src/univ/scrolbar.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/univ/scrolbar.cpp
   3 // Purpose:     wxScrollBar implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_SCROLLBAR
  27
  28 #include "wx/scrolbar.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/timer.h"
  32     #include "wx/dcclient.h"
  33     #include "wx/validate.h"
  34     #include "wx/log.h"
  35 #endif
  36
  37 #include "wx/univ/scrtimer.h"
  38
  39 #include "wx/univ/renderer.h"
  40 #include "wx/univ/inphand.h"
  41 #include "wx/univ/theme.h"
  42
  43 #define WXDEBUG_SCROLLBAR
  44
  45 #ifndef __WXDEBUG__
  46     #undef WXDEBUG_SCROLLBAR
  47 #endif // !__WXDEBUG__
  48
  49 #if defined(WXDEBUG_SCROLLBAR) && defined(__WXMSW__) && !defined(__WXMICROWIN__)
  50 #include "wx/msw/private.h"
  51 #endif
  52
  53 // ----------------------------------------------------------------------------
  54 // wxScrollBarTimer: this class is used to repeatedly scroll the scrollbar
  55 // when the mouse is help pressed on the arrow or on the bar. It generates the
  56 // given scroll action command periodically.
  57 // ----------------------------------------------------------------------------
  58
  59 class wxScrollBarTimer : public wxScrollTimer
  60 {
  61 public:
  62     wxScrollBarTimer(wxStdScrollBarInputHandler *handler,
  63                      const wxControlAction& action,
  64                      wxScrollBar *control);
  65
  66 protected:
  67     virtual bool DoNotify();
  68
  69 private:
  70     wxStdScrollBarInputHandler *m_handler;
  71     wxControlAction m_action;
  72     wxScrollBar    *m_control;
  73 };
  74
  75 // ============================================================================
  76 // implementation
  77 // ============================================================================
  78
  79 IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
  80
  81 BEGIN_EVENT_TABLE(wxScrollBar, wxScrollBarBase)
  82 END_EVENT_TABLE()
  83
  84 // ----------------------------------------------------------------------------
  85 // creation
  86 // ----------------------------------------------------------------------------
  87
  88 #ifdef __VISUALC__
  89     // warning C4355: 'this' : used in base member initializer list
  90     #pragma warning(disable:4355)  // so what? disable it...
  91 #endif
  92
  93 wxScrollBar::wxScrollBar()
  94            : m_arrows(this)
  95 {
  96     Init();
  97 }
  98
  99 wxScrollBar::wxScrollBar(wxWindow *parent,
 100                          wxWindowID id,
 101                          const wxPoint& pos,
 102                          const wxSize& size,
 103                          long style,
 104                          const wxValidator& validator,
 105                          const wxString& name)
 106            : m_arrows(this)
 107 {
 108     Init();
 109
 110     (void)Create(parent, id, pos, size, style, validator, name);
 111 }
 112
 113 #ifdef __VISUALC__
 114     // warning C4355: 'this' : used in base member initializer list
 115     #pragma warning(default:4355)
 116 #endif
 117
 118 void wxScrollBar::Init()
 119 {
 120     m_range =
 121     m_thumbSize =
 122     m_thumbPos =
 123     m_pageSize = 0;
 124
 125     m_thumbPosOld = -1;
 126
 127     for ( size_t n = 0; n < WXSIZEOF(m_elementsState); n++ )
 128     {
 129         m_elementsState[n] = 0;
 130     }
 131
 132     m_dirty = false;
 133 }
 134
 135 bool wxScrollBar::Create(wxWindow *parent,
 136                          wxWindowID id,
 137                          const wxPoint &pos,
 138                          const wxSize &size,
 139                          long style,
 140                          const wxValidator& validator,
 141                          const wxString &name)
 142 {
 143     // the scrollbars never have the border
 144     style &= ~wxBORDER_MASK;
 145
 146     if ( !wxControl::Create(parent, id, pos, size, style, validator, name) )
 147         return false;
 148
 149     SetBestSize(size);
 150
 151     // override the cursor of the target window (if any)
 152     SetCursor(wxCURSOR_ARROW);
 153
 154     CreateInputHandler(wxINP_HANDLER_SCROLLBAR);
 155
 156     return true;
 157 }
 158
 159 wxScrollBar::~wxScrollBar()
 160 {
 161 }
 162
 163 // ----------------------------------------------------------------------------
 164 // misc accessors
 165 // ----------------------------------------------------------------------------
 166
 167 bool wxScrollBar::IsStandalone() const
 168 {
 169     wxWindow *parent = GetParent();
 170     if ( !parent )
 171     {
 172         return true;
 173     }
 174
 175     return (parent->GetScrollbar(wxHORIZONTAL) != this) &&
 176            (parent->GetScrollbar(wxVERTICAL) != this);
 177 }
 178
 179 bool wxScrollBar::AcceptsFocus() const
 180 {
 181     // the window scrollbars never accept focus
 182     return wxScrollBarBase::AcceptsFocus() && IsStandalone();
 183 }
 184
 185 // ----------------------------------------------------------------------------
 186 // scrollbar API
 187 // ----------------------------------------------------------------------------
 188
 189 void wxScrollBar::DoSetThumb(int pos)
 190 {
 191     // don't assert hecks here, we're a private function which is meant to be
 192     // called with any args at all
 193     if ( pos < 0 )
 194     {
 195         pos = 0;
 196     }
 197     else if ( pos > m_range - m_thumbSize )
 198     {
 199         pos = m_range - m_thumbSize;
 200     }
 201
 202     if ( m_thumbPos == pos )
 203     {
 204         // nothing changed, avoid refreshes which would provoke flicker
 205         return;
 206     }
 207
 208     if ( m_thumbPosOld == -1 )
 209     {
 210         // remember the old thumb position
 211         m_thumbPosOld = m_thumbPos;
 212     }
 213
 214     m_thumbPos = pos;
 215
 216     // we have to refresh the part of the bar which was under the thumb and the
 217     // thumb itself
 218     m_elementsState[Element_Thumb] |= wxCONTROL_DIRTY;
 219     m_elementsState[m_thumbPos > m_thumbPosOld
 220                         ? Element_Bar_1 : Element_Bar_2] |= wxCONTROL_DIRTY;
 221     m_dirty = true;
 222 }
 223
 224 int wxScrollBar::GetThumbPosition() const
 225 {
 226     return m_thumbPos;
 227 }
 228
 229 int wxScrollBar::GetThumbSize() const
 230 {
 231     return m_thumbSize;
 232 }
 233
 234 int wxScrollBar::GetPageSize() const
 235 {
 236     return m_pageSize;
 237 }
 238
 239 int wxScrollBar::GetRange() const
 240 {
 241     return m_range;
 242 }
 243
 244 void wxScrollBar::SetThumbPosition(int pos)
 245 {
 246     wxCHECK_RET( pos >= 0 && pos <= m_range, _T("thumb position out of range") );
 247
 248     DoSetThumb(pos);
 249 }
 250
 251 void wxScrollBar::SetScrollbar(int position, int thumbSize,
 252                                int range, int pageSize,
 253                                bool refresh)
 254 {
 255     // we only refresh everything when the range changes, thumb position
 256     // changes are handled in OnIdle
 257     bool needsRefresh = (range != m_range) ||
 258                         (thumbSize != m_thumbSize) ||
 259                         (pageSize != m_pageSize);
 260
 261     // set all parameters
 262     m_range = range;
 263     m_thumbSize = thumbSize;
 264     SetThumbPosition(position);
 265     m_pageSize = pageSize;
 266
 267     // ignore refresh parameter unless we really need to refresh everything -
 268     // there ir a lot of existing code which just calls SetScrollbar() without
 269     // specifying the last parameter even though it doesn't need at all to
 270     // refresh the window immediately
 271     if ( refresh && needsRefresh )
 272     {
 273         // and update the window
 274         Refresh();
 275         Update();
 276     }
 277 }
 278
 279 // ----------------------------------------------------------------------------
 280 // geometry
 281 // ----------------------------------------------------------------------------
 282
 283 wxSize wxScrollBar::DoGetBestClientSize() const
 284 {
 285     // this dimension is completely arbitrary
 286     static const wxCoord SIZE = 140;
 287
 288     wxSize size = m_renderer->GetScrollbarArrowSize();
 289     if ( IsVertical() )
 290     {
 291         size.y = SIZE;
 292     }
 293     else // horizontal
 294     {
 295         size.x = SIZE;
 296     }
 297
 298     return size;
 299 }
 300
 301 wxScrollArrows::Arrow wxScrollBar::HitTest(const wxPoint& pt) const
 302 {
 303     switch ( m_renderer->HitTestScrollbar(this, pt) )
 304     {
 305         case wxHT_SCROLLBAR_ARROW_LINE_1:
 306             return wxScrollArrows::Arrow_First;
 307
 308         case wxHT_SCROLLBAR_ARROW_LINE_2:
 309             return wxScrollArrows::Arrow_Second;
 310
 311         default:
 312             return wxScrollArrows::Arrow_None;
 313     }
 314 }
 315
 316 // ----------------------------------------------------------------------------
 317 // drawing
 318 // ----------------------------------------------------------------------------
 319
 320 void wxScrollBar::OnInternalIdle()
 321 {
 322     UpdateThumb();
 323     wxControl::OnInternalIdle();
 324 }
 325
 326 void wxScrollBar::UpdateThumb()
 327 {
 328     if ( m_dirty )
 329     {
 330         for ( size_t n = 0; n < WXSIZEOF(m_elementsState); n++ )
 331         {
 332             if ( m_elementsState[n] & wxCONTROL_DIRTY )
 333             {
 334                 wxRect rect = GetRenderer()->GetScrollbarRect(this, (Element)n);
 335
 336                 if ( rect.width && rect.height )
 337                 {
 338                     // we try to avoid redrawing the entire shaft (which might
 339                     // be quite long) if possible by only redrawing the area
 340                     // wich really changed
 341                     if ( (n == Element_Bar_1 || n == Element_Bar_2) &&
 342                             (m_thumbPosOld != -1) )
 343                     {
 344                         // the less efficient but more reliable (i.e. this will
 345                         // probably work everywhere) version: refresh the
 346                         // distance covered by thumb since the last update
 347 #if 0
 348                         wxRect rectOld =
 349                             GetRenderer()->GetScrollbarRect(this,
 350                                                             (Element)n,
 351                                                             m_thumbPosOld);
 352                         if ( IsVertical() )
 353                         {
 354                             if ( n == Element_Bar_1 )
 355                                 rect.SetTop(rectOld.GetBottom());
 356                             else
 357                                 rect.SetBottom(rectOld.GetBottom());
 358                         }
 359                         else // horizontal
 360                         {
 361                             if ( n == Element_Bar_1 )
 362                                 rect.SetLeft(rectOld.GetRight());
 363                             else
 364                                 rect.SetRight(rectOld.GetRight());
 365                         }
 366 #else                   // efficient version: only repaint the area occupied by
 367                         // the thumb previously - we can't do better than this
 368                         rect = GetRenderer()->GetScrollbarRect(this,
 369                                                                Element_Thumb,
 370                                                                m_thumbPosOld);
 371 #endif // 0/1
 372                     }
 373
 374 #ifdef WXDEBUG_SCROLLBAR
 375         static bool s_refreshDebug = false;
 376         if ( s_refreshDebug )
 377         {
 378             wxClientDC dc(this);
 379             dc.SetBrush(*wxCYAN_BRUSH);
 380             dc.SetPen(*wxTRANSPARENT_PEN);
 381             dc.DrawRectangle(rect);
 382
 383             // under Unix we use "--sync" X option for this
 384             #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 385                 ::GdiFlush();
 386                 ::Sleep(200);
 387             #endif // __WXMSW__
 388         }
 389 #endif // WXDEBUG_SCROLLBAR
 390
 391                     Refresh(false, &rect);
 392                 }
 393
 394                 m_elementsState[n] &= ~wxCONTROL_DIRTY;
 395             }
 396         }
 397
 398         m_dirty = false;
 399     }
 400 }
 401
 402 void wxScrollBar::DoDraw(wxControlRenderer *renderer)
 403 {
 404     renderer->DrawScrollbar(this, m_thumbPosOld);
 405
 406     // clear all dirty flags
 407     m_dirty = false;
 408     m_thumbPosOld = -1;
 409 }
 410
 411 // ----------------------------------------------------------------------------
 412 // state flags
 413 // ----------------------------------------------------------------------------
 414
 415 static inline wxScrollBar::Element ElementForArrow(wxScrollArrows::Arrow arrow)
 416 {
 417     return arrow == wxScrollArrows::Arrow_First
 418             ? wxScrollBar::Element_Arrow_Line_1
 419             : wxScrollBar::Element_Arrow_Line_2;
 420 }
 421
 422 int wxScrollBar::GetArrowState(wxScrollArrows::Arrow arrow) const
 423 {
 424     return GetState(ElementForArrow(arrow));
 425 }
 426
 427 void wxScrollBar::SetArrowFlag(wxScrollArrows::Arrow arrow, int flag, bool set)
 428 {
 429     Element which = ElementForArrow(arrow);
 430     int state = GetState(which);
 431     if ( set )
 432         state |= flag;
 433     else
 434         state &= ~flag;
 435
 436     SetState(which, state);
 437 }
 438
 439 int wxScrollBar::GetState(Element which) const
 440 {
 441     // if the entire scrollbar is disabled, all of its elements are too
 442     int flags = m_elementsState[which];
 443     if ( !IsEnabled() )
 444         flags |= wxCONTROL_DISABLED;
 445
 446     return flags;
 447 }
 448
 449 void wxScrollBar::SetState(Element which, int flags)
 450 {
 451     if ( (int)(m_elementsState[which] & ~wxCONTROL_DIRTY) != flags )
 452     {
 453         m_elementsState[which] = flags | wxCONTROL_DIRTY;
 454
 455         m_dirty = true;
 456     }
 457 }
 458
 459 // ----------------------------------------------------------------------------
 460 // input processing
 461 // ----------------------------------------------------------------------------
 462
 463 bool wxScrollBar::OnArrow(wxScrollArrows::Arrow arrow)
 464 {
 465     int oldThumbPos = GetThumbPosition();
 466     PerformAction(arrow == wxScrollArrows::Arrow_First
 467                     ? wxACTION_SCROLL_LINE_UP
 468                     : wxACTION_SCROLL_LINE_DOWN);
 469
 470     // did we scroll till the end?
 471     return GetThumbPosition() != oldThumbPos;
 472 }
 473
 474 bool wxScrollBar::PerformAction(const wxControlAction& action,
 475                                 long numArg,
 476                                 const wxString& strArg)
 477 {
 478     int thumbOld = m_thumbPos;
 479
 480     bool notify = false; // send an event about the change?
 481
 482     wxEventType scrollType;
 483
 484     // test for thumb move first as these events happen in quick succession
 485     if ( action == wxACTION_SCROLL_THUMB_MOVE )
 486     {
 487         DoSetThumb(numArg);
 488
 489         // VS: we have to force redraw here, otherwise the thumb will lack
 490         //     behind mouse cursor
 491         UpdateThumb();
 492
 493         scrollType = wxEVT_SCROLLWIN_THUMBTRACK;
 494     }
 495     else if ( action == wxACTION_SCROLL_LINE_UP )
 496     {
 497         scrollType = wxEVT_SCROLLWIN_LINEUP;
 498         ScrollLines(-1);
 499     }
 500     else if ( action == wxACTION_SCROLL_LINE_DOWN )
 501     {
 502         scrollType = wxEVT_SCROLLWIN_LINEDOWN;
 503         ScrollLines(1);
 504     }
 505     else if ( action == wxACTION_SCROLL_PAGE_UP )
 506     {
 507         scrollType = wxEVT_SCROLLWIN_PAGEUP;
 508         ScrollPages(-1);
 509     }
 510     else if ( action == wxACTION_SCROLL_PAGE_DOWN )
 511     {
 512         scrollType = wxEVT_SCROLLWIN_PAGEDOWN;
 513         ScrollPages(1);
 514     }
 515     else if ( action == wxACTION_SCROLL_START )
 516     {
 517         scrollType = wxEVT_SCROLLWIN_THUMBRELEASE; // anything better?
 518         ScrollToStart();
 519     }
 520     else if ( action == wxACTION_SCROLL_END )
 521     {
 522         scrollType = wxEVT_SCROLLWIN_THUMBRELEASE; // anything better?
 523         ScrollToEnd();
 524     }
 525     else if ( action == wxACTION_SCROLL_THUMB_DRAG )
 526     {
 527         // we won't use it but this line suppresses the compiler
 528         // warning about "variable may be used without having been
 529         // initialized"
 530         scrollType = wxEVT_NULL;
 531     }
 532     else if ( action == wxACTION_SCROLL_THUMB_RELEASE )
 533     {
 534         // always notify about this
 535         notify = true;
 536         scrollType = wxEVT_SCROLLWIN_THUMBRELEASE;
 537     }
 538     else
 539         return wxControl::PerformAction(action, numArg, strArg);
 540
 541     // has scrollbar position changed?
 542     bool changed = m_thumbPos != thumbOld;
 543     if ( notify || changed )
 544     {
 545         if ( IsStandalone() )
 546         {
 547             // we should generate EVT_SCROLL events for the standalone
 548             // scrollbars and not the EVT_SCROLLWIN ones
 549             //
 550             // NB: we assume that scrollbar events are sequentially numbered
 551             //     but this should be ok as other code relies on this as well
 552             scrollType += wxEVT_SCROLL_TOP - wxEVT_SCROLLWIN_TOP;
 553             wxScrollEvent event(scrollType, this->GetId(), m_thumbPos,
 554                                 IsVertical() ? wxVERTICAL : wxHORIZONTAL);
 555             event.SetEventObject(this);
 556             GetEventHandler()->ProcessEvent(event);
 557         }
 558         else // part of the window
 559         {
 560             wxScrollWinEvent event(scrollType, m_thumbPos,
 561                                    IsVertical() ? wxVERTICAL : wxHORIZONTAL);
 562             event.SetEventObject(this);
 563             GetParent()->GetEventHandler()->ProcessEvent(event);
 564         }
 565     }
 566
 567     return true;
 568 }
 569
 570 void wxScrollBar::ScrollToStart()
 571 {
 572     DoSetThumb(0);
 573 }
 574
 575 void wxScrollBar::ScrollToEnd()
 576 {
 577     DoSetThumb(m_range - m_thumbSize);
 578 }
 579
 580 bool wxScrollBar::ScrollLines(int nLines)
 581 {
 582     DoSetThumb(m_thumbPos + nLines);
 583     return true;
 584 }
 585
 586 bool wxScrollBar::ScrollPages(int nPages)
 587 {
 588     DoSetThumb(m_thumbPos + nPages*m_pageSize);
 589     return true;
 590 }
 591
 592 // ============================================================================
 593 // scroll bar input handler
 594 // ============================================================================
 595
 596 // ----------------------------------------------------------------------------
 597 // wxScrollBarTimer
 598 // ----------------------------------------------------------------------------
 599
 600 wxScrollBarTimer::wxScrollBarTimer(wxStdScrollBarInputHandler *handler,
 601                                    const wxControlAction& action,
 602                                    wxScrollBar *control)
 603 {
 604     m_handler = handler;
 605     m_action = action;
 606     m_control = control;
 607 }
 608
 609 bool wxScrollBarTimer::DoNotify()
 610 {
 611     return m_handler->OnScrollTimer(m_control, m_action);
 612 }
 613
 614 // ----------------------------------------------------------------------------
 615 // wxStdScrollBarInputHandler
 616 // ----------------------------------------------------------------------------
 617
 618 wxStdScrollBarInputHandler::wxStdScrollBarInputHandler(wxRenderer *renderer,
 619                                                        wxInputHandler *handler)
 620                           : wxStdInputHandler(handler)
 621 {
 622     m_renderer = renderer;
 623     m_winCapture = NULL;
 624     m_htLast = wxHT_NOWHERE;
 625     m_timerScroll = NULL;
 626 }
 627
 628 wxStdScrollBarInputHandler::~wxStdScrollBarInputHandler()
 629 {
 630     // normally, it's NULL by now but just in case the user somehow managed to
 631     // keep the mouse captured until now...
 632     delete m_timerScroll;
 633 }
 634
 635 void wxStdScrollBarInputHandler::SetElementState(wxScrollBar *control,
 636                                                  int flag,
 637                                                  bool doIt)
 638 {
 639     if ( m_htLast > wxHT_SCROLLBAR_FIRST && m_htLast < wxHT_SCROLLBAR_LAST )
 640     {
 641         wxScrollBar::Element
 642             elem = (wxScrollBar::Element)(m_htLast - wxHT_SCROLLBAR_FIRST - 1);
 643
 644         int flags = control->GetState(elem);
 645         if ( doIt )
 646             flags |= flag;
 647         else
 648             flags &= ~flag;
 649         control->SetState(elem, flags);
 650     }
 651 }
 652
 653 bool wxStdScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
 654                                                const wxControlAction& action)
 655 {
 656     int oldThumbPos = scrollbar->GetThumbPosition();
 657     scrollbar->PerformAction(action);
 658     if ( scrollbar->GetThumbPosition() != oldThumbPos )
 659         return true;
 660
 661     // we scrolled till the end
 662     m_timerScroll->Stop();
 663
 664     return false;
 665 }
 666
 667 void wxStdScrollBarInputHandler::StopScrolling(wxScrollBar *control)
 668 {
 669     // return everything to the normal state
 670     if ( m_winCapture )
 671     {
 672         m_winCapture->ReleaseMouse();
 673         m_winCapture = NULL;
 674     }
 675
 676     m_btnCapture = -1;
 677
 678     if ( m_timerScroll )
 679     {
 680         delete m_timerScroll;
 681         m_timerScroll = NULL;
 682     }
 683
 684     // unpress the arrow and highlight the current element
 685     Press(control, false);
 686 }
 687
 688 wxCoord
 689 wxStdScrollBarInputHandler::GetMouseCoord(const wxScrollBar *scrollbar,
 690                                           const wxMouseEvent& event) const
 691 {
 692     wxPoint pt = event.GetPosition();
 693     return scrollbar->GetWindowStyle() & wxVERTICAL ? pt.y : pt.x;
 694 }
 695
 696 void wxStdScrollBarInputHandler::HandleThumbMove(wxScrollBar *scrollbar,
 697                                                  const wxMouseEvent& event)
 698 {
 699     int thumbPos = GetMouseCoord(scrollbar, event) - m_ofsMouse;
 700     thumbPos = m_renderer->PixelToScrollbar(scrollbar, thumbPos);
 701     scrollbar->PerformAction(wxACTION_SCROLL_THUMB_MOVE, thumbPos);
 702 }
 703
 704 bool wxStdScrollBarInputHandler::HandleKey(wxInputConsumer *consumer,
 705                                            const wxKeyEvent& event,
 706                                            bool pressed)
 707 {
 708     // we only react to the key presses here
 709     if ( pressed )
 710     {
 711         wxControlAction action;
 712         switch ( event.GetKeyCode() )
 713         {
 714             case WXK_DOWN:
 715             case WXK_RIGHT:     action = wxACTION_SCROLL_LINE_DOWN; break;
 716             case WXK_UP:
 717             case WXK_LEFT:      action = wxACTION_SCROLL_LINE_UP;   break;
 718             case WXK_HOME:      action = wxACTION_SCROLL_START;     break;
 719             case WXK_END:       action = wxACTION_SCROLL_END;       break;
 720             case WXK_PAGEUP:    action = wxACTION_SCROLL_PAGE_UP;   break;
 721             case WXK_PAGEDOWN:  action = wxACTION_SCROLL_PAGE_DOWN; break;
 722         }
 723
 724         if ( !action.IsEmpty() )
 725         {
 726             consumer->PerformAction(action);
 727
 728             return true;
 729         }
 730     }
 731
 732     return wxStdInputHandler::HandleKey(consumer, event, pressed);
 733 }
 734
 735 bool wxStdScrollBarInputHandler::HandleMouse(wxInputConsumer *consumer,
 736                                              const wxMouseEvent& event)
 737 {
 738     // is this a click event from an acceptable button?
 739     int btn = event.GetButton();
 740     if ( (btn != -1) && IsAllowedButton(btn) )
 741     {
 742         // determine which part of the window mouse is in
 743         wxScrollBar *scrollbar = wxStaticCast(consumer->GetInputWindow(), wxScrollBar);
 744         wxHitTest ht = m_renderer->HitTestScrollbar
 745                                    (
 746                                     scrollbar,
 747                                     event.GetPosition()
 748                                    );
 749
 750         // when the mouse is pressed on any scrollbar element, we capture it
 751         // and hold capture until the same mouse button is released
 752         if ( event.ButtonDown() || event.ButtonDClick() )
 753         {
 754             if ( !m_winCapture )
 755             {
 756                 m_btnCapture = btn;
 757                 m_winCapture = consumer->GetInputWindow();
 758                 m_winCapture->CaptureMouse();
 759
 760                 // generate the command
 761                 bool hasAction = true;
 762                 wxControlAction action;
 763                 switch ( ht )
 764                 {
 765                     case wxHT_SCROLLBAR_ARROW_LINE_1:
 766                         action = wxACTION_SCROLL_LINE_UP;
 767                         break;
 768
 769                     case wxHT_SCROLLBAR_ARROW_LINE_2:
 770                         action = wxACTION_SCROLL_LINE_DOWN;
 771                         break;
 772
 773                     case wxHT_SCROLLBAR_BAR_1:
 774                         action = wxACTION_SCROLL_PAGE_UP;
 775                         m_ptStartScrolling = event.GetPosition();
 776                         break;
 777
 778                     case wxHT_SCROLLBAR_BAR_2:
 779                         action = wxACTION_SCROLL_PAGE_DOWN;
 780                         m_ptStartScrolling = event.GetPosition();
 781                         break;
 782
 783                     case wxHT_SCROLLBAR_THUMB:
 784                         consumer->PerformAction(wxACTION_SCROLL_THUMB_DRAG);
 785                         m_ofsMouse = GetMouseCoord(scrollbar, event) -
 786                                      m_renderer->ScrollbarToPixel(scrollbar);
 787
 788                         // fall through: there is no immediate action
 789
 790                     default:
 791                         hasAction = false;
 792                 }
 793
 794                 // remove highlighting
 795                 Highlight(scrollbar, false);
 796                 m_htLast = ht;
 797
 798                 // and press the arrow or highlight thumb now instead
 799                 if ( m_htLast == wxHT_SCROLLBAR_THUMB )
 800                     Highlight(scrollbar, true);
 801                 else
 802                     Press(scrollbar, true);
 803
 804                 // start dragging
 805                 if ( hasAction )
 806                 {
 807                     m_timerScroll = new wxScrollBarTimer(this, action,
 808                                                          scrollbar);
 809                     m_timerScroll->StartAutoScroll();
 810                 }
 811                 //else: no (immediate) action
 812
 813             }
 814             //else: mouse already captured, nothing to do
 815         }
 816         // release mouse if the *same* button went up
 817         else if ( btn == m_btnCapture )
 818         {
 819             if ( m_winCapture )
 820             {
 821                 StopScrolling(scrollbar);
 822
 823                 // if we were dragging the thumb, send the last event
 824                 if ( m_htLast == wxHT_SCROLLBAR_THUMB )
 825                 {
 826                     scrollbar->PerformAction(wxACTION_SCROLL_THUMB_RELEASE);
 827                 }
 828
 829                 m_htLast = ht;
 830                 Highlight(scrollbar, true);
 831             }
 832             else
 833             {
 834                 // this is not supposed to happen as the button can't go up
 835                 // without going down previously and then we'd have
 836                 // m_winCapture by now
 837                 wxFAIL_MSG( _T("logic error in mouse capturing code") );
 838             }
 839         }
 840     }
 841
 842     return wxStdInputHandler::HandleMouse(consumer, event);
 843 }
 844
 845 bool wxStdScrollBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
 846                                                  const wxMouseEvent& event)
 847 {
 848     wxScrollBar *scrollbar = wxStaticCast(consumer->GetInputWindow(), wxScrollBar);
 849
 850     if ( m_winCapture )
 851     {
 852         if ( (m_htLast == wxHT_SCROLLBAR_THUMB) && event.Dragging() )
 853         {
 854             // make the thumb follow the mouse by keeping the same offset
 855             // between the mouse position and the top/left of the thumb
 856             HandleThumbMove(scrollbar, event);
 857
 858             return true;
 859         }
 860
 861         // no other changes are possible while the mouse is captured
 862         return false;
 863     }
 864
 865     bool isArrow = scrollbar->GetArrows().HandleMouseMove(event);
 866
 867     if ( event.Dragging() )
 868     {
 869         wxHitTest ht = m_renderer->HitTestScrollbar
 870                                    (
 871                                     scrollbar,
 872                                     event.GetPosition()
 873                                    );
 874         if ( ht == m_htLast )
 875         {
 876             // nothing changed
 877             return false;
 878         }
 879
 880 #ifdef DEBUG_MOUSE
 881         wxLogDebug("Scrollbar::OnMouseMove: ht = %d", ht);
 882 #endif // DEBUG_MOUSE
 883
 884         Highlight(scrollbar, false);
 885         m_htLast = ht;
 886
 887         if ( !isArrow )
 888             Highlight(scrollbar, true);
 889         //else: already done by wxScrollArrows::HandleMouseMove
 890     }
 891     else if ( event.Leaving() )
 892     {
 893         if ( !isArrow )
 894             Highlight(scrollbar, false);
 895
 896         m_htLast = wxHT_NOWHERE;
 897     }
 898     else // event.Entering()
 899     {
 900         // we don't process this event
 901         return false;
 902     }
 903
 904     // we did something
 905     return true;
 906 }
 907
 908 #endif // wxUSE_SCROLLBAR
 909
 910 // ----------------------------------------------------------------------------
 911 // wxScrollTimer
 912 // ----------------------------------------------------------------------------
 913
 914 wxScrollTimer::wxScrollTimer()
 915 {
 916     m_skipNext = false;
 917 }
 918
 919 void wxScrollTimer::StartAutoScroll()
 920 {
 921     // start scrolling immediately
 922     if ( !DoNotify() )
 923     {
 924         // ... and end it too
 925         return;
 926     }
 927
 928     // there is an initial delay before the scrollbar starts scrolling -
 929     // implement it by ignoring the first timer expiration and only start
 930     // scrolling from the second one
 931     m_skipNext = true;
 932     Start(200); // FIXME: hardcoded delay
 933 }
 934
 935 void wxScrollTimer::Notify()
 936 {
 937     if ( m_skipNext )
 938     {
 939         // scroll normally now - reduce the delay
 940         Stop();
 941         Start(50); // FIXME: hardcoded delay
 942
 943         m_skipNext = false;
 944     }
 945     else
 946     {
 947         // if DoNotify() returns false, we're already deleted by the timer
 948         // event handler, so don't do anything else here
 949         (void)DoNotify();
 950     }
 951 }