/////////////////////////////////////////////////////////////////////////////
// Name: vscroll.h
-// Purpose: documentation for wxVarHScrollHelper class
+// Purpose: interface of wxVarHScrollHelper
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/**
- @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}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarHScrollHelper : public wxVarScrollHelperBase
+class wxVarScrollHelperBase
{
public:
/**
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;
+ ~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
+ 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;
+
+ /**
+ 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 int GetNonOrientationTargetSize() const;
+
+ /**
+ This function need to be overridden to return the orientation that this helper
+ is working with, either @c wxHORIZONTAL or @c wxVERTICAL.
+ */
+ 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;
+
+ /**
+ 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;
+
+ /**
+ Returns @true if the given scroll unit is currently visible (even if only
partially visible) or @false otherwise.
*/
- bool IsColumnVisible(size_t column) const;
+ bool IsVisible(size_t unit) const;
/**
This function must be overridden in the derived class, and should return the
- width of the given column in pixels.
+ size of the given unit in pixels.
*/
- virtual wxCoord OnGetColumnWidth(size_t column) const;
+ virtual wxCoord OnGetUnitSize(size_t unit) 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
+ 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 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
+ @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 columnMin is inclusive, while columnMax is exclusive.
- */
- virtual void OnGetColumnsWidthHint(size_t columnMin,
- size_t columnMax) const;
-
- /**
- Triggers a refresh for just the given column's area of the window if it's
- visible.
+ Finally, note that unitMin is inclusive, while unitMax is exclusive.
*/
- virtual void RefreshColumn(size_t column);
+ virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const;
/**
- Triggers a refresh for the area between the specified range of columns given
- (inclusively).
+ Recalculate all parameters and repaint all units.
*/
- virtual void RefreshColumns(size_t from, size_t to);
+ virtual void RefreshAll();
/**
- Scroll by the specified number of pages which may be positive (to scroll right)
- or negative (to scroll left).
- */
- virtual bool ScrollColumnPages(int pages);
+ 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).
- /**
- 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).
+ @see GetTargetWindow()
*/
- virtual bool ScrollColumns(int columns);
+ void SetTargetWindow(wxWindow* target);
/**
- 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.
+ Update the thumb size shown by the scrollbar.
*/
- bool ScrollToColumn(size_t column);
+ virtual void UpdateScrollbar();
/**
- 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.
+ 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).
*/
- void SetColumnCount(size_t columnCount);
+ int VirtualHitTest(wxCoord coord) const;
};
+
/**
@class wxVarVScrollHelper
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
class wxVarVScrollHelper : public wxVarScrollHelperBase
{
/**
Returns the number of rows the target window contains.
-
+
@see SetRowCount()
*/
size_t GetRowCount() const;
};
+
/**
- @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 using wxHScrolledWindow.
- 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 those functions provided. You will likely want
+ to derive your window from wxHScrolledWindow rather than from here directly.
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarScrollHelperBase
+class wxVarHScrollHelper : public wxVarScrollHelperBase
{
public:
/**
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.
- */
- ~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;
-
- /**
- 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;
-
- /**
- 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.
- */
- void EnablePhysicalScrolling(bool scrolling = true);
-
- /**
- 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;
-
- /**
- 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 int GetNonOrientationTargetSize() const;
+ wxVarHScrollHelper(wxWindow* winToScroll);
/**
- This function need to be overridden to return the orientation that this helper
- is working with, either @c wxHORIZONTAL or @c wxVERTICAL.
+ 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 wxOrientation GetOrientation() const;
+ virtual wxCoord EstimateTotalWidth() 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;
+ Returns the number of columns the target window contains.
- /**
- This function will return the target window this helper class is currently
- scrolling.
-
- @see SetTargetWindow()
+ @see SetColumnCount()
*/
- wxWindow* GetTargetWindow() const;
+ size_t GetColumnCount() const;
/**
- Returns the index of the first visible unit based on the scroll position.
+ Returns the index of the first visible column based on the scroll position.
*/
- size_t GetVisibleBegin() const;
+ size_t GetVisibleColumnsBegin() 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.
+ 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.
*/
- size_t GetVisibleEnd() const;
+ size_t GetVisibleColumnsEnd() const;
/**
- Returns @true if the given scroll unit is currently visible (even if only
+ Returns @true if the given column is currently visible (even if only
partially visible) or @false otherwise.
*/
- bool IsVisible(size_t unit) const;
+ bool IsColumnVisible(size_t column) const;
/**
This function must be overridden in the derived class, and should return the
- size of the given unit in pixels.
+ width of the given column in pixels.
*/
- virtual wxCoord OnGetUnitSize(size_t unit) const;
+ virtual wxCoord OnGetColumnWidth(size_t column) 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
+ 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 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
+ @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 unitMin is inclusive, while unitMax is exclusive.
- */
- virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const;
-
- /**
- Recalculate all parameters and repaint all units.
- */
- virtual void RefreshAll();
-
- /**
- 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 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).
+ Finally, note that columnMin is inclusive, while columnMax is exclusive.
*/
- 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 void OnGetColumnsWidthHint(size_t columnMin,
+ size_t columnMax) const;
- @seealso
- 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
+ Triggers a refresh for just the given column's area of the window if it's
+ visible.
*/
- wxVScrolledWindow();
- wxVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
- //@}
+ virtual void RefreshColumn(size_t column);
/**
- 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.
+ Triggers a refresh for the area between the specified range of columns given
+ (inclusively).
*/
- bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
+ virtual void RefreshColumns(size_t from, size_t to);
- //@{
/**
- 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.
+ Scroll by the specified number of pages which may be positive (to scroll right)
+ or negative (to scroll left).
*/
- 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.
+ virtual bool ScrollColumnPages(int pages);
- @library{wxcore}
- @category{FIXME}
+ /**
+ 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).
+ */
+ virtual bool ScrollColumns(int columns);
- @seealso
- 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
+ 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.
*/
- wxHVScrolledWindow();
- wxHVScrolledWindow(wxWindow* parent,
- wxWindowID id = wxID_ANY,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0,
- const wxString& name = wxPanelNameStr);
- //@}
+ bool ScrollToColumn(size_t column);
/**
- 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.
+ 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.
*/
- 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);
};
+
/**
@class wxVarHVScrollHelper
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxVarHVScrollHelper : public wxVarVScrollHelper
+class wxVarHVScrollHelper : public wxVarVScrollHelper,
+ public wxVarHScrollHelper
{
public:
/**
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.
/**
Returns the number of columns and rows the target window contains.
-
+
@see SetRowColumnCount()
*/
wxSize GetRowColumnCount() 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}
+
+ @see wxHScrolledWindow, wxHVScrolledWindow
+*/
+class wxVScrolledWindow : public wxPanel, public wxVarVScrollHelper
+{
+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);
+ //@}
+
+ /**
+ 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.
+ */
+ 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 wxHScrolledWindow
@wxheader{vscroll.h}
@library{wxcore}
@category{FIXME}
- @seealso
- wxHVScrolledWindow, wxVScrolledWindow
+ @see wxHVScrolledWindow, wxVScrolledWindow
*/
-class wxHScrolledWindow : public wxPanel
+class wxHScrolledWindow : public wxPanel, public wxVarHScrollHelper
{
public:
//@{
one.
Note that @c wxHSCROLL 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
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.
+
+ 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}
+
+ @see wxHScrolledWindow, wxVScrolledWindow
+*/
+class wxHVScrolledWindow : public wxPanel, public wxVarHVScrollHelper
+{
+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);
+ //@}
+
+ /**
+ 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.
+ */
+ bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxPanelNameStr);
+};
+
projects / wxWidgets.git / blobdiff