Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "vcl/event.hxx"
22 : #include "vcl/decoview.hxx"
23 : #include "vcl/scrbar.hxx"
24 : #include "vcl/timer.hxx"
25 :
26 : #include "svdata.hxx"
27 :
28 : #include "rtl/string.hxx"
29 : #include "tools/rc.h"
30 :
31 : using ::rtl::OUString;
32 :
33 :
34 : /* #i77549#
35 : HACK: for scrollbars in case of thumb rect, page up and page down rect we
36 : abuse the HitTestNativeControl interface. All theming engines but aqua
37 : are actually able to draw the thumb according to our internal representation.
38 : However aqua draws a little outside. The canonical way would be to enhance the
39 : HitTestNativeControl passing a ScrollbarValue additionally so all necessary
40 : information is available in the call.
41 : .
42 : However since there is only this one small exception we will deviate a little and
43 : instead pass the respective rect as control region to allow for a small correction.
44 :
45 : So all places using HitTestNativeControl on PART_THUMB_HORZ, PART_THUMB_VERT,
46 : PART_TRACK_HORZ_LEFT, PART_TRACK_HORZ_RIGHT, PART_TRACK_VERT_UPPER, PART_TRACK_VERT_LOWER
47 : do not use the control rectangle as region but the actuall part rectangle, making
48 : only small deviations feasible.
49 : */
50 :
51 : #include "thumbpos.hxx"
52 :
53 : // =======================================================================
54 :
55 : #define SCRBAR_DRAW_BTN1 ((sal_uInt16)0x0001)
56 : #define SCRBAR_DRAW_BTN2 ((sal_uInt16)0x0002)
57 : #define SCRBAR_DRAW_PAGE1 ((sal_uInt16)0x0004)
58 : #define SCRBAR_DRAW_PAGE2 ((sal_uInt16)0x0008)
59 : #define SCRBAR_DRAW_THUMB ((sal_uInt16)0x0010)
60 : #define SCRBAR_DRAW_BACKGROUND ((sal_uInt16)0x0020)
61 : #define SCRBAR_DRAW_ALL (SCRBAR_DRAW_BTN1 | SCRBAR_DRAW_BTN2 | \
62 : SCRBAR_DRAW_PAGE1 | SCRBAR_DRAW_PAGE2 |\
63 : SCRBAR_DRAW_THUMB | SCRBAR_DRAW_BACKGROUND )
64 :
65 : #define SCRBAR_STATE_BTN1_DOWN ((sal_uInt16)0x0001)
66 : #define SCRBAR_STATE_BTN1_DISABLE ((sal_uInt16)0x0002)
67 : #define SCRBAR_STATE_BTN2_DOWN ((sal_uInt16)0x0004)
68 : #define SCRBAR_STATE_BTN2_DISABLE ((sal_uInt16)0x0008)
69 : #define SCRBAR_STATE_PAGE1_DOWN ((sal_uInt16)0x0010)
70 : #define SCRBAR_STATE_PAGE2_DOWN ((sal_uInt16)0x0020)
71 : #define SCRBAR_STATE_THUMB_DOWN ((sal_uInt16)0x0040)
72 :
73 : #define SCRBAR_VIEW_STYLE (WB_3DLOOK | WB_HORZ | WB_VERT)
74 :
75 647 : struct ImplScrollBarData
76 : {
77 : AutoTimer maTimer; // Timer
78 : sal_Bool mbHide;
79 : Rectangle maTrackRect; // TODO: move to ScrollBar class when binary incompatibility of ScrollBar class is no longer problematic
80 : };
81 :
82 : // =======================================================================
83 :
84 502 : void ScrollBar::ImplInit( Window* pParent, WinBits nStyle )
85 : {
86 502 : mpData = NULL;
87 502 : mnThumbPixRange = 0;
88 502 : mnThumbPixPos = 0;
89 502 : mnThumbPixSize = 0;
90 502 : mnMinRange = 0;
91 502 : mnMaxRange = 100;
92 502 : mnThumbPos = 0;
93 502 : mnVisibleSize = 0;
94 502 : mnLineSize = 1;
95 502 : mnPageSize = 1;
96 502 : mnDelta = 0;
97 502 : mnDragDraw = 0;
98 502 : mnStateFlags = 0;
99 502 : meScrollType = SCROLL_DONTKNOW;
100 502 : meDDScrollType = SCROLL_DONTKNOW;
101 502 : mbCalcSize = sal_True;
102 502 : mbFullDrag = 0;
103 :
104 502 : if( !mpData ) // TODO: remove when maTrackRect is no longer in mpData
105 : {
106 502 : mpData = new ImplScrollBarData;
107 502 : mpData->maTimer.SetTimeoutHdl( LINK( this, ScrollBar, ImplAutoTimerHdl ) );
108 502 : mpData->mbHide = sal_False;
109 : }
110 :
111 502 : ImplInitStyle( nStyle );
112 502 : Control::ImplInit( pParent, nStyle, NULL );
113 :
114 502 : long nScrollSize = GetSettings().GetStyleSettings().GetScrollBarSize();
115 502 : SetSizePixel( Size( nScrollSize, nScrollSize ) );
116 502 : SetBackground();
117 502 : }
118 :
119 : // -----------------------------------------------------------------------
120 :
121 502 : void ScrollBar::ImplInitStyle( WinBits nStyle )
122 : {
123 502 : if ( nStyle & WB_DRAG )
124 14 : mbFullDrag = sal_True;
125 : else
126 488 : mbFullDrag = (GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_SCROLL) != 0;
127 502 : }
128 :
129 : // -----------------------------------------------------------------------
130 :
131 502 : ScrollBar::ScrollBar( Window* pParent, WinBits nStyle ) :
132 502 : Control( WINDOW_SCROLLBAR )
133 : {
134 502 : ImplInit( pParent, nStyle );
135 502 : }
136 :
137 : // -----------------------------------------------------------------------
138 :
139 0 : ScrollBar::ScrollBar( Window* pParent, const ResId& rResId ) :
140 0 : Control( WINDOW_SCROLLBAR )
141 : {
142 0 : rResId.SetRT( RSC_SCROLLBAR );
143 0 : WinBits nStyle = ImplInitRes( rResId );
144 0 : ImplInit( pParent, nStyle );
145 0 : ImplLoadRes( rResId );
146 :
147 0 : if ( !(nStyle & WB_HIDE) )
148 0 : Show();
149 0 : }
150 :
151 : // -----------------------------------------------------------------------
152 :
153 309 : ScrollBar::~ScrollBar()
154 : {
155 145 : if( mpData )
156 145 : delete mpData;
157 164 : }
158 :
159 : // -----------------------------------------------------------------------
160 :
161 0 : void ScrollBar::ImplLoadRes( const ResId& rResId )
162 : {
163 0 : Control::ImplLoadRes( rResId );
164 :
165 0 : sal_Int16 nMin = ReadShortRes();
166 0 : sal_Int16 nMax = ReadShortRes();
167 0 : sal_Int16 nThumbPos = ReadShortRes();
168 0 : sal_Int16 nPage = ReadShortRes();
169 0 : sal_Int16 nStep = ReadShortRes();
170 0 : sal_Int16 nVisibleSize = ReadShortRes();
171 :
172 0 : SetRange( Range( nMin, nMax ) );
173 0 : SetLineSize( nStep );
174 0 : SetPageSize( nPage );
175 0 : SetVisibleSize( nVisibleSize );
176 0 : SetThumbPos( nThumbPos );
177 0 : }
178 :
179 : // -----------------------------------------------------------------------
180 :
181 1002 : void ScrollBar::ImplUpdateRects( sal_Bool bUpdate )
182 : {
183 1002 : sal_uInt16 nOldStateFlags = mnStateFlags;
184 1002 : Rectangle aOldPage1Rect = maPage1Rect;
185 1002 : Rectangle aOldPage2Rect = maPage2Rect;
186 1002 : Rectangle aOldThumbRect = maThumbRect;
187 :
188 1002 : mnStateFlags &= ~SCRBAR_STATE_BTN1_DISABLE;
189 1002 : mnStateFlags &= ~SCRBAR_STATE_BTN2_DISABLE;
190 :
191 1002 : Rectangle& maTrackRect = mpData->maTrackRect; // TODO: remove when maTrackRect is no longer in mpData
192 1002 : if ( mnThumbPixRange )
193 : {
194 982 : if ( GetStyle() & WB_HORZ )
195 : {
196 197 : maThumbRect.Left() = maTrackRect.Left()+mnThumbPixPos;
197 197 : maThumbRect.Right() = maThumbRect.Left()+mnThumbPixSize-1;
198 197 : if ( !mnThumbPixPos )
199 197 : maPage1Rect.Right() = RECT_EMPTY;
200 : else
201 0 : maPage1Rect.Right() = maThumbRect.Left()-1;
202 197 : if ( mnThumbPixPos >= (mnThumbPixRange-mnThumbPixSize) )
203 7 : maPage2Rect.Right() = RECT_EMPTY;
204 : else
205 : {
206 190 : maPage2Rect.Left() = maThumbRect.Right()+1;
207 190 : maPage2Rect.Right() = maTrackRect.Right();
208 : }
209 : }
210 : else
211 : {
212 785 : maThumbRect.Top() = maTrackRect.Top()+mnThumbPixPos;
213 785 : maThumbRect.Bottom() = maThumbRect.Top()+mnThumbPixSize-1;
214 785 : if ( !mnThumbPixPos )
215 772 : maPage1Rect.Bottom() = RECT_EMPTY;
216 : else
217 13 : maPage1Rect.Bottom() = maThumbRect.Top()-1;
218 785 : if ( mnThumbPixPos >= (mnThumbPixRange-mnThumbPixSize) )
219 2 : maPage2Rect.Bottom() = RECT_EMPTY;
220 : else
221 : {
222 783 : maPage2Rect.Top() = maThumbRect.Bottom()+1;
223 783 : maPage2Rect.Bottom() = maTrackRect.Bottom();
224 : }
225 : }
226 : }
227 : else
228 : {
229 20 : if ( GetStyle() & WB_HORZ )
230 : {
231 4 : const long nSpace = maTrackRect.Right() - maTrackRect.Left();
232 4 : if ( nSpace > 0 )
233 : {
234 0 : maPage1Rect.Left() = maTrackRect.Left();
235 0 : maPage1Rect.Right() = maTrackRect.Left() + (nSpace/2);
236 0 : maPage2Rect.Left() = maPage1Rect.Right() + 1;
237 0 : maPage2Rect.Right() = maTrackRect.Right();
238 : }
239 : }
240 : else
241 : {
242 16 : const long nSpace = maTrackRect.Bottom() - maTrackRect.Top();
243 16 : if ( nSpace > 0 )
244 : {
245 0 : maPage1Rect.Top() = maTrackRect.Top();
246 0 : maPage1Rect.Bottom() = maTrackRect.Top() + (nSpace/2);
247 0 : maPage2Rect.Top() = maPage1Rect.Bottom() + 1;
248 0 : maPage2Rect.Bottom() = maTrackRect.Bottom();
249 : }
250 : }
251 : }
252 :
253 1002 : if( !IsNativeControlSupported(CTRL_SCROLLBAR, PART_ENTIRE_CONTROL) )
254 : {
255 : // disable scrollbar buttons only in VCL's own 'theme'
256 : // as it is uncommon on other platforms
257 1002 : if ( mnThumbPos == mnMinRange )
258 989 : mnStateFlags |= SCRBAR_STATE_BTN1_DISABLE;
259 1002 : if ( mnThumbPos >= (mnMaxRange-mnVisibleSize) )
260 9 : mnStateFlags |= SCRBAR_STATE_BTN2_DISABLE;
261 : }
262 :
263 1002 : if ( bUpdate )
264 : {
265 0 : sal_uInt16 nDraw = 0;
266 0 : if ( (nOldStateFlags & SCRBAR_STATE_BTN1_DISABLE) !=
267 : (mnStateFlags & SCRBAR_STATE_BTN1_DISABLE) )
268 0 : nDraw |= SCRBAR_DRAW_BTN1;
269 0 : if ( (nOldStateFlags & SCRBAR_STATE_BTN2_DISABLE) !=
270 : (mnStateFlags & SCRBAR_STATE_BTN2_DISABLE) )
271 0 : nDraw |= SCRBAR_DRAW_BTN2;
272 0 : if ( aOldPage1Rect != maPage1Rect )
273 0 : nDraw |= SCRBAR_DRAW_PAGE1;
274 0 : if ( aOldPage2Rect != maPage2Rect )
275 0 : nDraw |= SCRBAR_DRAW_PAGE2;
276 0 : if ( aOldThumbRect != maThumbRect )
277 0 : nDraw |= SCRBAR_DRAW_THUMB;
278 0 : ImplDraw( nDraw, this );
279 : }
280 1002 : }
281 :
282 : // -----------------------------------------------------------------------
283 :
284 0 : long ScrollBar::ImplCalcThumbPos( long nPixPos )
285 : {
286 : // Position berechnen
287 : long nCalcThumbPos;
288 : nCalcThumbPos = ImplMulDiv( nPixPos, mnMaxRange-mnVisibleSize-mnMinRange,
289 0 : mnThumbPixRange-mnThumbPixSize );
290 0 : nCalcThumbPos += mnMinRange;
291 0 : return nCalcThumbPos;
292 : }
293 :
294 : // -----------------------------------------------------------------------
295 :
296 973 : long ScrollBar::ImplCalcThumbPosPix( long nPos )
297 : {
298 : long nCalcThumbPos;
299 :
300 : // Position berechnen
301 : nCalcThumbPos = ImplMulDiv( nPos-mnMinRange, mnThumbPixRange-mnThumbPixSize,
302 973 : mnMaxRange-mnVisibleSize-mnMinRange );
303 :
304 : // Am Anfang und Ende des ScrollBars versuchen wir die Anzeige korrekt
305 : // anzuzeigen
306 973 : if ( !nCalcThumbPos && (mnThumbPos > mnMinRange) )
307 0 : nCalcThumbPos = 1;
308 973 : if ( nCalcThumbPos &&
309 : ((nCalcThumbPos+mnThumbPixSize) >= mnThumbPixRange) &&
310 : (mnThumbPos < (mnMaxRange-mnVisibleSize)) )
311 0 : nCalcThumbPos--;
312 :
313 973 : return nCalcThumbPos;
314 : }
315 :
316 : // -----------------------------------------------------------------------
317 :
318 1002 : void ScrollBar::ImplCalc( sal_Bool bUpdate )
319 : {
320 1002 : const Size aSize = GetOutputSizePixel();
321 1002 : const long nMinThumbSize = GetSettings().GetStyleSettings().GetMinThumbSize();
322 :
323 1002 : Rectangle& maTrackRect = mpData->maTrackRect; // TODO: remove when maTrackRect is no longer in mpData
324 1002 : if ( mbCalcSize )
325 : {
326 679 : Size aOldSize = getCurrentCalcSize();
327 :
328 679 : const Rectangle aControlRegion( Point(0,0), aSize );
329 679 : Rectangle aBtn1Region, aBtn2Region, aTrackRegion, aBoundingRegion;
330 :
331 679 : if ( GetStyle() & WB_HORZ )
332 : {
333 945 : if ( GetNativeControlRegion( CTRL_SCROLLBAR, PART_BUTTON_LEFT,
334 756 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aBtn1Region ) &&
335 : GetNativeControlRegion( CTRL_SCROLLBAR, PART_BUTTON_RIGHT,
336 189 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aBtn2Region ) )
337 : {
338 0 : maBtn1Rect = aBtn1Region;
339 0 : maBtn2Rect = aBtn2Region;
340 : }
341 : else
342 : {
343 189 : Size aBtnSize( aSize.Height(), aSize.Height() );
344 189 : maBtn2Rect.Top() = maBtn1Rect.Top();
345 189 : maBtn2Rect.Left() = aSize.Width()-aSize.Height();
346 189 : maBtn1Rect.SetSize( aBtnSize );
347 189 : maBtn2Rect.SetSize( aBtnSize );
348 : }
349 :
350 378 : if ( GetNativeControlRegion( CTRL_SCROLLBAR, PART_TRACK_HORZ_AREA,
351 378 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aTrackRegion ) )
352 0 : maTrackRect = aTrackRegion;
353 : else
354 189 : maTrackRect = Rectangle( maBtn1Rect.TopRight(), maBtn2Rect.BottomLeft() );
355 :
356 : // Check if available space is big enough for thumb ( min thumb size = ScrBar width/height )
357 189 : mnThumbPixRange = maTrackRect.Right() - maTrackRect.Left();
358 189 : if( mnThumbPixRange > 0 )
359 : {
360 185 : maPage1Rect.Left() = maTrackRect.Left();
361 185 : maPage1Rect.Bottom() =
362 185 : maPage2Rect.Bottom() =
363 185 : maThumbRect.Bottom() = maTrackRect.Bottom();
364 : }
365 : else
366 : {
367 4 : mnThumbPixRange = 0;
368 4 : maPage1Rect.SetEmpty();
369 4 : maPage2Rect.SetEmpty();
370 : }
371 : }
372 : else
373 : {
374 2450 : if ( GetNativeControlRegion( CTRL_SCROLLBAR, PART_BUTTON_UP,
375 1960 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aBtn1Region ) &&
376 : GetNativeControlRegion( CTRL_SCROLLBAR, PART_BUTTON_DOWN,
377 490 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aBtn2Region ) )
378 : {
379 0 : maBtn1Rect = aBtn1Region;
380 0 : maBtn2Rect = aBtn2Region;
381 : }
382 : else
383 : {
384 490 : const Size aBtnSize( aSize.Width(), aSize.Width() );
385 490 : maBtn2Rect.Left() = maBtn1Rect.Left();
386 490 : maBtn2Rect.Top() = aSize.Height()-aSize.Width();
387 490 : maBtn1Rect.SetSize( aBtnSize );
388 490 : maBtn2Rect.SetSize( aBtnSize );
389 : }
390 :
391 980 : if ( GetNativeControlRegion( CTRL_SCROLLBAR, PART_TRACK_VERT_AREA,
392 980 : aControlRegion, 0, ImplControlValue(), rtl::OUString(), aBoundingRegion, aTrackRegion ) )
393 0 : maTrackRect = aTrackRegion;
394 : else
395 490 : maTrackRect = Rectangle( maBtn1Rect.BottomLeft()+Point(0,1), maBtn2Rect.TopRight() );
396 :
397 : // Check if available space is big enough for thumb
398 490 : mnThumbPixRange = maTrackRect.Bottom() - maTrackRect.Top();
399 490 : if( mnThumbPixRange > 0 )
400 : {
401 474 : maPage1Rect.Top() = maTrackRect.Top();
402 474 : maPage1Rect.Right() =
403 474 : maPage2Rect.Right() =
404 474 : maThumbRect.Right() = maTrackRect.Right();
405 : }
406 : else
407 : {
408 16 : mnThumbPixRange = 0;
409 16 : maPage1Rect.SetEmpty();
410 16 : maPage2Rect.SetEmpty();
411 : }
412 : }
413 :
414 679 : if ( !mnThumbPixRange )
415 20 : maThumbRect.SetEmpty();
416 :
417 679 : mbCalcSize = sal_False;
418 :
419 679 : Size aNewSize = getCurrentCalcSize();
420 679 : if (aOldSize != aNewSize)
421 : {
422 673 : queue_resize();
423 : }
424 : }
425 :
426 1002 : if ( mnThumbPixRange )
427 : {
428 : // Werte berechnen
429 982 : if ( (mnVisibleSize >= (mnMaxRange-mnMinRange)) ||
430 : ((mnMaxRange-mnMinRange) <= 0) )
431 : {
432 9 : mnThumbPos = mnMinRange;
433 9 : mnThumbPixPos = 0;
434 9 : mnThumbPixSize = mnThumbPixRange;
435 : }
436 : else
437 : {
438 973 : if ( mnVisibleSize )
439 973 : mnThumbPixSize = ImplMulDiv( mnThumbPixRange, mnVisibleSize, mnMaxRange-mnMinRange );
440 : else
441 : {
442 0 : if ( GetStyle() & WB_HORZ )
443 0 : mnThumbPixSize = maThumbRect.GetWidth();
444 : else
445 0 : mnThumbPixSize = maThumbRect.GetHeight();
446 : }
447 973 : if ( mnThumbPixSize < nMinThumbSize )
448 0 : mnThumbPixSize = nMinThumbSize;
449 973 : if ( mnThumbPixSize > mnThumbPixRange )
450 0 : mnThumbPixSize = mnThumbPixRange;
451 973 : mnThumbPixPos = ImplCalcThumbPosPix( mnThumbPos );
452 : }
453 : }
454 :
455 : // Wenn neu ausgegeben werden soll und wir schon ueber eine
456 : // Aktion einen Paint-Event ausgeloest bekommen haben, dann
457 : // geben wir nicht direkt aus, sondern invalidieren nur alles
458 1002 : if ( bUpdate && HasPaintEvent() )
459 : {
460 323 : Invalidate();
461 323 : bUpdate = sal_False;
462 : }
463 1002 : ImplUpdateRects( bUpdate );
464 1002 : }
465 :
466 : // -----------------------------------------------------------------------
467 :
468 0 : void ScrollBar::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong nFlags )
469 : {
470 0 : Point aPos = pDev->LogicToPixel( rPos );
471 0 : Size aSize = pDev->LogicToPixel( rSize );
472 0 : Rectangle aRect( aPos, aSize );
473 :
474 0 : pDev->Push();
475 0 : pDev->SetMapMode();
476 0 : if ( !(nFlags & WINDOW_DRAW_MONO) )
477 : {
478 : // DecoView uses the FaceColor...
479 0 : AllSettings aSettings = pDev->GetSettings();
480 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
481 0 : if ( IsControlBackground() )
482 0 : aStyleSettings.SetFaceColor( GetControlBackground() );
483 : else
484 0 : aStyleSettings.SetFaceColor( GetSettings().GetStyleSettings().GetFaceColor() );
485 :
486 0 : aSettings.SetStyleSettings( aStyleSettings );
487 0 : pDev->SetSettings( aSettings );
488 : }
489 :
490 : // for printing:
491 : // -calculate the size of the rects
492 : // -because this is zero-based add the correct offset
493 : // -print
494 : // -force recalculate
495 :
496 0 : if ( mbCalcSize )
497 0 : ImplCalc( sal_False );
498 :
499 0 : maBtn1Rect+=aPos;
500 0 : maBtn2Rect+=aPos;
501 0 : maThumbRect+=aPos;
502 0 : mpData->maTrackRect+=aPos; // TODO: update when maTrackRect is no longer in mpData
503 0 : maPage1Rect+=aPos;
504 0 : maPage2Rect+=aPos;
505 :
506 0 : ImplDraw( SCRBAR_DRAW_ALL, pDev );
507 0 : pDev->Pop();
508 :
509 0 : mbCalcSize = sal_True;
510 0 : }
511 :
512 : // -----------------------------------------------------------------------
513 :
514 4250 : sal_Bool ScrollBar::ImplDrawNative( sal_uInt16 nDrawFlags )
515 : {
516 4250 : ScrollbarValue scrValue;
517 :
518 4250 : sal_Bool bNativeOK = IsNativeControlSupported(CTRL_SCROLLBAR, PART_ENTIRE_CONTROL);
519 4250 : if( bNativeOK )
520 : {
521 0 : sal_Bool bHorz = (GetStyle() & WB_HORZ ? true : false);
522 :
523 : // Draw the entire background if the control supports it
524 0 : if( IsNativeControlSupported(CTRL_SCROLLBAR, bHorz ? PART_DRAW_BACKGROUND_HORZ : PART_DRAW_BACKGROUND_VERT) )
525 : {
526 0 : ControlState nState = ( IsEnabled() ? CTRL_STATE_ENABLED : 0 ) | ( HasFocus() ? CTRL_STATE_FOCUSED : 0 );
527 :
528 0 : scrValue.mnMin = mnMinRange;
529 0 : scrValue.mnMax = mnMaxRange;
530 0 : scrValue.mnCur = mnThumbPos;
531 0 : scrValue.mnVisibleSize = mnVisibleSize;
532 0 : scrValue.maThumbRect = maThumbRect;
533 0 : scrValue.maButton1Rect = maBtn1Rect;
534 0 : scrValue.maButton2Rect = maBtn2Rect;
535 : scrValue.mnButton1State = ((mnStateFlags & SCRBAR_STATE_BTN1_DOWN) ? CTRL_STATE_PRESSED : 0) |
536 0 : ((!(mnStateFlags & SCRBAR_STATE_BTN1_DISABLE)) ? CTRL_STATE_ENABLED : 0);
537 : scrValue.mnButton2State = ((mnStateFlags & SCRBAR_STATE_BTN2_DOWN) ? CTRL_STATE_PRESSED : 0) |
538 0 : ((!(mnStateFlags & SCRBAR_STATE_BTN2_DISABLE)) ? CTRL_STATE_ENABLED : 0);
539 0 : scrValue.mnThumbState = nState | ((mnStateFlags & SCRBAR_STATE_THUMB_DOWN) ? CTRL_STATE_PRESSED : 0);
540 0 : scrValue.mnPage1State = nState | ((mnStateFlags & SCRBAR_STATE_PAGE1_DOWN) ? CTRL_STATE_PRESSED : 0);
541 0 : scrValue.mnPage2State = nState | ((mnStateFlags & SCRBAR_STATE_PAGE2_DOWN) ? CTRL_STATE_PRESSED : 0);
542 :
543 0 : if( IsMouseOver() )
544 : {
545 0 : Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
546 0 : if( pRect )
547 : {
548 0 : if( pRect == &maThumbRect )
549 0 : scrValue.mnThumbState |= CTRL_STATE_ROLLOVER;
550 0 : else if( pRect == &maBtn1Rect )
551 0 : scrValue.mnButton1State |= CTRL_STATE_ROLLOVER;
552 0 : else if( pRect == &maBtn2Rect )
553 0 : scrValue.mnButton2State |= CTRL_STATE_ROLLOVER;
554 0 : else if( pRect == &maPage1Rect )
555 0 : scrValue.mnPage1State |= CTRL_STATE_ROLLOVER;
556 0 : else if( pRect == &maPage2Rect )
557 0 : scrValue.mnPage2State |= CTRL_STATE_ROLLOVER;
558 : }
559 : }
560 :
561 0 : Rectangle aCtrlRegion;
562 0 : aCtrlRegion.Union( maBtn1Rect );
563 0 : aCtrlRegion.Union( maBtn2Rect );
564 0 : aCtrlRegion.Union( maPage1Rect );
565 0 : aCtrlRegion.Union( maPage2Rect );
566 0 : aCtrlRegion.Union( maThumbRect );
567 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, (bHorz ? PART_DRAW_BACKGROUND_HORZ : PART_DRAW_BACKGROUND_VERT),
568 0 : aCtrlRegion, nState, scrValue, rtl::OUString() );
569 : }
570 : else
571 : {
572 0 : if ( (nDrawFlags & SCRBAR_DRAW_PAGE1) || (nDrawFlags & SCRBAR_DRAW_PAGE2) )
573 : {
574 0 : sal_uInt32 part1 = bHorz ? PART_TRACK_HORZ_LEFT : PART_TRACK_VERT_UPPER;
575 0 : sal_uInt32 part2 = bHorz ? PART_TRACK_HORZ_RIGHT : PART_TRACK_VERT_LOWER;
576 0 : Rectangle aCtrlRegion1( maPage1Rect );
577 0 : Rectangle aCtrlRegion2( maPage2Rect );
578 0 : ControlState nState1 = (IsEnabled() ? CTRL_STATE_ENABLED : 0) | (HasFocus() ? CTRL_STATE_FOCUSED : 0);
579 0 : ControlState nState2 = nState1;
580 :
581 0 : nState1 |= ((mnStateFlags & SCRBAR_STATE_PAGE1_DOWN) ? CTRL_STATE_PRESSED : 0);
582 0 : nState2 |= ((mnStateFlags & SCRBAR_STATE_PAGE2_DOWN) ? CTRL_STATE_PRESSED : 0);
583 :
584 0 : if( IsMouseOver() )
585 : {
586 0 : Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
587 0 : if( pRect )
588 : {
589 0 : if( pRect == &maPage1Rect )
590 0 : nState1 |= CTRL_STATE_ROLLOVER;
591 0 : else if( pRect == &maPage2Rect )
592 0 : nState2 |= CTRL_STATE_ROLLOVER;
593 : }
594 : }
595 :
596 0 : if ( nDrawFlags & SCRBAR_DRAW_PAGE1 )
597 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, part1, aCtrlRegion1, nState1,
598 0 : scrValue, rtl::OUString() );
599 :
600 0 : if ( nDrawFlags & SCRBAR_DRAW_PAGE2 )
601 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, part2, aCtrlRegion2, nState2,
602 0 : scrValue, rtl::OUString() );
603 : }
604 0 : if ( (nDrawFlags & SCRBAR_DRAW_BTN1) || (nDrawFlags & SCRBAR_DRAW_BTN2) )
605 : {
606 0 : sal_uInt32 part1 = bHorz ? PART_BUTTON_LEFT : PART_BUTTON_UP;
607 0 : sal_uInt32 part2 = bHorz ? PART_BUTTON_RIGHT : PART_BUTTON_DOWN;
608 0 : Rectangle aCtrlRegion1( maBtn1Rect );
609 0 : Rectangle aCtrlRegion2( maBtn2Rect );
610 0 : ControlState nState1 = HasFocus() ? CTRL_STATE_FOCUSED : 0;
611 0 : ControlState nState2 = nState1;
612 :
613 0 : if ( !Window::IsEnabled() || !IsEnabled() )
614 0 : nState1 = (nState2 &= ~CTRL_STATE_ENABLED);
615 : else
616 0 : nState1 = (nState2 |= CTRL_STATE_ENABLED);
617 :
618 0 : nState1 |= ((mnStateFlags & SCRBAR_STATE_BTN1_DOWN) ? CTRL_STATE_PRESSED : 0);
619 0 : nState2 |= ((mnStateFlags & SCRBAR_STATE_BTN2_DOWN) ? CTRL_STATE_PRESSED : 0);
620 :
621 0 : if(mnStateFlags & SCRBAR_STATE_BTN1_DISABLE)
622 0 : nState1 &= ~CTRL_STATE_ENABLED;
623 0 : if(mnStateFlags & SCRBAR_STATE_BTN2_DISABLE)
624 0 : nState2 &= ~CTRL_STATE_ENABLED;
625 :
626 0 : if( IsMouseOver() )
627 : {
628 0 : Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
629 0 : if( pRect )
630 : {
631 0 : if( pRect == &maBtn1Rect )
632 0 : nState1 |= CTRL_STATE_ROLLOVER;
633 0 : else if( pRect == &maBtn2Rect )
634 0 : nState2 |= CTRL_STATE_ROLLOVER;
635 : }
636 : }
637 :
638 0 : if ( nDrawFlags & SCRBAR_DRAW_BTN1 )
639 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, part1, aCtrlRegion1, nState1,
640 0 : scrValue, rtl::OUString() );
641 :
642 0 : if ( nDrawFlags & SCRBAR_DRAW_BTN2 )
643 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, part2, aCtrlRegion2, nState2,
644 0 : scrValue, rtl::OUString() );
645 : }
646 0 : if ( (nDrawFlags & SCRBAR_DRAW_THUMB) && !maThumbRect.IsEmpty() )
647 : {
648 0 : ControlState nState = IsEnabled() ? CTRL_STATE_ENABLED : 0;
649 0 : Rectangle aCtrlRegion( maThumbRect );
650 :
651 0 : if ( mnStateFlags & SCRBAR_STATE_THUMB_DOWN )
652 0 : nState |= CTRL_STATE_PRESSED;
653 :
654 0 : if ( HasFocus() )
655 0 : nState |= CTRL_STATE_FOCUSED;
656 :
657 0 : if( IsMouseOver() )
658 : {
659 0 : Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
660 0 : if( pRect )
661 : {
662 0 : if( pRect == &maThumbRect )
663 0 : nState |= CTRL_STATE_ROLLOVER;
664 : }
665 : }
666 :
667 : bNativeOK = DrawNativeControl( CTRL_SCROLLBAR, (bHorz ? PART_THUMB_HORZ : PART_THUMB_VERT),
668 0 : aCtrlRegion, nState, scrValue, rtl::OUString() );
669 : }
670 : }
671 : }
672 4250 : return bNativeOK;
673 : }
674 :
675 850 : void ScrollBar::ImplDraw( sal_uInt16 nDrawFlags, OutputDevice* pOutDev )
676 : {
677 850 : DecorationView aDecoView( pOutDev );
678 850 : Rectangle aTempRect;
679 : sal_uInt16 nStyle;
680 850 : const StyleSettings& rStyleSettings = pOutDev->GetSettings().GetStyleSettings();
681 : SymbolType eSymbolType;
682 850 : sal_Bool bEnabled = IsEnabled();
683 :
684 : // Evt. noch offene Berechnungen nachholen
685 850 : if ( mbCalcSize )
686 0 : ImplCalc( sal_False );
687 :
688 850 : Window *pWin = NULL;
689 850 : if( pOutDev->GetOutDevType() == OUTDEV_WINDOW )
690 850 : pWin = (Window*) pOutDev;
691 :
692 : // Draw the entire control if the native theme engine needs it
693 850 : if ( nDrawFlags && pWin && pWin->IsNativeControlSupported(CTRL_SCROLLBAR, PART_DRAW_BACKGROUND_HORZ) )
694 : {
695 0 : ImplDrawNative( SCRBAR_DRAW_BACKGROUND );
696 850 : return;
697 : }
698 :
699 850 : if( (nDrawFlags & SCRBAR_DRAW_BTN1) && (!pWin || !ImplDrawNative( SCRBAR_DRAW_BTN1 ) ) )
700 : {
701 850 : nStyle = BUTTON_DRAW_NOLIGHTBORDER;
702 850 : if ( mnStateFlags & SCRBAR_STATE_BTN1_DOWN )
703 0 : nStyle |= BUTTON_DRAW_PRESSED;
704 850 : aTempRect = aDecoView.DrawButton( maBtn1Rect, nStyle );
705 850 : ImplCalcSymbolRect( aTempRect );
706 850 : nStyle = 0;
707 850 : if ( (mnStateFlags & SCRBAR_STATE_BTN1_DISABLE) || !bEnabled )
708 845 : nStyle |= SYMBOL_DRAW_DISABLE;
709 850 : if ( rStyleSettings.GetOptions() & STYLE_OPTION_SCROLLARROW )
710 : {
711 0 : if ( GetStyle() & WB_HORZ )
712 0 : eSymbolType = SYMBOL_ARROW_LEFT;
713 : else
714 0 : eSymbolType = SYMBOL_ARROW_UP;
715 : }
716 : else
717 : {
718 850 : if ( GetStyle() & WB_HORZ )
719 417 : eSymbolType = SYMBOL_SPIN_LEFT;
720 : else
721 433 : eSymbolType = SYMBOL_SPIN_UP;
722 : }
723 850 : aDecoView.DrawSymbol( aTempRect, eSymbolType, rStyleSettings.GetButtonTextColor(), nStyle );
724 : }
725 :
726 850 : if ( (nDrawFlags & SCRBAR_DRAW_BTN2) && (!pWin || !ImplDrawNative( SCRBAR_DRAW_BTN2 ) ) )
727 : {
728 850 : nStyle = BUTTON_DRAW_NOLIGHTBORDER;
729 850 : if ( mnStateFlags & SCRBAR_STATE_BTN2_DOWN )
730 0 : nStyle |= BUTTON_DRAW_PRESSED;
731 850 : aTempRect = aDecoView.DrawButton( maBtn2Rect, nStyle );
732 850 : ImplCalcSymbolRect( aTempRect );
733 850 : nStyle = 0;
734 850 : if ( (mnStateFlags & SCRBAR_STATE_BTN2_DISABLE) || !bEnabled )
735 2 : nStyle |= SYMBOL_DRAW_DISABLE;
736 850 : if ( rStyleSettings.GetOptions() & STYLE_OPTION_SCROLLARROW )
737 : {
738 0 : if ( GetStyle() & WB_HORZ )
739 0 : eSymbolType = SYMBOL_ARROW_RIGHT;
740 : else
741 0 : eSymbolType = SYMBOL_ARROW_DOWN;
742 : }
743 : else
744 : {
745 850 : if ( GetStyle() & WB_HORZ )
746 417 : eSymbolType = SYMBOL_SPIN_RIGHT;
747 : else
748 433 : eSymbolType = SYMBOL_SPIN_DOWN;
749 : }
750 850 : aDecoView.DrawSymbol( aTempRect, eSymbolType, rStyleSettings.GetButtonTextColor(), nStyle );
751 : }
752 :
753 850 : pOutDev->SetLineColor();
754 :
755 850 : if ( (nDrawFlags & SCRBAR_DRAW_THUMB) && (!pWin || !ImplDrawNative( SCRBAR_DRAW_THUMB ) ) )
756 : {
757 850 : if ( !maThumbRect.IsEmpty() )
758 : {
759 850 : if ( bEnabled )
760 : {
761 848 : nStyle = BUTTON_DRAW_NOLIGHTBORDER;
762 848 : aTempRect = aDecoView.DrawButton( maThumbRect, nStyle );
763 : }
764 : else
765 : {
766 2 : pOutDev->SetFillColor( rStyleSettings.GetCheckedColor() );
767 2 : pOutDev->DrawRect( maThumbRect );
768 : }
769 : }
770 : }
771 :
772 850 : if ( (nDrawFlags & SCRBAR_DRAW_PAGE1) && (!pWin || !ImplDrawNative( SCRBAR_DRAW_PAGE1 ) ) )
773 : {
774 850 : if ( mnStateFlags & SCRBAR_STATE_PAGE1_DOWN )
775 0 : pOutDev->SetFillColor( rStyleSettings.GetShadowColor() );
776 : else
777 850 : pOutDev->SetFillColor( rStyleSettings.GetCheckedColor() );
778 850 : pOutDev->DrawRect( maPage1Rect );
779 : }
780 850 : if ( (nDrawFlags & SCRBAR_DRAW_PAGE2) && (!pWin || !ImplDrawNative( SCRBAR_DRAW_PAGE2 ) ) )
781 : {
782 850 : if ( mnStateFlags & SCRBAR_STATE_PAGE2_DOWN )
783 0 : pOutDev->SetFillColor( rStyleSettings.GetShadowColor() );
784 : else
785 850 : pOutDev->SetFillColor( rStyleSettings.GetCheckedColor() );
786 850 : pOutDev->DrawRect( maPage2Rect );
787 : }
788 : }
789 :
790 : // -----------------------------------------------------------------------
791 :
792 0 : long ScrollBar::ImplScroll( long nNewPos, sal_Bool bCallEndScroll )
793 : {
794 0 : long nOldPos = mnThumbPos;
795 0 : SetThumbPos( nNewPos );
796 0 : long nDelta = mnThumbPos-nOldPos;
797 0 : if ( nDelta )
798 : {
799 0 : mnDelta = nDelta;
800 0 : Scroll();
801 0 : if ( bCallEndScroll )
802 0 : EndScroll();
803 0 : mnDelta = 0;
804 : }
805 0 : return nDelta;
806 : }
807 :
808 : // -----------------------------------------------------------------------
809 :
810 0 : long ScrollBar::ImplDoAction( sal_Bool bCallEndScroll )
811 : {
812 0 : long nDelta = 0;
813 :
814 0 : switch ( meScrollType )
815 : {
816 : case SCROLL_LINEUP:
817 0 : nDelta = ImplScroll( mnThumbPos-mnLineSize, bCallEndScroll );
818 0 : break;
819 :
820 : case SCROLL_LINEDOWN:
821 0 : nDelta = ImplScroll( mnThumbPos+mnLineSize, bCallEndScroll );
822 0 : break;
823 :
824 : case SCROLL_PAGEUP:
825 0 : nDelta = ImplScroll( mnThumbPos-mnPageSize, bCallEndScroll );
826 0 : break;
827 :
828 : case SCROLL_PAGEDOWN:
829 0 : nDelta = ImplScroll( mnThumbPos+mnPageSize, bCallEndScroll );
830 0 : break;
831 : default:
832 : ;
833 : }
834 :
835 0 : return nDelta;
836 : }
837 :
838 : // -----------------------------------------------------------------------
839 :
840 0 : void ScrollBar::ImplDoMouseAction( const Point& rMousePos, sal_Bool bCallAction )
841 : {
842 0 : sal_uInt16 nOldStateFlags = mnStateFlags;
843 0 : sal_Bool bAction = sal_False;
844 0 : sal_Bool bHorizontal = ( GetStyle() & WB_HORZ )? sal_True: sal_False;
845 0 : sal_Bool bIsInside = sal_False;
846 :
847 0 : Point aPoint( 0, 0 );
848 0 : Rectangle aControlRegion( aPoint, GetOutputSizePixel() );
849 :
850 0 : switch ( meScrollType )
851 : {
852 : case SCROLL_LINEUP:
853 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_RIGHT: PART_BUTTON_LEFT): PART_BUTTON_UP,
854 0 : aControlRegion, rMousePos, bIsInside )?
855 : bIsInside:
856 0 : maBtn1Rect.IsInside( rMousePos ) )
857 : {
858 0 : bAction = bCallAction;
859 0 : mnStateFlags |= SCRBAR_STATE_BTN1_DOWN;
860 : }
861 : else
862 0 : mnStateFlags &= ~SCRBAR_STATE_BTN1_DOWN;
863 0 : break;
864 :
865 : case SCROLL_LINEDOWN:
866 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_LEFT: PART_BUTTON_RIGHT): PART_BUTTON_DOWN,
867 0 : aControlRegion, rMousePos, bIsInside )?
868 : bIsInside:
869 0 : maBtn2Rect.IsInside( rMousePos ) )
870 : {
871 0 : bAction = bCallAction;
872 0 : mnStateFlags |= SCRBAR_STATE_BTN2_DOWN;
873 : }
874 : else
875 0 : mnStateFlags &= ~SCRBAR_STATE_BTN2_DOWN;
876 0 : break;
877 :
878 : case SCROLL_PAGEUP:
879 : // HitTestNativeControl, see remark at top of file
880 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? PART_TRACK_HORZ_LEFT: PART_TRACK_VERT_UPPER,
881 0 : maPage1Rect, rMousePos, bIsInside )?
882 : bIsInside:
883 0 : maPage1Rect.IsInside( rMousePos ) )
884 : {
885 0 : bAction = bCallAction;
886 0 : mnStateFlags |= SCRBAR_STATE_PAGE1_DOWN;
887 : }
888 : else
889 0 : mnStateFlags &= ~SCRBAR_STATE_PAGE1_DOWN;
890 0 : break;
891 :
892 : case SCROLL_PAGEDOWN:
893 : // HitTestNativeControl, see remark at top of file
894 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? PART_TRACK_HORZ_RIGHT: PART_TRACK_VERT_LOWER,
895 0 : maPage2Rect, rMousePos, bIsInside )?
896 : bIsInside:
897 0 : maPage2Rect.IsInside( rMousePos ) )
898 : {
899 0 : bAction = bCallAction;
900 0 : mnStateFlags |= SCRBAR_STATE_PAGE2_DOWN;
901 : }
902 : else
903 0 : mnStateFlags &= ~SCRBAR_STATE_PAGE2_DOWN;
904 0 : break;
905 : default:
906 : ;
907 : }
908 :
909 0 : if ( nOldStateFlags != mnStateFlags )
910 0 : ImplDraw( mnDragDraw, this );
911 0 : if ( bAction )
912 0 : ImplDoAction( sal_False );
913 0 : }
914 :
915 : // -----------------------------------------------------------------------
916 :
917 0 : void ScrollBar::ImplDragThumb( const Point& rMousePos )
918 : {
919 : long nMovePix;
920 0 : if ( GetStyle() & WB_HORZ )
921 0 : nMovePix = rMousePos.X()-(maThumbRect.Left()+mnMouseOff);
922 : else
923 0 : nMovePix = rMousePos.Y()-(maThumbRect.Top()+mnMouseOff);
924 :
925 : // move thumb if necessary
926 0 : if ( nMovePix )
927 : {
928 0 : mnThumbPixPos += nMovePix;
929 0 : if ( mnThumbPixPos < 0 )
930 0 : mnThumbPixPos = 0;
931 0 : if ( mnThumbPixPos > (mnThumbPixRange-mnThumbPixSize) )
932 0 : mnThumbPixPos = mnThumbPixRange-mnThumbPixSize;
933 0 : long nOldPos = mnThumbPos;
934 0 : mnThumbPos = ImplCalcThumbPos( mnThumbPixPos );
935 0 : ImplUpdateRects();
936 0 : if ( mbFullDrag && (nOldPos != mnThumbPos) )
937 : {
938 0 : mnDelta = mnThumbPos-nOldPos;
939 0 : Scroll();
940 0 : mnDelta = 0;
941 : }
942 : }
943 0 : }
944 :
945 : // -----------------------------------------------------------------------
946 :
947 0 : void ScrollBar::MouseButtonDown( const MouseEvent& rMEvt )
948 : {
949 0 : bool bPrimaryWarps = GetSettings().GetStyleSettings().GetPrimaryButtonWarpsSlider();
950 0 : bool bWarp = bPrimaryWarps ? rMEvt.IsLeft() : rMEvt.IsMiddle();
951 0 : bool bPrimaryWarping = bWarp && rMEvt.IsLeft();
952 0 : bool bPage = bPrimaryWarps ? rMEvt.IsRight() : rMEvt.IsLeft();
953 :
954 0 : if (rMEvt.IsLeft() || rMEvt.IsMiddle() || rMEvt.IsRight())
955 : {
956 0 : const Point& rMousePos = rMEvt.GetPosPixel();
957 0 : sal_uInt16 nTrackFlags = 0;
958 0 : sal_Bool bHorizontal = ( GetStyle() & WB_HORZ )? sal_True: sal_False;
959 0 : sal_Bool bIsInside = sal_False;
960 0 : sal_Bool bDragToMouse = sal_False;
961 :
962 0 : Point aPoint( 0, 0 );
963 0 : Rectangle aControlRegion( aPoint, GetOutputSizePixel() );
964 :
965 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_RIGHT: PART_BUTTON_LEFT): PART_BUTTON_UP,
966 0 : aControlRegion, rMousePos, bIsInside )?
967 : bIsInside:
968 0 : maBtn1Rect.IsInside( rMousePos ) )
969 : {
970 0 : if (rMEvt.IsLeft() && !(mnStateFlags & SCRBAR_STATE_BTN1_DISABLE) )
971 : {
972 0 : nTrackFlags = STARTTRACK_BUTTONREPEAT;
973 0 : meScrollType = SCROLL_LINEUP;
974 0 : mnDragDraw = SCRBAR_DRAW_BTN1;
975 : }
976 : }
977 0 : else if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_LEFT: PART_BUTTON_RIGHT): PART_BUTTON_DOWN,
978 0 : aControlRegion, rMousePos, bIsInside )?
979 : bIsInside:
980 0 : maBtn2Rect.IsInside( rMousePos ) )
981 : {
982 0 : if (rMEvt.IsLeft() && !(mnStateFlags & SCRBAR_STATE_BTN2_DISABLE) )
983 : {
984 0 : nTrackFlags = STARTTRACK_BUTTONREPEAT;
985 0 : meScrollType = SCROLL_LINEDOWN;
986 0 : mnDragDraw = SCRBAR_DRAW_BTN2;
987 : }
988 : }
989 : else
990 : {
991 : bool bThumbHit = HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? PART_THUMB_HORZ : PART_THUMB_VERT,
992 0 : maThumbRect, rMousePos, bIsInside )
993 0 : ? bIsInside : maThumbRect.IsInside( rMousePos );
994 :
995 0 : bool bThumbAction = bWarp || bPage;
996 :
997 0 : bool bDragHandling = bWarp || (bThumbHit && bThumbAction);
998 0 : if( bDragHandling )
999 : {
1000 0 : if( mpData )
1001 : {
1002 0 : mpData->mbHide = sal_True; // disable focus blinking
1003 0 : if( HasFocus() )
1004 0 : ImplDraw( SCRBAR_DRAW_THUMB, this ); // paint without focus
1005 : }
1006 :
1007 0 : if ( mnVisibleSize < mnMaxRange-mnMinRange )
1008 : {
1009 0 : nTrackFlags = 0;
1010 0 : meScrollType = SCROLL_DRAG;
1011 0 : mnDragDraw = SCRBAR_DRAW_THUMB;
1012 :
1013 : // calculate mouse offset
1014 0 : if (bWarp && (!bThumbHit || !bPrimaryWarping))
1015 : {
1016 0 : bDragToMouse = sal_True;
1017 0 : if ( GetStyle() & WB_HORZ )
1018 0 : mnMouseOff = maThumbRect.GetWidth()/2;
1019 : else
1020 0 : mnMouseOff = maThumbRect.GetHeight()/2;
1021 : }
1022 : else
1023 : {
1024 0 : if ( GetStyle() & WB_HORZ )
1025 0 : mnMouseOff = rMousePos.X()-maThumbRect.Left();
1026 : else
1027 0 : mnMouseOff = rMousePos.Y()-maThumbRect.Top();
1028 : }
1029 :
1030 0 : mnStateFlags |= SCRBAR_STATE_THUMB_DOWN;
1031 0 : ImplDraw( mnDragDraw, this );
1032 : }
1033 : }
1034 0 : else if(bPage && (HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? PART_TRACK_HORZ_AREA : PART_TRACK_VERT_AREA,
1035 0 : aControlRegion, rMousePos, bIsInside ) ?
1036 0 : bIsInside : sal_True) )
1037 : {
1038 0 : nTrackFlags = STARTTRACK_BUTTONREPEAT;
1039 :
1040 : // HitTestNativeControl, see remark at top of file
1041 0 : if ( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? PART_TRACK_HORZ_LEFT : PART_TRACK_VERT_UPPER,
1042 0 : maPage1Rect, rMousePos, bIsInside )?
1043 : bIsInside:
1044 0 : maPage1Rect.IsInside( rMousePos ) )
1045 : {
1046 0 : meScrollType = SCROLL_PAGEUP;
1047 0 : mnDragDraw = SCRBAR_DRAW_PAGE1;
1048 : }
1049 : else
1050 : {
1051 0 : meScrollType = SCROLL_PAGEDOWN;
1052 0 : mnDragDraw = SCRBAR_DRAW_PAGE2;
1053 : }
1054 : }
1055 : }
1056 :
1057 : // Soll Tracking gestartet werden
1058 0 : if ( meScrollType != SCROLL_DONTKNOW )
1059 : {
1060 : // remember original position in case of abort or EndScroll-Delta
1061 0 : mnStartPos = mnThumbPos;
1062 : // #92906# Call StartTracking() before ImplDoMouseAction(), otherwise
1063 : // MouseButtonUp() / EndTracking() may be called if somebody is spending
1064 : // a lot of time in the scroll handler
1065 0 : StartTracking( nTrackFlags );
1066 0 : ImplDoMouseAction( rMousePos );
1067 :
1068 0 : if( bDragToMouse )
1069 0 : ImplDragThumb( rMousePos );
1070 : }
1071 : }
1072 0 : }
1073 :
1074 : // -----------------------------------------------------------------------
1075 :
1076 0 : void ScrollBar::Tracking( const TrackingEvent& rTEvt )
1077 : {
1078 0 : if ( rTEvt.IsTrackingEnded() )
1079 : {
1080 : // Button und PageRect-Status wieder herstellen
1081 0 : sal_uInt16 nOldStateFlags = mnStateFlags;
1082 : mnStateFlags &= ~(SCRBAR_STATE_BTN1_DOWN | SCRBAR_STATE_BTN2_DOWN |
1083 : SCRBAR_STATE_PAGE1_DOWN | SCRBAR_STATE_PAGE2_DOWN |
1084 0 : SCRBAR_STATE_THUMB_DOWN);
1085 0 : if ( nOldStateFlags != mnStateFlags )
1086 0 : ImplDraw( mnDragDraw, this );
1087 0 : mnDragDraw = 0;
1088 :
1089 : // Bei Abbruch, die alte ThumbPosition wieder herstellen
1090 0 : if ( rTEvt.IsTrackingCanceled() )
1091 : {
1092 0 : long nOldPos = mnThumbPos;
1093 0 : SetThumbPos( mnStartPos );
1094 0 : mnDelta = mnThumbPos-nOldPos;
1095 0 : Scroll();
1096 : }
1097 :
1098 0 : if ( meScrollType == SCROLL_DRAG )
1099 : {
1100 : // Wenn gedragt wurde, berechnen wir den Thumb neu, damit
1101 : // er wieder auf einer gerundeten ThumbPosition steht
1102 0 : ImplCalc();
1103 :
1104 0 : if ( !mbFullDrag && (mnStartPos != mnThumbPos) )
1105 : {
1106 0 : mnDelta = mnThumbPos-mnStartPos;
1107 0 : Scroll();
1108 0 : mnDelta = 0;
1109 : }
1110 : }
1111 :
1112 0 : mnDelta = mnThumbPos-mnStartPos;
1113 0 : EndScroll();
1114 0 : mnDelta = 0;
1115 0 : meScrollType = SCROLL_DONTKNOW;
1116 :
1117 0 : if( mpData )
1118 0 : mpData->mbHide = sal_False; // re-enable focus blinking
1119 : }
1120 : else
1121 : {
1122 0 : const Point rMousePos = rTEvt.GetMouseEvent().GetPosPixel();
1123 :
1124 : // Dragging wird speziell behandelt
1125 0 : if ( meScrollType == SCROLL_DRAG )
1126 0 : ImplDragThumb( rMousePos );
1127 : else
1128 0 : ImplDoMouseAction( rMousePos, rTEvt.IsTrackingRepeat() );
1129 :
1130 : // Wenn ScrollBar-Werte so umgesetzt wurden, das es nichts
1131 : // mehr zum Tracking gibt, dann berechen wir hier ab
1132 0 : if ( !IsVisible() || (mnVisibleSize >= (mnMaxRange-mnMinRange)) )
1133 0 : EndTracking();
1134 : }
1135 0 : }
1136 :
1137 : // -----------------------------------------------------------------------
1138 :
1139 0 : void ScrollBar::KeyInput( const KeyEvent& rKEvt )
1140 : {
1141 0 : if ( !rKEvt.GetKeyCode().GetModifier() )
1142 : {
1143 0 : switch ( rKEvt.GetKeyCode().GetCode() )
1144 : {
1145 : case KEY_HOME:
1146 0 : DoScroll( 0 );
1147 0 : break;
1148 :
1149 : case KEY_END:
1150 0 : DoScroll( GetRangeMax() );
1151 0 : break;
1152 :
1153 : case KEY_LEFT:
1154 : case KEY_UP:
1155 0 : DoScrollAction( SCROLL_LINEUP );
1156 0 : break;
1157 :
1158 : case KEY_RIGHT:
1159 : case KEY_DOWN:
1160 0 : DoScrollAction( SCROLL_LINEDOWN );
1161 0 : break;
1162 :
1163 : case KEY_PAGEUP:
1164 0 : DoScrollAction( SCROLL_PAGEUP );
1165 0 : break;
1166 :
1167 : case KEY_PAGEDOWN:
1168 0 : DoScrollAction( SCROLL_PAGEDOWN );
1169 0 : break;
1170 :
1171 : default:
1172 0 : Control::KeyInput( rKEvt );
1173 0 : break;
1174 : }
1175 : }
1176 : else
1177 0 : Control::KeyInput( rKEvt );
1178 0 : }
1179 :
1180 : // -----------------------------------------------------------------------
1181 :
1182 850 : void ScrollBar::Paint( const Rectangle& )
1183 : {
1184 850 : ImplDraw( SCRBAR_DRAW_ALL, this );
1185 850 : }
1186 :
1187 : // -----------------------------------------------------------------------
1188 :
1189 1071 : void ScrollBar::Resize()
1190 : {
1191 1071 : Control::Resize();
1192 1071 : mbCalcSize = sal_True;
1193 1071 : if ( IsReallyVisible() )
1194 288 : ImplCalc( sal_False );
1195 1071 : Invalidate();
1196 1071 : }
1197 :
1198 : // -----------------------------------------------------------------------
1199 :
1200 0 : IMPL_LINK_NOARG(ScrollBar, ImplAutoTimerHdl)
1201 : {
1202 0 : if( mpData && mpData->mbHide )
1203 0 : return 0;
1204 0 : ImplInvert();
1205 0 : return 0;
1206 : }
1207 :
1208 0 : void ScrollBar::ImplInvert()
1209 : {
1210 0 : Rectangle aRect( maThumbRect );
1211 0 : if( aRect.getWidth() > 4 )
1212 : {
1213 0 : aRect.Left() += 2;
1214 0 : aRect.Right() -= 2;
1215 : }
1216 0 : if( aRect.getHeight() > 4 )
1217 : {
1218 0 : aRect.Top() += 2;
1219 0 : aRect.Bottom() -= 2;
1220 : }
1221 :
1222 0 : Invert( aRect, 0 );
1223 0 : }
1224 :
1225 : // -----------------------------------------------------------------------
1226 :
1227 0 : void ScrollBar::GetFocus()
1228 : {
1229 0 : if( !mpData )
1230 : {
1231 0 : mpData = new ImplScrollBarData;
1232 0 : mpData->maTimer.SetTimeoutHdl( LINK( this, ScrollBar, ImplAutoTimerHdl ) );
1233 0 : mpData->mbHide = sal_False;
1234 : }
1235 0 : ImplInvert(); // react immediately
1236 0 : mpData->maTimer.SetTimeout( GetSettings().GetStyleSettings().GetCursorBlinkTime() );
1237 0 : mpData->maTimer.Start();
1238 0 : Control::GetFocus();
1239 0 : }
1240 :
1241 : // -----------------------------------------------------------------------
1242 :
1243 0 : void ScrollBar::LoseFocus()
1244 : {
1245 0 : if( mpData )
1246 0 : mpData->maTimer.Stop();
1247 0 : ImplDraw( SCRBAR_DRAW_THUMB, this );
1248 :
1249 0 : Control::LoseFocus();
1250 0 : }
1251 :
1252 : // -----------------------------------------------------------------------
1253 :
1254 2497 : void ScrollBar::StateChanged( StateChangedType nType )
1255 : {
1256 2497 : Control::StateChanged( nType );
1257 :
1258 2497 : if ( nType == STATE_CHANGE_INITSHOW )
1259 379 : ImplCalc( sal_False );
1260 2118 : else if ( nType == STATE_CHANGE_DATA )
1261 : {
1262 1227 : if ( IsReallyVisible() && IsUpdateMode() )
1263 323 : ImplCalc( sal_True );
1264 : }
1265 891 : else if ( nType == STATE_CHANGE_UPDATEMODE )
1266 : {
1267 0 : if ( IsReallyVisible() && IsUpdateMode() )
1268 : {
1269 0 : ImplCalc( sal_False );
1270 0 : Invalidate();
1271 : }
1272 : }
1273 891 : else if ( nType == STATE_CHANGE_ENABLE )
1274 : {
1275 229 : if ( IsReallyVisible() && IsUpdateMode() )
1276 208 : Invalidate();
1277 : }
1278 662 : else if ( nType == STATE_CHANGE_STYLE )
1279 : {
1280 0 : ImplInitStyle( GetStyle() );
1281 0 : if ( IsReallyVisible() && IsUpdateMode() )
1282 : {
1283 0 : if ( (GetPrevStyle() & SCRBAR_VIEW_STYLE) !=
1284 0 : (GetStyle() & SCRBAR_VIEW_STYLE) )
1285 : {
1286 0 : mbCalcSize = sal_True;
1287 0 : ImplCalc( sal_False );
1288 0 : Invalidate();
1289 : }
1290 : }
1291 : }
1292 2497 : }
1293 :
1294 : // -----------------------------------------------------------------------
1295 :
1296 196 : void ScrollBar::DataChanged( const DataChangedEvent& rDCEvt )
1297 : {
1298 196 : Control::DataChanged( rDCEvt );
1299 :
1300 392 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1301 196 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
1302 : {
1303 12 : mbCalcSize = sal_True;
1304 12 : ImplCalc( sal_False );
1305 12 : Invalidate();
1306 : }
1307 196 : }
1308 :
1309 : // -----------------------------------------------------------------------
1310 :
1311 0 : Rectangle* ScrollBar::ImplFindPartRect( const Point& rPt )
1312 : {
1313 0 : sal_Bool bHorizontal = ( GetStyle() & WB_HORZ )? sal_True: sal_False;
1314 0 : sal_Bool bIsInside = sal_False;
1315 :
1316 0 : Point aPoint( 0, 0 );
1317 0 : Rectangle aControlRegion( aPoint, GetOutputSizePixel() );
1318 :
1319 0 : if( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_RIGHT: PART_BUTTON_LEFT): PART_BUTTON_UP,
1320 0 : aControlRegion, rPt, bIsInside )?
1321 : bIsInside:
1322 0 : maBtn1Rect.IsInside( rPt ) )
1323 0 : return &maBtn1Rect;
1324 0 : else if( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal? (IsRTLEnabled()? PART_BUTTON_LEFT: PART_BUTTON_RIGHT): PART_BUTTON_DOWN,
1325 0 : aControlRegion, rPt, bIsInside )?
1326 : bIsInside:
1327 0 : maBtn2Rect.IsInside( rPt ) )
1328 0 : return &maBtn2Rect;
1329 : // HitTestNativeControl, see remark at top of file
1330 0 : else if( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal ? PART_TRACK_HORZ_LEFT : PART_TRACK_VERT_UPPER,
1331 0 : maPage1Rect, rPt, bIsInside)?
1332 : bIsInside:
1333 0 : maPage1Rect.IsInside( rPt ) )
1334 0 : return &maPage1Rect;
1335 : // HitTestNativeControl, see remark at top of file
1336 0 : else if( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal ? PART_TRACK_HORZ_RIGHT : PART_TRACK_VERT_LOWER,
1337 0 : maPage2Rect, rPt, bIsInside)?
1338 : bIsInside:
1339 0 : maPage2Rect.IsInside( rPt ) )
1340 0 : return &maPage2Rect;
1341 : // HitTestNativeControl, see remark at top of file
1342 0 : else if( HitTestNativeControl( CTRL_SCROLLBAR, bHorizontal ? PART_THUMB_HORZ : PART_THUMB_VERT,
1343 0 : maThumbRect, rPt, bIsInside)?
1344 : bIsInside:
1345 0 : maThumbRect.IsInside( rPt ) )
1346 0 : return &maThumbRect;
1347 : else
1348 0 : return NULL;
1349 : }
1350 :
1351 0 : long ScrollBar::PreNotify( NotifyEvent& rNEvt )
1352 : {
1353 0 : long nDone = 0;
1354 0 : const MouseEvent* pMouseEvt = NULL;
1355 :
1356 0 : if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
1357 : {
1358 0 : if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
1359 : {
1360 : // trigger redraw if mouse over state has changed
1361 0 : if( IsNativeControlSupported(CTRL_SCROLLBAR, PART_ENTIRE_CONTROL) )
1362 : {
1363 0 : Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
1364 0 : Rectangle* pLastRect = ImplFindPartRect( GetLastPointerPosPixel() );
1365 0 : if( pRect != pLastRect || pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() )
1366 : {
1367 0 : Region aRgn( GetActiveClipRegion() );
1368 0 : Region aClipRegion;
1369 :
1370 0 : if ( pRect )
1371 0 : aClipRegion.Union( *pRect );
1372 0 : if ( pLastRect )
1373 0 : aClipRegion.Union( *pLastRect );
1374 :
1375 : // Support for 3-button scroll bars
1376 0 : sal_Bool bHas3Buttons = IsNativeControlSupported( CTRL_SCROLLBAR, HAS_THREE_BUTTONS );
1377 0 : if ( bHas3Buttons && ( pRect == &maBtn1Rect || pLastRect == &maBtn1Rect ) )
1378 : {
1379 0 : aClipRegion.Union( maBtn2Rect );
1380 : }
1381 :
1382 0 : SetClipRegion( aClipRegion );
1383 0 : Paint( aClipRegion.GetBoundRect() );
1384 :
1385 0 : SetClipRegion( aRgn );
1386 : }
1387 : }
1388 : }
1389 : }
1390 :
1391 0 : return nDone ? nDone : Control::PreNotify(rNEvt);
1392 : }
1393 :
1394 : // -----------------------------------------------------------------------
1395 :
1396 0 : void ScrollBar::Scroll()
1397 : {
1398 0 : ImplCallEventListenersAndHandler( VCLEVENT_SCROLLBAR_SCROLL, maScrollHdl, this );
1399 0 : }
1400 :
1401 : // -----------------------------------------------------------------------
1402 :
1403 0 : void ScrollBar::EndScroll()
1404 : {
1405 0 : ImplCallEventListenersAndHandler( VCLEVENT_SCROLLBAR_ENDSCROLL, maEndScrollHdl, this );
1406 0 : }
1407 :
1408 : // -----------------------------------------------------------------------
1409 :
1410 0 : long ScrollBar::DoScroll( long nNewPos )
1411 : {
1412 0 : if ( meScrollType != SCROLL_DONTKNOW )
1413 0 : return 0;
1414 :
1415 0 : meScrollType = SCROLL_DRAG;
1416 0 : long nDelta = ImplScroll( nNewPos, sal_True );
1417 0 : meScrollType = SCROLL_DONTKNOW;
1418 0 : return nDelta;
1419 : }
1420 :
1421 : // -----------------------------------------------------------------------
1422 :
1423 0 : long ScrollBar::DoScrollAction( ScrollType eScrollType )
1424 : {
1425 0 : if ( (meScrollType != SCROLL_DONTKNOW) ||
1426 : (eScrollType == SCROLL_DONTKNOW) ||
1427 : (eScrollType == SCROLL_DRAG) )
1428 0 : return 0;
1429 :
1430 0 : meScrollType = eScrollType;
1431 0 : long nDelta = ImplDoAction( sal_True );
1432 0 : meScrollType = SCROLL_DONTKNOW;
1433 0 : return nDelta;
1434 : }
1435 :
1436 : // -----------------------------------------------------------------------
1437 :
1438 0 : void ScrollBar::SetRangeMin( long nNewRange )
1439 : {
1440 0 : SetRange( Range( nNewRange, GetRangeMax() ) );
1441 0 : }
1442 :
1443 : // -----------------------------------------------------------------------
1444 :
1445 0 : void ScrollBar::SetRangeMax( long nNewRange )
1446 : {
1447 0 : SetRange( Range( GetRangeMin(), nNewRange ) );
1448 0 : }
1449 :
1450 : // -----------------------------------------------------------------------
1451 :
1452 2794 : void ScrollBar::SetRange( const Range& rRange )
1453 : {
1454 : // Range einpassen
1455 2794 : Range aRange = rRange;
1456 2794 : aRange.Justify();
1457 2794 : long nNewMinRange = aRange.Min();
1458 2794 : long nNewMaxRange = aRange.Max();
1459 :
1460 : // Wenn Range sich unterscheidet, dann neuen setzen
1461 2794 : if ( (mnMinRange != nNewMinRange) ||
1462 : (mnMaxRange != nNewMaxRange) )
1463 : {
1464 444 : mnMinRange = nNewMinRange;
1465 444 : mnMaxRange = nNewMaxRange;
1466 :
1467 : // Thumb einpassen
1468 444 : if ( mnThumbPos > mnMaxRange-mnVisibleSize )
1469 15 : mnThumbPos = mnMaxRange-mnVisibleSize;
1470 444 : if ( mnThumbPos < mnMinRange )
1471 15 : mnThumbPos = mnMinRange;
1472 :
1473 444 : StateChanged( STATE_CHANGE_DATA );
1474 : }
1475 2794 : }
1476 :
1477 : // -----------------------------------------------------------------------
1478 :
1479 1428 : void ScrollBar::SetThumbPos( long nNewThumbPos )
1480 : {
1481 1428 : if ( nNewThumbPos > mnMaxRange-mnVisibleSize )
1482 37 : nNewThumbPos = mnMaxRange-mnVisibleSize;
1483 1428 : if ( nNewThumbPos < mnMinRange )
1484 37 : nNewThumbPos = mnMinRange;
1485 :
1486 1428 : if ( mnThumbPos != nNewThumbPos )
1487 : {
1488 19 : mnThumbPos = nNewThumbPos;
1489 19 : StateChanged( STATE_CHANGE_DATA );
1490 : }
1491 1428 : }
1492 :
1493 : // -----------------------------------------------------------------------
1494 :
1495 1412 : void ScrollBar::SetVisibleSize( long nNewSize )
1496 : {
1497 1412 : if ( mnVisibleSize != nNewSize )
1498 : {
1499 764 : mnVisibleSize = nNewSize;
1500 :
1501 : // Thumb einpassen
1502 764 : if ( mnThumbPos > mnMaxRange-mnVisibleSize )
1503 23 : mnThumbPos = mnMaxRange-mnVisibleSize;
1504 764 : if ( mnThumbPos < mnMinRange )
1505 23 : mnThumbPos = mnMinRange;
1506 764 : StateChanged( STATE_CHANGE_DATA );
1507 : }
1508 1412 : }
1509 :
1510 0 : Size ScrollBar::GetOptimalSize(WindowSizeType) const
1511 : {
1512 0 : if (mbCalcSize)
1513 0 : const_cast<ScrollBar*>(this)->ImplCalc(sal_False);
1514 0 : return getCurrentCalcSize();
1515 : }
1516 :
1517 1358 : Size ScrollBar::getCurrentCalcSize() const
1518 : {
1519 1358 : Rectangle aCtrlRegion;
1520 1358 : aCtrlRegion.Union(maBtn1Rect);
1521 1358 : aCtrlRegion.Union(maBtn2Rect);
1522 1358 : aCtrlRegion.Union(maPage1Rect);
1523 1358 : aCtrlRegion.Union(maPage2Rect);
1524 1358 : aCtrlRegion.Union(maThumbRect);
1525 1358 : return aCtrlRegion.GetSize();
1526 : }
1527 :
1528 : // =======================================================================
1529 :
1530 248 : void ScrollBarBox::ImplInit( Window* pParent, WinBits nStyle )
1531 : {
1532 248 : Window::ImplInit( pParent, nStyle, NULL );
1533 :
1534 248 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1535 248 : long nScrollSize = rStyleSettings.GetScrollBarSize();
1536 248 : SetSizePixel( Size( nScrollSize, nScrollSize ) );
1537 248 : ImplInitSettings();
1538 248 : }
1539 :
1540 : // -----------------------------------------------------------------------
1541 :
1542 248 : ScrollBarBox::ScrollBarBox( Window* pParent, WinBits nStyle ) :
1543 248 : Window( WINDOW_SCROLLBARBOX )
1544 : {
1545 248 : ImplInit( pParent, nStyle );
1546 248 : }
1547 :
1548 : // -----------------------------------------------------------------------
1549 :
1550 248 : void ScrollBarBox::ImplInitSettings()
1551 : {
1552 : // Hack, damit man auch DockingWindows ohne Hintergrund bauen kann
1553 : // und noch nicht alles umgestellt ist
1554 248 : if ( IsBackground() )
1555 : {
1556 248 : Color aColor;
1557 248 : if ( IsControlBackground() )
1558 0 : aColor = GetControlBackground();
1559 : else
1560 248 : aColor = GetSettings().GetStyleSettings().GetFaceColor();
1561 248 : SetBackground( aColor );
1562 : }
1563 248 : }
1564 :
1565 : // -----------------------------------------------------------------------
1566 :
1567 504 : void ScrollBarBox::StateChanged( StateChangedType nType )
1568 : {
1569 504 : Window::StateChanged( nType );
1570 :
1571 504 : if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1572 : {
1573 0 : ImplInitSettings();
1574 0 : Invalidate();
1575 : }
1576 504 : }
1577 :
1578 : // -----------------------------------------------------------------------
1579 :
1580 92 : void ScrollBarBox::DataChanged( const DataChangedEvent& rDCEvt )
1581 : {
1582 92 : Window::DataChanged( rDCEvt );
1583 :
1584 184 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1585 92 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
1586 : {
1587 0 : ImplInitSettings();
1588 0 : Invalidate();
1589 : }
1590 92 : }
1591 :
1592 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
