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 : #include <string.h>
21 : #include <tools/debug.hxx>
22 : #include <vcl/svapp.hxx>
23 : #include <tools/poly.hxx>
24 : #include <vcl/i18nhelp.hxx>
25 : #include <vcl/settings.hxx>
26 :
27 : #include <svtools/ruler.hxx>
28 : #include <svtools/svtresid.hxx>
29 : #include <svtools/svtools.hrc>
30 : #include <svtools/colorcfg.hxx>
31 :
32 : #include <boost/scoped_array.hpp>
33 : #include <vector>
34 :
35 : using namespace std;
36 : using namespace ::com::sun::star;
37 : using namespace ::com::sun::star::uno;
38 : using namespace ::com::sun::star::lang;
39 : using namespace ::com::sun::star::accessibility;
40 :
41 : #define RULER_OFF 3
42 : #define RULER_RESIZE_OFF 4
43 : #define RULER_MIN_SIZE 3
44 :
45 : #define RULER_VAR_SIZE 8
46 :
47 : #define RULER_UPDATE_LINES 0x01
48 :
49 : #define RULER_CLIP 150
50 :
51 : #define RULER_UNIT_MM 0
52 : #define RULER_UNIT_CM 1
53 : #define RULER_UNIT_M 2
54 : #define RULER_UNIT_KM 3
55 : #define RULER_UNIT_INCH 4
56 : #define RULER_UNIT_FOOT 5
57 : #define RULER_UNIT_MILE 6
58 : #define RULER_UNIT_POINT 7
59 : #define RULER_UNIT_PICA 8
60 : #define RULER_UNIT_CHAR 9
61 : #define RULER_UNIT_LINE 10
62 : #define RULER_UNIT_COUNT 11
63 :
64 : class ImplRulerData
65 : {
66 : friend class Ruler;
67 :
68 : private:
69 : vector<RulerLine> pLines;
70 : vector<RulerBorder> pBorders;
71 : vector<RulerIndent> pIndents;
72 : vector<RulerTab> pTabs;
73 :
74 : long nNullVirOff;
75 : long nRulVirOff;
76 : long nRulWidth;
77 : long nPageOff;
78 : long nPageWidth;
79 : long nNullOff;
80 : long nMargin1;
81 : long nMargin2;
82 : long nLeftFrameMargin;
83 : long nRightFrameMargin;
84 : sal_uInt16 nMargin1Style;
85 : sal_uInt16 nMargin2Style;
86 : bool bAutoPageWidth;
87 : bool bTextRTL;
88 :
89 : public:
90 : ImplRulerData();
91 : ~ImplRulerData();
92 :
93 : ImplRulerData& operator=( const ImplRulerData& rData );
94 : };
95 :
96 11388 : ImplRulerData::ImplRulerData() :
97 : nNullVirOff (0),
98 : nRulVirOff (0),
99 : nRulWidth (0),
100 : nPageOff (0),
101 : nPageWidth (0),
102 : nNullOff (0),
103 : nMargin1 (0),
104 : nMargin2 (0),
105 : nLeftFrameMargin (0),
106 : nRightFrameMargin (0),
107 : nMargin1Style (0),
108 : nMargin2Style (0),
109 : bAutoPageWidth (true), // Page width == EditWin width
110 11388 : bTextRTL (false)
111 : {
112 11388 : }
113 :
114 11372 : ImplRulerData::~ImplRulerData()
115 11372 : {}
116 :
117 0 : ImplRulerData& ImplRulerData::operator=( const ImplRulerData& rData )
118 : {
119 0 : if( this == &rData )
120 0 : return *this;
121 :
122 0 : nNullVirOff = rData.nNullVirOff;
123 0 : nRulVirOff = rData.nRulVirOff;
124 0 : nRulWidth = rData.nRulWidth;
125 0 : nPageOff = rData.nPageOff;
126 0 : nPageWidth = rData.nPageWidth;
127 0 : nNullOff = rData.nNullOff;
128 0 : nMargin1 = rData.nMargin1;
129 0 : nMargin2 = rData.nMargin2;
130 0 : nLeftFrameMargin = rData.nLeftFrameMargin;
131 0 : nRightFrameMargin = rData.nRightFrameMargin;
132 0 : nMargin1Style = rData.nMargin1Style;
133 0 : nMargin2Style = rData.nMargin2Style;
134 0 : bAutoPageWidth = rData.bAutoPageWidth;
135 0 : bTextRTL = rData.bTextRTL;
136 :
137 0 : if ( !rData.pLines.empty() )
138 : {
139 0 : pLines.resize(rData.pLines.size());
140 0 : std::copy(rData.pLines.begin(), rData.pLines.end(), pLines.begin());
141 : }
142 : else
143 : {
144 0 : pLines.clear();
145 : }
146 :
147 0 : if ( !rData.pBorders.empty() )
148 : {
149 0 : pBorders.resize(rData.pBorders.size());
150 0 : std::copy(rData.pBorders.begin(), rData.pBorders.end(), pBorders.begin());
151 : }
152 : else
153 : {
154 0 : pBorders.clear();
155 : }
156 :
157 0 : if ( !rData.pIndents.empty() )
158 : {
159 0 : pIndents.resize(rData.pIndents.size());
160 0 : std::copy(rData.pIndents.begin(), rData.pIndents.end(), pIndents.begin());
161 : }
162 : else
163 : {
164 0 : pIndents.clear();
165 : }
166 :
167 0 : if ( !rData.pTabs.empty() )
168 : {
169 0 : pTabs.resize(rData.pTabs.size());
170 0 : std::copy(rData.pTabs.begin(), rData.pTabs.end(), pTabs.begin());
171 : }
172 : else
173 : {
174 0 : pTabs.clear();
175 : }
176 :
177 0 : return *this;
178 : }
179 :
180 : static const RulerUnitData aImplRulerUnitTab[RULER_UNIT_COUNT] =
181 : {
182 : { MAP_100TH_MM, 100, 25.0, 25.0, 50.0, 100.0, 100, 3, " mm" }, // MM
183 : { MAP_100TH_MM, 1000, 100.0, 500.0, 1000.0, 1000.0, 1000, 3, " cm" }, // CM
184 : { MAP_MM, 1000, 10.0, 250.0, 500.0, 1000.0, 10000, 4, " m" }, // M
185 : { MAP_CM, 100000, 12500.0, 25000.0, 50000.0, 100000.0, 100000, 6, " km" }, // KM
186 : { MAP_1000TH_INCH, 1000, 62.5, 125.0, 500.0, 1000.0, 25400, 3, "\"" }, // INCH
187 : { MAP_100TH_INCH, 1200, 120.0, 120.0, 600.0, 1200.0, 30480, 3, "'" }, // FOOT
188 : { MAP_10TH_INCH, 633600, 63360.0, 63360.0, 316800.0, 633600.0, 1609344, 4, " miles" }, // MILE
189 : { MAP_POINT, 1, 12.0, 12.0, 12.0, 36.0, 353, 2, " pt" }, // POINT
190 : { MAP_100TH_MM, 423, 423.0, 423.0, 423.0, 846.0, 423, 3, " pi" }, // PICA
191 : { MAP_100TH_MM, 371, 371.0, 371.0, 371.0, 743.0, 371, 3, " ch" }, // CHAR
192 : { MAP_100TH_MM, 551, 551.0, 551.0, 551.0, 1102.0, 551, 3, " li" } // LINE
193 : };
194 :
195 : static RulerTabData ruler_tab =
196 : {
197 : 0, // DPIScaleFactor to be set
198 : 7, // ruler_tab_width
199 : 6, // ruler_tab_height
200 : 2, // ruler_tab_height2
201 : 2, // ruler_tab_width2
202 : 8, // ruler_tab_cwidth
203 : 4, // ruler_tab_cwidth2
204 : 4, // ruler_tab_cwidth3
205 : 2, // ruler_tab_cwidth4
206 : 4, // ruler_tab_dheight
207 : 1, // ruler_tab_dheight2
208 : 5, // ruler_tab_dwidth
209 : 3, // ruler_tab_dwidth2
210 : 3, // ruler_tab_dwidth3
211 : 1, // ruler_tab_dwidth4
212 : 5 // ruler_tab_textoff
213 : };
214 :
215 5694 : void Ruler::ImplInit( WinBits nWinBits )
216 : {
217 : // Default WinBits setzen
218 5694 : if ( !(nWinBits & WB_VERT) )
219 : {
220 2847 : nWinBits |= WB_HORZ;
221 :
222 : // --- RTL --- no UI mirroring for horizontal rulers, because
223 : // the document is also not mirrored
224 2847 : EnableRTL( false );
225 : }
226 :
227 : // Initialize variables
228 5694 : mnWinStyle = nWinBits; // Window-Style
229 5694 : mnBorderOff = 0; // Border-Offset
230 5694 : mnWinOff = 0; // EditWinOffset
231 5694 : mnWinWidth = 0; // EditWinWidth
232 5694 : mnWidth = 0; // Window width
233 5694 : mnHeight = 0; // Window height
234 5694 : mnVirOff = 0; // Offset of VirtualDevice from top-left corner
235 5694 : mnVirWidth = 0; // width or height from VirtualDevice
236 5694 : mnVirHeight = 0; // height of width from VirtualDevice
237 5694 : mnDragPos = 0; // Drag-Position (Null point)
238 5694 : mnUpdateEvtId = 0; // Update event was not sent yet
239 5694 : mnDragAryPos = 0; // Drag-Array-Index
240 5694 : mnDragSize = 0; // Did size change at dragging
241 5694 : mnDragModifier = 0; // Modifier key at dragging
242 5694 : mnExtraStyle = 0; // Style of Extra field
243 5694 : mnExtraClicks = 0; // No. of clicks for Extra field
244 5694 : mnExtraModifier = 0; // Modifier key at click in extra field
245 5694 : mnCharWidth = 371;
246 5694 : mnLineHeight = 551;
247 5694 : mbCalc = true; // Should recalculate page width
248 5694 : mbFormat = true; // Should redraw
249 5694 : mbDrag = false; // Currently at dragging
250 5694 : mbDragDelete = false; // Has mouse left the dragging area
251 5694 : mbDragCanceled = false; // Dragging cancelled?
252 5694 : mbAutoWinWidth = true; // EditWinWidth == RulerWidth
253 5694 : mbActive = true; // Is ruler active
254 5694 : mnUpdateFlags = 0; // What needs to be updated
255 5694 : mpData = mpSaveData; // Pointer to normal data
256 5694 : meExtraType = RULER_EXTRA_DONTKNOW; // What is in extra field
257 5694 : meDragType = RULER_TYPE_DONTKNOW; // Which element is dragged
258 :
259 : // Initialize Units
260 5694 : mnUnitIndex = RULER_UNIT_CM;
261 5694 : meUnit = FUNIT_CM;
262 5694 : maZoom = Fraction( 1, 1 );
263 5694 : meSourceUnit = MAP_100TH_MM;
264 :
265 : // Recalculate border widths
266 5694 : if ( nWinBits & WB_BORDER )
267 5694 : mnBorderWidth = 1;
268 : else
269 0 : mnBorderWidth = 0;
270 :
271 : // Settings
272 5694 : ImplInitSettings( true, true, true );
273 :
274 : // Setup the default size
275 5694 : Rectangle aRect;
276 5694 : GetTextBoundRect( aRect, OUString( "0123456789" ) );
277 5694 : long nDefHeight = aRect.GetHeight() + RULER_OFF * 2 + ruler_tab.textoff * 2 + mnBorderWidth;
278 :
279 5694 : Size aDefSize;
280 5694 : if ( nWinBits & WB_HORZ )
281 2847 : aDefSize.Height() = nDefHeight;
282 : else
283 2847 : aDefSize.Width() = nDefHeight;
284 5694 : SetOutputSizePixel( aDefSize );
285 5694 : SetType(WINDOW_RULER);
286 5694 : pAccContext = NULL;
287 5694 : }
288 :
289 5694 : Ruler::Ruler( vcl::Window* pParent, WinBits nWinStyle ) :
290 : Window( pParent, nWinStyle & WB_3DLOOK ),
291 : maVirDev( VclPtr<VirtualDevice>::Create(*this) ),
292 : maMapMode( MAP_100TH_MM ),
293 5694 : mpSaveData(new ImplRulerData),
294 : mpData(NULL),
295 11388 : mpDragData(new ImplRulerData)
296 : {
297 : // Check to see if the ruler constructor has
298 : // already been called before otherwise
299 : // we end up with over-scaled elements
300 5694 : if (ruler_tab.DPIScaleFactor == 0)
301 : {
302 62 : ruler_tab.DPIScaleFactor = GetDPIScaleFactor();
303 62 : ruler_tab.width *= ruler_tab.DPIScaleFactor;
304 62 : ruler_tab.height *= ruler_tab.DPIScaleFactor;
305 62 : ruler_tab.height2 *= ruler_tab.DPIScaleFactor;
306 62 : ruler_tab.width2 *= ruler_tab.DPIScaleFactor;
307 62 : ruler_tab.cwidth *= ruler_tab.DPIScaleFactor;
308 62 : ruler_tab.cwidth2 *= ruler_tab.DPIScaleFactor;
309 62 : ruler_tab.cwidth3 *= ruler_tab.DPIScaleFactor;
310 62 : ruler_tab.cwidth4 *= ruler_tab.DPIScaleFactor;
311 62 : ruler_tab.dheight *= ruler_tab.DPIScaleFactor;
312 62 : ruler_tab.dheight2 *= ruler_tab.DPIScaleFactor;
313 62 : ruler_tab.dwidth *= ruler_tab.DPIScaleFactor;
314 62 : ruler_tab.dwidth2 *= ruler_tab.DPIScaleFactor;
315 62 : ruler_tab.dwidth3 *= ruler_tab.DPIScaleFactor;
316 62 : ruler_tab.dwidth4 *= ruler_tab.DPIScaleFactor;
317 62 : ruler_tab.textoff *= ruler_tab.DPIScaleFactor;
318 : }
319 :
320 :
321 5694 : ImplInit( nWinStyle );
322 5694 : }
323 :
324 11372 : Ruler::~Ruler()
325 : {
326 5686 : disposeOnce();
327 5686 : }
328 :
329 5686 : void Ruler::dispose()
330 : {
331 5686 : if ( mnUpdateEvtId )
332 0 : Application::RemoveUserEvent( mnUpdateEvtId );
333 5686 : delete mpSaveData;
334 5686 : mpSaveData = NULL;
335 5686 : delete mpDragData;
336 5686 : mpDragData = NULL;
337 5686 : if( pAccContext )
338 : {
339 5 : pAccContext->release();
340 5 : pAccContext = NULL;
341 : }
342 5686 : Window::dispose();
343 5686 : }
344 :
345 23045 : void Ruler::ImplVDrawLine(vcl::RenderContext& rRenderContext, long nX1, long nY1, long nX2, long nY2)
346 : {
347 23045 : if ( nX1 < -RULER_CLIP )
348 : {
349 42 : nX1 = -RULER_CLIP;
350 42 : if ( nX2 < -RULER_CLIP )
351 0 : return;
352 : }
353 23045 : long nClip = mnVirWidth + RULER_CLIP;
354 23045 : if ( nX2 > nClip )
355 : {
356 124 : nX2 = nClip;
357 124 : if ( nX1 > nClip )
358 40 : return;
359 : }
360 :
361 23005 : if ( mnWinStyle & WB_HORZ )
362 22556 : rRenderContext.DrawLine( Point( nX1, nY1 ), Point( nX2, nY2 ) );
363 : else
364 449 : rRenderContext.DrawLine( Point( nY1, nX1 ), Point( nY2, nX2 ) );
365 : }
366 :
367 745703 : void Ruler::ImplVDrawRect(vcl::RenderContext& rRenderContext, long nX1, long nY1, long nX2, long nY2)
368 : {
369 745703 : if ( nX1 < -RULER_CLIP )
370 : {
371 42 : nX1 = -RULER_CLIP;
372 42 : if ( nX2 < -RULER_CLIP )
373 0 : return;
374 : }
375 745703 : long nClip = mnVirWidth + RULER_CLIP;
376 745703 : if ( nX2 > nClip )
377 : {
378 819 : nX2 = nClip;
379 819 : if ( nX1 > nClip )
380 769 : return;
381 : }
382 :
383 744934 : if ( mnWinStyle & WB_HORZ )
384 738924 : rRenderContext.DrawRect(Rectangle(nX1, nY1, nX2, nY2));
385 : else
386 6010 : rRenderContext.DrawRect(Rectangle(nY1, nX1, nY2, nX2));
387 : }
388 :
389 158232 : void Ruler::ImplVDrawText(vcl::RenderContext& rRenderContext, long nX, long nY, const OUString& rText, long nMin, long nMax)
390 : {
391 158232 : Rectangle aRect;
392 158232 : rRenderContext.GetTextBoundRect(aRect, rText);
393 :
394 158232 : long nShiftX = ( aRect.GetWidth() / 2 ) + aRect.Left();
395 158232 : long nShiftY = ( aRect.GetHeight() / 2 ) + aRect.Top();
396 :
397 158232 : if ( (nX > -RULER_CLIP) && (nX < mnVirWidth + RULER_CLIP) && ( nX < nMax - nShiftX ) && ( nX > nMin + nShiftX ) )
398 : {
399 78880 : if ( mnWinStyle & WB_HORZ )
400 77108 : rRenderContext.DrawText(Point(nX - nShiftX, nY - nShiftY), rText);
401 : else
402 1772 : rRenderContext.DrawText(Point(nY - nShiftX, nX - nShiftY), rText);
403 : }
404 158232 : }
405 :
406 10872 : void Ruler::ImplInvertLines(vcl::RenderContext& rRenderContext, bool bErase)
407 : {
408 : // Position lines
409 10872 : if (!mpData->pLines.empty() && mbActive && !mbDrag && !mbFormat && !(mnUpdateFlags & RULER_UPDATE_LINES) )
410 : {
411 0 : long nNullWinOff = mpData->nNullVirOff + mnVirOff;
412 0 : long nRulX1 = mpData->nRulVirOff + mnVirOff;
413 0 : long nRulX2 = nRulX1 + mpData->nRulWidth;
414 0 : long nY = (RULER_OFF * 2) + mnVirHeight - 1;
415 :
416 : // Calculate rectangle
417 0 : Rectangle aRect;
418 0 : if (mnWinStyle & WB_HORZ)
419 0 : aRect.Bottom() = nY;
420 : else
421 0 : aRect.Right() = nY;
422 :
423 : // Draw lines
424 0 : for (size_t i = 0; i < mpData->pLines.size(); i++)
425 : {
426 0 : const long n = mpData->pLines[i].nPos + nNullWinOff;
427 0 : if ((n >= nRulX1) && (n < nRulX2))
428 : {
429 0 : if (mnWinStyle & WB_HORZ )
430 : {
431 0 : aRect.Left() = n;
432 0 : aRect.Right() = n;
433 : }
434 : else
435 : {
436 0 : aRect.Top() = n;
437 0 : aRect.Bottom() = n;
438 : }
439 0 : if (bErase)
440 : {
441 0 : Rectangle aTempRect = aRect;
442 :
443 0 : if (mnWinStyle & WB_HORZ)
444 0 : aTempRect.Bottom() = RULER_OFF - 1;
445 : else
446 0 : aTempRect.Right() = RULER_OFF - 1;
447 :
448 0 : rRenderContext.Erase(aTempRect);
449 :
450 0 : if (mnWinStyle & WB_HORZ)
451 : {
452 0 : aTempRect.Bottom() = aRect.Bottom();
453 0 : aTempRect.Top() = aTempRect.Bottom() - RULER_OFF + 1;
454 : }
455 : else
456 : {
457 0 : aTempRect.Right() = aRect.Right();
458 0 : aTempRect.Left() = aTempRect.Right() - RULER_OFF + 1;
459 : }
460 0 : rRenderContext.Erase(aTempRect);
461 : }
462 0 : Invert(aRect);
463 : }
464 : }
465 0 : mnUpdateFlags = 0;
466 : }
467 10872 : }
468 :
469 10751 : void Ruler::ImplDrawTicks(vcl::RenderContext& rRenderContext, long nMin, long nMax, long nStart, long nTop, long nBottom)
470 : {
471 10751 : double nCenter = nTop + ((nBottom - nTop) / 2);
472 :
473 10751 : long nTickLength3 = (nBottom - nTop) * 0.5;
474 10751 : long nTickLength2 = nTickLength3 * 0.66;
475 10751 : long nTickLength1 = nTickLength2 * 0.66;
476 :
477 10751 : long nScale = ruler_tab.DPIScaleFactor;
478 10751 : long DPIOffset = nScale - 1;
479 :
480 10751 : double nTick4 = aImplRulerUnitTab[mnUnitIndex].nTick4;
481 10751 : double nTick2 = 0;
482 10751 : double nTickCount = aImplRulerUnitTab[mnUnitIndex].nTick1 / nScale;
483 10751 : double nTickUnit = 0;
484 : long nTickWidth;
485 10751 : bool bNoTicks = false;
486 :
487 10751 : double nAcceptanceDelta = 0.0001;
488 :
489 10751 : Size aPixSize = rRenderContext.LogicToPixel(Size(nTick4, nTick4), maMapMode);
490 :
491 10751 : if (mnUnitIndex == RULER_UNIT_CHAR)
492 : {
493 0 : if (mnCharWidth == 0)
494 0 : mnCharWidth = 371;
495 0 : nTick4 = mnCharWidth * 2;
496 0 : nTick2 = mnCharWidth;
497 0 : nTickCount = mnCharWidth;
498 0 : nTickUnit = mnCharWidth;
499 : }
500 10751 : else if (mnUnitIndex == RULER_UNIT_LINE)
501 : {
502 0 : if (mnLineHeight == 0)
503 0 : mnLineHeight = 551;
504 0 : nTick4 = mnLineHeight * 2;
505 0 : nTick2 = mnLineHeight;
506 0 : nTickUnit = mnLineHeight;
507 0 : nTickCount = mnLineHeight;
508 : }
509 :
510 10751 : if (mnWinStyle & WB_HORZ)
511 : {
512 10633 : nTickWidth = aPixSize.Width();
513 : }
514 : else
515 : {
516 118 : vcl::Font aFont = rRenderContext.GetFont();
517 118 : if (mnWinStyle & WB_RIGHT_ALIGNED)
518 1 : aFont.SetOrientation(2700);
519 : else
520 117 : aFont.SetOrientation(900);
521 118 : rRenderContext.SetFont(aFont);
522 118 : nTickWidth = aPixSize.Height();
523 : }
524 :
525 10751 : long nMaxWidth = rRenderContext.PixelToLogic(Size(mpData->nPageWidth, 0), maMapMode).Width();
526 10751 : if (nMaxWidth < 0)
527 0 : nMaxWidth = -nMaxWidth;
528 :
529 10751 : if ((mnUnitIndex == RULER_UNIT_CHAR) || (mnUnitIndex == RULER_UNIT_LINE))
530 0 : nMaxWidth /= nTickUnit;
531 : else
532 10751 : nMaxWidth /= aImplRulerUnitTab[mnUnitIndex].nTickUnit;
533 :
534 10751 : OUString aNumString = OUString::number(nMaxWidth);
535 10751 : long nTxtWidth = rRenderContext.GetTextWidth( aNumString );
536 10751 : const long nTextOff = 4;
537 :
538 : // Determine the number divider for ruler drawn numbers - means which numbers
539 : // should be shown on the ruler and which should be skipped because the ruler
540 : // is not big enough to draw them
541 10751 : if (nTickWidth < nTxtWidth + nTextOff)
542 : {
543 : // Calculate the scale of the ruler
544 6 : long nMulti = 1;
545 6 : long nOrgTick4 = nTick4;
546 :
547 26 : while (nTickWidth < nTxtWidth + nTextOff)
548 : {
549 14 : long nOldMulti = nMulti;
550 14 : if (nTickWidth == 0)
551 0 : nMulti *= 10;
552 14 : else if (nMulti < 10)
553 14 : nMulti++;
554 0 : else if (nMulti < 100)
555 0 : nMulti += 10;
556 0 : else if (nMulti < 1000)
557 0 : nMulti += 100;
558 : else
559 0 : nMulti += 1000;
560 :
561 : // Overflow - in this case don't draw ticks and exit
562 14 : if (nMulti < nOldMulti)
563 : {
564 0 : bNoTicks = true;
565 0 : break;
566 : }
567 :
568 14 : nTick4 = nOrgTick4 * nMulti;
569 14 : aPixSize = rRenderContext.LogicToPixel(Size(nTick4, nTick4), maMapMode);
570 14 : if (mnWinStyle & WB_HORZ)
571 8 : nTickWidth = aPixSize.Width();
572 : else
573 6 : nTickWidth = aPixSize.Height();
574 : }
575 6 : nTickCount = nTick4;
576 : }
577 : else
578 : {
579 10745 : rRenderContext.SetLineColor(rRenderContext.GetSettings().GetStyleSettings().GetShadowColor());
580 : }
581 :
582 10751 : if (!bNoTicks)
583 : {
584 10751 : long n = 0;
585 10751 : double nTick = 0.0;
586 10751 : double nTick3 = 0;
587 :
588 10751 : if ((mnUnitIndex != RULER_UNIT_CHAR) && (mnUnitIndex != RULER_UNIT_LINE))
589 : {
590 10751 : nTick2 = aImplRulerUnitTab[mnUnitIndex].nTick2;
591 10751 : nTick3 = aImplRulerUnitTab[mnUnitIndex].nTick3;
592 : }
593 :
594 10751 : Size nTickGapSize;
595 :
596 10751 : nTickGapSize = rRenderContext.LogicToPixel(Size(nTickCount, nTickCount), maMapMode);
597 10751 : long nTickGap1 = mnWinStyle & WB_HORZ ? nTickGapSize.Width() : nTickGapSize.Height();
598 10751 : nTickGapSize = rRenderContext.LogicToPixel(Size(nTick2, nTick2), maMapMode);
599 10751 : long nTickGap2 = mnWinStyle & WB_HORZ ? nTickGapSize.Width() : nTickGapSize.Height();
600 10751 : nTickGapSize = rRenderContext.LogicToPixel(Size(nTick3, nTick3), maMapMode);
601 10751 : long nTickGap3 = mnWinStyle & WB_HORZ ? nTickGapSize.Width() : nTickGapSize.Height();
602 :
603 1393022 : while (((nStart - n) >= nMin) || ((nStart + n) <= nMax))
604 : {
605 : // Null point
606 1371520 : if (nTick == 0.0)
607 : {
608 10751 : if (nStart > nMin)
609 : {
610 : // 0 is only painted when Margin1 is not equal to zero
611 375 : if ((mpData->nMargin1Style & RULER_STYLE_INVISIBLE) || (mpData->nMargin1 != 0))
612 : {
613 4 : aNumString = "0";
614 4 : ImplVDrawText(rRenderContext, nStart, nCenter, aNumString);
615 : }
616 : }
617 : }
618 : else
619 : {
620 1360769 : aPixSize = rRenderContext.LogicToPixel(Size(nTick, nTick), maMapMode);
621 :
622 1360769 : if (mnWinStyle & WB_HORZ)
623 1331716 : n = aPixSize.Width();
624 : else
625 29053 : n = aPixSize.Height();
626 :
627 : // Tick4 - Output (Text)
628 1360769 : double aStep = (nTick / nTick4);
629 1360769 : double aRest = std::abs(aStep - std::floor(aStep));
630 :
631 1360769 : if (aRest < nAcceptanceDelta)
632 : {
633 79114 : if ((mnUnitIndex == RULER_UNIT_CHAR) || (mnUnitIndex == RULER_UNIT_LINE))
634 0 : aNumString = OUString::number(nTick / nTickUnit);
635 : else
636 79114 : aNumString = OUString::number(nTick / aImplRulerUnitTab[mnUnitIndex].nTickUnit);
637 :
638 79114 : long nHorizontalLocation = nStart + n;
639 79114 : ImplVDrawText(rRenderContext, nHorizontalLocation, nCenter, aNumString, nMin, nMax);
640 :
641 79114 : if (nMin < nHorizontalLocation && nHorizontalLocation < nMax)
642 : {
643 79086 : ImplVDrawRect(rRenderContext, nHorizontalLocation, nBottom, nHorizontalLocation + DPIOffset, nBottom - 1 * nScale);
644 79086 : ImplVDrawRect(rRenderContext, nHorizontalLocation, nTop, nHorizontalLocation + DPIOffset, nTop + 1 * nScale);
645 : }
646 :
647 79114 : nHorizontalLocation = nStart - n;
648 79114 : ImplVDrawText(rRenderContext, nHorizontalLocation, nCenter, aNumString, nMin, nMax);
649 :
650 79114 : if (nMin < nHorizontalLocation && nHorizontalLocation < nMax)
651 : {
652 : ImplVDrawRect(rRenderContext, nHorizontalLocation, nBottom,
653 111 : nHorizontalLocation + DPIOffset, nBottom - 1 * nScale);
654 : ImplVDrawRect(rRenderContext, nHorizontalLocation, nTop,
655 111 : nHorizontalLocation + DPIOffset, nTop + 1 * nScale);
656 : }
657 : }
658 : // Tick/Tick2 - Output (Strokes)
659 : else
660 : {
661 1281655 : long nTickLength = nTickLength1;
662 :
663 1281655 : aStep = (nTick / nTick2);
664 1281655 : aRest = std::abs(aStep - std::floor(aStep));
665 1281655 : if (aRest < nAcceptanceDelta)
666 596606 : nTickLength = nTickLength2;
667 :
668 1281655 : aStep = (nTick / nTick3);
669 1281655 : aRest = std::abs(aStep - std::floor(aStep));
670 1281655 : if (aRest < nAcceptanceDelta )
671 87293 : nTickLength = nTickLength3;
672 :
673 1281655 : if ((nTickLength == nTickLength1 && nTickGap1 > 6) ||
674 509313 : (nTickLength == nTickLength2 && nTickGap2 > 6) ||
675 87293 : (nTickLength == nTickLength3 && nTickGap3 > 6))
676 : {
677 576494 : long nT1 = nCenter - (nTickLength / 2.0);
678 576494 : long nT2 = nT1 + nTickLength - 1;
679 : long nT;
680 :
681 576494 : nT = nStart + n;
682 :
683 576494 : if (nT < nMax)
684 574017 : ImplVDrawRect(rRenderContext, nT, nT1, nT + DPIOffset, nT2);
685 576494 : nT = nStart - n;
686 576494 : if (nT > nMin)
687 1791 : ImplVDrawRect(rRenderContext, nT, nT1, nT + DPIOffset, nT2);
688 : }
689 : }
690 : }
691 1371520 : nTick += nTickCount;
692 : }
693 10751 : }
694 10751 : }
695 :
696 2 : void Ruler::ImplDrawBorders(vcl::RenderContext& rRenderContext, long nMin, long nMax, long nVirTop, long nVirBottom)
697 : {
698 2 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
699 : long n;
700 : long n1;
701 : long n2;
702 : long nTemp1;
703 : long nTemp2;
704 : sal_uInt32 i;
705 :
706 4 : for (i = 0; i < mpData->pBorders.size(); i++)
707 : {
708 2 : if (mpData->pBorders[i].nStyle & RULER_STYLE_INVISIBLE)
709 0 : continue;
710 :
711 2 : n1 = mpData->pBorders[i].nPos + mpData->nNullVirOff;
712 2 : n2 = n1 + mpData->pBorders[i].nWidth;
713 :
714 2 : if (((n1 >= nMin) && (n1 <= nMax)) || ((n2 >= nMin) && (n2 <= nMax)))
715 : {
716 2 : if ((n2 - n1) > 3)
717 : {
718 0 : rRenderContext.SetLineColor();
719 0 : rRenderContext.SetFillColor(rStyleSettings.GetFaceColor());
720 0 : ImplVDrawRect(rRenderContext, n1, nVirTop, n2, nVirBottom);
721 :
722 0 : rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
723 0 : ImplVDrawLine(rRenderContext, n1 + 1, nVirTop, n1 + 1, nVirBottom);
724 0 : ImplVDrawLine(rRenderContext, n1, nVirTop, n2, nVirTop);
725 :
726 0 : rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
727 0 : ImplVDrawLine(rRenderContext, n1, nVirTop, n1, nVirBottom);
728 0 : ImplVDrawLine(rRenderContext, n1, nVirBottom, n2, nVirBottom);
729 0 : ImplVDrawLine(rRenderContext, n2 - 1, nVirTop, n2 - 1, nVirBottom);
730 :
731 0 : rRenderContext.SetLineColor(rStyleSettings.GetDarkShadowColor());
732 0 : ImplVDrawLine(rRenderContext, n2, nVirTop, n2, nVirBottom);
733 :
734 0 : if (mpData->pBorders[i].nStyle & RULER_BORDER_VARIABLE)
735 : {
736 0 : if (n2 - n1 > RULER_VAR_SIZE + 4)
737 : {
738 0 : nTemp1 = n1 + (((n2 - n1 + 1) - RULER_VAR_SIZE) / 2);
739 0 : nTemp2 = nVirTop + (((nVirBottom - nVirTop + 1) - RULER_VAR_SIZE) / 2);
740 0 : long nTemp3 = nTemp1 + RULER_VAR_SIZE - 1;
741 0 : long nTemp4 = nTemp2 + RULER_VAR_SIZE - 1;
742 0 : long nTempY = nTemp2;
743 :
744 0 : rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
745 0 : while (nTempY <= nTemp4)
746 : {
747 0 : ImplVDrawLine(rRenderContext, nTemp1, nTempY, nTemp3, nTempY);
748 0 : nTempY += 2;
749 : }
750 :
751 0 : nTempY = nTemp2 + 1;
752 0 : rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
753 0 : while (nTempY <= nTemp4)
754 : {
755 0 : ImplVDrawLine(rRenderContext, nTemp1, nTempY, nTemp3, nTempY);
756 0 : nTempY += 2;
757 : }
758 : }
759 : }
760 :
761 0 : if (mpData->pBorders[i].nStyle & RULER_BORDER_SIZEABLE)
762 : {
763 0 : if (n2 - n1 > RULER_VAR_SIZE + 10)
764 : {
765 0 : rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
766 0 : ImplVDrawLine(rRenderContext, n1 + 4, nVirTop + 3, n1 + 4, nVirBottom - 3);
767 0 : ImplVDrawLine(rRenderContext, n2 - 5, nVirTop + 3, n2 - 5, nVirBottom - 3);
768 0 : rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
769 0 : ImplVDrawLine(rRenderContext, n1 + 5, nVirTop + 3, n1 + 5, nVirBottom - 3);
770 0 : ImplVDrawLine(rRenderContext, n2 - 4, nVirTop + 3, n2 - 4, nVirBottom - 3);
771 : }
772 : }
773 : }
774 : else
775 : {
776 2 : n = n1 + ((n2 - n1) / 2);
777 2 : rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
778 :
779 2 : if (mpData->pBorders[i].nStyle & RULER_BORDER_SNAP)
780 0 : ImplVDrawLine(rRenderContext, n, nVirTop, n, nVirBottom);
781 2 : else if (mpData->pBorders[i].nStyle & RULER_BORDER_MARGIN)
782 0 : ImplVDrawLine(rRenderContext, n, nVirTop, n, nVirBottom);
783 : else
784 : {
785 2 : ImplVDrawLine(rRenderContext, n - 1, nVirTop, n - 1, nVirBottom);
786 2 : ImplVDrawLine(rRenderContext, n + 1, nVirTop, n + 1, nVirBottom);
787 2 : rRenderContext.SetLineColor();
788 2 : rRenderContext.SetFillColor(rStyleSettings.GetWindowColor());
789 2 : ImplVDrawRect(rRenderContext, n, nVirTop, n, nVirBottom);
790 : }
791 : }
792 : }
793 : }
794 2 : }
795 :
796 957 : void Ruler::ImplDrawIndent(vcl::RenderContext& rRenderContext, const Polygon& rPoly, sal_uInt16 nStyle, bool bIsHit)
797 : {
798 957 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
799 :
800 957 : if (nStyle & RULER_STYLE_INVISIBLE)
801 957 : return;
802 :
803 957 : rRenderContext.SetLineColor(rStyleSettings.GetDarkShadowColor());
804 957 : rRenderContext.SetFillColor(bIsHit ? rStyleSettings.GetDarkShadowColor() : rStyleSettings.GetWorkspaceColor());
805 957 : rRenderContext.DrawPolygon(rPoly);
806 : }
807 :
808 323 : void Ruler::ImplDrawIndents(vcl::RenderContext& rRenderContext, long nMin, long nMax, long nVirTop, long nVirBottom)
809 : {
810 : sal_uInt32 j;
811 : long n;
812 323 : long nIndentHeight = (mnVirHeight / 2) - 1;
813 323 : long nIndentWidth2 = nIndentHeight-3;
814 :
815 323 : Polygon aPoly(5);
816 :
817 1292 : for (j = 0; j < mpData->pIndents.size(); j++)
818 : {
819 969 : if (mpData->pIndents[j].nStyle & RULER_STYLE_INVISIBLE)
820 0 : continue;
821 :
822 969 : sal_uInt16 nStyle = mpData->pIndents[j].nStyle;
823 969 : sal_uInt16 nIndentStyle = nStyle & RULER_INDENT_STYLE;
824 :
825 969 : n = mpData->pIndents[j].nPos+mpData->nNullVirOff;
826 :
827 969 : if ((n >= nMin) && (n <= nMax))
828 : {
829 957 : if (nIndentStyle == RULER_INDENT_BORDER)
830 : {
831 0 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
832 0 : rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
833 0 : ImplVDrawLine(rRenderContext, n, nVirTop + 1, n, nVirBottom - 1);
834 : }
835 957 : else if (nIndentStyle == RULER_INDENT_BOTTOM)
836 : {
837 640 : aPoly.SetPoint(Point(n + 0, nVirBottom - nIndentHeight), 0);
838 640 : aPoly.SetPoint(Point(n - nIndentWidth2, nVirBottom - 3), 1);
839 640 : aPoly.SetPoint(Point(n - nIndentWidth2, nVirBottom), 2);
840 640 : aPoly.SetPoint(Point(n + nIndentWidth2, nVirBottom), 3);
841 640 : aPoly.SetPoint(Point(n + nIndentWidth2, nVirBottom - 3), 4);
842 : }
843 : else
844 : {
845 317 : aPoly.SetPoint(Point(n + 0, nVirTop + nIndentHeight), 0);
846 317 : aPoly.SetPoint(Point(n - nIndentWidth2, nVirTop + 3), 1);
847 317 : aPoly.SetPoint(Point(n - nIndentWidth2, nVirTop), 2);
848 317 : aPoly.SetPoint(Point(n + nIndentWidth2, nVirTop), 3);
849 317 : aPoly.SetPoint(Point(n + nIndentWidth2, nVirTop + 3), 4);
850 : }
851 :
852 957 : if (0 == (mnWinStyle & WB_HORZ))
853 : {
854 0 : Point aTmp;
855 0 : for (sal_uInt16 i = 0; i < 5; i++)
856 : {
857 0 : aTmp = aPoly[i];
858 0 : Point aSet(nVirBottom - aTmp.Y(), aTmp.X());
859 0 : aPoly[i] = aSet;
860 : }
861 : }
862 957 : if (RULER_INDENT_BORDER != nIndentStyle)
863 : {
864 957 : bool bIsHit = false;
865 957 : if(mxCurrentHitTest.get() != NULL && mxCurrentHitTest->eType == RULER_TYPE_INDENT)
866 : {
867 0 : bIsHit = mxCurrentHitTest->nAryPos == j;
868 : }
869 957 : else if(mbDrag && meDragType == RULER_TYPE_INDENT)
870 : {
871 0 : bIsHit = mnDragAryPos == j;
872 : }
873 957 : ImplDrawIndent(rRenderContext, aPoly, nStyle, bIsHit);
874 : }
875 : }
876 323 : }
877 323 : }
878 :
879 10567 : static void ImplCenterTabPos(Point& rPos, sal_uInt16 nTabStyle)
880 : {
881 10567 : bool bRTL = 0 != (nTabStyle & RULER_TAB_RTL);
882 10567 : nTabStyle &= RULER_TAB_STYLE;
883 10567 : rPos.Y() += ruler_tab.height/2;
884 :
885 10567 : if ( (!bRTL && nTabStyle == RULER_TAB_LEFT) ||
886 0 : ( bRTL && nTabStyle == RULER_TAB_RIGHT) )
887 : {
888 10567 : rPos.X() -= ruler_tab.width / 2;
889 : }
890 0 : else if ( (!bRTL && nTabStyle == RULER_TAB_RIGHT) ||
891 0 : ( bRTL && nTabStyle == RULER_TAB_LEFT) )
892 : {
893 0 : rPos.X() += ruler_tab.width / 2;
894 : }
895 10567 : }
896 :
897 0 : static void lcl_RotateRect_Impl(Rectangle& rRect, const long nReference, bool bRightAligned)
898 : {
899 0 : if (!rRect.IsEmpty())
900 : {
901 0 : Rectangle aTmp(rRect);
902 0 : rRect.Top() = aTmp.Left();
903 0 : rRect.Bottom() = aTmp.Right();
904 0 : rRect.Left() = aTmp.Top();
905 0 : rRect.Right() = aTmp.Bottom();
906 :
907 0 : if (bRightAligned)
908 : {
909 0 : long nRef = 2 * nReference;
910 0 : rRect.Left() = nRef - rRect.Left();
911 0 : rRect.Right() = nRef - rRect.Right();
912 : }
913 : }
914 0 : }
915 :
916 14211 : static void ImplDrawRulerTab(vcl::RenderContext& rRenderContext, const Point& rPos,
917 : sal_uInt16 nStyle, WinBits nWinBits)
918 : {
919 14211 : if (nStyle & RULER_STYLE_INVISIBLE)
920 14211 : return;
921 :
922 14211 : sal_uInt16 nTabStyle = nStyle & RULER_TAB_STYLE;
923 14211 : bool bRTL = 0 != (nStyle & RULER_TAB_RTL);
924 :
925 : // Scale by the screen DPI scaling factor
926 : // However when doing this some of the rectangles
927 : // drawn become asymmetric due to the +1 offsets
928 14211 : sal_uInt16 DPIOffset = rRenderContext.GetDPIScaleFactor() - 1;
929 :
930 14211 : Rectangle aRect1;
931 14211 : Rectangle aRect2;
932 14211 : Rectangle aRect3;
933 :
934 14211 : aRect3.SetEmpty();
935 :
936 14211 : if (nTabStyle == RULER_TAB_DEFAULT)
937 : {
938 3644 : aRect1.Left() = rPos.X() - ruler_tab.dwidth2 + 1;
939 3644 : aRect1.Top() = rPos.Y() - ruler_tab.dheight2 + 1;
940 3644 : aRect1.Right() = rPos.X() - ruler_tab.dwidth2 + ruler_tab.dwidth + DPIOffset;
941 3644 : aRect1.Bottom() = rPos.Y();
942 :
943 3644 : aRect2.Left() = rPos.X() - ruler_tab.dwidth2 + ruler_tab.dwidth3;
944 3644 : aRect2.Top() = rPos.Y() - ruler_tab.dheight + 1;
945 3644 : aRect2.Right() = rPos.X() - ruler_tab.dwidth2 + ruler_tab.dwidth3 + ruler_tab.dwidth4 - 1;
946 3644 : aRect2.Bottom() = rPos.Y();
947 :
948 : }
949 10567 : else if ((!bRTL && nTabStyle == RULER_TAB_LEFT) || (bRTL && nTabStyle == RULER_TAB_RIGHT))
950 : {
951 10567 : aRect1.Left() = rPos.X();
952 10567 : aRect1.Top() = rPos.Y() - ruler_tab.height2 + 1;
953 10567 : aRect1.Right() = rPos.X() + ruler_tab.width - 1;
954 10567 : aRect1.Bottom() = rPos.Y();
955 :
956 10567 : aRect2.Left() = rPos.X();
957 10567 : aRect2.Top() = rPos.Y() - ruler_tab.height + 1;
958 10567 : aRect2.Right() = rPos.X() + ruler_tab.width2 - 1;
959 10567 : aRect2.Bottom() = rPos.Y();
960 : }
961 0 : else if ((!bRTL && nTabStyle == RULER_TAB_RIGHT) || (bRTL && nTabStyle == RULER_TAB_LEFT))
962 : {
963 0 : aRect1.Left() = rPos.X() - ruler_tab.width + 1;
964 0 : aRect1.Top() = rPos.Y() - ruler_tab.height2 + 1;
965 0 : aRect1.Right() = rPos.X();
966 0 : aRect1.Bottom() = rPos.Y();
967 :
968 0 : aRect2.Left() = rPos.X() - ruler_tab.width2 + 1;
969 0 : aRect2.Top() = rPos.Y() - ruler_tab.height + 1;
970 0 : aRect2.Right() = rPos.X();
971 0 : aRect2.Bottom() = rPos.Y();
972 : }
973 : else
974 : {
975 0 : aRect1.Left() = rPos.X() - ruler_tab.cwidth2 + 1;
976 0 : aRect1.Top() = rPos.Y() - ruler_tab.height2 + 1;
977 0 : aRect1.Right() = rPos.X() - ruler_tab.cwidth2 + ruler_tab.cwidth + DPIOffset;
978 0 : aRect1.Bottom() = rPos.Y();
979 :
980 0 : aRect2.Left() = rPos.X() - ruler_tab.cwidth2 + ruler_tab.cwidth3;
981 0 : aRect2.Top() = rPos.Y() - ruler_tab.height + 1;
982 0 : aRect2.Right() = rPos.X() - ruler_tab.cwidth2 + ruler_tab.cwidth3 + ruler_tab.cwidth4 - 1;
983 0 : aRect2.Bottom() = rPos.Y();
984 :
985 0 : if (nTabStyle == RULER_TAB_DECIMAL)
986 : {
987 0 : aRect3.Left() = rPos.X() - ruler_tab.cwidth2 + ruler_tab.cwidth - 1;
988 0 : aRect3.Top() = rPos.Y() - ruler_tab.height + 1 + 1 - DPIOffset;
989 0 : aRect3.Right() = rPos.X() - ruler_tab.cwidth2 + ruler_tab.cwidth + DPIOffset;
990 0 : aRect3.Bottom() = rPos.Y() - ruler_tab.height + 1 + 2;
991 : }
992 : }
993 14211 : if (0 == (nWinBits & WB_HORZ))
994 : {
995 0 : bool bRightAligned = 0 != (nWinBits & WB_RIGHT_ALIGNED);
996 0 : lcl_RotateRect_Impl(aRect1, rPos.Y(), bRightAligned);
997 0 : lcl_RotateRect_Impl(aRect2, rPos.Y(), bRightAligned);
998 0 : lcl_RotateRect_Impl(aRect3, rPos.Y(), bRightAligned);
999 : }
1000 14211 : rRenderContext.DrawRect(aRect1);
1001 14211 : rRenderContext.DrawRect(aRect2);
1002 :
1003 14211 : if (!aRect3.IsEmpty())
1004 0 : rRenderContext.DrawRect(aRect3);
1005 : }
1006 :
1007 14211 : void Ruler::ImplDrawTab(vcl::RenderContext& rRenderContext, const Point& rPos, sal_uInt16 nStyle)
1008 : {
1009 14211 : if (nStyle & RULER_STYLE_INVISIBLE)
1010 14211 : return;
1011 :
1012 14211 : rRenderContext.SetLineColor();
1013 :
1014 14211 : if (nStyle & RULER_STYLE_DONTKNOW)
1015 0 : rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetFaceColor());
1016 : else
1017 14211 : rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetDarkShadowColor());
1018 :
1019 14211 : if (mpData->bTextRTL)
1020 0 : nStyle |= RULER_TAB_RTL;
1021 :
1022 14211 : ImplDrawRulerTab(rRenderContext, rPos, nStyle, GetStyle());
1023 : }
1024 :
1025 282 : void Ruler::ImplDrawTabs(vcl::RenderContext& rRenderContext, long nMin, long nMax, long nVirTop, long nVirBottom)
1026 : {
1027 3928 : for (size_t i = 0; i < mpData->pTabs.size(); i++)
1028 : {
1029 3646 : if (mpData->pTabs[i].nStyle & RULER_STYLE_INVISIBLE)
1030 0 : continue;
1031 :
1032 : long aPosition;
1033 3646 : aPosition = mpData->pTabs[i].nPos;
1034 3646 : aPosition += +mpData->nNullVirOff;
1035 3646 : long nTopBottom = (GetStyle() & WB_RIGHT_ALIGNED) ? nVirTop : nVirBottom;
1036 3646 : if (nMin <= aPosition && aPosition <= nMax)
1037 3644 : ImplDrawTab(rRenderContext, Point( aPosition, nTopBottom ), mpData->pTabs[i].nStyle);
1038 : }
1039 282 : }
1040 :
1041 33252 : static int adjustSize(int nOrig)
1042 : {
1043 33252 : if (nOrig <= 0)
1044 16626 : return 0;
1045 :
1046 : // make sure we return an odd number, that looks better in the ruler
1047 16626 : return ( (3*nOrig) / 8) * 2 + 1;
1048 : }
1049 :
1050 10872 : void Ruler::ApplySettings(vcl::RenderContext& rRenderContext)
1051 : {
1052 10872 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1053 :
1054 10872 : vcl::Font aFont = rStyleSettings.GetToolFont();
1055 : // make the font a bit smaller than default
1056 10872 : Size aSize(adjustSize(aFont.GetSize().Width()), adjustSize(aFont.GetSize().Height()));
1057 10872 : aFont.SetSize(aSize);
1058 :
1059 10872 : ApplyControlFont(rRenderContext, aFont);
1060 :
1061 10872 : ApplyControlForeground(*this, rStyleSettings.GetDarkShadowColor());
1062 10872 : SetTextFillColor();
1063 :
1064 10872 : Color aColor;
1065 21744 : svtools::ColorConfig aColorConfig;
1066 10872 : aColor = Color(aColorConfig.GetColorValue(svtools::APPBACKGROUND).nColor);
1067 21744 : ApplyControlBackground(rRenderContext, aColor);
1068 10872 : }
1069 :
1070 5754 : void Ruler::ImplInitSettings(bool bFont, bool bForeground, bool bBackground)
1071 : {
1072 5754 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1073 :
1074 5754 : if (bFont)
1075 : {
1076 5754 : vcl::Font aFont = rStyleSettings.GetToolFont();
1077 : // make the font a bit smaller than default
1078 5754 : Size aSize(adjustSize(aFont.GetSize().Width()), adjustSize(aFont.GetSize().Height()));
1079 5754 : aFont.SetSize(aSize);
1080 :
1081 5754 : ApplyControlFont(*this, aFont);
1082 : }
1083 :
1084 5754 : if (bForeground || bFont)
1085 : {
1086 5754 : ApplyControlForeground(*this, rStyleSettings.GetDarkShadowColor());
1087 5754 : SetTextFillColor();
1088 : }
1089 :
1090 5754 : if (bBackground)
1091 : {
1092 5754 : Color aColor;
1093 5754 : svtools::ColorConfig aColorConfig;
1094 5754 : aColor = Color(aColorConfig.GetColorValue(svtools::APPBACKGROUND).nColor);
1095 5754 : ApplyControlBackground(*this, aColor);
1096 : }
1097 :
1098 5754 : maVirDev->SetSettings( GetSettings() );
1099 5754 : maVirDev->SetBackground( GetBackground() );
1100 5754 : vcl::Font aFont = GetFont();
1101 :
1102 5754 : if (mnWinStyle & WB_VERT)
1103 2877 : aFont.SetOrientation(900);
1104 :
1105 5754 : maVirDev->SetFont(aFont);
1106 5754 : maVirDev->SetTextColor(GetTextColor());
1107 5754 : maVirDev->SetTextFillColor(GetTextFillColor());
1108 5754 : }
1109 :
1110 10742 : void Ruler::ImplCalc()
1111 : {
1112 : // calculate offset
1113 10742 : mpData->nRulVirOff = mnWinOff + mpData->nPageOff;
1114 10742 : if ( mpData->nRulVirOff > mnVirOff )
1115 75 : mpData->nRulVirOff -= mnVirOff;
1116 : else
1117 10667 : mpData->nRulVirOff = 0;
1118 10742 : long nRulWinOff = mpData->nRulVirOff+mnVirOff;
1119 :
1120 : // calculate non-visual part of the page
1121 : long nNotVisPageWidth;
1122 10742 : if ( mpData->nPageOff < 0 )
1123 : {
1124 89 : nNotVisPageWidth = -(mpData->nPageOff);
1125 89 : if ( nRulWinOff < mnWinOff )
1126 43 : nNotVisPageWidth -= mnWinOff-nRulWinOff;
1127 : }
1128 : else
1129 10653 : nNotVisPageWidth = 0;
1130 :
1131 : // calculate width
1132 10742 : if ( mnWinStyle & WB_HORZ )
1133 : {
1134 10627 : if ( mbAutoWinWidth )
1135 10627 : mnWinWidth = mnWidth - mnVirOff;
1136 10627 : if ( mpData->bAutoPageWidth )
1137 10307 : mpData->nPageWidth = mnWinWidth;
1138 10627 : mpData->nRulWidth = std::min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth );
1139 10627 : if ( nRulWinOff+mpData->nRulWidth > mnWidth )
1140 71 : mpData->nRulWidth = mnWidth-nRulWinOff;
1141 : }
1142 : else
1143 : {
1144 115 : if ( mbAutoWinWidth )
1145 115 : mnWinWidth = mnHeight - mnVirOff;
1146 115 : if ( mpData->bAutoPageWidth )
1147 67 : mpData->nPageWidth = mnWinWidth;
1148 115 : mpData->nRulWidth = std::min( mnWinWidth, mpData->nPageWidth-nNotVisPageWidth );
1149 115 : if ( nRulWinOff+mpData->nRulWidth > mnHeight )
1150 0 : mpData->nRulWidth = mnHeight-nRulWinOff;
1151 : }
1152 :
1153 10742 : mbCalc = false;
1154 10742 : }
1155 :
1156 10751 : void Ruler::ImplFormat(vcl::RenderContext& rRenderContext)
1157 : {
1158 : // if already formatted, don't do it again
1159 10751 : if (!mbFormat)
1160 0 : return;
1161 :
1162 : // don't do anything if the window still has no size
1163 10751 : if (!mnVirWidth)
1164 0 : return;
1165 :
1166 10751 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1167 : long nP1; // pixel position of Page1
1168 : long nP2; // pixel position of Page2
1169 : long nM1; // pixel position of Margin1
1170 : long nM2; // pixel position of Margin2
1171 : long nVirTop; // top/left corner
1172 : long nVirBottom; // bottom/right corner
1173 : long nVirLeft; // left/top corner
1174 : long nVirRight; // right/bottom corner
1175 : long nNullVirOff; // for faster calculation
1176 :
1177 : // calculate values
1178 10751 : if (mbCalc)
1179 10742 : ImplCalc();
1180 :
1181 10751 : mpData->nNullVirOff = mnWinOff + mpData->nPageOff + mpData->nNullOff - mnVirOff;
1182 :
1183 10751 : nNullVirOff = mpData->nNullVirOff;
1184 10751 : nVirLeft = mpData->nRulVirOff;
1185 10751 : nVirRight = nVirLeft + mpData->nRulWidth - 1;
1186 10751 : nVirTop = 0;
1187 10751 : nVirBottom = mnVirHeight - 1;
1188 :
1189 10751 : if (!IsReallyVisible())
1190 0 : return;
1191 :
1192 10751 : Size aVirDevSize;
1193 :
1194 : // initialize VirtualDevice
1195 10751 : if (mnWinStyle & WB_HORZ)
1196 : {
1197 10633 : aVirDevSize.Width() = mnVirWidth;
1198 10633 : aVirDevSize.Height() = mnVirHeight;
1199 : }
1200 : else
1201 : {
1202 118 : aVirDevSize.Height() = mnVirWidth;
1203 118 : aVirDevSize.Width() = mnVirHeight;
1204 : }
1205 10751 : if (aVirDevSize != maVirDev->GetOutputSizePixel())
1206 4790 : maVirDev->SetOutputSizePixel(aVirDevSize, true);
1207 : else
1208 5961 : maVirDev->Erase();
1209 :
1210 : // calculate margins
1211 10751 : if (!(mpData->nMargin1Style & RULER_STYLE_INVISIBLE))
1212 : {
1213 377 : nM1 = mpData->nMargin1 + nNullVirOff;
1214 377 : if (mpData->bAutoPageWidth)
1215 : {
1216 3 : nP1 = nVirLeft;
1217 3 : if (nM1 < nVirLeft)
1218 0 : nP1--;
1219 : }
1220 : else
1221 374 : nP1 = nNullVirOff - mpData->nNullOff;
1222 : }
1223 : else
1224 : {
1225 10374 : nM1 = nVirLeft-1;
1226 10374 : nP1 = nM1;
1227 : }
1228 10751 : if (!(mpData->nMargin2Style & RULER_STYLE_INVISIBLE))
1229 : {
1230 377 : nM2 = mpData->nMargin2 + nNullVirOff;
1231 377 : if (mpData->bAutoPageWidth)
1232 : {
1233 3 : nP2 = nVirRight;
1234 3 : if (nM2 > nVirRight)
1235 0 : nP2++;
1236 : }
1237 : else
1238 374 : nP2 = nNullVirOff - mpData->nNullOff + mpData->nPageWidth;
1239 377 : if (nM2 > nP2)
1240 0 : nM2 = nP2;
1241 : }
1242 : else
1243 : {
1244 10374 : nM2 = nVirRight+1;
1245 10374 : nP2 = nM2;
1246 : }
1247 :
1248 : // top/bottom border
1249 10751 : maVirDev->SetLineColor(rStyleSettings.GetShadowColor());
1250 10751 : ImplVDrawLine(*maVirDev.get(), nVirLeft, nVirTop + 1, nM1, nVirTop + 1); //top left line
1251 10751 : ImplVDrawLine(*maVirDev.get(), nM2, nVirTop + 1, nP2 - 1, nVirTop + 1); //top right line
1252 :
1253 10751 : nVirTop++;
1254 10751 : nVirBottom--;
1255 :
1256 : // draw margin1, margin2 and in-between
1257 10751 : maVirDev->SetLineColor();
1258 10751 : maVirDev->SetFillColor(rStyleSettings.GetDialogColor());
1259 10751 : if (nM1 > nVirLeft)
1260 371 : ImplVDrawRect(*maVirDev.get(), nP1, nVirTop + 1, nM1, nVirBottom); //left gray rectangle
1261 10751 : if (nM2 < nP2)
1262 377 : ImplVDrawRect(*maVirDev.get(), nM2, nVirTop + 1, nP2, nVirBottom); //right gray rectangle
1263 10751 : if (nM2 - nM1 > 0)
1264 : {
1265 10751 : maVirDev->SetFillColor(rStyleSettings.GetWindowColor());
1266 10751 : ImplVDrawRect(*maVirDev.get(), nM1 + 1, nVirTop, nM2 - 1, nVirBottom); //center rectangle
1267 : }
1268 10751 : maVirDev->SetLineColor(rStyleSettings.GetShadowColor());
1269 10751 : if (nM1 > nVirLeft)
1270 : {
1271 371 : ImplVDrawLine(*maVirDev.get(), nM1, nVirTop + 1, nM1, nVirBottom); //right line of the left rectangle
1272 371 : ImplVDrawLine(*maVirDev.get(), nP1, nVirBottom, nM1, nVirBottom); //bottom line of the left rectangle
1273 371 : if (nP1 >= nVirLeft)
1274 : {
1275 15 : ImplVDrawLine(*maVirDev.get(), nP1, nVirTop + 1, nP1, nVirBottom); //left line of the left rectangle
1276 15 : ImplVDrawLine(*maVirDev.get(), nP1, nVirBottom, nP1 + 1, nVirBottom); //?
1277 : }
1278 : }
1279 10751 : if (nM2 < nP2)
1280 : {
1281 377 : ImplVDrawLine(*maVirDev.get(), nM2, nVirBottom, nP2 - 1, nVirBottom); //bottom line of the right rectangle
1282 377 : ImplVDrawLine(*maVirDev.get(), nM2, nVirTop + 1, nM2, nVirBottom); //left line of the right rectangle
1283 377 : if (nP2 <= nVirRight + 1)
1284 13 : ImplVDrawLine(*maVirDev.get(), nP2 - 1, nVirTop + 1, nP2 - 1, nVirBottom); //right line of the right rectangle
1285 : }
1286 :
1287 10751 : long nMin = nVirLeft;
1288 10751 : long nMax = nP2;
1289 10751 : long nStart = 0;
1290 :
1291 10751 : if (mpData->bTextRTL)
1292 0 : nStart = mpData->nRightFrameMargin + nNullVirOff;
1293 : else
1294 10751 : nStart = mpData->nLeftFrameMargin + nNullVirOff;
1295 :
1296 10751 : if (nP1 > nVirLeft)
1297 0 : nMin++;
1298 :
1299 10751 : if (nP2 < nVirRight)
1300 6 : nMax--;
1301 :
1302 : // Draw captions
1303 10751 : ImplDrawTicks(*maVirDev.get(), nMin, nMax, nStart, nVirTop, nVirBottom);
1304 :
1305 : // Draw borders
1306 10751 : if (!mpData->pBorders.empty())
1307 2 : ImplDrawBorders(*maVirDev.get(), nVirLeft, nP2, nVirTop, nVirBottom);
1308 :
1309 : // Draw indents
1310 10751 : if (!mpData->pIndents.empty())
1311 323 : ImplDrawIndents(*maVirDev.get(), nVirLeft, nP2, nVirTop - 1, nVirBottom + 1);
1312 :
1313 : // Tabs
1314 10751 : if (!mpData->pTabs.empty())
1315 282 : ImplDrawTabs(*maVirDev.get(), nVirLeft, nP2, nVirTop-1, nVirBottom + 1);
1316 :
1317 10751 : mbFormat = false;
1318 : }
1319 :
1320 24561 : void Ruler::ImplInitExtraField( bool bUpdate )
1321 : {
1322 24561 : Size aWinSize = GetOutputSizePixel();
1323 :
1324 : // extra field evaluate
1325 24561 : if ( mnWinStyle & WB_EXTRAFIELD )
1326 : {
1327 23501 : maExtraRect.Left() = RULER_OFF;
1328 23501 : maExtraRect.Top() = RULER_OFF;
1329 23501 : maExtraRect.Right() = RULER_OFF + mnVirHeight - 1;
1330 23501 : maExtraRect.Bottom() = RULER_OFF + mnVirHeight - 1;
1331 23501 : if(mpData->bTextRTL)
1332 : {
1333 0 : if(mnWinStyle & WB_HORZ)
1334 0 : maExtraRect.Move(aWinSize.Width() - maExtraRect.GetWidth() - maExtraRect.Left(), 0);
1335 : else
1336 0 : maExtraRect.Move(0, aWinSize.Height() - maExtraRect.GetHeight() - maExtraRect.Top());
1337 0 : mnVirOff = 0;
1338 : }
1339 : else
1340 23501 : mnVirOff = maExtraRect.Right()+1;
1341 :
1342 : }
1343 : else
1344 : {
1345 1060 : maExtraRect.SetEmpty();
1346 1060 : mnVirOff = 0;
1347 : }
1348 :
1349 : // mnVirWidth depends on mnVirOff
1350 54626 : if ( (mnVirWidth > RULER_MIN_SIZE) ||
1351 14400 : ((aWinSize.Width() > RULER_MIN_SIZE) && (aWinSize.Height() > RULER_MIN_SIZE)) )
1352 : {
1353 21442 : if ( mnWinStyle & WB_HORZ )
1354 7357 : mnVirWidth = aWinSize.Width()-mnVirOff;
1355 : else
1356 14085 : mnVirWidth = aWinSize.Height()-mnVirOff;
1357 :
1358 21442 : if ( mnVirWidth < RULER_MIN_SIZE )
1359 0 : mnVirWidth = 0;
1360 : }
1361 :
1362 24561 : if ( bUpdate )
1363 : {
1364 376 : mbCalc = true;
1365 376 : mbFormat = true;
1366 376 : Invalidate();
1367 : }
1368 24561 : }
1369 :
1370 10872 : void Ruler::ImplDraw(vcl::RenderContext& rRenderContext)
1371 : {
1372 10872 : if (mbFormat)
1373 : {
1374 10751 : ImplFormat(rRenderContext);
1375 : }
1376 :
1377 10872 : if (IsReallyVisible())
1378 : {
1379 : // output the ruler to the virtual device
1380 10872 : Point aOffPos;
1381 10872 : Size aVirDevSize = maVirDev->GetOutputSizePixel();
1382 :
1383 10872 : if (mnWinStyle & WB_HORZ)
1384 : {
1385 10710 : aOffPos.X() = mnVirOff;
1386 10710 : if (mpData->bTextRTL)
1387 0 : aVirDevSize.Width() -= maExtraRect.GetWidth();
1388 :
1389 10710 : aOffPos.Y() = RULER_OFF;
1390 : }
1391 : else
1392 : {
1393 162 : aOffPos.X() = RULER_OFF;
1394 162 : aOffPos.Y() = mnVirOff;
1395 : }
1396 10872 : rRenderContext.DrawOutDev(aOffPos, aVirDevSize, Point(), aVirDevSize, *maVirDev.get());
1397 :
1398 : // redraw positionlines
1399 10872 : ImplInvertLines(rRenderContext, true);
1400 : }
1401 10872 : }
1402 :
1403 10702 : void Ruler::ImplDrawExtra(vcl::RenderContext& rRenderContext, bool bPaint)
1404 : {
1405 10702 : const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1406 10702 : Rectangle aRect = maExtraRect;
1407 10702 : bool bEraseRect = false;
1408 :
1409 10702 : aRect.Left() += 2;
1410 10702 : aRect.Top() += 2;
1411 10702 : aRect.Right() -= 2;
1412 10702 : aRect.Bottom() -= 2;
1413 :
1414 10702 : if (!bPaint && !(mnExtraStyle & RULER_STYLE_HIGHLIGHT))
1415 : {
1416 0 : rRenderContext.SetFillColor(rStyleSettings.GetWorkspaceColor());
1417 0 : bEraseRect = true;
1418 : }
1419 : else
1420 : {
1421 10702 : if (mnExtraStyle & RULER_STYLE_HIGHLIGHT)
1422 : {
1423 0 : rRenderContext.SetFillColor(rStyleSettings.GetCheckedColor());
1424 0 : bEraseRect = true;
1425 : }
1426 : }
1427 :
1428 10702 : if (bEraseRect)
1429 : {
1430 0 : rRenderContext.SetLineColor();
1431 0 : rRenderContext.DrawRect(aRect);
1432 : }
1433 :
1434 : // output content
1435 10702 : if (meExtraType == RULER_EXTRA_NULLOFFSET)
1436 : {
1437 135 : rRenderContext.SetLineColor(rStyleSettings.GetButtonTextColor());
1438 270 : rRenderContext.DrawLine(Point(aRect.Left() + 1, aRect.Top() + 4),
1439 405 : Point(aRect.Right() - 1, aRect.Top() + 4));
1440 270 : rRenderContext.DrawLine(Point(aRect.Left() + 4, aRect.Top() + 1),
1441 405 : Point(aRect.Left() + 4, aRect.Bottom() - 1));
1442 : }
1443 10567 : else if (meExtraType == RULER_EXTRA_TAB)
1444 : {
1445 10567 : sal_uInt16 nTabStyle = mnExtraStyle & RULER_TAB_STYLE;
1446 10567 : if (mpData->bTextRTL)
1447 0 : nTabStyle |= RULER_TAB_RTL;
1448 10567 : Point aCenter = aRect.Center();
1449 10567 : Point aDraw(aCenter);
1450 10567 : ImplCenterTabPos(aDraw, nTabStyle);
1451 10567 : WinBits nWinBits = GetStyle();
1452 10567 : if (0 == (nWinBits & WB_HORZ))
1453 : {
1454 0 : if ((nWinBits & WB_RIGHT_ALIGNED) != 0)
1455 0 : aDraw.Y() = 2 * aCenter.Y() - aDraw.Y();
1456 :
1457 0 : if (mpData->bTextRTL)
1458 : {
1459 0 : long nTemp = aDraw.X();
1460 0 : aDraw.X() = aDraw.Y();
1461 0 : aDraw.Y() = nTemp;
1462 : }
1463 : }
1464 10567 : ImplDrawTab(rRenderContext, aDraw, nTabStyle);
1465 : }
1466 10702 : }
1467 :
1468 50677 : void Ruler::ImplUpdate( bool bMustCalc )
1469 : {
1470 : // clear lines in this place so they aren't considered at recalculation
1471 50677 : if (!mbFormat)
1472 10073 : Invalidate(InvalidateFlags::NoErase);
1473 :
1474 : // set flags
1475 50677 : if (bMustCalc)
1476 28940 : mbCalc = true;
1477 50677 : mbFormat = true;
1478 :
1479 : // abort if we are dragging as drag-handler will update the ruler after drag is finished
1480 50677 : if (mbDrag)
1481 50677 : return;
1482 :
1483 : // otherwise trigger update
1484 50677 : if (IsReallyVisible() && IsUpdateMode())
1485 : {
1486 17518 : Invalidate(InvalidateFlags::NoErase);
1487 : }
1488 : }
1489 :
1490 0 : bool Ruler::ImplHitTest( const Point& rPos, RulerSelection* pHitTest,
1491 : bool bRequireStyle, sal_uInt16 nRequiredStyle ) const
1492 : {
1493 : sal_Int32 i;
1494 : sal_uInt16 nStyle;
1495 : long nHitBottom;
1496 : long nX;
1497 : long nY;
1498 : long n1;
1499 :
1500 0 : if ( !mbActive )
1501 0 : return false;
1502 :
1503 : // determine positions
1504 0 : bool bIsHori = 0 != (mnWinStyle & WB_HORZ);
1505 0 : if ( bIsHori )
1506 : {
1507 0 : nX = rPos.X();
1508 0 : nY = rPos.Y();
1509 : }
1510 : else
1511 : {
1512 0 : nX = rPos.Y();
1513 0 : nY = rPos.X();
1514 : }
1515 0 : nHitBottom = mnVirHeight + (RULER_OFF * 2);
1516 :
1517 : // #i32608#
1518 0 : pHitTest->nAryPos = 0;
1519 0 : pHitTest->mnDragSize = 0;
1520 0 : pHitTest->bSize = false;
1521 0 : pHitTest->bSizeBar = false;
1522 :
1523 : // so that leftover tabs and indents are taken into account
1524 : long nXExtraOff;
1525 0 : if ( !mpData->pTabs.empty() || !mpData->pIndents.empty() )
1526 0 : nXExtraOff = (mnVirHeight / 2) - 4;
1527 : else
1528 0 : nXExtraOff = 0;
1529 :
1530 : // test if outside
1531 0 : nX -= mnVirOff;
1532 0 : long nXTemp = nX;
1533 0 : if ( (nX < mpData->nRulVirOff - nXExtraOff) ||
1534 0 : (nX > mpData->nRulVirOff + mpData->nRulWidth + nXExtraOff) ||
1535 0 : (nY < 0) ||
1536 : (nY > nHitBottom) )
1537 : {
1538 0 : pHitTest->nPos = 0;
1539 0 : pHitTest->eType = RULER_TYPE_OUTSIDE;
1540 0 : return false;
1541 : }
1542 :
1543 0 : nX -= mpData->nNullVirOff;
1544 0 : pHitTest->nPos = nX;
1545 0 : pHitTest->eType = RULER_TYPE_DONTKNOW;
1546 :
1547 : // first test the tabs
1548 0 : Rectangle aRect;
1549 0 : if ( !mpData->pTabs.empty() )
1550 : {
1551 0 : aRect.Bottom() = nHitBottom;
1552 0 : aRect.Top() = aRect.Bottom() - ruler_tab.height - RULER_OFF;
1553 :
1554 0 : for ( i = mpData->pTabs.size() - 1; i >= 0; i-- )
1555 : {
1556 0 : nStyle = mpData->pTabs[i].nStyle;
1557 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1558 : {
1559 0 : nStyle &= RULER_TAB_STYLE;
1560 :
1561 : // default tabs are only shown (no action)
1562 0 : if ( nStyle != RULER_TAB_DEFAULT )
1563 : {
1564 0 : n1 = mpData->pTabs[i].nPos;
1565 :
1566 0 : if ( nStyle == RULER_TAB_LEFT )
1567 : {
1568 0 : aRect.Left() = n1;
1569 0 : aRect.Right() = n1 + ruler_tab.width - 1;
1570 : }
1571 0 : else if ( nStyle == RULER_TAB_RIGHT )
1572 : {
1573 0 : aRect.Right() = n1;
1574 0 : aRect.Left() = n1 - ruler_tab.width - 1;
1575 : }
1576 : else
1577 : {
1578 0 : aRect.Left() = n1 - ruler_tab.cwidth2 + 1;
1579 0 : aRect.Right() = n1 - ruler_tab.cwidth2 + ruler_tab.cwidth;
1580 : }
1581 :
1582 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1583 : {
1584 0 : pHitTest->eType = RULER_TYPE_TAB;
1585 0 : pHitTest->nAryPos = i;
1586 0 : return true;
1587 : }
1588 : }
1589 : }
1590 : }
1591 : }
1592 :
1593 : // Indents
1594 0 : if ( !mpData->pIndents.empty() )
1595 : {
1596 0 : long nIndentHeight = (mnVirHeight / 2) - 1;
1597 0 : long nIndentWidth2 = nIndentHeight - 3;
1598 :
1599 0 : for ( i = mpData->pIndents.size(); i; i-- )
1600 : {
1601 0 : nStyle = mpData->pIndents[i-1].nStyle;
1602 0 : if ( (! bRequireStyle || nStyle == nRequiredStyle) &&
1603 0 : !(nStyle & RULER_STYLE_INVISIBLE) )
1604 : {
1605 0 : nStyle &= RULER_INDENT_STYLE;
1606 0 : n1 = mpData->pIndents[i-1].nPos;
1607 :
1608 0 : if ( (nStyle == RULER_INDENT_BOTTOM) != !bIsHori )
1609 : {
1610 0 : aRect.Left() = n1-nIndentWidth2;
1611 0 : aRect.Right() = n1+nIndentWidth2;
1612 0 : aRect.Top() = nHitBottom-nIndentHeight-RULER_OFF+1;
1613 0 : aRect.Bottom() = nHitBottom;
1614 : }
1615 : else
1616 : {
1617 0 : aRect.Left() = n1-nIndentWidth2;
1618 0 : aRect.Right() = n1+nIndentWidth2;
1619 0 : aRect.Top() = 0;
1620 0 : aRect.Bottom() = nIndentHeight+RULER_OFF-1;
1621 : }
1622 :
1623 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1624 : {
1625 0 : pHitTest->eType = RULER_TYPE_INDENT;
1626 0 : pHitTest->nAryPos = i-1;
1627 0 : return true;
1628 : }
1629 : }
1630 : }
1631 : }
1632 :
1633 : // everything left and right is outside and don't take this into account
1634 0 : if ( (nXTemp < mpData->nRulVirOff) || (nXTemp > mpData->nRulVirOff+mpData->nRulWidth) )
1635 : {
1636 0 : pHitTest->nPos = 0;
1637 0 : pHitTest->eType = RULER_TYPE_OUTSIDE;
1638 0 : return false;
1639 : }
1640 :
1641 : // test the borders
1642 0 : int nBorderTolerance = 1;
1643 0 : if(pHitTest->bExpandTest)
1644 : {
1645 0 : nBorderTolerance++;
1646 : }
1647 :
1648 0 : for ( i = mpData->pBorders.size(); i; i-- )
1649 : {
1650 0 : n1 = mpData->pBorders[i-1].nPos;
1651 0 : long n2 = n1 + mpData->pBorders[i-1].nWidth;
1652 :
1653 : // borders have at least 3 pixel padding
1654 0 : if ( !mpData->pBorders[i-1].nWidth )
1655 : {
1656 0 : n1 -= nBorderTolerance;
1657 0 : n2 += nBorderTolerance;
1658 :
1659 : }
1660 :
1661 0 : if ( (nX >= n1) && (nX <= n2) )
1662 : {
1663 0 : nStyle = mpData->pBorders[i-1].nStyle;
1664 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1665 : {
1666 0 : pHitTest->eType = RULER_TYPE_BORDER;
1667 0 : pHitTest->nAryPos = i-1;
1668 :
1669 0 : if ( !(nStyle & RULER_BORDER_SIZEABLE) )
1670 : {
1671 0 : if ( nStyle & RULER_BORDER_MOVEABLE )
1672 : {
1673 0 : pHitTest->bSizeBar = true;
1674 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE;
1675 : }
1676 : }
1677 : else
1678 : {
1679 0 : long nMOff = RULER_MOUSE_BORDERWIDTH;
1680 0 : while ( nMOff*2 >= (n2-n1-RULER_MOUSE_BORDERMOVE) )
1681 : {
1682 0 : if ( nMOff < 2 )
1683 : {
1684 0 : nMOff = 0;
1685 0 : break;
1686 : }
1687 : else
1688 0 : nMOff--;
1689 : }
1690 :
1691 0 : if ( nX <= n1+nMOff )
1692 : {
1693 0 : pHitTest->bSize = true;
1694 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_1;
1695 : }
1696 0 : else if ( nX >= n2-nMOff )
1697 : {
1698 0 : pHitTest->bSize = true;
1699 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_2;
1700 : }
1701 : else
1702 : {
1703 0 : if ( nStyle & RULER_BORDER_MOVEABLE )
1704 : {
1705 0 : pHitTest->bSizeBar = true;
1706 0 : pHitTest->mnDragSize = RULER_DRAGSIZE_MOVE;
1707 : }
1708 : }
1709 : }
1710 :
1711 0 : return true;
1712 : }
1713 : }
1714 : }
1715 :
1716 : // Margins
1717 0 : int nMarginTolerance = pHitTest->bExpandTest ? nBorderTolerance : RULER_MOUSE_MARGINWIDTH;
1718 :
1719 0 : if ( (mpData->nMargin1Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE )
1720 : {
1721 0 : n1 = mpData->nMargin1;
1722 0 : if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) )
1723 : {
1724 0 : pHitTest->eType = RULER_TYPE_MARGIN1;
1725 0 : pHitTest->bSize = true;
1726 0 : return true;
1727 : }
1728 : }
1729 0 : if ( (mpData->nMargin2Style & (RULER_MARGIN_SIZEABLE | RULER_STYLE_INVISIBLE)) == RULER_MARGIN_SIZEABLE )
1730 : {
1731 0 : n1 = mpData->nMargin2;
1732 0 : if ( (nX >= n1 - nMarginTolerance) && (nX <= n1 + nMarginTolerance) )
1733 : {
1734 0 : pHitTest->eType = RULER_TYPE_MARGIN2;
1735 0 : pHitTest->bSize = true;
1736 0 : return true;
1737 : }
1738 : }
1739 :
1740 : // test tabs again
1741 0 : if ( !mpData->pTabs.empty() )
1742 : {
1743 0 : aRect.Top() = RULER_OFF;
1744 0 : aRect.Bottom() = nHitBottom;
1745 :
1746 0 : for ( i = mpData->pTabs.size() - 1; i >= 0; i-- )
1747 : {
1748 0 : nStyle = mpData->pTabs[i].nStyle;
1749 0 : if ( !(nStyle & RULER_STYLE_INVISIBLE) )
1750 : {
1751 0 : nStyle &= RULER_TAB_STYLE;
1752 :
1753 : // default tabs are only shown (no action)
1754 0 : if ( nStyle != RULER_TAB_DEFAULT )
1755 : {
1756 0 : n1 = mpData->pTabs[i].nPos;
1757 :
1758 0 : if ( nStyle == RULER_TAB_LEFT )
1759 : {
1760 0 : aRect.Left() = n1;
1761 0 : aRect.Right() = n1 + ruler_tab.width - 1;
1762 : }
1763 0 : else if ( nStyle == RULER_TAB_RIGHT )
1764 : {
1765 0 : aRect.Right() = n1;
1766 0 : aRect.Left() = n1 - ruler_tab.width - 1;
1767 : }
1768 : else
1769 : {
1770 0 : aRect.Left() = n1 - ruler_tab.cwidth2 + 1;
1771 0 : aRect.Right() = n1 - ruler_tab.cwidth2 + ruler_tab.cwidth;
1772 : }
1773 :
1774 0 : aRect.Left()--;
1775 0 : aRect.Right()++;
1776 :
1777 0 : if ( aRect.IsInside( Point( nX, nY ) ) )
1778 : {
1779 0 : pHitTest->eType = RULER_TYPE_TAB;
1780 0 : pHitTest->nAryPos = i;
1781 0 : return true;
1782 : }
1783 : }
1784 : }
1785 : }
1786 : }
1787 :
1788 0 : return false;
1789 : }
1790 :
1791 0 : bool Ruler::ImplDocHitTest( const Point& rPos, RulerType eDragType,
1792 : RulerSelection* pHitTest ) const
1793 : {
1794 0 : Point aPos = rPos;
1795 0 : bool bRequiredStyle = false;
1796 0 : sal_uInt16 nRequiredStyle = 0;
1797 :
1798 0 : if (eDragType == RULER_TYPE_INDENT)
1799 : {
1800 0 : bRequiredStyle = true;
1801 0 : nRequiredStyle = RULER_INDENT_BOTTOM;
1802 : }
1803 :
1804 0 : if ( mnWinStyle & WB_HORZ )
1805 0 : aPos.X() += mnWinOff;
1806 : else
1807 0 : aPos.Y() += mnWinOff;
1808 :
1809 0 : if ( (eDragType == RULER_TYPE_INDENT) || (eDragType == RULER_TYPE_DONTKNOW) )
1810 : {
1811 0 : if ( mnWinStyle & WB_HORZ )
1812 0 : aPos.Y() = RULER_OFF + 1;
1813 : else
1814 0 : aPos.X() = RULER_OFF + 1;
1815 :
1816 0 : if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) )
1817 : {
1818 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1819 0 : return true;
1820 : }
1821 : }
1822 :
1823 0 : if ( (eDragType == RULER_TYPE_INDENT) ||
1824 0 : (eDragType == RULER_TYPE_TAB) ||
1825 : (eDragType == RULER_TYPE_DONTKNOW) )
1826 : {
1827 0 : if ( mnWinStyle & WB_HORZ )
1828 0 : aPos.Y() = mnHeight - RULER_OFF - 1;
1829 : else
1830 0 : aPos.X() = mnWidth - RULER_OFF - 1;
1831 :
1832 0 : if ( ImplHitTest( aPos, pHitTest, bRequiredStyle, nRequiredStyle ) )
1833 : {
1834 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1835 0 : return true;
1836 : }
1837 : }
1838 :
1839 0 : if ( (eDragType == RULER_TYPE_MARGIN1) || (eDragType == RULER_TYPE_MARGIN2) ||
1840 0 : (eDragType == RULER_TYPE_BORDER) || (eDragType == RULER_TYPE_DONTKNOW) )
1841 : {
1842 0 : if ( mnWinStyle & WB_HORZ )
1843 0 : aPos.Y() = RULER_OFF + (mnVirHeight / 2);
1844 : else
1845 0 : aPos.X() = RULER_OFF + (mnVirHeight / 2);
1846 :
1847 0 : if ( ImplHitTest( aPos, pHitTest ) )
1848 : {
1849 0 : if ( (pHitTest->eType == eDragType) || (eDragType == RULER_TYPE_DONTKNOW) )
1850 0 : return true;
1851 : }
1852 : }
1853 :
1854 0 : pHitTest->eType = RULER_TYPE_DONTKNOW;
1855 :
1856 0 : return false;
1857 : }
1858 :
1859 0 : bool Ruler::ImplStartDrag( RulerSelection* pHitTest, sal_uInt16 nModifier )
1860 : {
1861 : // don't trigger drag if a border that was clicked can not be changed
1862 0 : if ( (pHitTest->eType == RULER_TYPE_BORDER) &&
1863 0 : !pHitTest->bSize && !pHitTest->bSizeBar )
1864 0 : return false;
1865 :
1866 : // Set drag data
1867 0 : meDragType = pHitTest->eType;
1868 0 : mnDragPos = pHitTest->nPos;
1869 0 : mnDragAryPos = pHitTest->nAryPos;
1870 0 : mnDragSize = pHitTest->mnDragSize;
1871 0 : mnDragModifier = nModifier;
1872 0 : *mpDragData = *mpSaveData;
1873 0 : mpData = mpDragData;
1874 :
1875 : // call handler
1876 0 : if (StartDrag())
1877 : {
1878 : // if the handler allows dragging, initialize dragging
1879 0 : mbDrag = true;
1880 0 : mnStartDragPos = mnDragPos;
1881 0 : StartTracking();
1882 0 : Invalidate(InvalidateFlags::NoErase);
1883 0 : return true;
1884 : }
1885 : else
1886 : {
1887 : // otherwise reset the data
1888 0 : meDragType = RULER_TYPE_DONTKNOW;
1889 0 : mnDragPos = 0;
1890 0 : mnDragAryPos = 0;
1891 0 : mnDragSize = 0;
1892 0 : mnDragModifier = 0;
1893 0 : mpData = mpSaveData;
1894 : }
1895 :
1896 0 : return false;
1897 : }
1898 :
1899 0 : void Ruler::ImplDrag( const Point& rPos )
1900 : {
1901 : long nX;
1902 : long nY;
1903 : long nOutHeight;
1904 :
1905 0 : if ( mnWinStyle & WB_HORZ )
1906 : {
1907 0 : nX = rPos.X();
1908 0 : nY = rPos.Y();
1909 0 : nOutHeight = mnHeight;
1910 : }
1911 : else
1912 : {
1913 0 : nX = rPos.Y();
1914 0 : nY = rPos.X();
1915 0 : nOutHeight = mnWidth;
1916 : }
1917 :
1918 : // calculate and fit X
1919 0 : nX -= mnVirOff;
1920 0 : if ( nX < mpData->nRulVirOff )
1921 : {
1922 0 : nX = mpData->nRulVirOff;
1923 : }
1924 0 : else if ( nX > mpData->nRulVirOff+mpData->nRulWidth )
1925 : {
1926 0 : nX = mpData->nRulVirOff+mpData->nRulWidth;
1927 : }
1928 0 : nX -= mpData->nNullVirOff;
1929 :
1930 : // if upper or left from ruler, then consider old values
1931 0 : mbDragDelete = false;
1932 0 : if ( nY < 0 )
1933 : {
1934 0 : if ( !mbDragCanceled )
1935 : {
1936 : // reset the data
1937 0 : mbDragCanceled = true;
1938 0 : ImplRulerData aTempData;
1939 0 : aTempData = *mpDragData;
1940 0 : *mpDragData = *mpSaveData;
1941 0 : mbCalc = true;
1942 0 : mbFormat = true;
1943 :
1944 : // call handler
1945 0 : mnDragPos = mnStartDragPos;
1946 0 : Drag();
1947 :
1948 : // and redraw
1949 0 : Invalidate(InvalidateFlags::NoErase);
1950 :
1951 : // reset the data as before cancel
1952 0 : *mpDragData = aTempData;
1953 : }
1954 : }
1955 : else
1956 : {
1957 0 : mbDragCanceled = false;
1958 :
1959 : // +2, so the tabs are not cleared too quickly
1960 0 : if ( nY > nOutHeight + 2 )
1961 0 : mbDragDelete = true;
1962 :
1963 0 : mnDragPos = nX;
1964 :
1965 : // call handler
1966 0 : Drag();
1967 :
1968 : // redraw
1969 0 : if (mbFormat)
1970 0 : Invalidate(InvalidateFlags::NoErase);
1971 : }
1972 0 : }
1973 :
1974 0 : void Ruler::ImplEndDrag()
1975 : {
1976 : // get values
1977 0 : if ( mbDragCanceled )
1978 0 : *mpDragData = *mpSaveData;
1979 : else
1980 0 : *mpSaveData = *mpDragData;
1981 :
1982 0 : mpData = mpSaveData;
1983 0 : mbDrag = false;
1984 :
1985 : // call handler
1986 0 : EndDrag();
1987 :
1988 : // reset drag values
1989 0 : meDragType = RULER_TYPE_DONTKNOW;
1990 0 : mnDragPos = 0;
1991 0 : mnDragAryPos = 0;
1992 0 : mnDragSize = 0;
1993 0 : mbDragCanceled = false;
1994 0 : mbDragDelete = false;
1995 0 : mnDragModifier = 0;
1996 0 : mnStartDragPos = 0;
1997 :
1998 : // redraw
1999 0 : Invalidate(InvalidateFlags::NoErase);
2000 0 : }
2001 :
2002 0 : void Ruler::MouseButtonDown( const MouseEvent& rMEvt )
2003 : {
2004 0 : if ( rMEvt.IsLeft() && !IsTracking() )
2005 : {
2006 0 : Point aMousePos = rMEvt.GetPosPixel();
2007 0 : sal_uInt16 nMouseClicks = rMEvt.GetClicks();
2008 0 : sal_uInt16 nMouseModifier = rMEvt.GetModifier();
2009 :
2010 : // update ruler
2011 0 : if ( mbFormat )
2012 : {
2013 0 : Invalidate(InvalidateFlags::NoErase);
2014 : }
2015 :
2016 0 : if ( maExtraRect.IsInside( aMousePos ) )
2017 : {
2018 0 : mnExtraClicks = nMouseClicks;
2019 0 : mnExtraModifier = nMouseModifier;
2020 0 : ExtraDown();
2021 0 : mnExtraClicks = 0;
2022 0 : mnExtraModifier = 0;
2023 : }
2024 : else
2025 : {
2026 0 : boost::scoped_ptr<RulerSelection> pHitTest(new RulerSelection);
2027 0 : bool bHitTestResult = ImplHitTest(aMousePos, pHitTest.get());
2028 :
2029 0 : if ( nMouseClicks == 1 )
2030 : {
2031 0 : if ( bHitTestResult )
2032 : {
2033 0 : ImplStartDrag( pHitTest.get(), nMouseModifier );
2034 : }
2035 : else
2036 : {
2037 : // calculate position inside of ruler area
2038 0 : if ( pHitTest->eType == RULER_TYPE_DONTKNOW )
2039 : {
2040 0 : mnDragPos = pHitTest->nPos;
2041 0 : Click();
2042 0 : mnDragPos = 0;
2043 :
2044 : // call HitTest again as a click, for example, could set a new tab
2045 0 : if ( ImplHitTest(aMousePos, pHitTest.get()) )
2046 0 : ImplStartDrag(pHitTest.get(), nMouseModifier);
2047 : }
2048 : }
2049 : }
2050 : else
2051 : {
2052 0 : if (bHitTestResult)
2053 : {
2054 0 : mnDragPos = pHitTest->nPos;
2055 0 : mnDragAryPos = pHitTest->nAryPos;
2056 : }
2057 0 : meDragType = pHitTest->eType;
2058 :
2059 0 : DoubleClick();
2060 :
2061 0 : meDragType = RULER_TYPE_DONTKNOW;
2062 0 : mnDragPos = 0;
2063 0 : mnDragAryPos = 0;
2064 0 : }
2065 : }
2066 : }
2067 0 : }
2068 :
2069 0 : void Ruler::MouseMove( const MouseEvent& rMEvt )
2070 : {
2071 0 : PointerStyle ePtrStyle = PointerStyle::Arrow;
2072 :
2073 0 : mxPreviousHitTest.swap(mxCurrentHitTest);
2074 :
2075 0 : mxCurrentHitTest.reset(new RulerSelection);
2076 :
2077 0 : maHoverSelection.eType = RULER_TYPE_DONTKNOW;
2078 :
2079 0 : if (ImplHitTest( rMEvt.GetPosPixel(), mxCurrentHitTest.get() ))
2080 : {
2081 0 : maHoverSelection = *mxCurrentHitTest.get();
2082 :
2083 0 : if (mxCurrentHitTest->bSize)
2084 : {
2085 0 : if (mnWinStyle & WB_HORZ)
2086 : {
2087 0 : if (mxCurrentHitTest->mnDragSize == RULER_DRAGSIZE_1)
2088 0 : ePtrStyle = PointerStyle::TabSelectW;
2089 0 : else if (mxCurrentHitTest->mnDragSize == RULER_DRAGSIZE_2)
2090 0 : ePtrStyle = PointerStyle::TabSelectE;
2091 : else
2092 0 : ePtrStyle = PointerStyle::ESize;
2093 : }
2094 : else
2095 : {
2096 0 : if (mxCurrentHitTest->mnDragSize == RULER_DRAGSIZE_1)
2097 0 : ePtrStyle = PointerStyle::WindowNSize;
2098 0 : else if (mxCurrentHitTest->mnDragSize == RULER_DRAGSIZE_2)
2099 0 : ePtrStyle = PointerStyle::WindowSSize;
2100 : else
2101 0 : ePtrStyle = PointerStyle::SSize;
2102 : }
2103 : }
2104 0 : else if (mxCurrentHitTest->bSizeBar)
2105 : {
2106 0 : if (mnWinStyle & WB_HORZ)
2107 0 : ePtrStyle = PointerStyle::HSizeBar;
2108 : else
2109 0 : ePtrStyle = PointerStyle::VSizeBar;
2110 : }
2111 : }
2112 :
2113 0 : if (mxPreviousHitTest.get() != NULL && mxPreviousHitTest->eType != mxCurrentHitTest->eType)
2114 : {
2115 0 : mbFormat = true;
2116 : }
2117 :
2118 0 : SetPointer( Pointer(ePtrStyle) );
2119 :
2120 0 : if (mbFormat)
2121 : {
2122 0 : Invalidate(InvalidateFlags::NoErase);
2123 : }
2124 0 : }
2125 :
2126 0 : void Ruler::Tracking( const TrackingEvent& rTEvt )
2127 : {
2128 0 : if ( rTEvt.IsTrackingEnded() )
2129 : {
2130 : // reset the old state at cancel
2131 0 : if ( rTEvt.IsTrackingCanceled() )
2132 : {
2133 0 : mbDragCanceled = true;
2134 0 : mbFormat = true;
2135 : }
2136 :
2137 0 : ImplEndDrag();
2138 : }
2139 : else
2140 0 : ImplDrag( rTEvt.GetMouseEvent().GetPosPixel() );
2141 0 : }
2142 :
2143 10872 : void Ruler::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
2144 : {
2145 10872 : ImplDraw(rRenderContext);
2146 :
2147 : // consider extra field
2148 10872 : if (mnWinStyle & WB_EXTRAFIELD)
2149 10702 : ImplDrawExtra(rRenderContext, true);
2150 10872 : }
2151 :
2152 24185 : void Ruler::Resize()
2153 : {
2154 24185 : Size aWinSize = GetOutputSizePixel();
2155 :
2156 : long nNewHeight;
2157 24185 : if ( mnWinStyle & WB_HORZ )
2158 : {
2159 10202 : if ( aWinSize.Height() != mnHeight )
2160 2847 : nNewHeight = aWinSize.Height();
2161 : else
2162 7355 : nNewHeight = 0;
2163 : }
2164 : else
2165 : {
2166 13983 : if ( aWinSize.Width() != mnWidth )
2167 2752 : nNewHeight = aWinSize.Width();
2168 : else
2169 11231 : nNewHeight = 0;
2170 : }
2171 :
2172 24185 : mbFormat = true;
2173 :
2174 : // clear lines
2175 24185 : bool bVisible = IsReallyVisible();
2176 24185 : if ( bVisible && !mpData->pLines.empty() )
2177 : {
2178 0 : mnUpdateFlags |= RULER_UPDATE_LINES;
2179 0 : Invalidate(InvalidateFlags::NoErase);
2180 : }
2181 :
2182 : // recalculate some values if the height/width changes
2183 : // extra field should always be updated
2184 24185 : ImplInitExtraField( mpData->bTextRTL );
2185 24185 : if ( nNewHeight )
2186 : {
2187 5599 : mbCalc = true;
2188 5599 : mnVirHeight = nNewHeight - mnBorderWidth - ( RULER_OFF * 2 );
2189 : }
2190 : else
2191 : {
2192 18586 : if ( mpData->bAutoPageWidth )
2193 18206 : ImplUpdate( true );
2194 380 : else if ( mbAutoWinWidth )
2195 380 : mbCalc = true;
2196 : }
2197 :
2198 : // clear part of the border
2199 24185 : if ( bVisible )
2200 : {
2201 4431 : if ( nNewHeight )
2202 0 : Invalidate(InvalidateFlags::NoErase);
2203 4431 : else if ( mpData->bAutoPageWidth )
2204 : {
2205 : // only at AutoPageWidth muss we redraw
2206 4426 : Rectangle aRect;
2207 :
2208 4426 : if ( mnWinStyle & WB_HORZ )
2209 : {
2210 4425 : if ( mnWidth < aWinSize.Width() )
2211 36 : aRect.Left() = mnWidth - RULER_RESIZE_OFF;
2212 : else
2213 4389 : aRect.Left() = aWinSize.Width() - RULER_RESIZE_OFF;
2214 4425 : aRect.Right() = aRect.Left() + RULER_RESIZE_OFF;
2215 4425 : aRect.Top() = RULER_OFF;
2216 4425 : aRect.Bottom() = RULER_OFF + mnVirHeight;
2217 : }
2218 : else
2219 : {
2220 1 : if ( mnHeight < aWinSize.Height() )
2221 0 : aRect.Top() = mnHeight-RULER_RESIZE_OFF;
2222 : else
2223 1 : aRect.Top() = aWinSize.Height()-RULER_RESIZE_OFF;
2224 1 : aRect.Bottom() = aRect.Top() + RULER_RESIZE_OFF;
2225 1 : aRect.Left() = RULER_OFF;
2226 1 : aRect.Right() = RULER_OFF + mnVirHeight;
2227 : }
2228 :
2229 4426 : Invalidate(aRect, InvalidateFlags::NoErase);
2230 : }
2231 : }
2232 :
2233 24185 : mnWidth = aWinSize.Width();
2234 24185 : mnHeight = aWinSize.Height();
2235 24185 : }
2236 :
2237 11206 : void Ruler::StateChanged( StateChangedType nType )
2238 : {
2239 11206 : Window::StateChanged( nType );
2240 :
2241 11206 : if ( nType == StateChangedType::InitShow )
2242 2846 : Invalidate();
2243 8360 : else if ( nType == StateChangedType::UpdateMode )
2244 : {
2245 0 : if ( IsReallyVisible() && IsUpdateMode() )
2246 0 : Invalidate();
2247 : }
2248 8360 : else if ( (nType == StateChangedType::Zoom) ||
2249 : (nType == StateChangedType::ControlFont) )
2250 : {
2251 0 : ImplInitSettings( true, false, false );
2252 0 : Invalidate();
2253 : }
2254 8360 : else if ( nType == StateChangedType::ControlForeground )
2255 : {
2256 0 : ImplInitSettings( false, true, false );
2257 0 : Invalidate();
2258 : }
2259 8360 : else if ( nType == StateChangedType::ControlBackground )
2260 : {
2261 0 : ImplInitSettings( false, false, true );
2262 0 : Invalidate();
2263 : }
2264 11206 : }
2265 :
2266 66 : void Ruler::DataChanged( const DataChangedEvent& rDCEvt )
2267 : {
2268 66 : Window::DataChanged( rDCEvt );
2269 :
2270 264 : if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
2271 132 : (rDCEvt.GetType() == DataChangedEventType::DISPLAY) ||
2272 324 : (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
2273 198 : ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
2274 264 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
2275 : {
2276 60 : mbFormat = true;
2277 60 : ImplInitSettings( true, true, true );
2278 60 : Invalidate();
2279 : }
2280 66 : }
2281 :
2282 0 : bool Ruler::StartDrag()
2283 : {
2284 0 : if ( maStartDragHdl.IsSet() )
2285 0 : return maStartDragHdl.Call( this );
2286 : else
2287 0 : return false;
2288 : }
2289 :
2290 0 : void Ruler::Drag()
2291 : {
2292 0 : maDragHdl.Call( this );
2293 0 : }
2294 :
2295 0 : void Ruler::EndDrag()
2296 : {
2297 0 : maEndDragHdl.Call( this );
2298 0 : }
2299 :
2300 0 : void Ruler::Click()
2301 : {
2302 0 : maClickHdl.Call( this );
2303 0 : }
2304 :
2305 0 : void Ruler::DoubleClick()
2306 : {
2307 0 : maDoubleClickHdl.Call( this );
2308 0 : }
2309 :
2310 0 : void Ruler::ExtraDown()
2311 : {
2312 0 : maExtraDownHdl.Call( this );
2313 0 : }
2314 :
2315 11432 : void Ruler::Activate()
2316 : {
2317 11432 : mbActive = true;
2318 :
2319 : // update positionlies - draw is delayed
2320 11432 : mnUpdateFlags |= RULER_UPDATE_LINES;
2321 11432 : Invalidate(InvalidateFlags::NoErase);
2322 11432 : }
2323 :
2324 8824 : void Ruler::Deactivate()
2325 : {
2326 : // clear positionlines
2327 8824 : Invalidate(InvalidateFlags::NoErase);
2328 :
2329 8824 : mbActive = false;
2330 8824 : }
2331 :
2332 0 : bool Ruler::StartDocDrag( const MouseEvent& rMEvt, RulerType eDragType )
2333 : {
2334 0 : if ( !mbDrag )
2335 : {
2336 0 : Point aMousePos = rMEvt.GetPosPixel();
2337 0 : sal_uInt16 nMouseClicks = rMEvt.GetClicks();
2338 0 : sal_uInt16 nMouseModifier = rMEvt.GetModifier();
2339 0 : RulerSelection aHitTest;
2340 :
2341 0 : if(eDragType != RULER_TYPE_DONTKNOW)
2342 0 : aHitTest.bExpandTest = true;
2343 :
2344 : // update ruler
2345 0 : if ( mbFormat )
2346 : {
2347 0 : Invalidate(InvalidateFlags::NoErase);
2348 : }
2349 :
2350 0 : if ( nMouseClicks == 1 )
2351 : {
2352 0 : if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) )
2353 : {
2354 0 : Pointer aPtr;
2355 :
2356 0 : if ( aHitTest.bSize )
2357 : {
2358 0 : if ( mnWinStyle & WB_HORZ )
2359 0 : aPtr = Pointer( PointerStyle::ESize );
2360 : else
2361 0 : aPtr = Pointer( PointerStyle::SSize );
2362 : }
2363 0 : else if ( aHitTest.bSizeBar )
2364 : {
2365 0 : if ( mnWinStyle & WB_HORZ )
2366 0 : aPtr = Pointer( PointerStyle::HSizeBar );
2367 : else
2368 0 : aPtr = Pointer( PointerStyle::VSizeBar );
2369 : }
2370 0 : SetPointer( aPtr );
2371 0 : return ImplStartDrag( &aHitTest, nMouseModifier );
2372 : }
2373 : }
2374 0 : else if ( nMouseClicks == 2 )
2375 : {
2376 0 : if ( ImplDocHitTest( aMousePos, eDragType, &aHitTest ) )
2377 : {
2378 0 : mnDragPos = aHitTest.nPos;
2379 0 : mnDragAryPos = aHitTest.nAryPos;
2380 : }
2381 0 : eDragType = aHitTest.eType;
2382 :
2383 0 : DoubleClick();
2384 :
2385 0 : eDragType = RULER_TYPE_DONTKNOW;
2386 0 : mnDragPos = 0;
2387 0 : mnDragAryPos = 0;
2388 :
2389 0 : return true;
2390 : }
2391 : }
2392 :
2393 0 : return false;
2394 : }
2395 :
2396 0 : void Ruler::CancelDrag()
2397 : {
2398 0 : if ( mbDrag )
2399 : {
2400 0 : ImplDrag( Point( -1, -1 ) );
2401 0 : ImplEndDrag();
2402 : }
2403 0 : }
2404 :
2405 0 : RulerType Ruler::GetType( const Point& rPos, sal_uInt16* pAryPos )
2406 : {
2407 0 : RulerSelection aHitTest;
2408 :
2409 : // update ruler
2410 0 : if ( IsReallyVisible() && mbFormat )
2411 : {
2412 0 : Invalidate(InvalidateFlags::NoErase);
2413 : }
2414 :
2415 0 : (void)ImplHitTest(rPos, &aHitTest);
2416 :
2417 : // return values
2418 0 : if ( pAryPos )
2419 0 : *pAryPos = aHitTest.nAryPos;
2420 0 : return aHitTest.eType;
2421 : }
2422 :
2423 174 : void Ruler::SetWinPos( long nNewOff, long nNewWidth )
2424 : {
2425 : // should widths be automatically calculated
2426 174 : if ( !nNewWidth )
2427 174 : mbAutoWinWidth = true;
2428 : else
2429 0 : mbAutoWinWidth = false;
2430 :
2431 174 : mnWinOff = nNewOff;
2432 174 : mnWinWidth = nNewWidth;
2433 174 : ImplUpdate( true );
2434 174 : }
2435 :
2436 56889 : void Ruler::SetPagePos( long nNewOff, long nNewWidth )
2437 : {
2438 : // should we do anything?
2439 56889 : if ( (mpData->nPageOff == nNewOff) && (mpData->nPageWidth == nNewWidth) )
2440 103218 : return;
2441 :
2442 : // should widths be automatically calculated
2443 10560 : if ( !nNewWidth )
2444 9786 : mpData->bAutoPageWidth = true;
2445 : else
2446 774 : mpData->bAutoPageWidth = false;
2447 :
2448 10560 : mpData->nPageOff = nNewOff;
2449 10560 : mpData->nPageWidth = nNewWidth;
2450 10560 : ImplUpdate( true );
2451 : }
2452 :
2453 343 : void Ruler::SetBorderPos( long nOff )
2454 : {
2455 343 : if ( mnWinStyle & WB_BORDER )
2456 : {
2457 343 : if ( mnBorderOff != nOff )
2458 : {
2459 88 : mnBorderOff = nOff;
2460 :
2461 88 : if ( IsReallyVisible() && IsUpdateMode() )
2462 0 : Invalidate(InvalidateFlags::NoErase);
2463 : }
2464 : }
2465 343 : }
2466 :
2467 5694 : void Ruler::SetUnit( FieldUnit eNewUnit )
2468 : {
2469 5694 : if ( meUnit != eNewUnit )
2470 : {
2471 5688 : meUnit = eNewUnit;
2472 5688 : switch ( meUnit )
2473 : {
2474 : case FUNIT_MM:
2475 0 : mnUnitIndex = RULER_UNIT_MM;
2476 0 : break;
2477 : case FUNIT_CM:
2478 0 : mnUnitIndex = RULER_UNIT_CM;
2479 0 : break;
2480 : case FUNIT_M:
2481 0 : mnUnitIndex = RULER_UNIT_M;
2482 0 : break;
2483 : case FUNIT_KM:
2484 0 : mnUnitIndex = RULER_UNIT_KM;
2485 0 : break;
2486 : case FUNIT_INCH:
2487 5688 : mnUnitIndex = RULER_UNIT_INCH;
2488 5688 : break;
2489 : case FUNIT_FOOT:
2490 0 : mnUnitIndex = RULER_UNIT_FOOT;
2491 0 : break;
2492 : case FUNIT_MILE:
2493 0 : mnUnitIndex = RULER_UNIT_MILE;
2494 0 : break;
2495 : case FUNIT_POINT:
2496 0 : mnUnitIndex = RULER_UNIT_POINT;
2497 0 : break;
2498 : case FUNIT_PICA:
2499 0 : mnUnitIndex = RULER_UNIT_PICA;
2500 0 : break;
2501 : case FUNIT_CHAR:
2502 0 : mnUnitIndex = RULER_UNIT_CHAR;
2503 0 : break;
2504 : case FUNIT_LINE:
2505 0 : mnUnitIndex = RULER_UNIT_LINE;
2506 0 : break;
2507 : default:
2508 : SAL_WARN( "svtools.control", "Ruler::SetUnit() - Wrong Unit" );
2509 0 : break;
2510 : }
2511 :
2512 5688 : maMapMode.SetMapUnit( aImplRulerUnitTab[mnUnitIndex].eMapUnit );
2513 5688 : ImplUpdate();
2514 : }
2515 5694 : }
2516 :
2517 8010 : void Ruler::SetZoom( const Fraction& rNewZoom )
2518 : {
2519 : DBG_ASSERT( rNewZoom.GetNumerator(), "Ruler::SetZoom() with scale 0 is not allowed" );
2520 :
2521 8010 : if ( maZoom != rNewZoom )
2522 : {
2523 2072 : maZoom = rNewZoom;
2524 2072 : maMapMode.SetScaleX( maZoom );
2525 2072 : maMapMode.SetScaleY( maZoom );
2526 2072 : ImplUpdate();
2527 : }
2528 8010 : }
2529 :
2530 5694 : void Ruler::SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle )
2531 : {
2532 5694 : if ( mnWinStyle & WB_EXTRAFIELD )
2533 : {
2534 5694 : meExtraType = eNewExtraType;
2535 5694 : mnExtraStyle = nStyle;
2536 5694 : if (IsReallyVisible() && IsUpdateMode())
2537 0 : Invalidate(InvalidateFlags::NoErase);
2538 : }
2539 5694 : }
2540 :
2541 1244 : void Ruler::SetNullOffset( long nPos )
2542 : {
2543 1244 : if ( mpData->nNullOff != nPos )
2544 : {
2545 660 : mpData->nNullOff = nPos;
2546 660 : ImplUpdate();
2547 : }
2548 1244 : }
2549 :
2550 570 : void Ruler::SetLeftFrameMargin( long nPos )
2551 : {
2552 570 : if ( (mpData->nLeftFrameMargin != nPos) )
2553 : {
2554 0 : mpData->nLeftFrameMargin = nPos;
2555 0 : ImplUpdate();
2556 : }
2557 570 : }
2558 :
2559 570 : void Ruler::SetRightFrameMargin( long nPos )
2560 : {
2561 570 : if ( (mpData->nRightFrameMargin != nPos) )
2562 : {
2563 326 : mpData->nRightFrameMargin = nPos;
2564 326 : ImplUpdate();
2565 : }
2566 570 : }
2567 :
2568 57549 : void Ruler::SetMargin1( long nPos, sal_uInt16 nMarginStyle )
2569 : {
2570 57549 : if ( (mpData->nMargin1 != nPos) || (mpData->nMargin1Style != nMarginStyle) )
2571 : {
2572 6170 : mpData->nMargin1 = nPos;
2573 6170 : mpData->nMargin1Style = nMarginStyle;
2574 6170 : ImplUpdate();
2575 : }
2576 57549 : }
2577 :
2578 57549 : void Ruler::SetMargin2( long nPos, sal_uInt16 nMarginStyle )
2579 : {
2580 : DBG_ASSERT( (nPos >= mpData->nMargin1) ||
2581 : (mpData->nMargin1Style & RULER_STYLE_INVISIBLE) ||
2582 : (mpData->nMargin2Style & RULER_STYLE_INVISIBLE),
2583 : "Ruler::SetMargin2() - Margin2 < Margin1" );
2584 :
2585 57549 : if ( (mpData->nMargin2 != nPos) || (mpData->nMargin2Style != nMarginStyle) )
2586 : {
2587 6205 : mpData->nMargin2 = nPos;
2588 6205 : mpData->nMargin2Style = nMarginStyle;
2589 6205 : ImplUpdate();
2590 : }
2591 57549 : }
2592 :
2593 0 : void Ruler::SetLines( sal_uInt32 aLineArraySize, const RulerLine* pLineArray )
2594 : {
2595 : // To determine if what has changed
2596 0 : if ( mpData->pLines.size() == aLineArraySize )
2597 : {
2598 0 : sal_uInt32 i = aLineArraySize;
2599 0 : vector<RulerLine>::const_iterator aItr1 = mpData->pLines.begin();
2600 0 : const RulerLine* pAry2 = pLineArray;
2601 0 : while ( i )
2602 : {
2603 0 : if ( (aItr1->nPos != pAry2->nPos) ||
2604 0 : (aItr1->nStyle != pAry2->nStyle) )
2605 0 : break;
2606 0 : ++aItr1;
2607 0 : ++pAry2;
2608 0 : i--;
2609 : }
2610 0 : if ( !i )
2611 0 : return;
2612 : }
2613 :
2614 : // New values and new share issue
2615 : bool bMustUpdate;
2616 0 : if ( IsReallyVisible() && IsUpdateMode() )
2617 0 : bMustUpdate = true;
2618 : else
2619 0 : bMustUpdate = false;
2620 :
2621 : // Delete old lines
2622 0 : if ( bMustUpdate )
2623 0 : Invalidate(InvalidateFlags::NoErase);
2624 :
2625 : // New data set
2626 0 : if ( !aLineArraySize || !pLineArray )
2627 : {
2628 0 : if ( mpData->pLines.empty() )
2629 0 : return;
2630 0 : mpData->pLines.clear();
2631 : }
2632 : else
2633 : {
2634 0 : if ( mpData->pLines.size() != aLineArraySize )
2635 : {
2636 0 : mpData->pLines.resize(aLineArraySize);
2637 : }
2638 :
2639 : std::copy( pLineArray,
2640 : pLineArray + aLineArraySize,
2641 0 : mpData->pLines.begin() );
2642 :
2643 0 : if ( bMustUpdate )
2644 0 : Invalidate(InvalidateFlags::NoErase);
2645 : }
2646 : }
2647 :
2648 56889 : void Ruler::SetBorders( sal_uInt32 aBorderArraySize, const RulerBorder* pBorderArray )
2649 : {
2650 56889 : if ( !aBorderArraySize || !pBorderArray )
2651 : {
2652 56885 : if ( mpData->pBorders.empty() )
2653 56885 : return;
2654 0 : mpData->pBorders.clear();
2655 : }
2656 : else
2657 : {
2658 4 : if ( mpData->pBorders.size() != aBorderArraySize )
2659 : {
2660 2 : mpData->pBorders.resize(aBorderArraySize);
2661 : }
2662 : else
2663 : {
2664 2 : sal_uInt32 i = aBorderArraySize;
2665 2 : const RulerBorder* pAry1 = &mpData->pBorders[0];
2666 2 : const RulerBorder* pAry2 = pBorderArray;
2667 6 : while ( i )
2668 : {
2669 4 : if ( (pAry1->nPos != pAry2->nPos) ||
2670 4 : (pAry1->nWidth != pAry2->nWidth) ||
2671 2 : (pAry1->nStyle != pAry2->nStyle) )
2672 : break;
2673 2 : pAry1++;
2674 2 : pAry2++;
2675 2 : i--;
2676 : }
2677 2 : if ( !i )
2678 2 : return;
2679 : }
2680 : std::copy( pBorderArray,
2681 : pBorderArray + aBorderArraySize,
2682 2 : mpData->pBorders.begin() );
2683 : }
2684 :
2685 2 : ImplUpdate();
2686 : }
2687 :
2688 56316 : void Ruler::SetIndents( sal_uInt32 aIndentArraySize, const RulerIndent* pIndentArray )
2689 : {
2690 :
2691 56316 : if ( !aIndentArraySize || !pIndentArray )
2692 : {
2693 55746 : if ( mpData->pIndents.empty() )
2694 55746 : return;
2695 0 : mpData->pIndents.clear();
2696 : }
2697 : else
2698 : {
2699 570 : if ( mpData->pIndents.size() != aIndentArraySize )
2700 : {
2701 308 : mpData->pIndents.resize(aIndentArraySize);
2702 : }
2703 : else
2704 : {
2705 262 : sal_uInt32 i = aIndentArraySize;
2706 262 : const RulerIndent* pAry1 = &mpData->pIndents[0];
2707 262 : const RulerIndent* pAry2 = pIndentArray;
2708 1293 : while ( i )
2709 : {
2710 1555 : if ( (pAry1->nPos != pAry2->nPos) ||
2711 769 : (pAry1->nStyle != pAry2->nStyle) )
2712 : break;
2713 769 : pAry1++;
2714 769 : pAry2++;
2715 769 : i--;
2716 : }
2717 262 : if ( !i )
2718 245 : return;
2719 : }
2720 :
2721 : std::copy( pIndentArray,
2722 : pIndentArray + aIndentArraySize,
2723 325 : mpData->pIndents.begin() );
2724 : }
2725 :
2726 325 : ImplUpdate();
2727 : }
2728 :
2729 57486 : void Ruler::SetTabs( sal_uInt32 aTabArraySize, const RulerTab* pTabArray )
2730 : {
2731 57486 : if ( aTabArraySize == 0 || pTabArray == NULL )
2732 : {
2733 56719 : if ( mpData->pTabs.empty() )
2734 56719 : return;
2735 0 : mpData->pTabs.clear();
2736 : }
2737 : else
2738 : {
2739 767 : if ( mpData->pTabs.size() != aTabArraySize )
2740 : {
2741 278 : mpData->pTabs.resize(aTabArraySize);
2742 : }
2743 : else
2744 : {
2745 489 : sal_uInt32 i = aTabArraySize;
2746 489 : vector<RulerTab>::iterator aTabIterator = mpData->pTabs.begin();
2747 489 : const RulerTab* pInputArray = pTabArray;
2748 7316 : while ( i )
2749 : {
2750 6349 : RulerTab& aCurrent = *aTabIterator;
2751 12687 : if ( aCurrent.nPos != pInputArray->nPos ||
2752 6338 : aCurrent.nStyle != pInputArray->nStyle )
2753 : {
2754 : break;
2755 : }
2756 6338 : ++aTabIterator;
2757 6338 : pInputArray++;
2758 6338 : i--;
2759 : }
2760 489 : if ( !i )
2761 478 : return;
2762 : }
2763 289 : std::copy(pTabArray, pTabArray + aTabArraySize, mpData->pTabs.begin());
2764 : }
2765 :
2766 289 : ImplUpdate();
2767 : }
2768 :
2769 19075 : void Ruler::SetStyle( WinBits nStyle )
2770 : {
2771 19075 : if ( mnWinStyle != nStyle )
2772 : {
2773 376 : mnWinStyle = nStyle;
2774 376 : ImplInitExtraField( true );
2775 : }
2776 19075 : }
2777 :
2778 0 : void Ruler::DrawTab(vcl::RenderContext& rRenderContext, const Color &rFillColor, const Point& rPos, sal_uInt16 nStyle)
2779 : {
2780 0 : Point aPos(rPos);
2781 0 : sal_uInt16 nTabStyle = nStyle & (RULER_TAB_STYLE | RULER_TAB_RTL);
2782 :
2783 0 : rRenderContext.Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
2784 0 : rRenderContext.SetLineColor();
2785 0 : rRenderContext.SetFillColor(rFillColor);
2786 0 : ImplCenterTabPos(aPos, nTabStyle);
2787 0 : ImplDrawRulerTab(rRenderContext, aPos, nTabStyle, nStyle);
2788 0 : rRenderContext.Pop();
2789 0 : }
2790 :
2791 311 : void Ruler::SetTextRTL(bool bRTL)
2792 : {
2793 311 : if(mpData->bTextRTL != (bool) bRTL)
2794 : {
2795 0 : mpData->bTextRTL = bRTL;
2796 0 : if ( IsReallyVisible() && IsUpdateMode() )
2797 0 : ImplInitExtraField( true );
2798 : }
2799 :
2800 311 : }
2801 :
2802 55915 : long Ruler::GetPageOffset() const
2803 : {
2804 55915 : return mpData->nPageOff;
2805 : }
2806 :
2807 0 : long Ruler::GetNullOffset() const
2808 : {
2809 0 : return mpData->nNullOff;
2810 : }
2811 :
2812 0 : long Ruler::GetMargin1() const
2813 : {
2814 0 : return mpData->nMargin1;
2815 : }
2816 :
2817 0 : long Ruler::GetMargin2() const
2818 : {
2819 0 : return mpData->nMargin2;
2820 : }
2821 :
2822 :
2823 55915 : bool Ruler::GetTextRTL()
2824 : {
2825 55915 : return mpData->bTextRTL;
2826 : }
2827 :
2828 0 : RulerUnitData Ruler::GetCurrentRulerUnit() const
2829 : {
2830 0 : return aImplRulerUnitTab[mnUnitIndex];
2831 : }
2832 :
2833 0 : void Ruler::DrawTicks()
2834 : {
2835 0 : mbFormat = true;
2836 0 : Invalidate(InvalidateFlags::NoErase);
2837 0 : }
2838 :
2839 5 : uno::Reference< XAccessible > Ruler::CreateAccessible()
2840 : {
2841 5 : vcl::Window* pParent = GetAccessibleParentWindow();
2842 : OSL_ENSURE( pParent, "-SvxRuler::CreateAccessible(): No Parent!" );
2843 5 : uno::Reference< XAccessible > xAccParent = pParent->GetAccessible();
2844 5 : if( xAccParent.is() )
2845 : {
2846 : // MT: Fixed compiler issue because the address from a temporary object was used.
2847 : // BUT: Should it really be a Pointer, instead of const&???
2848 5 : OUString aStr;
2849 5 : if ( mnWinStyle & WB_HORZ )
2850 : {
2851 5 : aStr = SvtResId(STR_SVT_ACC_RULER_HORZ_NAME);
2852 : }
2853 : else
2854 : {
2855 0 : aStr = SvtResId(STR_SVT_ACC_RULER_VERT_NAME);
2856 : }
2857 5 : pAccContext = new SvtRulerAccessible( xAccParent, *this, aStr );
2858 5 : pAccContext->acquire();
2859 5 : this->SetAccessible(pAccContext);
2860 5 : return pAccContext;
2861 : }
2862 : else
2863 0 : return uno::Reference< XAccessible >();
2864 798 : }
2865 :
2866 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
