vcl/source/control/spinbtn.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: spinbtn.cxx,v $
  10  * $Revision: 1.13 $
  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 #include <tools/rcid.h>
  34 #include <vcl/spin.h>
  35 #include <vcl/event.hxx>
  36 #include <vcl/spin.hxx>
  37
  38 // =======================================================================
  39
  40 void SpinButton::ImplInit( Window* pParent, WinBits nStyle )
  41 {
  42     mbUpperIn     = FALSE;
  43     mbLowerIn     = FALSE;
  44     mbInitialUp   = FALSE;
  45     mbInitialDown = FALSE;
  46
  47     mnMinRange  = 0;
  48     mnMaxRange  = 100;
  49     mnValue     = 0;
  50     mnValueStep = 1;
  51
  52     maRepeatTimer.SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() );
  53     maRepeatTimer.SetTimeoutHdl( LINK( this, SpinButton, ImplTimeout ) );
  54
  55     mbRepeat = 0 != ( nStyle & WB_REPEAT );
  56
  57     if ( nStyle & WB_HSCROLL )
  58         mbHorz = TRUE;
  59     else
  60         mbHorz = FALSE;
  61
  62     Control::ImplInit( pParent, nStyle, NULL );
  63 }
  64
  65 // -----------------------------------------------------------------------
  66
  67 SpinButton::SpinButton( Window* pParent, WinBits nStyle )
  68     :Control( WINDOW_SPINBUTTON )
  69     ,mbUpperIsFocused( FALSE )
  70 {
  71     ImplInit( pParent, nStyle );
  72 }
  73
  74 // -----------------------------------------------------------------------
  75
  76 SpinButton::SpinButton( Window* pParent, const ResId& rResId )
  77     :Control( WINDOW_SPINBUTTON )
  78     ,mbUpperIsFocused( FALSE )
  79 {
  80     rResId.SetRT( RSC_SPINBUTTON );
  81     ImplInit( pParent, ImplInitRes( rResId ) );
  82     ImplLoadRes( rResId );
  83     Resize();
  84 }
  85
  86 // -----------------------------------------------------------------------
  87
  88 SpinButton::~SpinButton()
  89 {
  90 }
  91
  92 // -----------------------------------------------------------------------
  93
  94 IMPL_LINK( SpinButton, ImplTimeout, Timer*, pTimer )
  95 {
  96     if ( pTimer->GetTimeout() == GetSettings().GetMouseSettings().GetButtonStartRepeat() )
  97     {
  98         pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() );
  99         pTimer->Start();
 100     }
 101     else
 102     {
 103         if ( mbInitialUp )
 104             Up();
 105         else
 106             Down();
 107     }
 108
 109     return 0;
 110 }
 111
 112 // -----------------------------------------------------------------------
 113
 114 void SpinButton::Up()
 115 {
 116     if ( ImplIsUpperEnabled() )
 117     {
 118         mnValue += mnValueStep;
 119         StateChanged( STATE_CHANGE_DATA );
 120
 121         ImplMoveFocus( TRUE );
 122     }
 123
 124     ImplCallEventListenersAndHandler( VCLEVENT_SPINBUTTON_UP, maUpHdlLink, this );
 125 }
 126
 127 // -----------------------------------------------------------------------
 128
 129 void SpinButton::Down()
 130 {
 131     if ( ImplIsLowerEnabled() )
 132     {
 133         mnValue -= mnValueStep;
 134         StateChanged( STATE_CHANGE_DATA );
 135
 136         ImplMoveFocus( FALSE );
 137     }
 138
 139     ImplCallEventListenersAndHandler( VCLEVENT_SPINBUTTON_DOWN, maDownHdlLink, this );
 140 }
 141
 142 // -----------------------------------------------------------------------
 143
 144 void SpinButton::Resize()
 145 {
 146     Control::Resize();
 147
 148     Size aSize( GetOutputSizePixel() );
 149     Point aTmpPoint;
 150     Rectangle aRect( aTmpPoint, aSize );
 151     if ( mbHorz )
 152     {
 153         maLowerRect = Rectangle( 0, 0, aSize.Width()/2, aSize.Height()-1 );
 154         maUpperRect = Rectangle( maLowerRect.TopRight(), aRect.BottomRight() );
 155     }
 156     else
 157     {
 158         maUpperRect = Rectangle( 0, 0, aSize.Width()-1, aSize.Height()/2 );
 159         maLowerRect = Rectangle( maUpperRect.BottomLeft(), aRect.BottomRight() );
 160     }
 161
 162     ImplCalcFocusRect( ImplIsUpperEnabled() || !ImplIsLowerEnabled() );
 163
 164     Invalidate();
 165 }
 166
 167 // -----------------------------------------------------------------------
 168
 169 void SpinButton::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, ULONG nFlags )
 170 {
 171     Point       aPos  = pDev->LogicToPixel( rPos );
 172     Size        aSize = pDev->LogicToPixel( rSize );
 173
 174     pDev->Push();
 175     pDev->SetMapMode();
 176     if ( !(nFlags & WINDOW_DRAW_MONO) )
 177     {
 178         // DecoView uses the FaceColor...
 179         AllSettings aSettings = pDev->GetSettings();
 180         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
 181         if ( IsControlBackground() )
 182             aStyleSettings.SetFaceColor( GetControlBackground() );
 183         else
 184             aStyleSettings.SetFaceColor( GetSettings().GetStyleSettings().GetFaceColor() );
 185
 186         aSettings.SetStyleSettings( aStyleSettings );
 187         pDev->SetSettings( aSettings );
 188     }
 189
 190     Rectangle   aRect( Point( 0, 0 ), aSize );
 191     Rectangle aLowerRect, aUpperRect;
 192     if ( mbHorz )
 193     {
 194         aLowerRect = Rectangle( 0, 0, aSize.Width()/2, aSize.Height()-1 );
 195         aUpperRect = Rectangle( aLowerRect.TopRight(), aRect.BottomRight() );
 196     }
 197     else
 198     {
 199         aUpperRect = Rectangle( 0, 0, aSize.Width()-1, aSize.Height()/2 );
 200         aLowerRect = Rectangle( aUpperRect.BottomLeft(), aRect.BottomRight() );
 201     }
 202
 203     aUpperRect += aPos;
 204     aLowerRect += aPos;
 205
 206     ImplDrawSpinButton( pDev, aUpperRect, aLowerRect, FALSE, FALSE,
 207                         IsEnabled() && ImplIsUpperEnabled(),
 208                         IsEnabled() && ImplIsLowerEnabled(), mbHorz, TRUE );
 209     pDev->Pop();
 210 }
 211
 212
 213 void SpinButton::Paint( const Rectangle& )
 214 {
 215     HideFocus();
 216
 217     BOOL bEnable = IsEnabled();
 218     ImplDrawSpinButton( this, maUpperRect, maLowerRect, mbUpperIn, mbLowerIn,
 219                         bEnable && ImplIsUpperEnabled(),
 220                         bEnable && ImplIsLowerEnabled(), mbHorz, TRUE );
 221
 222     if ( HasFocus() )
 223         ShowFocus( maFocusRect );
 224 }
 225
 226 // -----------------------------------------------------------------------
 227
 228 void SpinButton::MouseButtonDown( const MouseEvent& rMEvt )
 229 {
 230     if ( maUpperRect.IsInside( rMEvt.GetPosPixel() ) && ( ImplIsUpperEnabled() ) )
 231     {
 232         mbUpperIn   = TRUE;
 233         mbInitialUp = TRUE;
 234         Invalidate( maUpperRect );
 235     }
 236     else if ( maLowerRect.IsInside( rMEvt.GetPosPixel() ) && ( ImplIsLowerEnabled() ) )
 237     {
 238         mbLowerIn     = TRUE;
 239         mbInitialDown = TRUE;
 240         Invalidate( maLowerRect );
 241     }
 242
 243     if ( mbUpperIn || mbLowerIn )
 244     {
 245         Update();
 246         CaptureMouse();
 247         if ( mbRepeat )
 248             maRepeatTimer.Start();
 249     }
 250 }
 251
 252 // -----------------------------------------------------------------------
 253
 254 void SpinButton::MouseButtonUp( const MouseEvent& )
 255 {
 256     ReleaseMouse();
 257     if ( mbRepeat )
 258     {
 259         maRepeatTimer.Stop();
 260         maRepeatTimer.SetTimeout(GetSettings().GetMouseSettings().GetButtonStartRepeat() );
 261     }
 262
 263     if ( mbUpperIn )
 264     {
 265         mbUpperIn   = FALSE;
 266         Invalidate( maUpperRect );
 267         Update();
 268         Up();
 269     }
 270     else if ( mbLowerIn )
 271     {
 272         mbLowerIn = FALSE;
 273         Invalidate( maLowerRect );
 274         Update();
 275         Down();
 276     }
 277
 278     mbInitialUp = mbInitialDown = FALSE;
 279 }
 280
 281 // -----------------------------------------------------------------------
 282
 283 void SpinButton::MouseMove( const MouseEvent& rMEvt )
 284 {
 285     if ( !rMEvt.IsLeft() || (!mbInitialUp && !mbInitialDown) )
 286         return;
 287
 288     if ( !maUpperRect.IsInside( rMEvt.GetPosPixel() ) &&
 289          mbUpperIn && mbInitialUp )
 290     {
 291         mbUpperIn = FALSE;
 292         maRepeatTimer.Stop();
 293         Invalidate( maUpperRect );
 294         Update();
 295     }
 296     else if ( !maLowerRect.IsInside( rMEvt.GetPosPixel() ) &&
 297               mbLowerIn & mbInitialDown )
 298     {
 299         mbLowerIn = FALSE;
 300         maRepeatTimer.Stop();
 301         Invalidate( maLowerRect );
 302         Update();
 303     }
 304     else if ( maUpperRect.IsInside( rMEvt.GetPosPixel() ) &&
 305               !mbUpperIn && mbInitialUp )
 306     {
 307         mbUpperIn = TRUE;
 308         if ( mbRepeat )
 309             maRepeatTimer.Start();
 310         Invalidate( maUpperRect );
 311         Update();
 312     }
 313     else if ( maLowerRect.IsInside( rMEvt.GetPosPixel() ) &&
 314               !mbLowerIn && mbInitialDown )
 315     {
 316         mbLowerIn = TRUE;
 317         if ( mbRepeat )
 318             maRepeatTimer.Start();
 319         Invalidate( maLowerRect );
 320         Update();
 321     }
 322 }
 323
 324 // -----------------------------------------------------------------------
 325
 326 void SpinButton::KeyInput( const KeyEvent& rKEvt )
 327 {
 328     KeyCode aCode = rKEvt.GetKeyCode();
 329
 330     if ( !rKEvt.GetKeyCode().GetModifier() )
 331     {
 332         switch ( rKEvt.GetKeyCode().GetCode() )
 333         {
 334         case KEY_LEFT:
 335         case KEY_RIGHT:
 336         {
 337             BOOL bUp = KEY_RIGHT == rKEvt.GetKeyCode().GetCode();
 338             if ( mbHorz && !ImplMoveFocus( bUp ) )
 339                 bUp ? Up() : Down();
 340         }
 341         break;
 342
 343         case KEY_UP:
 344         case KEY_DOWN:
 345         {
 346             BOOL bUp = KEY_UP == rKEvt.GetKeyCode().GetCode();
 347             if ( !mbHorz && !ImplMoveFocus( KEY_UP == rKEvt.GetKeyCode().GetCode() ) )
 348                 bUp ? Up() : Down();
 349         }
 350         break;
 351
 352         case KEY_SPACE:
 353             mbUpperIsFocused ? Up() : Down();
 354             break;
 355
 356         default:
 357             Control::KeyInput( rKEvt );
 358             break;
 359         }
 360     }
 361     else
 362         Control::KeyInput( rKEvt );
 363 }
 364
 365 // -----------------------------------------------------------------------
 366
 367 void SpinButton::StateChanged( StateChangedType nType )
 368 {
 369     switch ( nType )
 370     {
 371     case STATE_CHANGE_DATA:
 372     case STATE_CHANGE_ENABLE:
 373         Invalidate();
 374         break;
 375
 376     case STATE_CHANGE_STYLE:
 377     {
 378         BOOL bNewRepeat = 0 != ( GetStyle() & WB_REPEAT );
 379         if ( bNewRepeat != mbRepeat )
 380         {
 381             if ( maRepeatTimer.IsActive() )
 382             {
 383                 maRepeatTimer.Stop();
 384                 maRepeatTimer.SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() );
 385             }
 386             mbRepeat = bNewRepeat;
 387         }
 388
 389         BOOL bNewHorz = 0 != ( GetStyle() & WB_HSCROLL );
 390         if ( bNewHorz != mbHorz )
 391         {
 392             mbHorz = bNewHorz;
 393             Resize();
 394         }
 395     }
 396     break;
 397     }
 398
 399     Control::StateChanged( nType );
 400 }
 401
 402 // -----------------------------------------------------------------------
 403
 404 void SpinButton::SetRangeMin( long nNewRange )
 405 {
 406     SetRange( Range( nNewRange, GetRangeMax() ) );
 407 }
 408
 409 // -----------------------------------------------------------------------
 410
 411 void SpinButton::SetRangeMax( long nNewRange )
 412 {
 413     SetRange( Range( GetRangeMin(), nNewRange ) );
 414 }
 415
 416 // -----------------------------------------------------------------------
 417
 418 void SpinButton::SetRange( const Range& rRange )
 419 {
 420     // adjust rage
 421     Range aRange = rRange;
 422     aRange.Justify();
 423     long nNewMinRange = aRange.Min();
 424     long nNewMaxRange = aRange.Max();
 425
 426     // do something only if old and new range differ
 427     if ( (mnMinRange != nNewMinRange) ||
 428          (mnMaxRange != nNewMaxRange) )
 429     {
 430         mnMinRange = nNewMinRange;
 431         mnMaxRange = nNewMaxRange;
 432
 433         // adjust value to new range, if necessary
 434         if ( mnValue > mnMaxRange )
 435             mnValue = mnMaxRange;
 436         if ( mnValue < mnMinRange )
 437             mnValue = mnMinRange;
 438
 439         StateChanged( STATE_CHANGE_DATA );
 440     }
 441 }
 442
 443 // -----------------------------------------------------------------------
 444
 445 void SpinButton::SetValue( long nValue )
 446 {
 447     // adjust, if necessary
 448     if ( nValue > mnMaxRange )
 449         nValue = mnMaxRange;
 450     if ( nValue < mnMinRange )
 451         nValue = mnMinRange;
 452
 453     if ( mnValue != nValue )
 454     {
 455         mnValue = nValue;
 456         StateChanged( STATE_CHANGE_DATA );
 457     }
 458 }
 459
 460 // -----------------------------------------------------------------------
 461
 462 void SpinButton::GetFocus()
 463 {
 464     ShowFocus( maFocusRect );
 465     Control::GetFocus();
 466 }
 467
 468 // -----------------------------------------------------------------------
 469
 470 void SpinButton::LoseFocus()
 471 {
 472     HideFocus();
 473     Control::LoseFocus();
 474 }
 475
 476 // -----------------------------------------------------------------------
 477
 478 BOOL SpinButton::ImplMoveFocus( BOOL _bUpper )
 479 {
 480     if ( _bUpper == mbUpperIsFocused )
 481         return FALSE;
 482
 483     HideFocus();
 484     ImplCalcFocusRect( _bUpper );
 485     if ( HasFocus() )
 486         ShowFocus( maFocusRect );
 487     return TRUE;
 488 }
 489
 490 // -----------------------------------------------------------------------
 491
 492 void SpinButton::ImplCalcFocusRect( BOOL _bUpper )
 493 {
 494     maFocusRect = _bUpper ? maUpperRect : maLowerRect;
 495     // inflate by some pixels
 496     maFocusRect.Left() += 2;
 497     maFocusRect.Top() += 2;
 498     maFocusRect.Right() -= 2;
 499     maFocusRect.Bottom() -= 2;
 500     mbUpperIsFocused = _bUpper;
 501 }
 502
 503 // -----------------------------------------------------------------------
 504
 505 Rectangle* SpinButton::ImplFindPartRect( const Point& rPt )
 506 {
 507     if( maUpperRect.IsInside( rPt ) )
 508         return &maUpperRect;
 509     else if( maLowerRect.IsInside( rPt ) )
 510         return &maLowerRect;
 511     else
 512         return NULL;
 513 }
 514
 515 long SpinButton::PreNotify( NotifyEvent& rNEvt )
 516 {
 517     long nDone = 0;
 518     const MouseEvent* pMouseEvt = NULL;
 519
 520     if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
 521     {
 522         if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
 523         {
 524             // trigger redraw if mouse over state has changed
 525             if( IsNativeControlSupported(CTRL_SPINBOX, PART_ENTIRE_CONTROL) ||
 526                 IsNativeControlSupported(CTRL_SPINBOX, PART_ALL_BUTTONS) )
 527             {
 528                 Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
 529                 Rectangle* pLastRect = ImplFindPartRect( GetLastPointerPosPixel() );
 530                 if( pRect != pLastRect || (pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow()) )
 531                 {
 532                     Region aRgn( GetActiveClipRegion() );
 533                     if( pLastRect )
 534                     {
 535                         SetClipRegion( *pLastRect );
 536                         Paint( *pLastRect );
 537                         SetClipRegion( aRgn );
 538                     }
 539                     if( pRect )
 540                     {
 541                         SetClipRegion( *pRect );
 542                         Paint( *pRect );
 543                         SetClipRegion( aRgn );
 544                     }
 545                 }
 546             }
 547         }
 548     }
 549
 550     return nDone ? nDone : Control::PreNotify(rNEvt);
 551 }
 552
 553 // -----------------------------------------------------------------------