update all .po files ot latestes pot

[lyx.git] / src / vspace.h

diff --git a/src/vspace.h b/src/vspace.h
index c4cde2fbcecac9623a9657a4416340ad6efd4b9d..11fe28079d14a3f7030448053c3c8a36727d2114 100644 (file)
--- a/src/vspace.h
+++ b/src/vspace.h
@@ -54,38 +54,31 @@ public:
                UNIT_NONE
        };
 
-       //@Man: constructors
-       //@{
        ///
        LyXLength() : val(0), uni(LyXLength::PT) {}
+       ///
        LyXLength(float v, LyXLength::UNIT u) : val(v), uni(u) {}
 
        /** "data" must be a decimal number, followed by a unit. */
        explicit
         LyXLength(string const & data);
-       //@}
        
-       //@Man: selectors
-       //@{
-       ///
-       float value() const         { return val; };
        ///
-       LyXLength::UNIT unit() const { return uni; };
-       //@}
-
+       float value() const         { return val; }
        ///
-        bool operator== (LyXLength const &) const;
+       LyXLength::UNIT unit() const { return uni; }
 
        /// conversion
-       virtual string asString() const;
+       virtual string const asString() const;
        ///
-       virtual string asLatexString() const { return this->asString(); };
-
+       virtual string const asLatexString() const {
+               return this->asString();
+       }
 
        /** If "data" is valid, the length represented by it is
          stored into "result", if that is not 0. */
        friend bool isValidLength(string const & data, 
-                                 LyXLength * result= 0);
+                                 LyXLength * result = 0);
 
 protected:
        ///
@@ -94,14 +87,22 @@ protected:
        LyXLength::UNIT uni;
 };
 
+///
+inline
+bool operator==(LyXLength const & l1, LyXLength const & l2)
+{
+       return l1.value() == l2.value()
+               && l1.unit() == l2.unit();
+}
+       
+///
 extern LyXLength::UNIT unitFromString (string const & data);
+///
 extern bool isValidLength(string const & data, LyXLength * result);
 
 /// LyXGlueLength class
 class LyXGlueLength : public LyXLength {
 public:
-       //@Man: constructors
-       //@{
        ///
        LyXGlueLength(float v,
                      LyXLength::UNIT u, 
@@ -121,50 +122,74 @@ public:
          4cm plus 10pt minus 10pt */
        explicit
         LyXGlueLength(string const & data);
-       //@}
        
-       //@Man: selectors
-       //@{
-       ///
-       float plusValue() const         { return plus_val; };
        ///
-       LyXLength::UNIT plusUnit() const { return plus_uni; };
+       float plusValue() const         { return plus_val; }
        ///
-       float minusValue() const         { return minus_val; };
+       LyXLength::UNIT plusUnit() const { return plus_uni; }
        ///
-       LyXLength::UNIT minusUnit() const { return minus_uni; };
-       //@}
-
+       float minusValue() const         { return minus_val; }
        ///
-        bool operator == (LyXGlueLength const &) const;
+       LyXLength::UNIT minusUnit() const { return minus_uni; }
 
        /// conversion
-       virtual string asString() const;
+       virtual string const asString() const;
        ///
-       virtual string asLatexString() const;
+       virtual string const asLatexString() const;
 
 
        /** If "data" is valid, the length represented by it is
          stored into "result", if that is not 0. */
        friend bool isValidGlueLength(string const & data, 
-                                     LyXGlueLength* result= 0);
+                                     LyXGlueLength* result = 0);
 
 protected:
        ///
-       float           plus_val, minus_val;
+       float plus_val;
+       ///
+       float minus_val;
        ///
-       LyXLength::UNIT plus_uni, minus_uni;
+       LyXLength::UNIT plus_uni;
+       ///
+       LyXLength::UNIT minus_uni;
 };
 
+///
+inline
+bool operator==(LyXGlueLength const & l1, LyXGlueLength const & l2)
+{
+       return l1.value() == l2.value()
+               && l1.unit() == l2.unit()
+               && l1.plusValue() == l2.plusValue()
+               && l1.plusUnit() == l2.plusUnit()
+               && l1.minusValue() == l2.minusValue()
+               && l1.minusUnit() == l2.minusUnit();
+}
+
+
+///
 extern bool isValidGlueLength(string const & data, LyXGlueLength * result);
 
 ///  VSpace class
 class VSpace {
 public:
        ///
-       enum vspace_kind { NONE, DEFSKIP, 
-                          SMALLSKIP, MEDSKIP, BIGSKIP, 
-                          VFILL, LENGTH };
+       enum vspace_kind {
+               ///
+               NONE,
+               ///
+               DEFSKIP,
+               ///
+               SMALLSKIP,
+               ///
+               MEDSKIP,
+               ///
+               BIGSKIP,
+               ///
+               VFILL,
+               ///
+               LENGTH
+       };
        /// constructors
        VSpace() : 
                kin (NONE), 
@@ -183,6 +208,8 @@ public:
                len (l),
                kp (false) {}
 
+       ///
+       explicit
        VSpace(float v, LyXLength::UNIT u) : 
                kin (LENGTH), 
                len (v, u),
@@ -202,20 +229,22 @@ public:
        ///
        void setKeep(bool val) { kp = val; } 
        ///
-        bool operator == (VSpace const &) const;
+        bool operator==(VSpace const &) const;
 
        // conversion
        ///
-       string asLyXCommand() const;  // how it goes into the LyX file
+       string const asLyXCommand() const;  // how it goes into the LyX file
        ///
-       string asLatexCommand(BufferParams const & params) const;
+       string const asLatexCommand(BufferParams const & params) const;
        ///
        int inPixels(BufferView * bv) const;
+       ///
+       int inPixels(int default_height, int default_skip) const;
 private:
        ///
-       vspace_kind  kin;
+       vspace_kind kin;
        ///
-       LyXGlueLength    len;
+       LyXGlueLength len;
        ///
        bool kp;
 };