]> git.lyx.org Git - lyx.git/blob - src/lyxlength.C
redraw fix 1.
[lyx.git] / 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 "support/lstrings.h"
22
23 #include "Lsstream.h"
24
25 #include <cstdlib>
26
27 using std::abs;
28
29 LyXLength::LyXLength()
30         : val_(0), unit_(LyXLength::PT)
31 {}
32
33
34 LyXLength::LyXLength(double v, LyXLength::UNIT u)
35         : val_(v), unit_(u)
36 {}
37
38
39 #ifndef NO_PEXTRA_REALLY
40 // compatibility stuff < version 1.2.0pre and for 
41 // "old" 1.2.0 files before the pre
42 namespace {
43 string const convertOldRelLength(string const & oldLength) 
44 {
45         // we can have only one or none of the following
46         if (oldLength.find("c%") != string::npos) {
47                 return subst(oldLength,"c%","col%");
48                     
49         } else if (oldLength.find("t%") != string::npos) {
50                 if (oldLength.find("text%") != string::npos)
51                     return oldLength;
52                 else
53                     return subst(oldLength,"t%","text%");
54
55         } else if (oldLength.find("l%") != string::npos) {
56                 if (oldLength.find("col%") != string::npos)
57                     return oldLength;
58                 else
59                     return subst(oldLength,"l%","line%");
60
61         } else if (oldLength.find("p%") != string::npos)
62                 return subst(oldLength,"p%","page%");
63
64         return oldLength;
65 }
66 } // end anon
67 #endif
68
69 LyXLength::LyXLength(string const & data)
70         : val_(0), unit_(LyXLength::PT)
71 {
72         LyXLength tmp;
73
74 #ifndef NO_PEXTRA_REALLY
75         // this is needed for 1.1.x minipages with width like %t
76         if (!isValidLength (convertOldRelLength(data), &tmp))
77 #else
78         if (!isValidLength (data, &tmp))
79 #endif
80                 if (!isValidLength (convertOldRelLength(data), &tmp))
81                 return; // should raise an exception
82
83         val_  = tmp.val_;
84         unit_ = tmp.unit_;
85 }
86
87
88 string const LyXLength::asString() const
89 {
90         ostringstream buffer;
91         buffer << val_ << unit_name[unit_]; // setw?
92         return buffer.str().c_str();
93 }
94
95
96 string const LyXLength::asLatexString() const
97 {
98         ostringstream buffer;
99         switch (unit_) {
100         case PW:
101             buffer << abs(static_cast<int>(val_/100)) << "."
102                    << abs(static_cast<int>(val_)%100) << "\\textwidth";
103             break;
104         case PE:
105             buffer << abs(static_cast<int>(val_/100)) << "."
106                    << abs(static_cast<int>(val_)%100) << "\\columnwidth";
107             break;
108         case PP:
109             buffer << abs(static_cast<int>(val_/100)) << "."
110                    << abs(static_cast<int>(val_)%100) << "\\paperwidth";
111             break;
112         case PL:
113             buffer << abs(static_cast<int>(val_/100)) << "."
114                    << abs(static_cast<int>(val_)%100) << "\\linewidth";
115             break;
116         default:
117             buffer << val_ << unit_name[unit_]; // setw?
118             break;
119         }
120         return buffer.str().c_str();
121 }
122
123
124 double LyXLength::value() const
125 {
126         return val_;
127 }
128
129
130 LyXLength::UNIT LyXLength::unit() const
131 {
132         return unit_;
133 }
134
135
136 void LyXLength::value(double v)
137 {
138         val_ = v;
139 }
140
141
142 void LyXLength::unit(LyXLength::UNIT u)
143 {
144         unit_ = u;
145 }
146
147
148 bool LyXLength::zero() const
149 {
150         return val_ == 0.0;
151 }
152
153
154 int LyXLength::inPixels(int default_width, int default_height) const
155 {
156         // Zoom factor specified by user in percent
157         double const zoom = lyxrc.zoom / 100.0; // [percent]
158
159         // DPI setting for monitor: pixels/inch
160         double const dpi = lyxrc.dpi; // screen resolution [pixels/inch]
161
162         // Pixel values are scaled so that the ratio
163         // between lengths and font sizes on the screen
164         // is the same as on paper.
165
166         // we don't care about sign of value, we
167         // display negative space with text too
168         double result = 0.0;
169         int val_sign = val_ < 0.0 ? -1 : 1;
170
171         switch (unit_) {
172         case LyXLength::SP:
173                 // Scaled point: sp = 1/65536 pt
174                 result = zoom * dpi * val_
175                         / (72.27 * 65536); // 4736286.7
176                 break;
177         case LyXLength::PT:
178                 // Point: 1 pt = 1/72.27 inch
179                 result = zoom * dpi * val_
180                         / 72.27; // 72.27
181                 break;
182         case LyXLength::BP:
183                 // Big point: 1 bp = 1/72 inch
184                 result = zoom * dpi * val_
185                         / 72; // 72
186                 break;
187         case LyXLength::DD:
188                 // Didot: 1157dd = 1238 pt?
189                 result = zoom * dpi * val_
190                         / (72.27 / (0.376 * 2.845)); // 67.559735
191                 break;
192         case LyXLength::MM:
193                 // Millimeter: 1 mm = 1/25.4 inch
194                 result = zoom * dpi * val_
195                         / 25.4; // 25.4
196                 break;
197         case LyXLength::PC:
198                 // Pica: 1 pc = 12 pt
199                 result = zoom * dpi * val_
200                         / (72.27 / 12); // 6.0225
201                 break;
202         case LyXLength::CC:
203                 // Cicero: 1 cc = 12 dd
204                 result = zoom * dpi * val_
205                         / (72.27 / (12 * 0.376 * 2.845)); // 5.6299779
206                 break;
207         case LyXLength::CM:
208                 // Centimeter: 1 cm = 1/2.54 inch
209                 result = zoom * dpi * val_
210                         / 2.54; // 2.54
211                 break;
212         case LyXLength::IN:
213                 // Inch
214                 result = zoom * dpi * val_;
215                 break;
216         case LyXLength::EX:
217                 // Ex: The height of an "x"
218                 result = zoom * val_ * default_height / 2; // what to / width?
219                 break;
220         case LyXLength::EM: // what to / width?
221                 // Em: The width of an "m"
222                 result = zoom * val_ * default_height / 2; // Why 2?
223                 break;
224         case LyXLength::MU: // This is probably only allowed in
225                 // math mode
226                 result = zoom * val_ * default_height;
227                 break;
228         case LyXLength::PW: // Always % of workarea
229         case LyXLength::PE:
230         case LyXLength::PP:
231         case LyXLength::PL:
232                 result = val_ * default_width / 100;
233                 break;
234         case LyXLength::UNIT_NONE:
235                 result = 0;  // this cannot happen
236                 break;
237         }
238         return static_cast<int>(result * val_sign + 0.5);
239 }
240
241
242 int LyXLength::inBP() const
243 {
244         // return any LyXLength value as a one with
245         // the PostScript point, called bp (big points)
246         double result = 0.0;
247         int val_sign = val_ < 0.0 ? -1 : 1;
248         switch (unit_) {
249         case LyXLength::CM:
250                 // 1bp = 0.2835cm
251                 result = val_ * 28.346;
252                 break;
253         case LyXLength::MM:
254                 // 1bp = 0.02835mm
255                 result = val_ * 2.8346;
256                 break;
257         case LyXLength::IN:
258                 // 1pt = 1/72in
259                 result = val_ * 72.0;
260                 break;
261         default:
262                 // no other than bp possible
263                 result = val_;
264                 break;
265         }
266         return static_cast<int>(result * val_sign + 0.5);
267 }
268
269
270 bool operator==(LyXLength const & l1, LyXLength const & l2)
271 {
272         return l1.value() == l2.value() && l1.unit() == l2.unit();
273 }
274
275
276 bool operator!=(LyXLength const & l1, LyXLength const & l2)
277 {
278         return !(l1 == l2);
279 }