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