X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e54c96f187f46c06bd36be8cd52b35c19884aa2b..809ca837f607b74198d5f1226a4daf84bad0b984:/interface/vscroll.h?ds=sidebyside
diff --git a/interface/vscroll.h b/interface/vscroll.h
index a9f91fcc54..c5acde34e3 100644
--- a/interface/vscroll.h
+++ b/interface/vscroll.h
@@ -7,130 +7,190 @@
/////////////////////////////////////////////////////////////////////////////
/**
- @class wxVarHScrollHelper
+ @class wxVarScrollHelperBase
@wxheader{vscroll.h}
- This class provides functions wrapping the
- wxVarScrollHelperBase class, targeted for
- horizontal-specific scrolling using wxHScrolledWindow.
+ This class provides all common base functionality for scroll calculations
+ shared among all variable scrolled window implementations as well as
+ automatic scrollbar functionality, saved scroll positions, controlling
+ target windows to be scrolled, as well as defining all required virtual
+ functions that need to be implemented for any orientation specific work.
- Like wxVarScrollHelperBase, this class is mostly only useful to those classes
- built into wxWidgets deriving from here, and this documentation is mostly
- only provided for referencing those functions provided. You will likely want
- to derive your window from wxHScrolledWindow rather than from here directly.
+ Documentation of this class is provided specifically for referencing use
+ of the functions provided by this class for use with the variable scrolled
+ windows that derive from here. You will likely want to derive your window
+ from one of the already implemented variable scrolled windows rather than
+ from wxVarScrollHelperBase directly.
@library{wxcore}
- @category{FIXME}
+ @category{miscwnd}
@see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarHScrollHelper : public wxVarScrollHelperBase
+class wxVarScrollHelperBase
{
public:
/**
- Constructor taking the target window to be scrolled by this helper class.
- This will attach scroll event handlers to the target window to catch and
- handle scroll events appropriately.
+ Constructor taking the target window to be scrolled by this helper
+ class. This will attach scroll event handlers to the target window to
+ catch and handle scroll events appropriately.
*/
- wxVarHScrollHelper(wxWindow* winToScroll);
+ wxVarScrollHelperBase(wxWindow* winToScroll);
/**
- This class forwards calls from
- wxVarScrollHelperBase::EstimateTotalSize
- to this function so derived classes can override either just the height or
- the width estimation, or just estimate both differently if desired in any
- wxHVScrolledWindow derived class.
- Please note that this function will not be called if @c EstimateTotalSize()
- is overridden in your derived class.
+ Virtual destructor for detaching scroll event handlers attached with
+ this helper class.
*/
- virtual wxCoord EstimateTotalWidth() const;
+ virtual ~wxVarScrollHelperBase();
/**
- Returns the number of columns the target window contains.
-
- @see SetColumnCount()
+ Translates the logical coordinate given to the current device
+ coordinate. For example, if the window is scrolled 10 units and each
+ scroll unit represents 10 device units (which may not be the case since
+ this class allows for variable scroll unit sizes), a call to this
+ function with a coordinate of 15 will return -85.
+
+ @see CalcUnscrolledPosition()
*/
- size_t GetColumnCount() const;
+ int CalcScrolledPosition(int coord) const;
/**
- Returns the index of the first visible column based on the scroll position.
+ Translates the device coordinate given to the corresponding logical
+ coordinate. For example, if the window is scrolled 10 units and each
+ scroll unit represents 10 device units (which may not be the case since
+ this class allows for variable scroll unit sizes), a call to this
+ function with a coordinate of 15 will return 115.
+
+ @see CalcScrolledPosition()
*/
- size_t GetVisibleColumnsBegin() const;
+ int CalcUnscrolledPosition(int coord) const;
/**
- Returns the index of the last visible column based on the scroll position. This
- includes the last column even if it is only partially visible.
+ With physical scrolling on (when this is @true), the device origin is
+ changed properly when a wxPaintDC is prepared, children are actually
+ moved and laid out properly, and the contents of the window (pixels)
+ are actually moved. When this is @false, you are responsible for
+ repainting any invalidated areas of the window yourself to account for
+ the new scroll position.
*/
- size_t GetVisibleColumnsEnd() const;
+ void EnablePhysicalScrolling(bool scrolling = true);
/**
- Returns @true if the given column is currently visible (even if only
- partially visible) or @false otherwise.
+ When the number of scroll units change, we try to estimate the total
+ size of all units when the full window size is needed (i.e. to
+ calculate the scrollbar thumb size). This is a rather expensive
+ operation in terms of unit access, so if the user code may estimate the
+ average size better or faster than we do, it should override this
+ function to implement its own logic. This function should return the
+ best guess for the total virtual window size.
+
+ @note Although returning a totally wrong value would still work, it
+ risks resulting in very strange scrollbar behaviour so this
+ function should really try to make the best guess possible.
*/
- bool IsColumnVisible(size_t column) const;
+ virtual wxCoord EstimateTotalSize() const;
/**
- This function must be overridden in the derived class, and should return the
- width of the given column in pixels.
+ This function needs to be overridden in the in the derived class to
+ return the window size with respect to the opposing orientation. If
+ this is a vertical scrolled window, it should return the height.
+
+ @see GetOrientationTargetSize()
*/
- virtual wxCoord OnGetColumnWidth(size_t column) const;
+ virtual int GetNonOrientationTargetSize() const;
/**
- This function doesn't have to be overridden but it may be useful to do so if
- calculating the columns' sizes is a relatively expensive operation as it gives
- your code a chance to calculate several of them at once and cache the result
- if necessary.
- @c OnGetColumnsWidthHint() is normally called just before
- OnGetColumnWidth() but you
- shouldn't rely on the latter being called for all columns in the interval
- specified here. It is also possible that OnGetColumnWidth() will be called for
- units outside of this interval, so this is really just a hint, not a promise.
- Finally, note that columnMin is inclusive, while columnMax is exclusive.
+ This function need to be overridden to return the orientation that this
+ helper is working with, either @c wxHORIZONTAL or @c wxVERTICAL.
*/
- virtual void OnGetColumnsWidthHint(size_t columnMin,
- size_t columnMax) const;
+ virtual wxOrientation GetOrientation() const;
+
+ /**
+ This function needs to be overridden in the in the derived class to
+ return the window size with respect to the orientation this helper is
+ working with. If this is a vertical scrolled window, it should return
+ the width.
+
+ @see GetNonOrientationTargetSize()
+ */
+ virtual int GetOrientationTargetSize() const;
+
+ /**
+ This function will return the target window this helper class is
+ currently scrolling.
+
+ @see SetTargetWindow()
+ */
+ wxWindow* GetTargetWindow() const;
+
+ /**
+ Returns the index of the first visible unit based on the scroll
+ position.
+ */
+ size_t GetVisibleBegin() const;
/**
- Triggers a refresh for just the given column's area of the window if it's
+ Returns the index of the last visible unit based on the scroll
+ position. This includes the last unit even if it is only partially
visible.
*/
- virtual void RefreshColumn(size_t column);
+ size_t GetVisibleEnd() const;
/**
- Triggers a refresh for the area between the specified range of columns given
- (inclusively).
+ Returns @true if the given scroll unit is currently visible (even if
+ only partially visible) or @false otherwise.
*/
- virtual void RefreshColumns(size_t from, size_t to);
+ bool IsVisible(size_t unit) const;
/**
- Scroll by the specified number of pages which may be positive (to scroll right)
- or negative (to scroll left).
+ This function must be overridden in the derived class, and should
+ return the size of the given unit in pixels.
*/
- virtual bool ScrollColumnPages(int pages);
+ virtual wxCoord OnGetUnitSize(size_t unit) const;
/**
- Scroll by the specified number of columns which may be positive (to scroll
- right)
- or negative (to scroll left).
- Returns @true if the window was scrolled, @false otherwise (for
- example, if we're trying to scroll right but we are already showing the last
- column).
+ This function doesn't have to be overridden but it may be useful to do
+ so if calculating the units' sizes is a relatively expensive operation
+ as it gives your code a chance to calculate several of them at once and
+ cache the result if necessary.
+
+ OnGetUnitsSizeHint() is normally called just before OnGetUnitSize() but
+ you shouldn't rely on the latter being called for all units in the
+ interval specified here. It is also possible that OnGetUnitSize() will
+ be called for units outside of this interval, so this is really just a
+ hint, not a promise.
+
+ Finally, note that @a unitMin is inclusive, while @a unitMax is
+ exclusive.
*/
- virtual bool ScrollColumns(int columns);
+ virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const;
/**
- Scroll to the specified column. It will become the first visible column in the
- window.
- Returns @true if we scrolled the window, @false if nothing was done.
+ Recalculate all parameters and repaint all units.
*/
- bool ScrollToColumn(size_t column);
+ virtual void RefreshAll();
/**
- Set the number of columns the window contains. The derived class must provide
- the widths for all columns with indices up to the one given here in it's
- OnGetColumnWidth() implementation.
+ Normally the window will scroll itself, but in some rare occasions you
+ might want it to scroll (part of) another window (e.g. a child of it in
+ order to scroll only a portion the area between the scrollbars like a
+ spreadsheet where only the cell area will move).
+
+ @see GetTargetWindow()
*/
- void SetColumnCount(size_t columnCount);
+ void SetTargetWindow(wxWindow* target);
+
+ /**
+ Update the thumb size shown by the scrollbar.
+ */
+ virtual void UpdateScrollbar();
+
+ /**
+ Returns the virtual scroll unit under the device unit given accounting
+ for scroll position or @c wxNOT_FOUND if none (i.e. if it is below the
+ last item).
+ */
+ int VirtualHitTest(wxCoord coord) const;
};
@@ -139,17 +199,17 @@ public:
@class wxVarVScrollHelper
@wxheader{vscroll.h}
- This class provides functions wrapping the
- wxVarScrollHelperBase class, targeted for
- vertical-specific scrolling using wxVScrolledWindow.
+ This class provides functions wrapping the wxVarScrollHelperBase class,
+ targeted for vertical-specific scrolling.
- Like wxVarScrollHelperBase, this class is mostly only useful to those classes
- built into wxWidgets deriving from here, and this documentation is mostly
- only provided for referencing those functions provided. You will likely want
- to derive your window from wxVScrolledWindow rather than from here directly.
+ Like wxVarScrollHelperBase, this class is mostly only useful to those
+ classes built into wxWidgets deriving from here, and this documentation is
+ mostly only provided for referencing the functions provided by this class.
+ You will likely want to derive your window from wxVScrolledWindow rather
+ than from here directly.
@library{wxcore}
- @category{FIXME}
+ @category{miscwnd}
@see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
@@ -157,38 +217,39 @@ class wxVarVScrollHelper : public wxVarScrollHelperBase
{
public:
/**
- Constructor taking the target window to be scrolled by this helper class.
- This will attach scroll event handlers to the target window to catch and
- handle scroll events appropriately.
+ Constructor taking the target window to be scrolled by this helper
+ class. This will attach scroll event handlers to the target window to
+ catch and handle scroll events appropriately.
*/
wxVarVScrollHelper(wxWindow* winToScroll);
/**
- This class forwards calls from
- wxVarScrollHelperBase::EstimateTotalSize
- to this function so derived classes can override either just the height or
- the width estimation, or just estimate both differently if desired in any
+ This class forwards calls from EstimateTotalSize() to this function so
+ derived classes can override either just the height or the width
+ estimation, or just estimate both differently if desired in any
wxHVScrolledWindow derived class.
- Please note that this function will not be called if @c EstimateTotalSize()
- is overridden in your derived class.
+
+ @note This function will not be called if EstimateTotalSize() is
+ overridden in your derived class.
*/
virtual wxCoord EstimateTotalHeight() const;
/**
Returns the number of rows the target window contains.
-
+
@see SetRowCount()
*/
size_t GetRowCount() const;
/**
- Returns the index of the first visible row based on the scroll position.
+ Returns the index of the first visible row based on the scroll
+ position.
*/
size_t GetVisibleRowsBegin() const;
/**
- Returns the index of the last visible row based on the scroll position. This
- includes the last row even if it is only partially visible.
+ Returns the index of the last visible row based on the scroll position.
+ This includes the last row even if it is only partially visible.
*/
size_t GetVisibleRowsEnd() const;
@@ -199,61 +260,70 @@ public:
bool IsRowVisible(size_t row) const;
/**
- This function must be overridden in the derived class, and should return the
- height of the given row in pixels.
+ This function must be overridden in the derived class, and should
+ return the height of the given row in pixels.
*/
virtual wxCoord OnGetRowHeight(size_t row) const;
/**
- This function doesn't have to be overridden but it may be useful to do so if
- calculating the rows' sizes is a relatively expensive operation as it gives
- your code a chance to calculate several of them at once and cache the result
- if necessary.
- @c OnGetRowsHeightHint() is normally called just before
- OnGetRowHeight() but you
- shouldn't rely on the latter being called for all rows in the interval
- specified here. It is also possible that OnGetRowHeight() will be called for
- units outside of this interval, so this is really just a hint, not a promise.
- Finally, note that rowMin is inclusive, while rowMax is exclusive.
+ This function doesn't have to be overridden but it may be useful to do
+ so if calculating the rows' sizes is a relatively expensive operation
+ as it gives your code a chance to calculate several of them at once and
+ cache the result if necessary.
+
+ OnGetRowsHeightHint() is normally called just before OnGetRowHeight()
+ but you shouldn't rely on the latter being called for all rows in the
+ interval specified here. It is also possible that OnGetRowHeight() will
+ be called for units outside of this interval, so this is really just a
+ hint, not a promise.
+
+ Finally, note that @a rowMin is inclusive, while @a rowMax is
+ exclusive.
*/
virtual void OnGetRowsHeightHint(size_t rowMin, size_t rowMax) const;
/**
- Triggers a refresh for just the given row's area of the window if it's visible.
+ Triggers a refresh for just the given row's area of the window if it's
+ visible.
*/
virtual void RefreshRow(size_t row);
/**
- Triggers a refresh for the area between the specified range of rows given
- (inclusively).
+ Triggers a refresh for the area between the specified range of rows
+ given (inclusively).
*/
virtual void RefreshRows(size_t from, size_t to);
/**
- Scroll by the specified number of pages which may be positive (to scroll down)
- or negative (to scroll up).
+ Scroll by the specified number of pages which may be positive (to
+ scroll down) or negative (to scroll up).
*/
virtual bool ScrollRowPages(int pages);
/**
- Scroll by the specified number of rows which may be positive (to scroll down)
- or negative (to scroll up).
- Returns @true if the window was scrolled, @false otherwise (for
- example, if we're trying to scroll down but we are already showing the last
- row).
+ Scroll by the specified number of rows which may be positive (to scroll
+ down) or negative (to scroll up).
+
+ @return @true if the window was scrolled, @false otherwise (for
+ example, if we're trying to scroll down but we are already
+ showing the last row).
*/
virtual bool ScrollRows(int rows);
/**
- Scroll to the specified row. It will become the first visible row in the window.
- Returns @true if we scrolled the window, @false if nothing was done.
+ Scroll to the specified row. It will become the first visible row in
+ the window.
+
+ @return @true if we scrolled the window, @false if nothing was done.
*/
bool ScrollToRow(size_t row);
/**
- Set the number of rows the window contains. The derived class must provide the
- heights for all rows with indices up to the one given here in it's
- OnGetRowHeight() implementation.
+ Set the number of rows the window contains. The derived class must
+ provide the heights for all rows with indices up to the one given here
+ in it's OnGetRowHeight() implementation.
+
+ @see GetRowCount()
*/
void SetRowCount(size_t rowCount);
};
@@ -261,378 +331,138 @@ public:
/**
- @class wxVarScrollHelperBase
+ @class wxVarHScrollHelper
@wxheader{vscroll.h}
- This class provides all common base functionality for scroll calculations
- shared among all variable scrolled window implementations as well as
- automatic scrollbar functionality, saved scroll positions, controlling
- target windows to be scrolled, as well as defining all required virtual
- functions that need to be implemented for any orientation specific work.
+ This class provides functions wrapping the wxVarScrollHelperBase class,
+ targeted for horizontal-specific scrolling.
- Documentation of this class is provided specifically for referencing use
- of the functions provided by this class for use with the variable scrolled
- windows that derive from here. You will likely want to derive your window
- from one of the already implemented variable scrolled windows rather than
- from wxVarScrollHelperBase directly.
+ Like wxVarScrollHelperBase, this class is mostly only useful to those
+ classes built into wxWidgets deriving from here, and this documentation is
+ mostly only provided for referencing the functions provided by this class.
+ You will likely want to derive your window from wxHScrolledWindow rather
+ than from here directly.
@library{wxcore}
- @category{FIXME}
+ @category{miscwnd}
@see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarScrollHelperBase
+class wxVarHScrollHelper : public wxVarScrollHelperBase
{
public:
/**
- Constructor taking the target window to be scrolled by this helper class.
- This will attach scroll event handlers to the target window to catch and
- handle scroll events appropriately.
- */
- wxVarScrollHelperBase(wxWindow* winToScroll);
-
- /**
- Virtual destructor for detaching scroll event handlers attached with this
- helper class.
+ Constructor taking the target window to be scrolled by this helper
+ class. This will attach scroll event handlers to the target window to
+ catch and handle scroll events appropriately.
*/
- ~wxVarScrollHelperBase();
-
- /**
- Translates the logical coordinate given to the current device coordinate.
- For example, if the window is scrolled 10 units and each scroll unit
- represents 10 device units (which may not be the case since this class allows
- for variable scroll unit sizes), a call to this function with a coordinate of
- 15 will return -85.
-
- @see CalcUnscrolledPosition()
- */
- int CalcScrolledPosition(int coord) const;
+ wxVarHScrollHelper(wxWindow* winToScroll);
/**
- Translates the device coordinate given to the corresponding logical
- coordinate. For example, if the window is scrolled 10 units and each scroll
- unit represents 10 device units (which may not be the case since this class
- allows for variable scroll unit sizes), a call to this function with a
- coordinate of 15 will return 115.
-
- @see CalcScrolledPosition()
- */
- int CalcUnscrolledPosition(int coord) const;
+ This class forwards calls from EstimateTotalSize() to this function so
+ derived classes can override either just the height or the width
+ estimation, or just estimate both differently if desired in any
+ wxHVScrolledWindow derived class.
- /**
- With physical scrolling on (when this is @true), the device origin is
- changed properly when a wxPaintDC is prepared,
- children are actually moved and laid out properly, and the contents of the
- window (pixels) are actually moved. When this is @false, you are
- responsible for repainting any invalidated areas of the window yourself to
- account for the new scroll position.
+ @note This function will not be called if EstimateTotalSize() is
+ overridden in your derived class.
*/
- void EnablePhysicalScrolling(bool scrolling = true);
+ virtual wxCoord EstimateTotalWidth() const;
/**
- When the number of scroll units change, we try to estimate the total size of
- all units when the full window size is needed (i.e. to calculate the scrollbar
- thumb size). This is a rather expensive operation in terms of unit access, so
- if the user code may estimate the average size better or faster than we do, it
- should override this function to implement its own logic. This function should
- return the best guess for the total virtual window size.
- Note that although returning a totally wrong value would still work, it risks
- resulting in very strange scrollbar behaviour so this function should really
- try to make the best guess possible.
- */
- virtual wxCoord EstimateTotalSize() const;
+ Returns the number of columns the target window contains.
- /**
- This function needs to be overridden in the in the derived class to return the
- window size with respect to the opposing orientation. If this is a vertical
- scrolled window, it should return the height.
-
- @see GetOrientationTargetSize()
+ @see SetColumnCount()
*/
- virtual int GetNonOrientationTargetSize() const;
+ size_t GetColumnCount() const;
/**
- This function need to be overridden to return the orientation that this helper
- is working with, either @c wxHORIZONTAL or @c wxVERTICAL.
+ Returns the index of the first visible column based on the scroll
+ position.
*/
- virtual wxOrientation GetOrientation() const;
+ size_t GetVisibleColumnsBegin() const;
/**
- This function needs to be overridden in the in the derived class to return the
- window size with respect to the orientation this helper is working with. If
- this is a vertical scrolled window, it should return the width.
-
- @see GetNonOrientationTargetSize()
+ Returns the index of the last visible column based on the scroll
+ position. This includes the last column even if it is only partially
+ visible.
*/
- virtual int GetOrientationTargetSize() const;
+ size_t GetVisibleColumnsEnd() const;
/**
- This function will return the target window this helper class is currently
- scrolling.
-
- @see SetTargetWindow()
+ Returns @true if the given column is currently visible (even if only
+ partially visible) or @false otherwise.
*/
- wxWindow* GetTargetWindow() const;
+ bool IsColumnVisible(size_t column) const;
/**
- Returns the index of the first visible unit based on the scroll position.
+ This function must be overridden in the derived class, and should
+ return the width of the given column in pixels.
*/
- size_t GetVisibleBegin() const;
+ virtual wxCoord OnGetColumnWidth(size_t column) const;
/**
- Returns the index of the last visible unit based on the scroll position. This
- includes the last unit even if it is only partially visible.
- */
- size_t GetVisibleEnd() const;
+ This function doesn't have to be overridden but it may be useful to do
+ so if calculating the columns' sizes is a relatively expensive
+ operation as it gives your code a chance to calculate several of them
+ at once and cache the result if necessary.
- /**
- Returns @true if the given scroll unit is currently visible (even if only
- partially visible) or @false otherwise.
- */
- bool IsVisible(size_t unit) const;
+ OnGetColumnsWidthHint() is normally called just before
+ OnGetColumnWidth() but you shouldn't rely on the latter being called
+ for all columns in the interval specified here. It is also possible
+ that OnGetColumnWidth() will be called for units outside of this
+ interval, so this is really just a hint, not a promise.
- /**
- This function must be overridden in the derived class, and should return the
- size of the given unit in pixels.
+ Finally, note that @a columnMin is inclusive, while @a columnMax is
+ exclusive.
*/
- virtual wxCoord OnGetUnitSize(size_t unit) const;
+ virtual void OnGetColumnsWidthHint(size_t columnMin,
+ size_t columnMax) const;
/**
- This function doesn't have to be overridden but it may be useful to do so if
- calculating the units' sizes is a relatively expensive operation as it gives
- your code a chance to calculate several of them at once and cache the result
- if necessary.
- @c OnGetUnitsSizeHint() is normally called just before
- OnGetUnitSize() but you
- shouldn't rely on the latter being called for all units in the interval
- specified here. It is also possible that OnGetUnitSize() will be called for
- units outside of this interval, so this is really just a hint, not a promise.
- Finally, note that unitMin is inclusive, while unitMax is exclusive.
+ Triggers a refresh for just the given column's area of the window if
+ it's visible.
*/
- virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const;
+ virtual void RefreshColumn(size_t column);
/**
- Recalculate all parameters and repaint all units.
+ Triggers a refresh for the area between the specified range of columns
+ given (inclusively).
*/
- virtual void RefreshAll();
+ virtual void RefreshColumns(size_t from, size_t to);
/**
- Normally the window will scroll itself, but in some rare occasions you might
- want it to scroll (part of) another window (e.g. a child of it in order to
- scroll only a portion the area between the scrollbars like a spreadsheet where
- only the cell area will move).
-
- @see GetTargetWindow()
+ Scroll by the specified number of pages which may be positive (to
+ scroll right) or negative (to scroll left).
*/
- void SetTargetWindow(wxWindow* target);
+ virtual bool ScrollColumnPages(int pages);
/**
- Update the thumb size shown by the scrollbar.
- */
- virtual void UpdateScrollbar();
+ Scroll by the specified number of columns which may be positive (to
+ scroll right) or negative (to scroll left).
- /**
- Returns the virtual scroll unit under the device unit given accounting for
- scroll position or @c wxNOT_FOUND if none (i.e. if it is below the last
- item).
+ @return @true if the window was scrolled, @false otherwise (for
+ example, if we're trying to scroll right but we are already
+ showing the last column).
*/
- int VirtualHitTest(wxCoord coord) const;
-};
-
-
-
-/**
- @class wxVScrolledWindow
- @wxheader{vscroll.h}
-
- In the name of this class, "V" may stand for "variable" because it can be
- used for scrolling rows of variable heights; "virtual", because it is not
- necessary to know the heights of all rows in advance -- only those which
- are shown on the screen need to be measured; or even "vertical", because
- this class only supports scrolling vertically.
-
- In any case, this is a generalization of the
- wxScrolledWindow class which can be only used when
- all rows have the same heights. It lacks some other wxScrolledWindow features
- however, notably it can't scroll only a rectangle of the window and not its
- entire client area.
-
- To use this class, you need to derive from it and implement the
- wxVarVScrollHelper::OnGetRowHeight pure virtual
- method. You also must call wxVarVScrollHelper::SetRowCount
- to let the base class know how many rows it should display, but from that
- moment on the scrolling is handled entirely by wxVScrolledWindow. You only
- need to draw the visible part of contents in your @c OnPaint() method as
- usual. You should use wxVarVScrollHelper::GetVisibleRowsBegin
- and wxVarVScrollHelper::GetVisibleRowsEnd to
- select the lines to display. Note that the device context origin is not shifted
- so the first visible row always appears at the point (0, 0) in physical as
- well as logical coordinates.
-
- @library{wxcore}
- @category{miscwnd}
+ virtual bool ScrollColumns(int columns);
- @see wxHScrolledWindow, wxHVScrolledWindow
-*/
-class wxVScrolledWindow : public wxPanel
-{
-public:
- //@{
/**
- This is the normal constructor, no need to call @c Create() after using this
- one.
- Note that @c wxVSCROLL is always automatically added to our style, there is
- no need to specify it explicitly.
-
- @param parent
- The parent window, must not be @NULL
- @param id
- The identifier of this window, wxID_ANY by default
- @param pos
- The initial window position
- @param size
- The initial window size
- @param style
- The window style. There are no special style bits defined for
- this class.
- @param name
- The name for this window; usually not used
- */
- wxVScrolledWindow();
- wxVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
- //@}
+ Scroll to the specified column. It will become the first visible column
+ in the window.
- /**
- Same as the @ref wxvscrolledwindow() "non-default constuctor"
- but returns status code: @true if ok, @false if the window couldn't
- be created.
- Just as with the constructor above, the @c wxVSCROLL style is always used,
- there is no need to specify it explicitly.
+ @return @true if we scrolled the window, @false if nothing was done.
*/
- bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
-
- //@{
- /**
- The following functions provide backwards compatibility for applications
- originally built using wxVScrolledWindow in 2.6 or 2.8. Originally,
- wxVScrolledWindow referred to scrolling "lines". We now use "units" in
- wxVarScrollHelperBase to avoid implying any orientation (since the functions
- are used for both horizontal and vertical scrolling in derived classes). And
- in the new wxVScrolledWindow and wxHScrolledWindow classes, we refer to them
- as "rows" and "columns", respectively. This is to help clear some confusion
- in not only those classes, but also in wxHVScrolledWindow where functions
- are inherited from both.
- You are encouraged to update any existing code using these function to use
- the new replacements mentioned below, and avoid using these functions for
- any new code as they are deprecated.
-
- Deprecated for wxVarVScrollHelper::SetRowCount.
- */
- size_t GetFirstVisibleLine();
- const size_t GetLastVisibleLine();
- const size_t GetLineCount();
- const int HitTest(wxCoord x, wxCoord y);
- const int HitTest(const wxPoint& pt);
- const virtual wxCoord OnGetLineHeight(size_t line);
- const virtual void OnGetLinesHint(size_t lineMin,
- size_t lineMax);
- const virtual void RefreshLine(size_t line);
- virtual void RefreshLines(size_t from, size_t to);
- virtual bool ScrollLines(int lines);
- virtual bool ScrollPages(int pages);
- bool ScrollToLine(size_t line);
- void SetLineCount(size_t count);
- //@}
-};
-
-
-
-/**
- @class wxHVScrolledWindow
- @wxheader{vscroll.h}
-
- This window inherits all functionality of both vertical and horizontal,
- variable scrolled windows. It automatically handles everything needed to
- scroll both axis simultaneously with both variable row heights and variable
- column widths.
-
- This is a generalization of the wxScrolledWindow
- class which can be only used when all rows and columns are the same size. It
- lacks some other wxScrolledWindow features however, notably it can't scroll
- only a rectangle of the window and not its entire client area.
-
- To use this class, you must derive from it and implement both the
- wxVarVScrollHelper::OnGetRowHeight and
- wxVarHScrollHelper::OnGetColumnWidth pure virtual
- methods to let the base class know how many rows and columns it should
- display. You also need to set the total rows and columns the window contains,
- but from that moment on the scrolling is handled entirely by
- wxHVScrolledWindow. You only need to draw the visible part of contents in
- your @c OnPaint() method as usual. You should use
- wxVarHVScrollHelper::GetVisibleBegin
- and wxVarHVScrollHelper::GetVisibleEnd to select the
- lines to display. Note that the device context origin is not shifted so the
- first visible row and column always appear at the point (0, 0) in physical
- as well as logical coordinates.
-
- @library{wxcore}
- @category{FIXME}
+ bool ScrollToColumn(size_t column);
- @see wxHScrolledWindow, wxVScrolledWindow
-*/
-class wxHVScrolledWindow : public wxPanel
-{
-public:
- //@{
/**
- This is the normal constructor, no need to call @c Create() after using this
- one.
- Note that @c wxHSCROLL and @c wxVSCROLL are always automatically added
- to our styles, there is no need to specify it explicitly.
-
- @param parent
- The parent window, must not be @NULL
- @param id
- The identifier of this window, wxID_ANY by default
- @param pos
- The initial window position
- @param size
- The initial window size
- @param style
- The window style. There are no special style bits defined for
- this class.
- @param name
- The name for this window; usually not used
- */
- wxHVScrolledWindow();
- wxHVScrolledWindow(wxWindow* parent,
- wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
- //@}
+ Set the number of columns the window contains. The derived class must
+ provide the widths for all columns with indices up to the one given
+ here in it's OnGetColumnWidth() implementation.
- /**
- Same as the @ref wxhvscrolledwindow() "non-default constuctor"
- but returns status code: @true if ok, @false if the window couldn't
- be created.
- Just as with the constructor above, the @c wxHSCROLL and @c wxVSCROLL
- styles are always used, there is no need to specify it explicitly.
+ @see GetColumnCount()
*/
- bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
+ void SetColumnCount(size_t columnCount);
};
@@ -641,71 +471,69 @@ public:
@class wxVarHVScrollHelper
@wxheader{vscroll.h}
- This class provides functions wrapping the
- wxVarHScrollHelper and
- wxVarVScrollHelper classes, targeted for
- scrolling a window in both axis using
- wxHVScrolledWindow. Since this class is also
- the join class of the horizontal and vertical scrolling functionality, it
- also addresses some wrappers that help avoid the need to specify class scope
- in your wxHVScrolledWindow-derived class when using wxVarScrollHelperBase
- functionality.
-
- Like all three of it's scroll helper base classes, this class is mostly only
- useful to those classes built into wxWidgets deriving from here, and this
- documentation is mostly only provided for referencing those functions
- provided. You will likely want to derive your window from wxHVScrolledWindow
- rather than from here directly.
+ This class provides functions wrapping the wxVarHScrollHelper and
+ wxVarVScrollHelper classes, targeted for scrolling a window in both axis.
+ Since this class is also the join class of the horizontal and vertical
+ scrolling functionality, it also addresses some wrappers that help avoid
+ the need to specify class scope in your wxHVScrolledWindow derived class
+ when using wxVarScrollHelperBase functionality.
+
+ Like all three of it's scroll helper base classes, this class is mostly
+ only useful to those classes built into wxWidgets deriving from here, and
+ this documentation is mostly only provided for referencing the functions
+ provided by this class. You will likely want to derive your window from
+ wxHVScrolledWindow rather than from here directly.
@library{wxcore}
- @category{FIXME}
+ @category{miscwnd}
@see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarHVScrollHelper : public wxVarVScrollHelper
+class wxVarHVScrollHelper : public wxVarVScrollHelper,
+ public wxVarHScrollHelper
{
public:
/**
- Constructor taking the target window to be scrolled by this helper class.
- This will attach scroll event handlers to the target window to catch and
- handle scroll events appropriately.
+ Constructor taking the target window to be scrolled by this helper
+ class. This will attach scroll event handlers to the target window to
+ catch and handle scroll events appropriately.
*/
wxVarHVScrollHelper(wxWindow* winToScroll);
/**
With physical scrolling on (when this is @true), the device origin is
- changed properly when a wxPaintDC is prepared,
- children are actually moved and laid out properly, and the contents of the
- window (pixels) are actually moved. When this is @false, you are
- responsible for repainting any invalidated areas of the window yourself to
- account for the new scroll position.
-
+ changed properly when a wxPaintDC is prepared, children are actually
+ moved and laid out properly, and the contents of the window (pixels)
+ are actually moved. When this is @false, you are responsible for
+ repainting any invalidated areas of the window yourself to account for
+ the new scroll position.
+
@param vscrolling
Specifies if physical scrolling should be turned on when scrolling
- vertically.
+ vertically.
@param hscrolling
Specifies if physical scrolling should be turned on when scrolling
- horizontally.
+ horizontally.
*/
void EnablePhysicalScrolling(bool vscrolling = true,
bool hscrolling = true);
/**
Returns the number of columns and rows the target window contains.
-
+
@see SetRowColumnCount()
*/
wxSize GetRowColumnCount() const;
/**
- Returns the index of the first visible column and row based on the current
- scroll position.
+ Returns the index of the first visible column and row based on the
+ current scroll position.
*/
wxPosition GetVisibleBegin() const;
/**
- Returns the index of the last visible column and row based on the scroll
- position. This includes any partially visible columns or rows.
+ Returns the index of the last visible column and row based on the
+ scroll position. This includes any partially visible columns or rows.
*/
wxPosition GetVisibleEnd() const;
@@ -715,13 +543,13 @@ public:
(even if only partially visible) or @false otherwise.
*/
bool IsVisible(size_t row, size_t column) const;
- const bool IsVisible(const wxPosition& pos) const;
+ bool IsVisible(const wxPosition& pos) const;
//@}
//@{
/**
- Triggers a refresh for just the area shared between the given row and column
- of the window if it is visible.
+ Triggers a refresh for just the area shared between the given row and
+ column of the window if it is visible.
*/
virtual void RefreshRowColumn(size_t row, size_t column);
virtual void RefreshRowColumn(const wxPosition& pos);
@@ -729,24 +557,23 @@ public:
//@{
/**
- Triggers a refresh for the visible area shared between all given rows and
- columns (inclusive) of the window. If the target window for both orientations
- is the same, the rectangle of cells is refreshed; if the target windows
- differ, the entire client size opposite the orientation direction is
- refreshed between the specified limits.
+ Triggers a refresh for the visible area shared between all given rows
+ and columns (inclusive) of the window. If the target window for both
+ orientations is the same, the rectangle of cells is refreshed; if the
+ target windows differ, the entire client size opposite the orientation
+ direction is refreshed between the specified limits.
*/
virtual void RefreshRowsColumns(size_t fromRow, size_t toRow,
- size_t fromColumn,
- size_t toColumn);
+ size_t fromColumn, size_t toColumn);
virtual void RefreshRowsColumns(const wxPosition& from,
const wxPosition& to);
//@}
//@{
/**
- Scroll to the specified row and column. It will become the first visible row
- and column in the window. Returns @true if we scrolled the window,
- @false if nothing was done.
+ Scroll to the specified row and column. It will become the first
+ visible row and column in the window. Returns @true if we scrolled the
+ window, @false if nothing was done.
*/
bool ScrollToRowColumn(size_t row, size_t column);
bool ScrollToRowColumn(const wxPosition& pos);
@@ -754,26 +581,152 @@ public:
/**
Set the number of rows and columns the target window will contain. The
- derived class must provide the sizes for all rows and columns with indices up
- to the ones given here in it's wxVarVScrollHelper::OnGetRowHeight
- and wxVarHScrollHelper::OnGetColumnWidth implementations,
- respectively.
+ derived class must provide the sizes for all rows and columns with
+ indices up to the ones given here in it's OnGetRowHeight() and
+ OnGetColumnWidth() implementations, respectively.
+
+ @see GetRowColumnCount()
*/
void SetRowColumnCount(size_t rowCount, size_t columnCount);
//@{
/**
- Returns the virtual scroll unit under the device unit given accounting for
- scroll position or @c wxNOT_FOUND (for the row, column, or possibly both
- values) if none.
+ Returns the virtual scroll unit under the device unit given accounting
+ for scroll position or @c wxNOT_FOUND (for the row, column, or possibly
+ both values) if none.
*/
wxPosition VirtualHitTest(wxCoord x, wxCoord y) const;
- const wxPosition VirtualHitTest(const wxPoint& pos) const;
+ wxPosition VirtualHitTest(const wxPoint& pos) const;
//@}
};
+/**
+ @class wxVScrolledWindow
+ @wxheader{vscroll.h}
+
+ In the name of this class, "V" may stand for "variable" because it can be
+ used for scrolling rows of variable heights; "virtual", because it is not
+ necessary to know the heights of all rows in advance -- only those which
+ are shown on the screen need to be measured; or even "vertical", because
+ this class only supports scrolling vertically.
+
+ In any case, this is a generalization of wxScrolled which can be only used
+ when all rows have the same heights. It lacks some other wxScrolled
+ features however, notably it can't scroll specific pixel sizes of the
+ window or its exact client area size.
+
+ To use this class, you need to derive from it and implement the
+ OnGetRowHeight() pure virtual method. You also must call SetRowCount() to
+ let the base class know how many rows it should display, but from that
+ moment on the scrolling is handled entirely by wxVScrolledWindow. You only
+ need to draw the visible part of contents in your @c OnPaint() method as
+ usual. You should use GetVisibleRowsBegin() and GetVisibleRowsEnd() to
+ select the lines to display. Note that the device context origin is not
+ shifted so the first visible row always appears at the point (0, 0) in
+ physical as well as logical coordinates.
+
+ @section wxWidgets 2.8 Compatibility Functions
+
+ The following functions provide backwards compatibility for applications
+ originally built using wxVScrolledWindow in 2.6 or 2.8. Originally,
+ wxVScrolledWindow referred to scrolling "lines". We now use "units" in
+ wxVarScrollHelperBase to avoid implying any orientation (since the
+ functions are used for both horizontal and vertical scrolling in derived
+ classes). And in the new wxVScrolledWindow and wxHScrolledWindow classes,
+ we refer to them as "rows" and "columns", respectively. This is to help
+ clear some confusion in not only those classes, but also in
+ wxHVScrolledWindow where functions are inherited from both.
+
+ You are encouraged to update any existing code using these function to use
+ the new replacements mentioned below, and avoid using these functions for
+ any new code as they are deprecated.
+
+ @beginTable
+ @row2col{ size_t %GetFirstVisibleLine() const,
+ Deprecated for GetVisibleRowsBegin(). }
+ @row2col{ size_t %GetLastVisibleLine() const,
+ Deprecated for GetVisibleRowsEnd(). This function originally had a
+ slight design flaw in that it was possible to return
+ (size_t)-1 (ie: a large positive number) if the scroll
+ position was 0 and the first line wasn't completely visible. }
+ @row2col{ size_t %GetLineCount() const,
+ Deprecated for GetRowCount(). }
+ @row2col{ int %HitTest(wxCoord x\, wxCoord y) const
+ @n int %HitTest(const wxPoint& pt) const,
+ Deprecated for VirtualHitTest(). }
+ @row2col{ virtual wxCoord %OnGetLineHeight(size_t line) const,
+ Deprecated for OnGetRowHeight(). }
+ @row2col{ virtual void %OnGetLinesHint(size_t lineMin\, size_t lineMax) const,
+ Deprecated for OnGetRowsHeightHint(). }
+ @row2col{ virtual void %RefreshLine(size_t line),
+ Deprecated for RefreshRow(). }
+ @row2col{ virtual void %RefreshLines(size_t from\, size_t to),
+ Deprecated for RefreshRows(). }
+ @row2col{ virtual bool %ScrollLines(int lines),
+ Deprecated for ScrollRows(). }
+ @row2col{ virtual bool %ScrollPages(int pages),
+ Deprecated for ScrollRowPages(). }
+ @row2col{ bool %ScrollToLine(size_t line),
+ Deprecated for ScrollToRow(). }
+ @row2col{ void %SetLineCount(size_t count),
+ Deprecated for SetRowCount(). }
+ @endTable
+
+ @library{wxcore}
+ @category{miscwnd}
+
+ @see wxHScrolledWindow, wxHVScrolledWindow
+*/
+class wxVScrolledWindow : public wxPanel, public wxVarVScrollHelper
+{
+public:
+ /**
+ Default constructor, you must call Create() later.
+ */
+ wxVScrolledWindow();
+ /**
+ This is the normal constructor, no need to call Create() after using
+ this constructor.
+
+ @note @c wxVSCROLL is always automatically added to the style, there is
+ no need to specify it explicitly.
+
+ @param parent
+ The parent window, must not be @NULL.
+ @param id
+ The identifier of this window, wxID_ANY by default.
+ @param pos
+ The initial window position.
+ @param size
+ The initial window size.
+ @param style
+ The window style. There are no special style bits defined for this
+ class.
+ @param name
+ The name for this window; usually not used.
+ */
+ wxVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxPanelNameStr);
+
+ /**
+ Same as the non-default constuctor, but returns a status code: @true if
+ ok, @false if the window couldn't be created.
+
+ Just as with the constructor, the @c wxVSCROLL style is always used,
+ there is no need to specify it explicitly.
+ */
+ bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxPanelNameStr);
+};
+
+
+
/**
@class wxHScrolledWindow
@wxheader{vscroll.h}
@@ -783,72 +736,147 @@ public:
the widths of all columns in advance -- only those which are shown on the
screen need to be measured.
- In any case, this is a generalization of the
- wxScrolledWindow class which can be only used when
- all columns have the same widths. It lacks some other wxScrolledWindow features
- however, notably it can't scroll only a rectangle of the window and not its
- entire client area.
+ In any case, this is a generalization of wxScrolled which can be only used
+ when all columns have the same widths. It lacks some other wxScrolled
+ features however, notably it can't scroll specific pixel sizes of the
+ window or its exact client area size.
To use this class, you need to derive from it and implement the
- wxVarHScrollHelper::OnGetColumnWidth pure virtual
- method. You also must call wxVarHScrollHelper::SetColumnCount
- to let the base class know how many columns it should display, but from that
- moment on the scrolling is handled entirely by wxHScrolledWindow. You only
- need to draw the visible part of contents in your @c OnPaint() method as
- usual. You should use wxVarHScrollHelper::GetVisibleColumnsBegin
- and wxVarHScrollHelper::GetVisibleColumnsEnd to
- select the lines to display. Note that the device context origin is not shifted
- so the first visible column always appears at the point (0, 0) in physical as
- well as logical coordinates.
+ OnGetColumnWidth() pure virtual method. You also must call SetColumnCount()
+ to let the base class know how many columns it should display, but from
+ that moment on the scrolling is handled entirely by wxHScrolledWindow. You
+ only need to draw the visible part of contents in your @c OnPaint() method
+ as usual. You should use GetVisibleColumnsBegin() and
+ GetVisibleColumnsEnd() to select the lines to display. Note that the device
+ context origin is not shifted so the first visible column always appears at
+ the point (0, 0) in physical as well as logical coordinates.
@library{wxcore}
- @category{FIXME}
+ @category{miscwnd}
@see wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxHScrolledWindow : public wxPanel
+class wxHScrolledWindow : public wxPanel, public wxVarHScrollHelper
{
public:
- //@{
/**
- This is the normal constructor, no need to call @c Create() after using this
- one.
- Note that @c wxHSCROLL is always automatically added to our style, there is
- no need to specify it explicitly.
-
+ Default constructor, you must call Create() later.
+ */
+ wxHScrolledWindow();
+ /**
+ This is the normal constructor, no need to call Create() after using
+ this constructor.
+
+ @note @c wxHSCROLL is always automatically added to the style, there is
+ no need to specify it explicitly.
+
@param parent
- The parent window, must not be @NULL
+ The parent window, must not be @NULL.
@param id
- The identifier of this window, wxID_ANY by default
+ The identifier of this window, wxID_ANY by default.
@param pos
- The initial window position
+ The initial window position.
@param size
- The initial window size
+ The initial window size.
@param style
- The window style. There are no special style bits defined for
- this class.
+ The window style. There are no special style bits defined for this
+ class.
@param name
- The name for this window; usually not used
+ The name for this window; usually not used.
*/
- wxHScrolledWindow();
wxHScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
+ const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxPanelNameStr);
- //@}
/**
- Same as the @ref wxhscrolledwindow() "non-default constuctor"
- but returns status code: @true if ok, @false if the window couldn't
- be created.
- Just as with the constructor above, the @c wxHSCROLL style is always used,
+ Same as the non-default constuctor, but returns a status code: @true if
+ ok, @false if the window couldn't be created.
+
+ Just as with the constructor, the @c wxHSCROLL style is always used,
there is no need to specify it explicitly.
*/
bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxPanelNameStr);
+};
+
+
+
+/**
+ @class wxHVScrolledWindow
+ @wxheader{vscroll.h}
+
+ This window inherits all functionality of both vertical and horizontal,
+ variable scrolled windows. It automatically handles everything needed to
+ scroll both axis simultaneously with both variable row heights and variable
+ column widths.
+
+ In any case, this is a generalization of wxScrolled which can be only used
+ when all rows and columns are the same size. It lacks some other wxScrolled
+ features however, notably it can't scroll specific pixel sizes of the
+ window or its exact client area size.
+
+ To use this class, you must derive from it and implement both the
+ OnGetRowHeight() and OnGetColumnWidth() pure virtual methods to let the
+ base class know how many rows and columns it should display. You also need
+ to set the total rows and columns the window contains, but from that moment
+ on the scrolling is handled entirely by wxHVScrolledWindow. You only need
+ to draw the visible part of contents in your @c OnPaint() method as usual.
+ You should use GetVisibleBegin() and GetVisibleEnd() to select the lines to
+ display. Note that the device context origin is not shifted so the first
+ visible row and column always appear at the point (0, 0) in physical as
+ well as logical coordinates.
+
+ @library{wxcore}
+ @category{miscwnd}
+
+ @see wxHScrolledWindow, wxVScrolledWindow
+*/
+class wxHVScrolledWindow : public wxPanel, public wxVarHVScrollHelper
+{
+public:
+ /**
+ Default constructor, you must call Create() later.
+ */
+ wxHVScrolledWindow();
+ /**
+ This is the normal constructor, no need to call Create() after using
+ this constructor.
+
+ @note @c wxHSCROLL and @c wxVSCROLL are always automatically added to
+ the style, there is no need to specify it explicitly.
+
+ @param parent
+ The parent window, must not be @NULL.
+ @param id
+ The identifier of this window, wxID_ANY by default.
+ @param pos
+ The initial window position.
+ @param size
+ The initial window size.
+ @param style
+ The window style. There are no special style bits defined for this
+ class.
+ @param name
+ The name for this window; usually not used.
+ */
+ wxHVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxPanelNameStr);
+
+ /**
+ Same as the non-default constuctor, but returns a status code: @true if
+ ok, @false if the window couldn't be created.
+
+ Just as with the constructor, the @c wxHSCROLL and @c wxVSCROLL styles
+ are always used, there is no need to specify them explicitly.
+ */
+ bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxPanelNameStr);
};