vcl/source/control/spinbtn.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <tools/rcid.h>
  21 #include <vcl/event.hxx>
  22 #include <vcl/spin.hxx>
  23 #include <vcl/settings.hxx>
  24
  25 #include "spin.hxx"
  26
  27 void SpinButton::ImplInit( vcl::Window* pParent, WinBits nStyle )
  28 {
  29     mbUpperIn     = false;
  30     mbLowerIn     = false;
  31     mbInitialUp   = false;
  32     mbInitialDown = false;
  33
  34     mnMinRange  = 0;
  35     mnMaxRange  = 100;
  36     mnValue     = 0;
  37     mnValueStep = 1;
  38
  39     maRepeatTimer.SetTimeout(GetSettings().GetMouseSettings().GetButtonStartRepeat());
  40     maRepeatTimer.SetTimeoutHdl(LINK(this, SpinButton, ImplTimeout));
  41
  42     mbRepeat = 0 != (nStyle & WB_REPEAT);
  43
  44     if (nStyle & WB_HSCROLL)
  45         mbHorz = true;
  46     else
  47         mbHorz = false;
  48
  49     Control::ImplInit( pParent, nStyle, nullptr );
  50 }
  51
  52 SpinButton::SpinButton( vcl::Window* pParent, WinBits nStyle )
  53     : Control(WINDOW_SPINBUTTON)
  54     , mbUpperIsFocused(false)
  55 {
  56     ImplInit(pParent, nStyle);
  57 }
  58
  59 IMPL_LINK(SpinButton, ImplTimeout, Timer*, pTimer, void)
  60 {
  61     if (pTimer->GetTimeout() == GetSettings().GetMouseSettings().GetButtonStartRepeat())
  62     {
  63         pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() );
  64         pTimer->Start();
  65     }
  66     else
  67     {
  68         if (mbInitialUp)
  69             Up();
  70         else
  71             Down();
  72     }
  73 }
  74
  75 void SpinButton::Up()
  76 {
  77     if (ImplIsUpperEnabled())
  78     {
  79         mnValue += mnValueStep;
  80         CompatStateChanged(StateChangedType::Data);
  81
  82         ImplMoveFocus(true);
  83     }
  84
  85     ImplCallEventListenersAndHandler(VCLEVENT_SPINBUTTON_UP, nullptr );
  86 }
  87
  88 void SpinButton::Down()
  89 {
  90     if (ImplIsLowerEnabled())
  91     {
  92         mnValue -= mnValueStep;
  93         CompatStateChanged(StateChangedType::Data);
  94
  95         ImplMoveFocus(false);
  96     }
  97
  98     ImplCallEventListenersAndHandler(VCLEVENT_SPINBUTTON_DOWN, nullptr );
  99 }
 100
 101 void SpinButton::Resize()
 102 {
 103     Control::Resize();
 104
 105     Size aSize(GetOutputSizePixel());
 106     Point aTmpPoint;
 107     Rectangle aRect(aTmpPoint, aSize);
 108     if (mbHorz)
 109     {
 110         maLowerRect = Rectangle(0, 0, aSize.Width() / 2, aSize.Height() - 1);
 111         maUpperRect = Rectangle(maLowerRect.TopRight(), aRect.BottomRight());
 112     }
 113     else
 114     {
 115         maUpperRect = Rectangle(0, 0, aSize.Width() - 1, aSize.Height() / 2);
 116         maLowerRect = Rectangle(maUpperRect.BottomLeft(), aRect.BottomRight());
 117     }
 118
 119     ImplCalcFocusRect(ImplIsUpperEnabled() || !ImplIsLowerEnabled());
 120
 121     Invalidate();
 122 }
 123
 124 void SpinButton::Draw(OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags nFlags)
 125 {
 126     Point aPos  = pDev->LogicToPixel(rPos);
 127     Size aSize = pDev->LogicToPixel(rSize);
 128
 129     pDev->Push();
 130     pDev->SetMapMode();
 131     if ( !(nFlags & DrawFlags::Mono) )
 132     {
 133         // DecoView uses the FaceColor...
 134         AllSettings aSettings = pDev->GetSettings();
 135         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
 136         if ( IsControlBackground() )
 137             aStyleSettings.SetFaceColor( GetControlBackground() );
 138         else
 139             aStyleSettings.SetFaceColor( GetSettings().GetStyleSettings().GetFaceColor() );
 140
 141         aSettings.SetStyleSettings( aStyleSettings );
 142         pDev->SetSettings( aSettings );
 143     }
 144
 145     Rectangle   aRect( Point( 0, 0 ), aSize );
 146     Rectangle aLowerRect, aUpperRect;
 147     if ( mbHorz )
 148     {
 149         aLowerRect = Rectangle( 0, 0, aSize.Width()/2, aSize.Height()-1 );
 150         aUpperRect = Rectangle( aLowerRect.TopRight(), aRect.BottomRight() );
 151     }
 152     else
 153     {
 154         aUpperRect = Rectangle( 0, 0, aSize.Width()-1, aSize.Height()/2 );
 155         aLowerRect = Rectangle( aUpperRect.BottomLeft(), aRect.BottomRight() );
 156     }
 157
 158     aUpperRect += aPos;
 159     aLowerRect += aPos;
 160
 161     ImplDrawSpinButton(*pDev, this, aUpperRect, aLowerRect, false, false,
 162                        IsEnabled() && ImplIsUpperEnabled(),
 163                        IsEnabled() && ImplIsLowerEnabled(), mbHorz, true);
 164     pDev->Pop();
 165 }
 166
 167 void SpinButton::Paint(vcl::RenderContext& rRenderContext, const Rectangle& /*rRect*/)
 168 {
 169     HideFocus();
 170
 171     bool bEnable = IsEnabled();
 172     ImplDrawSpinButton(rRenderContext, this, maUpperRect, maLowerRect, mbUpperIn, mbLowerIn,
 173                        bEnable && ImplIsUpperEnabled(),
 174                        bEnable && ImplIsLowerEnabled(), mbHorz, true);
 175
 176     if (HasFocus())
 177         ShowFocus(maFocusRect);
 178 }
 179
 180 void SpinButton::MouseButtonDown( const MouseEvent& rMEvt )
 181 {
 182     if ( maUpperRect.IsInside( rMEvt.GetPosPixel() ) && ( ImplIsUpperEnabled() ) )
 183     {
 184         mbUpperIn   = true;
 185         mbInitialUp = true;
 186         Invalidate( maUpperRect );
 187     }
 188     else if ( maLowerRect.IsInside( rMEvt.GetPosPixel() ) && ( ImplIsLowerEnabled() ) )
 189     {
 190         mbLowerIn     = true;
 191         mbInitialDown = true;
 192         Invalidate( maLowerRect );
 193     }
 194
 195     if ( mbUpperIn || mbLowerIn )
 196     {
 197         Update();
 198         CaptureMouse();
 199         if ( mbRepeat )
 200             maRepeatTimer.Start();
 201     }
 202 }
 203
 204 void SpinButton::MouseButtonUp( const MouseEvent& )
 205 {
 206     ReleaseMouse();
 207     if ( mbRepeat )
 208     {
 209         maRepeatTimer.Stop();
 210         maRepeatTimer.SetTimeout(GetSettings().GetMouseSettings().GetButtonStartRepeat() );
 211     }
 212
 213     if ( mbUpperIn )
 214     {
 215         mbUpperIn   = false;
 216         Invalidate( maUpperRect );
 217         Update();
 218         Up();
 219     }
 220     else if ( mbLowerIn )
 221     {
 222         mbLowerIn = false;
 223         Invalidate( maLowerRect );
 224         Update();
 225         Down();
 226     }
 227
 228     mbInitialUp = mbInitialDown = false;
 229 }
 230
 231 void SpinButton::MouseMove( const MouseEvent& rMEvt )
 232 {
 233     if ( !rMEvt.IsLeft() || (!mbInitialUp && !mbInitialDown) )
 234         return;
 235
 236     if ( !maUpperRect.IsInside( rMEvt.GetPosPixel() ) &&
 237          mbUpperIn && mbInitialUp )
 238     {
 239         mbUpperIn = false;
 240         maRepeatTimer.Stop();
 241         Invalidate( maUpperRect );
 242         Update();
 243     }
 244     else if ( !maLowerRect.IsInside( rMEvt.GetPosPixel() ) &&
 245               mbLowerIn && mbInitialDown )
 246     {
 247         mbLowerIn = false;
 248         maRepeatTimer.Stop();
 249         Invalidate( maLowerRect );
 250         Update();
 251     }
 252     else if ( maUpperRect.IsInside( rMEvt.GetPosPixel() ) &&
 253               !mbUpperIn && mbInitialUp )
 254     {
 255         mbUpperIn = true;
 256         if ( mbRepeat )
 257             maRepeatTimer.Start();
 258         Invalidate( maUpperRect );
 259         Update();
 260     }
 261     else if ( maLowerRect.IsInside( rMEvt.GetPosPixel() ) &&
 262               !mbLowerIn && mbInitialDown )
 263     {
 264         mbLowerIn = true;
 265         if ( mbRepeat )
 266             maRepeatTimer.Start();
 267         Invalidate( maLowerRect );
 268         Update();
 269     }
 270 }
 271
 272 void SpinButton::KeyInput( const KeyEvent& rKEvt )
 273 {
 274     if ( !rKEvt.GetKeyCode().GetModifier() )
 275     {
 276         switch ( rKEvt.GetKeyCode().GetCode() )
 277         {
 278         case KEY_LEFT:
 279         case KEY_RIGHT:
 280         {
 281             bool bUp = KEY_RIGHT == rKEvt.GetKeyCode().GetCode();
 282             if ( mbHorz && !ImplMoveFocus( bUp ) )
 283                 bUp ? Up() : Down();
 284         }
 285         break;
 286
 287         case KEY_UP:
 288         case KEY_DOWN:
 289         {
 290             bool bUp = KEY_UP == rKEvt.GetKeyCode().GetCode();
 291             if ( !mbHorz && !ImplMoveFocus( KEY_UP == rKEvt.GetKeyCode().GetCode() ) )
 292                 bUp ? Up() : Down();
 293         }
 294         break;
 295
 296         case KEY_SPACE:
 297             mbUpperIsFocused ? Up() : Down();
 298             break;
 299
 300         default:
 301             Control::KeyInput( rKEvt );
 302             break;
 303         }
 304     }
 305     else
 306         Control::KeyInput( rKEvt );
 307 }
 308
 309 void SpinButton::StateChanged( StateChangedType nType )
 310 {
 311     switch ( nType )
 312     {
 313     case StateChangedType::Data:
 314     case StateChangedType::Enable:
 315         Invalidate();
 316         break;
 317
 318     case StateChangedType::Style:
 319     {
 320         bool bNewRepeat = 0 != ( GetStyle() & WB_REPEAT );
 321         if ( bNewRepeat != mbRepeat )
 322         {
 323             if ( maRepeatTimer.IsActive() )
 324             {
 325                 maRepeatTimer.Stop();
 326                 maRepeatTimer.SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() );
 327             }
 328             mbRepeat = bNewRepeat;
 329         }
 330
 331         bool bNewHorz = 0 != ( GetStyle() & WB_HSCROLL );
 332         if ( bNewHorz != mbHorz )
 333         {
 334             mbHorz = bNewHorz;
 335             Resize();
 336         }
 337     }
 338     break;
 339     default:;
 340     }
 341
 342     Control::StateChanged( nType );
 343 }
 344
 345 void SpinButton::SetRangeMin( long nNewRange )
 346 {
 347     SetRange( Range( nNewRange, GetRangeMax() ) );
 348 }
 349
 350 void SpinButton::SetRangeMax( long nNewRange )
 351 {
 352     SetRange( Range( GetRangeMin(), nNewRange ) );
 353 }
 354
 355 void SpinButton::SetRange( const Range& rRange )
 356 {
 357     // adjust rage
 358     Range aRange = rRange;
 359     aRange.Justify();
 360     long nNewMinRange = aRange.Min();
 361     long nNewMaxRange = aRange.Max();
 362
 363     // do something only if old and new range differ
 364     if ( (mnMinRange != nNewMinRange) ||
 365          (mnMaxRange != nNewMaxRange) )
 366     {
 367         mnMinRange = nNewMinRange;
 368         mnMaxRange = nNewMaxRange;
 369
 370         // adjust value to new range, if necessary
 371         if ( mnValue > mnMaxRange )
 372             mnValue = mnMaxRange;
 373         if ( mnValue < mnMinRange )
 374             mnValue = mnMinRange;
 375
 376         CompatStateChanged( StateChangedType::Data );
 377     }
 378 }
 379
 380 void SpinButton::SetValue( long nValue )
 381 {
 382     // adjust, if necessary
 383     if ( nValue > mnMaxRange )
 384         nValue = mnMaxRange;
 385     if ( nValue < mnMinRange )
 386         nValue = mnMinRange;
 387
 388     if ( mnValue != nValue )
 389     {
 390         mnValue = nValue;
 391         CompatStateChanged( StateChangedType::Data );
 392     }
 393 }
 394
 395 void SpinButton::GetFocus()
 396 {
 397     ShowFocus( maFocusRect );
 398     Control::GetFocus();
 399 }
 400
 401 void SpinButton::LoseFocus()
 402 {
 403     HideFocus();
 404     Control::LoseFocus();
 405 }
 406
 407 bool SpinButton::ImplMoveFocus( bool _bUpper )
 408 {
 409     if ( _bUpper == mbUpperIsFocused )
 410         return false;
 411
 412     HideFocus();
 413     ImplCalcFocusRect( _bUpper );
 414     if ( HasFocus() )
 415         ShowFocus( maFocusRect );
 416     return true;
 417 }
 418
 419 void SpinButton::ImplCalcFocusRect( bool _bUpper )
 420 {
 421     maFocusRect = _bUpper ? maUpperRect : maLowerRect;
 422     // inflate by some pixels
 423     maFocusRect.Left() += 2;
 424     maFocusRect.Top() += 2;
 425     maFocusRect.Right() -= 2;
 426     maFocusRect.Bottom() -= 2;
 427     mbUpperIsFocused = _bUpper;
 428 }
 429
 430 Rectangle* SpinButton::ImplFindPartRect( const Point& rPt )
 431 {
 432     if( maUpperRect.IsInside( rPt ) )
 433         return &maUpperRect;
 434     else if( maLowerRect.IsInside( rPt ) )
 435         return &maLowerRect;
 436     else
 437         return nullptr;
 438 }
 439
 440 bool SpinButton::PreNotify( NotifyEvent& rNEvt )
 441 {
 442     const MouseEvent* pMouseEvt = nullptr;
 443
 444     if ((rNEvt.GetType() == MouseNotifyEvent::MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != nullptr)
 445     {
 446         if (!pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged())
 447         {
 448             // trigger redraw if mouse over state has changed
 449             if (IsNativeControlSupported(ControlType::Spinbox, ControlPart::Entire) ||
 450                 IsNativeControlSupported(ControlType::Spinbox, ControlPart::AllButtons) )
 451             {
 452                 Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
 453                 Rectangle* pLastRect = ImplFindPartRect( GetLastPointerPosPixel() );
 454                 if (pRect != pLastRect || (pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow()))
 455                 {
 456                     vcl::Region aRgn(GetActiveClipRegion());
 457                     if (pLastRect)
 458                     {
 459                         SetClipRegion(vcl::Region(*pLastRect));
 460                         Invalidate(*pLastRect);
 461                         SetClipRegion( aRgn );
 462                     }
 463                     if (pRect)
 464                     {
 465                         SetClipRegion(vcl::Region(*pRect));
 466                         Invalidate(*pRect);
 467                         SetClipRegion(aRgn);
 468                     }
 469                 }
 470             }
 471         }
 472     }
 473
 474     return Control::PreNotify(rNEvt);
 475 }
 476
 477 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */