X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fvspace.C;h=a314e312543f6d74e3cf4a839ec072eecf27a33b;hb=32ef0d04c48a1751abbb5e3b17d1bec25f22c255;hp=a614b0c282499cb8ad518f93890a19cd3f5df6d0;hpb=8dccec5c46a1689fe3ea37144252e952771e1e1c;p=lyx.git diff --git a/src/vspace.C b/src/vspace.C index a614b0c282..a314e31254 100644 --- a/src/vspace.C +++ b/src/vspace.C @@ -1,11 +1,10 @@ -// -*- C++ -*- /* This file is part of * ====================================================== * * LyX, The Document Processor * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995 Matthias Ettrich + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -15,128 +14,172 @@ #pragma implementation "vspace.h" #endif +#include + #include "lyx_main.h" #include "buffer.h" #include "vspace.h" #include "lyxrc.h" #include "lyxtext.h" -#include #include "BufferView.h" #include "support/lstrings.h" -extern LyXRC * lyxrc; -extern BufferView * current_view; + +namespace { /* length units */ -static const int num_units = LyXLength::UNIT_NONE; +int const num_units = LyXLength::UNIT_NONE; // I am not sure if "mu" should be possible to select (Lgb) -static char const * unit_name[num_units] = { "sp", "pt", "bp", "dd", - "mm", "pc", "cc", "cm", - "in", "ex", "em", "mu" }; - +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(i); -} /* The following static items form a simple scanner for * length strings, used by isValid[Glue]Length. See comments there. */ -static float number[4] = { 0, 0, 0, 0 }; -static LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE, - LyXLength::UNIT_NONE }; -//static int number_index, unit_index; -int number_index, unit_index; - -static inline void lyx_advance (string & data, unsigned int n) +float 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, unsigned int n) { data.erase(0, n); } -static inline bool isEndOfData (string const & data) + +inline +bool isEndOfData(string const & data) { - return frontStrip (data).empty(); + return frontStrip(data).empty(); } -static char nextToken (string & data) + +char nextToken(string & data) { data = frontStrip(data); if (data.empty()) return '\0'; else if (data[0] == '+') { - lyx_advance (data, 1); + lyx_advance(data, 1); return '+'; - } - else if (prefixIs(data, "plus")) { - lyx_advance (data, 4); + } else if (prefixIs(data, "plus")) { + lyx_advance(data, 4); return '+'; - } - else if (data[0] == '-') { - lyx_advance (data, 1); + } else if (data[0] == '-') { + lyx_advance(data, 1); return '-'; - } - else if (prefixIs(data, "minus")) { - lyx_advance (data, 5); + } else if (prefixIs(data, "minus")) { + lyx_advance(data, 5); return '-'; - } - else { - string::size_type i; - - // I really mean assignment ("=") below, not equality! - if ((i = data.find_last_of("0123456789.")) != string::npos) { - if (number_index > 3) return 'E'; // Error - string buffer = data.substr(0, i + 1); - if (sscanf (buffer.c_str(), - "%f", &number[number_index]) == 1) { - lyx_advance (data, i + 1); + } else { + string::size_type i = data.find_first_not_of("0123456789."); + + if (i != 0) { + if (number_index > 3) return 'E'; + + string buffer; + + // we have found some number + if (i == string::npos) { + buffer = data; + i = data.size() + 1; + } else + buffer = data.substr(0, i); + + lyx_advance(data, i); + + if (isStrDbl(buffer)) { + number[number_index] = strToDbl(buffer); ++number_index; return 'n'; - } else - return 'E'; // Error - } else if ((i = data.find_last_of("abcdefghijklmnopqrstuvwxyz")) - != string::npos) { - if (unit_index > 3) return 'E'; // Error - string buffer = data.substr(0, i + 1); - unit[unit_index] = unitFromString (buffer); + } else 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) { - lyx_advance (data, i + 1); ++unit_index; return 'u'; - } else - return 'E'; // Error - } else - return 'E'; // Error + } else return 'E'; // Error + } + return 'E'; // Error } } -static struct { + +struct LaTeXLength { char const * pattern; int plus_val_index, minus_val_index, plus_uni_index, minus_uni_index; -} table[] = { { "nu", 0, 0, 0, 0 }, - { "nu+nu", 2, 0, 2, 0 }, - { "nu+nu-nu", 2, 3, 2, 3 }, - { "nu+-nu", 2, 2, 2, 2 }, - { "nu-nu", 0, 2, 0, 2 }, - { "nu-nu+nu", 3, 2, 3, 2 }, - { "nu-+nu", 2, 2, 2, 2 }, - { "n+nu", 2, 0, 1, 0 }, - { "n+n-nu", 2, 3, 1, 1 }, - { "n+-nu", 2, 2, 1, 1 }, - { "n-nu", 0, 2, 0, 1 }, - { "n-n+nu", 3, 2, 1, 1 }, - { "n-+nu", 2, 2, 1, 1 }, - { "", 0, 0, 0, 0 } // sentinel, must be empty }; + +LaTeXLength table[] = { + { "nu", 0, 0, 0, 0 }, + { "nu+nu", 2, 0, 2, 0 }, + { "nu+nu-nu", 2, 3, 2, 3 }, + { "nu+-nu", 2, 2, 2, 2 }, + { "nu-nu", 0, 2, 0, 2 }, + { "nu-nu+nu", 3, 2, 3, 2 }, + { "nu-+nu", 2, 2, 2, 2 }, + { "n+nu", 2, 0, 1, 0 }, + { "n+n-nu", 2, 3, 1, 1 }, + { "n+-nu", 2, 2, 1, 1 }, + { "n-nu", 0, 2, 0, 1 }, + { "n-n+nu", 3, 2, 1, 1 }, + { "n-+nu", 2, 2, 1, 1 }, + { "", 0, 0, 0, 0 } // sentinel, must be empty +}; + +} // namespace anon + +const char * stringFromUnit(int unit) +{ + if (unit < 0 || unit >= num_units) + return 0; + return unit_name[unit]; +} + + +LyXLength::UNIT unitFromString (string const & data) +{ + int i = 0; + while ((i < num_units) && (data != unit_name[i])) ++i; + return static_cast(i); +} + + bool isValidGlueLength (string const & data, LyXGlueLength * result) { // This parser is table-driven. First, it constructs a "pattern" @@ -162,7 +205,7 @@ bool isValidGlueLength (string const & data, LyXGlueLength * result) // To make isValidGlueLength recognize negative values as // the first number this little hack is needed: short val_sign = 1; // positive as default - switch(buffer[0]) { + switch (buffer[0]) { case '-': lyx_advance(buffer, 1); val_sign = -1; @@ -218,15 +261,17 @@ bool isValidLength(string const & data, LyXLength * result) /// 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; - string buffer = data; + string buffer(data); int pattern_index = 0; char pattern[3]; // To make isValidLength recognize negative values // this little hack is needed: short val_sign = 1; // positive as default - switch(buffer[0]) { + switch (buffer[0]) { case '-': lyx_advance(buffer, 1); val_sign = -1; @@ -263,6 +308,7 @@ bool isValidLength(string const & data, LyXLength * result) return true; } + /// LyXLength class LyXLength::LyXLength(string const & data) @@ -277,18 +323,34 @@ LyXLength::LyXLength(string const & data) } } -bool LyXLength::operator== (LyXLength const & other) const + +string const LyXLength::asString() const { - return (val == other.val && - uni == other.uni); + ostringstream buffer; + buffer << val << unit_name[uni]; // setw? + return buffer.str().c_str(); } -string LyXLength::asString() const -{ - char buffer[20]; - sprintf (buffer, "%g%s", val, unit_name[uni]); - return string (buffer); +string const LyXLength::asLatexString() const +{ + ostringstream buffer; + switch(uni) { + 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[uni]; // setw? + break; + } + return buffer.str().c_str(); } @@ -312,87 +374,84 @@ LyXGlueLength::LyXGlueLength (string const & data) } -bool LyXGlueLength::operator== (LyXGlueLength const & other) const +string const LyXGlueLength::asString() const { - return (val == other.val && - uni == other.uni && - plus_val == other.plus_val && - plus_uni == other.plus_uni && - minus_val == other.minus_val && - minus_uni == other.minus_uni); -} + ostringstream buffer; - -string LyXGlueLength::asString() const -{ - char buffer[20]; - if (plus_val != 0.0) if (minus_val != 0.0) if ((uni == plus_uni) && (uni == minus_uni)) if (plus_val == minus_val) - sprintf (buffer, "%g+-%g%s", - val, plus_val, unit_name[uni]); + buffer << val << "+-" + << plus_val << unit_name[uni]; else - sprintf (buffer, "%g+%g-%g%s", - val, plus_val, minus_val, - unit_name[uni]); + buffer << val + << '+' << plus_val + << '-' << minus_val + << unit_name[uni]; else - if ((plus_uni == minus_uni) && (plus_val == minus_val)) - sprintf (buffer, "%g%s+-%g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni]); + if (plus_uni == minus_uni + && plus_val == minus_val) + buffer << val << unit_name[uni] + << "+-" << plus_val + << unit_name[plus_uni]; + else - sprintf (buffer, "%g%s+%g%s-%g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni], - minus_val, unit_name[minus_uni]); + buffer << val << unit_name[uni] + << '+' << plus_val + << unit_name[plus_uni] + << '-' << minus_val + << unit_name[minus_uni]; else if (uni == plus_uni) - sprintf (buffer, "%g+%g%s", - val, plus_val, unit_name[uni]); + buffer << val << '+' << plus_val + << unit_name[uni]; else - sprintf (buffer, "%g%s+%g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni]); + buffer << val << unit_name[uni] + << '+' << plus_val + << unit_name[plus_uni]; + else if (minus_val != 0.0) if (uni == minus_uni) - sprintf (buffer, "%g-%g%s", - val, minus_val, unit_name[uni]); + buffer << val << '-' << minus_val + << unit_name[uni]; + else - sprintf (buffer, "%g%s-%g%s", - val, unit_name[uni], - minus_val, unit_name[minus_uni]); + buffer << val << unit_name[uni] + << '-' << minus_val + << unit_name[minus_uni]; else - sprintf (buffer, "%g%s", val, unit_name[uni]); - return string (buffer); + buffer << val << unit_name[uni]; + + return buffer.str().c_str(); } -string LyXGlueLength::asLatexString() const +string const LyXGlueLength::asLatexString() const { - char buffer[40]; + ostringstream buffer; if (plus_val != 0.0) if (minus_val != 0.0) - sprintf (buffer, "%g%s plus %g%s minus %g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni], - minus_val, unit_name[minus_uni]); + buffer << val << unit_name[uni] + << " plus " + << plus_val << unit_name[plus_uni] + << " minus " + << minus_val << unit_name[minus_uni]; else - sprintf (buffer, "%g%s plus %g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni]); + buffer << val << unit_name[uni] + << " plus " + << plus_val << unit_name[plus_uni]; else if (minus_val != 0.0) - sprintf (buffer, "%g%s minus %g%s", - val, unit_name[uni], - minus_val, unit_name[minus_uni]); + buffer << val << unit_name[uni] + << " minus " + << minus_val << unit_name[minus_uni]; else - sprintf (buffer, "%g%s", - val, unit_name[uni]); - return string (buffer); + buffer << val << unit_name[uni]; + + return buffer.str().c_str(); } @@ -422,7 +481,7 @@ VSpace::VSpace (string const & data) else if (prefixIs (input, "vfill")) kin = VFILL; else if (isValidGlueLength (input, &len)) kin = LENGTH; - else if (sscanf (input.c_str(), "%f", &value) == 1) { + else if (sscanf(input.c_str(), "%f", &value) == 1) { // This last one is for reading old .lyx files // without units in added_space_top/bottom. // Let unit default to centimeters here. @@ -434,20 +493,20 @@ VSpace::VSpace (string const & data) bool VSpace::operator==(VSpace const & other) const { - if (this->kin == other.kin) - if (this->kin == LENGTH) - if (this->len == other.len) - return this->kp == other.kp; - else - return false; - else - return this->kp == other.kp; - else + if (this->kin != other.kin) + return false; + + if (this->kin != LENGTH) + return this->kp == other.kp; + + if (!(this->len == other.len)) return false; + + return this->kp == other.kp; } -string VSpace::asLyXCommand() const +string const VSpace::asLyXCommand() const { string result; @@ -467,12 +526,12 @@ string VSpace::asLyXCommand() const } -string VSpace::asLatexCommand() const +string const VSpace::asLatexCommand(BufferParams const & params) const { switch (kin) { case NONE: return string(); case DEFSKIP: - return current_view->buffer()->params.getDefSkip().asLatexCommand(); + return params.getDefSkip().asLatexCommand(params); case SMALLSKIP: return kp ? "\\vspace*{\\smallskipamount}" : "\\smallskip{}"; case MEDSKIP: return kp ? "\\vspace*{\\medskipamount}" @@ -488,16 +547,29 @@ string VSpace::asLatexCommand() const } -int VSpace::inPixels() const +int VSpace::inPixels(BufferView * bv) const { // Height of a normal line in pixels (zoom factor considered) - int height = current_view->text->DefaultHeight(); // [pixels] + int height = bv->text->defaultHeight(); // [pixels] + int skip = 0; + int width = bv->workWidth(); + + if (kin == DEFSKIP) + 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] + // Zoom factor specified by user in percent - float const zoom = lyxrc->zoom / 100.0; // [percent] + float const zoom = lyxrc.zoom / 100.0; // [percent] // DPI setting for monitor: pixels/inch - float const dpi = lyxrc->dpi; // screen resolution [pixels/inch] + float const dpi = lyxrc.dpi; // screen resolution [pixels/inch] // We want the result in pixels float result, value; @@ -506,15 +578,15 @@ int VSpace::inPixels() const case NONE: return 0; case DEFSKIP: - return current_view->buffer()->params.getDefSkip().inPixels(); + 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 SMALLSKIP: return height / 4; + case MEDSKIP: return height / 2; case BIGSKIP: return height; - case VFILL: return 3*height; + case VFILL: return 3 * height; // leave space for the vfill symbol case LENGTH: // Pixel values are scaled so that the ratio @@ -584,6 +656,12 @@ int VSpace::inPixels() const // 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;