X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fvspace.C;h=6b4d25a7ed5a16e73484828a3ec1d4267c60a0ac;hb=98c966c64594611e469313314abd1e59524adb4a;hp=ec023d85776312692686a1e4350040271641ece7;hpb=33a28bdc9cdf978601d5d40b693f13924801ad9e;p=lyx.git diff --git a/src/vspace.C b/src/vspace.C index ec023d8577..6b4d25a7ed 100644 --- a/src/vspace.C +++ b/src/vspace.C @@ -1,12 +1,10 @@ -/* This file is part of - * ====================================================== +/** + * \file vspace.C + * Copyright 1995-2002 the LyX Team + * Read the file COPYING * - * LyX, The Document Processor - * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * \author Matthias Ettrich + */ #include @@ -21,6 +19,7 @@ #include "lyxrc.h" #include "lyxtext.h" #include "BufferView.h" +#include "support/LAssert.h" #include "support/lstrings.h" @@ -29,29 +28,45 @@ namespace { -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) { data.erase(0, n); } - +/// return true when the input is at the end inline bool isEndOfData(string const & data) { return frontStrip(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); @@ -76,7 +91,7 @@ char nextToken(string & data) if (number_index > 3) return 'E'; string buffer; - + // we have found some number if (i == string::npos) { buffer = data; @@ -92,13 +107,13 @@ char nextToken(string & data) return 'n'; } 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; @@ -125,6 +140,7 @@ char nextToken(string & data) } +/// latex representation of a vspace struct LaTeXLength { char const * pattern; int plus_val_index; @@ -134,6 +150,7 @@ struct LaTeXLength { }; +/// the possible formats for a vspace string LaTeXLength table[] = { { "nu", 0, 0, 0, 0 }, { "nu+nu", 2, 0, 2, 0 }, @@ -200,7 +217,7 @@ bool isValidGlueLength(string const & data, LyXGlueLength * result) break; } // end of hack - + int pattern_index = 0; int table_index = 0; char pattern[20]; @@ -224,7 +241,7 @@ 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. @@ -242,10 +259,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; @@ -269,7 +286,7 @@ 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" @@ -284,8 +301,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) { @@ -410,142 +427,87 @@ string const VSpace::asLyXCommand() const string const VSpace::asLatexCommand(BufferParams const & params) const { + string ret; + switch (kind_) { - case NONE: return string(); + case NONE: + break; 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() + '}'; + ret = params.getDefSkip().asLatexCommand(params); + break; + case SMALLSKIP: + ret = keep_ ? "\\vspace*{\\smallskipamount}" + : "\\smallskip{}"; + break; + case MEDSKIP: + ret = keep_ ? "\\vspace*{\\medskipamount}" + : "\\medskip{}"; + break; + case BIGSKIP: + ret = keep_ ? "\\vspace*{\\bigskipamount}" + : "\\bigskip{}"; + break; + case VFILL: + ret = keep_ ? "\\vspace*{\\fill}" + : "\\vfill{}"; + break; + case LENGTH: + { + string const lenstr = len_.asLatexString(); + + ret = keep_ ? "\\vspace*{" + lenstr + '}' + : "\\vspace{" + lenstr + '}'; } - return string(); // should never be reached + break; + + } + + return ret; } + int VSpace::inPixels(BufferView * bv) const { // Height of a normal line in pixels (zoom factor considered) - int default_height = bv->text->defaultHeight(); // [pixels] - int default_skip = 0; - int default_width = bv->workWidth(); - - if (kind_ == DEFSKIP) - default_skip = bv->buffer()->params.getDefSkip().inPixels(bv); - - // 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] - - // DPI setting for monitor: pixels/inch - double const dpi = lyxrc.dpi; // screen resolution [pixels/inch] + int const default_height = bv->text->defaultHeight(); // [pixels] - // We want the result in pixels - double result; - double value; + int retval = 0; switch (kind_) { case NONE: - return 0; - + // Value for this is already set + break; case DEFSKIP: - return default_skip; + retval = bv->buffer()->params.getDefSkip().inPixels(bv); + break; // 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; + case SMALLSKIP: + retval = default_height / 4; + break; + + case MEDSKIP: + retval = default_height / 2; + break; + + case BIGSKIP: + retval = default_height; + break; + + case VFILL: // leave space for the vfill symbol - 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_.len().value(); - int val_sign = value < 0.0 ? -1 : 1; - - switch (len_.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); + retval = 3 * default_height; + break; + + case LENGTH: { + int const default_width = bv->workWidth(); + retval = len_.len().inPixels(default_width, default_height); + break; + } + } - return 0; // never reached + return retval; }