vcl/source/control/spinfld.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/rc.h"
  21
  22 #include <vcl/event.hxx>
  23 #include <vcl/decoview.hxx>
  24 #include <vcl/spinfld.hxx>
  25 #include <vcl/settings.hxx>
  26 #include <vcl/uitest/uiobject.hxx>
  27
  28 #include "controldata.hxx"
  29 #include "spin.hxx"
  30 #include "svdata.hxx"
  31
  32 namespace {
  33
  34 void ImplGetSpinbuttonValue(vcl::Window* pWin,
  35                             const Rectangle& rUpperRect, const Rectangle& rLowerRect,
  36                             bool bUpperIn, bool bLowerIn, bool bUpperEnabled, bool bLowerEnabled,
  37                             bool bHorz, SpinbuttonValue& rValue )
  38 {
  39     // convert spinbutton data to a SpinbuttonValue structure for native painting
  40
  41     rValue.maUpperRect = rUpperRect;
  42     rValue.maLowerRect = rLowerRect;
  43
  44     Point aPointerPos = pWin->GetPointerPosPixel();
  45
  46     ControlState nState = ControlState::ENABLED;
  47     if (bUpperIn)
  48         nState |= ControlState::PRESSED;
  49     if (!pWin->IsEnabled() || !bUpperEnabled)
  50         nState &= ~ControlState::ENABLED;
  51     if (pWin->HasFocus())
  52         nState |= ControlState::FOCUSED;
  53     if (pWin->IsMouseOver() && rUpperRect.IsInside(aPointerPos))
  54         nState |= ControlState::ROLLOVER;
  55     rValue.mnUpperState = nState;
  56
  57     nState = ControlState::ENABLED;
  58     if (bLowerIn)
  59         nState |= ControlState::PRESSED;
  60     if (!pWin->IsEnabled() || !bLowerEnabled)
  61         nState &= ~ControlState::ENABLED;
  62     if (pWin->HasFocus())
  63         nState |= ControlState::FOCUSED;
  64     // for overlapping spins: highlight only one
  65     if (pWin->IsMouseOver() && rLowerRect.IsInside(aPointerPos) && !rUpperRect.IsInside(aPointerPos))
  66         nState |= ControlState::ROLLOVER;
  67     rValue.mnLowerState = nState;
  68
  69     rValue.mnUpperPart = bHorz ? ControlPart::ButtonLeft : ControlPart::ButtonUp;
  70     rValue.mnLowerPart = bHorz ? ControlPart::ButtonRight : ControlPart::ButtonDown;
  71 }
  72
  73 bool ImplDrawNativeSpinfield(vcl::RenderContext& rRenderContext, vcl::Window* pWin, const SpinbuttonValue& rSpinbuttonValue)
  74 {
  75     bool bNativeOK = false;
  76
  77     if (rRenderContext.IsNativeControlSupported(ControlType::Spinbox, ControlPart::Entire) &&
  78         // there is just no useful native support for spinfields with dropdown
  79         !(pWin->GetStyle() & WB_DROPDOWN))
  80     {
  81         if (rRenderContext.IsNativeControlSupported(ControlType::Spinbox, rSpinbuttonValue.mnUpperPart) &&
  82             rRenderContext.IsNativeControlSupported(ControlType::Spinbox, rSpinbuttonValue.mnLowerPart))
  83         {
  84             // only paint the embedded spin buttons, all buttons are painted at once
  85             Rectangle aUpperAndLowerButtons( rSpinbuttonValue.maUpperRect.GetUnion( rSpinbuttonValue.maLowerRect ) );
  86             bNativeOK = rRenderContext.DrawNativeControl(ControlType::Spinbox, ControlPart::AllButtons, aUpperAndLowerButtons,
  87                                                          ControlState::ENABLED, rSpinbuttonValue, OUString());
  88         }
  89         else
  90         {
  91             // paint the spinbox as a whole, use borderwindow to have proper clipping
  92             vcl::Window* pBorder = pWin->GetWindow(GetWindowType::Border);
  93
  94             // to not overwrite everything, set the button region as clipregion to the border window
  95             Rectangle aClipRect(rSpinbuttonValue.maLowerRect);
  96             aClipRect.Union(rSpinbuttonValue.maUpperRect);
  97
  98             vcl::RenderContext* pContext = &rRenderContext;
  99             vcl::Region oldRgn;
 100             Point aPt;
 101             Size aSize(pBorder->GetOutputSizePixel());    // the size of the border window, i.e., the whole control
 102             Rectangle aNatRgn(aPt, aSize);
 103
 104             if (!pWin->SupportsDoubleBuffering())
 105             {
 106                 // convert from screen space to borderwin space
 107                 aClipRect.SetPos(pBorder->ScreenToOutputPixel(pWin->OutputToScreenPixel(aClipRect.TopLeft())));
 108
 109                 oldRgn = pBorder->GetClipRegion();
 110                 pBorder->SetClipRegion(vcl::Region(aClipRect));
 111
 112                 pContext = pBorder;
 113             }
 114
 115             Rectangle aBound, aContent;
 116             if (!ImplGetSVData()->maNWFData.mbCanDrawWidgetAnySize &&
 117                 pContext->GetNativeControlRegion(ControlType::Spinbox, ControlPart::Entire,
 118                                                 aNatRgn, ControlState::NONE, rSpinbuttonValue,
 119                                                 OUString(), aBound, aContent))
 120             {
 121                 aSize = aContent.GetSize();
 122             }
 123
 124             Rectangle aRgn(aPt, aSize);
 125             if (pWin->SupportsDoubleBuffering())
 126             {
 127                 // convert from borderwin space, to the pWin's space
 128                 aRgn.SetPos(pWin->ScreenToOutputPixel(pBorder->OutputToScreenPixel(aRgn.TopLeft())));
 129             }
 130
 131             bNativeOK = pContext->DrawNativeControl(ControlType::Spinbox, ControlPart::Entire, aRgn,
 132                                                    ControlState::ENABLED, rSpinbuttonValue, OUString());
 133
 134             if (!pWin->SupportsDoubleBuffering())
 135                 pBorder->SetClipRegion(vcl::Region(oldRgn));
 136         }
 137     }
 138     return bNativeOK;
 139 }
 140
 141 bool ImplDrawNativeSpinbuttons(vcl::RenderContext& rRenderContext, const SpinbuttonValue& rSpinbuttonValue)
 142 {
 143     bool bNativeOK = false;
 144
 145     if (rRenderContext.IsNativeControlSupported(ControlType::SpinButtons, ControlPart::Entire))
 146     {
 147         Rectangle aArea = rSpinbuttonValue.maUpperRect.GetUnion(rSpinbuttonValue.maLowerRect);
 148         // only paint the standalone spin buttons, all buttons are painted at once
 149         bNativeOK = rRenderContext.DrawNativeControl(ControlType::SpinButtons, ControlPart::AllButtons, aArea,
 150                                                      ControlState::ENABLED, rSpinbuttonValue, OUString());
 151     }
 152     return bNativeOK;
 153 }
 154
 155 }
 156
 157 void ImplDrawSpinButton(vcl::RenderContext& rRenderContext, vcl::Window* pWindow,
 158                         const Rectangle& rUpperRect, const Rectangle& rLowerRect,
 159                         bool bUpperIn, bool bLowerIn, bool bUpperEnabled, bool bLowerEnabled,
 160                         bool bHorz, bool bMirrorHorz)
 161 {
 162     bool bNativeOK = false;
 163
 164     if (pWindow)
 165     {
 166         // are we drawing standalone spin buttons or members of a spinfield ?
 167         ControlType aControl = ControlType::SpinButtons;
 168         switch (pWindow->GetType())
 169         {
 170             case WINDOW_EDIT:
 171             case WINDOW_MULTILINEEDIT:
 172             case WINDOW_PATTERNFIELD:
 173             case WINDOW_METRICFIELD:
 174             case WINDOW_CURRENCYFIELD:
 175             case WINDOW_DATEFIELD:
 176             case WINDOW_TIMEFIELD:
 177             case WINDOW_LONGCURRENCYFIELD:
 178             case WINDOW_NUMERICFIELD:
 179             case WINDOW_SPINFIELD:
 180                 aControl = ControlType::Spinbox;
 181                 break;
 182             default:
 183                 aControl = ControlType::SpinButtons;
 184                 break;
 185         }
 186
 187         SpinbuttonValue aValue;
 188         ImplGetSpinbuttonValue(pWindow, rUpperRect, rLowerRect,
 189                                bUpperIn, bLowerIn, bUpperEnabled, bLowerEnabled,
 190                                bHorz, aValue);
 191
 192         if( aControl == ControlType::Spinbox )
 193             bNativeOK = ImplDrawNativeSpinfield(rRenderContext, pWindow, aValue);
 194         else if( aControl == ControlType::SpinButtons )
 195             bNativeOK = ImplDrawNativeSpinbuttons(rRenderContext, aValue);
 196     }
 197
 198     if (bNativeOK)
 199         return;
 200
 201     ImplDrawUpDownButtons(rRenderContext,
 202                           rUpperRect, rLowerRect,
 203                           bUpperIn, bLowerIn, bUpperEnabled, bLowerEnabled,
 204                           bHorz, bMirrorHorz);
 205 }
 206
 207 void ImplDrawUpDownButtons(vcl::RenderContext& rRenderContext,
 208                            const Rectangle& rUpperRect, const Rectangle& rLowerRect,
 209                            bool bUpperIn, bool bLowerIn, bool bUpperEnabled, bool bLowerEnabled,
 210                            bool bHorz, bool bMirrorHorz)
 211 {
 212     DecorationView aDecoView(&rRenderContext);
 213
 214     SymbolType eType1, eType2;
 215
 216     if ( bHorz )
 217     {
 218         eType1 = bMirrorHorz ? SymbolType::SPIN_RIGHT : SymbolType::SPIN_LEFT;
 219         eType2 = bMirrorHorz ? SymbolType::SPIN_LEFT : SymbolType::SPIN_RIGHT;
 220     }
 221     else
 222     {
 223         eType1 = SymbolType::SPIN_UP;
 224         eType2 = SymbolType::SPIN_DOWN;
 225     }
 226
 227     DrawButtonFlags nStyle = DrawButtonFlags::NoLeftLightBorder;
 228     // draw upper/left Button
 229     if (bUpperIn)
 230         nStyle |= DrawButtonFlags::Pressed;
 231
 232     Rectangle aUpRect = aDecoView.DrawButton(rUpperRect, nStyle);
 233
 234     nStyle = DrawButtonFlags::NoLeftLightBorder;
 235     // draw lower/right Button
 236     if (bLowerIn)
 237         nStyle |= DrawButtonFlags::Pressed;
 238
 239     Rectangle aLowRect = aDecoView.DrawButton(rLowerRect, nStyle);
 240
 241      // make use of additional default edge
 242     aUpRect.Left()--;
 243     aUpRect.Top()--;
 244     aUpRect.Right()++;
 245     aUpRect.Bottom()++;
 246     aLowRect.Left()--;
 247     aLowRect.Top()--;
 248     aLowRect.Right()++;
 249     aLowRect.Bottom()++;
 250
 251     // draw into the edge, so that something is visible if the rectangle is too small
 252     if (aUpRect.GetHeight() < 4)
 253     {
 254         aUpRect.Right()++;
 255         aUpRect.Bottom()++;
 256         aLowRect.Right()++;
 257         aLowRect.Bottom()++;
 258     }
 259
 260     // calculate Symbol size
 261     long nTempSize1 = aUpRect.GetWidth();
 262     long nTempSize2 = aLowRect.GetWidth();
 263     if (std::abs( nTempSize1-nTempSize2 ) == 1)
 264     {
 265         if (nTempSize1 > nTempSize2)
 266             aUpRect.Left()++;
 267         else
 268             aLowRect.Left()++;
 269     }
 270     nTempSize1 = aUpRect.GetHeight();
 271     nTempSize2 = aLowRect.GetHeight();
 272     if (std::abs(nTempSize1 - nTempSize2) == 1)
 273     {
 274         if (nTempSize1 > nTempSize2)
 275             aUpRect.Top()++;
 276         else
 277             aLowRect.Top()++;
 278     }
 279
 280     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 281
 282     DrawSymbolFlags nSymStyle = DrawSymbolFlags::NONE;
 283     if (!bUpperEnabled)
 284         nSymStyle |= DrawSymbolFlags::Disable;
 285     aDecoView.DrawSymbol(aUpRect, eType1, rStyleSettings.GetButtonTextColor(), nSymStyle);
 286
 287     nSymStyle = DrawSymbolFlags::NONE;
 288     if (!bLowerEnabled)
 289         nSymStyle |= DrawSymbolFlags::Disable;
 290     aDecoView.DrawSymbol(aLowRect, eType2, rStyleSettings.GetButtonTextColor(), nSymStyle);
 291 }
 292
 293 void SpinField::ImplInitSpinFieldData()
 294 {
 295     mpEdit.disposeAndClear();
 296     mbSpin          = false;
 297     mbRepeat        = false;
 298     mbUpperIn       = false;
 299     mbLowerIn       = false;
 300     mbInitialUp     = false;
 301     mbInitialDown   = false;
 302     mbNoSelect      = false;
 303     mbInDropDown    = false;
 304 }
 305
 306 void SpinField::ImplInit(vcl::Window* pParent, WinBits nWinStyle)
 307 {
 308     Edit::ImplInit( pParent, nWinStyle );
 309
 310     if (nWinStyle & (WB_SPIN | WB_DROPDOWN))
 311     {
 312         mbSpin = true;
 313
 314         // Some themes want external spin buttons, therefore the main
 315         // spinfield should not overdraw the border between its encapsulated
 316         // edit field and the spin buttons
 317         if ((nWinStyle & WB_SPIN) && ImplUseNativeBorder(*this, nWinStyle))
 318         {
 319             SetBackground();
 320             mpEdit.set(VclPtr<Edit>::Create(this, WB_NOBORDER));
 321             mpEdit->SetBackground();
 322         }
 323         else
 324             mpEdit.set(VclPtr<Edit>::Create(this, WB_NOBORDER));
 325
 326         mpEdit->EnableRTL(false);
 327         mpEdit->SetPosPixel(Point());
 328         mpEdit->Show();
 329
 330         SetSubEdit(mpEdit);
 331
 332         maRepeatTimer.SetTimeoutHdl(LINK( this, SpinField, ImplTimeout));
 333         maRepeatTimer.SetTimeout(GetSettings().GetMouseSettings().GetButtonStartRepeat());
 334         if (nWinStyle & WB_REPEAT)
 335             mbRepeat = true;
 336
 337         SetCompoundControl(true);
 338     }
 339 }
 340
 341 SpinField::SpinField(vcl::Window* pParent, WinBits nWinStyle) :
 342     Edit(WINDOW_SPINFIELD)
 343 {
 344     ImplInitSpinFieldData();
 345     ImplInit(pParent, nWinStyle);
 346 }
 347
 348 SpinField::~SpinField()
 349 {
 350     disposeOnce();
 351 }
 352
 353 void SpinField::dispose()
 354 {
 355     mpEdit.disposeAndClear();
 356
 357     Edit::dispose();
 358 }
 359
 360 void SpinField::Up()
 361 {
 362     ImplCallEventListenersAndHandler( VCLEVENT_SPINFIELD_UP, [this] () { maUpHdlLink.Call(*this); } );
 363 }
 364
 365 void SpinField::Down()
 366 {
 367     ImplCallEventListenersAndHandler( VCLEVENT_SPINFIELD_DOWN, [this] () { maDownHdlLink.Call(*this); } );
 368 }
 369
 370 void SpinField::First()
 371 {
 372     ImplCallEventListenersAndHandler( VCLEVENT_SPINFIELD_FIRST, [this] () { maFirstHdlLink.Call(*this); } );
 373 }
 374
 375 void SpinField::Last()
 376 {
 377     ImplCallEventListenersAndHandler( VCLEVENT_SPINFIELD_LAST, [this] () { maLastHdlLink.Call(*this); } );
 378 }
 379
 380 void SpinField::MouseButtonDown( const MouseEvent& rMEvt )
 381 {
 382     if (!HasFocus() && (!mpEdit || !mpEdit->HasFocus()))
 383     {
 384         mbNoSelect = true;
 385         GrabFocus();
 386     }
 387
 388     if (!IsReadOnly())
 389     {
 390         if (maUpperRect.IsInside(rMEvt.GetPosPixel()))
 391         {
 392             mbUpperIn   = true;
 393             mbInitialUp = true;
 394             Invalidate(maUpperRect);
 395         }
 396         else if (maLowerRect.IsInside(rMEvt.GetPosPixel()))
 397         {
 398             mbLowerIn    = true;
 399             mbInitialDown = true;
 400             Invalidate(maLowerRect);
 401         }
 402         else if (maDropDownRect.IsInside(rMEvt.GetPosPixel()))
 403         {
 404             // put DropDownButton to the right
 405             mbInDropDown = ShowDropDown( !mbInDropDown );
 406             Invalidate(Rectangle(Point(), GetOutputSizePixel()));
 407         }
 408
 409         if (mbUpperIn || mbLowerIn)
 410         {
 411             Update();
 412             CaptureMouse();
 413             if (mbRepeat)
 414                 maRepeatTimer.Start();
 415             return;
 416         }
 417     }
 418
 419     Edit::MouseButtonDown(rMEvt);
 420 }
 421
 422 void SpinField::MouseButtonUp(const MouseEvent& rMEvt)
 423 {
 424     ReleaseMouse();
 425     mbInitialUp = mbInitialDown = false;
 426     maRepeatTimer.Stop();
 427     maRepeatTimer.SetTimeout(GetSettings().GetMouseSettings().GetButtonStartRepeat());
 428
 429     if (mbUpperIn)
 430     {
 431         mbUpperIn = false;
 432         Invalidate(maUpperRect);
 433         Update();
 434         Up();
 435     }
 436     else if (mbLowerIn)
 437     {
 438         mbLowerIn = false;
 439         Invalidate(maLowerRect);
 440         Update();
 441         Down();
 442     }
 443
 444     Edit::MouseButtonUp(rMEvt);
 445 }
 446
 447 void SpinField::MouseMove(const MouseEvent& rMEvt)
 448 {
 449     if (rMEvt.IsLeft())
 450     {
 451         if (mbInitialUp)
 452         {
 453             bool bNewUpperIn = maUpperRect.IsInside(rMEvt.GetPosPixel());
 454             if (bNewUpperIn != mbUpperIn)
 455             {
 456                 if (bNewUpperIn)
 457                 {
 458                     if (mbRepeat)
 459                         maRepeatTimer.Start();
 460                 }
 461                 else
 462                     maRepeatTimer.Stop();
 463
 464                 mbUpperIn = bNewUpperIn;
 465                 Invalidate(maUpperRect);
 466                 Update();
 467             }
 468         }
 469         else if (mbInitialDown)
 470         {
 471             bool bNewLowerIn = maLowerRect.IsInside(rMEvt.GetPosPixel());
 472             if (bNewLowerIn != mbLowerIn)
 473             {
 474                 if (bNewLowerIn)
 475                 {
 476                     if (mbRepeat)
 477                         maRepeatTimer.Start();
 478                 }
 479                 else
 480                     maRepeatTimer.Stop();
 481
 482                 mbLowerIn = bNewLowerIn;
 483                 Invalidate(maLowerRect);
 484                 Update();
 485             }
 486         }
 487     }
 488
 489     Edit::MouseMove(rMEvt);
 490 }
 491
 492 bool SpinField::EventNotify(NotifyEvent& rNEvt)
 493 {
 494     bool bDone = false;
 495     if (rNEvt.GetType() == MouseNotifyEvent::KEYINPUT)
 496     {
 497         const KeyEvent& rKEvt = *rNEvt.GetKeyEvent();
 498         if (!IsReadOnly())
 499         {
 500             sal_uInt16 nMod = rKEvt.GetKeyCode().GetModifier();
 501             switch (rKEvt.GetKeyCode().GetCode())
 502             {
 503                 case KEY_UP:
 504                 {
 505                     if (!nMod)
 506                     {
 507                         Up();
 508                         bDone = true;
 509                     }
 510                 }
 511                 break;
 512                 case KEY_DOWN:
 513                 {
 514                     if (!nMod)
 515                     {
 516                         Down();
 517                         bDone = true;
 518                     }
 519                     else if ((nMod == KEY_MOD2) && !mbInDropDown && (GetStyle() & WB_DROPDOWN))
 520                     {
 521                         mbInDropDown = ShowDropDown(true);
 522                         Invalidate(Rectangle(Point(), GetOutputSizePixel()));
 523                         bDone = true;
 524                     }
 525                 }
 526                 break;
 527                 case KEY_PAGEUP:
 528                 {
 529                     if (!nMod)
 530                     {
 531                         Last();
 532                         bDone = true;
 533                     }
 534                 }
 535                 break;
 536                 case KEY_PAGEDOWN:
 537                 {
 538                     if (!nMod)
 539                     {
 540                         First();
 541                         bDone = true;
 542                     }
 543                 }
 544                 break;
 545             }
 546         }
 547     }
 548
 549     if (rNEvt.GetType() == MouseNotifyEvent::COMMAND)
 550     {
 551         if ((rNEvt.GetCommandEvent()->GetCommand() == CommandEventId::Wheel) && !IsReadOnly())
 552         {
 553             MouseWheelBehaviour nWheelBehavior(GetSettings().GetMouseSettings().GetWheelBehavior());
 554             if (nWheelBehavior == MouseWheelBehaviour::ALWAYS
 555                || (nWheelBehavior == MouseWheelBehaviour::FocusOnly && HasChildPathFocus()))
 556             {
 557                 const CommandWheelData* pData = rNEvt.GetCommandEvent()->GetWheelData();
 558                 if (pData->GetMode() == CommandWheelMode::SCROLL)
 559                 {
 560                     if (pData->GetDelta() < 0)
 561                         Down();
 562                     else
 563                         Up();
 564                     bDone = true;
 565                 }
 566             }
 567             else
 568                 bDone = false;  // don't eat this event, let the default handling happen (i.e. scroll the context)
 569         }
 570     }
 571
 572     return bDone || Edit::EventNotify(rNEvt);
 573 }
 574
 575 void SpinField::FillLayoutData() const
 576 {
 577     if (mbSpin)
 578     {
 579         mpControlData->mpLayoutData.reset( new vcl::ControlLayoutData );
 580         AppendLayoutData(*GetSubEdit());
 581         GetSubEdit()->SetLayoutDataParent(this);
 582     }
 583     else
 584         Edit::FillLayoutData();
 585 }
 586
 587 void SpinField::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRect)
 588 {
 589     if (mbSpin)
 590     {
 591         bool bEnable = IsEnabled();
 592         ImplDrawSpinButton(rRenderContext, this, maUpperRect, maLowerRect,
 593                            mbUpperIn, mbLowerIn, bEnable, bEnable);
 594     }
 595
 596     if (GetStyle() & WB_DROPDOWN)
 597     {
 598         DecorationView aView(&rRenderContext);
 599
 600         DrawButtonFlags nStyle = DrawButtonFlags::NoLightBorder;
 601         if (mbInDropDown)
 602             nStyle |= DrawButtonFlags::Pressed;
 603         Rectangle aInnerRect = aView.DrawButton(maDropDownRect, nStyle);
 604
 605         SymbolType eSymbol = SymbolType::SPIN_DOWN;
 606         DrawSymbolFlags nSymbolStyle = IsEnabled() ? DrawSymbolFlags::NONE : DrawSymbolFlags::Disable;
 607         aView.DrawSymbol(aInnerRect, eSymbol, rRenderContext.GetSettings().GetStyleSettings().GetButtonTextColor(), nSymbolStyle);
 608     }
 609
 610     Edit::Paint(rRenderContext, rRect);
 611 }
 612
 613 void SpinField::ImplCalcButtonAreas(OutputDevice* pDev, const Size& rOutSz, Rectangle& rDDArea,
 614                                     Rectangle& rSpinUpArea, Rectangle& rSpinDownArea)
 615 {
 616     const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings();
 617
 618     Size aSize = rOutSz;
 619     Size aDropDownSize;
 620
 621     if (GetStyle() & WB_DROPDOWN)
 622     {
 623         long nW = rStyleSettings.GetScrollBarSize();
 624         nW = GetDrawPixel( pDev, nW );
 625         aDropDownSize = Size( CalcZoom( nW ), aSize.Height() );
 626         aSize.Width() -= aDropDownSize.Width();
 627         rDDArea = Rectangle( Point( aSize.Width(), 0 ), aDropDownSize );
 628         rDDArea.Top()--;
 629     }
 630     else
 631         rDDArea.SetEmpty();
 632
 633     // calcuate sizes according to the height
 634     if (GetStyle() & WB_SPIN)
 635     {
 636         long nBottom1 = aSize.Height()/2;
 637         long nBottom2 = aSize.Height()-1;
 638         long nTop2 = nBottom1;
 639         if ( !(aSize.Height() & 0x01) )
 640             nBottom1--;
 641
 642         bool bNativeRegionOK = false;
 643         Rectangle aContentUp, aContentDown;
 644
 645         if ((pDev->GetOutDevType() == OUTDEV_WINDOW) &&
 646             // there is just no useful native support for spinfields with dropdown
 647             ! (GetStyle() & WB_DROPDOWN) &&
 648             IsNativeControlSupported(ControlType::Spinbox, ControlPart::Entire))
 649         {
 650             vcl::Window *pWin = static_cast<vcl::Window*>(pDev);
 651             vcl::Window *pBorder = pWin->GetWindow( GetWindowType::Border );
 652
 653             // get the system's spin button size
 654             ImplControlValue aControlValue;
 655             Rectangle aBound;
 656             Point aPoint;
 657
 658             // use the full extent of the control
 659             Rectangle aArea( aPoint, pBorder->GetOutputSizePixel() );
 660
 661             bNativeRegionOK =
 662                 pWin->GetNativeControlRegion(ControlType::Spinbox, ControlPart::ButtonUp,
 663                     aArea, ControlState::NONE, aControlValue, OUString(), aBound, aContentUp) &&
 664                 pWin->GetNativeControlRegion(ControlType::Spinbox, ControlPart::ButtonDown,
 665                     aArea, ControlState::NONE, aControlValue, OUString(), aBound, aContentDown);
 666
 667             if (bNativeRegionOK)
 668             {
 669                 // convert back from border space to local coordinates
 670                 aPoint = pBorder->ScreenToOutputPixel( pWin->OutputToScreenPixel( aPoint ) );
 671                 aContentUp.Move(-aPoint.X(), -aPoint.Y());
 672                 aContentDown.Move(-aPoint.X(), -aPoint.Y());
 673             }
 674         }
 675
 676         if (bNativeRegionOK)
 677         {
 678             rSpinUpArea = aContentUp;
 679             rSpinDownArea = aContentDown;
 680         }
 681         else
 682         {
 683             aSize.Width() -= CalcZoom( GetDrawPixel( pDev, rStyleSettings.GetSpinSize() ) );
 684
 685             rSpinUpArea = Rectangle( aSize.Width(), 0, rOutSz.Width()-aDropDownSize.Width()-1, nBottom1 );
 686             rSpinDownArea = Rectangle( rSpinUpArea.Left(), nTop2, rSpinUpArea.Right(), nBottom2 );
 687         }
 688     }
 689     else
 690     {
 691         rSpinUpArea.SetEmpty();
 692         rSpinDownArea.SetEmpty();
 693     }
 694 }
 695
 696 void SpinField::Resize()
 697 {
 698     if (mbSpin)
 699     {
 700         Control::Resize();
 701         Size aSize = GetOutputSizePixel();
 702         bool bSubEditPositioned = false;
 703
 704         if (GetStyle() & (WB_SPIN | WB_DROPDOWN))
 705         {
 706             ImplCalcButtonAreas( this, aSize, maDropDownRect, maUpperRect, maLowerRect );
 707
 708             ImplControlValue aControlValue;
 709             Point aPoint;
 710             Rectangle aContent, aBound;
 711
 712             // use the full extent of the control
 713             vcl::Window *pBorder = GetWindow( GetWindowType::Border );
 714             Rectangle aArea( aPoint, pBorder->GetOutputSizePixel() );
 715
 716             // adjust position and size of the edit field
 717             if (GetNativeControlRegion(ControlType::Spinbox, ControlPart::SubEdit, aArea, ControlState::NONE,
 718                                        aControlValue, OUString(), aBound, aContent) &&
 719                 // there is just no useful native support for spinfields with dropdown
 720                 !(GetStyle() & WB_DROPDOWN))
 721             {
 722                 // convert back from border space to local coordinates
 723                 aPoint = pBorder->ScreenToOutputPixel(OutputToScreenPixel(aPoint));
 724                 aContent.Move(-aPoint.X(), -aPoint.Y());
 725
 726                 // use the themes drop down size
 727                 mpEdit->SetPosPixel( aContent.TopLeft() );
 728                 bSubEditPositioned = true;
 729                 aSize = aContent.GetSize();
 730             }
 731             else
 732             {
 733                 if (maUpperRect.IsEmpty())
 734                 {
 735                     SAL_WARN_IF( maDropDownRect.IsEmpty(), "vcl", "SpinField::Resize: SPIN && DROPDOWN, but all empty rects?" );
 736                     aSize.Width() = maDropDownRect.Left();
 737                 }
 738                 else
 739                     aSize.Width() = maUpperRect.Left();
 740             }
 741         }
 742
 743         if (!bSubEditPositioned)
 744         {
 745             // this moves our sub edit if RTL gets switched
 746             mpEdit->SetPosPixel(Point());
 747         }
 748         mpEdit->SetSizePixel(aSize);
 749
 750         if (GetStyle() & WB_SPIN)
 751             Invalidate(Rectangle(maUpperRect.TopLeft(), maLowerRect.BottomRight()));
 752         if (GetStyle() & WB_DROPDOWN)
 753             Invalidate(maDropDownRect);
 754     }
 755 }
 756
 757 void SpinField::StateChanged(StateChangedType nType)
 758 {
 759     Edit::StateChanged(nType);
 760
 761     if (nType == StateChangedType::Enable)
 762     {
 763         if (mbSpin || (GetStyle() & WB_DROPDOWN))
 764         {
 765             mpEdit->Enable(IsEnabled());
 766
 767             if (mbSpin)
 768             {
 769                 Invalidate(maLowerRect);
 770                 Invalidate(maUpperRect);
 771             }
 772             if (GetStyle() & WB_DROPDOWN)
 773                 Invalidate(maDropDownRect);
 774         }
 775     }
 776     else if (nType == StateChangedType::Style)
 777     {
 778         if (GetStyle() & WB_REPEAT)
 779             mbRepeat = true;
 780         else
 781             mbRepeat = false;
 782     }
 783     else if (nType == StateChangedType::Zoom)
 784     {
 785         Resize();
 786         if (mpEdit)
 787             mpEdit->SetZoom(GetZoom());
 788         Invalidate();
 789     }
 790     else if (nType == StateChangedType::ControlFont)
 791     {
 792         if (mpEdit)
 793             mpEdit->SetControlFont(GetControlFont());
 794         Invalidate();
 795     }
 796     else if (nType == StateChangedType::ControlForeground)
 797     {
 798         if (mpEdit)
 799             mpEdit->SetControlForeground(GetControlForeground());
 800         Invalidate();
 801     }
 802     else if (nType == StateChangedType::ControlBackground)
 803     {
 804         if (mpEdit)
 805             mpEdit->SetControlBackground(GetControlBackground());
 806         Invalidate();
 807     }
 808     else if( nType == StateChangedType::Mirroring )
 809     {
 810         if (mpEdit)
 811             mpEdit->CompatStateChanged(StateChangedType::Mirroring);
 812         Resize();
 813     }
 814 }
 815
 816 void SpinField::DataChanged( const DataChangedEvent& rDCEvt )
 817 {
 818     Edit::DataChanged(rDCEvt);
 819
 820     if ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 821         (rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
 822     {
 823         Resize();
 824         Invalidate();
 825     }
 826 }
 827
 828 Rectangle* SpinField::ImplFindPartRect(const Point& rPt)
 829 {
 830     if (maUpperRect.IsInside(rPt))
 831         return &maUpperRect;
 832     else if (maLowerRect.IsInside(rPt))
 833         return &maLowerRect;
 834     else
 835         return nullptr;
 836 }
 837
 838 bool SpinField::PreNotify(NotifyEvent& rNEvt)
 839 {
 840     const MouseEvent* pMouseEvt = nullptr;
 841
 842     if ((rNEvt.GetType() == MouseNotifyEvent::MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != nullptr)
 843     {
 844         if (!pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged())
 845         {
 846             // trigger redraw if mouse over state has changed
 847             if( IsNativeControlSupported(ControlType::Spinbox, ControlPart::Entire) ||
 848                 IsNativeControlSupported(ControlType::Spinbox, ControlPart::AllButtons) )
 849             {
 850                 Rectangle* pRect = ImplFindPartRect( GetPointerPosPixel() );
 851                 Rectangle* pLastRect = ImplFindPartRect( GetLastPointerPosPixel() );
 852                 if( pRect != pLastRect || (pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow()) )
 853                 {
 854                     // FIXME: this is currently only on OS X
 855                     // check for other platforms that need similar handling
 856                     if (ImplGetSVData()->maNWFData.mbNoFocusRects && IsNativeWidgetEnabled() &&
 857                         IsNativeControlSupported(ControlType::Editbox, ControlPart::Entire))
 858                     {
 859                         ImplInvalidateOutermostBorder(this);
 860                     }
 861                     else
 862                     {
 863                         // paint directly
 864                         vcl::Region aRgn( GetActiveClipRegion() );
 865                         if (pLastRect)
 866                         {
 867                             SetClipRegion(vcl::Region(*pLastRect));
 868                             Invalidate(*pLastRect);
 869                             SetClipRegion( aRgn );
 870                         }
 871                         if (pRect)
 872                         {
 873                             SetClipRegion(vcl::Region(*pRect));
 874                             Invalidate(*pRect);
 875                             SetClipRegion( aRgn );
 876                         }
 877                     }
 878                 }
 879             }
 880         }
 881     }
 882
 883     return Edit::PreNotify(rNEvt);
 884 }
 885
 886 void SpinField::EndDropDown()
 887 {
 888     mbInDropDown = false;
 889     Invalidate(Rectangle(Point(), GetOutputSizePixel()));
 890 }
 891
 892 bool SpinField::ShowDropDown( bool )
 893 {
 894     return false;
 895 }
 896
 897 Size SpinField::CalcMinimumSizeForText(const OUString &rString) const
 898 {
 899     Size aSz = Edit::CalcMinimumSizeForText(rString);
 900
 901     if ( GetStyle() & WB_DROPDOWN )
 902         aSz.Width() += GetSettings().GetStyleSettings().GetScrollBarSize();
 903     if ( GetStyle() & WB_SPIN )
 904     {
 905         ImplControlValue aControlValue;
 906         Rectangle aArea( Point(), Size(100, aSz.Height()));
 907         Rectangle aEntireBound, aEntireContent, aEditBound, aEditContent;
 908         if (
 909                GetNativeControlRegion(ControlType::Spinbox, ControlPart::Entire,
 910                    aArea, ControlState::NONE, aControlValue, OUString(), aEntireBound, aEntireContent) &&
 911                GetNativeControlRegion(ControlType::Spinbox, ControlPart::SubEdit,
 912                    aArea, ControlState::NONE, aControlValue, OUString(), aEditBound, aEditContent)
 913            )
 914         {
 915             aSz.Width() += (aEntireContent.GetWidth() - aEditContent.GetWidth());
 916         }
 917         else
 918         {
 919             aSz.Width() += maUpperRect.GetWidth();
 920         }
 921     }
 922
 923     return aSz;
 924 }
 925
 926 Size SpinField::CalcMinimumSize() const
 927 {
 928     return CalcMinimumSizeForText(GetText());
 929 }
 930
 931 Size SpinField::GetOptimalSize() const
 932 {
 933     return CalcMinimumSize();
 934 }
 935
 936 Size SpinField::CalcSize(sal_Int32 nChars) const
 937 {
 938     Size aSz = Edit::CalcSize( nChars );
 939
 940     if ( GetStyle() & WB_DROPDOWN )
 941         aSz.Width() += GetSettings().GetStyleSettings().GetScrollBarSize();
 942     if ( GetStyle() & WB_SPIN )
 943         aSz.Width() += GetSettings().GetStyleSettings().GetSpinSize();
 944
 945     return aSz;
 946 }
 947
 948 IMPL_LINK( SpinField, ImplTimeout, Timer*, pTimer, void )
 949 {
 950     if ( pTimer->GetTimeout() == GetSettings().GetMouseSettings().GetButtonStartRepeat() )
 951     {
 952         pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() );
 953         pTimer->Start();
 954     }
 955     else
 956     {
 957         if ( mbInitialUp )
 958             Up();
 959         else
 960             Down();
 961     }
 962 }
 963
 964 void SpinField::Draw(OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags nFlags)
 965 {
 966     Edit::Draw(pDev, rPos, rSize, nFlags);
 967
 968     WinBits nFieldStyle = GetStyle();
 969     if ( !(nFlags & DrawFlags::NoControls ) && ( nFieldStyle & (WB_SPIN|WB_DROPDOWN) ) )
 970     {
 971         Point aPos = pDev->LogicToPixel( rPos );
 972         Size aSize = pDev->LogicToPixel( rSize );
 973         OutDevType eOutDevType = pDev->GetOutDevType();
 974         AllSettings aOldSettings = pDev->GetSettings();
 975
 976         pDev->Push();
 977         pDev->SetMapMode();
 978
 979         if (eOutDevType == OUTDEV_PRINTER)
 980         {
 981             StyleSettings aStyleSettings = aOldSettings.GetStyleSettings();
 982             aStyleSettings.SetFaceColor(COL_LIGHTGRAY);
 983             aStyleSettings.SetButtonTextColor(COL_BLACK);
 984             AllSettings aSettings(aOldSettings);
 985             aSettings.SetStyleSettings(aStyleSettings);
 986             pDev->SetSettings(aSettings);
 987         }
 988
 989         Rectangle aDD, aUp, aDown;
 990         ImplCalcButtonAreas(pDev, aSize, aDD, aUp, aDown);
 991         aDD.Move(aPos.X(), aPos.Y());
 992         aUp.Move(aPos.X(), aPos.Y());
 993         aUp.Top()++;
 994         aDown.Move(aPos.X(), aPos.Y());
 995
 996         Color aButtonTextColor;
 997         if ((nFlags & DrawFlags::Mono) || (eOutDevType == OUTDEV_PRINTER))
 998             aButtonTextColor = Color( COL_BLACK );
 999         else
1000             aButtonTextColor = GetSettings().GetStyleSettings().GetButtonTextColor();
1001
1002         if (GetStyle() & WB_DROPDOWN)
1003         {
1004             DecorationView aView( pDev );
1005             DrawButtonFlags nStyle = DrawButtonFlags::NoLightBorder;
1006             Rectangle aInnerRect = aView.DrawButton( aDD, nStyle );
1007             SymbolType eSymbol = SymbolType::SPIN_DOWN;
1008             DrawSymbolFlags nSymbolStyle = (IsEnabled() || (nFlags & DrawFlags::NoDisable)) ? DrawSymbolFlags::NONE : DrawSymbolFlags::Disable;
1009             aView.DrawSymbol(aInnerRect, eSymbol, aButtonTextColor, nSymbolStyle);
1010         }
1011
1012         if (GetStyle() & WB_SPIN)
1013         {
1014             ImplDrawSpinButton(*pDev, this, aUp, aDown, false, false);
1015         }
1016
1017         pDev->Pop();
1018         pDev->SetSettings(aOldSettings);
1019     }
1020 }
1021
1022 FactoryFunction SpinField::GetUITestFactory() const
1023 {
1024     return SpinFieldUIObject::create;
1025 }
1026
1027 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */