lastfiles.h \
layout.C \
layout.h \
+ lengthcommon.C \
+ lengthcommon.h \
lyx_cb.C \
lyx_cb.h \
lyx_gui.C \
lyxfind.h \
lyxfunc.C \
lyxfunc.h \
+ lyxgluelength.C \
+ lyxgluelength.h \
+ lyxlength.C \
+ lexlength.h \
lyxlex.C \
lyxlex.h \
lyxlex_pimpl.C \
// The standard layout should always be numer 0;
current_view->text->setLayout(current_view, 0);
- current_view->text->
- setParagraph(current_view, 0, 0,
- 0, 0,
- VSpace (0.3 * buffer->params.spacing.getValue(),
- LyXLength::CM),
- VSpace (0.3 *
- buffer->params.spacing.getValue(),
- LyXLength::CM),
- Spacing(),
- LYX_ALIGN_CENTER, string(), 0);
+ LyXLength len(0.3 * buffer->params.spacing.getValue(), LyXLength::CM);
+ current_view->text->setParagraph(current_view, 0, 0, 0, 0,
+ VSpace(len), VSpace(len), Spacing(),
+ LYX_ALIGN_CENTER, string(), 0);
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
--- /dev/null
+#include <config.h>
+
+#include "lengthcommon.h"
+
+int const num_units = LyXLength::UNIT_NONE;
+
+// I am not sure if "mu" should be possible to select (Lgb)
+char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
+ "mm", "pc", "cc", "cm",
+ "in", "ex", "em", "mu",
+ "%", "c%", "p%", "l%" };
+
+
+LyXLength::UNIT unitFromString(string const & data)
+{
+ int i = 0;
+ while (i < num_units && data != unit_name[i])
+ ++i;
+ return static_cast<LyXLength::UNIT>(i);
+}
--- /dev/null
+// -*- C++ -*-
+
+#ifndef LENGHT_COMMON_H
+#define LENGHT_COMMON_H
+
+#include "LString.h"
+#include "lyxlength.h"
+
+extern int const num_units;
+
+// I am not sure if "mu" should be possible to select (Lgb)
+extern char const *unit_name[];
+
+LyXLength::UNIT unitFromString(string const & data);
+
+#endif
--- /dev/null
+/* This file is part of
+ * ======================================================
+ *
+ * LyX, The Document Processor
+ *
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2001 The LyX Team.
+ *
+ * ====================================================== */
+
+#include <config.h>
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "lyxgluelength.h"
+
+#include "Lsstream.h"
+
+namespace {
+// this is now here and in lyxlenght.h
+
+int const num_units = LyXLength::UNIT_NONE;
+
+// I am not sure if "mu" should be possible to select (Lgb)
+char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
+ "mm", "pc", "cc", "cm",
+ "in", "ex", "em", "mu",
+ "%", "c%", "p%", "l%" };
+
+}
+
+
+LyXGlueLength::LyXGlueLength(LyXLength const & len)
+ : len_(len)
+{}
+
+
+LyXGlueLength::LyXGlueLength(LyXLength const & len, LyXLength const & plus,
+ LyXLength const & minus)
+ : len_(len), plus_(plus), minus_(minus)
+{}
+
+
+LyXGlueLength::LyXGlueLength(string const & data)
+{
+ isValidGlueLength(data, this);
+}
+
+
+string const LyXGlueLength::asString() const
+{
+ ostringstream buffer;
+
+ if (plus_.value() != 0.0)
+ if (minus_.value() != 0.0)
+ if (len_.unit() == plus_.unit() && len_.unit() == minus_.unit())
+ if (plus_.value() == minus_.value())
+ buffer << len_.value() << "+-"
+ << plus_.value() << unit_name[len_.unit()];
+ else
+ buffer << len_.value()
+ << '+' << plus_.value()
+ << '-' << minus_.value()
+ << unit_name[len_.unit()];
+ else
+ if (plus_.unit() == minus_.unit()
+ && plus_.value() == minus_.value())
+ buffer << len_.value() << unit_name[len_.unit()]
+ << "+-" << plus_.value()
+ << unit_name[plus_.unit()];
+
+ else
+ buffer << len_.value() << unit_name[len_.unit()]
+ << '+' << plus_.value()
+ << unit_name[plus_.unit()]
+ << '-' << minus_.value()
+ << unit_name[minus_.unit()];
+ else
+ if (len_.unit() == plus_.unit())
+ buffer << len_.value() << '+' << plus_.value()
+ << unit_name[len_.unit()];
+ else
+ buffer << len_.value() << unit_name[len_.unit()]
+ << '+' << plus_.value()
+ << unit_name[plus_.unit()];
+
+ else
+ if (minus_.value() != 0.0)
+ if (len_.unit() == minus_.unit())
+ buffer << len_.value() << '-' << minus_.value()
+ << unit_name[len_.unit()];
+
+ else
+ buffer << len_.value() << unit_name[len_.unit()]
+ << '-' << minus_.value()
+ << unit_name[minus_.unit()];
+ else
+ buffer << len_.value() << unit_name[len_.unit()];
+
+ return buffer.str().c_str();
+}
+
+
+string const LyXGlueLength::asLatexString() const
+{
+ ostringstream buffer;
+
+ if (plus_.value() != 0.0)
+ if (minus_.value() != 0.0)
+ buffer << len_.value() << unit_name[len_.unit()]
+ << " plus "
+ << plus_.value() << unit_name[plus_.unit()]
+ << " minus "
+ << minus_.value() << unit_name[minus_.unit()];
+ else
+ buffer << len_.value() << unit_name[len_.unit()]
+ << " plus "
+ << plus_.value() << unit_name[plus_.unit()];
+ else
+ if (minus_.value() != 0.0)
+ buffer << len_.value() << unit_name[len_.unit()]
+ << " minus "
+ << minus_.value() << unit_name[minus_.unit()];
+ else
+ buffer << len_.value() << unit_name[len_.unit()];
+
+ return buffer.str().c_str();
+}
+
+
+LyXLength const & LyXGlueLength::len() const
+{
+ return len_;
+}
+
+
+LyXLength const & LyXGlueLength::plus() const
+{
+ return plus_;
+}
+
+
+LyXLength const & LyXGlueLength::minus() const
+{
+ return minus_;
+}
+
+
+bool operator==(LyXGlueLength const & l1, LyXGlueLength const & l2)
+{
+ return l1.len() == l2.len()
+ && l1.plus() == l2.plus()
+ && l1.minus() == l2.minus();
+}
+
+
+bool operator!=(LyXGlueLength const & l1, LyXGlueLength const & l2)
+{
+ return !(l1 == l2);
+}
--- /dev/null
+// -*- C++ -*-
+/* This file is part of
+ * ======================================================
+ *
+ * LyX, The Document Processor
+ *
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2001 The LyX Team.
+ *
+ * ====================================================== */
+
+#ifndef LYX_GLUE_LENGTH_H
+#define LYX_GLUE_LENGTH_H
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "lyxlength.h"
+
+#include "LString.h"
+
+class BufferParams;
+class BufferView;
+
+
+class LyXGlueLength {
+public:
+ ///
+ LyXGlueLength() {}
+ ///
+ explicit LyXGlueLength(LyXLength const & len);
+ ///
+ LyXGlueLength(LyXLength const & len,
+ LyXLength const & plus,
+ LyXLength const & minus);
+
+ /** "data" must be a decimal number, followed by a unit, and
+ optional "glue" indicated by "+" and "-". You may abbreviate
+ reasonably. Examples:
+ 1.2 cm // 4mm +2pt // 2cm -4mm +2mm // 4+0.1-0.2cm
+ The traditional Latex format is also accepted, like
+ 4cm plus 10pt minus 10pt */
+ explicit LyXGlueLength(string const & data);
+
+ ///
+ LyXLength const & len() const;
+ ///
+ LyXLength const & plus() const;
+ ///
+ LyXLength const & minus() const;
+
+
+ /// conversion
+ string const asString() const;
+ ///
+ 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);
+
+private:
+ /// the normal vlaue
+ LyXLength len_;
+ /// extra stretch
+ LyXLength plus_;
+ /// extra shrink
+ LyXLength minus_;
+};
+
+///
+bool operator==(LyXGlueLength const & l1, LyXGlueLength const & l2);
+///
+bool operator!=(LyXGlueLength const & l1, LyXGlueLength const & l2);
+///
+bool isValidGlueLength(string const & data, LyXGlueLength * result);
+
+#endif
--- /dev/null
+/* This file is part of
+ * ======================================================
+ *
+ * LyX, The Document Processor
+ *
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2001 The LyX Team.
+ *
+ * ====================================================== */
+
+#include <config.h>
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "lyxlength.h"
+
+#include "Lsstream.h"
+
+namespace {
+// this is now here and in lyxgluelength.C
+
+int const num_units = LyXLength::UNIT_NONE;
+
+// I am not sure if "mu" should be possible to select (Lgb)
+char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
+ "mm", "pc", "cc", "cm",
+ "in", "ex", "em", "mu",
+ "%", "c%", "p%", "l%" };
+
+
+LyXLength::UNIT unitFromString(string const & data)
+{
+ int i = 0;
+ while (i < num_units && data != unit_name[i])
+ ++i;
+ return static_cast<LyXLength::UNIT>(i);
+}
+
+}
+
+
+LyXLength::LyXLength()
+ : val_(0), unit_(LyXLength::PT)
+{}
+
+
+LyXLength::LyXLength(double v, LyXLength::UNIT u)
+ : val_(v), unit_(u)
+{}
+
+
+LyXLength::LyXLength(string const & data)
+{
+ LyXLength tmp;
+
+ if (!isValidLength (data, &tmp))
+ return; // should raise an exception
+
+ val_ = tmp.val_;
+ unit_ = tmp.unit_;
+}
+
+
+string const LyXLength::asString() const
+{
+ ostringstream buffer;
+ buffer << val_ << unit_name[unit_]; // setw?
+ return buffer.str().c_str();
+}
+
+
+string const LyXLength::asLatexString() const
+{
+ ostringstream buffer;
+ switch(unit_) {
+ case PW:
+ case PE:
+ buffer << abs(static_cast<int>(val_/100)) << "."
+ << abs(static_cast<int>(val_)%100) << "\\columnwidth";
+ break;
+ case PP:
+ buffer << abs(static_cast<int>(val_/100)) << "."
+ << abs(static_cast<int>(val_)%100) << "\\pagewidth";
+ break;
+ case PL:
+ buffer << abs(static_cast<int>(val_/100)) << "."
+ << abs(static_cast<int>(val_)%100) << "\\linewidth";
+ break;
+ default:
+ buffer << val_ << unit_name[unit_]; // setw?
+ break;
+ }
+ return buffer.str().c_str();
+}
+
+
+double LyXLength::value() const
+{
+ return val_;
+}
+
+
+LyXLength::UNIT LyXLength::unit() const
+{
+ return unit_;
+}
+
+
+void LyXLength::value(double v)
+{
+ val_ = v;
+}
+
+
+void LyXLength::unit(LyXLength::UNIT u)
+{
+ unit_ = u;
+}
+
+
+bool operator==(LyXLength const & l1, LyXLength const & l2)
+{
+ return l1.value() == l2.value() && l1.unit() == l2.unit();
+}
--- /dev/null
+// -*- C++ -*-
+/* This file is part of
+ * ======================================================
+ *
+ * LyX, The Document Processor
+ *
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2001 The LyX Team.
+ *
+ * ====================================================== */
+
+#ifndef LYX_LENGTH_H
+#define LYX_LENGTH_H
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+#include "LString.h"
+
+//
+/// LyXLength Class
+//
+class LyXLength {
+public:
+ /// length units
+ enum UNIT {
+ /// Scaled point (65536sp = 1pt) TeX's smallest unit.
+ SP,
+ /// Point = 1/72.27in = 0.351mm
+ PT,
+ /// Big point (72bp = 1in), also PostScript point
+ BP,
+ /// Didot point = 1/72 of a French inch, = 0.376mm
+ DD,
+ /// Millimeter = 2.845pt
+ MM,
+ /// Pica = 12pt = 4.218mm
+ PC,
+ /// Cicero = 12dd = 4.531mm
+ CC,
+ /// Centimeter = 10mm = 2.371pc
+ CM,
+ /// Inch = 25.4mm = 72.27pt = 6.022pc
+ IN,
+ /// Height of a small "x" for the current font.
+ EX,
+ /// Width of capital "M" in current font.
+ 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
+ };
+
+ ///
+ LyXLength();
+ ///
+ LyXLength(double v, LyXLength::UNIT u);
+
+ /// "data" must be a decimal number, followed by a unit
+ explicit LyXLength(string const & data);
+
+ ///
+ double value() const;
+ ///
+ LyXLength::UNIT unit() const;
+ ///
+ void value(double);
+ ///
+ void unit(LyXLength::UNIT unit);
+
+ /// real length in SP
+ //void lenght();
+
+ /// conversion
+ string const asString() const;
+ ///
+ 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);
+
+private:
+ ///
+ double val_;
+ ///
+ LyXLength::UNIT unit_;
+};
+
+///
+bool operator==(LyXLength const & l1, LyXLength const & l2);
+///
+bool isValidLength(string const & data, LyXLength * result);
+///
+char const * stringFromUnit(int unit);
+
+#endif
#include <config.h>
#ifdef __GNUG__
-#pragma implementation "vspace.h"
+#pragma implementation
#endif
#include "vspace.h"
+#include "lengthcommon.h"
#include "lyx_main.h"
#include "buffer.h"
#include "lyxrc.h"
namespace {
+#if 0
/* length units
*/
int number_index;
int unit_index;
+LyXLength::UNIT unitFromString(string const & data)
+{
+ int i = 0;
+ while (i < num_units && data != unit_name[i])
+ ++i;
+ return static_cast<LyXLength::UNIT>(i);
+}
+
+#endif
+double number[4] = { 0, 0, 0, 0 };
+LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE,
+ LyXLength::UNIT_NONE,
+ LyXLength::UNIT_NONE,
+ LyXLength::UNIT_NONE };
+
+int number_index;
+int unit_index;
inline
void lyx_advance(string & data, string::size_type n)
{ "", 0, 0, 0, 0 } // sentinel, must be empty
};
+
} // namespace anon
const char * stringFromUnit(int unit)
// is zero, the corresponding array value is zero or UNIT_NONE,
// so we needn't check this.
if (result) {
- result->val_ = number[1] * val_sign;
- result->unit_ = unit[1];
- result->plus_val_ = number[table[table_index].plus_val_index];
- result->minus_val_ = number[table[table_index].minus_val_index];
- result->plus_unit_ = unit [table[table_index].plus_uni_index];
- result->minus_unit_ = unit [table[table_index].minus_uni_index];
+ result->len_.value (number[1] * val_sign);
+ result->len_.unit (unit[1]);
+ result->plus_.value (number[table[table_index].plus_val_index]);
+ result->plus_.unit (unit [table[table_index].plus_uni_index]);
+ result->minus_.value(number[table[table_index].minus_val_index]);
+ result->minus_.unit (unit [table[table_index].minus_uni_index]);
}
return true;
}
}
-
-
-//
-// LyXLength
-//
-
-LyXLength::LyXLength()
- : val_(0), unit_(LyXLength::PT)
-{}
-
-
-LyXLength::LyXLength(double v, LyXLength::UNIT u)
- : val_(v), unit_(u)
-{}
-
-
-LyXLength::LyXLength(string const & data)
-{
- LyXLength tmp;
-
- if (!isValidLength (data, &tmp))
- return; // should raise an exception
-
- val_ = tmp.val_;
- unit_ = tmp.unit_;
-}
-
-
-string const LyXLength::asString() const
-{
- ostringstream buffer;
- buffer << val_ << unit_name[unit_]; // setw?
- return buffer.str().c_str();
-}
-
-
-string const LyXLength::asLatexString() const
-{
- ostringstream buffer;
- switch(unit_) {
- case PW:
- case PE:
- buffer << abs(static_cast<int>(val_/100)) << "."
- << abs(static_cast<int>(val_)%100) << "\\columnwidth";
- break;
- case PP:
- buffer << abs(static_cast<int>(val_/100)) << "."
- << abs(static_cast<int>(val_)%100) << "\\pagewidth";
- break;
- case PL:
- buffer << abs(static_cast<int>(val_/100)) << "."
- << abs(static_cast<int>(val_)%100) << "\\linewidth";
- break;
- default:
- buffer << val_ << unit_name[unit_]; // setw?
- break;
- }
- return buffer.str().c_str();
-}
-
-
-double LyXLength::value() const
-{
- return val_;
-}
-
-
-LyXLength::UNIT LyXLength::unit() const
-{
- return unit_;
-}
-
-
-bool operator==(LyXLength const & l1, LyXLength const & l2)
-{
- return l1.value() == l2.value() && l1.unit() == l2.unit();
-}
-
-
-LyXLength::UNIT unitFromString (string const & data)
-{
- int i = 0;
- while (i < num_units && data != unit_name[i])
- ++i;
- return static_cast<LyXLength::UNIT>(i);
-}
-
-
-
-//
-// LyXGlueLength
-//
-
-
-LyXGlueLength::LyXGlueLength(
- double v, LyXLength::UNIT u,
- double pv, LyXLength::UNIT pu,
- double mv, LyXLength::UNIT mu)
- : LyXLength(v, u),
- plus_val_(pv), minus_val_(mv),
- plus_unit_(pu), minus_unit_(mu)
-{}
-
-
-LyXGlueLength::LyXGlueLength(string const & data)
-{
- LyXGlueLength tmp(0.0, PT);
-
- // we should really raise exception here
- if (!isValidGlueLength(data, &tmp))
- ;
-
- val_ = tmp.val_;
- unit_ = tmp.unit_;
- plus_val_ = tmp.plus_val_;
- plus_unit_ = tmp.plus_unit_;
- minus_val_ = tmp.minus_val_;
- minus_unit_ = tmp.minus_unit_;
-}
-
-
-string const LyXGlueLength::asString() const
-{
- ostringstream buffer;
-
- if (plus_val_ != 0.0)
- if (minus_val_ != 0.0)
- if (unit_ == plus_unit_ && unit_ == minus_unit_)
- if (plus_val_ == minus_val_)
- buffer << val_ << "+-"
- << plus_val_ << unit_name[unit_];
- else
- buffer << val_
- << '+' << plus_val_
- << '-' << minus_val_
- << unit_name[unit_];
- else
- if (plus_unit_ == minus_unit_
- && plus_val_ == minus_val_)
- buffer << val_ << unit_name[unit_]
- << "+-" << plus_val_
- << unit_name[plus_unit_];
-
- else
- buffer << val_ << unit_name[unit_]
- << '+' << plus_val_
- << unit_name[plus_unit_]
- << '-' << minus_val_
- << unit_name[minus_unit_];
- else
- if (unit_ == plus_unit_)
- buffer << val_ << '+' << plus_val_
- << unit_name[unit_];
- else
- buffer << val_ << unit_name[unit_]
- << '+' << plus_val_
- << unit_name[plus_unit_];
-
- else
- if (minus_val_ != 0.0)
- if (unit_ == minus_unit_)
- buffer << val_ << '-' << minus_val_
- << unit_name[unit_];
-
- else
- buffer << val_ << unit_name[unit_]
- << '-' << minus_val_
- << unit_name[minus_unit_];
- else
- buffer << val_ << unit_name[unit_];
-
- return buffer.str().c_str();
-}
-
-
-string const LyXGlueLength::asLatexString() const
-{
- ostringstream buffer;
-
- if (plus_val_ != 0.0)
- if (minus_val_ != 0.0)
- buffer << val_ << unit_name[unit_]
- << " plus "
- << plus_val_ << unit_name[plus_unit_]
- << " minus "
- << minus_val_ << unit_name[minus_unit_];
- else
- buffer << val_ << unit_name[unit_]
- << " plus "
- << plus_val_ << unit_name[plus_unit_];
- else
- if (minus_val_ != 0.0)
- buffer << val_ << unit_name[unit_]
- << " minus "
- << minus_val_ << unit_name[minus_unit_];
- else
- buffer << val_ << unit_name[unit_];
-
- return buffer.str().c_str();
-}
-
-
-double LyXGlueLength::plusValue() const
-{
- return plus_val_;
-}
-
-
-LyXLength::UNIT LyXGlueLength::plusUnit() const
-{
- return plus_unit_;
-}
-
-
-double LyXGlueLength::minusValue() const
-{
- return minus_val_;
-}
-
-
-LyXLength::UNIT LyXGlueLength::minusUnit() const
-{
- return minus_unit_;
-}
-
-
-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();
-}
-
-
-bool operator!=(LyXGlueLength const & l1, LyXGlueLength const & l2)
-{
- return !(l1 == l2);
-}
-
-
-
//
// VSpace class
//
VSpace::VSpace()
- : kind_(NONE), len_(0.0, LyXLength::PT), keep_(false)
+ : kind_(NONE), len_(), keep_(false)
{}
VSpace::VSpace(vspace_kind k)
- : kind_(k), len_(0.0, LyXLength::PT), keep_(false)
+ : kind_(k), len_(), keep_(false)
{}
-VSpace::VSpace(LyXGlueLength l)
+VSpace::VSpace(LyXLength const & l)
: kind_(LENGTH), len_(l), keep_(false)
{}
-VSpace::VSpace(double v, LyXLength::UNIT u)
- : kind_(LENGTH), len_(v, u), keep_(false)
+VSpace::VSpace(LyXGlueLength const & l)
+ : kind_(LENGTH), len_(l), keep_(false)
{}
VSpace::VSpace(string const & data)
- : kind_(NONE), len_(0.0, LyXLength::PT), keep_(false)
+ : kind_(NONE), len_(), keep_(false)
{
if (data.empty())
return;
// without units in added_space_top/bottom.
// Let unit default to centimeters here.
kind_ = LENGTH;
- len_ = LyXGlueLength(value, LyXLength::CM);
+ len_ = LyXGlueLength(LyXLength(value, LyXLength::CM));
}
}
int VSpace::inPixels(BufferView * bv) const
{
// Height of a normal line in pixels (zoom factor considered)
- int height = bv->text->defaultHeight(); // [pixels]
- int skip = 0;
- int width = bv->workWidth();
+ int default_height = bv->text->defaultHeight(); // [pixels]
+ int default_skip = 0;
+ int default_width = bv->workWidth();
if (kind_ == DEFSKIP)
- skip = bv->buffer()->params.getDefSkip().inPixels(bv);
+ default_skip = bv->buffer()->params.getDefSkip().inPixels(bv);
- return inPixels(height, skip, width);
-}
-
-
-int VSpace::inPixels(int default_height, int default_skip, int default_width)
- const
-{
// Height of a normal line in pixels (zoom factor considered)
int height = default_height; // [pixels]
// we don't care about sign of value, we
// display negative space with text too
result = 0.0;
- value = len_.value();
+ value = len_.len().value();
int val_sign = value < 0.0 ? -1 : 1;
- switch (len_.unit()) {
+ switch (len_.len().unit()) {
case LyXLength::SP:
// Scaled point: sp = 1/65536 pt
result = zoom * dpi * value
#pragma interface
#endif
+#include "lyxgluelength.h"
+
#include "LString.h"
class BufferParams;
class BufferView;
-//
-/// LyXLength Class
-//
-class LyXLength {
-public:
- /// length units
- enum UNIT {
- /// Scaled point (65536sp = 1pt) TeX's smallest unit.
- SP,
- /// Point = 1/72.27in = 0.351mm
- PT,
- /// Big point (72bp = 1in), also PostScript point
- BP,
- /// Didot point = 1/72 of a French inch, = 0.376mm
- DD,
- /// Millimeter = 2.845pt
- MM,
- /// Pica = 12pt = 4.218mm
- PC,
- /// Cicero = 12dd = 4.531mm
- CC,
- /// Centimeter = 10mm = 2.371pc
- CM,
- /// Inch = 25.4mm = 72.27pt = 6.022pc
- IN,
- /// Height of a small "x" for the current font.
- EX,
- /// Width of capital "M" in current font.
- 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
- };
-
- ///
- LyXLength();
- ///
- LyXLength(double v, LyXLength::UNIT u);
-
- /// "data" must be a decimal number, followed by a unit
- explicit LyXLength(string const & data);
-
- ///
- double value() const;
- ///
- LyXLength::UNIT unit() const;
-
- /// conversion
- virtual string const asString() 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 isValidLength(string const & data, LyXLength * result = 0);
-
-protected:
- ///
- double val_;
- ///
- LyXLength::UNIT unit_;
-};
-
-///
-bool operator==(LyXLength const & l1, LyXLength const & l2);
-///
-LyXLength::UNIT unitFromString (string const & data);
-///
-bool isValidLength(string const & data, LyXLength * result);
-///
-const char * stringFromUnit(int unit);
-
-
-
-//
-/// LyXGlueLength class
-//
-class LyXGlueLength : public LyXLength {
-public:
- ///
- LyXGlueLength(double v,
- LyXLength::UNIT u,
- double pv = 0.0,
- LyXLength::UNIT pu = LyXLength::UNIT_NONE,
- double mv = 0.0,
- LyXLength::UNIT mu = LyXLength::UNIT_NONE);
-
- /** "data" must be a decimal number, followed by a unit, and
- optional "glue" indicated by "+" and "-". You may abbreviate
- reasonably. Examples:
- 1.2 cm // 4mm +2pt // 2cm -4mm +2mm // 4+0.1-0.2cm
- The traditional Latex format is also accepted, like
- 4cm plus 10pt minus 10pt */
- explicit LyXGlueLength(string const & data);
-
- ///
- double plusValue() const;
- ///
- LyXLength::UNIT plusUnit() const;
- ///
- double minusValue() const;
- ///
- LyXLength::UNIT minusUnit() const;
-
- /// conversion
- virtual string const asString() 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);
-
-protected:
- ///
- double plus_val_;
- ///
- double minus_val_;
- ///
- LyXLength::UNIT plus_unit_;
- ///
- LyXLength::UNIT minus_unit_;
-};
-
-///
-bool operator==(LyXGlueLength const & l1, LyXGlueLength const & l2);
-///
-bool operator!=(LyXGlueLength const & l1, LyXGlueLength const & l2);
///
-bool isValidGlueLength(string const & data, LyXGlueLength * result);
-
-
-//
-/// VSpace class
-//
class VSpace {
public:
/// The different kinds of spaces.
/// Constructor
explicit VSpace(vspace_kind k);
/// Constructor
- explicit VSpace(LyXGlueLength l);
+ explicit VSpace(LyXLength const & l);
/// Constructor
- explicit VSpace(double v, LyXLength::UNIT u);
+ explicit VSpace(LyXGlueLength const & l);
/// Constructor for reading from a .lyx file
explicit VSpace(string const & data);
/// access functions
vspace_kind kind() const;
///
- LyXGlueLength length() const;
+ LyXGlueLength length() const;
// a flag that switches between \vspace and \vspace*
bool keep() const;
string const asLatexCommand(BufferParams const & params) const;
///
int inPixels(BufferView * bv) const;
- ///
- int inPixels(int default_height, int default_skip, int default_width=0) const;
private:
/// This VSpace kind
vspace_kind kind_;
projects / features.git / commitdiff