src/generic/vscroll.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/vscroll.cpp
   3 // Purpose:     wxVScrolledWindow implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by: Brad Anderson, David Warkentin
   6 // Created:     30.05.03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24 #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/dc.h"
  29     #include "wx/sizer.h"
  30 #endif
  31
  32 #include "wx/vscroll.h"
  33
  34 // ============================================================================
  35 // wxVarScrollHelperEvtHandler declaration
  36 // ============================================================================
  37
  38 // ----------------------------------------------------------------------------
  39 // wxScrollHelperEvtHandler: intercept the events from the window and forward
  40 // them to wxVarScrollHelperBase
  41 // ----------------------------------------------------------------------------
  42
  43 class WXDLLEXPORT wxVarScrollHelperEvtHandler : public wxEvtHandler
  44 {
  45 public:
  46     wxVarScrollHelperEvtHandler(wxVarScrollHelperBase *scrollHelper)
  47     {
  48         m_scrollHelper = scrollHelper;
  49     }
  50
  51     virtual bool ProcessEvent(wxEvent& event);
  52
  53 private:
  54     wxVarScrollHelperBase *m_scrollHelper;
  55
  56     wxDECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler);
  57 };
  58
  59 // ============================================================================
  60 // wxVarScrollHelperEvtHandler implementation
  61 // ============================================================================
  62
  63 bool wxVarScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
  64 {
  65     wxEventType evType = event.GetEventType();
  66
  67     // pass it on to the real handler
  68     bool processed = wxEvtHandler::ProcessEvent(event);
  69
  70     // always process the size events ourselves, even if the user code handles
  71     // them as well, as we need to AdjustScrollbars()
  72     //
  73     // NB: it is important to do it after processing the event in the normal
  74     //     way as HandleOnSize() may generate a wxEVT_SIZE itself if the
  75     //     scrollbar[s] (dis)appear and it should be seen by the user code
  76     //     after this one
  77     if ( evType == wxEVT_SIZE )
  78     {
  79         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
  80
  81         return !event.GetSkipped();
  82     }
  83
  84     if ( processed )
  85     {
  86         // normally, nothing more to do here - except if we have a command
  87         // event
  88         if ( event.IsCommandEvent() )
  89         {
  90             return true;
  91         }
  92     }
  93
  94     // reset the skipped flag (which might have been set to true in
  95     // ProcessEvent() above) to be able to test it below
  96     bool wasSkipped = event.GetSkipped();
  97     if ( wasSkipped )
  98         event.Skip(false);
  99
 100     // reset the skipped flag to false as it might have been set to true in
 101     // ProcessEvent() above
 102     event.Skip(false);
 103
 104     if ( evType == wxEVT_SCROLLWIN_TOP ||
 105          evType == wxEVT_SCROLLWIN_BOTTOM ||
 106          evType == wxEVT_SCROLLWIN_LINEUP ||
 107          evType == wxEVT_SCROLLWIN_LINEDOWN ||
 108          evType == wxEVT_SCROLLWIN_PAGEUP ||
 109          evType == wxEVT_SCROLLWIN_PAGEDOWN ||
 110          evType == wxEVT_SCROLLWIN_THUMBTRACK ||
 111          evType == wxEVT_SCROLLWIN_THUMBRELEASE )
 112     {
 113         m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
 114         if ( !event.GetSkipped() )
 115         {
 116             // it makes sense to indicate that we processed the message as we
 117             // did scroll the window (and also notice that wxAutoScrollTimer
 118             // relies on our return value for continuous scrolling)
 119             processed = true;
 120             wasSkipped = false;
 121         }
 122     }
 123 #if wxUSE_MOUSEWHEEL
 124     else if ( evType == wxEVT_MOUSEWHEEL )
 125     {
 126         m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);
 127     }
 128 #endif // wxUSE_MOUSEWHEEL
 129
 130     if ( processed )
 131         event.Skip(wasSkipped);
 132
 133     return processed;
 134 }
 135
 136
 137 // ============================================================================
 138 // wxVarScrollHelperBase implementation
 139 // ============================================================================
 140
 141 // ----------------------------------------------------------------------------
 142 // wxVarScrollHelperBase initialization
 143 // ----------------------------------------------------------------------------
 144
 145 wxVarScrollHelperBase::wxVarScrollHelperBase(wxWindow *win)
 146 {
 147     wxASSERT_MSG( win, wxT("associated window can't be NULL in wxVarScrollHelperBase") );
 148
 149 #if wxUSE_MOUSEWHEEL
 150     m_sumWheelRotation = 0;
 151 #endif
 152
 153     m_unitMax = 0;
 154     m_sizeTotal = 0;
 155     m_unitFirst = 0;
 156
 157     m_win =
 158     m_targetWindow = NULL;
 159
 160     m_physicalScrolling = true;
 161     m_handler = NULL;
 162
 163     m_win = win;
 164
 165     // by default, the associated window is also the target window
 166     DoSetTargetWindow(win);
 167
 168 }
 169
 170 wxVarScrollHelperBase::~wxVarScrollHelperBase()
 171 {
 172     DeleteEvtHandler();
 173 }
 174
 175 // ----------------------------------------------------------------------------
 176 // wxVarScrollHelperBase various helpers
 177 // ----------------------------------------------------------------------------
 178
 179 void
 180 wxVarScrollHelperBase::AssignOrient(wxCoord& x,
 181                                     wxCoord& y,
 182                                     wxCoord first,
 183                                     wxCoord second)
 184 {
 185     if ( GetOrientation() == wxVERTICAL )
 186     {
 187         x = first;
 188         y = second;
 189     }
 190     else // horizontal
 191     {
 192         x = second;
 193         y = first;
 194     }
 195 }
 196
 197 void
 198 wxVarScrollHelperBase::IncOrient(wxCoord& x, wxCoord& y, wxCoord inc)
 199 {
 200     if ( GetOrientation() == wxVERTICAL )
 201         y += inc;
 202     else
 203         x += inc;
 204 }
 205
 206 wxCoord wxVarScrollHelperBase::DoEstimateTotalSize() const
 207 {
 208     // estimate the total height: it is impossible to call
 209     // OnGetUnitSize() for every unit because there may be too many of
 210     // them, so we just make a guess using some units in the beginning,
 211     // some in the end and some in the middle
 212     static const size_t NUM_UNITS_TO_SAMPLE = 10;
 213
 214     wxCoord sizeTotal;
 215     if ( m_unitMax < 3*NUM_UNITS_TO_SAMPLE )
 216     {
 217         // in this case, full calculations are faster and more correct than
 218         // guessing
 219         sizeTotal = GetUnitsSize(0, m_unitMax);
 220     }
 221     else // too many units to calculate exactly
 222     {
 223         // look at some units in the beginning/middle/end
 224         sizeTotal =
 225             GetUnitsSize(0, NUM_UNITS_TO_SAMPLE) +
 226                 GetUnitsSize(m_unitMax - NUM_UNITS_TO_SAMPLE,
 227                              m_unitMax) +
 228                     GetUnitsSize(m_unitMax/2 - NUM_UNITS_TO_SAMPLE/2,
 229                                  m_unitMax/2 + NUM_UNITS_TO_SAMPLE/2);
 230
 231         // use the height of the units we looked as the average
 232         sizeTotal = (wxCoord)
 233                 (((float)sizeTotal / (3*NUM_UNITS_TO_SAMPLE)) * m_unitMax);
 234     }
 235
 236     return sizeTotal;
 237 }
 238
 239 wxCoord wxVarScrollHelperBase::GetUnitsSize(size_t unitMin, size_t unitMax) const
 240 {
 241     if ( unitMin == unitMax )
 242         return 0;
 243     else if ( unitMin > unitMax )
 244         return -GetUnitsSize(unitMax, unitMin);
 245     //else: unitMin < unitMax
 246
 247     // let the user code know that we're going to need all these units
 248     OnGetUnitsSizeHint(unitMin, unitMax);
 249
 250     // sum up their sizes
 251     wxCoord size = 0;
 252     for ( size_t unit = unitMin; unit < unitMax; ++unit )
 253     {
 254         size += OnGetUnitSize(unit);
 255     }
 256
 257     return size;
 258 }
 259
 260 size_t wxVarScrollHelperBase::FindFirstVisibleFromLast(size_t unitLast, bool full) const
 261 {
 262     const wxCoord sWindow = GetOrientationTargetSize();
 263
 264     // go upwards until we arrive at a unit such that unitLast is not visible
 265     // any more when it is shown
 266     size_t unitFirst = unitLast;
 267     wxCoord s = 0;
 268     for ( ;; )
 269     {
 270         s += OnGetUnitSize(unitFirst);
 271
 272         if ( s > sWindow )
 273         {
 274             // for this unit to be fully visible we need to go one unit
 275             // down, but if it is enough for it to be only partly visible then
 276             // this unit will do as well
 277             if ( full )
 278             {
 279                 ++unitFirst;
 280             }
 281
 282             break;
 283         }
 284
 285         if ( !unitFirst )
 286             break;
 287
 288         --unitFirst;
 289     }
 290
 291     return unitFirst;
 292 }
 293
 294 size_t wxVarScrollHelperBase::GetNewScrollPosition(wxScrollWinEvent& event) const
 295 {
 296     wxEventType evtType = event.GetEventType();
 297
 298     if ( evtType == wxEVT_SCROLLWIN_TOP )
 299     {
 300         return 0;
 301     }
 302     else if ( evtType == wxEVT_SCROLLWIN_BOTTOM )
 303     {
 304         return m_unitMax;
 305     }
 306     else if ( evtType == wxEVT_SCROLLWIN_LINEUP )
 307     {
 308         return m_unitFirst ? m_unitFirst - 1 : 0;
 309     }
 310     else if ( evtType == wxEVT_SCROLLWIN_LINEDOWN )
 311     {
 312         return m_unitFirst + 1;
 313     }
 314     else if ( evtType == wxEVT_SCROLLWIN_PAGEUP )
 315     {
 316         return FindFirstVisibleFromLast(m_unitFirst);
 317     }
 318     else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
 319     {
 320         if ( GetVisibleEnd() )
 321             return GetVisibleEnd() - 1;
 322         else
 323             return GetVisibleEnd();
 324     }
 325     else if ( evtType == wxEVT_SCROLLWIN_THUMBRELEASE )
 326     {
 327         return event.GetPosition();
 328     }
 329     else if ( evtType == wxEVT_SCROLLWIN_THUMBTRACK )
 330     {
 331         return event.GetPosition();
 332     }
 333
 334     // unknown scroll event?
 335     wxFAIL_MSG( wxT("unknown scroll event type?") );
 336     return 0;
 337 }
 338
 339 void wxVarScrollHelperBase::UpdateScrollbar()
 340 {
 341     // if there is nothing to scroll, remove the scrollbar
 342     if ( !m_unitMax )
 343     {
 344         RemoveScrollbar();
 345         return;
 346     }
 347
 348     // see how many units can we fit on screen
 349     const wxCoord sWindow = GetOrientationTargetSize();
 350
 351     // do vertical calculations
 352     wxCoord s = 0;
 353     size_t unit;
 354     for ( unit = m_unitFirst; unit < m_unitMax; ++unit )
 355     {
 356         if ( s > sWindow )
 357             break;
 358
 359         s += OnGetUnitSize(unit);
 360     }
 361
 362     m_nUnitsVisible = unit - m_unitFirst;
 363
 364     int unitsPageSize = m_nUnitsVisible;
 365     if ( s > sWindow )
 366     {
 367         // last unit is only partially visible, we still need the scrollbar and
 368         // so we have to "fix" pageSize because if it is equal to m_unitMax
 369         // the scrollbar is not shown at all under MSW
 370         --unitsPageSize;
 371     }
 372
 373     // set the scrollbar parameters to reflect this
 374     m_win->SetScrollbar(GetOrientation(), m_unitFirst, unitsPageSize, m_unitMax);
 375 }
 376
 377 void wxVarScrollHelperBase::RemoveScrollbar()
 378 {
 379     m_unitFirst = 0;
 380     m_nUnitsVisible = m_unitMax;
 381     m_win->SetScrollbar(GetOrientation(), 0, 0, 0);
 382 }
 383
 384 void wxVarScrollHelperBase::DeleteEvtHandler()
 385 {
 386     // search for m_handler in the handler list
 387     if ( m_win && m_handler )
 388     {
 389         if ( m_win->RemoveEventHandler(m_handler) )
 390         {
 391             delete m_handler;
 392         }
 393         //else: something is very wrong, so better [maybe] leak memory than
 394         //      risk a crash because of double deletion
 395
 396         m_handler = NULL;
 397     }
 398 }
 399
 400 void wxVarScrollHelperBase::DoSetTargetWindow(wxWindow *target)
 401 {
 402     m_targetWindow = target;
 403 #ifdef __WXMAC__
 404     target->MacSetClipChildren( true ) ;
 405 #endif
 406
 407     // install the event handler which will intercept the events we're
 408     // interested in (but only do it for our real window, not the target window
 409     // which we scroll - we don't need to hijack its events)
 410     if ( m_targetWindow == m_win )
 411     {
 412         // if we already have a handler, delete it first
 413         DeleteEvtHandler();
 414
 415         m_handler = new wxVarScrollHelperEvtHandler(this);
 416         m_targetWindow->PushEventHandler(m_handler);
 417     }
 418 }
 419
 420 // ----------------------------------------------------------------------------
 421 // wxVarScrollHelperBase operations
 422 // ----------------------------------------------------------------------------
 423
 424 void wxVarScrollHelperBase::SetTargetWindow(wxWindow *target)
 425 {
 426     wxCHECK_RET( target, wxT("target window must not be NULL") );
 427
 428     if ( target == m_targetWindow )
 429         return;
 430
 431     DoSetTargetWindow(target);
 432 }
 433
 434 void wxVarScrollHelperBase::SetUnitCount(size_t count)
 435 {
 436     // save the number of units
 437     m_unitMax = count;
 438
 439     // and our estimate for their total height
 440     m_sizeTotal = EstimateTotalSize();
 441
 442     // ScrollToUnit() will update the scrollbar itself if it changes the unit
 443     // we pass to it because it's out of [new] range
 444     size_t oldScrollPos = m_unitFirst;
 445     DoScrollToUnit(m_unitFirst);
 446     if ( oldScrollPos == m_unitFirst )
 447     {
 448         // but if it didn't do it, we still need to update the scrollbar to
 449         // reflect the changed number of units ourselves
 450         UpdateScrollbar();
 451     }
 452 }
 453
 454 void wxVarScrollHelperBase::RefreshUnit(size_t unit)
 455 {
 456     // is this unit visible?
 457     if ( !IsVisible(unit) )
 458     {
 459         // no, it is useless to do anything
 460         return;
 461     }
 462
 463     // calculate the rect occupied by this unit on screen
 464     wxRect rect;
 465     AssignOrient(rect.width, rect.height,
 466                  GetNonOrientationTargetSize(), OnGetUnitSize(unit));
 467
 468     for ( size_t n = GetVisibleBegin(); n < unit; ++n )
 469     {
 470         IncOrient(rect.x, rect.y, OnGetUnitSize(n));
 471     }
 472
 473     // do refresh it
 474     m_targetWindow->RefreshRect(rect);
 475 }
 476
 477 void wxVarScrollHelperBase::RefreshUnits(size_t from, size_t to)
 478 {
 479     wxASSERT_MSG( from <= to, wxT("RefreshUnits(): empty range") );
 480
 481     // clump the range to just the visible units -- it is useless to refresh
 482     // the other ones
 483     if ( from < GetVisibleBegin() )
 484         from = GetVisibleBegin();
 485
 486     if ( to > GetVisibleEnd() )
 487         to = GetVisibleEnd();
 488
 489     // calculate the rect occupied by these units on screen
 490     int orient_size, nonorient_size, orient_pos;
 491     orient_size = nonorient_size = orient_pos = 0;
 492
 493     nonorient_size = GetNonOrientationTargetSize();
 494
 495     for ( size_t nBefore = GetVisibleBegin();
 496           nBefore < from;
 497           nBefore++ )
 498     {
 499         orient_pos += OnGetUnitSize(nBefore);
 500     }
 501
 502     for ( size_t nBetween = from; nBetween <= to; nBetween++ )
 503     {
 504         orient_size += OnGetUnitSize(nBetween);
 505     }
 506
 507     wxRect rect;
 508     AssignOrient(rect.x, rect.y, 0, orient_pos);
 509     AssignOrient(rect.width, rect.height, nonorient_size, orient_size);
 510
 511     // do refresh it
 512     m_targetWindow->RefreshRect(rect);
 513 }
 514
 515 void wxVarScrollHelperBase::RefreshAll()
 516 {
 517     UpdateScrollbar();
 518
 519     m_targetWindow->Refresh();
 520 }
 521
 522 bool wxVarScrollHelperBase::ScrollLayout()
 523 {
 524     if ( m_targetWindow->GetSizer() && m_physicalScrolling )
 525     {
 526         // adjust the sizer dimensions/position taking into account the
 527         // virtual size and scrolled position of the window.
 528
 529         int x, y;
 530         AssignOrient(x, y, 0, -GetScrollOffset());
 531
 532         int w, h;
 533         m_targetWindow->GetVirtualSize(&w, &h);
 534
 535         m_targetWindow->GetSizer()->SetDimension(x, y, w, h);
 536         return true;
 537     }
 538
 539     // fall back to default for LayoutConstraints
 540     return m_targetWindow->wxWindow::Layout();
 541 }
 542
 543 int wxVarScrollHelperBase::VirtualHitTest(wxCoord coord) const
 544 {
 545     const size_t unitMax = GetVisibleEnd();
 546     for ( size_t unit = GetVisibleBegin(); unit < unitMax; ++unit )
 547     {
 548         coord -= OnGetUnitSize(unit);
 549         if ( coord < 0 )
 550             return unit;
 551     }
 552
 553     return wxNOT_FOUND;
 554 }
 555
 556 // ----------------------------------------------------------------------------
 557 // wxVarScrollHelperBase scrolling
 558 // ----------------------------------------------------------------------------
 559
 560 bool wxVarScrollHelperBase::DoScrollToUnit(size_t unit)
 561 {
 562     if ( !m_unitMax )
 563     {
 564         // we're empty, code below doesn't make sense in this case
 565         return false;
 566     }
 567
 568     // determine the real first unit to scroll to: we shouldn't scroll beyond
 569     // the end
 570     size_t unitFirstLast = FindFirstVisibleFromLast(m_unitMax - 1, true);
 571     if ( unit > unitFirstLast )
 572         unit = unitFirstLast;
 573
 574     // anything to do?
 575     if ( unit == m_unitFirst )
 576     {
 577         // no
 578         return false;
 579     }
 580
 581
 582     // remember the currently shown units for the refresh code below
 583     size_t unitFirstOld = GetVisibleBegin(),
 584            unitLastOld = GetVisibleEnd();
 585
 586     m_unitFirst = unit;
 587
 588
 589     // the size of scrollbar thumb could have changed
 590     UpdateScrollbar();
 591
 592     // finally refresh the display -- but only redraw as few units as possible
 593     // to avoid flicker.  We can't do this if we have children because they
 594     // won't be scrolled
 595     if ( m_targetWindow->GetChildren().empty() &&
 596          (GetVisibleBegin() >= unitLastOld || GetVisibleEnd() <= unitFirstOld) )
 597     {
 598         // the simplest case: we don't have any old units left, just redraw
 599         // everything
 600         m_targetWindow->Refresh();
 601     }
 602     else // scroll the window
 603     {
 604         // Avoid scrolling visible parts of the screen on Mac
 605 #ifdef __WXMAC__
 606         if (m_physicalScrolling && m_targetWindow->IsShownOnScreen())
 607 #else
 608         if ( m_physicalScrolling )
 609 #endif
 610         {
 611             wxCoord dx = 0,
 612                     dy = GetUnitsSize(GetVisibleBegin(), unitFirstOld);
 613
 614             if ( GetOrientation() == wxHORIZONTAL )
 615             {
 616                 wxCoord tmp = dx;
 617                 dx = dy;
 618                 dy = tmp;
 619             }
 620
 621             m_targetWindow->ScrollWindow(dx, dy);
 622         }
 623         else // !m_physicalScrolling
 624         {
 625             // we still need to invalidate but we can't use ScrollWindow
 626             // because physical scrolling is disabled (the user either didn't
 627             // want children scrolled and/or doesn't want pixels to be
 628             // physically scrolled).
 629             m_targetWindow->Refresh();
 630         }
 631     }
 632
 633     return true;
 634 }
 635
 636 bool wxVarScrollHelperBase::DoScrollUnits(int units)
 637 {
 638     units += m_unitFirst;
 639     if ( units < 0 )
 640         units = 0;
 641
 642     return DoScrollToUnit(units);
 643 }
 644
 645 bool wxVarScrollHelperBase::DoScrollPages(int pages)
 646 {
 647     bool didSomething = false;
 648
 649     while ( pages )
 650     {
 651         int unit;
 652         if ( pages > 0 )
 653         {
 654             unit = GetVisibleEnd();
 655             if ( unit )
 656                 --unit;
 657             --pages;
 658         }
 659         else // pages < 0
 660         {
 661             unit = FindFirstVisibleFromLast(GetVisibleEnd());
 662             ++pages;
 663         }
 664
 665         didSomething = DoScrollToUnit(unit);
 666     }
 667
 668     return didSomething;
 669 }
 670
 671 // ----------------------------------------------------------------------------
 672 // event handling
 673 // ----------------------------------------------------------------------------
 674
 675 void wxVarScrollHelperBase::HandleOnSize(wxSizeEvent& event)
 676 {
 677     if ( m_unitMax )
 678     {
 679         // sometimes change in varscrollable window's size can result in
 680         // unused empty space after the last item. Fix it by decrementing
 681         // first visible item position according to the available space.
 682
 683         // determine free space
 684         const wxCoord sWindow = GetOrientationTargetSize();
 685         wxCoord s = 0;
 686         size_t unit;
 687         for ( unit = m_unitFirst; unit < m_unitMax; ++unit )
 688         {
 689             if ( s > sWindow )
 690                 break;
 691
 692             s += OnGetUnitSize(unit);
 693         }
 694         wxCoord freeSpace = sWindow - s;
 695
 696         // decrement first visible item index as long as there is free space
 697         size_t idealUnitFirst;
 698         for ( idealUnitFirst = m_unitFirst;
 699               idealUnitFirst > 0;
 700               idealUnitFirst-- )
 701         {
 702             wxCoord us = OnGetUnitSize(idealUnitFirst-1);
 703             if ( freeSpace < us )
 704                 break;
 705             freeSpace -= us;
 706         }
 707         m_unitFirst = idealUnitFirst;
 708     }
 709
 710     UpdateScrollbar();
 711
 712     event.Skip();
 713 }
 714
 715 void wxVarScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event)
 716 {
 717     if (GetOrientation() != event.GetOrientation())
 718     {
 719         event.Skip();
 720         return;
 721     }
 722
 723     DoScrollToUnit(GetNewScrollPosition(event));
 724
 725 #ifdef __WXMAC__
 726     UpdateMacScrollWindow();
 727 #endif // __WXMAC__
 728 }
 729
 730 void wxVarScrollHelperBase::DoPrepareDC(wxDC& dc)
 731 {
 732     if ( m_physicalScrolling )
 733     {
 734         wxPoint pt = dc.GetDeviceOrigin();
 735
 736         IncOrient(pt.x, pt.y, -GetScrollOffset());
 737
 738         dc.SetDeviceOrigin(pt.x, pt.y);
 739     }
 740 }
 741
 742 int wxVarScrollHelperBase::DoCalcScrolledPosition(int coord) const
 743 {
 744     return coord - GetScrollOffset();
 745 }
 746
 747 int wxVarScrollHelperBase::DoCalcUnscrolledPosition(int coord) const
 748 {
 749     return coord + GetScrollOffset();
 750 }
 751
 752 #if wxUSE_MOUSEWHEEL
 753
 754 void wxVarScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)
 755 {
 756     // we only want to process wheel events for vertical implementations.
 757     // There is no way to determine wheel orientation (and on MSW horizontal
 758     // wheel rotation just fakes scroll events, rather than sending a MOUSEWHEEL
 759     // event).
 760     if ( GetOrientation() != wxVERTICAL )
 761         return;
 762
 763     m_sumWheelRotation += event.GetWheelRotation();
 764     int delta = event.GetWheelDelta();
 765
 766     // how much to scroll this time
 767     int units_to_scroll = -(m_sumWheelRotation/delta);
 768     if ( !units_to_scroll )
 769         return;
 770
 771     m_sumWheelRotation += units_to_scroll*delta;
 772
 773     if ( !event.IsPageScroll() )
 774         DoScrollUnits( units_to_scroll*event.GetLinesPerAction() );
 775     else // scroll pages instead of units
 776         DoScrollPages( units_to_scroll );
 777 }
 778
 779 #endif // wxUSE_MOUSEWHEEL
 780
 781
 782 // ============================================================================
 783 // wxVarHVScrollHelper implementation
 784 // ============================================================================
 785
 786 // ----------------------------------------------------------------------------
 787 // wxVarHVScrollHelper operations
 788 // ----------------------------------------------------------------------------
 789
 790 void wxVarHVScrollHelper::SetRowColumnCount(size_t rowCount, size_t columnCount)
 791 {
 792     SetRowCount(rowCount);
 793     SetColumnCount(columnCount);
 794 }
 795
 796 bool wxVarHVScrollHelper::ScrollToRowColumn(size_t row, size_t column)
 797 {
 798     bool result = false;
 799     result |= ScrollToRow(row);
 800     result |= ScrollToColumn(column);
 801     return result;
 802 }
 803
 804 void wxVarHVScrollHelper::RefreshRowColumn(size_t row, size_t column)
 805 {
 806     // is this unit visible?
 807     if ( !IsRowVisible(row) || !IsColumnVisible(column) )
 808     {
 809         // no, it is useless to do anything
 810         return;
 811     }
 812
 813     // calculate the rect occupied by this cell on screen
 814     wxRect v_rect, h_rect;
 815     v_rect.height = OnGetRowHeight(row);
 816     h_rect.width = OnGetColumnWidth(column);
 817
 818     size_t n;
 819
 820     for ( n = GetVisibleRowsBegin(); n < row; n++ )
 821     {
 822         v_rect.y += OnGetRowHeight(n);
 823     }
 824
 825     for ( n = GetVisibleColumnsBegin(); n < column; n++ )
 826     {
 827         h_rect.x += OnGetColumnWidth(n);
 828     }
 829
 830     // refresh but specialize the behavior if we have a single target window
 831     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
 832     {
 833         v_rect.x = h_rect.x;
 834         v_rect.width = h_rect.width;
 835         wxVarVScrollHelper::GetTargetWindow()->RefreshRect(v_rect);
 836     }
 837     else
 838     {
 839         v_rect.x = 0;
 840         v_rect.width = wxVarVScrollHelper::GetNonOrientationTargetSize();
 841         h_rect.y = 0;
 842         h_rect.width = wxVarHScrollHelper::GetNonOrientationTargetSize();
 843
 844         wxVarVScrollHelper::GetTargetWindow()->RefreshRect(v_rect);
 845         wxVarHScrollHelper::GetTargetWindow()->RefreshRect(h_rect);
 846     }
 847 }
 848
 849 void wxVarHVScrollHelper::RefreshRowsColumns(size_t fromRow, size_t toRow,
 850                                              size_t fromColumn, size_t toColumn)
 851 {
 852     wxASSERT_MSG( fromRow <= toRow || fromColumn <= toColumn,
 853         wxT("RefreshRowsColumns(): empty range") );
 854
 855     // clump the range to just the visible units -- it is useless to refresh
 856     // the other ones
 857     if ( fromRow < GetVisibleRowsBegin() )
 858         fromRow = GetVisibleRowsBegin();
 859
 860     if ( toRow > GetVisibleRowsEnd() )
 861         toRow = GetVisibleRowsEnd();
 862
 863     if ( fromColumn < GetVisibleColumnsBegin() )
 864         fromColumn = GetVisibleColumnsBegin();
 865
 866     if ( toColumn > GetVisibleColumnsEnd() )
 867         toColumn = GetVisibleColumnsEnd();
 868
 869     // calculate the rect occupied by these units on screen
 870     wxRect v_rect, h_rect;
 871     size_t nBefore, nBetween;
 872
 873     for ( nBefore = GetVisibleRowsBegin();
 874           nBefore < fromRow;
 875           nBefore++ )
 876     {
 877         v_rect.y += OnGetRowHeight(nBefore);
 878     }
 879
 880     for ( nBetween = fromRow; nBetween <= toRow; nBetween++ )
 881     {
 882         v_rect.height += OnGetRowHeight(nBetween);
 883     }
 884
 885     for ( nBefore = GetVisibleColumnsBegin();
 886           nBefore < fromColumn;
 887           nBefore++ )
 888     {
 889         h_rect.x += OnGetColumnWidth(nBefore);
 890     }
 891
 892     for ( nBetween = fromColumn; nBetween <= toColumn; nBetween++ )
 893     {
 894         h_rect.width += OnGetColumnWidth(nBetween);
 895     }
 896
 897     // refresh but specialize the behavior if we have a single target window
 898     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
 899     {
 900         v_rect.x = h_rect.x;
 901         v_rect.width = h_rect.width;
 902         wxVarVScrollHelper::GetTargetWindow()->RefreshRect(v_rect);
 903     }
 904     else
 905     {
 906         v_rect.x = 0;
 907         v_rect.width = wxVarVScrollHelper::GetNonOrientationTargetSize();
 908         h_rect.y = 0;
 909         h_rect.width = wxVarHScrollHelper::GetNonOrientationTargetSize();
 910
 911         wxVarVScrollHelper::GetTargetWindow()->RefreshRect(v_rect);
 912         wxVarHScrollHelper::GetTargetWindow()->RefreshRect(h_rect);
 913     }
 914 }
 915
 916 wxPosition wxVarHVScrollHelper::VirtualHitTest(wxCoord x, wxCoord y) const
 917 {
 918     return wxPosition(wxVarVScrollHelper::VirtualHitTest(y),
 919                       wxVarHScrollHelper::VirtualHitTest(x));
 920 }
 921
 922 void wxVarHVScrollHelper::DoPrepareDC(wxDC& dc)
 923 {
 924     wxVarVScrollHelper::DoPrepareDC(dc);
 925     wxVarHScrollHelper::DoPrepareDC(dc);
 926 }
 927
 928 bool wxVarHVScrollHelper::ScrollLayout()
 929 {
 930     bool layout_result = false;
 931     layout_result |= wxVarVScrollHelper::ScrollLayout();
 932     layout_result |= wxVarHScrollHelper::ScrollLayout();
 933     return layout_result;
 934 }
 935
 936 wxSize wxVarHVScrollHelper::GetRowColumnCount() const
 937 {
 938     return wxSize(GetColumnCount(), GetRowCount());
 939 }
 940
 941 wxPosition wxVarHVScrollHelper::GetVisibleBegin() const
 942 {
 943     return wxPosition(GetVisibleRowsBegin(), GetVisibleColumnsBegin());
 944 }
 945
 946 wxPosition wxVarHVScrollHelper::GetVisibleEnd() const
 947 {
 948     return wxPosition(GetVisibleRowsEnd(), GetVisibleColumnsEnd());
 949 }
 950
 951 bool wxVarHVScrollHelper::IsVisible(size_t row, size_t column) const
 952 {
 953     return IsRowVisible(row) && IsColumnVisible(column);
 954 }
 955
 956
 957 // ============================================================================
 958 // wx[V/H/HV]ScrolledWindow implementations
 959 // ============================================================================
 960
 961 IMPLEMENT_ABSTRACT_CLASS(wxVScrolledWindow, wxPanel)
 962 IMPLEMENT_ABSTRACT_CLASS(wxHScrolledWindow, wxPanel)
 963 IMPLEMENT_ABSTRACT_CLASS(wxHVScrolledWindow, wxPanel)
 964
 965
 966 #if WXWIN_COMPATIBILITY_2_8
 967
 968 // ===========================================================================
 969 // wxVarVScrollLegacyAdaptor
 970 // ===========================================================================
 971
 972 size_t wxVarVScrollLegacyAdaptor::GetFirstVisibleLine() const
 973 { return GetVisibleRowsBegin(); }
 974
 975 size_t wxVarVScrollLegacyAdaptor::GetLastVisibleLine() const
 976 { return GetVisibleRowsEnd() - 1; }
 977
 978 size_t wxVarVScrollLegacyAdaptor::GetLineCount() const
 979 { return GetRowCount(); }
 980
 981 void wxVarVScrollLegacyAdaptor::SetLineCount(size_t count)
 982 { SetRowCount(count); }
 983
 984 void wxVarVScrollLegacyAdaptor::RefreshLine(size_t line)
 985 { RefreshRow(line); }
 986
 987 void wxVarVScrollLegacyAdaptor::RefreshLines(size_t from, size_t to)
 988 { RefreshRows(from, to); }
 989
 990 bool wxVarVScrollLegacyAdaptor::ScrollToLine(size_t line)
 991 { return ScrollToRow(line); }
 992
 993 bool wxVarVScrollLegacyAdaptor::ScrollLines(int lines)
 994 { return ScrollRows(lines); }
 995
 996 bool wxVarVScrollLegacyAdaptor::ScrollPages(int pages)
 997 { return ScrollRowPages(pages); }
 998
 999 wxCoord wxVarVScrollLegacyAdaptor::OnGetLineHeight(size_t WXUNUSED(n)) const
1000 {
1001     wxFAIL_MSG( wxT("OnGetLineHeight() must be overridden if OnGetRowHeight() isn't!") );
1002     return -1;
1003 }
1004
1005 void wxVarVScrollLegacyAdaptor::OnGetLinesHint(size_t WXUNUSED(lineMin),
1006                                                size_t WXUNUSED(lineMax)) const
1007 {
1008 }
1009
1010 wxCoord wxVarVScrollLegacyAdaptor::OnGetRowHeight(size_t n) const
1011 {
1012     return OnGetLineHeight(n);
1013 }
1014
1015 void wxVarVScrollLegacyAdaptor::OnGetRowsHeightHint(size_t rowMin,
1016                                                     size_t rowMax) const
1017 {
1018     OnGetLinesHint(rowMin, rowMax);
1019 }
1020
1021 #endif // WXWIN_COMPATIBILITY_2_8