src/lyxlength.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2001 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 #include <config.h>
  12
  13 #ifdef __GNUG__
  14 #pragma implementation
  15 #endif
  16
  17 #include "lyxlength.h"
  18 #include "lengthcommon.h"
  19 #include "lyxrc.h"
  20
  21 #include "Lsstream.h"
  22
  23 #include <cstdlib>
  24
  25
  26 LyXLength::LyXLength()
  27         : val_(0), unit_(LyXLength::PT)
  28 {}
  29
  30
  31 LyXLength::LyXLength(double v, LyXLength::UNIT u)
  32         : val_(v), unit_(u)
  33 {}
  34
  35
  36 LyXLength::LyXLength(string const & data)
  37         : val_(0), unit_(LyXLength::PT)
  38 {
  39         LyXLength tmp;
  40
  41         if (!isValidLength (data, &tmp))
  42                 return; // should raise an exception
  43
  44         val_  = tmp.val_;
  45         unit_ = tmp.unit_;
  46 }
  47
  48
  49 string const LyXLength::asString() const
  50 {
  51         ostringstream buffer;
  52         buffer << val_ << unit_name[unit_]; // setw?
  53         return buffer.str().c_str();
  54 }
  55
  56
  57 string const LyXLength::asLatexString() const
  58 {
  59         ostringstream buffer;
  60         switch (unit_) {
  61         case PW:
  62             buffer << abs(static_cast<int>(val_/100)) << "."
  63                    << abs(static_cast<int>(val_)%100) << "\\textwidth";
  64             break;
  65         case PE:
  66             buffer << abs(static_cast<int>(val_/100)) << "."
  67                    << abs(static_cast<int>(val_)%100) << "\\columnwidth";
  68             break;
  69         case PP:
  70             buffer << abs(static_cast<int>(val_/100)) << "."
  71                    << abs(static_cast<int>(val_)%100) << "\\paperwidth";
  72             break;
  73         case PL:
  74             buffer << abs(static_cast<int>(val_/100)) << "."
  75                    << abs(static_cast<int>(val_)%100) << "\\linewidth";
  76             break;
  77         default:
  78             buffer << val_ << unit_name[unit_]; // setw?
  79             break;
  80         }
  81         return buffer.str().c_str();
  82 }
  83
  84
  85 double LyXLength::value() const
  86 {
  87         return val_;
  88 }
  89
  90
  91 LyXLength::UNIT LyXLength::unit() const
  92 {
  93         return unit_;
  94 }
  95
  96
  97 void LyXLength::value(double v)
  98 {
  99         val_ = v;
 100 }
 101
 102
 103 void LyXLength::unit(LyXLength::UNIT u)
 104 {
 105         unit_ = u;
 106 }
 107
 108
 109 bool LyXLength::zero() const
 110 {
 111         return val_ == 0.0;
 112 }
 113
 114
 115 int LyXLength::inPixels(int default_width, int default_height) const
 116 {
 117         // Zoom factor specified by user in percent
 118         double const zoom = lyxrc.zoom / 100.0; // [percent]
 119
 120         // DPI setting for monitor: pixels/inch
 121         double const dpi = lyxrc.dpi; // screen resolution [pixels/inch]
 122
 123         // Pixel values are scaled so that the ratio
 124         // between lengths and font sizes on the screen
 125         // is the same as on paper.
 126
 127         // we don't care about sign of value, we
 128         // display negative space with text too
 129         double result = 0.0;
 130         int val_sign = val_ < 0.0 ? -1 : 1;
 131
 132         switch (unit_) {
 133         case LyXLength::SP:
 134                 // Scaled point: sp = 1/65536 pt
 135                 result = zoom * dpi * val_
 136                         / (72.27 * 65536); // 4736286.7
 137                 break;
 138         case LyXLength::PT:
 139                 // Point: 1 pt = 1/72.27 inch
 140                 result = zoom * dpi * val_
 141                         / 72.27; // 72.27
 142                 break;
 143         case LyXLength::BP:
 144                 // Big point: 1 bp = 1/72 inch
 145                 result = zoom * dpi * val_
 146                         / 72; // 72
 147                 break;
 148         case LyXLength::DD:
 149                 // Didot: 1157dd = 1238 pt?
 150                 result = zoom * dpi * val_
 151                         / (72.27 / (0.376 * 2.845)); // 67.559735
 152                 break;
 153         case LyXLength::MM:
 154                 // Millimeter: 1 mm = 1/25.4 inch
 155                 result = zoom * dpi * val_
 156                         / 25.4; // 25.4
 157                 break;
 158         case LyXLength::PC:
 159                 // Pica: 1 pc = 12 pt
 160                 result = zoom * dpi * val_
 161                         / (72.27 / 12); // 6.0225
 162                 break;
 163         case LyXLength::CC:
 164                 // Cicero: 1 cc = 12 dd
 165                 result = zoom * dpi * val_
 166                         / (72.27 / (12 * 0.376 * 2.845)); // 5.6299779
 167                 break;
 168         case LyXLength::CM:
 169                 // Centimeter: 1 cm = 1/2.54 inch
 170                 result = zoom * dpi * val_
 171                         / 2.54; // 2.54
 172                 break;
 173         case LyXLength::IN:
 174                 // Inch
 175                 result = zoom * dpi * val_;
 176                 break;
 177         case LyXLength::EX:
 178                 // Ex: The height of an "x"
 179                 result = zoom * val_ * default_height / 2; // what to / width?
 180                 break;
 181         case LyXLength::EM: // what to / width?
 182                 // Em: The width of an "m"
 183                 result = zoom * val_ * default_height / 2; // Why 2?
 184                 break;
 185         case LyXLength::MU: // This is probably only allowed in
 186                 // math mode
 187                 result = zoom * val_ * default_height;
 188                 break;
 189         case LyXLength::PW: // Always % of workarea
 190         case LyXLength::PE:
 191         case LyXLength::PP:
 192         case LyXLength::PL:
 193                 result = val_ * default_width / 100;
 194                 break;
 195         case LyXLength::UNIT_NONE:
 196                 result = 0;  // this cannot happen
 197                 break;
 198         }
 199         return static_cast<int>(result * val_sign + 0.5);
 200 }
 201
 202
 203 bool operator==(LyXLength const & l1, LyXLength const & l2)
 204 {
 205         return l1.value() == l2.value() && l1.unit() == l2.unit();
 206 }
 207
 208
 209 bool operator!=(LyXLength const & l1, LyXLength const & l2)
 210 {
 211         return !(l1 == l2);
 212 }