src/univ/scrolbar.cpp

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