1 /////////////////////////////////////////////////////////////////////////////
2 // Name: include/wx/vscroll.h
3 // Purpose: Variable scrolled windows (wx[V/H/HV]ScrolledWindow)
4 // Author: Vadim Zeitlin
5 // Modified by: Brad Anderson, Bryan Petty
8 // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_VSCROLL_H_
13 #define _WX_VSCROLL_H_
16 #include "wx/position.h"
18 class WXDLLEXPORT wxVarScrollHelperEvtHandler
;
21 // Using the same techniques as the wxScrolledWindow class |
22 // hierarchy, the wx[V/H/HV]ScrolledWindow classes are slightly |
23 // more complex (compare with the diagram outlined in |
24 // scrolwin.h) for the purpose of reducing code duplication |
25 // through the use of mix-in classes. |
27 // wxVarScrollHelperBase |
31 // wxVarHScrollHelper wxVarVScrollHelper |
35 // | wxVarHVScrollHelper | |
38 // | wxPanel | wxVarVScrollLegacyAdaptor |
40 // | / \ `-----|----------. | |
44 // wxHScrolledWindow \ | wxVScrolledWindow |
46 // wxHVScrolledWindow |
49 // Border added to suppress GCC multi-line comment warnings ->|
52 // ===========================================================================
53 // wxVarScrollHelperBase
54 // ===========================================================================
56 // Provides all base common scroll calculations needed for either orientation,
57 // automatic scrollbar functionality, saved scroll positions, functionality
58 // for changing the target window to be scrolled, as well as defining all
59 // required virtual functions that need to be implemented for any orientation
62 class WXDLLEXPORT wxVarScrollHelperBase
65 // constructors and such
66 // ---------------------
68 wxVarScrollHelperBase(wxWindow
*winToScroll
);
69 virtual ~wxVarScrollHelperBase();
74 // with physical scrolling on, the device origin is changed properly when
75 // a wxPaintDC is prepared, children are actually moved and laid out
76 // properly, and the contents of the window (pixels) are actually moved
77 void EnablePhysicalScrolling(bool scrolling
= true)
78 { m_physicalScrolling
= scrolling
; }
80 // wxNOT_FOUND if none, i.e. if it is below the last item
81 virtual int HitTest(wxCoord coord
) const;
83 // recalculate all our parameters and redisplay all units
84 virtual void RefreshAll();
89 // get the first currently visible unit
90 size_t GetVisibleBegin() const { return m_unitFirst
; }
92 // get the last currently visible unit
93 size_t GetVisibleEnd() const
94 { return m_unitFirst
+ m_nUnitsVisible
; }
96 // is this unit currently visible?
97 bool IsVisible(size_t unit
) const
98 { return unit
>= m_unitFirst
&& unit
< GetVisibleEnd(); }
100 // translate between scrolled and unscrolled coordinates
101 int CalcScrolledPosition(int coord
) const
102 { return DoCalcScrolledPosition(coord
); }
103 int CalcUnscrolledPosition(int coord
) const
104 { return DoCalcUnscrolledPosition(coord
); }
106 virtual int DoCalcScrolledPosition(int coord
) const;
107 virtual int DoCalcUnscrolledPosition(int coord
) const;
109 // update the thumb size shown by the scrollbar
110 virtual void UpdateScrollbar();
111 void RemoveScrollbar();
113 // Normally the wxScrolledWindow will scroll itself, but in some rare
114 // occasions you might want it to scroll [part of] another window (e.g. a
115 // child of it in order to scroll only a portion the area between the
116 // scrollbars (spreadsheet: only cell area will move).
117 virtual void SetTargetWindow(wxWindow
*target
);
118 virtual wxWindow
*GetTargetWindow() const { return m_targetWindow
; }
120 // Override this function to draw the graphic (or just process EVT_PAINT)
121 //virtual void OnDraw(wxDC& WXUNUSED(dc)) { }
123 // change the DC origin according to the scroll position. To properly
124 // forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER()
126 virtual void DoPrepareDC(wxDC
& dc
);
128 // the methods to be called from the window event handlers
129 void HandleOnScroll(wxScrollWinEvent
& event
);
130 void HandleOnSize(wxSizeEvent
& event
);
132 void HandleOnMouseWheel(wxMouseEvent
& event
);
133 #endif // wxUSE_MOUSEWHEEL
135 // these functions must be overidden in the derived class to return
136 // orientation specific data (e.g. the width for vertically scrolling
137 // derivatives in the case of GetOrientationTargetSize())
138 virtual int GetOrientationTargetSize() const = 0;
139 virtual int GetNonOrientationTargetSize() const = 0;
140 virtual wxOrientation
GetOrientation() const = 0;
143 // all *Unit* functions are protected to be exposed by
144 // wxVarScrollHelperBase implementations (with appropriate names)
146 // get the number of units this window contains (previously set by
148 size_t GetUnitCount() const { return m_unitMax
; }
150 // set the number of units the helper contains: the derived class must
151 // provide the sizes for all units with indices up to the one given here
152 // in its OnGetUnitSize()
153 void SetUnitCount(size_t count
);
155 // redraw the specified unit
156 virtual void RefreshUnit(size_t unit
);
158 // redraw all units in the specified range (inclusive)
159 virtual void RefreshUnits(size_t from
, size_t to
);
161 // scroll to the specified unit: it will become the first visible unit in
164 // return true if we scrolled the window, false if nothing was done
165 bool DoScrollToUnit(size_t unit
);
167 // scroll by the specified number of units/pages
168 virtual bool DoScrollUnits(int units
);
169 virtual bool DoScrollPages(int pages
);
171 // this function must be overridden in the derived class and it should
172 // return the size of the given unit in pixels
173 virtual wxCoord
OnGetUnitSize(size_t n
) const = 0;
175 // this function doesn't have to be overridden but it may be useful to do
176 // it if calculating the units' sizes is a relatively expensive operation
177 // as it gives the user code a possibility to calculate several of them at
180 // OnGetUnitsSizeHint() is normally called just before OnGetUnitSize() but
181 // you shouldn't rely on the latter being called for all units in the
182 // interval specified here. It is also possible that OnGetUnitHeight() will
183 // be called for the units outside of this interval, so this is really just
184 // a hint, not a promise.
186 // finally note that unitMin is inclusive, while unitMax is exclusive, as
188 virtual void OnGetUnitsSizeHint(size_t WXUNUSED(unitMin
),
189 size_t WXUNUSED(unitMax
)) const
192 // when the number of units changes, we try to estimate the total size
193 // of all units which is a rather expensive operation in terms of unit
194 // access, so if the user code may estimate the average size
195 // better/faster than we do, it should override this function to implement
198 // this function should return the best guess for the total size it may
200 virtual wxCoord
EstimateTotalSize() const { return DoEstimateTotalSize(); }
202 wxCoord
DoEstimateTotalSize() const;
204 // find the index of the unit we need to show to fit the specified unit on
205 // the opposite side either fully or partially (depending on fullyVisible)
206 size_t FindFirstVisibleFromLast(size_t last
,
207 bool fullyVisible
= false) const;
209 // get the total size of the units between unitMin (inclusive) and
210 // unitMax (exclusive)
211 wxCoord
GetUnitsSize(size_t unitMin
, size_t unitMax
) const;
213 // get the offset of the first visible unit
214 wxCoord
GetScrollOffset() const
215 { return GetUnitsSize(0, GetVisibleBegin()); }
217 // get the size of the target window
218 wxSize
GetTargetSize() const { return m_targetWindow
->GetClientSize(); }
220 void GetTargetSize(int *w
, int *h
)
222 wxSize size
= GetTargetSize();
229 // calculate the new scroll position based on scroll event type
230 size_t GetNewScrollPosition(wxScrollWinEvent
& event
) const;
232 // replacement implementation of wxWindow::Layout virtual method. To
233 // properly forward calls to wxWindow::Layout use
234 // WX_FORWARD_TO_SCROLL_HELPER() derived class
238 // queue mac window update after handling scroll event
239 virtual void UpdateMacScrollWindow() = 0;
242 // change the target window
243 void DoSetTargetWindow(wxWindow
*target
);
245 // delete the event handler we installed
246 void DeleteEvtHandler();
248 // helper function abstracting the orientation test: with vertical
249 // orientation, it assigns the first value to x and the second one to y,
250 // with horizontal orientation it reverses them, i.e. the first value is
251 // assigned to y and the second one to x
252 void AssignOrient(wxCoord
& x
, wxCoord
& y
, wxCoord first
, wxCoord second
);
254 // similar to "oriented assignment" above but does "oriented increment":
255 // for vertical orientation, y is incremented by the given value and x if
256 // left unchanged, for horizontal orientation x is incremented
257 void IncOrient(wxCoord
& x
, wxCoord
& y
, wxCoord inc
);
261 // the window that receives the scroll events and the window to actually
262 // scroll, respectively
266 // the total number of (logical) units
269 // the total (estimated) size
272 // the first currently visible unit
275 // the number of currently visible units (including the last, possibly only
276 // partly, visible one)
277 size_t m_nUnitsVisible
;
279 // accumulated mouse wheel rotation
281 int m_sumWheelRotation
;
284 // do child scrolling (used in DoPrepareDC())
285 bool m_physicalScrolling
;
287 // handler injected into target window to forward some useful events to us
288 wxVarScrollHelperEvtHandler
*m_handler
;
293 // ===========================================================================
294 // wxVarVScrollHelper
295 // ===========================================================================
297 // Provides public API functions targeted for vertical-specific scrolling,
298 // wrapping the functionality of wxVarScrollHelperBase.
300 class WXDLLEXPORT wxVarVScrollHelper
: public wxVarScrollHelperBase
303 // constructors and such
304 // ---------------------
306 // ctor must be given the associated window
307 wxVarVScrollHelper(wxWindow
*winToScroll
)
308 : wxVarScrollHelperBase(winToScroll
)
314 void SetRowCount(size_t rowCount
) { SetUnitCount(rowCount
); }
315 bool ScrollToRow(size_t row
) { return DoScrollToUnit(row
); }
317 virtual bool ScrollRows(int rows
)
318 { return DoScrollUnits(rows
); }
319 virtual bool ScrollRowPages(int pages
)
320 { return DoScrollPages(pages
); }
322 virtual void RefreshRow(size_t row
)
323 { RefreshUnit(row
); }
324 virtual void RefreshRows(size_t from
, size_t to
)
325 { RefreshUnits(from
, to
); }
327 virtual int HitTest(wxCoord y
) const
328 { return wxVarScrollHelperBase::HitTest(y
); }
332 size_t GetRowCount() const { return GetUnitCount(); }
333 size_t GetVisibleRowsBegin() const { return GetVisibleBegin(); }
334 size_t GetVisibleRowsEnd() const { return GetVisibleEnd(); }
335 bool IsRowVisible(size_t row
) const { return IsVisible(row
); }
337 virtual int GetOrientationTargetSize() const
338 { return GetTargetWindow()->GetClientSize().y
; }
339 virtual int GetNonOrientationTargetSize() const
340 { return GetTargetWindow()->GetClientSize().x
; }
341 virtual wxOrientation
GetOrientation() const { return wxVERTICAL
; }
344 // this function must be overridden in the derived class and it should
345 // return the size of the given row in pixels
346 virtual wxCoord
OnGetRowHeight(size_t n
) const = 0;
347 wxCoord
OnGetUnitSize(size_t n
) const { return OnGetRowHeight(n
); }
349 virtual void OnGetRowsHeightHint(size_t WXUNUSED(rowMin
),
350 size_t WXUNUSED(rowMax
)) const { }
352 // forward calls to OnGetRowsHeightHint()
353 virtual void OnGetUnitsSizeHint(size_t unitMin
, size_t unitMax
) const
354 { return OnGetRowsHeightHint(unitMin
, unitMax
); }
356 // again, if not overridden, it will fall back on default method
357 virtual wxCoord
EstimateTotalHeight() const
358 { return DoEstimateTotalSize(); }
360 // forward calls to EstimateTotalHeight()
361 virtual wxCoord
EstimateTotalSize() const { return EstimateTotalHeight(); }
363 wxCoord
GetRowsHeight(size_t rowMin
, size_t rowMax
) const
364 { return GetUnitsSize(rowMin
, rowMax
); }
369 // ===========================================================================
370 // wxVarHScrollHelper
371 // ===========================================================================
373 // Provides public API functions targeted for horizontal-specific scrolling,
374 // wrapping the functionality of wxVarScrollHelperBase.
376 class WXDLLEXPORT wxVarHScrollHelper
: public wxVarScrollHelperBase
379 // constructors and such
380 // ---------------------
382 // ctor must be given the associated window
383 wxVarHScrollHelper(wxWindow
*winToScroll
)
384 : wxVarScrollHelperBase(winToScroll
)
390 void SetColumnCount(size_t columnCount
)
391 { SetUnitCount(columnCount
); }
393 bool ScrollToColumn(size_t column
)
394 { return DoScrollToUnit(column
); }
395 virtual bool ScrollColumns(int columns
)
396 { return DoScrollUnits(columns
); }
397 virtual bool ScrollColumnPages(int pages
)
398 { return DoScrollPages(pages
); }
400 virtual void RefreshColumn(size_t column
)
401 { RefreshUnit(column
); }
402 virtual void RefreshColumns(size_t from
, size_t to
)
403 { RefreshUnits(from
, to
); }
404 virtual int HitTest(wxCoord x
) const
405 { return wxVarScrollHelperBase::HitTest(x
); }
409 size_t GetColumnCount() const
410 { return GetUnitCount(); }
411 size_t GetVisibleColumnsBegin() const
412 { return GetVisibleBegin(); }
413 size_t GetVisibleColumnsEnd() const
414 { return GetVisibleEnd(); }
415 bool IsColumnVisible(size_t column
) const
416 { return IsVisible(column
); }
419 virtual int GetOrientationTargetSize() const
420 { return GetTargetWindow()->GetClientSize().x
; }
421 virtual int GetNonOrientationTargetSize() const
422 { return GetTargetWindow()->GetClientSize().y
; }
423 virtual wxOrientation
GetOrientation() const { return wxHORIZONTAL
; }
426 // this function must be overridden in the derived class and it should
427 // return the size of the given column in pixels
428 virtual wxCoord
OnGetColumnWidth(size_t n
) const = 0;
429 wxCoord
OnGetUnitSize(size_t n
) const { return OnGetColumnWidth(n
); }
431 virtual void OnGetColumnsWidthHint(size_t WXUNUSED(columnMin
),
432 size_t WXUNUSED(columnMax
)) const
435 // forward calls to OnGetColumnsWidthHint()
436 virtual void OnGetUnitsSizeHint(size_t unitMin
, size_t unitMax
) const
437 { return OnGetColumnsWidthHint(unitMin
, unitMax
); }
439 // again, if not overridden, it will fall back on default method
440 virtual wxCoord
EstimateTotalWidth() const { return DoEstimateTotalSize(); }
442 // forward calls to EstimateTotalWidth()
443 virtual wxCoord
EstimateTotalSize() const { return EstimateTotalWidth(); }
445 wxCoord
GetColumnsWidth(size_t columnMin
, size_t columnMax
) const
446 { return GetUnitsSize(columnMin
, columnMax
); }
451 // ===========================================================================
452 // wxVarHVScrollHelper
453 // ===========================================================================
455 // Provides public API functions targeted at functions with similar names in
456 // both wxVScrollHelper and wxHScrollHelper so class scope doesn't need to be
457 // specified (since we are using multiple inheritance). It also provides
458 // functions to make changing values for both orientations at the same time
461 class WXDLLEXPORT wxVarHVScrollHelper
: public wxVarVScrollHelper
,
462 public wxVarHScrollHelper
465 // constructors and such
466 // ---------------------
468 // ctor must be given the associated window
469 wxVarHVScrollHelper(wxWindow
*winToScroll
)
470 : wxVarVScrollHelper(winToScroll
), wxVarHScrollHelper(winToScroll
) { }
475 // set the number of units the window contains for each axis: the derived
476 // class must provide the widths and heights for all units with indices up
477 // to each of the one given here in its OnGetColumnWidth() and
479 void SetRowColumnCount(size_t rowCount
, size_t columnCount
);
482 // with physical scrolling on, the device origin is changed properly when
483 // a wxPaintDC is prepared, children are actually moved and laid out
484 // properly, and the contents of the window (pixels) are actually moved
485 void EnablePhysicalScrolling(bool vscrolling
= true, bool hscrolling
= true)
487 wxVarVScrollHelper::EnablePhysicalScrolling(vscrolling
);
488 wxVarHScrollHelper::EnablePhysicalScrolling(hscrolling
);
491 // scroll to the specified row/column: it will become the first visible
492 // cell in the window
494 // return true if we scrolled the window, false if nothing was done
495 bool ScrollToRowColumn(size_t row
, size_t column
);
496 bool ScrollToRowColumn(const wxPosition
&pos
)
497 { return ScrollToRowColumn(pos
.GetRow(), pos
.GetColumn()); }
499 // redraw the specified cell
500 virtual void RefreshRowColumn(size_t row
, size_t column
);
501 virtual void RefreshRowColumn(const wxPosition
&pos
)
502 { RefreshRowColumn(pos
.GetRow(), pos
.GetColumn()); }
504 // redraw the specified regions (inclusive). If the target window for
505 // both orientations is the same the rectangle of cells is refreshed; if
506 // the target windows differ the entire client size opposite the
507 // orientation direction is refreshed between the specified limits
508 virtual void RefreshRowsColumns(size_t fromRow
, size_t toRow
,
509 size_t fromColumn
, size_t toColumn
);
510 virtual void RefreshRowsColumns(const wxPosition
& from
,
511 const wxPosition
& to
)
513 RefreshRowsColumns(from
.GetRow(), to
.GetRow(),
514 from
.GetColumn(), to
.GetColumn());
517 // Override wxPanel::HitTest to use our version
518 virtual wxPosition
HitTest(wxCoord x
, wxCoord y
) const;
519 virtual wxPosition
HitTest(const wxPoint
&pos
) const
520 { return HitTest(pos
.x
, pos
.y
); }
522 // change the DC origin according to the scroll position. To properly
523 // forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER()
524 // derived class. We use this version to call both base classes'
526 virtual void DoPrepareDC(wxDC
& dc
);
528 // replacement implementation of wxWindow::Layout virtual method. To
529 // properly forward calls to wxWindow::Layout use
530 // WX_FORWARD_TO_SCROLL_HELPER() derived class. We use this version to
531 // call both base classes' ScrollLayout()
537 // get the number of units this window contains (previously set by
538 // Set[Column/Row/RowColumn/Unit]Count())
539 wxSize
GetRowColumnCount() const;
541 // get the first currently visible units
542 wxPosition
GetVisibleBegin() const;
543 wxPosition
GetVisibleEnd() const;
545 // is this cell currently visible?
546 bool IsVisible(size_t row
, size_t column
) const;
547 bool IsVisible(const wxPosition
&pos
) const
548 { return IsVisible(pos
.GetRow(), pos
.GetColumn()); }
553 #if WXWIN_COMPATIBILITY_2_8
555 // ===========================================================================
556 // wxVarVScrollLegacyAdaptor
557 // ===========================================================================
559 // Provides backwards compatible API for applications originally built using
560 // wxVScrolledWindow in 2.6 or 2.8. Originally, wxVScrolledWindow referred
561 // to scrolling "lines". We use "units" in wxVarScrollHelperBase to avoid
562 // implying any orientation (since the functions are used for both horizontal
563 // and vertical scrolling in derived classes). And in the new
564 // wxVScrolledWindow and wxHScrolledWindow classes, we refer to them as
565 // "rows" and "columns", respectively. This is to help clear some confusion
566 // in not only those classes, but also in wxHVScrolledWindow where functions
567 // are inherited from both.
569 class WXDLLEXPORT wxVarVScrollLegacyAdaptor
: public wxVarVScrollHelper
572 // constructors and such
573 // ---------------------
574 wxVarVScrollLegacyAdaptor(wxWindow
*winToScroll
)
575 : wxVarVScrollHelper(winToScroll
)
582 // this is the same as GetVisibleRowsBegin(), exists to match
583 // GetLastVisibleLine() and for backwards compatibility only
584 size_t GetFirstVisibleLine() const { return GetVisibleRowsBegin(); }
586 // get the last currently visible line
588 // this function is unsafe as it returns (size_t)-1 (i.e. a huge positive
589 // number) if the control is empty, use GetVisibleRowsEnd() instead, this
590 // one is kept for backwards compatibility
591 size_t GetLastVisibleLine() const { return GetVisibleRowsEnd() - 1; }
593 // "line" to "unit" compatibility functions
594 // ----------------------------------------
596 // get the number of lines this window contains (set by SetLineCount())
597 size_t GetLineCount() const { return GetRowCount(); }
599 // set the number of lines the helper contains: the derived class must
600 // provide the sizes for all lines with indices up to the one given here
601 // in its OnGetLineHeight()
602 void SetLineCount(size_t count
) { SetRowCount(count
); }
604 // redraw the specified line
605 virtual void RefreshLine(size_t line
) { RefreshRow(line
); }
607 // redraw all lines in the specified range (inclusive)
608 virtual void RefreshLines(size_t from
, size_t to
) { RefreshRows(from
, to
); }
610 // scroll to the specified line: it will become the first visible line in
613 // return true if we scrolled the window, false if nothing was done
614 bool ScrollToLine(size_t line
) { return ScrollToRow(line
); }
616 // scroll by the specified number of lines/pages
617 virtual bool ScrollLines(int lines
) { return ScrollRows(lines
); }
618 virtual bool ScrollPages(int pages
) { return ScrollRowPages(pages
); }
621 // unless the code has been updated to override OnGetRowHeight() instead,
622 // this function must be overridden in the derived class and it should
623 // return the height of the given row in pixels
624 virtual wxCoord
OnGetLineHeight(size_t WXUNUSED(n
)) const
626 wxFAIL_MSG( _T("must be overridden if OnGetRowHeight() isn't!") );
631 // forwards the calls from base class pure virtual function to pure virtual
632 // OnGetLineHeight instead (backwards compatible name)
633 // note that we don't need to forward OnGetUnitSize() as it is already
634 // forwarded to OnGetRowHeight() in wxVarVScrollHelper
635 virtual wxCoord
OnGetRowHeight(size_t n
) const
636 { return OnGetLineHeight(n
); }
638 // this function doesn't have to be overridden but it may be useful to do
639 // it if calculating the lines heights is a relatively expensive operation
640 // as it gives the user code a possibility to calculate several of them at
643 // OnGetLinesHint() is normally called just before OnGetLineHeight() but you
644 // shouldn't rely on the latter being called for all lines in the interval
645 // specified here. It is also possible that OnGetLineHeight() will be
646 // called for the lines outside of this interval, so this is really just a
647 // hint, not a promise.
649 // finally note that lineMin is inclusive, while lineMax is exclusive, as
651 virtual void OnGetLinesHint(size_t WXUNUSED(lineMin
),
652 size_t WXUNUSED(lineMax
)) const { }
654 // forwards the calls from base class pure virtual function to pure virtual
655 // OnGetLinesHint instead (backwards compatible name)
656 void OnGetRowsHeightHint(size_t rowMin
, size_t rowMax
) const
657 { return OnGetLinesHint(rowMin
, rowMax
); }
660 // get the total height of the lines between lineMin (inclusive) and
661 // lineMax (exclusive)
662 wxCoord
GetLinesHeight(size_t lineMin
, size_t lineMax
) const
663 { return GetRowsHeight(lineMin
, lineMax
); }
666 #else // !WXWIN_COMPATIBILITY_2_8
668 // shortcut to avoid checking compatibility modes later
669 // remove this and all references to wxVarVScrollLegacyAdaptor once
670 // wxWidgets 2.6 and 2.8 compatibility is removed
671 typedef wxVarVScrollHelper wxVarVScrollLegacyAdaptor
;
673 #endif // WXWIN_COMPATIBILITY_2_8/!WXWIN_COMPATIBILITY_2_8
676 // this macro must be used in declaration of wxVarScrollHelperBase-derived
678 #define WX_FORWARD_TO_VAR_SCROLL_HELPER() \
680 virtual void PrepareDC(wxDC& dc) { DoPrepareDC(dc); } \
681 virtual bool Layout() { return ScrollLayout(); }
685 // ===========================================================================
687 // ===========================================================================
689 // In the name of this class, "V" may stand for "variable" because it can be
690 // used for scrolling rows of variable heights; "virtual", because it is not
691 // necessary to know the heights of all rows in advance -- only those which
692 // are shown on the screen need to be measured; or even "vertical", because
693 // this class only supports scrolling vertically.
695 // In any case, this is a generalization of the wxScrolledWindow class which
696 // can be only used when all rows have the same heights. It lacks some other
697 // wxScrolledWindow features however, notably it can't scroll only a rectangle
698 // of the window and not its entire client area.
700 class WXDLLEXPORT wxVScrolledWindow
: public wxPanel
,
701 public wxVarVScrollLegacyAdaptor
704 // constructors and such
705 // ---------------------
707 // default ctor, you must call Create() later
708 wxVScrolledWindow() : wxVarVScrollLegacyAdaptor(this) { }
710 // normal ctor, no need to call Create() after this one
712 // note that wxVSCROLL is always automatically added to our style, there is
713 // no need to specify it explicitly
714 wxVScrolledWindow(wxWindow
*parent
,
715 wxWindowID id
= wxID_ANY
,
716 const wxPoint
& pos
= wxDefaultPosition
,
717 const wxSize
& size
= wxDefaultSize
,
719 const wxString
& name
= wxPanelNameStr
)
720 : wxVarVScrollLegacyAdaptor(this)
722 (void)Create(parent
, id
, pos
, size
, style
, name
);
725 // same as the previous ctor but returns status code: true if ok
727 // just as with the ctor above, wxVSCROLL style is always used, there is no
728 // need to specify it
729 bool Create(wxWindow
*parent
,
730 wxWindowID id
= wxID_ANY
,
731 const wxPoint
& pos
= wxDefaultPosition
,
732 const wxSize
& size
= wxDefaultSize
,
734 const wxString
& name
= wxPanelNameStr
)
736 return wxPanel::Create(parent
, id
, pos
, size
, style
| wxVSCROLL
, name
);
739 // Make sure we prefer our version of HitTest rather than wxWindow's
740 int HitTest(wxCoord
WXUNUSED(x
), wxCoord y
) const
741 { return wxVarVScrollHelper::HitTest(y
); }
742 int HitTest(const wxPoint
& pt
) const
743 { return HitTest(pt
.x
, pt
.y
); }
745 WX_FORWARD_TO_VAR_SCROLL_HELPER()
749 virtual void UpdateMacScrollWindow() { Update(); }
753 DECLARE_NO_COPY_CLASS(wxVScrolledWindow
)
754 DECLARE_ABSTRACT_CLASS(wxVScrolledWindow
)
759 // ===========================================================================
761 // ===========================================================================
763 // In the name of this class, "H" stands for "horizontal" because it can be
764 // used for scrolling columns of variable widths. It is not necessary to know
765 // the widths of all columns in advance -- only those which are shown on the
766 // screen need to be measured.
768 // This is a generalization of the wxScrolledWindow class which can be only
769 // used when all columns have the same width. It lacks some other
770 // wxScrolledWindow features however, notably it can't scroll only a rectangle
771 // of the window and not its entire client area.
773 class WXDLLEXPORT wxHScrolledWindow
: public wxPanel
,
774 public wxVarHScrollHelper
777 // constructors and such
778 // ---------------------
780 // default ctor, you must call Create() later
781 wxHScrolledWindow() : wxVarHScrollHelper(this) { }
783 // normal ctor, no need to call Create() after this one
785 // note that wxHSCROLL is always automatically added to our style, there is
786 // no need to specify it explicitly
787 wxHScrolledWindow(wxWindow
*parent
,
788 wxWindowID id
= wxID_ANY
,
789 const wxPoint
& pos
= wxDefaultPosition
,
790 const wxSize
& size
= wxDefaultSize
,
792 const wxString
& name
= wxPanelNameStr
)
793 : wxVarHScrollHelper(this)
795 (void)Create(parent
, id
, pos
, size
, style
, name
);
798 // same as the previous ctor but returns status code: true if ok
800 // just as with the ctor above, wxHSCROLL style is always used, there is no
801 // need to specify it
802 bool Create(wxWindow
*parent
,
803 wxWindowID id
= wxID_ANY
,
804 const wxPoint
& pos
= wxDefaultPosition
,
805 const wxSize
& size
= wxDefaultSize
,
807 const wxString
& name
= wxPanelNameStr
)
809 return wxPanel::Create(parent
, id
, pos
, size
, style
| wxHSCROLL
, name
);
812 // Make sure we prefer our version of HitTest rather than wxWindow's
813 int HitTest(wxCoord x
, wxCoord
WXUNUSED(y
)) const
814 { return wxVarHScrollHelper::HitTest(x
); }
815 int HitTest(const wxPoint
& pt
) const
816 { return HitTest(pt
.x
, pt
.y
); }
818 WX_FORWARD_TO_VAR_SCROLL_HELPER()
822 virtual void UpdateMacScrollWindow() { Update(); }
826 DECLARE_NO_COPY_CLASS(wxHScrolledWindow
)
827 DECLARE_ABSTRACT_CLASS(wxHScrolledWindow
)
832 // ===========================================================================
833 // wxHVScrolledWindow
834 // ===========================================================================
836 // This window inherits all functionality of both vertical and horizontal
837 // scrolled windows automatically handling everything needed to scroll both
838 // axis simultaneously.
840 class WXDLLEXPORT wxHVScrolledWindow
: public wxPanel
,
841 public wxVarHVScrollHelper
844 // constructors and such
845 // ---------------------
847 // default ctor, you must call Create() later
850 wxVarHVScrollHelper(this) { }
852 // normal ctor, no need to call Create() after this one
854 // note that wxVSCROLL and wxHSCROLL are always automatically added to our
855 // style, there is no need to specify them explicitly
856 wxHVScrolledWindow(wxWindow
*parent
,
857 wxWindowID id
= wxID_ANY
,
858 const wxPoint
& pos
= wxDefaultPosition
,
859 const wxSize
& size
= wxDefaultSize
,
861 const wxString
& name
= wxPanelNameStr
)
863 wxVarHVScrollHelper(this)
865 (void)Create(parent
, id
, pos
, size
, style
, name
);
868 // same as the previous ctor but returns status code: true if ok
870 // just as with the ctor above, wxVSCROLL and wxHSCROLL styles are always
871 // used, there is no need to specify them
872 bool Create(wxWindow
*parent
,
873 wxWindowID id
= wxID_ANY
,
874 const wxPoint
& pos
= wxDefaultPosition
,
875 const wxSize
& size
= wxDefaultSize
,
877 const wxString
& name
= wxPanelNameStr
)
879 return wxPanel::Create(parent
, id
, pos
, size
,
880 style
| wxVSCROLL
| wxHSCROLL
, name
);
883 // Make sure we prefer our version of HitTest rather than wxWindow's
884 wxPosition
HitTest(wxCoord x
, wxCoord y
) const
885 { return wxVarHVScrollHelper::HitTest(x
, y
); }
886 wxPosition
HitTest(const wxPoint
&pt
) const
887 { return HitTest(pt
.x
, pt
.y
); }
889 WX_FORWARD_TO_VAR_SCROLL_HELPER()
893 virtual void UpdateMacScrollWindow() { Update(); }
897 DECLARE_NO_COPY_CLASS(wxHVScrolledWindow
)
898 DECLARE_ABSTRACT_CLASS(wxHVScrolledWindow
)
901 #endif // _WX_VSCROLL_H_