X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxlength.C;h=70a8aaad4204d20c66f3ec7a7b6330bc8c2fc357;hb=fd2124c83dfcfeaf33b64d1d33c8ceb8d9f5f9b9;hp=67be44c917df7c0dba587c603acebdbc1e18846a;hpb=ce96d714211fc54fb5d3baf697c967695f641464;p=lyx.git diff --git a/src/lyxlength.C b/src/lyxlength.C index 67be44c917..70a8aaad42 100644 --- a/src/lyxlength.C +++ b/src/lyxlength.C @@ -1,32 +1,34 @@ -/* This file is part of - * ====================================================== +/** + * \file lyxlength.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Matthias Ettrich + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author Angus Leeming + * \author John Levon + * \author Dekel Tsur * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "lyxlength.h" #include "lengthcommon.h" #include "lyxrc.h" -#include "support/lstrings.h" +#include +#include -#include "Lsstream.h" -#include +using std::ostringstream; +using std::string; LyXLength::LyXLength() - : val_(0), unit_(LyXLength::PT) + : val_(0), unit_(LyXLength::UNIT_NONE) {} @@ -35,48 +37,12 @@ LyXLength::LyXLength(double v, LyXLength::UNIT u) {} -#ifndef NO_PEXTRA_REALLY -// compatibility stuff < version 1.2.0pre and for -// "old" 1.2.0 files before the pre -namespace { -string const convertOldRelLength(string const & oldLength) -{ - // we can have only one or none of the following - if (oldLength.find("c%") != string::npos) { - return subst(oldLength,"c%","col%"); - - } else if (oldLength.find("t%") != string::npos) { - if (oldLength.find("text%") != string::npos) - return oldLength; - else - return subst(oldLength,"t%","text%"); - - } else if (oldLength.find("l%") != string::npos) { - if (oldLength.find("col%") != string::npos) - return oldLength; - else - return subst(oldLength,"l%","line%"); - - } else if (oldLength.find("p%") != string::npos) - return subst(oldLength,"p%","page%"); - - return oldLength; -} -} // end anon -#endif - LyXLength::LyXLength(string const & data) : val_(0), unit_(LyXLength::PT) { LyXLength tmp; -#ifndef NO_PEXTRA_REALLY - // this is needed for 1.1.x minipages with width like %t - if (!isValidLength (convertOldRelLength(data), &tmp)) -#else - if (!isValidLength (data, &tmp)) -#endif - if (!isValidLength (convertOldRelLength(data), &tmp)) + if (!isValidLength(data, &tmp)) return; // should raise an exception val_ = tmp.val_; @@ -86,37 +52,39 @@ LyXLength::LyXLength(string const & data) string const LyXLength::asString() const { - ostringstream buffer; - buffer << val_ << unit_name[unit_]; // setw? - return buffer.str().c_str(); + ostringstream os; + os << val_ << unit_name[unit_]; // setw? + return os.str(); } string const LyXLength::asLatexString() const { - ostringstream buffer; + ostringstream os; switch (unit_) { - case PW: - buffer << abs(static_cast(val_/100)) << "." - << abs(static_cast(val_)%100) << "\\textwidth"; - break; - 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) << "\\paperwidth"; - break; - case PL: - buffer << abs(static_cast(val_/100)) << "." - << abs(static_cast(val_)%100) << "\\linewidth"; - break; + case PTW: + os << val_ / 100.0 << "\\textwidth"; + break; + case PCW: + os << val_ / 100.0 << "\\columnwidth"; + break; + case PPW: + os << val_ / 100.0 << "\\paperwidth"; + break; + case PLW: + os << val_ / 100.0 << "\\linewidth"; + break; + case PPH: + os << val_ / 100.0 << "\\paperheight"; + break; + case PTH: + os << val_ / 100.0 << "\\textheight"; + break; default: - buffer << val_ << unit_name[unit_]; // setw? - break; + os << val_ << unit_name[unit_]; + break; } - return buffer.str().c_str(); + return os.str(); } @@ -150,7 +118,13 @@ bool LyXLength::zero() const } -int LyXLength::inPixels(int default_width, int default_height) const +bool LyXLength::empty() const +{ + return unit_ == LyXLength::UNIT_NONE; +} + + +int LyXLength::inPixels(int text_width, int em_width_base) const { // Zoom factor specified by user in percent double const zoom = lyxrc.zoom / 100.0; // [percent] @@ -158,14 +132,19 @@ int LyXLength::inPixels(int default_width, int default_height) const // DPI setting for monitor: pixels/inch double const dpi = lyxrc.dpi; // screen resolution [pixels/inch] + double const em_width = (em_width_base > 0) + ? em_width_base + : 10*(dpi/72.27)*zoom; + // A different estimate for em_width is + // font_metrics::width('M', LyXFont(LyXFont::ALL_SANE)) + // but this estimate might not be more accurate as the screen font + // is different then the latex font. + // 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 double result = 0.0; - int val_sign = val_ < 0.0 ? -1 : 1; switch (unit_) { case LyXLength::SP: @@ -214,27 +193,64 @@ int LyXLength::inPixels(int default_width, int default_height) const break; case LyXLength::EX: // Ex: The height of an "x" - result = zoom * val_ * default_height / 2; // what to / width? + // 0.4305 is the ration between 1ex and 1em in cmr10 + result = val_ * em_width * 0.4305; break; - case LyXLength::EM: // what to / width? + case LyXLength::EM: // Em: The width of an "m" - result = zoom * val_ * default_height / 2; // Why 2? + result = val_ * em_width; + break; + case LyXLength::MU: + // math unit = 1/18em + result = val_ * em_width / 18; break; - case LyXLength::MU: // This is probably only allowed in - // math mode - result = zoom * val_ * default_height; + case LyXLength::PCW: // Always % of workarea + case LyXLength::PTW: + case LyXLength::PLW: + result = val_ * text_width / 100; break; - case LyXLength::PW: // Always % of workarea - case LyXLength::PE: - case LyXLength::PP: - case LyXLength::PL: - result = val_ * default_width / 100; + case LyXLength::PPW: + // paperwidth/textwidth is 1.7 for A4 paper with default margins + result = val_ * text_width * 1.7 / 100; + break; + case LyXLength::PTH: + result = val_ * text_width * 1.787 / 100; + break; + case LyXLength::PPH: + result = val_ * text_width * 2.2 / 100; break; case LyXLength::UNIT_NONE: result = 0; // this cannot happen break; } - return static_cast(result * val_sign + 0.5); + return static_cast(result + ((result >= 0) ? 0.5 : -0.5)); +} + + +int LyXLength::inBP() const +{ + // return any LyXLength value as a one with + // the PostScript point, called bp (big points) + double result = 0.0; + switch (unit_) { + case LyXLength::CM: + // 1bp = 0.2835cm + result = val_ * 28.346; + break; + case LyXLength::MM: + // 1bp = 0.02835mm + result = val_ * 2.8346; + break; + case LyXLength::IN: + // 1pt = 1/72in + result = val_ * 72.0; + break; + default: + // no other than bp possible + result = val_; + break; + } + return static_cast(result + 0.5); }