vcl/source/control/slider.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: slider.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #ifndef _SV_RC_H
  35 #include <tools/rc.h>
  36 #endif
  37 #include <vcl/event.hxx>
  38 #include <vcl/decoview.hxx>
  39 #include <vcl/slider.hxx>
  40
  41
  42
  43 // =======================================================================
  44
  45 static long ImplMulDiv( long nNumber, long nNumerator, long nDenominator )
  46 {
  47     double n = ((double)nNumber * (double)nNumerator) / (double)nDenominator;
  48     return (long)n;
  49 }
  50
  51 // =======================================================================
  52
  53 #define SLIDER_DRAW_THUMB                       ((USHORT)0x0001)
  54 #define SLIDER_DRAW_CHANNEL1            ((USHORT)0x0002)
  55 #define SLIDER_DRAW_CHANNEL2            ((USHORT)0x0004)
  56 #define SLIDER_DRAW_CHANNEL             (SLIDER_DRAW_CHANNEL1 | SLIDER_DRAW_CHANNEL2)
  57 #define SLIDER_DRAW_ALL                         (SLIDER_DRAW_THUMB | SLIDER_DRAW_CHANNEL)
  58
  59 #define SLIDER_STATE_CHANNEL1_DOWN      ((USHORT)0x0001)
  60 #define SLIDER_STATE_CHANNEL2_DOWN      ((USHORT)0x0002)
  61 #define SLIDER_STATE_THUMB_DOWN         ((USHORT)0x0004)
  62
  63 #define SLIDER_THUMB_SIZE                       9
  64 #define SLIDER_THUMB_HALFSIZE           4
  65 #define SLIDER_CHANNEL_OFFSET           0
  66 #define SLIDER_CHANNEL_SIZE             4
  67 #define SLIDER_CHANNEL_HALFSIZE         2
  68
  69 #define SLIDER_HEIGHT                           16
  70
  71 #define SLIDER_VIEW_STYLE                       (WB_3DLOOK | WB_HORZ | WB_VERT)
  72
  73 // =======================================================================
  74
  75 void Slider::ImplInit( Window* pParent, WinBits nStyle )
  76 {
  77     mnThumbPixOffset    = 0;
  78     mnThumbPixRange     = 0;
  79     mnThumbPixPos               = 0;    // between mnThumbPixOffset and mnThumbPixOffset+mnThumbPixRange
  80     mnChannelPixOffset  = 0;
  81     mnChannelPixRange   = 0;
  82     mnChannelPixTop     = 0;
  83     mnChannelPixBottom  = 0;
  84
  85     mnMinRange                  = 0;
  86     mnMaxRange                  = 100;
  87     mnThumbPos                  = 0;
  88     mnLineSize                  = 1;
  89     mnPageSize                  = 1;
  90     mnDelta                     = 0;
  91     mnDragDraw                  = 0;
  92     mnStateFlags                = 0;
  93     meScrollType                = SCROLL_DONTKNOW;
  94     mbCalcSize                  = TRUE;
  95     mbFullDrag                  = TRUE;
  96
  97     Control::ImplInit( pParent, nStyle, NULL );
  98
  99     ImplInitSettings();
 100     SetSizePixel( CalcWindowSizePixel() );
 101 }
 102
 103 // -----------------------------------------------------------------------
 104
 105 Slider::Slider( Window* pParent, WinBits nStyle ) :
 106     Control( WINDOW_SLIDER )
 107 {
 108     ImplInit( pParent, nStyle );
 109 }
 110
 111 // -----------------------------------------------------------------------
 112
 113 Slider::Slider( Window* pParent, const ResId& rResId ) :
 114     Control( WINDOW_SLIDER )
 115 {
 116     rResId.SetRT( RSC_SCROLLBAR );
 117     WinBits nStyle = ImplInitRes( rResId );
 118     ImplInit( pParent, nStyle );
 119     ImplLoadRes( rResId );
 120
 121     if ( !(nStyle & WB_HIDE) )
 122         Show();
 123 }
 124
 125 // -----------------------------------------------------------------------
 126
 127 void Slider::ImplLoadRes( const ResId& rResId )
 128 {
 129     Control::ImplLoadRes( rResId );
 130
 131     INT16 nMin                  = ReadShortRes();
 132     INT16 nMax                  = ReadShortRes();
 133     INT16 nThumbPos             = ReadShortRes();
 134     INT16 nPage                 = ReadShortRes();
 135     INT16 nStep                 = ReadShortRes();
 136     /* INT16 nVisibleSize       = */ ReadShortRes();
 137
 138     SetRange( Range( nMin, nMax ) );
 139     SetLineSize( nStep );
 140     SetPageSize( nPage );
 141     SetThumbPos( nThumbPos );
 142 }
 143
 144 // -----------------------------------------------------------------------
 145
 146 void Slider::ImplInitSettings()
 147 {
 148     Window* pParent = GetParent();
 149     if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
 150     {
 151         EnableChildTransparentMode( TRUE );
 152         SetParentClipMode( PARENTCLIPMODE_NOCLIP );
 153         SetPaintTransparent( TRUE );
 154         SetBackground();
 155     }
 156     else
 157     {
 158         EnableChildTransparentMode( FALSE );
 159         SetParentClipMode( 0 );
 160         SetPaintTransparent( FALSE );
 161
 162         if ( IsControlBackground() )
 163             SetBackground( GetControlBackground() );
 164         else
 165             SetBackground( pParent->GetBackground() );
 166     }
 167 }
 168
 169 // -----------------------------------------------------------------------
 170
 171 void Slider::ImplUpdateRects( BOOL bUpdate )
 172 {
 173     Rectangle aOldThumbRect = maThumbRect;
 174
 175     if ( mnThumbPixRange )
 176     {
 177         if ( GetStyle() & WB_HORZ )
 178         {
 179             maThumbRect.Left()          = mnThumbPixPos-SLIDER_THUMB_HALFSIZE;
 180             maThumbRect.Right()         = maThumbRect.Left()+SLIDER_THUMB_SIZE-1;
 181             if ( mnChannelPixOffset < maThumbRect.Left() )
 182             {
 183                 maChannel1Rect.Left()   = mnChannelPixOffset;
 184                 maChannel1Rect.Right()  = maThumbRect.Left()-1;
 185                 maChannel1Rect.Top()    = mnChannelPixTop;
 186                 maChannel1Rect.Bottom() = mnChannelPixBottom;
 187             }
 188             else
 189                 maChannel1Rect.SetEmpty();
 190             if ( mnChannelPixOffset+mnChannelPixRange-1 > maThumbRect.Right() )
 191             {
 192                 maChannel2Rect.Left()   = maThumbRect.Right()+1;
 193                 maChannel2Rect.Right()  = mnChannelPixOffset+mnChannelPixRange-1;
 194                 maChannel2Rect.Top()    = mnChannelPixTop;
 195                 maChannel2Rect.Bottom() = mnChannelPixBottom;
 196             }
 197             else
 198                 maChannel2Rect.SetEmpty();
 199         }
 200         else
 201         {
 202             maThumbRect.Top()           = mnThumbPixPos-SLIDER_THUMB_HALFSIZE;
 203             maThumbRect.Bottom()        = maThumbRect.Top()+SLIDER_THUMB_SIZE-1;
 204             if ( mnChannelPixOffset < maThumbRect.Top() )
 205             {
 206                 maChannel1Rect.Top()    = mnChannelPixOffset;
 207                 maChannel1Rect.Bottom() = maThumbRect.Top()-1;
 208                 maChannel1Rect.Left()   = mnChannelPixTop;
 209                 maChannel1Rect.Right()  = mnChannelPixBottom;
 210             }
 211             else
 212                 maChannel1Rect.SetEmpty();
 213             if ( mnChannelPixOffset+mnChannelPixRange-1 > maThumbRect.Bottom() )
 214             {
 215                 maChannel2Rect.Top()    = maThumbRect.Bottom()+1;
 216                 maChannel2Rect.Bottom() = mnChannelPixOffset+mnChannelPixRange-1;
 217                 maChannel2Rect.Left()   = mnChannelPixTop;
 218                 maChannel2Rect.Right()  = mnChannelPixBottom;
 219             }
 220             else
 221                 maChannel2Rect.SetEmpty();
 222         }
 223     }
 224     else
 225     {
 226         maChannel1Rect.SetEmpty();
 227         maChannel2Rect.SetEmpty();
 228         maThumbRect.SetEmpty();
 229     }
 230
 231     if ( bUpdate )
 232     {
 233         if ( aOldThumbRect != maThumbRect )
 234         {
 235             Region aInvalidRegion( aOldThumbRect );
 236             aInvalidRegion.Union( maThumbRect );
 237
 238             if( !IsBackground() && GetParent() )
 239             {
 240                 const Point aPos( GetPosPixel() );
 241                 aInvalidRegion.Move( aPos.X(), aPos.Y() );
 242                 GetParent()->Invalidate( aInvalidRegion, INVALIDATE_TRANSPARENT | INVALIDATE_UPDATE );
 243             }
 244             else
 245                 Invalidate( aInvalidRegion );
 246         }
 247     }
 248 }
 249
 250 // -----------------------------------------------------------------------
 251
 252 long Slider::ImplCalcThumbPos( long nPixPos )
 253 {
 254     // Position berechnen
 255     long nCalcThumbPos;
 256     nCalcThumbPos = ImplMulDiv( nPixPos-mnThumbPixOffset, mnMaxRange-mnMinRange, mnThumbPixRange-1 );
 257     nCalcThumbPos += mnMinRange;
 258     return nCalcThumbPos;
 259 }
 260
 261 // -----------------------------------------------------------------------
 262
 263 long Slider::ImplCalcThumbPosPix( long nPos )
 264 {
 265     // Position berechnen
 266     long nCalcThumbPos;
 267     nCalcThumbPos = ImplMulDiv( nPos-mnMinRange, mnThumbPixRange-1, mnMaxRange-mnMinRange );
 268     // Am Anfang und Ende des Sliders versuchen wir die Anzeige korrekt
 269     // anzuzeigen
 270     if ( !nCalcThumbPos && (mnThumbPos > mnMinRange) )
 271         nCalcThumbPos = 1;
 272     if ( nCalcThumbPos &&
 273          (nCalcThumbPos == mnThumbPixRange-1) &&
 274          (mnThumbPos < mnMaxRange) )
 275         nCalcThumbPos--;
 276     return nCalcThumbPos+mnThumbPixOffset;
 277 }
 278
 279 // -----------------------------------------------------------------------
 280
 281 void Slider::ImplCalc( BOOL bUpdate )
 282 {
 283     BOOL bInvalidateAll = FALSE;
 284
 285     if ( mbCalcSize )
 286     {
 287         long nOldChannelPixOffset       = mnChannelPixOffset;
 288         long nOldChannelPixRange        = mnChannelPixRange;
 289         long nOldChannelPixTop          = mnChannelPixTop;
 290         long nOldChannelPixBottom       = mnChannelPixBottom;
 291         long nCalcWidth;
 292         long nCalcHeight;
 293
 294         maChannel1Rect.SetEmpty();
 295         maChannel2Rect.SetEmpty();
 296         maThumbRect.SetEmpty();
 297
 298         Size aSize = GetOutputSizePixel();
 299         if ( GetStyle() & WB_HORZ )
 300         {
 301             nCalcWidth                  = aSize.Width();
 302             nCalcHeight                 = aSize.Height();
 303             maThumbRect.Top()   = 0;
 304             maThumbRect.Bottom()= aSize.Height()-1;
 305         }
 306         else
 307         {
 308             nCalcWidth                  = aSize.Height();
 309             nCalcHeight                 = aSize.Width();
 310             maThumbRect.Left()  = 0;
 311             maThumbRect.Right() = aSize.Width()-1;
 312         }
 313
 314         if ( nCalcWidth >= SLIDER_THUMB_SIZE )
 315         {
 316             mnThumbPixOffset    = SLIDER_THUMB_HALFSIZE;
 317             mnThumbPixRange     = nCalcWidth-(SLIDER_THUMB_HALFSIZE*2);
 318             mnThumbPixPos               = 0;
 319             mnChannelPixOffset  = SLIDER_CHANNEL_OFFSET;
 320             mnChannelPixRange   = nCalcWidth-(SLIDER_CHANNEL_OFFSET*2);
 321             mnChannelPixTop     = (nCalcHeight/2)-SLIDER_CHANNEL_HALFSIZE;
 322             mnChannelPixBottom  = mnChannelPixTop+SLIDER_CHANNEL_SIZE-1;
 323         }
 324         else
 325         {
 326             mnThumbPixRange = 0;
 327             mnChannelPixRange = 0;
 328         }
 329
 330         if ( (nOldChannelPixOffset != mnChannelPixOffset) ||
 331              (nOldChannelPixRange != mnChannelPixRange) ||
 332              (nOldChannelPixTop != mnChannelPixTop) ||
 333              (nOldChannelPixBottom != mnChannelPixBottom) )
 334             bInvalidateAll = TRUE;
 335
 336         mbCalcSize = FALSE;
 337     }
 338
 339     if ( mnThumbPixRange )
 340         mnThumbPixPos = ImplCalcThumbPosPix( mnThumbPos );
 341
 342     if ( bUpdate && bInvalidateAll )
 343     {
 344         Invalidate();
 345         bUpdate = FALSE;
 346     }
 347     ImplUpdateRects( bUpdate );
 348 }
 349
 350 // -----------------------------------------------------------------------
 351
 352 void Slider::ImplDraw( USHORT nDrawFlags )
 353 {
 354     DecorationView                      aDecoView( this );
 355     USHORT                                      nStyle;
 356     const StyleSettings&        rStyleSettings = GetSettings().GetStyleSettings();
 357     BOOL                                        bEnabled = IsEnabled();
 358
 359     // Evt. noch offene Berechnungen nachholen
 360     if ( mbCalcSize )
 361         ImplCalc( FALSE );
 362
 363     if ( (nDrawFlags & SLIDER_DRAW_CHANNEL1) && !maChannel1Rect.IsEmpty() )
 364     {
 365         long            nRectSize;
 366         Rectangle       aRect = maChannel1Rect;
 367         SetLineColor( rStyleSettings.GetShadowColor() );
 368         if ( GetStyle() & WB_HORZ )
 369         {
 370             DrawLine( aRect.TopLeft(), Point( aRect.Left(), aRect.Bottom()-1 ) );
 371             DrawLine( aRect.TopLeft(), aRect.TopRight() );
 372         }
 373         else
 374         {
 375             DrawLine( aRect.TopLeft(), Point( aRect.Right()-1, aRect.Top() ) );
 376             DrawLine( aRect.TopLeft(), aRect.BottomLeft() );
 377         }
 378         SetLineColor( rStyleSettings.GetLightColor() );
 379         if ( GetStyle() & WB_HORZ )
 380         {
 381             DrawLine( aRect.BottomLeft(), aRect.BottomRight() );
 382             nRectSize = aRect.GetWidth();
 383         }
 384         else
 385         {
 386             DrawLine( aRect.TopRight(), aRect.BottomRight() );
 387             nRectSize = aRect.GetHeight();
 388         }
 389
 390         if ( nRectSize > 1 )
 391         {
 392             aRect.Left()++;
 393             aRect.Top()++;
 394             if ( GetStyle() & WB_HORZ )
 395                 aRect.Bottom()--;
 396             else
 397                 aRect.Right()--;
 398             SetLineColor();
 399             if ( mnStateFlags & SLIDER_STATE_CHANNEL1_DOWN )
 400                 SetFillColor( rStyleSettings.GetShadowColor() );
 401             else
 402                 SetFillColor( rStyleSettings.GetCheckedColor() );
 403             DrawRect( aRect );
 404         }
 405     }
 406
 407     if ( (nDrawFlags & SLIDER_DRAW_CHANNEL2) && !maChannel2Rect.IsEmpty() )
 408     {
 409         long            nRectSize;
 410         Rectangle       aRect = maChannel2Rect;
 411         SetLineColor( rStyleSettings.GetLightColor() );
 412         if ( GetStyle() & WB_HORZ )
 413         {
 414             DrawLine( aRect.TopRight(), aRect.BottomRight() );
 415             DrawLine( aRect.BottomLeft(), aRect.BottomRight() );
 416             nRectSize = aRect.GetWidth();
 417         }
 418         else
 419         {
 420             DrawLine( aRect.BottomLeft(), aRect.BottomRight() );
 421             DrawLine( aRect.TopRight(), aRect.BottomRight() );
 422             nRectSize = aRect.GetHeight();
 423         }
 424
 425         if ( nRectSize > 1 )
 426         {
 427             SetLineColor( rStyleSettings.GetShadowColor() );
 428             if ( GetStyle() & WB_HORZ )
 429                 DrawLine( aRect.TopLeft(), Point( aRect.Right()-1, aRect.Top() ) );
 430             else
 431                 DrawLine( aRect.TopLeft(), Point( aRect.Left(), aRect.Bottom()-1 ) );
 432
 433             aRect.Right()--;
 434             aRect.Bottom()--;
 435             if ( GetStyle() & WB_HORZ )
 436                 aRect.Top()++;
 437             else
 438                 aRect.Left()++;
 439             SetLineColor();
 440             if ( mnStateFlags & SLIDER_STATE_CHANNEL2_DOWN )
 441                 SetFillColor( rStyleSettings.GetShadowColor() );
 442             else
 443                 SetFillColor( rStyleSettings.GetCheckedColor() );
 444             DrawRect( aRect );
 445         }
 446     }
 447
 448     if ( nDrawFlags & SLIDER_DRAW_THUMB )
 449     {
 450         if ( !maThumbRect.IsEmpty() )
 451         {
 452             if ( bEnabled )
 453             {
 454                 nStyle = 0;
 455                 if ( mnStateFlags & SLIDER_STATE_THUMB_DOWN )
 456                     nStyle |= BUTTON_DRAW_PRESSED;
 457                 aDecoView.DrawButton( maThumbRect, nStyle );
 458             }
 459             else
 460             {
 461                 SetLineColor( rStyleSettings.GetShadowColor() );
 462                 SetFillColor( rStyleSettings.GetCheckedColor() );
 463                 DrawRect( maThumbRect );
 464             }
 465         }
 466     }
 467 }
 468
 469 // -----------------------------------------------------------------------
 470
 471 BOOL Slider::ImplIsPageUp( const Point& rPos )
 472 {
 473     Size aSize = GetOutputSizePixel();
 474     Rectangle aRect = maChannel1Rect;
 475     if ( GetStyle() & WB_HORZ )
 476     {
 477         aRect.Top()     = 0;
 478         aRect.Bottom()  = aSize.Height()-1;
 479     }
 480     else
 481     {
 482         aRect.Left()    = 0;
 483         aRect.Right()   = aSize.Width()-1;
 484     }
 485     return aRect.IsInside( rPos );
 486 }
 487
 488 // -----------------------------------------------------------------------
 489
 490 BOOL Slider::ImplIsPageDown( const Point& rPos )
 491 {
 492     Size aSize = GetOutputSizePixel();
 493     Rectangle aRect = maChannel2Rect;
 494     if ( GetStyle() & WB_HORZ )
 495     {
 496         aRect.Top()     = 0;
 497         aRect.Bottom()  = aSize.Height()-1;
 498     }
 499     else
 500     {
 501         aRect.Left()    = 0;
 502         aRect.Right()   = aSize.Width()-1;
 503     }
 504     return aRect.IsInside( rPos );
 505 }
 506
 507 // -----------------------------------------------------------------------
 508
 509 long Slider::ImplSlide( long nNewPos, BOOL bCallEndSlide )
 510 {
 511     long nOldPos = mnThumbPos;
 512     SetThumbPos( nNewPos );
 513     long nDelta = mnThumbPos-nOldPos;
 514     if ( nDelta )
 515     {
 516         mnDelta = nDelta;
 517         Slide();
 518         if ( bCallEndSlide )
 519             EndSlide();
 520         mnDelta = 0;
 521     }
 522     return nDelta;
 523 }
 524
 525 // -----------------------------------------------------------------------
 526
 527 long Slider::ImplDoAction( BOOL bCallEndSlide )
 528 {
 529     long nDelta = 0;
 530
 531     switch ( meScrollType )
 532     {
 533         case SCROLL_LINEUP:
 534             nDelta = ImplSlide( mnThumbPos-mnLineSize, bCallEndSlide );
 535             break;
 536
 537         case SCROLL_LINEDOWN:
 538             nDelta = ImplSlide( mnThumbPos+mnLineSize, bCallEndSlide );
 539             break;
 540
 541         case SCROLL_PAGEUP:
 542             nDelta = ImplSlide( mnThumbPos-mnPageSize, bCallEndSlide );
 543             break;
 544
 545         case SCROLL_PAGEDOWN:
 546             nDelta = ImplSlide( mnThumbPos+mnPageSize, bCallEndSlide );
 547             break;
 548
 549         case SCROLL_SET:
 550             nDelta = ImplSlide( ImplCalcThumbPos( GetPointerPosPixel().X() ), bCallEndSlide );
 551             break;
 552         default:
 553             break;
 554     }
 555
 556     return nDelta;
 557 }
 558
 559 // -----------------------------------------------------------------------
 560
 561 void Slider::ImplDoMouseAction( const Point& rMousePos, BOOL bCallAction )
 562 {
 563     USHORT      nOldStateFlags = mnStateFlags;
 564     BOOL        bAction = FALSE;
 565
 566     switch ( meScrollType )
 567     {
 568         case( SCROLL_SET ):
 569         {
 570             const bool bUp = ImplIsPageUp( rMousePos ), bDown = ImplIsPageDown( rMousePos );
 571
 572             if ( bUp || bDown )
 573             {
 574                 bAction = bCallAction;
 575                 mnStateFlags |= ( bUp ? SLIDER_STATE_CHANNEL1_DOWN : SLIDER_STATE_CHANNEL2_DOWN );
 576             }
 577             else
 578                 mnStateFlags &= ~( SLIDER_STATE_CHANNEL1_DOWN | SLIDER_STATE_CHANNEL2_DOWN );
 579             break;
 580         }
 581
 582         case SCROLL_PAGEUP:
 583             if ( ImplIsPageUp( rMousePos ) )
 584             {
 585                 bAction = bCallAction;
 586                 mnStateFlags |= SLIDER_STATE_CHANNEL1_DOWN;
 587             }
 588             else
 589                 mnStateFlags &= ~SLIDER_STATE_CHANNEL1_DOWN;
 590             break;
 591
 592         case SCROLL_PAGEDOWN:
 593             if ( ImplIsPageDown( rMousePos ) )
 594             {
 595                 bAction = bCallAction;
 596                 mnStateFlags |= SLIDER_STATE_CHANNEL2_DOWN;
 597             }
 598             else
 599                 mnStateFlags &= ~SLIDER_STATE_CHANNEL2_DOWN;
 600             break;
 601         default:
 602             break;
 603     }
 604
 605     if ( bAction )
 606     {
 607         if ( ImplDoAction( FALSE ) )
 608         {
 609             // Update the channel complete
 610             if ( mnDragDraw & SLIDER_DRAW_CHANNEL )
 611             {
 612                 Update();
 613                 ImplDraw( mnDragDraw );
 614             }
 615         }
 616     }
 617     else if ( nOldStateFlags != mnStateFlags )
 618         ImplDraw( mnDragDraw );
 619 }
 620
 621 // -----------------------------------------------------------------------
 622
 623 long Slider::ImplDoSlide( long nNewPos )
 624 {
 625     if ( meScrollType != SCROLL_DONTKNOW )
 626         return 0;
 627
 628     meScrollType = SCROLL_DRAG;
 629     long nDelta = ImplSlide( nNewPos, TRUE );
 630     meScrollType = SCROLL_DONTKNOW;
 631     return nDelta;
 632 }
 633
 634 // -----------------------------------------------------------------------
 635
 636 long Slider::ImplDoSlideAction( ScrollType eScrollType )
 637 {
 638     if ( (meScrollType != SCROLL_DONTKNOW) ||
 639          (eScrollType == SCROLL_DONTKNOW) ||
 640          (eScrollType == SCROLL_DRAG) )
 641         return 0;
 642
 643     meScrollType = eScrollType;
 644     long nDelta = ImplDoAction( TRUE );
 645     meScrollType = SCROLL_DONTKNOW;
 646     return nDelta;
 647 }
 648
 649 // -----------------------------------------------------------------------
 650
 651 void Slider::MouseButtonDown( const MouseEvent& rMEvt )
 652 {
 653     if ( rMEvt.IsLeft() )
 654     {
 655         const Point&    rMousePos = rMEvt.GetPosPixel();
 656         USHORT                  nTrackFlags = 0;
 657
 658         if ( maThumbRect.IsInside( rMousePos ) )
 659         {
 660             nTrackFlags         = 0;
 661             meScrollType        = SCROLL_DRAG;
 662             mnDragDraw          = SLIDER_DRAW_THUMB;
 663
 664             // Zusaetzliche Daten berechnen
 665             Point aCenterPos = maThumbRect.Center();
 666             if ( GetStyle() & WB_HORZ )
 667                 mnMouseOff = rMousePos.X()-aCenterPos.X();
 668             else
 669                 mnMouseOff = rMousePos.Y()-aCenterPos.Y();
 670
 671             // Im OS2-Look geben wir den Thumb gedrueckt aus
 672             if ( GetSettings().GetStyleSettings().GetOptions() & STYLE_OPTION_OS2STYLE )
 673             {
 674                 mnStateFlags |= SLIDER_STATE_THUMB_DOWN;
 675                 ImplDraw( SLIDER_DRAW_THUMB );
 676             }
 677         }
 678         else if ( ImplIsPageUp( rMousePos ) )
 679         {
 680             if( GetStyle() & WB_SLIDERSET )
 681                 meScrollType = SCROLL_SET;
 682             else
 683             {
 684                 nTrackFlags = STARTTRACK_BUTTONREPEAT;
 685                 meScrollType = SCROLL_PAGEUP;
 686             }
 687
 688             mnDragDraw = SLIDER_DRAW_CHANNEL;
 689         }
 690         else if ( ImplIsPageDown( rMousePos ) )
 691         {
 692             if( GetStyle() & WB_SLIDERSET )
 693                 meScrollType = SCROLL_SET;
 694             else
 695             {
 696                 nTrackFlags = STARTTRACK_BUTTONREPEAT;
 697                 meScrollType = SCROLL_PAGEDOWN;
 698             }
 699
 700             mnDragDraw = SLIDER_DRAW_CHANNEL;
 701         }
 702
 703         // Soll Tracking gestartet werden
 704         if( meScrollType != SCROLL_DONTKNOW )
 705         {
 706             // Startposition merken fuer Abbruch und EndScroll-Delta
 707             mnStartPos = mnThumbPos;
 708             ImplDoMouseAction( rMousePos, meScrollType != SCROLL_SET );
 709             Update();
 710
 711             if( meScrollType != SCROLL_SET )
 712                 StartTracking( nTrackFlags );
 713         }
 714     }
 715 }
 716
 717 // -----------------------------------------------------------------------
 718
 719 void Slider::MouseButtonUp( const MouseEvent& )
 720 {
 721     if( SCROLL_SET == meScrollType )
 722     {
 723         // Button und PageRect-Status wieder herstellen
 724         const USHORT nOldStateFlags = mnStateFlags;
 725
 726         mnStateFlags &= ~( SLIDER_STATE_CHANNEL1_DOWN | SLIDER_STATE_CHANNEL2_DOWN | SLIDER_STATE_THUMB_DOWN );
 727
 728         if ( nOldStateFlags != mnStateFlags )
 729             ImplDraw( mnDragDraw );
 730
 731         mnDragDraw = 0;
 732         ImplDoAction( TRUE );
 733         meScrollType = SCROLL_DONTKNOW;
 734     }
 735 }
 736
 737 // -----------------------------------------------------------------------
 738
 739 void Slider::Tracking( const TrackingEvent& rTEvt )
 740 {
 741     if ( rTEvt.IsTrackingEnded() )
 742     {
 743         // Button und PageRect-Status wieder herstellen
 744         USHORT nOldStateFlags = mnStateFlags;
 745         mnStateFlags &= ~(SLIDER_STATE_CHANNEL1_DOWN | SLIDER_STATE_CHANNEL2_DOWN |
 746                           SLIDER_STATE_THUMB_DOWN);
 747         if ( nOldStateFlags != mnStateFlags )
 748             ImplDraw( mnDragDraw );
 749         mnDragDraw = 0;
 750
 751         // Bei Abbruch, die alte ThumbPosition wieder herstellen
 752         if ( rTEvt.IsTrackingCanceled() )
 753         {
 754             long nOldPos = mnThumbPos;
 755             SetThumbPos( mnStartPos );
 756             mnDelta = mnThumbPos-nOldPos;
 757             Slide();
 758         }
 759
 760         if ( meScrollType == SCROLL_DRAG )
 761         {
 762             // Wenn gedragt wurde, berechnen wir den Thumb neu, damit
 763             // er wieder auf einer gerundeten ThumbPosition steht
 764             ImplCalc();
 765             Update();
 766
 767             if ( !mbFullDrag && (mnStartPos != mnThumbPos) )
 768             {
 769                 mnDelta = mnThumbPos-mnStartPos;
 770                 Slide();
 771                 mnDelta = 0;
 772             }
 773         }
 774
 775         mnDelta = mnThumbPos-mnStartPos;
 776         EndSlide();
 777         mnDelta = 0;
 778         meScrollType = SCROLL_DONTKNOW;
 779     }
 780     else
 781     {
 782         const Point rMousePos = rTEvt.GetMouseEvent().GetPosPixel();
 783
 784         // Dragging wird speziell behandelt
 785         if ( meScrollType == SCROLL_DRAG )
 786         {
 787             long nMovePix;
 788             Point aCenterPos = maThumbRect.Center();
 789             if ( GetStyle() & WB_HORZ )
 790                 nMovePix = rMousePos.X()-(aCenterPos.X()+mnMouseOff);
 791             else
 792                 nMovePix = rMousePos.Y()-(aCenterPos.Y()+mnMouseOff);
 793             // Nur wenn sich Maus in die Scrollrichtung bewegt, muessen
 794             // wir etwas tun
 795             if ( nMovePix )
 796             {
 797                 mnThumbPixPos += nMovePix;
 798                 if ( mnThumbPixPos < mnThumbPixOffset )
 799                     mnThumbPixPos = mnThumbPixOffset;
 800                 if ( mnThumbPixPos > (mnThumbPixOffset+mnThumbPixRange-1) )
 801                     mnThumbPixPos = mnThumbPixOffset+mnThumbPixRange-1;
 802                 long nOldPos = mnThumbPos;
 803                 mnThumbPos = ImplCalcThumbPos( mnThumbPixPos );
 804                 if ( nOldPos != mnThumbPos )
 805                 {
 806                     ImplUpdateRects();
 807                     Update();
 808                     if ( mbFullDrag && (nOldPos != mnThumbPos) )
 809                     {
 810                         mnDelta = mnThumbPos-nOldPos;
 811                         Slide();
 812                         mnDelta = 0;
 813                     }
 814                 }
 815             }
 816         }
 817         else
 818             ImplDoMouseAction( rMousePos, rTEvt.IsTrackingRepeat() );
 819
 820         // Wenn Slider-Werte so umgesetzt wurden, das es nichts
 821         // mehr zum Tracking gibt, dann berechen wir hier ab
 822         if ( !IsVisible() )
 823             EndTracking();
 824     }
 825 }
 826
 827 // -----------------------------------------------------------------------
 828
 829 void Slider::KeyInput( const KeyEvent& rKEvt )
 830 {
 831     if ( !rKEvt.GetKeyCode().GetModifier() )
 832     {
 833         switch ( rKEvt.GetKeyCode().GetCode() )
 834         {
 835             case KEY_HOME:
 836                 ImplDoSlide( GetRangeMin() );
 837                 break;
 838             case KEY_END:
 839                 ImplDoSlide( GetRangeMax() );
 840                 break;
 841
 842             case KEY_LEFT:
 843             case KEY_UP:
 844                 ImplDoSlideAction( SCROLL_LINEUP );
 845                 break;
 846
 847             case KEY_RIGHT:
 848             case KEY_DOWN:
 849                 ImplDoSlideAction( SCROLL_LINEDOWN );
 850                 break;
 851
 852             case KEY_PAGEUP:
 853                 ImplDoSlideAction( SCROLL_PAGEUP );
 854                 break;
 855
 856             case KEY_PAGEDOWN:
 857                 ImplDoSlideAction( SCROLL_PAGEDOWN );
 858                 break;
 859
 860             default:
 861                 Control::KeyInput( rKEvt );
 862                 break;
 863         }
 864     }
 865     else
 866         Control::KeyInput( rKEvt );
 867 }
 868
 869 // -----------------------------------------------------------------------
 870
 871 void Slider::Paint( const Rectangle& )
 872 {
 873     ImplDraw( SLIDER_DRAW_ALL );
 874 }
 875
 876 // -----------------------------------------------------------------------
 877
 878 void Slider::Resize()
 879 {
 880     Control::Resize();
 881     mbCalcSize = TRUE;
 882     if ( IsReallyVisible() )
 883         ImplCalc( FALSE );
 884     Invalidate();
 885 }
 886
 887 // -----------------------------------------------------------------------
 888
 889 void Slider::RequestHelp( const HelpEvent& rHEvt )
 890 {
 891     Control::RequestHelp( rHEvt );
 892 }
 893
 894 // -----------------------------------------------------------------------
 895
 896 void Slider::StateChanged( StateChangedType nType )
 897 {
 898     Control::StateChanged( nType );
 899
 900     if ( nType == STATE_CHANGE_INITSHOW )
 901         ImplCalc( FALSE );
 902     else if ( nType == STATE_CHANGE_DATA )
 903     {
 904         if ( IsReallyVisible() && IsUpdateMode() )
 905             ImplCalc( TRUE );
 906     }
 907     else if ( nType == STATE_CHANGE_UPDATEMODE )
 908     {
 909         if ( IsReallyVisible() && IsUpdateMode() )
 910         {
 911             ImplCalc( FALSE );
 912             Invalidate();
 913         }
 914     }
 915     else if ( nType == STATE_CHANGE_ENABLE )
 916     {
 917         if ( IsReallyVisible() && IsUpdateMode() )
 918             Invalidate();
 919     }
 920     else if ( nType == STATE_CHANGE_STYLE )
 921     {
 922         if ( IsReallyVisible() && IsUpdateMode() )
 923         {
 924             if ( (GetPrevStyle() & SLIDER_VIEW_STYLE) !=
 925                  (GetStyle() & SLIDER_VIEW_STYLE) )
 926             {
 927                 mbCalcSize = TRUE;
 928                 ImplCalc( FALSE );
 929                 Invalidate();
 930             }
 931         }
 932     }
 933     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 934     {
 935         ImplInitSettings();
 936         Invalidate();
 937     }
 938 }
 939
 940 // -----------------------------------------------------------------------
 941
 942 void Slider::DataChanged( const DataChangedEvent& rDCEvt )
 943 {
 944     Control::DataChanged( rDCEvt );
 945
 946     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 947          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 948     {
 949         ImplInitSettings();
 950         Invalidate();
 951     }
 952 }
 953
 954 // -----------------------------------------------------------------------
 955
 956 void Slider::Slide()
 957 {
 958     maSlideHdl.Call( this );
 959 }
 960
 961 // -----------------------------------------------------------------------
 962
 963 void Slider::EndSlide()
 964 {
 965     maEndSlideHdl.Call( this );
 966 }
 967
 968 // -----------------------------------------------------------------------
 969
 970 void Slider::SetRangeMin( long nNewRange )
 971 {
 972     SetRange( Range( nNewRange, GetRangeMax() ) );
 973 }
 974
 975 // -----------------------------------------------------------------------
 976
 977 void Slider::SetRangeMax( long nNewRange )
 978 {
 979     SetRange( Range( GetRangeMin(), nNewRange ) );
 980 }
 981
 982 // -----------------------------------------------------------------------
 983
 984 void Slider::SetRange( const Range& rRange )
 985 {
 986     // Range einpassen
 987     Range aRange = rRange;
 988     aRange.Justify();
 989     long nNewMinRange = aRange.Min();
 990     long nNewMaxRange = aRange.Max();
 991
 992     // Wenn Range sich unterscheidet, dann neuen setzen
 993     if ( (mnMinRange != nNewMinRange) ||
 994          (mnMaxRange != nNewMaxRange) )
 995     {
 996         mnMinRange = nNewMinRange;
 997         mnMaxRange = nNewMaxRange;
 998
 999         // Thumb einpassen
1000         if ( mnThumbPos > mnMaxRange )
1001             mnThumbPos = mnMaxRange;
1002         if ( mnThumbPos < mnMinRange )
1003             mnThumbPos = mnMinRange;
1004
1005         StateChanged( STATE_CHANGE_DATA );
1006     }
1007 }
1008
1009 // -----------------------------------------------------------------------
1010
1011 void Slider::SetThumbPos( long nNewThumbPos )
1012 {
1013     if ( nNewThumbPos < mnMinRange )
1014         nNewThumbPos = mnMinRange;
1015     if ( nNewThumbPos > mnMaxRange )
1016         nNewThumbPos = mnMaxRange;
1017
1018     if ( mnThumbPos != nNewThumbPos )
1019     {
1020         mnThumbPos = nNewThumbPos;
1021         StateChanged( STATE_CHANGE_DATA );
1022     }
1023 }
1024
1025 // -----------------------------------------------------------------------
1026
1027 Size Slider::CalcWindowSizePixel()
1028 {
1029     long nWidth = mnMaxRange-mnMinRange+(SLIDER_THUMB_HALFSIZE*2)+1;
1030     long nHeight = SLIDER_HEIGHT;
1031     Size aSize;
1032     if ( GetStyle() & WB_HORZ )
1033     {
1034         aSize.Width()   = nWidth;
1035         aSize.Height()  = nHeight;
1036     }
1037     else
1038     {
1039         aSize.Height()  = nWidth;
1040         aSize.Width()   = nHeight;
1041     }
1042     return aSize;
1043 }