Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <string.h>
22 : #include <tools/debug.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <tools/poly.hxx>
25 : #include <vcl/i18nhelp.hxx>
26 :
27 : #define _SV_RULER_CXX
28 : #include <svtools/ruler.hxx>
29 :
30 : // =======================================================================
31 :
32 : #define RULER_OFF 3
33 : #define RULER_TEXTOFF 5
34 : #define RULER_RESIZE_OFF 4
35 : #define RULER_MIN_SIZE 3
36 :
37 : #define RULER_TICK1_WIDTH 1
38 : #define RULER_TICK2_WIDTH 3
39 :
40 : #define RULER_VAR_SIZE 8
41 :
42 : #define RULER_TAB_HEIGHT2 2
43 : #define RULER_TAB_WIDTH2 2
44 : #define RULER_TAB_CWIDTH 8
45 : #define RULER_TAB_CWIDTH2 4
46 : #define RULER_TAB_CWIDTH3 4
47 : #define RULER_TAB_CWIDTH4 2
48 : #define RULER_TAB_DHEIGHT 4
49 : #define RULER_TAB_DHEIGHT2 1
50 : #define RULER_TAB_DWIDTH 5
51 : #define RULER_TAB_DWIDTH2 3
52 : #define RULER_TAB_DWIDTH3 3
53 : #define RULER_TAB_DWIDTH4 1
54 :
55 : #define RULER_UPDATE_LINES 0x01
56 : #define RULER_UPDATE_DRAW 0x02
57 :
58 : #define RULER_CLIP 150
59 :
60 : // =======================================================================
61 :
62 : #define RULER_UNIT_MM 0
63 : #define RULER_UNIT_CM 1
64 : #define RULER_UNIT_M 2
65 : #define RULER_UNIT_KM 3
66 : #define RULER_UNIT_INCH 4
67 : #define RULER_UNIT_FOOT 5
68 : #define RULER_UNIT_MILE 6
69 : #define RULER_UNIT_POINT 7
70 : #define RULER_UNIT_PICA 8
71 : #define RULER_UNIT_CHAR 9
72 : #define RULER_UNIT_LINE 10
73 : #define RULER_UNIT_COUNT 11
74 :
75 : // -----------------
76 : // - ImplRulerData -
77 : // -----------------
78 : class ImplRulerData
79 : {
80 : friend class Ruler;
81 :
82 : private:
83 : RulerLine* pLines;
84 : RulerBorder* pBorders;
85 : RulerIndent* pIndents;
86 : RulerTab* pTabs;
87 : long nNullVirOff;
88 : long nRulVirOff;
89 : long nRulWidth;
90 : long nPageOff;
91 : long nPageWidth;
92 : long nNullOff;
93 : long nMargin1;
94 : long nMargin2;
95 : sal_uInt16 nLines;
96 : sal_uInt16 nBorders;
97 : sal_uInt16 nIndents;
98 : sal_uInt16 nTabs;
99 : sal_uInt16 nMargin1Style;
100 : sal_uInt16 nMargin2Style;
101 : sal_Bool bAutoPageWidth;
102 : sal_Bool bTextRTL;
103 :
104 : #ifdef _SV_RULER_CXX
105 : public:
106 : ImplRulerData();
107 : ~ImplRulerData();
108 : ImplRulerData& operator=( const ImplRulerData& rData );
109 : #endif
110 : };
111 :
112 :
113 : struct ImplRulerUnitData
114 : {
115 : MapUnit eMapUnit; // MAP_UNIT zum Umrechnen
116 : long nTickUnit; // Teiler fuer Einheit
117 : long nTick1; // Schrittweite
118 : long nTick2; // Tick fuer halbe Werte
119 : long nTick3; // Tick fuer Zahlenausgabe
120 : long n100THMM; // Teiler fuer Einheit
121 : sal_uInt16 nUnitDigits; // Anzahl Nachkommastellen
122 : sal_Char aUnitStr[8]; // Einheiten-String
123 : };
124 :
125 : static ImplRulerUnitData aImplRulerUnitTab[RULER_UNIT_COUNT] =
126 : {
127 : { MAP_100TH_MM, 100, 25, 50, 100, 100, 3, " mm" }, // MM
128 : { MAP_100TH_MM, 1000, 250, 500, 1000, 1000, 3, " cm" }, // CM
129 : { MAP_MM, 1000, 250, 500, 1000, 10000, 4, " m" }, // M
130 : { MAP_CM, 100000, 25000, 50000, 100000, 100000, 6, " km" }, // KM
131 : { MAP_100TH_INCH, 100, 10, 50, 100, 2540, 3, "\"" }, // INCH
132 : { MAP_100TH_INCH, 1200, 120, 600, 1200, 30480, 3, "'" }, // FOOT
133 : { MAP_10TH_INCH, 633600, 63360, 316800, 633600, 1609344, 4, " miles" }, // MILE
134 : { MAP_POINT, 1, 12, 12, 36, 353, 2, " pt" }, // POINT
135 : { MAP_100TH_MM, 423, 423, 423, 846, 423, 3, " pi" }, // PICA
136 : { MAP_100TH_MM, 371, 371, 371, 743, 371, 3, " ch" }, // CHAR
137 : { MAP_100TH_MM, 551, 551, 551, 1102, 551, 3, " li" } // LINE
138 : };
139 :
140 : // =======================================================================
141 :
142 : struct ImplRulerHitTest
143 : {
144 : long nPos;
145 : RulerType eType;
146 : sal_uInt16 nAryPos;
147 : sal_uInt16 mnDragSize;
148 : sal_Bool bSize;
149 : sal_Bool bSizeBar;
150 : sal_Bool bExpandTest;
151 0 : ImplRulerHitTest() :
152 0 : bExpandTest( sal_False ) {}
153 : };
154 :
155 : // =======================================================================
156 :
157 944 : ImplRulerData::ImplRulerData()
158 : {
159 944 : memset( this, 0, sizeof( ImplRulerData ) );
160 :
161 : // PageBreite == EditWinBreite
162 944 : bAutoPageWidth = sal_True;
163 944 : }
164 :
165 : // -----------------------------------------------------------------------
166 :
167 252 : ImplRulerData::~ImplRulerData()
168 : {
169 252 : delete[] pLines;
170 252 : delete[] pBorders;
171 252 : delete[] pIndents;
172 252 : delete[] pTabs;
173 252 : }
174 :
175 : // -----------------------------------------------------------------------
176 :
177 0 : ImplRulerData& ImplRulerData::operator=( const ImplRulerData& rData )
178 : {
179 0 : if( this == &rData )
180 0 : return *this;
181 :
182 0 : delete[] pLines;
183 0 : delete[] pBorders;
184 0 : delete[] pIndents;
185 0 : delete[] pTabs;
186 :
187 0 : memcpy( this, &rData, sizeof( ImplRulerData ) );
188 :
189 0 : if ( rData.pLines )
190 : {
191 0 : pLines = new RulerLine[nLines];
192 0 : memcpy( pLines, rData.pLines, nLines*sizeof( RulerLine ) );
193 : }
194 :
195 0 : if ( rData.pBorders )
196 : {
197 0 : pBorders = new RulerBorder[nBorders];
198 0 : memcpy( pBorders, rData.pBorders, nBorders*sizeof( RulerBorder ) );
199 : }
200 :
201 0 : if ( rData.pIndents )
202 : {
203 0 : pIndents = new RulerIndent[nIndents];
204 0 : memcpy( pIndents, rData.pIndents, nIndents*sizeof( RulerIndent ) );
205 : }
206 :
207 0 : if ( rData.pTabs )
208 : {
209 0 : pTabs = new RulerTab[nTabs];
210 0 : memcpy( pTabs, rData.pTabs, nTabs*sizeof( RulerTab ) );
211 : }
212 :
213 0 : return *this;
214 : }
215 :
216 : // =======================================================================
217 :
218 472 : void Ruler::ImplInit( WinBits nWinBits )
219 : {
220 : // Default WinBits setzen
221 472 : if ( !(nWinBits & WB_VERT) )
222 : {
223 236 : nWinBits |= WB_HORZ;
224 :
225 : // --- RTL --- no UI mirroring for horizontal rulers, because
226 : // the document is also not mirrored
227 236 : EnableRTL( sal_False );
228 : }
229 :
230 : // Variablen initialisieren
231 472 : mnWinStyle = nWinBits; // Window-Style
232 472 : mnBorderOff = 0; // Border-Offset
233 472 : mnWinOff = 0; // EditWinOffset
234 472 : mnWinWidth = 0; // EditWinWidth
235 472 : mnWidth = 0; // Fensterbreite
236 472 : mnHeight = 0; // Fensterhoehe
237 472 : mnVirOff = 0; // Offset des VirtualDeice vom linke/oberen Rand
238 472 : mnVirWidth = 0; // Breite bzw. Hoehe vom VirtualDevice
239 472 : mnVirHeight = 0; // Hoehe bzw. Breite vom VirtualDevice
240 472 : mnDragPos = 0; // Drag-Position (NullPunkt)
241 472 : mnUpdateEvtId = 0; // Noch kein Update-Event verschickt
242 472 : mnDragAryPos = 0; // Drag-Array-Index
243 472 : mnDragSize = 0; // Wird beim Draggen die Groesse geaendert
244 472 : mnDragScroll = 0; // Soll beim Draggen gescrollt werden
245 472 : mnDragModifier = 0; // Modifier-Tasten beim Draggen
246 472 : mnExtraStyle = 0; // Style des Extra-Feldes
247 472 : mnExtraClicks = 0; // Click-Anzahl fuer Extra-Feld
248 472 : mnExtraModifier = 0; // Modifier-Tasten beim Click im Extrafeld
249 472 : mnCharWidth = 371;
250 472 : mnLineHeight = 551;
251 472 : mbCalc = sal_True; // Muessen Pagebreiten neu berechnet werden
252 472 : mbFormat = sal_True; // Muss neu ausgegeben werden
253 472 : mbDrag = sal_False; // Sind wir im Drag-Modus
254 472 : mbDragDelete = sal_False; // Wird Maus beim Draggen unten rausgezogen
255 472 : mbDragCanceled = sal_False; // Wurde Dragging abgebrochen
256 472 : mbAutoWinWidth = sal_True; // EditWinBreite == RulerBreite
257 472 : mbActive = sal_True; // Ist Lineal aktiv
258 472 : mnUpdateFlags = 0; // Was soll im Update-Handler upgedatet werden
259 472 : mpData = mpSaveData; // Wir zeigen auf die normalen Daten
260 472 : meExtraType = RULER_EXTRA_DONTKNOW; // Was im ExtraFeld dargestellt wird
261 472 : meDragType = RULER_TYPE_DONTKNOW; // Gibt an, was gedragt wird
262 :
263 : // Units initialisieren
264 472 : mnUnitIndex = RULER_UNIT_CM;
265 472 : meUnit = FUNIT_CM;
266 472 : maZoom = Fraction( 1, 1 );
267 472 : meSourceUnit = MAP_100TH_MM;
268 :
269 : // Border-Breiten berechnen
270 472 : if ( nWinBits & WB_BORDER )
271 472 : mnBorderWidth = 1;
272 : else
273 0 : mnBorderWidth = 0;
274 :
275 : // Einstellungen setzen
276 472 : ImplInitSettings( sal_True, sal_True, sal_True );
277 :
278 : // Setup the default size
279 472 : Rectangle aRect;
280 472 : GetTextBoundRect( aRect, rtl::OUString( "0123456789" ) );
281 472 : long nDefHeight = aRect.GetHeight() + RULER_OFF*2 + RULER_TEXTOFF*2 + mnBorderWidth;
282 :
283 472 : Size aDefSize;
284 472 : if ( nWinBits & WB_HORZ )
285 236 : aDefSize.Height() = nDefHeight;
286 : else
287 236 : aDefSize.Width() = nDefHeight;
288 472 : SetOutputSizePixel( aDefSize );
289 472 : SetType(WINDOW_RULER);
290 472 : }
291 :
292 : // -----------------------------------------------------------------------
293 :
294 472 : Ruler::Ruler( Window* pParent, WinBits nWinStyle ) :
295 : Window( pParent, nWinStyle & WB_3DLOOK ),
296 : maVirDev( *this ),
297 : maMapMode( MAP_100TH_MM ),
298 472 : mpSaveData(new ImplRulerData),
299 : mpData(0),
300 944 : mpDragData(new ImplRulerData)
301 : {
302 472 : ImplInit( nWinStyle );
303 472 : }
304 :
305 : // -----------------------------------------------------------------------
306 :
307 252 : Ruler::~Ruler()
308 : {
309 126 : if ( mnUpdateEvtId )
310 126 : Application::RemoveUserEvent( mnUpdateEvtId );
311 126 : delete mpSaveData;
312 126 : delete mpDragData;
313 126 : }
314 :
315 : // -----------------------------------------------------------------------
316 :
317 56879 : void Ruler::ImplVDrawLine( long nX1, long nY1, long nX2, long nY2 )
318 : {
319 56879 : if ( nX1 < -RULER_CLIP )
320 : {
321 0 : nX1 = -RULER_CLIP;
322 0 : if ( nX2 < -RULER_CLIP )
323 0 : return;
324 : }
325 56879 : long nClip = mnVirWidth+RULER_CLIP;
326 56879 : if ( nX2 > nClip )
327 : {
328 426 : nX2 = nClip;
329 426 : if ( nX1 > nClip )
330 426 : return;
331 : }
332 :
333 56453 : if ( mnWinStyle & WB_HORZ )
334 32188 : maVirDev.DrawLine( Point( nX1, nY1 ), Point( nX2, nY2 ) );
335 : else
336 24265 : maVirDev.DrawLine( Point( nY1, nX1 ), Point( nY2, nX2 ) );
337 : }
338 :
339 : // -----------------------------------------------------------------------
340 :
341 1002 : void Ruler::ImplVDrawRect( long nX1, long nY1, long nX2, long nY2 )
342 : {
343 1002 : if ( nX1 < -RULER_CLIP )
344 : {
345 0 : nX1 = -RULER_CLIP;
346 0 : if ( nX2 < -RULER_CLIP )
347 0 : return;
348 : }
349 1002 : long nClip = mnVirWidth+RULER_CLIP;
350 1002 : if ( nX2 > nClip )
351 : {
352 18 : nX2 = nClip;
353 18 : if ( nX1 > nClip )
354 9 : return;
355 : }
356 :
357 993 : if ( mnWinStyle & WB_HORZ )
358 452 : maVirDev.DrawRect( Rectangle( nX1, nY1, nX2, nY2 ) );
359 : else
360 541 : maVirDev.DrawRect( Rectangle( nY1, nX1, nY2, nX2 ) );
361 : }
362 :
363 : // -----------------------------------------------------------------------
364 :
365 11566 : void Ruler::ImplVDrawText( long nX, long nY, const String& rText, long nMin, long nMax )
366 : {
367 11566 : Rectangle aRect;
368 11566 : maVirDev.GetTextBoundRect( aRect, rText );
369 :
370 11566 : long nShiftX = ( aRect.GetWidth() / 2 ) + aRect.Left();
371 11566 : long nShiftY = ( aRect.GetHeight() / 2 ) + aRect.Top();
372 :
373 11566 : if ( (nX > -RULER_CLIP) && (nX < mnVirWidth+RULER_CLIP) && ( nX < nMax - nShiftX ) && ( nX > nMin + nShiftX ) )
374 : {
375 5182 : if ( mnWinStyle & WB_HORZ )
376 3047 : maVirDev.DrawText( Point( nX - nShiftX, nY - nShiftY ), rText );
377 : else
378 2135 : maVirDev.DrawText( Point( nY - nShiftX, nX - nShiftY ), rText );
379 : }
380 11566 : }
381 :
382 : // -----------------------------------------------------------------------
383 :
384 2768 : void Ruler::ImplInvertLines( sal_Bool bErase )
385 : {
386 : // Positionslinien
387 2768 : if ( mpData->nLines && mbActive && !mbDrag && !mbFormat &&
388 0 : !(mnUpdateFlags & RULER_UPDATE_LINES) )
389 : {
390 : long n;
391 0 : long nNullWinOff = mpData->nNullVirOff+mnVirOff;
392 0 : long nRulX1 = mpData->nRulVirOff+mnVirOff;
393 0 : long nRulX2 = nRulX1+mpData->nRulWidth;
394 0 : long nY = (RULER_OFF*2)+mnVirHeight-1;
395 :
396 : // Rectangle berechnen
397 0 : Rectangle aRect;
398 0 : if ( mnWinStyle & WB_HORZ )
399 0 : aRect.Bottom() = nY;
400 : else
401 0 : aRect.Right() = nY;
402 :
403 : // Linien ausgeben
404 0 : for ( sal_uInt16 i = 0; i < mpData->nLines; i++ )
405 : {
406 0 : n = mpData->pLines[i].nPos+nNullWinOff;
407 0 : if ( (n >= nRulX1) && (n < nRulX2) )
408 : {
409 0 : if ( mnWinStyle & WB_HORZ )
410 : {
411 0 : aRect.Left() = n;
412 0 : aRect.Right() = n;
413 : }
414 : else
415 : {
416 0 : aRect.Top() = n;
417 0 : aRect.Bottom() = n;
418 : }
419 0 : if ( bErase )
420 : {
421 0 : Rectangle aTempRect = aRect;
422 0 : if ( mnWinStyle & WB_HORZ )
423 0 : aTempRect.Bottom() = RULER_OFF-1;
424 : else
425 0 : aTempRect.Right() = RULER_OFF-1;
426 0 : Erase( aTempRect );
427 0 : if ( mnWinStyle & WB_HORZ )
428 : {
429 0 : aTempRect.Bottom() = aRect.Bottom();
430 0 : aTempRect.Top() = aTempRect.Bottom()-RULER_OFF+1;
431 : }
432 : else
433 : {
434 0 : aTempRect.Right() = aRect.Right();
435 0 : aTempRect.Left() = aTempRect.Right()-RULER_OFF+1;
436 : }
437 0 : Erase( aTempRect );
438 : }
439 0 : Invert( aRect );
440 : }
441 : }
442 : }
443 2768 : }
444 :
445 : // -----------------------------------------------------------------------
446 :
447 962 : void Ruler::ImplDrawTicks( long nMin, long nMax, long nStart, long nCenter )
448 : {
449 962 : long n = 0;
450 962 : long nTick3 = aImplRulerUnitTab[mnUnitIndex].nTick3;
451 962 : long nTickCount = aImplRulerUnitTab[mnUnitIndex].nTick1;
452 962 : Size aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode );
453 : long nTickWidth;
454 962 : sal_Bool bNoTicks = sal_False;
455 :
456 962 : long nTickUnit = 0;
457 962 : long nTick2 = 0;
458 962 : if ( mnUnitIndex == RULER_UNIT_CHAR )
459 : {
460 0 : if ( mnCharWidth == 0 )
461 0 : mnCharWidth = 371;
462 0 : nTick3 = mnCharWidth*2;
463 0 : nTickCount = mnCharWidth;
464 0 : nTickUnit = mnCharWidth;
465 0 : nTick2 = mnCharWidth;
466 : }
467 962 : else if ( mnUnitIndex == RULER_UNIT_LINE )
468 : {
469 0 : if ( mnLineHeight == 0 )
470 0 : mnLineHeight = 551;
471 0 : nTick3 = mnLineHeight*2;
472 0 : nTickCount = mnLineHeight;
473 0 : nTickUnit = mnLineHeight;
474 0 : nTick2 = mnLineHeight;
475 : }
476 962 : aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode );
477 :
478 : // Groessenvorberechnung
479 : // Sizes calculation
480 962 : if ( mnWinStyle & WB_HORZ )
481 433 : nTickWidth = aPixSize.Width();
482 : else
483 : {
484 529 : Font aFont = GetFont();
485 529 : if ( mnWinStyle & WB_RIGHT_ALIGNED )
486 0 : aFont.SetOrientation( 2700 );
487 : else
488 529 : aFont.SetOrientation( 900 );
489 529 : maVirDev.SetFont( aFont );
490 529 : nTickWidth = aPixSize.Height();
491 : }
492 962 : long nMaxWidth = maVirDev.PixelToLogic( Size( mpData->nPageWidth, 0 ), maMapMode ).Width();
493 962 : if ( nMaxWidth < 0 )
494 0 : nMaxWidth = -nMaxWidth;
495 :
496 962 : if (( mnUnitIndex == RULER_UNIT_CHAR ) || ( mnUnitIndex == RULER_UNIT_LINE ))
497 0 : nMaxWidth /= nTickUnit;
498 : else
499 962 : nMaxWidth /= aImplRulerUnitTab[mnUnitIndex].nTickUnit;
500 962 : UniString aNumStr(rtl::OUString::valueOf(static_cast<sal_Int32>(nMaxWidth)));
501 962 : long nTxtWidth = GetTextWidth( aNumStr );
502 962 : const long nTextOff = 4;
503 962 : if ( nTickWidth < nTxtWidth+nTextOff )
504 : {
505 : // Calculate the scale of the ruler
506 0 : long nMulti = 1;
507 0 : long nOrgTick3 = nTick3;
508 0 : while ( nTickWidth < nTxtWidth+nTextOff )
509 : {
510 0 : long nOldMulti = nMulti;
511 0 : if ( !nTickWidth ) //If nTickWidth equals 0
512 0 : nMulti *= 10;
513 0 : else if ( nMulti < 10 )
514 0 : nMulti++;
515 0 : else if ( nMulti < 100 )
516 0 : nMulti += 10;
517 0 : else if ( nMulti < 1000 )
518 0 : nMulti += 100;
519 : else
520 0 : nMulti += 1000;
521 : // Ueberlauf, dann geben wir nichts aus, da wir bei so einem
522 : // unsinnigen Massstab sowieso nichts vernuenftiges anzeigen
523 : // koennen
524 0 : if ( nMulti < nOldMulti )
525 : {
526 0 : bNoTicks = sal_True;
527 0 : break;
528 : }
529 :
530 0 : nTick3 = nOrgTick3 * nMulti;
531 0 : aPixSize = maVirDev.LogicToPixel( Size( nTick3, nTick3 ), maMapMode );
532 0 : if ( mnWinStyle & WB_HORZ )
533 0 : nTickWidth = aPixSize.Width();
534 : else
535 0 : nTickWidth = aPixSize.Height();
536 : }
537 0 : nTickCount = nTick3;
538 : }
539 : else
540 962 : maVirDev.SetLineColor( GetSettings().GetStyleSettings().GetShadowColor() );
541 :
542 962 : if ( !bNoTicks )
543 : {
544 962 : long nTick = 0;
545 64188 : while ( ((nStart-n) >= nMin) || ((nStart+n) <= nMax) )
546 : {
547 : // Null-Punkt
548 62264 : if ( !nTick )
549 : {
550 962 : if ( nStart > nMin )
551 : {
552 : // 0 is only painted when Margin1 is not equal to zero
553 20 : if ( (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || (mpData->nMargin1 != 0) )
554 : {
555 0 : aNumStr = (sal_Unicode)'0';
556 0 : ImplVDrawText( nStart, nCenter, aNumStr );
557 : }
558 : }
559 : }
560 : else
561 : {
562 61302 : aPixSize = maVirDev.LogicToPixel( Size( nTick, nTick ), maMapMode );
563 :
564 61302 : if ( mnWinStyle & WB_HORZ )
565 34641 : n = aPixSize.Width();
566 : else
567 26661 : n = aPixSize.Height();
568 :
569 : // Tick3 - Output (Text)
570 61302 : if ( !(nTick % nTick3) )
571 : {
572 5783 : if ( ( mnUnitIndex == RULER_UNIT_CHAR ) || ( mnUnitIndex == RULER_UNIT_LINE ) )
573 0 : aNumStr = UniString::CreateFromInt32( nTick / nTickUnit );
574 : else
575 5783 : aNumStr = UniString::CreateFromInt32( nTick / aImplRulerUnitTab[mnUnitIndex].nTickUnit );
576 :
577 5783 : ImplVDrawText( nStart + n, nCenter, aNumStr, nMin, nMax );
578 5783 : ImplVDrawText( nStart - n, nCenter, aNumStr, nMin, nMax );
579 : }
580 : // Tick/Tick2 - Output (Strokes)
581 : else
582 : {
583 55519 : if ( ( mnUnitIndex != RULER_UNIT_CHAR ) && ( mnUnitIndex != RULER_UNIT_LINE ) )
584 55519 : nTick2 = aImplRulerUnitTab[mnUnitIndex].nTick2;
585 55519 : if ( !(nTick % nTick2 ) )
586 6158 : nTickWidth = RULER_TICK2_WIDTH;
587 : else
588 49361 : nTickWidth = RULER_TICK1_WIDTH;
589 55519 : long nT1 = nCenter-(nTickWidth/2);
590 55519 : long nT2 = nT1+nTickWidth-1;
591 : long nT;
592 :
593 55519 : nT = nStart+n;
594 55519 : if ( nT < nMax )
595 54642 : ImplVDrawLine( nT, nT1, nT, nT2 );
596 55519 : nT = nStart-n;
597 55519 : if ( nT > nMin )
598 170 : ImplVDrawLine( nT, nT1, nT, nT2 );
599 : }
600 : }
601 : // #i49017# with some zoom factors the value nTick can overflow
602 62264 : if( ((sal_uLong)nTick + (sal_uLong)nTickCount) > (sal_uLong)LONG_MAX)
603 0 : break;
604 62264 : nTick += nTickCount;
605 : }
606 962 : }
607 962 : }
608 :
609 : // -----------------------------------------------------------------------
610 :
611 0 : void Ruler::ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom )
612 : {
613 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
614 : long n;
615 : long n1;
616 : long n2;
617 : long nTemp1;
618 : long nTemp2;
619 : sal_uInt16 i;
620 :
621 0 : for ( i = 0; i < mpData->nBorders; i++ )
622 : {
623 0 : if ( mpData->pBorders[i].nStyle & RULER_STYLE_INVISIBLE )
624 0 : continue;
625 :
626 0 : n1 = mpData->pBorders[i].nPos+mpData->nNullVirOff;
627 0 : n2 = n1+mpData->pBorders[i].nWidth;
628 :
629 0 : if ( ((n1 >= nMin) && (n1 <= nMax)) || ((n2 >= nMin) && (n2 <= nMax)) )
630 : {
631 0 : if ( (n2-n1) > 3 )
632 : {
633 0 : maVirDev.SetLineColor();
634 0 : maVirDev.SetFillColor( rStyleSettings.GetFaceColor() );
635 0 : ImplVDrawRect( n1, nVirTop, n2, nVirBottom );
636 :
637 0 : maVirDev.SetLineColor( rStyleSettings.GetLightColor() );
638 0 : ImplVDrawLine( n1+1, nVirTop, n1+1, nVirBottom );
639 0 : ImplVDrawLine( n1, nVirTop, n2, nVirTop );
640 0 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
641 0 : ImplVDrawLine( n1, nVirTop, n1, nVirBottom );
642 0 : ImplVDrawLine( n1, nVirBottom, n2, nVirBottom );
643 0 : ImplVDrawLine( n2-1, nVirTop, n2-1, nVirBottom );
644 0 : maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() );
645 0 : ImplVDrawLine( n2, nVirTop, n2, nVirBottom );
646 :
647 0 : if ( mpData->pBorders[i].nStyle & RULER_BORDER_VARIABLE )
648 : {
649 0 : if ( n2-n1 > RULER_VAR_SIZE+4 )
650 : {
651 0 : nTemp1 = n1 + (((n2-n1+1)-RULER_VAR_SIZE) / 2);
652 0 : nTemp2 = nVirTop + (((nVirBottom-nVirTop+1)-RULER_VAR_SIZE) / 2);
653 0 : long nTemp3 = nTemp1+RULER_VAR_SIZE-1;
654 0 : long nTemp4 = nTemp2+RULER_VAR_SIZE-1;
655 0 : long nTempY = nTemp2;
656 :
657 0 : maVirDev.SetLineColor( rStyleSettings.GetLightColor() );
658 0 : while ( nTempY <= nTemp4 )
659 : {
660 0 : ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY );
661 0 : nTempY += 2;
662 : }
663 :
664 0 : nTempY = nTemp2+1;
665 0 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
666 0 : while ( nTempY <= nTemp4 )
667 : {
668 0 : ImplVDrawLine( nTemp1, nTempY, nTemp3, nTempY );
669 0 : nTempY += 2;
670 : }
671 : }
672 : }
673 :
674 0 : if ( mpData->pBorders[i].nStyle & RULER_BORDER_SIZEABLE )
675 : {
676 0 : if ( n2-n1 > RULER_VAR_SIZE+10 )
677 : {
678 0 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
679 0 : ImplVDrawLine( n1+4, nVirTop+3, n1+4, nVirBottom-3 );
680 0 : ImplVDrawLine( n2-5, nVirTop+3, n2-5, nVirBottom-3 );
681 0 : maVirDev.SetLineColor( rStyleSettings.GetLightColor() );
682 0 : ImplVDrawLine( n1+5, nVirTop+3, n1+5, nVirBottom-3 );
683 0 : ImplVDrawLine( n2-4, nVirTop+3, n2-4, nVirBottom-3 );
684 : }
685 : }
686 : }
687 : else
688 : {
689 0 : n = n1+((n2-n1)/2);
690 0 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
691 :
692 0 : if ( mpData->pBorders[i].nStyle & RULER_BORDER_SNAP )
693 0 : ImplVDrawLine( n, nVirTop, n, nVirBottom );
694 0 : else if ( mpData->pBorders[i].nStyle & RULER_BORDER_MARGIN )
695 0 : ImplVDrawLine( n, nVirTop, n, nVirBottom );
696 : else
697 : {
698 0 : ImplVDrawLine( n-1, nVirTop, n-1, nVirBottom );
699 0 : ImplVDrawLine( n+1, nVirTop, n+1, nVirBottom );
700 0 : maVirDev.SetLineColor();
701 0 : maVirDev.SetFillColor( rStyleSettings.GetWindowColor() );
702 0 : ImplVDrawRect( n, nVirTop, n, nVirBottom );
703 : }
704 : }
705 : }
706 : }
707 0 : }
708 :
709 : // -----------------------------------------------------------------------
710 :
711 30 : void Ruler::ImplDrawIndent( const Polygon& rPoly, sal_uInt16 nStyle )
712 : {
713 30 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
714 30 : Point aPos1;
715 30 : Point aPos2;
716 :
717 30 : if ( nStyle & RULER_STYLE_INVISIBLE )
718 30 : return;
719 :
720 30 : maVirDev.SetLineColor( rStyleSettings.GetDarkShadowColor() );
721 30 : maVirDev.SetFillColor( rStyleSettings.GetWorkspaceColor() );
722 30 : maVirDev.DrawPolygon( rPoly );
723 : }
724 :
725 : // -----------------------------------------------------------------------
726 :
727 10 : void Ruler::ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom )
728 : {
729 : sal_uInt16 j;
730 : long n;
731 10 : long nIndentHeight = (mnVirHeight/2) - 1;
732 10 : long nIndentWidth2 = nIndentHeight-3;
733 10 : Polygon aPoly( 5 );
734 :
735 60 : for ( j = 0; j < mpData->nIndents; j++ )
736 : {
737 50 : if ( mpData->pIndents[j].nStyle & RULER_STYLE_INVISIBLE )
738 2 : continue;
739 :
740 48 : sal_uInt16 nStyle = mpData->pIndents[j].nStyle;
741 48 : sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE;
742 :
743 48 : n = mpData->pIndents[j].nPos+mpData->nNullVirOff;
744 :
745 48 : if ( (n >= nMin) && (n <= nMax) )
746 : {
747 48 : if(nIndentStyle == RULER_INDENT_BORDER)
748 : {
749 18 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
750 18 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
751 18 : ImplVDrawLine( n, nVirTop+1, n, nVirBottom-1 );
752 : }
753 30 : else if ( nIndentStyle == RULER_INDENT_BOTTOM )
754 : {
755 20 : aPoly.SetPoint( Point( n+0, nVirBottom-nIndentHeight ), 0 );
756 20 : aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom-3 ), 1 );
757 20 : aPoly.SetPoint( Point( n-nIndentWidth2, nVirBottom ), 2 );
758 20 : aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom ), 3 );
759 20 : aPoly.SetPoint( Point( n+nIndentWidth2, nVirBottom-3 ), 4 );
760 : }
761 : else
762 : {
763 10 : aPoly.SetPoint( Point( n+0, nVirTop+nIndentHeight ), 0 );
764 10 : aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop+3 ), 1 );
765 10 : aPoly.SetPoint( Point( n-nIndentWidth2, nVirTop ), 2 );
766 10 : aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop ), 3 );
767 10 : aPoly.SetPoint( Point( n+nIndentWidth2, nVirTop+3 ), 4 );
768 : }
769 :
770 48 : if(0 == (mnWinStyle & WB_HORZ))
771 : {
772 0 : Point aTmp;
773 0 : for(sal_uInt16 i = 0; i < 5; i++)
774 : {
775 0 : aTmp = aPoly[i];
776 0 : Point aSet(nVirBottom - aTmp.Y(), aTmp.X());
777 0 : aPoly[i] = aSet;
778 : }
779 : }
780 48 : if(RULER_INDENT_BORDER != nIndentStyle)
781 30 : ImplDrawIndent( aPoly, nStyle );
782 : }
783 10 : }
784 10 : }
785 :
786 : // -----------------------------------------------------------------------
787 :
788 845 : static void ImplCenterTabPos( Point& rPos, sal_uInt16 nTabStyle )
789 : {
790 845 : sal_Bool bRTL = 0 != (nTabStyle & RULER_TAB_RTL);
791 845 : nTabStyle &= RULER_TAB_STYLE;
792 845 : rPos.Y() += RULER_TAB_HEIGHT/2;
793 845 : if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT))
794 845 : rPos.X() -= RULER_TAB_WIDTH/2;
795 0 : else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT))
796 0 : rPos.X() += RULER_TAB_WIDTH/2;
797 845 : }
798 :
799 : // -----------------------------------------------------------------------
800 1284 : static void lcl_RotateRect_Impl(Rectangle& rRect, const long nReference, sal_Bool bRightAligned)
801 : {
802 1284 : if(!rRect.IsEmpty())
803 : {
804 856 : Rectangle aTmp(rRect);
805 856 : rRect.Top() = aTmp.Left();
806 856 : rRect.Bottom() = aTmp.Right();
807 856 : rRect.Left() = aTmp.Top();
808 856 : rRect.Right() = aTmp.Bottom();
809 856 : if(bRightAligned)
810 : {
811 0 : long nRef = 2 * nReference;
812 0 : rRect.Left() = nRef - rRect.Left();
813 0 : rRect.Right() = nRef - rRect.Right();
814 : }
815 : }
816 1284 : }
817 : // -----------------------------------------------------------------------
818 :
819 966 : static void ImplDrawRulerTab( OutputDevice* pDevice,
820 : const Point& rPos, sal_uInt16 nStyle, WinBits nWinBits )
821 : {
822 966 : if ( nStyle & RULER_STYLE_INVISIBLE )
823 966 : return;
824 :
825 966 : sal_uInt16 nTabStyle = nStyle & RULER_TAB_STYLE;
826 966 : sal_Bool bRTL = 0 != (nStyle & RULER_TAB_RTL);
827 966 : Rectangle aRect1, aRect2, aRect3;
828 966 : aRect3.SetEmpty();
829 966 : if ( nTabStyle == RULER_TAB_DEFAULT )
830 : {
831 120 : aRect1.Left() = rPos.X() - RULER_TAB_DWIDTH2 + 1 ;
832 120 : aRect1.Top() = rPos.Y() - RULER_TAB_DHEIGHT2 + 1 ;
833 120 : aRect1.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH ;
834 120 : aRect1.Bottom() = rPos.Y();
835 120 : aRect2.Left() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3;
836 120 : aRect2.Top() = rPos.Y() - RULER_TAB_DHEIGHT + 1;
837 120 : aRect2.Right() = rPos.X() - RULER_TAB_DWIDTH2 + RULER_TAB_DWIDTH3 + RULER_TAB_DWIDTH4 - 1;
838 120 : aRect2.Bottom() = rPos.Y();
839 :
840 : }
841 846 : else if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||( bRTL && nTabStyle == RULER_TAB_RIGHT))
842 : {
843 846 : aRect1.Left() = rPos.X();
844 846 : aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1;
845 846 : aRect1.Right() = rPos.X() + RULER_TAB_WIDTH - 1;
846 846 : aRect1.Bottom() = rPos.Y();
847 846 : aRect2.Left() = rPos.X();
848 846 : aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1;
849 846 : aRect2.Right() = rPos.X() + RULER_TAB_WIDTH2 - 1;
850 846 : aRect2.Bottom() = rPos.Y();
851 : }
852 0 : else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||( bRTL && nTabStyle == RULER_TAB_LEFT))
853 : {
854 0 : aRect1.Left() = rPos.X() - RULER_TAB_WIDTH + 1;
855 0 : aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1;
856 0 : aRect1.Right() = rPos.X();
857 0 : aRect1.Bottom() = rPos.Y();
858 0 : aRect2.Left() = rPos.X() - RULER_TAB_WIDTH2 + 1;
859 0 : aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1;
860 0 : aRect2.Right() = rPos.X();
861 0 : aRect2.Bottom() = rPos.Y();
862 : }
863 : else
864 : {
865 0 : aRect1.Left() = rPos.X() - RULER_TAB_CWIDTH2 + 1;
866 0 : aRect1.Top() = rPos.Y() - RULER_TAB_HEIGHT2 + 1;
867 0 : aRect1.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH;
868 0 : aRect1.Bottom() = rPos.Y();
869 0 : aRect2.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3;
870 0 : aRect2.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1;
871 0 : aRect2.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH3 + RULER_TAB_CWIDTH4 - 1;
872 0 : aRect2.Bottom() = rPos.Y();
873 :
874 0 : if ( nTabStyle == RULER_TAB_DECIMAL )
875 : {
876 0 : aRect3.Left() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH - 1;
877 0 : aRect3.Top() = rPos.Y() - RULER_TAB_HEIGHT + 1 + 1;
878 0 : aRect3.Right() = rPos.X() - RULER_TAB_CWIDTH2 + RULER_TAB_CWIDTH;
879 0 : aRect3.Bottom()= rPos.Y() - RULER_TAB_HEIGHT + 1 + 2 ;
880 : }
881 : }
882 966 : if( 0 == (nWinBits&WB_HORZ) )
883 : {
884 428 : sal_Bool bRightAligned = 0 != (nWinBits&WB_RIGHT_ALIGNED);
885 428 : lcl_RotateRect_Impl(aRect1, rPos.Y(), bRightAligned);
886 428 : lcl_RotateRect_Impl(aRect2, rPos.Y(), bRightAligned);
887 428 : lcl_RotateRect_Impl(aRect3, rPos.Y(), bRightAligned);
888 : }
889 966 : pDevice->DrawRect( aRect1 );
890 966 : pDevice->DrawRect( aRect2 );
891 966 : if(!aRect2.IsEmpty())
892 966 : pDevice->DrawRect( aRect3 );
893 :
894 : }
895 :
896 : // -----------------------------------------------------------------------
897 :
898 966 : void Ruler::ImplDrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle )
899 : {
900 966 : if ( nStyle & RULER_STYLE_INVISIBLE )
901 966 : return;
902 :
903 966 : pDevice->SetLineColor();
904 966 : if ( nStyle & RULER_STYLE_DONTKNOW )
905 0 : pDevice->SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() );
906 : else
907 966 : pDevice->SetFillColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
908 :
909 966 : if(mpData->bTextRTL)
910 0 : nStyle |= RULER_TAB_RTL;
911 966 : ImplDrawRulerTab( pDevice, rPos, nStyle, GetStyle());
912 : }
913 :
914 : // -----------------------------------------------------------------------
915 :
916 10 : void Ruler::ImplDrawTabs( long nMin, long nMax, long nVirTop, long nVirBottom )
917 : {
918 131 : for ( sal_uInt16 i = 0; i < mpData->nTabs; i++ )
919 : {
920 121 : if ( mpData->pTabs[i].nStyle & RULER_STYLE_INVISIBLE )
921 0 : continue;
922 :
923 : long n;
924 121 : n = mpData->pTabs[i].nPos;
925 121 : n += +mpData->nNullVirOff;
926 121 : long nTopBottom = GetStyle() & WB_RIGHT_ALIGNED ? nVirTop : nVirBottom;
927 121 : if ( (n >= nMin) && (n <= nMax) )
928 121 : ImplDrawTab( &maVirDev, Point( n, nTopBottom ), mpData->pTabs[i].nStyle );
929 : }
930 10 : }
931 :
932 : // -----------------------------------------------------------------------
933 :
934 472 : void Ruler::ImplInitSettings( sal_Bool bFont,
935 : sal_Bool bForeground, sal_Bool bBackground )
936 : {
937 472 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
938 :
939 472 : if ( bFont )
940 : {
941 472 : Font aFont;
942 472 : aFont = rStyleSettings.GetToolFont();
943 472 : if ( IsControlFont() )
944 0 : aFont.Merge( GetControlFont() );
945 472 : SetZoomedPointFont( aFont );
946 : }
947 :
948 472 : if ( bForeground || bFont )
949 : {
950 472 : Color aColor;
951 472 : if ( IsControlForeground() )
952 0 : aColor = GetControlForeground();
953 : else
954 472 : aColor = rStyleSettings.GetDarkShadowColor();
955 472 : SetTextColor( aColor );
956 472 : SetTextFillColor();
957 : }
958 :
959 472 : if ( bBackground )
960 : {
961 472 : Color aColor;
962 472 : if ( IsControlBackground() )
963 0 : aColor = GetControlBackground();
964 : else
965 472 : aColor = rStyleSettings.GetWorkspaceColor();
966 472 : SetBackground( aColor );
967 : }
968 :
969 472 : maVirDev.SetSettings( GetSettings() );
970 472 : maVirDev.SetBackground( GetBackground() );
971 472 : Font aFont = GetFont();
972 472 : if ( mnWinStyle & WB_VERT )
973 236 : aFont.SetOrientation( 900 );
974 472 : maVirDev.SetFont( aFont );
975 472 : maVirDev.SetTextColor( GetTextColor() );
976 472 : maVirDev.SetTextFillColor( GetTextFillColor() );
977 472 : }
978 :
979 : // -----------------------------------------------------------------------
980 :
981 1246 : void Ruler::ImplCalc()
982 : {
983 : // Offset berechnen
984 1246 : mpData->nRulVirOff = mnWinOff + mpData->nPageOff;
985 1246 : if ( mpData->nRulVirOff > mnVirOff )
986 585 : mpData->nRulVirOff -= mnVirOff;
987 : else
988 661 : mpData->nRulVirOff = 0;
989 1246 : long nRulWinOff = mpData->nRulVirOff+mnVirOff;
990 :
991 : // Nicht sichtbaren Bereich der Page berechnen
992 : long nNotVisPageWidth;
993 1246 : if ( mpData->nPageOff < 0 )
994 : {
995 0 : nNotVisPageWidth = -(mpData->nPageOff);
996 0 : if ( nRulWinOff < mnWinOff )
997 0 : nNotVisPageWidth -= mnWinOff-nRulWinOff;
998 : }
999 : else
1000 1246 : nNotVisPageWidth = 0;
1001 :
1002 : // Breite berechnen
1003 1246 : if ( mnWinStyle & WB_HORZ )
1004 : {
1005 575 : if ( mbAutoWinWidth )
1006 575 : mnWinWidth = mnWidth - mnVirOff;
1007 575 : if ( mpData->bAutoPageWidth )
1008 565 : mpData->nPageWidth = mnWinWidth;
1009 575 : mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth );
1010 575 : if ( nRulWinOff+mpData->nRulWidth > mnWidth )
1011 571 : mpData->nRulWidth = mnWidth-nRulWinOff;
1012 : }
1013 : else
1014 : {
1015 671 : if ( mbAutoWinWidth )
1016 671 : mnWinWidth = mnHeight - mnVirOff;
1017 671 : if ( mpData->bAutoPageWidth )
1018 661 : mpData->nPageWidth = mnWinWidth;
1019 671 : mpData->nRulWidth = Min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth );
1020 671 : if ( nRulWinOff+mpData->nRulWidth > mnHeight )
1021 9 : mpData->nRulWidth = mnHeight-nRulWinOff;
1022 : }
1023 :
1024 1246 : mbCalc = sal_False;
1025 1246 : }
1026 :
1027 : // -----------------------------------------------------------------------
1028 :
1029 1434 : void Ruler::ImplFormat()
1030 : {
1031 : // Wenn schon formatiert ist, brauchen wir es nicht nochmal
1032 1434 : if ( !mbFormat )
1033 : return;
1034 :
1035 : // Wenn Fenster noch keine Groesse hat, brauchen wir noch nichts machen
1036 1434 : if ( !mnVirWidth )
1037 : return;
1038 :
1039 1246 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1040 : long nP1; // Pixel-Position von Page1
1041 : long nP2; // Pixel-Position von Page2
1042 : long nM1; // Pixel-Position von Margin1
1043 : long nM2; // Pixel-Position von Margin2
1044 : long nVirTop; // Obere/Linke-Kante bei Ausgabe
1045 : long nVirBottom; // Untere/Rechte-Kante bei Ausgabe
1046 : long nVirLeft; // Linke/Obere-Kante bei Ausgabe
1047 : long nVirRight; // Rechte/Untere-Kante bei Ausgabe
1048 : long nNullVirOff; // Fuer schnellere Berechnung
1049 :
1050 : // Werte berechnen
1051 1246 : if ( mbCalc )
1052 1246 : ImplCalc();
1053 1246 : mpData->nNullVirOff = mnWinOff+mpData->nPageOff+mpData->nNullOff-mnVirOff;
1054 1246 : nNullVirOff = mpData->nNullVirOff;
1055 1246 : nVirLeft = mpData->nRulVirOff;
1056 1246 : nVirRight = nVirLeft+mpData->nRulWidth-1;
1057 1246 : nVirTop = 0;
1058 1246 : nVirBottom = mnVirHeight-1;
1059 :
1060 1246 : if ( !IsReallyVisible() )
1061 : return;
1062 :
1063 962 : Size aVirDevSize;
1064 :
1065 : // initialize VirtualDevice
1066 962 : if ( mnWinStyle & WB_HORZ )
1067 : {
1068 433 : aVirDevSize.Width() = mnVirWidth;
1069 433 : aVirDevSize.Height() = mnVirHeight;
1070 : }
1071 : else
1072 : {
1073 529 : aVirDevSize.Height() = mnVirWidth;
1074 529 : aVirDevSize.Width() = mnVirHeight;
1075 : }
1076 962 : if ( aVirDevSize != maVirDev.GetOutputSizePixel() )
1077 575 : maVirDev.SetOutputSizePixel( aVirDevSize, sal_True );
1078 : else
1079 387 : maVirDev.Erase();
1080 :
1081 : // Raender berechnen
1082 962 : if ( !(mpData->nMargin1Style & RULER_STYLE_INVISIBLE) )
1083 : {
1084 20 : nM1 = mpData->nMargin1+nNullVirOff;
1085 20 : if ( mpData->bAutoPageWidth )
1086 : {
1087 0 : nP1 = nVirLeft;
1088 0 : if ( nM1 < nVirLeft )
1089 0 : nP1--;
1090 : }
1091 : else
1092 20 : nP1 = nNullVirOff-mpData->nNullOff;
1093 : }
1094 : else
1095 : {
1096 942 : nM1 = nVirLeft-1;
1097 942 : nP1 = nM1;
1098 : }
1099 962 : if ( !(mpData->nMargin2Style & RULER_STYLE_INVISIBLE) )
1100 : {
1101 20 : nM2 = mpData->nMargin2+nNullVirOff;
1102 20 : if ( mpData->bAutoPageWidth )
1103 : {
1104 0 : nP2 = nVirRight;
1105 0 : if ( nM2 > nVirRight )
1106 0 : nP2++;
1107 : }
1108 : else
1109 20 : nP2 = nNullVirOff-mpData->nNullOff+mpData->nPageWidth;
1110 20 : if ( nM2 > nP2 )
1111 0 : nM2 = nP2;
1112 : }
1113 : else
1114 : {
1115 942 : nM2 = nVirRight+1;
1116 942 : nP2 = nM2;
1117 : }
1118 :
1119 : // Obere/untere Kante ausgeben
1120 962 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
1121 962 : ImplVDrawLine( nVirLeft, nVirTop+1, nM1, nVirTop+1 ); //top left line
1122 962 : ImplVDrawLine( nM2, nVirTop+1, nP2 -1, nVirTop+1 ); //top right line
1123 :
1124 : // Jetzt wird zwischen dem Schatten ausgegeben
1125 962 : nVirTop++;
1126 962 : nVirBottom--;
1127 :
1128 : // Margin1, Margin2 und Zwischenraum ausgeben
1129 962 : maVirDev.SetLineColor();
1130 962 : maVirDev.SetFillColor( rStyleSettings.GetWorkspaceColor() );
1131 962 : if ( nM1 > nVirLeft )
1132 20 : ImplVDrawRect( nP1, nVirTop+1, nM1, nVirBottom ); //left gray rectangle
1133 962 : if ( nM2 < nP2 )
1134 20 : ImplVDrawRect( nM2, nVirTop+1, nP2, nVirBottom ); //right gray rectangle
1135 962 : if ( nM2-nM1 > 0 )
1136 : {
1137 962 : maVirDev.SetFillColor( rStyleSettings.GetWindowColor() );
1138 962 : ImplVDrawRect( nM1+1, nVirTop, nM2-1, nVirBottom ); //center rectangle
1139 : }
1140 962 : maVirDev.SetLineColor( rStyleSettings.GetShadowColor() );
1141 962 : if ( nM1 > nVirLeft )
1142 : {
1143 20 : ImplVDrawLine( nM1, nVirTop+1, nM1, nVirBottom );//right line of the left rectangle
1144 20 : ImplVDrawLine( nP1, nVirBottom, nM1, nVirBottom );//bottom line of the left rectangle
1145 20 : if ( nP1 >= nVirLeft )
1146 : {
1147 20 : ImplVDrawLine( nP1, nVirTop+1, nP1, nVirBottom );//left line of the left rectangle
1148 20 : ImplVDrawLine( nP1, nVirBottom, nP1+1, nVirBottom );//?
1149 : }
1150 : }
1151 962 : if ( nM2 < nP2 )
1152 : {
1153 20 : ImplVDrawLine( nM2, nVirBottom, nP2-1, nVirBottom );//bottom line of the right rectangle
1154 20 : ImplVDrawLine( nM2, nVirTop+1, nM2, nVirBottom );//left line of the right rectangle
1155 20 : if ( nP2 <= nVirRight+1 )
1156 5 : ImplVDrawLine( nP2-1, nVirTop+1, nP2-1, nVirBottom );//right line of the right rectangle
1157 : }
1158 :
1159 : // Lineal-Beschriftung (nur wenn keine Bemassungspfeile)
1160 962 : long nMin = nVirLeft;
1161 962 : long nMax = nP2;
1162 962 : long nStart = mpData->bTextRTL ? mpData->nMargin2 + nNullVirOff : nNullVirOff;
1163 962 : long nCenter = nVirTop+((nVirBottom-nVirTop)/2);
1164 :
1165 : // Nicht Schatten uebermalen
1166 962 : if ( nP1 > nVirLeft )
1167 0 : nMin++;
1168 962 : if ( nP2 < nVirRight )
1169 0 : nMax--;
1170 :
1171 : // Draw captions
1172 962 : ImplDrawTicks( nMin, nMax, nStart, nCenter );
1173 :
1174 : // Draw borders
1175 962 : if ( mpData->pBorders )
1176 0 : ImplDrawBorders( nVirLeft, nP2, nVirTop, nVirBottom );
1177 :
1178 : // Draw indents
1179 962 : if ( mpData->pIndents )
1180 10 : ImplDrawIndents( nVirLeft, nP2, nVirTop-1, nVirBottom+1 );
1181 :
1182 : // Tabs
1183 962 : if ( mpData->pTabs )
1184 : {
1185 10 : ImplDrawTabs( nVirLeft, nP2, nVirTop-1, nVirBottom+1 );
1186 : }
1187 :
1188 : // Wir haben formatiert
1189 962 : mbFormat = sal_False;
1190 : }
1191 :
1192 : // -----------------------------------------------------------------------
1193 :
1194 1238 : void Ruler::ImplInitExtraField( sal_Bool bUpdate )
1195 : {
1196 1238 : Size aWinSize = GetOutputSizePixel();
1197 :
1198 : // Extra-Field beruecksichtigen
1199 1238 : if ( mnWinStyle & WB_EXTRAFIELD )
1200 : {
1201 1137 : maExtraRect.Left() = RULER_OFF;
1202 1137 : maExtraRect.Top() = RULER_OFF;
1203 1137 : maExtraRect.Right() = RULER_OFF+mnVirHeight-1;
1204 1137 : maExtraRect.Bottom() = RULER_OFF+mnVirHeight-1;
1205 1137 : if(mpData->bTextRTL)
1206 : {
1207 0 : if(mnWinStyle & WB_HORZ)
1208 0 : maExtraRect.Move(aWinSize.Width() - maExtraRect.GetWidth() - maExtraRect.Left(), 0);
1209 : else
1210 0 : maExtraRect.Move(0, aWinSize.Height() - maExtraRect.GetHeight() - maExtraRect.Top());
1211 0 : mnVirOff = 0;
1212 : }
1213 : else
1214 1137 : mnVirOff = maExtraRect.Right()+1;
1215 :
1216 : }
1217 : else
1218 : {
1219 101 : maExtraRect.SetEmpty();
1220 101 : mnVirOff = 0;
1221 : }
1222 :
1223 : // mnVirWidth depends on mnVirOff
1224 2690 : if ( (mnVirWidth > RULER_MIN_SIZE) ||
1225 1452 : ((aWinSize.Width() > RULER_MIN_SIZE) && (aWinSize.Height() > RULER_MIN_SIZE)) )
1226 : {
1227 766 : if ( mnWinStyle & WB_HORZ )
1228 188 : mnVirWidth = aWinSize.Width()-mnVirOff;
1229 : else
1230 578 : mnVirWidth = aWinSize.Height()-mnVirOff;
1231 :
1232 766 : if ( mnVirWidth < RULER_MIN_SIZE )
1233 0 : mnVirWidth = 0;
1234 : }
1235 :
1236 1238 : if ( bUpdate )
1237 : {
1238 101 : mbCalc = sal_True;
1239 101 : mbFormat = sal_True;
1240 101 : Invalidate();
1241 : }
1242 1238 : }
1243 :
1244 : // -----------------------------------------------------------------------
1245 :
1246 1170 : void Ruler::ImplDraw()
1247 : {
1248 1170 : if ( mbFormat )
1249 962 : ImplFormat();
1250 :
1251 1170 : if ( IsReallyVisible() )
1252 : {
1253 : // Lineal ueber das VirtualDevice ausgeben
1254 1170 : Point aOffPos;
1255 1170 : Size aVirDevSize = maVirDev.GetOutputSizePixel();
1256 : // Size aVirDevSize2 = maVirDev.GetOutputSizePixel();
1257 1170 : if ( mnWinStyle & WB_HORZ )
1258 : {
1259 529 : aOffPos.X() = mnVirOff;
1260 529 : if(mpData->bTextRTL)
1261 0 : aVirDevSize.Width() -= maExtraRect.GetWidth();
1262 :
1263 : // else
1264 : // aVirDevSize.Width() -= mnVirOff;
1265 529 : aOffPos.Y() = RULER_OFF;
1266 : }
1267 : else
1268 : {
1269 641 : aOffPos.X() = RULER_OFF;
1270 641 : aOffPos.Y() = mnVirOff;
1271 : // else
1272 : // aVirDevSize.Height() -= mnVirOff;
1273 : }
1274 1170 : DrawOutDev( aOffPos, aVirDevSize, Point(), aVirDevSize, maVirDev );
1275 :
1276 : // Positionslinien neu malen
1277 1170 : ImplInvertLines( sal_True );
1278 : }
1279 1170 : }
1280 :
1281 : // -----------------------------------------------------------------------
1282 :
1283 845 : void Ruler::ImplDrawExtra( sal_Bool bPaint )
1284 : {
1285 845 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1286 845 : Rectangle aRect = maExtraRect;
1287 845 : sal_Bool bEraseRect = sal_False;
1288 :
1289 845 : aRect.Left() += 2;
1290 845 : aRect.Top() += 2;
1291 845 : aRect.Right() -= 2;
1292 845 : aRect.Bottom() -= 2;
1293 :
1294 845 : if ( !bPaint && !(mnExtraStyle & RULER_STYLE_HIGHLIGHT) )
1295 : {
1296 0 : SetFillColor( rStyleSettings.GetWorkspaceColor() );
1297 0 : bEraseRect = sal_True;
1298 : }
1299 : else
1300 : {
1301 845 : if ( mnExtraStyle & RULER_STYLE_HIGHLIGHT )
1302 : {
1303 0 : SetFillColor( rStyleSettings.GetCheckedColor() );
1304 0 : bEraseRect = sal_True;
1305 : }
1306 : }
1307 :
1308 845 : if ( bEraseRect )
1309 : {
1310 0 : SetLineColor();
1311 0 : DrawRect( aRect );
1312 : }
1313 :
1314 : // Inhalt ausgeben
1315 845 : if ( meExtraType == RULER_EXTRA_NULLOFFSET )
1316 : {
1317 0 : SetLineColor( rStyleSettings.GetButtonTextColor() );
1318 0 : DrawLine( Point( aRect.Left()+1, aRect.Top()+4 ),
1319 0 : Point( aRect.Right()-1, aRect.Top()+4 ) );
1320 0 : DrawLine( Point( aRect.Left()+4, aRect.Top()+1 ),
1321 0 : Point( aRect.Left()+4, aRect.Bottom()-1 ) );
1322 : }
1323 845 : else if ( meExtraType == RULER_EXTRA_TAB )
1324 : {
1325 845 : sal_uInt16 nTabStyle = mnExtraStyle & RULER_TAB_STYLE;
1326 845 : if(mpData->bTextRTL)
1327 0 : nTabStyle |= RULER_TAB_RTL;
1328 845 : Point aCenter = aRect.Center();
1329 845 : Point aDraw(aCenter);
1330 845 : ImplCenterTabPos( aDraw, nTabStyle );
1331 845 : WinBits nWinBits = GetStyle();
1332 845 : if(0 == (nWinBits&WB_HORZ) )
1333 : {
1334 428 : if(0 != (nWinBits&WB_RIGHT_ALIGNED))
1335 0 : aDraw.Y() = 2 * aCenter.Y() - aDraw.Y();
1336 428 : if(mpData->bTextRTL)
1337 : {
1338 0 : long nTemp = aDraw.X();
1339 0 : aDraw.X() = aDraw.Y();
1340 0 : aDraw.Y() = nTemp;
1341 : }
1342 : }
1343 845 : ImplDrawTab( this, aDraw, nTabStyle );
1344 : }
1345 845 : }
1346 :
1347 : // -----------------------------------------------------------------------
1348 :
1349 3169 : void Ruler::ImplUpdate( sal_Bool bMustCalc )
1350 : {
1351 : // Hier schon Linien loeschen, damit Sie vor dem Neuberechnen schon
1352 : // geloscht sind, da danach die alten Positionen nicht mehr bestimmt
1353 : // werden koennen
1354 3169 : if ( !mbFormat )
1355 610 : ImplInvertLines();
1356 :
1357 : // Flags setzen
1358 3169 : if ( bMustCalc )
1359 1755 : mbCalc = sal_True;
1360 3169 : mbFormat = sal_True;
1361 :
1362 : // Wenn wir am Draggen sind, wird nach dem Drag-Handler automatisch
1363 : // das Lineal neu upgedatet
1364 3169 : if ( mbDrag )
1365 3169 : return;
1366 :
1367 : // Gegebenenfalls Update ausloesen
1368 3169 : if ( IsReallyVisible() && IsUpdateMode() )
1369 : {
1370 1300 : mnUpdateFlags |= RULER_UPDATE_DRAW;
1371 1300 : if ( !mnUpdateEvtId )
1372 21 : mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL );
1373 : }
1374 : }
1375 :
1376 : // -----------------------------------------------------------------------
1377 :
1378 0 : sal_Bool Ruler::ImplHitTest( const Point& rPos, ImplRulerHitTest* pHitTest,
1379 : sal_Bool bRequireStyle, sal_uInt16 nRequiredStyle ) const
1380 : {
1381 : sal_uInt16 i;
1382 : sal_uInt16 nStyle;
1383 : long nHitBottom;
1384 : long nX;
1385 : long nY;
1386 : long n1;
1387 : long n2;
1388 :
1389 0 : if ( !mbActive )
1390 0 : return sal_False;
1391 :
1392 : // Position ermitteln
1393 0 : sal_Bool bIsHori = 0 != (mnWinStyle & WB_HORZ);
1394 0 : if ( bIsHori )
1395 : {
1396 0 : nX = rPos.X();
1397 0 : nY = rPos.Y();
1398 : }
1399 : else
1400 : {
1401 0 : nX = rPos.Y();
1402 0 : nY = rPos.X();
1403 : }
1404 0 : nHitBottom = mnVirHeight+(RULER_OFF*2);
1405 :
1406 : // #i32608#
1407 0 : pHitTest->nAryPos = 0;
1408 0 : pHitTest->mnDragSize = 0;
1409 0 : pHitTest->bSize = sal_False;
1410 0 : pHitTest->bSizeBar = sal_False;
1411 :
1412 : // Damit ueberstehende Tabs und Einzuege mit beruecksichtigt werden
1413 : long nXExtraOff;
1414 0 : if ( mpData->pTabs || mpData->pIndents )
1415 0 : nXExtraOff = (mnVirHeight/2) - 4;
1416 : else
1417 0 : nXExtraOff = 0;
1418 :
1419 : // Test auf ausserhalb
1420 0 : nX -= mnVirOff;
1421 0 : long nXTemp = nX;
1422 0 : if ( (nX < mpData->nRulVirOff-nXExtraOff) || (nX > mpData->nRulVirOff+mpData->nRulWidth+nXExtraOff) ||
1423 : (nY < 0) || (nY > nHitBottom) )
1424 : {
1425 0 : pHitTest->nPos = 0;
1426 0 : pHitTest->eType = RULER_TYPE_OUTSIDE;
1427 0 : return sal_False;
1428 : }
1429 :
1430 0 : nX -= mpData->nNullVirOff;
1431 0 : pHitTest->nPos = nX;
1432 0 : pHitTest->eType = RULER_TYPE_DONTKNOW;
1433 :
1434 : // Zuerst die Tabs testen
1435 0 : Rectangle aRect;
1436 0 : if ( mpData->pTabs )
1437 : {
1438 0 : aRect.Bottom() = nHitBottom;
1439 0 : aRect.Top() = aRect.Bottom()-RULER_TAB_HEIGHT-RULER_OFF;
1440 :
1441 0 : for ( i = mpData->nTabs; i; i-- )
1442 : {
1443 0 : nStyle = mpData->pTabs[i-1].nStyle;
1444 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1445 : {
1446 0 : nStyle &= RULER_TAB_STYLE;
1447 :
1448 : // Default-Tabs werden nur angezeigt
1449 0 : if ( nStyle != RULER_TAB_DEFAULT )
1450 : {
1451 0 : n1 = mpData->pTabs[i-1].nPos;
1452 :
1453 0 : if ( nStyle == RULER_TAB_LEFT )
1454 : {
1455 0 : aRect.Left() = n1;
1456 0 : aRect.Right() = n1+RULER_TAB_WIDTH-1;
1457 : }
1458 0 : else if ( nStyle == RULER_TAB_RIGHT )
1459 : {
1460 0 : aRect.Right() = n1;
1461 0 : aRect.Left() = n1-RULER_TAB_WIDTH-1;
1462 : }
1463 : else
1464 : {
1465 0 : aRect.Left() = n1-RULER_TAB_CWIDTH2+1;
1466 0 : aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH;
1467 : }
1468 :
1469 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1470 : {
1471 0 : pHitTest->eType = RULER_TYPE_TAB;
1472 0 : pHitTest->nAryPos = i-1;
1473 0 : return sal_True;
1474 : }
1475 : }
1476 : }
1477 : }
1478 : }
1479 :
1480 : // Dann die Einzuege
1481 0 : if ( mpData->pIndents )
1482 : {
1483 0 : long nIndentHeight = (mnVirHeight/2) - 1;
1484 0 : long nIndentWidth2 = nIndentHeight-3;
1485 :
1486 0 : for ( i = mpData->nIndents; i; i-- )
1487 : {
1488 0 : nStyle = mpData->pIndents[i-1].nStyle;
1489 0 : if ( (! bRequireStyle || nStyle == nRequiredStyle) &&
1490 0 : !(nStyle & RULER_STYLE_INVISIBLE) )
1491 : {
1492 0 : nStyle &= RULER_INDENT_STYLE;
1493 0 : n1 = mpData->pIndents[i-1].nPos;
1494 :
1495 0 : if ( (nStyle == RULER_INDENT_BOTTOM) ^ (!bIsHori) )
1496 : {
1497 0 : aRect.Left() = n1-nIndentWidth2;
1498 0 : aRect.Right() = n1+nIndentWidth2;
1499 0 : aRect.Top() = nHitBottom-nIndentHeight-RULER_OFF+1;
1500 0 : aRect.Bottom() = nHitBottom;
1501 : }
1502 : else
1503 : {
1504 0 : aRect.Left() = n1-nIndentWidth2;
1505 0 : aRect.Right() = n1+nIndentWidth2;
1506 0 : aRect.Top() = 0;
1507 0 : aRect.Bottom() = nIndentHeight+RULER_OFF-1;
1508 : }
1509 :
1510 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1511 : {
1512 0 : pHitTest->eType = RULER_TYPE_INDENT;
1513 0 : pHitTest->nAryPos = i-1;
1514 0 : return sal_True;
1515 : }
1516 : }
1517 : }
1518 : }
1519 :
1520 : // Jetzt zaehlt nichts mehr, was links oder rechts uebersteht
1521 0 : if ( (nXTemp < mpData->nRulVirOff) || (nXTemp > mpData->nRulVirOff+mpData->nRulWidth) )
1522 : {
1523 0 : pHitTest->nPos = 0;
1524 0 : pHitTest->eType = RULER_TYPE_OUTSIDE;
1525 0 : return sal_False;
1526 : }
1527 :
1528 : // Danach die Spalten testen
1529 0 : int nBorderTolerance = 1;
1530 0 : if(pHitTest->bExpandTest)
1531 : {
1532 0 : nBorderTolerance++;
1533 : }
1534 :
1535 0 : for ( i = mpData->nBorders; i; i-- )
1536 : {
1537 0 : n1 = mpData->pBorders[i-1].nPos;
1538 0 : n2 = n1 + mpData->pBorders[i-1].nWidth;
1539 :
1540 : // Spalten werden mit mindestens 3 Pixel breite gezeichnet
1541 0 : if ( !mpData->pBorders[i-1].nWidth )
1542 : {
1543 0 : n1 -= nBorderTolerance;
1544 0 : n2 += nBorderTolerance;
1545 :
1546 : }
1547 :
1548 0 : if ( (nX >= n1) && (nX <= n2) )
1549 : {
1550 0 : nStyle = mpData->pBorders[i-1].nStyle;
1551 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1552 : {
1553 0 : pHitTest->eType = RULER_TYPE_BORDER;
1554 0 : pHitTest->nAryPos = i-1;
1555 :
1556 0 : if ( !(nStyle & RULER_BORDER_SIZEABLE) )
1557 : {
1558 0 : if ( nStyle & RULER_BORDER_MOVEABLE )
1559 : {
1560 0 : pHitTest->bSizeBar = sal_True;
1561 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE;
1562 : }
1563 : }
1564 : else
1565 : {
1566 0 : long nMOff = RULER_MOUSE_BORDERWIDTH;
1567 0 : while ( nMOff*2 >= (n2-n1-RULER_MOUSE_BORDERMOVE) )
1568 : {
1569 0 : if ( nMOff < 2 )
1570 : {
1571 0 : nMOff = 0;
1572 0 : break;
1573 : }
1574 : else
1575 0 : nMOff--;
1576 : }
1577 :
1578 0 : if ( nX <= n1+nMOff )
1579 : {
1580 0 : pHitTest->bSize = sal_True;
1581 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_1;
1582 : }
1583 0 : else if ( nX >= n2-nMOff )
1584 : {
1585 0 : pHitTest->bSize = sal_True;
1586 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_2;
1587 : }
1588 : else
1589 : {
1590 0 : if ( nStyle & RULER_BORDER_MOVEABLE )
1591 : {
1592 0 : pHitTest->bSizeBar = sal_True;
1593 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE;
1594 : }
1595 : }
1596 : }
1597 :
1598 0 : return sal_True;
1599 : }
1600 : }
1601 : }
1602 :
1603 : // Und zum Schluss die Raender
1604 0 : int nMarginTolerance = pHitTest->bExpandTest ? nBorderTolerance : RULER_MOUSE_MARGINWIDTH;
1605 :
1606 0 : if ( (mpData->nMargin1Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE )
1607 : {
1608 0 : n1 = mpData->nMargin1;
1609 0 : if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) )
1610 : {
1611 0 : pHitTest->eType = RULER_TYPE_MARGIN1;
1612 0 : pHitTest->bSize = sal_True;
1613 0 : return sal_True;
1614 : }
1615 : }
1616 0 : if ( (mpData->nMargin2Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE )
1617 : {
1618 0 : n1 = mpData->nMargin2;
1619 0 : if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) )
1620 : {
1621 0 : pHitTest->eType = RULER_TYPE_MARGIN2;
1622 0 : pHitTest->bSize = sal_True;
1623 0 : return sal_True;
1624 : }
1625 : }
1626 :
1627 : // Jetzt nocheinmal die Tabs testen, nur mit etwas mehr spielraum
1628 0 : if ( mpData->pTabs )
1629 : {
1630 0 : aRect.Top() = RULER_OFF;
1631 0 : aRect.Bottom() = nHitBottom;
1632 :
1633 0 : for ( i = mpData->nTabs; i; i-- )
1634 : {
1635 0 : nStyle = mpData->pTabs[i-1].nStyle;
1636 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1637 : {
1638 0 : nStyle &= RULER_TAB_STYLE;
1639 :
1640 : // Default-Tabs werden nur angezeigt
1641 0 : if ( nStyle != RULER_TAB_DEFAULT )
1642 : {
1643 0 : n1 = mpData->pTabs[i-1].nPos;
1644 :
1645 0 : if ( nStyle == RULER_TAB_LEFT )
1646 : {
1647 0 : aRect.Left() = n1;
1648 0 : aRect.Right() = n1+RULER_TAB_WIDTH-1;
1649 : }
1650 0 : else if ( nStyle == RULER_TAB_RIGHT )
1651 : {
1652 0 : aRect.Right() = n1;
1653 0 : aRect.Left() = n1-RULER_TAB_WIDTH-1;
1654 : }
1655 : else
1656 : {
1657 0 : aRect.Left() = n1-RULER_TAB_CWIDTH2+1;
1658 0 : aRect.Right() = n1-RULER_TAB_CWIDTH2+RULER_TAB_CWIDTH;
1659 : }
1660 :
1661 0 : aRect.Left()--;
1662 0 : aRect.Right()++;
1663 :
1664 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1665 : {
1666 0 : pHitTest->eType = RULER_TYPE_TAB;
1667 0 : pHitTest->nAryPos = i-1;
1668 0 : return sal_True;
1669 : }
1670 : }
1671 : }
1672 : }
1673 : }
1674 :
1675 0 : return sal_False;
1676 : }
1677 :
1678 : // -----------------------------------------------------------------------
1679 :
1680 0 : sal_Bool Ruler::ImplDocHitTest( const Point& rPos, RulerType eDragType,
1681 : ImplRulerHitTest* pHitTest ) const
1682 : {
1683 0 : Point aPos = rPos;
1684 0 : sal_Bool bRequiredStyle = sal_False;
1685 0 : sal_uInt16 nRequiredStyle = 0;
1686 :
1687 0 : if (eDragType == RULER_TYPE_INDENT)
1688 : {
1689 0 : bRequiredStyle = sal_True;
1690 0 : nRequiredStyle = RULER_INDENT_BOTTOM;
1691 : }
1692 :
1693 0 : if ( mnWinStyle & WB_HORZ )
1694 0 : aPos.X() += mnWinOff;
1695 : else
1696 0 : aPos.Y() += mnWinOff;
1697 :
1698 0 : if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_DONTKNOW) )
1699 : {
1700 0 : if ( mnWinStyle & WB_HORZ )
1701 0 : aPos.Y() = RULER_OFF+1;
1702 : else
1703 0 : aPos.X() = RULER_OFF+1;
1704 :
1705 : // HitTest durchfuehren
1706 0 : if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) )
1707 : {
1708 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1709 0 : return sal_True;
1710 : }
1711 : }
1712 :
1713 0 : if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_TAB) ||
1714 : (eDragType == RULER_TYPE_DONTKNOW) )
1715 : {
1716 0 : if ( mnWinStyle & WB_HORZ )
1717 0 : aPos.Y() = mnHeight-RULER_OFF-1;
1718 : else
1719 0 : aPos.X() = mnWidth-RULER_OFF-1;
1720 :
1721 : // HitTest durchfuehren
1722 0 : if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) )
1723 : {
1724 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1725 0 : return sal_True;
1726 : }
1727 : }
1728 :
1729 0 : if ( (eDragType == RULER_TYPE_MARGIN1) || (eDragType == RULER_TYPE_MARGIN2) ||
1730 : (eDragType == RULER_TYPE_BORDER) || (eDragType == RULER_TYPE_DONTKNOW) )
1731 : {
1732 0 : if ( mnWinStyle & WB_HORZ )
1733 0 : aPos.Y() = RULER_OFF + (mnVirHeight/2);
1734 : else
1735 0 : aPos.X() = RULER_OFF + (mnVirHeight/2);
1736 :
1737 : // HitTest durchfuehren
1738 0 : if ( ImplHitTest( aPos, pHitTest ) )
1739 : {
1740 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1741 0 : return sal_True;
1742 : }
1743 : }
1744 :
1745 : // Auf DontKnow setzen
1746 0 : pHitTest->eType = RULER_TYPE_DONTKNOW;
1747 :
1748 0 : return sal_False;
1749 : }
1750 :
1751 : // -----------------------------------------------------------------------
1752 :
1753 0 : sal_Bool Ruler::ImplStartDrag( ImplRulerHitTest* pHitTest, sal_uInt16 nModifier )
1754 : {
1755 : // Wenn eine Spalte angeklick wurde, die weder verschiebar noch
1756 : // in der Groesse aenderbar ist, brauchen wir auch kein Drag ausloesen
1757 0 : if ( (pHitTest->eType == RULER_TYPE_BORDER) &&
1758 0 : !pHitTest->bSize && !pHitTest->bSizeBar )
1759 0 : return sal_False;
1760 :
1761 : // Dragdaten setzen
1762 0 : meDragType = pHitTest->eType;
1763 0 : mnDragPos = pHitTest->nPos;
1764 0 : mnDragAryPos = pHitTest->nAryPos;
1765 0 : mnDragSize = pHitTest->mnDragSize;
1766 0 : mnDragModifier = nModifier;
1767 0 : *mpDragData = *mpSaveData;
1768 0 : mpData = mpDragData;
1769 :
1770 : // Handler rufen
1771 0 : if ( StartDrag() )
1772 : {
1773 : // Wenn der Handler das Draggen erlaubt, dann das Draggen
1774 : // initialisieren
1775 0 : ImplInvertLines();
1776 0 : mbDrag = sal_True;
1777 0 : mnStartDragPos = mnDragPos;
1778 0 : StartTracking();
1779 0 : return sal_True;
1780 : }
1781 : else
1782 : {
1783 : // Ansonsten muessen wir die Daten zuruecksetzen
1784 0 : meDragType = RULER_TYPE_DONTKNOW;
1785 0 : mnDragPos = 0;
1786 0 : mnDragAryPos = 0;
1787 0 : mnDragSize = 0;
1788 0 : mnDragModifier = 0;
1789 0 : mpData = mpSaveData;
1790 : }
1791 :
1792 0 : return sal_False;
1793 : }
1794 :
1795 : // -----------------------------------------------------------------------
1796 :
1797 0 : void Ruler::ImplDrag( const Point& rPos )
1798 : {
1799 : long nX;
1800 : long nY;
1801 : long nOutHeight;
1802 :
1803 0 : if ( mnWinStyle & WB_HORZ )
1804 : {
1805 0 : nX = rPos.X();
1806 0 : nY = rPos.Y();
1807 0 : nOutHeight = mnHeight;
1808 : }
1809 : else
1810 : {
1811 0 : nX = rPos.Y();
1812 0 : nY = rPos.X();
1813 0 : nOutHeight = mnWidth;
1814 : }
1815 :
1816 : // X berechnen und einpassen
1817 0 : nX -= mnVirOff;
1818 0 : if ( nX < mpData->nRulVirOff )
1819 : {
1820 0 : nX = mpData->nRulVirOff;
1821 0 : mnDragScroll = RULER_SCROLL_1;
1822 : }
1823 0 : else if ( nX > mpData->nRulVirOff+mpData->nRulWidth )
1824 : {
1825 0 : nX = mpData->nRulVirOff+mpData->nRulWidth;
1826 0 : mnDragScroll = RULER_SCROLL_2;
1827 : }
1828 0 : nX -= mpData->nNullVirOff;
1829 :
1830 : // Wenn oberhalb oder links vom Lineal, dann alte Werte
1831 0 : mbDragDelete = sal_False;
1832 0 : if ( nY < 0 )
1833 : {
1834 0 : if ( !mbDragCanceled )
1835 : {
1836 : // Daten wiederherstellen
1837 0 : mbDragCanceled = sal_True;
1838 0 : ImplRulerData aTempData;
1839 0 : aTempData = *mpDragData;
1840 0 : *mpDragData = *mpSaveData;
1841 0 : mbCalc = sal_True;
1842 0 : mbFormat = sal_True;
1843 :
1844 : // Handler rufen
1845 0 : mnDragPos = mnStartDragPos;
1846 0 : Drag();
1847 :
1848 : // Und neu ausgeben (zeitverzoegert)
1849 0 : ImplDraw();
1850 :
1851 : // Daten wieder wie vor dem Cancel herstellen
1852 0 : *mpDragData = aTempData;
1853 : }
1854 : }
1855 : else
1856 : {
1857 0 : mbDragCanceled = sal_False;
1858 :
1859 : // +2, damit nicht so schnell die Tabs geloescht werden
1860 0 : if ( nY > nOutHeight+2 )
1861 0 : mbDragDelete = sal_True;
1862 :
1863 0 : mnDragPos = nX;
1864 :
1865 : // Handler rufen
1866 0 : Drag();
1867 :
1868 : // Und neu ausgeben
1869 0 : if ( mbFormat )
1870 0 : ImplDraw();
1871 : }
1872 :
1873 0 : mnDragScroll = 0;
1874 0 : }
1875 :
1876 : // -----------------------------------------------------------------------
1877 :
1878 0 : void Ruler::ImplEndDrag()
1879 : {
1880 : // Werte uebernehmen
1881 0 : if ( mbDragCanceled )
1882 0 : *mpDragData = *mpSaveData;
1883 : else
1884 0 : *mpSaveData = *mpDragData;
1885 0 : mpData = mpSaveData;
1886 0 : mbDrag = sal_False;
1887 :
1888 : // Handler rufen
1889 0 : EndDrag();
1890 :
1891 : // Drag-Werte zuruecksetzen
1892 0 : meDragType = RULER_TYPE_DONTKNOW;
1893 0 : mnDragPos = 0;
1894 0 : mnDragAryPos = 0;
1895 0 : mnDragSize = 0;
1896 0 : mbDragCanceled = sal_False;
1897 0 : mbDragDelete = sal_False;
1898 0 : mnDragModifier = 0;
1899 0 : mnDragScroll = 0;
1900 0 : mnStartDragPos = 0;
1901 :
1902 : // Und neu ausgeben
1903 0 : ImplDraw();
1904 0 : }
1905 :
1906 : // -----------------------------------------------------------------------
1907 :
1908 538 : IMPL_LINK_NOARG(Ruler, ImplUpdateHdl)
1909 : {
1910 269 : mnUpdateEvtId = 0;
1911 :
1912 : // Feststellen, was upgedatet werden muss
1913 269 : if ( mnUpdateFlags & RULER_UPDATE_DRAW )
1914 : {
1915 225 : mnUpdateFlags = 0;
1916 225 : ImplDraw();
1917 : }
1918 44 : else if ( mnUpdateFlags & RULER_UPDATE_LINES )
1919 : {
1920 44 : mnUpdateFlags = 0;
1921 44 : ImplInvertLines();
1922 : }
1923 :
1924 269 : return 0;
1925 : }
1926 :
1927 : // -----------------------------------------------------------------------
1928 :
1929 0 : void Ruler::MouseButtonDown( const MouseEvent& rMEvt )
1930 : {
1931 0 : if ( rMEvt.IsLeft() && !IsTracking() )
1932 : {
1933 0 : Point aMousePos = rMEvt.GetPosPixel();
1934 0 : sal_uInt16 nMouseClicks = rMEvt.GetClicks();
1935 0 : sal_uInt16 nMouseModifier = rMEvt.GetModifier();
1936 :
1937 : // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten
1938 : // gearbeitet wird und die Anzeige auch zur Bearbeitung passt)
1939 0 : if ( mbFormat )
1940 : {
1941 0 : ImplDraw();
1942 0 : mnUpdateFlags &= ~RULER_UPDATE_DRAW;
1943 : }
1944 :
1945 0 : if ( maExtraRect.IsInside( aMousePos ) )
1946 : {
1947 0 : mnExtraClicks = nMouseClicks;
1948 0 : mnExtraModifier = nMouseModifier;
1949 0 : ExtraDown();
1950 0 : mnExtraClicks = 0;
1951 0 : mnExtraModifier = 0;
1952 : }
1953 : else
1954 : {
1955 0 : ImplRulerHitTest aHitTest;
1956 :
1957 0 : if ( nMouseClicks == 1 )
1958 : {
1959 0 : if ( ImplHitTest( aMousePos, &aHitTest ) )
1960 0 : ImplStartDrag( &aHitTest, nMouseModifier );
1961 : else
1962 : {
1963 : // Position innerhalb des Lineal-Bereiches
1964 0 : if ( aHitTest.eType == RULER_TYPE_DONTKNOW )
1965 : {
1966 0 : mnDragPos = aHitTest.nPos;
1967 0 : Click();
1968 0 : mnDragPos = 0;
1969 :
1970 : // Nocheinmal HitTest durchfuehren, da durch den Click
1971 : // zum Beispiel ein neuer Tab gesetzt werden konnte
1972 0 : if ( ImplHitTest( aMousePos, &aHitTest ) )
1973 0 : ImplStartDrag( &aHitTest, nMouseModifier );
1974 : }
1975 : }
1976 : }
1977 : else
1978 : {
1979 0 : if ( ImplHitTest( aMousePos, &aHitTest ) )
1980 : {
1981 0 : mnDragPos = aHitTest.nPos;
1982 0 : mnDragAryPos = aHitTest.nAryPos;
1983 : }
1984 0 : meDragType = aHitTest.eType;
1985 :
1986 0 : DoubleClick();
1987 :
1988 0 : meDragType = RULER_TYPE_DONTKNOW;
1989 0 : mnDragPos = 0;
1990 0 : mnDragAryPos = 0;
1991 : }
1992 : }
1993 : }
1994 0 : }
1995 :
1996 : // -----------------------------------------------------------------------
1997 :
1998 0 : void Ruler::MouseMove( const MouseEvent& rMEvt )
1999 : {
2000 0 : PointerStyle ePtrStyle = POINTER_ARROW;
2001 :
2002 : // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten
2003 : // gearbeitet wird und die Anzeige auch zur Bearbeitung passt)
2004 0 : if ( mbFormat )
2005 : {
2006 0 : ImplDraw();
2007 0 : mnUpdateFlags &= ~RULER_UPDATE_DRAW;
2008 : }
2009 :
2010 0 : ImplRulerHitTest aHitTest;
2011 0 : if ( ImplHitTest( rMEvt.GetPosPixel(), &aHitTest ) )
2012 : {
2013 0 : if ( aHitTest.bSize )
2014 : {
2015 0 : if ( mnWinStyle & WB_HORZ )
2016 0 : ePtrStyle = POINTER_ESIZE;
2017 : else
2018 0 : ePtrStyle = POINTER_SSIZE;
2019 : }
2020 0 : else if ( aHitTest.bSizeBar )
2021 : {
2022 0 : if ( mnWinStyle & WB_HORZ )
2023 0 : ePtrStyle = POINTER_HSIZEBAR;
2024 : else
2025 0 : ePtrStyle = POINTER_VSIZEBAR;
2026 : }
2027 : }
2028 :
2029 0 : SetPointer( Pointer( ePtrStyle ) );
2030 0 : }
2031 :
2032 : // -----------------------------------------------------------------------
2033 :
2034 0 : void Ruler::Tracking( const TrackingEvent& rTEvt )
2035 : {
2036 0 : if ( rTEvt.IsTrackingEnded() )
2037 : {
2038 : // Bei Abbruch, den alten Status wieder herstellen
2039 0 : if ( rTEvt.IsTrackingCanceled() )
2040 : {
2041 0 : mbDragCanceled = sal_True;
2042 0 : mbFormat = sal_True;
2043 : }
2044 :
2045 0 : ImplEndDrag();
2046 : }
2047 : else
2048 0 : ImplDrag( rTEvt.GetMouseEvent().GetPosPixel() );
2049 0 : }
2050 :
2051 : // -----------------------------------------------------------------------
2052 :
2053 945 : void Ruler::Paint( const Rectangle& )
2054 : {
2055 945 : ImplDraw();
2056 :
2057 : // Extra-Field beruecksichtigen
2058 945 : if ( mnWinStyle & WB_EXTRAFIELD )
2059 845 : ImplDrawExtra( sal_True );
2060 945 : }
2061 :
2062 : // -----------------------------------------------------------------------
2063 :
2064 1137 : void Ruler::Resize()
2065 : {
2066 1137 : Size aWinSize = GetOutputSizePixel();
2067 :
2068 : long nNewHeight;
2069 1137 : if ( mnWinStyle & WB_HORZ )
2070 : {
2071 424 : if ( aWinSize.Height() != mnHeight )
2072 236 : nNewHeight = aWinSize.Height();
2073 : else
2074 188 : nNewHeight = 0;
2075 : }
2076 : else
2077 : {
2078 713 : if ( aWinSize.Width() != mnWidth )
2079 236 : nNewHeight = aWinSize.Width();
2080 : else
2081 477 : nNewHeight = 0;
2082 : }
2083 :
2084 : // Hier schon Linien loeschen
2085 1137 : sal_Bool bVisible = IsReallyVisible();
2086 1137 : if ( bVisible && mpData->nLines )
2087 : {
2088 0 : ImplInvertLines();
2089 0 : mnUpdateFlags |= RULER_UPDATE_LINES;
2090 0 : if ( !mnUpdateEvtId )
2091 0 : mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL );
2092 : }
2093 1137 : mbFormat = sal_True;
2094 :
2095 : // Wenn sich die Hoehe bzw. Breite aendert, dann muessen besimmte Werte
2096 : // neu berechnet werden
2097 : //extra field should always be updated
2098 1137 : ImplInitExtraField( mpData->bTextRTL );
2099 1137 : if ( nNewHeight )
2100 : {
2101 472 : mbCalc = sal_True;
2102 472 : mnVirHeight = nNewHeight - mnBorderWidth - (RULER_OFF*2);
2103 : }
2104 : else
2105 : {
2106 665 : if ( mpData->bAutoPageWidth )
2107 665 : ImplUpdate( sal_True );
2108 0 : else if ( mbAutoWinWidth )
2109 0 : mbCalc = sal_True;
2110 : }
2111 :
2112 : // Gegebenenfalls ein Teil vom Rand loeschen, da 3D-Effekt/Trennlinie am
2113 : // Fensterrand
2114 1137 : if ( bVisible )
2115 : {
2116 292 : if ( nNewHeight )
2117 0 : Invalidate();
2118 292 : else if ( mpData->bAutoPageWidth )
2119 : {
2120 : // Nur bei AutoPageWidth haben wir rechts einen 3D-Effekt,
2121 : // der sich der Fensterbreite anpasst und deshalb neu gezeichnet
2122 : // werden muss
2123 292 : Rectangle aRect;
2124 :
2125 292 : if ( mnWinStyle & WB_HORZ )
2126 : {
2127 2 : if ( mnWidth < aWinSize.Width() )
2128 2 : aRect.Left() = mnWidth-RULER_RESIZE_OFF;
2129 : else
2130 0 : aRect.Left() = aWinSize.Width()-RULER_RESIZE_OFF;
2131 2 : aRect.Right() = aRect.Left()+RULER_RESIZE_OFF;
2132 2 : aRect.Top() = RULER_OFF;
2133 2 : aRect.Bottom() = RULER_OFF+mnVirHeight;
2134 : }
2135 : else
2136 : {
2137 290 : if ( mnHeight < aWinSize.Height() )
2138 7 : aRect.Top() = mnHeight-RULER_RESIZE_OFF;
2139 : else
2140 283 : aRect.Top() = aWinSize.Height()-RULER_RESIZE_OFF;
2141 290 : aRect.Bottom() = aRect.Top()+RULER_RESIZE_OFF;
2142 290 : aRect.Left() = RULER_OFF;
2143 290 : aRect.Right() = RULER_OFF+mnVirHeight;
2144 : }
2145 :
2146 292 : Invalidate( aRect );
2147 : }
2148 : }
2149 :
2150 : // Neue Groesse merken
2151 1137 : mnWidth = aWinSize.Width();
2152 1137 : mnHeight = aWinSize.Height();
2153 1137 : }
2154 :
2155 : // -----------------------------------------------------------------------
2156 :
2157 1400 : void Ruler::StateChanged( StateChangedType nType )
2158 : {
2159 1400 : Window::StateChanged( nType );
2160 :
2161 1400 : if ( nType == STATE_CHANGE_INITSHOW )
2162 472 : ImplFormat();
2163 928 : else if ( nType == STATE_CHANGE_UPDATEMODE )
2164 : {
2165 0 : if ( IsReallyVisible() && IsUpdateMode() )
2166 0 : ImplDraw();
2167 : }
2168 928 : else if ( (nType == STATE_CHANGE_ZOOM) ||
2169 : (nType == STATE_CHANGE_CONTROLFONT) )
2170 : {
2171 0 : ImplInitSettings( sal_True, sal_False, sal_False );
2172 0 : Invalidate();
2173 : }
2174 928 : else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
2175 : {
2176 0 : ImplInitSettings( sal_False, sal_True, sal_False );
2177 0 : Invalidate();
2178 : }
2179 928 : else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
2180 : {
2181 0 : ImplInitSettings( sal_False, sal_False, sal_True );
2182 0 : Invalidate();
2183 : }
2184 1400 : }
2185 :
2186 : // -----------------------------------------------------------------------
2187 :
2188 184 : void Ruler::DataChanged( const DataChangedEvent& rDCEvt )
2189 : {
2190 184 : Window::DataChanged( rDCEvt );
2191 :
2192 920 : if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
2193 184 : (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
2194 184 : (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
2195 184 : ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
2196 184 : (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
2197 : {
2198 0 : mbFormat = sal_True;
2199 0 : ImplInitSettings( sal_True, sal_True, sal_True );
2200 0 : Invalidate();
2201 : }
2202 184 : }
2203 :
2204 : // -----------------------------------------------------------------------
2205 :
2206 0 : long Ruler::StartDrag()
2207 : {
2208 0 : if ( maStartDragHdl.IsSet() )
2209 0 : return maStartDragHdl.Call( this );
2210 : else
2211 0 : return sal_False;
2212 : }
2213 :
2214 : // -----------------------------------------------------------------------
2215 :
2216 0 : void Ruler::Drag()
2217 : {
2218 0 : maDragHdl.Call( this );
2219 0 : }
2220 :
2221 : // -----------------------------------------------------------------------
2222 :
2223 0 : void Ruler::EndDrag()
2224 : {
2225 0 : maEndDragHdl.Call( this );
2226 0 : }
2227 :
2228 : // -----------------------------------------------------------------------
2229 :
2230 0 : void Ruler::Click()
2231 : {
2232 0 : maClickHdl.Call( this );
2233 0 : }
2234 :
2235 : // -----------------------------------------------------------------------
2236 :
2237 0 : void Ruler::DoubleClick()
2238 : {
2239 0 : maDoubleClickHdl.Call( this );
2240 0 : }
2241 :
2242 : // -----------------------------------------------------------------------
2243 :
2244 0 : void Ruler::ExtraDown()
2245 : {
2246 0 : maExtraDownHdl.Call( this );
2247 0 : }
2248 :
2249 : // -----------------------------------------------------------------------
2250 :
2251 944 : void Ruler::Activate()
2252 : {
2253 944 : mbActive = sal_True;
2254 :
2255 : // Positionslinien wieder anzeigen (erst hinter mbActive=sal_True rufen, da
2256 : // von ImplInvertLines() ausgewertet wird). Das Zeichnen der Linien
2257 : // wird verzoegert, damit im vermutlich noch nicht gepainteten Zustand
2258 : // Linien gezeichnet werden.
2259 944 : mnUpdateFlags |= RULER_UPDATE_LINES;
2260 944 : if ( !mnUpdateEvtId )
2261 472 : mnUpdateEvtId = Application::PostUserEvent( LINK( this, Ruler, ImplUpdateHdl ), NULL );
2262 944 : }
2263 :
2264 : // -----------------------------------------------------------------------
2265 :
2266 944 : void Ruler::Deactivate()
2267 : {
2268 : // Positionslinien loeschen (schon vor mbActive=sal_False rufen, da
2269 : // von ImplInvertLines() ausgewertet wird)
2270 944 : ImplInvertLines();
2271 :
2272 944 : mbActive = sal_False;
2273 944 : }
2274 :
2275 : // -----------------------------------------------------------------------
2276 :
2277 0 : sal_Bool Ruler::StartDocDrag( const MouseEvent& rMEvt, RulerType eDragType )
2278 : {
2279 0 : if ( !mbDrag )
2280 : {
2281 0 : Point aMousePos = rMEvt.GetPosPixel();
2282 0 : sal_uInt16 nMouseClicks = rMEvt.GetClicks();
2283 0 : sal_uInt16 nMouseModifier = rMEvt.GetModifier();
2284 0 : ImplRulerHitTest aHitTest;
2285 0 : if(eDragType != RULER_TYPE_DONTKNOW)
2286 0 : aHitTest.bExpandTest = sal_True;
2287 :
2288 : // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten
2289 : // gearbeitet wird und die Anzeige auch zur Bearbeitung passt)
2290 0 : if ( mbFormat )
2291 : {
2292 0 : ImplDraw();
2293 0 : mnUpdateFlags &= ~RULER_UPDATE_DRAW;
2294 : }
2295 :
2296 0 : if ( nMouseClicks == 1 )
2297 : {
2298 0 : if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) )
2299 : {
2300 0 : Pointer aPtr;
2301 :
2302 0 : if ( aHitTest.bSize )
2303 : {
2304 0 : if ( mnWinStyle & WB_HORZ )
2305 0 : aPtr = Pointer( POINTER_ESIZE );
2306 : else
2307 0 : aPtr = Pointer( POINTER_SSIZE );
2308 : }
2309 0 : else if ( aHitTest.bSizeBar )
2310 : {
2311 0 : if ( mnWinStyle & WB_HORZ )
2312 0 : aPtr = Pointer( POINTER_HSIZEBAR );
2313 : else
2314 0 : aPtr = Pointer( POINTER_VSIZEBAR );
2315 : }
2316 0 : SetPointer( aPtr );
2317 0 : return ImplStartDrag( &aHitTest, nMouseModifier );
2318 : }
2319 : }
2320 0 : else if ( nMouseClicks == 2 )
2321 : {
2322 0 : if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) )
2323 : {
2324 0 : mnDragPos = aHitTest.nPos;
2325 0 : mnDragAryPos = aHitTest.nAryPos;
2326 : }
2327 0 : eDragType = aHitTest.eType;
2328 :
2329 0 : DoubleClick();
2330 :
2331 0 : eDragType = RULER_TYPE_DONTKNOW;
2332 0 : mnDragPos = 0;
2333 0 : mnDragAryPos = 0;
2334 :
2335 0 : return sal_True;
2336 : }
2337 : }
2338 :
2339 0 : return sal_False;
2340 : }
2341 :
2342 : // -----------------------------------------------------------------------
2343 :
2344 0 : void Ruler::CancelDrag()
2345 : {
2346 0 : if ( mbDrag )
2347 : {
2348 0 : ImplDrag( Point( -1, -1 ) );
2349 0 : ImplEndDrag();
2350 : }
2351 0 : }
2352 :
2353 : // -----------------------------------------------------------------------
2354 :
2355 0 : RulerType Ruler::GetType( const Point& rPos, sal_uInt16* pAryPos ) const
2356 : {
2357 0 : ImplRulerHitTest aHitTest;
2358 :
2359 : // Gegebenenfalls Lineal updaten (damit mit den richtigen Daten
2360 : // gearbeitet wird und die Anzeige auch zur Bearbeitung passt)
2361 0 : if ( IsReallyVisible() && mbFormat )
2362 : {
2363 0 : ((Ruler*)this)->ImplDraw();
2364 0 : ((Ruler*)this)->mnUpdateFlags &= ~RULER_UPDATE_DRAW;
2365 : }
2366 :
2367 : // HitTest durchfuehren
2368 0 : ImplHitTest( rPos, &aHitTest );
2369 :
2370 : // Werte zurueckgeben
2371 0 : if ( pAryPos )
2372 0 : *pAryPos = aHitTest.nAryPos;
2373 0 : return aHitTest.eType;
2374 : }
2375 :
2376 : // -----------------------------------------------------------------------
2377 :
2378 186 : void Ruler::SetWinPos( long nNewOff, long nNewWidth )
2379 : {
2380 : // Gegebenenfalls werden die Breiten automatisch berechnet
2381 186 : if ( !nNewWidth )
2382 186 : mbAutoWinWidth = sal_True;
2383 : else
2384 0 : mbAutoWinWidth = sal_False;
2385 :
2386 : // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet)
2387 186 : mnWinOff = nNewOff;
2388 186 : mnWinWidth = nNewWidth;
2389 186 : ImplUpdate( sal_True );
2390 186 : }
2391 :
2392 : // -----------------------------------------------------------------------
2393 :
2394 2380 : void Ruler::SetPagePos( long nNewOff, long nNewWidth )
2395 : {
2396 : // Muessen wir ueberhaupt was machen
2397 2380 : if ( (mpData->nPageOff == nNewOff) && (mpData->nPageWidth == nNewWidth) )
2398 3856 : return;
2399 :
2400 : // Gegebenenfalls werden die Breiten automatisch berechnet
2401 904 : if ( !nNewWidth )
2402 884 : mpData->bAutoPageWidth = sal_True;
2403 : else
2404 20 : mpData->bAutoPageWidth = sal_False;
2405 :
2406 : // Werte setzen (werden in ImplFormat gegebenenfalls mitberechnet)
2407 904 : mpData->nPageOff = nNewOff;
2408 904 : mpData->nPageWidth = nNewWidth;
2409 904 : ImplUpdate( sal_True );
2410 : }
2411 :
2412 : // -----------------------------------------------------------------------
2413 :
2414 236 : void Ruler::SetBorderPos( long nOff )
2415 : {
2416 236 : if ( mnWinStyle & WB_BORDER )
2417 : {
2418 236 : if ( mnBorderOff != nOff )
2419 : {
2420 236 : mnBorderOff = nOff;
2421 :
2422 236 : if ( IsReallyVisible() && IsUpdateMode() )
2423 0 : Invalidate();
2424 : }
2425 : }
2426 236 : }
2427 :
2428 : // -----------------------------------------------------------------------
2429 :
2430 472 : void Ruler::SetUnit( FieldUnit eNewUnit )
2431 : {
2432 472 : if ( meUnit != eNewUnit )
2433 : {
2434 472 : meUnit = eNewUnit;
2435 472 : switch ( meUnit )
2436 : {
2437 : case FUNIT_MM:
2438 0 : mnUnitIndex = RULER_UNIT_MM;
2439 0 : break;
2440 : case FUNIT_CM:
2441 0 : mnUnitIndex = RULER_UNIT_CM;
2442 0 : break;
2443 : case FUNIT_M:
2444 0 : mnUnitIndex = RULER_UNIT_M;
2445 0 : break;
2446 : case FUNIT_KM:
2447 0 : mnUnitIndex = RULER_UNIT_KM;
2448 0 : break;
2449 : case FUNIT_INCH:
2450 472 : mnUnitIndex = RULER_UNIT_INCH;
2451 472 : break;
2452 : case FUNIT_FOOT:
2453 0 : mnUnitIndex = RULER_UNIT_FOOT;
2454 0 : break;
2455 : case FUNIT_MILE:
2456 0 : mnUnitIndex = RULER_UNIT_MILE;
2457 0 : break;
2458 : case FUNIT_POINT:
2459 0 : mnUnitIndex = RULER_UNIT_POINT;
2460 0 : break;
2461 : case FUNIT_PICA:
2462 0 : mnUnitIndex = RULER_UNIT_PICA;
2463 0 : break;
2464 : case FUNIT_CHAR:
2465 0 : mnUnitIndex = RULER_UNIT_CHAR;
2466 0 : break;
2467 : case FUNIT_LINE:
2468 0 : mnUnitIndex = RULER_UNIT_LINE;
2469 0 : break;
2470 : default:
2471 : SAL_WARN( "svtools.control", "Ruler::SetUnit() - Wrong Unit" );
2472 0 : break;
2473 : }
2474 :
2475 472 : maMapMode.SetMapUnit( aImplRulerUnitTab[mnUnitIndex].eMapUnit );
2476 472 : ImplUpdate();
2477 : }
2478 472 : }
2479 :
2480 : // -----------------------------------------------------------------------
2481 :
2482 540 : void Ruler::SetZoom( const Fraction& rNewZoom )
2483 : {
2484 : DBG_ASSERT( rNewZoom.GetNumerator(), "Ruler::SetZoom() with scale 0 is not allowed" );
2485 :
2486 540 : if ( maZoom != rNewZoom )
2487 : {
2488 66 : maZoom = rNewZoom;
2489 66 : maMapMode.SetScaleX( maZoom );
2490 66 : maMapMode.SetScaleY( maZoom );
2491 66 : ImplUpdate();
2492 : }
2493 540 : }
2494 :
2495 : // -----------------------------------------------------------------------
2496 :
2497 472 : void Ruler::SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle )
2498 : {
2499 472 : if ( mnWinStyle & WB_EXTRAFIELD )
2500 : {
2501 472 : meExtraType = eNewExtraType;
2502 472 : mnExtraStyle = nStyle;
2503 472 : if ( IsReallyVisible() && IsUpdateMode() )
2504 0 : ImplDrawExtra( sal_False );
2505 : }
2506 472 : }
2507 :
2508 : // -----------------------------------------------------------------------
2509 :
2510 20 : void Ruler::SetNullOffset( long nPos )
2511 : {
2512 20 : if ( mpData->nNullOff != nPos )
2513 : {
2514 20 : mpData->nNullOff = nPos;
2515 20 : ImplUpdate();
2516 : }
2517 20 : }
2518 :
2519 : // -----------------------------------------------------------------------
2520 :
2521 2380 : void Ruler::SetMargin1( long nPos, sal_uInt16 nMarginStyle )
2522 : {
2523 2380 : if ( (mpData->nMargin1 != nPos) || (mpData->nMargin1Style != nMarginStyle) )
2524 : {
2525 418 : mpData->nMargin1 = nPos;
2526 418 : mpData->nMargin1Style = nMarginStyle;
2527 418 : ImplUpdate();
2528 : }
2529 2380 : }
2530 :
2531 : // -----------------------------------------------------------------------
2532 :
2533 2380 : void Ruler::SetMargin2( long nPos, sal_uInt16 nMarginStyle )
2534 : {
2535 : DBG_ASSERT( (nPos >= mpData->nMargin1) ||
2536 : (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) ||
2537 : (mpData->nMargin2Style & RULER_STYLE_INVISIBLE),
2538 : "Ruler::SetMargin2() - Margin2 < Margin1" );
2539 :
2540 2380 : if ( (mpData->nMargin2 != nPos) || (mpData->nMargin2Style != nMarginStyle) )
2541 : {
2542 418 : mpData->nMargin2 = nPos;
2543 418 : mpData->nMargin2Style = nMarginStyle;
2544 418 : ImplUpdate();
2545 : }
2546 2380 : }
2547 :
2548 : // -----------------------------------------------------------------------
2549 :
2550 0 : void Ruler::SetLines( sal_uInt16 n, const RulerLine* pLineAry )
2551 : {
2552 : // To determine if what has changed
2553 0 : if ( mpData->nLines == n )
2554 : {
2555 0 : sal_uInt16 i = n;
2556 0 : const RulerLine* pAry1 = mpData->pLines;
2557 0 : const RulerLine* pAry2 = pLineAry;
2558 0 : while ( i )
2559 : {
2560 0 : if ( (pAry1->nPos != pAry2->nPos) ||
2561 : (pAry1->nStyle != pAry2->nStyle) )
2562 0 : break;
2563 0 : pAry1++;
2564 0 : pAry2++;
2565 0 : i--;
2566 : }
2567 0 : if ( !i )
2568 0 : return;
2569 : }
2570 :
2571 : // New values and new share issue
2572 : sal_Bool bMustUpdate;
2573 0 : if ( IsReallyVisible() && IsUpdateMode() )
2574 0 : bMustUpdate = sal_True;
2575 : else
2576 0 : bMustUpdate = sal_False;
2577 :
2578 : // Delete old lines
2579 0 : if ( bMustUpdate )
2580 0 : ImplInvertLines();
2581 :
2582 : // New data set
2583 0 : if ( !n || !pLineAry )
2584 : {
2585 0 : if ( !mpData->pLines )
2586 0 : return;
2587 0 : delete[] mpData->pLines;
2588 0 : mpData->nLines = 0;
2589 0 : mpData->pLines = NULL;
2590 : }
2591 : else
2592 : {
2593 0 : if ( mpData->nLines != n )
2594 : {
2595 0 : delete[] mpData->pLines;
2596 0 : mpData->nLines = n;
2597 0 : mpData->pLines = new RulerLine[n];
2598 : }
2599 :
2600 0 : memcpy( mpData->pLines, pLineAry, n*sizeof( RulerLine ) );
2601 :
2602 : // Linien neu ausgeben
2603 0 : if ( bMustUpdate )
2604 0 : ImplInvertLines();
2605 : }
2606 : }
2607 :
2608 : // -----------------------------------------------------------------------
2609 :
2610 2380 : void Ruler::SetBorders( sal_uInt16 n, const RulerBorder* pBrdAry )
2611 : {
2612 2380 : if ( !n || !pBrdAry )
2613 : {
2614 2380 : if ( !mpData->pBorders )
2615 2380 : return;
2616 0 : delete[] mpData->pBorders;
2617 0 : mpData->nBorders = 0;
2618 0 : mpData->pBorders = NULL;
2619 : }
2620 : else
2621 : {
2622 0 : if ( mpData->nBorders != n )
2623 : {
2624 0 : delete[] mpData->pBorders;
2625 0 : mpData->nBorders = n;
2626 0 : mpData->pBorders = new RulerBorder[n];
2627 : }
2628 : else
2629 : {
2630 0 : sal_uInt16 i = n;
2631 0 : const RulerBorder* pAry1 = mpData->pBorders;
2632 0 : const RulerBorder* pAry2 = pBrdAry;
2633 0 : while ( i )
2634 : {
2635 0 : if ( (pAry1->nPos != pAry2->nPos) ||
2636 : (pAry1->nWidth != pAry2->nWidth) ||
2637 : (pAry1->nStyle != pAry2->nStyle) )
2638 0 : break;
2639 0 : pAry1++;
2640 0 : pAry2++;
2641 0 : i--;
2642 : }
2643 0 : if ( !i )
2644 0 : return;
2645 : }
2646 :
2647 0 : memcpy( mpData->pBorders, pBrdAry, n*sizeof( RulerBorder ) );
2648 : }
2649 :
2650 0 : ImplUpdate();
2651 : }
2652 :
2653 : // -----------------------------------------------------------------------
2654 :
2655 2380 : void Ruler::SetIndents( sal_uInt16 n, const RulerIndent* pIndentAry )
2656 : {
2657 :
2658 2380 : if ( !n || !pIndentAry )
2659 : {
2660 2370 : if ( !mpData->pIndents )
2661 2370 : return;
2662 0 : delete[] mpData->pIndents;
2663 0 : mpData->nIndents = 0;
2664 0 : mpData->pIndents = NULL;
2665 : }
2666 : else
2667 : {
2668 10 : if ( mpData->nIndents != n )
2669 : {
2670 10 : delete[] mpData->pIndents;
2671 10 : mpData->nIndents = n;
2672 10 : mpData->pIndents = new RulerIndent[n];
2673 : }
2674 : else
2675 : {
2676 0 : sal_uInt16 i = n;
2677 0 : const RulerIndent* pAry1 = mpData->pIndents;
2678 0 : const RulerIndent* pAry2 = pIndentAry;
2679 0 : while ( i )
2680 : {
2681 0 : if ( (pAry1->nPos != pAry2->nPos) ||
2682 : (pAry1->nStyle != pAry2->nStyle) )
2683 0 : break;
2684 0 : pAry1++;
2685 0 : pAry2++;
2686 0 : i--;
2687 : }
2688 0 : if ( !i )
2689 0 : return;
2690 : }
2691 :
2692 10 : memcpy( mpData->pIndents, pIndentAry, n*sizeof( RulerIndent ) );
2693 : }
2694 :
2695 10 : ImplUpdate();
2696 : }
2697 :
2698 : // -----------------------------------------------------------------------
2699 :
2700 2588 : void Ruler::SetTabs( sal_uInt16 n, const RulerTab* pTabAry )
2701 : {
2702 2588 : if ( !n || !pTabAry )
2703 : {
2704 2578 : if ( !mpData->pTabs )
2705 2578 : return;
2706 0 : delete[] mpData->pTabs;
2707 0 : mpData->nTabs = 0;
2708 0 : mpData->pTabs = NULL;
2709 : }
2710 : else
2711 : {
2712 10 : if ( mpData->nTabs != n )
2713 : {
2714 10 : delete[] mpData->pTabs;
2715 10 : mpData->nTabs = n;
2716 10 : mpData->pTabs = new RulerTab[n];
2717 : }
2718 : else
2719 : {
2720 0 : sal_uInt16 i = n;
2721 0 : const RulerTab* pAry1 = mpData->pTabs;
2722 0 : const RulerTab* pAry2 = pTabAry;
2723 0 : while ( i )
2724 : {
2725 0 : if ( (pAry1->nPos != pAry2->nPos) ||
2726 : (pAry1->nStyle != pAry2->nStyle) )
2727 0 : break;
2728 0 : pAry1++;
2729 0 : pAry2++;
2730 0 : i--;
2731 : }
2732 0 : if ( !i )
2733 0 : return;
2734 : }
2735 :
2736 10 : memcpy( mpData->pTabs, pTabAry, n*sizeof( RulerTab ) );
2737 : }
2738 :
2739 10 : ImplUpdate();
2740 : }
2741 :
2742 : // -----------------------------------------------------------------------
2743 :
2744 827 : void Ruler::SetStyle( WinBits nStyle )
2745 : {
2746 827 : if ( mnWinStyle != nStyle )
2747 : {
2748 101 : mnWinStyle = nStyle;
2749 101 : ImplInitExtraField( sal_True );
2750 : }
2751 827 : }
2752 :
2753 : // -----------------------------------------------------------------------
2754 :
2755 0 : void Ruler::DrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle )
2756 : {
2757 0 : /*const StyleSettings& rStyleSettings =*/ pDevice->GetSettings().GetStyleSettings();
2758 0 : Point aPos( rPos );
2759 0 : sal_uInt16 nTabStyle = nStyle & (RULER_TAB_STYLE | RULER_TAB_RTL);
2760 :
2761 0 : pDevice->Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
2762 0 : pDevice->SetLineColor();
2763 0 : pDevice->SetFillColor( pDevice->GetSettings().GetStyleSettings().GetShadowColor() );
2764 0 : ImplCenterTabPos( aPos, nTabStyle );
2765 0 : ImplDrawRulerTab( pDevice, aPos, nTabStyle, nStyle );
2766 0 : pDevice->Pop();
2767 0 : }
2768 :
2769 10 : void Ruler::SetTextRTL(sal_Bool bRTL)
2770 : {
2771 10 : if(mpData->bTextRTL != bRTL)
2772 : {
2773 0 : mpData->bTextRTL = bRTL;
2774 0 : if ( IsReallyVisible() && IsUpdateMode() )
2775 0 : ImplInitExtraField( sal_True );
2776 : }
2777 :
2778 10 : }
2779 0 : long Ruler::GetPageOffset() const { return mpData->nPageOff; }
2780 0 : long Ruler::GetNullOffset() const { return mpData->nNullOff; }
2781 0 : long Ruler::GetMargin1() const { return mpData->nMargin1; }
2782 0 : long Ruler::GetMargin2() const { return mpData->nMargin2; }
2783 :
2784 0 : void Ruler::DrawTicks()
2785 : {
2786 0 : mbFormat = sal_True;
2787 0 : ImplDraw();
2788 0 : }
2789 :
2790 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
