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