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