* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
- * Copyright 1995-2000 The LyX Team.
+ * Copyright 1995-2001 The LyX Team.
*
* ====================================================== */
EM,
/// Math unit (18mu = 1em) for positioning in math mode
MU,
+ /// Percent of columnwidth both "%" or "%c"
+ PW,
+ PE,
+ /// Percent of pagewidth
+ PP,
+ /// Percent of linewidth
+ PL,
/// no unit
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;
/** 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:
///
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);
+///
+extern const char * stringFromUnit(int unit);
/// LyXGlueLength class
class LyXGlueLength : public LyXLength {
public:
- //@Man: constructors
- //@{
///
LyXGlueLength(float v,
LyXLength::UNIT u,
4cm plus 10pt minus 10pt */
explicit
LyXGlueLength(string const & data);
- //@}
- //@Man: selectors
- //@{
///
- float plusValue() const { return plus_val; };
+ float plusValue() const { return plus_val; }
///
- LyXLength::UNIT plusUnit() const { return plus_uni; };
+ LyXLength::UNIT plusUnit() const { return plus_uni; }
///
- float minusValue() const { return minus_val; };
+ float minusValue() const { return minus_val; }
///
- LyXLength::UNIT minusUnit() const { return minus_uni; };
- //@}
-
- ///
- 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;
///
- LyXLength::UNIT plus_uni, minus_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 };
- /// constructors
+ /// The different kinds of spaces.
+ enum vspace_kind {
+ ///
+ NONE,
+ ///
+ DEFSKIP,
+ ///
+ SMALLSKIP,
+ ///
+ MEDSKIP,
+ ///
+ BIGSKIP,
+ ///
+ VFILL,
+ ///
+ LENGTH
+ };
+ /// Constructor
VSpace() :
kin (NONE),
len(0.0, LyXLength::PT),
kp (false) {}
- ///
+ /// Constructor
explicit
- VSpace(vspace_kind k) :
+ VSpace(vspace_kind k) :
kin (k),
len (0.0, LyXLength::PT),
kp (false) {}
- ///
+ /// Constructor
explicit
VSpace(LyXGlueLength l) :
kin (LENGTH),
len (l),
kp (false) {}
+ /// Constructor
+ explicit
VSpace(float v, LyXLength::UNIT u) :
kin (LENGTH),
len (v, u),
kp (false) {}
- /// this constructor is for reading from a .lyx file
+ /// Constructor for reading from a .lyx file
explicit
VSpace(string const & data);
- // access functions
- vspace_kind kind() const { return kin; }
+ /// access functions
+ vspace_kind kind() const { return kin; }
///
- LyXLength length() const { return len; }
+ LyXGlueLength length() const { return len; }
// a flag that switches between \vspace and \vspace*
bool keep() const { return kp; }
///
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;
+ int inPixels(int default_height, int default_skip, int default_width=0) const;
private:
+ /// This VSpace kind
+ vspace_kind kin;
///
- vspace_kind kin;
- ///
- LyXGlueLength len;
+ LyXGlueLength len;
///
bool kp;
};
projects / lyx.git / blobdiff