mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-22 01:59:02 +00:00
c0ce79452f
This fixes a failing unit test with 32bit gcc 4.9.3 and -O2 optimization: It computed 9953 instead of 9954 for Length::inPixels() of value 2342. The reason for this is probably different rounding behaviour caused by storing the unrounded value in a processor register (uses 80bit accuracy) vs. writing it back to memory (uses 64bit accuracy). The unrounded value is very close to 9953.5 (which is not representable as an exact IEEE floating point value). Apart from that, having a proper function for rounding makes the code more readable, and has the nice side effect to make Length::inPB() work for negative lengths as well.
461 lines
9.0 KiB
C++
461 lines
9.0 KiB
C++
/**
|
|
* \file Length.cpp
|
|
* This file is part of LyX, the document processor.
|
|
* Licence details can be found in the file COPYING.
|
|
*
|
|
* \author Matthias Ettrich
|
|
* \author Lars Gullik Bjønnes
|
|
* \author Jean-Marc Lasgouttes
|
|
* \author Angus Leeming
|
|
* \author John Levon
|
|
* \author Dekel Tsur
|
|
*
|
|
* Full author contact details are available in file CREDITS.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "Length.h"
|
|
#include "LyXRC.h"
|
|
#include "MetricsInfo.h"
|
|
|
|
#include "frontends/FontMetrics.h"
|
|
|
|
#include "support/docstream.h"
|
|
#include "support/lstrings.h"
|
|
#include "support/lyxlib.h"
|
|
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
|
|
using namespace std;
|
|
using namespace lyx::support;
|
|
|
|
namespace lyx {
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Length
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
Length::Length()
|
|
: val_(0), unit_(Length::UNIT_NONE)
|
|
{}
|
|
|
|
|
|
Length::Length(double v, Length::UNIT u)
|
|
: val_(v), unit_(u)
|
|
{}
|
|
|
|
|
|
Length::Length(string const & data)
|
|
: val_(0), unit_(Length::PT)
|
|
{
|
|
Length tmp;
|
|
|
|
if (!isValidLength(data, &tmp))
|
|
return; // should raise an exception
|
|
|
|
val_ = tmp.val_;
|
|
unit_ = tmp.unit_;
|
|
}
|
|
|
|
|
|
string const Length::asString() const
|
|
{
|
|
ostringstream os;
|
|
if (unit_ != UNIT_NONE)
|
|
os << formatFPNumber(val_) << unit_name[unit_]; // setw?
|
|
return os.str();
|
|
}
|
|
|
|
|
|
docstring const Length::asDocstring() const
|
|
{
|
|
odocstringstream os;
|
|
if (unit_ != UNIT_NONE)
|
|
os << from_ascii(formatFPNumber(val_))
|
|
<< from_ascii(unit_name[unit_]); // setw?
|
|
return os.str();
|
|
}
|
|
|
|
|
|
string const Length::asLatexString() const
|
|
{
|
|
ostringstream os;
|
|
// Do not allow scientific notation (e.g. 1.2e+03), since this is not valid
|
|
// LaTeX (bug 9416)
|
|
switch (unit_) {
|
|
case PTW:
|
|
os << formatFPNumber(val_ / 100.0) << "\\textwidth";
|
|
break;
|
|
case PCW:
|
|
os << formatFPNumber(val_ / 100.0) << "\\columnwidth";
|
|
break;
|
|
case PPW:
|
|
os << formatFPNumber(val_ / 100.0) << "\\paperwidth";
|
|
break;
|
|
case PLW:
|
|
os << formatFPNumber(val_ / 100.0) << "\\linewidth";
|
|
break;
|
|
case PTH:
|
|
os << formatFPNumber(val_ / 100.0) << "\\textheight";
|
|
break;
|
|
case PPH:
|
|
os << formatFPNumber(val_ / 100.0) << "\\paperheight";
|
|
break;
|
|
case UNIT_NONE:
|
|
break;
|
|
default:
|
|
os << formatFPNumber(val_) << unit_name[unit_];
|
|
break;
|
|
}
|
|
return os.str();
|
|
}
|
|
|
|
|
|
string const Length::asHTMLString() const
|
|
{
|
|
ostringstream os;
|
|
switch (unit_) {
|
|
case PT:
|
|
case BP:
|
|
case DD:
|
|
// close enough
|
|
os << formatFPNumber(val_) << "pt";
|
|
break;
|
|
case MM:
|
|
case CM:
|
|
case PC:
|
|
case IN:
|
|
case EX:
|
|
case EM:
|
|
os << formatFPNumber(val_) << unit_name[unit_];
|
|
break;
|
|
case CC:
|
|
os << formatFPNumber(val_ / 12.0) << "pt";
|
|
break;
|
|
case MU:
|
|
os << formatFPNumber(val_ / 18.0) << "em";
|
|
break;
|
|
case PTW:
|
|
case PPW:
|
|
case PLW:
|
|
case PCW:
|
|
case PTH:
|
|
case PPH:
|
|
// what it's a percentage of probably won't make sense for HTML,
|
|
// so we'll assume people have chosen these appropriately
|
|
os << formatFPNumber(val_) << '%';
|
|
break;
|
|
case SP:
|
|
case UNIT_NONE:
|
|
break;
|
|
}
|
|
return os.str();
|
|
}
|
|
|
|
|
|
double Length::value() const
|
|
{
|
|
return val_;
|
|
}
|
|
|
|
|
|
Length::UNIT Length::unit() const
|
|
{
|
|
return unit_;
|
|
}
|
|
|
|
|
|
void Length::value(double v)
|
|
{
|
|
val_ = v;
|
|
}
|
|
|
|
|
|
void Length::unit(Length::UNIT u)
|
|
{
|
|
unit_ = u;
|
|
}
|
|
|
|
|
|
bool Length::zero() const
|
|
{
|
|
return val_ == 0.0;
|
|
}
|
|
|
|
|
|
bool Length::empty() const
|
|
{
|
|
return unit_ == Length::UNIT_NONE;
|
|
}
|
|
|
|
|
|
int Length::inPixels(int text_width, int em_width_base) const
|
|
{
|
|
// 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]
|
|
|
|
double const em_width_in = (em_width_base > 0)
|
|
? em_width_base / (zoom * dpi)
|
|
: 10.0/72.27;
|
|
// A different estimate for em_width is
|
|
// theFontMetrics(FontInfo(sane_font)).em()
|
|
// 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.
|
|
|
|
double const text_width_in = text_width / (zoom * dpi);
|
|
double const result = zoom * dpi * inInch(text_width_in, em_width_in);
|
|
return support::iround(result);
|
|
}
|
|
|
|
|
|
double Length::inInch(double text_width, double em_width) const
|
|
{
|
|
double result = 0.0;
|
|
|
|
switch (unit_) {
|
|
case Length::SP:
|
|
// Scaled point: sp = 1/65536 pt
|
|
result = val_ / (72.27 * 65536); // 4736286.7
|
|
break;
|
|
case Length::PT:
|
|
// Point: 1 pt = 1/72.27 inch
|
|
result = val_ / 72.27; // 72.27
|
|
break;
|
|
case Length::BP:
|
|
// Big point: 1 bp = 1/72 inch
|
|
result = val_ / 72; // 72
|
|
break;
|
|
case Length::DD:
|
|
// Didot: 1157dd = 1238 pt?
|
|
result = val_ / (72.27 / (0.376 * 2.845)); // 67.559735
|
|
break;
|
|
case Length::MM:
|
|
// Millimeter: 1 mm = 1/25.4 inch
|
|
result = val_ / 25.4; // 25.4
|
|
break;
|
|
case Length::PC:
|
|
// Pica: 1 pc = 12 pt
|
|
result = val_ / (72.27 / 12); // 6.0225
|
|
break;
|
|
case Length::CC:
|
|
// Cicero: 1 cc = 12 dd
|
|
result = val_
|
|
/ (72.27 / (12 * 0.376 * 2.845)); // 5.6299779
|
|
break;
|
|
case Length::CM:
|
|
// Centimeter: 1 cm = 1/2.54 inch
|
|
result = val_ / 2.54; // 2.54
|
|
break;
|
|
case Length::IN:
|
|
// Inch
|
|
result = val_;
|
|
break;
|
|
case Length::EX:
|
|
// Ex: The height of an "x"
|
|
// 0.4305 is the ration between 1ex and 1em in cmr10
|
|
result = val_ * em_width * 0.4305;
|
|
break;
|
|
case Length::EM:
|
|
// Em: The width of an "m"
|
|
result = val_ * em_width;
|
|
break;
|
|
case Length::MU:
|
|
// math unit = 1/18em
|
|
result = val_ * em_width / 18;
|
|
break;
|
|
case Length::PCW: // Always % of workarea
|
|
case Length::PTW:
|
|
case Length::PLW:
|
|
result = val_ * text_width / 100;
|
|
break;
|
|
case Length::PPW:
|
|
// paperwidth/textwidth is 1.7 for A4 paper with default margins
|
|
result = val_ * text_width * 1.7 / 100;
|
|
break;
|
|
case Length::PTH:
|
|
result = val_ * text_width * 1.787 / 100;
|
|
break;
|
|
case Length::PPH:
|
|
result = val_ * text_width * 2.2 / 100;
|
|
break;
|
|
case Length::UNIT_NONE:
|
|
result = 0; // this cannot happen
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
int Length::inPixels(MetricsBase const & base) const
|
|
{
|
|
return inPixels(base.textwidth, theFontMetrics(base.font).em());
|
|
}
|
|
|
|
|
|
int Length::inBP() const
|
|
{
|
|
// return any Length value as a one with
|
|
// the PostScript point, called bp (big points)
|
|
|
|
double const text_width_in = 210.0 / 2.54; // assume A4
|
|
double const em_width_in = 10.0 / 72.27;
|
|
double result = 72.0 * inInch(text_width_in, em_width_in);
|
|
return support::iround(result);
|
|
}
|
|
|
|
|
|
Length::UNIT Length::defaultUnit()
|
|
{
|
|
return lyxrc.default_length_unit;
|
|
}
|
|
|
|
|
|
|
|
bool operator==(Length const & l1, Length const & l2)
|
|
{
|
|
return l1.value() == l2.value() && l1.unit() == l2.unit();
|
|
}
|
|
|
|
|
|
bool operator!=(Length const & l1, Length const & l2)
|
|
{
|
|
return !(l1 == l2);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GlueLength
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
GlueLength::GlueLength(Length const & len)
|
|
: len_(len)
|
|
{}
|
|
|
|
|
|
GlueLength::GlueLength(Length const & len, Length const & plus,
|
|
Length const & minus)
|
|
: len_(len), plus_(plus), minus_(minus)
|
|
{}
|
|
|
|
|
|
GlueLength::GlueLength(string const & data)
|
|
{
|
|
isValidGlueLength(data, this);
|
|
}
|
|
|
|
|
|
string const GlueLength::asString() const
|
|
{
|
|
if (len_.empty())
|
|
return string();
|
|
|
|
ostringstream buffer;
|
|
|
|
buffer << formatFPNumber(len_.value());
|
|
|
|
if (plus_.zero() && minus_.zero()) {
|
|
buffer << unit_name[len_.unit()];
|
|
return buffer.str();
|
|
}
|
|
|
|
// just len and plus
|
|
if (minus_.zero()) {
|
|
if (len_.unit() != plus_.unit())
|
|
buffer << unit_name[len_.unit()];
|
|
buffer << '+' << formatFPNumber(plus_.value());
|
|
buffer << unit_name[plus_.unit()];
|
|
return buffer.str();
|
|
}
|
|
|
|
// just len and minus
|
|
if (plus_.zero()) {
|
|
if (len_.unit() != minus_.unit())
|
|
buffer << unit_name[len_.unit()];
|
|
buffer << '-' << formatFPNumber(minus_.value());
|
|
buffer << unit_name[minus_.unit()];
|
|
return buffer.str();
|
|
}
|
|
|
|
// ok, len, plus AND minus
|
|
|
|
// len+-
|
|
if (minus_ == plus_) {
|
|
if (len_.unit() != minus_.unit())
|
|
buffer << unit_name[len_.unit()];
|
|
buffer << "+-" << formatFPNumber(minus_.value());
|
|
buffer << unit_name[minus_.unit()];
|
|
return buffer.str();
|
|
}
|
|
|
|
// this is so rare a case, why bother minimising units ?
|
|
|
|
buffer << unit_name[len_.unit()];
|
|
buffer << '+' << formatFPNumber(plus_.value()) << unit_name[plus_.unit()];
|
|
buffer << '-' << formatFPNumber(minus_.value()) << unit_name[minus_.unit()];
|
|
|
|
return buffer.str();
|
|
}
|
|
|
|
|
|
string const GlueLength::asLatexString() const
|
|
{
|
|
ostringstream buffer;
|
|
// use Length::asLatexString() to handle also the percent lengths
|
|
buffer << len_.Length::asLatexString();
|
|
if (!plus_.zero())
|
|
buffer << " plus " << plus_.Length::asLatexString();
|
|
if (!minus_.zero())
|
|
buffer << " minus " << minus_.Length::asLatexString();
|
|
return buffer.str();
|
|
}
|
|
|
|
|
|
Length const & GlueLength::len() const
|
|
{
|
|
return len_;
|
|
}
|
|
|
|
|
|
Length const & GlueLength::plus() const
|
|
{
|
|
return plus_;
|
|
}
|
|
|
|
|
|
Length const & GlueLength::minus() const
|
|
{
|
|
return minus_;
|
|
}
|
|
|
|
|
|
bool operator==(GlueLength const & l1, GlueLength const & l2)
|
|
{
|
|
return l1.len() == l2.len()
|
|
&& l1.plus() == l2.plus()
|
|
&& l1.minus() == l2.minus();
|
|
}
|
|
|
|
|
|
bool operator!=(GlueLength const & l1, GlueLength const & l2)
|
|
{
|
|
return !(l1 == l2);
|
|
}
|
|
|
|
|
|
} // namespace lyx
|