X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fvspace.C;h=c1fdbf71ad93d5747f5dc0a219b58b96658fdd18;hb=16b2e76d1a7f8f5037d3d2e9fb78baeb4f67b0c6;hp=69fb9006b72fd8be7889ad42ce334841db13c3ef;hpb=2028cf65896b32368142b14da279ec774c97a711;p=lyx.git diff --git a/src/vspace.C b/src/vspace.C index 69fb9006b7..c1fdbf71ad 100644 --- a/src/vspace.C +++ b/src/vspace.C @@ -1,56 +1,54 @@ -/* This file is part of - * ====================================================== +/** + * \file vspace.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor - * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. + * \author Matthias Ettrich * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation "vspace.h" -#endif - -#include - -#include "lyx_main.h" -#include "buffer.h" #include "vspace.h" -#include "lyxrc.h" -#include "lyxtext.h" +#include "buffer.h" +#include "bufferparams.h" #include "BufferView.h" +#include "gettext.h" +#include "lengthcommon.h" +#include "lyxtext.h" + +#include "support/convert.h" #include "support/lstrings.h" -namespace { +namespace lyx { -/* length units - */ +using support::compare; +using support::isStrDbl; +using support::ltrim; +using support::prefixIs; +using support::rtrim; -int const num_units = LyXLength::UNIT_NONE; +using std::string; -// 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%" }; +namespace { -/* The following static items form a simple scanner for - * length strings, used by isValid[Glue]Length. See comments there. - */ -double number[4] = { 0, 0, 0, 0 }; -LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE }; +/// used to return numeric values in parsing vspace +double number[4] = { 0, 0, 0, 0 }; +/// used to return unit types in parsing vspace +LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE, + LyXLength::UNIT_NONE, + LyXLength::UNIT_NONE, + LyXLength::UNIT_NONE }; + +/// the current position in the number array int number_index; +/// the current position in the unit array int unit_index; - +/// skip n characters of input inline void lyx_advance(string & data, string::size_type n) { @@ -58,86 +56,115 @@ void lyx_advance(string & data, string::size_type n) } +/// return true when the input is at the end inline bool isEndOfData(string const & data) { - return frontStrip(data).empty(); + return ltrim(data).empty(); } +/** + * nextToken - return the next token in the input + * @param data input string + * @return a char representing the type of token returned + * + * The possible return values are : + * + stretch indicator for glue length + * - shrink indicator for glue length + * n a numeric value (stored in number array) + * u a unit type (stored in unit array) + * E parse error + */ char nextToken(string & data) { - data = frontStrip(data); + data = ltrim(data); + if (data.empty()) return '\0'; - else if (data[0] == '+') { + + if (data[0] == '+') { lyx_advance(data, 1); return '+'; - } else if (prefixIs(data, "plus")) { + } + + if (prefixIs(data, "plus")) { lyx_advance(data, 4); return '+'; - } else if (data[0] == '-') { + } + + if (data[0] == '-') { lyx_advance(data, 1); return '-'; - } else if (prefixIs(data, "minus")) { + } + + if (prefixIs(data, "minus")) { lyx_advance(data, 5); return '-'; - } else { - string::size_type i = data.find_first_not_of("0123456789."); + } - if (i != 0) { - if (number_index > 3) return 'E'; + string::size_type i = data.find_first_not_of("0123456789."); - string buffer; - - // we have found some number - if (i == string::npos) { - buffer = data; - i = data.size() + 1; - } else - buffer = data.substr(0, i); + if (i != 0) { + if (number_index > 3) + return 'E'; - lyx_advance(data, i); + string buffer; + + // we have found some number + if (i == string::npos) { + buffer = data; + i = data.size() + 1; + } else + buffer = data.substr(0, i); - if (isStrDbl(buffer)) { - number[number_index] = strToDbl(buffer); - ++number_index; - return 'n'; - } else return 'E'; + lyx_advance(data, i); + + if (isStrDbl(buffer)) { + number[number_index] = convert(buffer); + ++number_index; + return 'n'; } - - i = data.find_first_not_of("abcdefghijklmnopqrstuvwxyz%"); - if (i != 0) { - if (unit_index > 3) return 'E'; - - string buffer; - - // we have found some alphabetical string - if (i == string::npos) { - buffer = data; - i = data.size() + 1; - } else - buffer = data.substr(0, i); - - // possibly we have "mmplus" string or similar - if (buffer.size() > 5 && (buffer.substr(2,4) == string("plus") || buffer.substr(2,5) == string("minus"))) { - lyx_advance(data, 2); - unit[unit_index] = unitFromString(buffer.substr(0, 2)); - } else { - lyx_advance(data, i); - unit[unit_index] = unitFromString(buffer); - } - - if (unit[unit_index] != LyXLength::UNIT_NONE) { - ++unit_index; - return 'u'; - } else return 'E'; // Error + return 'E'; + } + + i = data.find_first_not_of("abcdefghijklmnopqrstuvwxyz%"); + if (i != 0) { + if (unit_index > 3) + return 'E'; + + string buffer; + + // we have found some alphabetical string + if (i == string::npos) { + buffer = data; + i = data.size() + 1; + } else + buffer = data.substr(0, i); + + // possibly we have "mmplus" string or similar + if (buffer.size() > 5 && + (buffer.substr(2, 4) == string("plus") || + buffer.substr(2, 5) == string("minus"))) + { + lyx_advance(data, 2); + unit[unit_index] = unitFromString(buffer.substr(0, 2)); + } else { + lyx_advance(data, i); + unit[unit_index] = unitFromString(buffer); + } + + if (unit[unit_index] != LyXLength::UNIT_NONE) { + ++unit_index; + return 'u'; } return 'E'; // Error } + return 'E'; // Error } +/// latex representation of a vspace struct LaTeXLength { char const * pattern; int plus_val_index; @@ -147,6 +174,7 @@ struct LaTeXLength { }; +/// the possible formats for a vspace string LaTeXLength table[] = { { "nu", 0, 0, 0, 0 }, { "nu+nu", 2, 0, 2, 0 }, @@ -164,11 +192,12 @@ LaTeXLength table[] = { { "", 0, 0, 0, 0 } // sentinel, must be empty }; + } // namespace anon const char * stringFromUnit(int unit) { - if (unit < 0 || unit >= num_units) + if (unit < 0 || unit > num_units) return 0; return unit_name[unit]; } @@ -194,7 +223,7 @@ bool isValidGlueLength(string const & data, LyXGlueLength * result) if (data.empty()) return true; - string buffer = frontStrip(data); + string buffer = ltrim(data); // To make isValidGlueLength recognize negative values as // the first number this little hack is needed: @@ -206,13 +235,12 @@ bool isValidGlueLength(string const & data, LyXGlueLength * result) break; case '+': lyx_advance(buffer, 1); - // fall through + break; default: - // no action break; } // end of hack - + int pattern_index = 0; int table_index = 0; char pattern[20]; @@ -236,17 +264,17 @@ bool isValidGlueLength(string const & data, LyXGlueLength * result) if (!*table[table_index].pattern) return false; } - + // Get the values from the appropriate places. If an index // 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; } @@ -254,10 +282,10 @@ bool isValidGlueLength(string const & data, LyXGlueLength * result) bool isValidLength(string const & data, LyXLength * result) { - /// This is a trimmed down version of isValidGlueLength. - /// The parser may seem overkill for lengths without - /// glue, but since we already have it, using it is - /// easier than writing something from scratch. + // This is a trimmed down version of isValidGlueLength. + // The parser may seem overkill for lengths without + // glue, but since we already have it, using it is + // easier than writing something from scratch. if (data.empty()) return true; @@ -281,14 +309,14 @@ bool isValidLength(string const & data, LyXLength * result) break; } // end of hack - + number_index = unit_index = 1; // entries at index 0 are sentinels // construct "pattern" from "data" - while (!isEndOfData (buffer)) { + while (!isEndOfData(buffer)) { if (pattern_index > 2) return false; - pattern[pattern_index] = nextToken (buffer); + pattern[pattern_index] = nextToken(buffer); if (pattern[pattern_index] == 'E') return false; ++pattern_index; @@ -296,8 +324,8 @@ bool isValidLength(string const & data, LyXLength * result) pattern[pattern_index] = '\0'; // only the most basic pattern is accepted here - if (compare(pattern, "nu") != 0) return false; - + if (compare(pattern, "nu") != 0) return false; + // It _was_ a correct length string. // Store away the values we found. if (result) { @@ -308,296 +336,63 @@ bool isValidLength(string const & data, LyXLength * result) } - - -// -// 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(val_/100)) << "." - << abs(static_cast(val_)%100) << "\\columnwidth"; - break; - case PP: - buffer << abs(static_cast(val_/100)) << "." - << abs(static_cast(val_)%100) << "\\pagewidth"; - break; - case PL: - buffer << abs(static_cast(val_/100)) << "." - << abs(static_cast(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(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(); -} - - - - // // VSpace class // VSpace::VSpace() - : kind_(NONE), len_(0.0, LyXLength::PT), keep_(false) + : kind_(DEFSKIP), 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_(DEFSKIP), len_(), keep_(false) { if (data.empty()) return; - double value; - string input = strip(data); + + string input = rtrim(data); string::size_type const length = input.length(); - if (length > 1 && input[length-1] == '*') { + if (length > 1 && input[length - 1] == '*') { keep_ = true; input.erase(length - 1); } - if (prefixIs (input, "defskip")) kind_ = DEFSKIP; - else if (prefixIs (input, "smallskip")) kind_ = SMALLSKIP; - else if (prefixIs (input, "medskip")) kind_ = MEDSKIP; - else if (prefixIs (input, "bigskip")) kind_ = BIGSKIP; - else if (prefixIs (input, "vfill")) kind_ = VFILL; - else if (isValidGlueLength(input, &len_)) kind_ = LENGTH; - else if (sscanf(input.c_str(), "%lf", &value) == 1) { + if (prefixIs(input, "defskip")) + kind_ = DEFSKIP; + else if (prefixIs(input, "smallskip")) + kind_ = SMALLSKIP; + else if (prefixIs(input, "medskip")) + kind_ = MEDSKIP; + else if (prefixIs(input, "bigskip")) + kind_ = BIGSKIP; + else if (prefixIs(input, "vfill")) + kind_ = VFILL; + else if (isValidGlueLength(input, &len_)) + kind_ = LENGTH; + else if (isStrDbl(input)) { // This last one is for reading old .lyx files // without units in added_space_top/bottom. // Let unit default to centimeters here. kind_ = LENGTH; - len_ = LyXGlueLength(value, LyXLength::CM); + len_ = LyXGlueLength(LyXLength(convert(input), LyXLength::CM)); } } @@ -608,7 +403,7 @@ VSpace::vspace_kind VSpace::kind() const } -LyXGlueLength VSpace::length() const +LyXGlueLength const & VSpace::length() const { return len_; } @@ -645,7 +440,6 @@ string const VSpace::asLyXCommand() const { string result; switch (kind_) { - case NONE: break; case DEFSKIP: result = "defskip"; break; case SMALLSKIP: result = "smallskip"; break; case MEDSKIP: result = "medskip"; break; @@ -653,7 +447,7 @@ string const VSpace::asLyXCommand() const case VFILL: result = "vfill"; break; case LENGTH: result = len_.asString(); break; } - if (keep_ && kind_ != NONE && kind_ != DEFSKIP) + if (keep_) result += '*'; return result; } @@ -662,148 +456,94 @@ string const VSpace::asLyXCommand() const string const VSpace::asLatexCommand(BufferParams const & params) const { switch (kind_) { - case NONE: return string(); case DEFSKIP: return params.getDefSkip().asLatexCommand(params); - case SMALLSKIP: return keep_ ? "\\vspace*{\\smallskipamount}" - : "\\smallskip{}"; - case MEDSKIP: return keep_ ? "\\vspace*{\\medskipamount}" - : "\\medskip{}"; - case BIGSKIP: return keep_ ? "\\vspace*{\\bigskipamount}" - : "\\bigskip{}"; - case VFILL: return keep_ ? "\\vspace*{\\fill}" - : "\\vfill{}"; - case LENGTH: return keep_ ? "\\vspace*{" + len_.asLatexString() + '}' - : "\\vspace{" + len_.asLatexString() + '}'; - } - return string(); // should never be reached -} + case SMALLSKIP: + return keep_ ? "\\vspace*{\\smallskipamount}" : "\\smallskip{}"; -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(); + case MEDSKIP: + return keep_ ? "\\vspace*{\\medskipamount}" : "\\medskip{}"; - if (kind_ == DEFSKIP) - skip = bv->buffer()->params.getDefSkip().inPixels(bv); + case BIGSKIP: + return keep_ ? "\\vspace*{\\bigskipamount}" : "\\bigskip{}"; - return inPixels(height, skip, width); + case VFILL: + return keep_ ? "\\vspace*{\\fill}" : "\\vfill{}"; + + case LENGTH: + return keep_ ? "\\vspace*{" + len_.asLatexString() + '}' + : "\\vspace{" + len_.asLatexString() + '}'; + + default: + BOOST_ASSERT(false); + return string(); + } } -int VSpace::inPixels(int default_height, int default_skip, int default_width) - const +docstring const VSpace::asGUIName() const { - // Height of a normal line in pixels (zoom factor considered) - int height = default_height; // [pixels] - - // Zoom factor specified by user in percent - double const zoom = lyxrc.zoom / 100.0; // [percent] + docstring result; + switch (kind_) { + case DEFSKIP: + result = _("Default skip"); + break; + case SMALLSKIP: + result = _("Small skip"); + break; + case MEDSKIP: + result = _("Medium skip"); + break; + case BIGSKIP: + result = _("Big skip"); + break; + case VFILL: + result = _("Vertical fill"); + break; + case LENGTH: + result = from_ascii(len_.asString()); + break; + } + if (keep_) + result += ", " + _("protected"); + return result; +} - // DPI setting for monitor: pixels/inch - double const dpi = lyxrc.dpi; // screen resolution [pixels/inch] - // We want the result in pixels - double result; - double value; +int VSpace::inPixels(BufferView const & bv) const +{ + // Height of a normal line in pixels (zoom factor considered) + int const default_height = defaultRowHeight(); switch (kind_) { - case NONE: - return 0; case DEFSKIP: - return default_skip; - - // This is how the skips are normally defined by - // LateX. But there should be some way to change - // this per document. - case SMALLSKIP: return height / 4; - case MEDSKIP: return height / 2; - case BIGSKIP: return height; - case VFILL: return 3 * height; + return bv.buffer()->params().getDefSkip().inPixels(bv); + + // This is how the skips are normally defined by LateX. + // But there should be some way to change this per document. + case SMALLSKIP: + return default_height / 4; + + case MEDSKIP: + return default_height / 2; + + case BIGSKIP: + return default_height; + + case VFILL: // leave space for the vfill symbol + return 3 * default_height; + case LENGTH: - // Pixel values are scaled so that the ratio - // between lengths and font sizes on the screen - // is the same as on paper. - - // we don't care about sign of value, we - // display negative space with text too - result = 0.0; - value = len_.value(); - int val_sign = value < 0.0 ? -1 : 1; - - switch (len_.unit()) { - case LyXLength::SP: - // Scaled point: sp = 1/65536 pt - result = zoom * dpi * value - / (72.27 * 65536); // 4736286.7 - break; - case LyXLength::PT: - // Point: 1 pt = 1/72.27 inch - result = zoom * dpi * value - / 72.27; // 72.27 - break; - case LyXLength::BP: - // Big point: 1 bp = 1/72 inch - result = zoom * dpi * value - / 72; // 72 - break; - case LyXLength::DD: - // Didot: 1157dd = 1238 pt? - result = zoom * dpi * value - / (72.27 / (0.376 * 2.845)); // 67.559735 - break; - case LyXLength::MM: - // Millimeter: 1 mm = 1/25.4 inch - result = zoom * dpi * value - / 25.4; // 25.4 - break; - case LyXLength::PC: - // Pica: 1 pc = 12 pt - result = zoom * dpi * value - / (72.27 / 12); // 6.0225 - break; - case LyXLength::CC: - // Cicero: 1 cc = 12 dd - result = zoom * dpi * value - / (72.27 / (12 * 0.376 * 2.845)); // 5.6299779 - break; - case LyXLength::CM: - // Centimeter: 1 cm = 1/2.54 inch - result = zoom * dpi * value - / 2.54; // 2.54 - break; - case LyXLength::IN: - // Inch - result = zoom * dpi * value; - break; - case LyXLength::EX: - // Ex: The height of an "x" - result = zoom * value * height / 2; // what to / width? - break; - case LyXLength::EM: // what to / width? - // Em: The width of an "m" - result = zoom * value * height / 2; // Why 2? - break; - case LyXLength::MU: // This is probably only allowed in - // math mode - result = zoom * value * height; - break; - case LyXLength::PW: // Always % of workarea - case LyXLength::PE: - case LyXLength::PP: - case LyXLength::PL: - result = value * default_width / 100; - break; - case LyXLength::UNIT_NONE: - result = 0; // this cannot happen - break; - } - return static_cast(result * val_sign + 0.5); + return len_.len().inPixels(bv.workWidth()); + + default: + BOOST_ASSERT(false); + return 0; } - return 0; // never reached } + + +} // namespace lyx