X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fvspace.C;h=d12ecb820a497080a57fba93f34d1ffd60d2b6c5;hb=f448e22d483e1370bcbfbb7be8cb47ad7251ed77;hp=c66e7874f3a46c73fbaefdabc2edab49edb62bec;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git diff --git a/src/vspace.C b/src/vspace.C index c66e7874f3..d12ecb820a 100644 --- a/src/vspace.C +++ b/src/vspace.C @@ -1,13 +1,13 @@ // -*- C++ -*- /* This file is part of - * ====================================================== + * ====================================================== * * LyX, The Document Processor * - * Copyright (C) 1995 Matthias Ettrich - * Copyright (C) 1995-1998 The LyX Team. + * Copyright 1995 Matthias Ettrich + * Copyright 1995-2000 The LyX Team. * - *======================================================*/ + * ====================================================== */ #include @@ -20,35 +20,26 @@ #include "vspace.h" #include "lyxrc.h" #include "lyxtext.h" -#include -#include #include "BufferView.h" +#include "support/lstrings.h" -extern LyXRC * lyxrc; -extern BufferView *current_view; - -// $Id: vspace.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $ - -#if !defined(lint) && !defined(WITH_WARNINGS) -static char vcid[] = "$Id: vspace.C,v 1.1 1999/09/27 18:44:38 larsbj Exp $"; -#endif /* lint */ /* length units */ -static const int num_units = int(LyXLength::UNIT_NONE); +static const int 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" }; +static char const * unit_name[num_units] = { "sp", "pt", "bp", "dd", + "mm", "pc", "cc", "cm", + "in", "ex", "em", "mu" }; -LyXLength::UNIT unitFromString (LString const & data) +LyXLength::UNIT unitFromString (string const & data) { - int i=0; - while ((i(i); } /* The following static items form a simple scanner for @@ -62,95 +53,122 @@ static LyXLength::UNIT unit[4] = { LyXLength::UNIT_NONE, //static int number_index, unit_index; int number_index, unit_index; -static void advance (LString& data, const int n) + +static inline +void lyx_advance(string & data, unsigned int n) { - if (data.length() <= n) - data.clean(); - else - data.substring (n, data.length()-1); + data.erase(0, n); } -static bool isEndOfData (LString& data) + +static inline +bool isEndOfData(string const & data) { - data.frontStrip (' '); - return data.empty(); + return frontStrip(data).empty(); } -static char nextToken (LString& data) -{ - data.frontStrip (' '); +static +char nextToken(string & data) +{ + data = frontStrip(data); if (data.empty()) return '\0'; else if (data[0] == '+') { - advance (data, 1); + lyx_advance(data, 1); return '+'; - } - else if (data.prefixIs ("plus")) { - advance (data, 4); + } else if (prefixIs(data, "plus")) { + lyx_advance(data, 4); return '+'; - } - else if (data[0] == '-') { - advance (data, 1); + } else if (data[0] == '-') { + lyx_advance(data, 1); return '-'; - } - else if (data.prefixIs ("minus")) { - advance (data, 5); + } else if (prefixIs(data, "minus")) { + lyx_advance(data, 5); return '-'; - } - else { - int i; - - // I really mean assignment ("=") below, not equality! - - if ((i = strspn (data.c_str(), "0123456789."))) { - if (number_index > 3) return 'E'; // Error - LString buffer = data; - buffer.substring (0, i-1); - if (sscanf (buffer.c_str(), - "%f", &number[number_index]) == 1) { - advance (data, i); - number_index++; + } 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 = strspn (data.c_str(), - "abcdefghijklmnopqrstuvwxyz"))) { - if (unit_index > 3) return 'E'; // Error - LString buffer = data; buffer.substring (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) { - advance (data, i); - unit_index++; + ++unit_index; return 'u'; - } else - return 'E'; // Error - } else - return 'E'; // Error + } else return 'E'; // Error + } + return 'E'; // Error } } -static struct { - char const* pattern; + +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 + plus_uni_index, minus_uni_index; }; -bool isValidGlueLength (LString const & data, LyXGlueLength* result) + +static +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 +}; + + +bool isValidGlueLength (string const & data, LyXGlueLength * result) { // This parser is table-driven. First, it constructs a "pattern" // that describes the sequence of tokens in "data". For example, @@ -168,19 +186,20 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result) // forward approach leads to very long, tedious code that would be // much harder to understand and maintain. (AS) - LString buffer = data; - buffer.frontStrip(' '); + if (data.empty()) + return true; + string buffer = frontStrip(data); // 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 '-': - advance(buffer, 1); + lyx_advance(buffer, 1); val_sign = -1; break; case '+': - advance(buffer, 1); + lyx_advance(buffer, 1); // fall through default: // no action @@ -198,14 +217,14 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result) if (pattern_index > 20) return false; pattern[pattern_index] = nextToken (buffer); if (pattern[pattern_index] == 'E') return false; - pattern_index++; + ++pattern_index; } pattern[pattern_index] = '\0'; // search "pattern" in "table" table_index = 0; - while (strcmp (pattern, table[table_index].pattern)) { - table_index++; + while (compare(pattern, table[table_index].pattern)) { + ++table_index; if (!*table[table_index].pattern) return false; } @@ -213,38 +232,38 @@ bool isValidGlueLength (LString const & data, LyXGlueLength* result) // 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->uni = unit[1]; - result->plus_val = number[table[table_index].plus_val_index]; - result->minus_val = number[table[table_index].minus_val_index]; - result->plus_uni = unit [table[table_index].plus_uni_index]; - result->minus_uni = unit [table[table_index].minus_uni_index]; + result->val = number[1] * val_sign; + result->uni = unit[1]; + result->plus_val = number[table[table_index].plus_val_index]; + result->minus_val = number[table[table_index].minus_val_index]; + result->plus_uni = unit [table[table_index].plus_uni_index]; + result->minus_uni = unit [table[table_index].minus_uni_index]; } return true; } -bool isValidLength(LString const & data, LyXLength* 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. - LString 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 '-': - advance(buffer, 1); + lyx_advance(buffer, 1); val_sign = -1; break; case '+': - advance(buffer, 1); + lyx_advance(buffer, 1); // fall through default: // no action @@ -259,25 +278,26 @@ bool isValidLength(LString const & data, LyXLength* result) if (pattern_index > 2) return false; pattern[pattern_index] = nextToken (buffer); if (pattern[pattern_index] == 'E') return false; - pattern_index++; + ++pattern_index; } pattern[pattern_index] = '\0'; // only the most basic pattern is accepted here - if (strcmp (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) { - result->val = number[1]*val_sign; - result->uni = unit[1]; + result->val = number[1] * val_sign; + result->uni = unit[1]; } return true; } + /// LyXLength class -LyXLength::LyXLength(LString const & data) +LyXLength::LyXLength(string const & data) { LyXLength tmp; @@ -289,151 +309,143 @@ LyXLength::LyXLength(LString const & data) } } -bool LyXLength::operator== (LyXLength other) -{ - return (this->val == other.val) - && (this->uni == other.uni); -} -LString LyXLength::asString() const +string const LyXLength::asString() const { - char buffer[20]; - - sprintf (buffer, "%g%s", val, unit_name[uni]); - return LString (buffer); + std::ostringstream buffer; + buffer << val << unit_name[uni]; // setw? + return buffer.str().c_str(); } /* LyXGlueLength class */ -LyXGlueLength::LyXGlueLength (LString const & data) +LyXGlueLength::LyXGlueLength (string const & data) { LyXGlueLength tmp(0.0, PT); if (!isValidGlueLength (data, &tmp)) return; // should raise an exception else { - val=tmp.val; - uni=tmp.uni; - plus_val =tmp.plus_val; - plus_uni =tmp.plus_uni; - minus_val=tmp.minus_val; - minus_uni=tmp.minus_uni; + val = tmp.val; + uni = tmp.uni; + plus_val = tmp.plus_val; + plus_uni = tmp.plus_uni; + minus_val = tmp.minus_val; + minus_uni = tmp.minus_uni; } } -bool LyXGlueLength::operator== (LyXGlueLength other) +string const LyXGlueLength::asString() const { - return (this->val == other.val) - && (this->uni == other.uni) - && (this->plus_val == other.plus_val) - && (this->plus_uni == other.plus_uni) - && (this->minus_val == other.minus_val) - && (this->minus_uni == other.minus_uni); -} + std::ostringstream buffer; - -LString 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]); - else - sprintf (buffer, "%g+%g-%g%s", - 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]); - 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]); - else - if (uni == plus_uni) - sprintf (buffer, "%g+%g%s", - val, plus_val, unit_name[uni]); - else - sprintf (buffer, "%g%s+%g%s", - val, unit_name[uni], - plus_val, unit_name[plus_uni]); + if (minus_val != 0.0) + if ((uni == plus_uni) && (uni == minus_uni)) + if (plus_val == minus_val) + buffer << val << "+-" + << plus_val << unit_name[uni]; + else + buffer << val + << '+' << plus_val + << '-' << minus_val + << unit_name[uni]; + else + if (plus_uni == minus_uni + && plus_val == minus_val) + buffer << val << unit_name[uni] + << "+-" << plus_val + << unit_name[plus_uni]; + + else + buffer << val << unit_name[uni] + << '+' << plus_val + << unit_name[plus_uni] + << '-' << minus_val + << unit_name[minus_uni]; + else + if (uni == plus_uni) + buffer << val << '+' << plus_val + << unit_name[uni]; + else + 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]); + if (minus_val != 0.0) + if (uni == minus_uni) + buffer << val << '-' << minus_val + << unit_name[uni]; + + else + buffer << val << unit_name[uni] + << '-' << minus_val + << unit_name[minus_uni]; else - sprintf (buffer, "%g%s-%g%s", - val, unit_name[uni], - minus_val, unit_name[minus_uni]); - else - sprintf (buffer, "%g%s", val, unit_name[uni]); - return LString (buffer); + buffer << val << unit_name[uni]; + + return buffer.str().c_str(); } -LString LyXGlueLength::asLatexString() const +string const LyXGlueLength::asLatexString() const { - char buffer[40]; + std::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 LString (buffer); + buffer << val << unit_name[uni]; + + return buffer.str().c_str(); } /* VSpace class */ -VSpace::VSpace (LString const & data) +VSpace::VSpace (string const & data) : kin (NONE), len (0.0, LyXLength::PT) { + kp = false; + if (data.empty()) + return; float value; - LString input = data; + string input = strip(data); - input.strip(' '); int length = input.length(); if (length > 1 && input[length-1] == '*') { kp = true; - input.substring (0, length-2); - } else - kp = false; - - if (input.prefixIs ("defskip")) kin = DEFSKIP; - else if (input.prefixIs ("smallskip")) kin = SMALLSKIP; - else if (input.prefixIs ("medskip")) kin = MEDSKIP; - else if (input.prefixIs ("bigskip")) kin = BIGSKIP; - else if (input.prefixIs ("vfill")) kin = VFILL; + input.erase(length - 1); + } + + if (prefixIs (input, "defskip")) kin = DEFSKIP; + else if (prefixIs (input, "smallskip")) kin = SMALLSKIP; + else if (prefixIs (input, "medskip")) kin = MEDSKIP; + else if (prefixIs (input, "bigskip")) kin = BIGSKIP; + 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. @@ -443,7 +455,7 @@ VSpace::VSpace (LString const & data) } -bool VSpace::operator== (VSpace other) +bool VSpace::operator==(VSpace const & other) const { if (this->kin == other.kin) if (this->kin == LENGTH) @@ -458,9 +470,9 @@ bool VSpace::operator== (VSpace other) } -LString VSpace::asLyXCommand() const +string const VSpace::asLyXCommand() const { - LString result; + string result; switch (kin) { case NONE: break; @@ -478,37 +490,48 @@ LString VSpace::asLyXCommand() const } -LString VSpace::asLatexCommand() const +string const VSpace::asLatexCommand(BufferParams const & params) const { switch (kin) { - case NONE: return LString(); + case NONE: return string(); case DEFSKIP: - return current_view->currentBuffer()->params.getDefSkip().asLatexCommand(); + return params.getDefSkip().asLatexCommand(params); case SMALLSKIP: return kp ? "\\vspace*{\\smallskipamount}" - : "\\smallskip{}"; + : "\\smallskip{}"; case MEDSKIP: return kp ? "\\vspace*{\\medskipamount}" - : "\\medskip{}"; + : "\\medskip{}"; case BIGSKIP: return kp ? "\\vspace*{\\bigskipamount}" - : "\\bigskip{}"; + : "\\bigskip{}"; case VFILL: return kp ? "\\vspace*{\\fill}" - : "\\vfill{}"; + : "\\vfill{}"; case LENGTH: return kp ? "\\vspace*{" + len.asLatexString() + '}' - : "\\vspace{" + len.asLatexString() + '}'; + : "\\vspace{" + len.asLatexString() + '}'; } - return LString(); // should never be reached + return string(); // should never be reached } -int VSpace::inPixels() const +int VSpace::inPixels(BufferView * bv) const { // Height of a normal line in pixels (zoom factor considered) - int height = current_view->currentBuffer()->text->DefaultHeight(); // [pixels] + int height = bv->text->DefaultHeight(); // [pixels] + int skip = 0; + if (kin == DEFSKIP) + skip = bv->buffer()->params.getDefSkip().inPixels(bv); + + return inPixels(height, skip); +} +int VSpace::inPixels(int default_height, int default_skip) 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; @@ -517,16 +540,16 @@ int VSpace::inPixels() const case NONE: return 0; case DEFSKIP: - return current_view->currentBuffer()->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; + // 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; - // leave space for the vfill symbol + case VFILL: return 3 * height; + // leave space for the vfill symbol case LENGTH: // Pixel values are scaled so that the ratio // between lengths and font sizes on the screen @@ -557,7 +580,7 @@ int VSpace::inPixels() const case LyXLength::DD: // Didot: 1157dd = 1238 pt? result = zoom * dpi * value - / (72.27/(0.376 * 2.845)); // 67.559735 + / (72.27 / (0.376 * 2.845)); // 67.559735 break; case LyXLength::MM: // Millimeter: 1 mm = 1/25.4 inch @@ -567,12 +590,12 @@ int VSpace::inPixels() const case LyXLength::PC: // Pica: 1 pc = 12 pt result = zoom * dpi * value - / (72.27/12); // 6.0225 + / (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 + / (72.27 / (12 * 0.376 * 2.845)); // 5.6299779 break; case LyXLength::CM: // Centimeter: 1 cm = 1/2.54 inch @@ -592,7 +615,7 @@ int VSpace::inPixels() const result = zoom * value * height / 2; // Why 2? break; case LyXLength::MU: // This is probably only allowed in - // math mode + // math mode result = zoom * value * height; break; case LyXLength::UNIT_NONE: