]> git.saurik.com Git - wxWidgets.git/blob - src/generic/vscroll.cpp
No real changes, just avoid overloaded virtual wxWebView::SetPage().
[wxWidgets.git] / 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 #include "wx/utils.h" // For wxMin/wxMax().
35
36 // ============================================================================
37 // wxVarScrollHelperEvtHandler declaration
38 // ============================================================================
39
40 // ----------------------------------------------------------------------------
41 // wxScrollHelperEvtHandler: intercept the events from the window and forward
42 // them to wxVarScrollHelperBase
43 // ----------------------------------------------------------------------------
44
45 class WXDLLEXPORT wxVarScrollHelperEvtHandler : public wxEvtHandler
46 {
47 public:
48 wxVarScrollHelperEvtHandler(wxVarScrollHelperBase *scrollHelper)
49 {
50 m_scrollHelper = scrollHelper;
51 }
52
53 virtual bool ProcessEvent(wxEvent& event);
54
55 private:
56 wxVarScrollHelperBase *m_scrollHelper;
57
58 wxDECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler);
59 };
60
61 // ============================================================================
62 // wxVarScrollHelperEvtHandler implementation
63 // ============================================================================
64
65 bool wxVarScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
66 {
67 wxEventType evType = event.GetEventType();
68
69 // pass it on to the real handler
70 bool processed = wxEvtHandler::ProcessEvent(event);
71
72 // always process the size events ourselves, even if the user code handles
73 // them as well, as we need to AdjustScrollbars()
74 //
75 // NB: it is important to do it after processing the event in the normal
76 // way as HandleOnSize() may generate a wxEVT_SIZE itself if the
77 // scrollbar[s] (dis)appear and it should be seen by the user code
78 // after this one
79 if ( evType == wxEVT_SIZE )
80 {
81 m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
82
83 return !event.GetSkipped();
84 }
85
86 if ( processed )
87 {
88 // normally, nothing more to do here - except if we have a command
89 // event
90 if ( event.IsCommandEvent() )
91 {
92 return true;
93 }
94 }
95
96 // reset the skipped flag (which might have been set to true in
97 // ProcessEvent() above) to be able to test it below
98 bool wasSkipped = event.GetSkipped();
99 if ( wasSkipped )
100 event.Skip(false);
101
102 if ( evType == wxEVT_SCROLLWIN_TOP ||
103 evType == wxEVT_SCROLLWIN_BOTTOM ||
104 evType == wxEVT_SCROLLWIN_LINEUP ||
105 evType == wxEVT_SCROLLWIN_LINEDOWN ||
106 evType == wxEVT_SCROLLWIN_PAGEUP ||
107 evType == wxEVT_SCROLLWIN_PAGEDOWN ||
108 evType == wxEVT_SCROLLWIN_THUMBTRACK ||
109 evType == wxEVT_SCROLLWIN_THUMBRELEASE )
110 {
111 m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
112 if ( !event.GetSkipped() )
113 {
114 // it makes sense to indicate that we processed the message as we
115 // did scroll the window (and also notice that wxAutoScrollTimer
116 // relies on our return value for continuous scrolling)
117 processed = true;
118 wasSkipped = false;
119 }
120 }
121 #if wxUSE_MOUSEWHEEL
122 else if ( evType == wxEVT_MOUSEWHEEL )
123 {
124 m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);
125 }
126 #endif // wxUSE_MOUSEWHEEL
127
128 event.Skip(wasSkipped);
129
130 return processed;
131 }
132
133
134 // ============================================================================
135 // wxVarScrollHelperBase implementation
136 // ============================================================================
137
138 // ----------------------------------------------------------------------------
139 // wxVarScrollHelperBase initialization
140 // ----------------------------------------------------------------------------
141
142 wxVarScrollHelperBase::wxVarScrollHelperBase(wxWindow *win)
143 {
144 wxASSERT_MSG( win, wxT("associated window can't be NULL in wxVarScrollHelperBase") );
145
146 #if wxUSE_MOUSEWHEEL
147 m_sumWheelRotation = 0;
148 #endif
149
150 m_unitMax = 0;
151 m_sizeTotal = 0;
152 m_unitFirst = 0;
153
154 m_win =
155 m_targetWindow = NULL;
156
157 m_physicalScrolling = true;
158 m_handler = NULL;
159
160 m_win = win;
161
162 // by default, the associated window is also the target window
163 DoSetTargetWindow(win);
164
165 }
166
167 wxVarScrollHelperBase::~wxVarScrollHelperBase()
168 {
169 DeleteEvtHandler();
170 }
171
172 // ----------------------------------------------------------------------------
173 // wxVarScrollHelperBase various helpers
174 // ----------------------------------------------------------------------------
175
176 void
177 wxVarScrollHelperBase::AssignOrient(wxCoord& x,
178 wxCoord& y,
179 wxCoord first,
180 wxCoord second)
181 {
182 if ( GetOrientation() == wxVERTICAL )
183 {
184 x = first;
185 y = second;
186 }
187 else // horizontal
188 {
189 x = second;
190 y = first;
191 }
192 }
193
194 void
195 wxVarScrollHelperBase::IncOrient(wxCoord& x, wxCoord& y, wxCoord inc)
196 {
197 if ( GetOrientation() == wxVERTICAL )
198 y += inc;
199 else
200 x += inc;
201 }
202
203 wxCoord wxVarScrollHelperBase::DoEstimateTotalSize() const
204 {
205 // estimate the total height: it is impossible to call
206 // OnGetUnitSize() for every unit because there may be too many of
207 // them, so we just make a guess using some units in the beginning,
208 // some in the end and some in the middle
209 static const size_t NUM_UNITS_TO_SAMPLE = 10;
210
211 wxCoord sizeTotal;
212 if ( m_unitMax < 3*NUM_UNITS_TO_SAMPLE )
213 {
214 // in this case, full calculations are faster and more correct than
215 // guessing
216 sizeTotal = GetUnitsSize(0, m_unitMax);
217 }
218 else // too many units to calculate exactly
219 {
220 // look at some units in the beginning/middle/end
221 sizeTotal =
222 GetUnitsSize(0, NUM_UNITS_TO_SAMPLE) +
223 GetUnitsSize(m_unitMax - NUM_UNITS_TO_SAMPLE,
224 m_unitMax) +
225 GetUnitsSize(m_unitMax/2 - NUM_UNITS_TO_SAMPLE/2,
226 m_unitMax/2 + NUM_UNITS_TO_SAMPLE/2);
227
228 // use the height of the units we looked as the average
229 sizeTotal = (wxCoord)
230 (((float)sizeTotal / (3*NUM_UNITS_TO_SAMPLE)) * m_unitMax);
231 }
232
233 return sizeTotal;
234 }
235
236 wxCoord wxVarScrollHelperBase::GetUnitsSize(size_t unitMin, size_t unitMax) const
237 {
238 if ( unitMin == unitMax )
239 return 0;
240 else if ( unitMin > unitMax )
241 return -GetUnitsSize(unitMax, unitMin);
242 //else: unitMin < unitMax
243
244 // let the user code know that we're going to need all these units
245 OnGetUnitsSizeHint(unitMin, unitMax);
246
247 // sum up their sizes
248 wxCoord size = 0;
249 for ( size_t unit = unitMin; unit < unitMax; ++unit )
250 {
251 size += OnGetUnitSize(unit);
252 }
253
254 return size;
255 }
256
257 size_t wxVarScrollHelperBase::FindFirstVisibleFromLast(size_t unitLast, bool full) const
258 {
259 const wxCoord sWindow = GetOrientationTargetSize();
260
261 // go upwards until we arrive at a unit such that unitLast is not visible
262 // any more when it is shown
263 size_t unitFirst = unitLast;
264 wxCoord s = 0;
265 for ( ;; )
266 {
267 s += OnGetUnitSize(unitFirst);
268
269 if ( s > sWindow )
270 {
271 // for this unit to be fully visible we need to go one unit
272 // down, but if it is enough for it to be only partly visible then
273 // this unit will do as well
274 if ( full )
275 {
276 ++unitFirst;
277 }
278
279 break;
280 }
281
282 if ( !unitFirst )
283 break;
284
285 --unitFirst;
286 }
287
288 return unitFirst;
289 }
290
291 size_t wxVarScrollHelperBase::GetNewScrollPosition(wxScrollWinEvent& event) const
292 {
293 wxEventType evtType = event.GetEventType();
294
295 if ( evtType == wxEVT_SCROLLWIN_TOP )
296 {
297 return 0;
298 }
299 else if ( evtType == wxEVT_SCROLLWIN_BOTTOM )
300 {
301 return m_unitMax;
302 }
303 else if ( evtType == wxEVT_SCROLLWIN_LINEUP )
304 {
305 return m_unitFirst ? m_unitFirst - 1 : 0;
306 }
307 else if ( evtType == wxEVT_SCROLLWIN_LINEDOWN )
308 {
309 return m_unitFirst + 1;
310 }
311 else if ( evtType == wxEVT_SCROLLWIN_PAGEUP )
312 {
313 // Page up should do at least as much as line up.
314 return wxMin(FindFirstVisibleFromLast(m_unitFirst),
315 m_unitFirst ? m_unitFirst - 1 : 0);
316 }
317 else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
318 {
319 // And page down should do at least as much as line down.
320 if ( GetVisibleEnd() )
321 return wxMax(GetVisibleEnd() - 1, m_unitFirst + 1);
322 else
323 return wxMax(GetVisibleEnd(), m_unitFirst + 1);
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 behaviour 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 behaviour 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