interface/wx/vscroll.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        vscroll.h
   3 // Purpose:     interface of wxVarHScrollHelper
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxVarScrollHelperBase
  11
  12     This class provides all common base functionality for scroll calculations
  13     shared among all variable scrolled window implementations as well as
  14     automatic scrollbar functionality, saved scroll positions, controlling
  15     target windows to be scrolled, as well as defining all required virtual
  16     functions that need to be implemented for any orientation specific work.
  17
  18     Documentation of this class is provided specifically for referencing use
  19     of the functions provided by this class for use with the variable scrolled
  20     windows that derive from here. You will likely want to derive your window
  21     from one of the already implemented variable scrolled windows rather than
  22     from wxVarScrollHelperBase directly.
  23
  24     @library{wxcore}
  25     @category{miscwnd}
  26
  27     @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
  28 */
  29 class wxVarScrollHelperBase
  30 {
  31 public:
  32     /**
  33         Constructor taking the target window to be scrolled by this helper
  34         class. This will attach scroll event handlers to the target window to
  35         catch and handle scroll events appropriately.
  36     */
  37     wxVarScrollHelperBase(wxWindow* winToScroll);
  38
  39     /**
  40         Virtual destructor for detaching scroll event handlers attached with
  41         this helper class.
  42     */
  43     virtual ~wxVarScrollHelperBase();
  44
  45     /**
  46         Translates the logical coordinate given to the current device
  47         coordinate. For example, if the window is scrolled 10 units and each
  48         scroll unit represents 10 device units (which may not be the case since
  49         this class allows for variable scroll unit sizes), a call to this
  50         function with a coordinate of 15 will return -85.
  51
  52         @see CalcUnscrolledPosition()
  53     */
  54     int CalcScrolledPosition(int coord) const;
  55
  56     /**
  57         Translates the device coordinate given to the corresponding logical
  58         coordinate. For example, if the window is scrolled 10 units and each
  59         scroll unit represents 10 device units (which may not be the case since
  60         this class allows for variable scroll unit sizes), a call to this
  61         function with a coordinate of 15 will return 115.
  62
  63         @see CalcScrolledPosition()
  64     */
  65     int CalcUnscrolledPosition(int coord) const;
  66
  67     /**
  68         With physical scrolling on (when this is @true), the device origin is
  69         changed properly when a wxPaintDC is prepared, children are actually
  70         moved and laid out properly, and the contents of the window (pixels)
  71         are actually moved. When this is @false, you are responsible for
  72         repainting any invalidated areas of the window yourself to account for
  73         the new scroll position.
  74     */
  75     void EnablePhysicalScrolling(bool scrolling = true);
  76
  77     /**
  78         When the number of scroll units change, we try to estimate the total
  79         size of all units when the full window size is needed (i.e. to
  80         calculate the scrollbar thumb size). This is a rather expensive
  81         operation in terms of unit access, so if the user code may estimate the
  82         average size better or faster than we do, it should override this
  83         function to implement its own logic. This function should return the
  84         best guess for the total virtual window size.
  85
  86         @note Although returning a totally wrong value would still work, it
  87               risks resulting in very strange scrollbar behaviour so this
  88               function should really try to make the best guess possible.
  89     */
  90     virtual wxCoord EstimateTotalSize() const;
  91
  92     /**
  93         This function needs to be overridden in the in the derived class to
  94         return the window size with respect to the opposing orientation. If
  95         this is a vertical scrolled window, it should return the height.
  96
  97         @see GetOrientationTargetSize()
  98     */
  99     virtual int GetNonOrientationTargetSize() const;
 100
 101     /**
 102         This function need to be overridden to return the orientation that this
 103         helper is working with, either @c wxHORIZONTAL or @c wxVERTICAL.
 104     */
 105     virtual wxOrientation GetOrientation() const;
 106
 107     /**
 108         This function needs to be overridden in the in the derived class to
 109         return the window size with respect to the orientation this helper is
 110         working with. If this is a vertical scrolled window, it should return
 111         the width.
 112
 113         @see GetNonOrientationTargetSize()
 114     */
 115     virtual int GetOrientationTargetSize() const;
 116
 117     /**
 118         This function will return the target window this helper class is
 119         currently scrolling.
 120
 121         @see SetTargetWindow()
 122     */
 123     wxWindow* GetTargetWindow() const;
 124
 125     /**
 126         Returns the index of the first visible unit based on the scroll
 127         position.
 128     */
 129     size_t GetVisibleBegin() const;
 130
 131     /**
 132         Returns the index of the last visible unit based on the scroll
 133         position. This includes the last unit even if it is only partially
 134         visible.
 135     */
 136     size_t GetVisibleEnd() const;
 137
 138     /**
 139         Returns @true if the given scroll unit is currently visible (even if
 140         only partially visible) or @false otherwise.
 141     */
 142     bool IsVisible(size_t unit) const;
 143
 144     /**
 145         This function must be overridden in the derived class, and should
 146         return the size of the given unit in pixels.
 147     */
 148     virtual wxCoord OnGetUnitSize(size_t unit) const;
 149
 150     /**
 151         This function doesn't have to be overridden but it may be useful to do
 152         so if calculating the units' sizes is a relatively expensive operation
 153         as it gives your code a chance to calculate several of them at once and
 154         cache the result if necessary.
 155
 156         OnGetUnitsSizeHint() is normally called just before OnGetUnitSize() but
 157         you shouldn't rely on the latter being called for all units in the
 158         interval specified here. It is also possible that OnGetUnitSize() will
 159         be called for units outside of this interval, so this is really just a
 160         hint, not a promise.
 161
 162         Finally, note that @a unitMin is inclusive, while @a unitMax is
 163         exclusive.
 164     */
 165     virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const;
 166
 167     /**
 168         Recalculate all parameters and repaint all units.
 169     */
 170     virtual void RefreshAll();
 171
 172     /**
 173         Normally the window will scroll itself, but in some rare occasions you
 174         might want it to scroll (part of) another window (e.g. a child of it in
 175         order to scroll only a portion the area between the scrollbars like a
 176         spreadsheet where only the cell area will move).
 177
 178         @see GetTargetWindow()
 179     */
 180     void SetTargetWindow(wxWindow* target);
 181
 182     /**
 183         Update the thumb size shown by the scrollbar.
 184     */
 185     virtual void UpdateScrollbar();
 186
 187     /**
 188         Returns the virtual scroll unit under the device unit given accounting
 189         for scroll position or @c wxNOT_FOUND if none (i.e. if it is below the
 190         last item).
 191     */
 192     int VirtualHitTest(wxCoord coord) const;
 193 };
 194
 195
 196
 197 /**
 198     @class wxVarVScrollHelper
 199
 200     This class provides functions wrapping the wxVarScrollHelperBase class,
 201     targeted for vertical-specific scrolling.
 202
 203     Like wxVarScrollHelperBase, this class is mostly only useful to those
 204     classes built into wxWidgets deriving from here, and this documentation is
 205     mostly only provided for referencing the functions provided by this class.
 206     You will likely want to derive your window from wxVScrolledWindow rather
 207     than from here directly.
 208
 209     @library{wxcore}
 210     @category{miscwnd}
 211
 212     @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
 213 */
 214 class wxVarVScrollHelper : public wxVarScrollHelperBase
 215 {
 216 public:
 217     /**
 218         Constructor taking the target window to be scrolled by this helper
 219         class. This will attach scroll event handlers to the target window to
 220         catch and handle scroll events appropriately.
 221     */
 222     wxVarVScrollHelper(wxWindow* winToScroll);
 223
 224     /**
 225         This class forwards calls from EstimateTotalSize() to this function so
 226         derived classes can override either just the height or the width
 227         estimation, or just estimate both differently if desired in any
 228         wxHVScrolledWindow derived class.
 229
 230         @note This function will not be called if EstimateTotalSize() is
 231               overridden in your derived class.
 232     */
 233     virtual wxCoord EstimateTotalHeight() const;
 234
 235     /**
 236         Returns the number of rows the target window contains.
 237
 238         @see SetRowCount()
 239     */
 240     size_t GetRowCount() const;
 241
 242     /**
 243         Returns the index of the first visible row based on the scroll
 244         position.
 245     */
 246     size_t GetVisibleRowsBegin() const;
 247
 248     /**
 249         Returns the index of the last visible row based on the scroll position.
 250         This includes the last row even if it is only partially visible.
 251     */
 252     size_t GetVisibleRowsEnd() const;
 253
 254     /**
 255         Returns @true if the given row is currently visible (even if only
 256         partially visible) or @false otherwise.
 257     */
 258     bool IsRowVisible(size_t row) const;
 259
 260     /**
 261         This function must be overridden in the derived class, and should
 262         return the height of the given row in pixels.
 263     */
 264     virtual wxCoord OnGetRowHeight(size_t row) const;
 265
 266     /**
 267         This function doesn't have to be overridden but it may be useful to do
 268         so if calculating the rows' sizes is a relatively expensive operation
 269         as it gives your code a chance to calculate several of them at once and
 270         cache the result if necessary.
 271
 272         OnGetRowsHeightHint() is normally called just before OnGetRowHeight()
 273         but you shouldn't rely on the latter being called for all rows in the
 274         interval specified here. It is also possible that OnGetRowHeight() will
 275         be called for units outside of this interval, so this is really just a
 276         hint, not a promise.
 277
 278         Finally, note that @a rowMin is inclusive, while @a rowMax is
 279         exclusive.
 280     */
 281     virtual void OnGetRowsHeightHint(size_t rowMin, size_t rowMax) const;
 282
 283     /**
 284         Triggers a refresh for just the given row's area of the window if it's
 285         visible.
 286     */
 287     virtual void RefreshRow(size_t row);
 288
 289     /**
 290         Triggers a refresh for the area between the specified range of rows
 291         given (inclusively).
 292     */
 293     virtual void RefreshRows(size_t from, size_t to);
 294
 295     /**
 296         Scroll by the specified number of pages which may be positive (to
 297         scroll down) or negative (to scroll up).
 298     */
 299     virtual bool ScrollRowPages(int pages);
 300
 301     /**
 302         Scroll by the specified number of rows which may be positive (to scroll
 303         down) or negative (to scroll up).
 304
 305         @return @true if the window was scrolled, @false otherwise (for
 306                 example, if we're trying to scroll down but we are already
 307                 showing the last row).
 308     */
 309     virtual bool ScrollRows(int rows);
 310
 311     /**
 312         Scroll to the specified row. It will become the first visible row in
 313         the window.
 314
 315         @return @true if we scrolled the window, @false if nothing was done.
 316     */
 317     bool ScrollToRow(size_t row);
 318
 319     /**
 320         Set the number of rows the window contains. The derived class must
 321         provide the heights for all rows with indices up to the one given here
 322         in it's OnGetRowHeight() implementation.
 323
 324         @see GetRowCount()
 325     */
 326     void SetRowCount(size_t rowCount);
 327 };
 328
 329
 330
 331 /**
 332     @class wxVarHScrollHelper
 333
 334     This class provides functions wrapping the wxVarScrollHelperBase class,
 335     targeted for horizontal-specific scrolling.
 336
 337     Like wxVarScrollHelperBase, this class is mostly only useful to those
 338     classes built into wxWidgets deriving from here, and this documentation is
 339     mostly only provided for referencing the functions provided by this class.
 340     You will likely want to derive your window from wxHScrolledWindow rather
 341     than from here directly.
 342
 343     @library{wxcore}
 344     @category{miscwnd}
 345
 346     @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
 347 */
 348 class wxVarHScrollHelper : public wxVarScrollHelperBase
 349 {
 350 public:
 351     /**
 352         Constructor taking the target window to be scrolled by this helper
 353         class. This will attach scroll event handlers to the target window to
 354         catch and handle scroll events appropriately.
 355     */
 356     wxVarHScrollHelper(wxWindow* winToScroll);
 357
 358     /**
 359         This class forwards calls from EstimateTotalSize() to this function so
 360         derived classes can override either just the height or the width
 361         estimation, or just estimate both differently if desired in any
 362         wxHVScrolledWindow derived class.
 363
 364         @note This function will not be called if EstimateTotalSize() is
 365               overridden in your derived class.
 366     */
 367     virtual wxCoord EstimateTotalWidth() const;
 368
 369     /**
 370         Returns the number of columns the target window contains.
 371
 372         @see SetColumnCount()
 373     */
 374     size_t GetColumnCount() const;
 375
 376     /**
 377         Returns the index of the first visible column based on the scroll
 378         position.
 379     */
 380     size_t GetVisibleColumnsBegin() const;
 381
 382     /**
 383         Returns the index of the last visible column based on the scroll
 384         position. This includes the last column even if it is only partially
 385         visible.
 386     */
 387     size_t GetVisibleColumnsEnd() const;
 388
 389     /**
 390         Returns @true if the given column is currently visible (even if only
 391         partially visible) or @false otherwise.
 392     */
 393     bool IsColumnVisible(size_t column) const;
 394
 395     /**
 396         This function must be overridden in the derived class, and should
 397         return the width of the given column in pixels.
 398     */
 399     virtual wxCoord OnGetColumnWidth(size_t column) const;
 400
 401     /**
 402         This function doesn't have to be overridden but it may be useful to do
 403         so if calculating the columns' sizes is a relatively expensive
 404         operation as it gives your code a chance to calculate several of them
 405         at once and cache the result if necessary.
 406
 407         OnGetColumnsWidthHint() is normally called just before
 408         OnGetColumnWidth() but you shouldn't rely on the latter being called
 409         for all columns in the interval specified here. It is also possible
 410         that OnGetColumnWidth() will be called for units outside of this
 411         interval, so this is really just a hint, not a promise.
 412
 413         Finally, note that @a columnMin is inclusive, while @a columnMax is
 414         exclusive.
 415     */
 416     virtual void OnGetColumnsWidthHint(size_t columnMin,
 417                                        size_t columnMax) const;
 418
 419     /**
 420         Triggers a refresh for just the given column's area of the window if
 421         it's visible.
 422     */
 423     virtual void RefreshColumn(size_t column);
 424
 425     /**
 426         Triggers a refresh for the area between the specified range of columns
 427         given (inclusively).
 428     */
 429     virtual void RefreshColumns(size_t from, size_t to);
 430
 431     /**
 432         Scroll by the specified number of pages which may be positive (to
 433         scroll right) or negative (to scroll left).
 434     */
 435     virtual bool ScrollColumnPages(int pages);
 436
 437     /**
 438         Scroll by the specified number of columns which may be positive (to
 439         scroll right) or negative (to scroll left).
 440
 441         @return @true if the window was scrolled, @false otherwise (for
 442                 example, if we're trying to scroll right but we are already
 443                 showing the last column).
 444     */
 445     virtual bool ScrollColumns(int columns);
 446
 447     /**
 448         Scroll to the specified column. It will become the first visible column
 449         in the window.
 450
 451         @return @true if we scrolled the window, @false if nothing was done.
 452     */
 453     bool ScrollToColumn(size_t column);
 454
 455     /**
 456         Set the number of columns the window contains. The derived class must
 457         provide the widths for all columns with indices up to the one given
 458         here in it's OnGetColumnWidth() implementation.
 459
 460         @see GetColumnCount()
 461     */
 462     void SetColumnCount(size_t columnCount);
 463 };
 464
 465
 466
 467 /**
 468     @class wxVarHVScrollHelper
 469
 470     This class provides functions wrapping the wxVarHScrollHelper and
 471     wxVarVScrollHelper classes, targeted for scrolling a window in both axis.
 472     Since this class is also the join class of the horizontal and vertical
 473     scrolling functionality, it also addresses some wrappers that help avoid
 474     the need to specify class scope in your wxHVScrolledWindow derived class
 475     when using wxVarScrollHelperBase functionality.
 476
 477     Like all three of it's scroll helper base classes, this class is mostly
 478     only useful to those classes built into wxWidgets deriving from here, and
 479     this documentation is mostly only provided for referencing the functions
 480     provided by this class. You will likely want to derive your window from
 481     wxHVScrolledWindow rather than from here directly.
 482
 483     @library{wxcore}
 484     @category{miscwnd}
 485
 486     @see wxHScrolledWindow, wxHVScrolledWindow, wxVScrolledWindow
 487 */
 488 class wxVarHVScrollHelper : public wxVarVScrollHelper,
 489                              public wxVarHScrollHelper
 490 {
 491 public:
 492     /**
 493         Constructor taking the target window to be scrolled by this helper
 494         class. This will attach scroll event handlers to the target window to
 495         catch and handle scroll events appropriately.
 496     */
 497     wxVarHVScrollHelper(wxWindow* winToScroll);
 498
 499     /**
 500         With physical scrolling on (when this is @true), the device origin is
 501         changed properly when a wxPaintDC is prepared, children are actually
 502         moved and laid out properly, and the contents of the window (pixels)
 503         are actually moved. When this is @false, you are responsible for
 504         repainting any invalidated areas of the window yourself to account for
 505         the new scroll position.
 506
 507         @param vscrolling
 508             Specifies if physical scrolling should be turned on when scrolling
 509             vertically.
 510         @param hscrolling
 511             Specifies if physical scrolling should be turned on when scrolling
 512             horizontally.
 513     */
 514     void EnablePhysicalScrolling(bool vscrolling = true,
 515                                  bool hscrolling = true);
 516
 517     /**
 518         Returns the number of columns and rows the target window contains.
 519
 520         @see SetRowColumnCount()
 521     */
 522     wxSize GetRowColumnCount() const;
 523
 524     /**
 525         Returns the index of the first visible column and row based on the
 526         current scroll position.
 527     */
 528     wxPosition GetVisibleBegin() const;
 529
 530     /**
 531         Returns the index of the last visible column and row based on the
 532         scroll position. This includes any partially visible columns or rows.
 533     */
 534     wxPosition GetVisibleEnd() const;
 535
 536     //@{
 537     /**
 538         Returns @true if both the given row and column are currently visible
 539         (even if only partially visible) or @false otherwise.
 540     */
 541     bool IsVisible(size_t row, size_t column) const;
 542     bool IsVisible(const wxPosition& pos) const;
 543     //@}
 544
 545     //@{
 546     /**
 547         Triggers a refresh for just the area shared between the given row and
 548         column of the window if it is visible.
 549     */
 550     virtual void RefreshRowColumn(size_t row, size_t column);
 551     virtual void RefreshRowColumn(const wxPosition& pos);
 552     //@}
 553
 554     //@{
 555     /**
 556         Triggers a refresh for the visible area shared between all given rows
 557         and columns (inclusive) of the window. If the target window for both
 558         orientations is the same, the rectangle of cells is refreshed; if the
 559         target windows differ, the entire client size opposite the orientation
 560         direction is refreshed between the specified limits.
 561     */
 562     virtual void RefreshRowsColumns(size_t fromRow, size_t toRow,
 563                                     size_t fromColumn, size_t toColumn);
 564     virtual void RefreshRowsColumns(const wxPosition& from,
 565                                     const wxPosition& to);
 566     //@}
 567
 568     //@{
 569     /**
 570         Scroll to the specified row and column. It will become the first
 571         visible row and column in the window. Returns @true if we scrolled the
 572         window, @false if nothing was done.
 573     */
 574     bool ScrollToRowColumn(size_t row, size_t column);
 575     bool ScrollToRowColumn(const wxPosition& pos);
 576     //@}
 577
 578     /**
 579         Set the number of rows and columns the target window will contain. The
 580         derived class must provide the sizes for all rows and columns with
 581         indices up to the ones given here in it's OnGetRowHeight() and
 582         OnGetColumnWidth() implementations, respectively.
 583
 584         @see GetRowColumnCount()
 585     */
 586     void SetRowColumnCount(size_t rowCount, size_t columnCount);
 587
 588     //@{
 589     /**
 590         Returns the virtual scroll unit under the device unit given accounting
 591         for scroll position or @c wxNOT_FOUND (for the row, column, or possibly
 592         both values) if none.
 593     */
 594     wxPosition VirtualHitTest(wxCoord x, wxCoord y) const;
 595     wxPosition VirtualHitTest(const wxPoint& pos) const;
 596     //@}
 597 };
 598
 599
 600
 601 /**
 602     @class wxVScrolledWindow
 603
 604     In the name of this class, "V" may stand for "variable" because it can be
 605     used for scrolling rows of variable heights; "virtual", because it is not
 606     necessary to know the heights of all rows in advance -- only those which
 607     are shown on the screen need to be measured; or even "vertical", because
 608     this class only supports scrolling vertically.
 609
 610     In any case, this is a generalization of wxScrolled which can be only used
 611     when all rows have the same heights. It lacks some other wxScrolled
 612     features however, notably it can't scroll specific pixel sizes of the
 613     window or its exact client area size.
 614
 615     To use this class, you need to derive from it and implement the
 616     OnGetRowHeight() pure virtual method. You also must call SetRowCount() to
 617     let the base class know how many rows it should display, but from that
 618     moment on the scrolling is handled entirely by wxVScrolledWindow. You only
 619     need to draw the visible part of contents in your @c OnPaint() method as
 620     usual. You should use GetVisibleRowsBegin() and GetVisibleRowsEnd() to
 621     select the lines to display. Note that the device context origin is not
 622     shifted so the first visible row always appears at the point (0, 0) in
 623     physical as well as logical coordinates.
 624
 625     @section wxWidgets 2.8 Compatibility Functions
 626
 627     The following functions provide backwards compatibility for applications
 628     originally built using wxVScrolledWindow in 2.6 or 2.8. Originally,
 629     wxVScrolledWindow referred to scrolling "lines". We now use "units" in
 630     wxVarScrollHelperBase to avoid implying any orientation (since the
 631     functions are used for both horizontal and vertical scrolling in derived
 632     classes). And in the new wxVScrolledWindow and wxHScrolledWindow classes,
 633     we refer to them as "rows" and "columns", respectively. This is to help
 634     clear some confusion in not only those classes, but also in
 635     wxHVScrolledWindow where functions are inherited from both.
 636
 637     You are encouraged to update any existing code using these function to use
 638     the new replacements mentioned below, and avoid using these functions for
 639     any new code as they are deprecated.
 640
 641     @beginTable
 642     @row2col{ <tt>size_t %GetFirstVisibleLine() const</tt>,
 643         Deprecated for GetVisibleRowsBegin(). }
 644     @row2col{ <tt>size_t %GetLastVisibleLine() const</tt>,
 645         Deprecated for GetVisibleRowsEnd(). This function originally had a
 646         slight design flaw in that it was possible to return
 647         <tt>(size_t)-1</tt> (ie: a large positive number) if the scroll
 648         position was 0 and the first line wasn't completely visible. }
 649     @row2col{ <tt>size_t %GetLineCount() const</tt>,
 650         Deprecated for GetRowCount(). }
 651     @row2col{ <tt>int %HitTest(wxCoord x\, wxCoord y) const
 652               @n  int %HitTest(const wxPoint& pt) const</tt>,
 653         Deprecated for VirtualHitTest(). }
 654     @row2col{ <tt>virtual wxCoord %OnGetLineHeight(size_t line) const</tt>,
 655         Deprecated for OnGetRowHeight(). }
 656     @row2col{ <tt>virtual void %OnGetLinesHint(size_t lineMin\, size_t lineMax) const</tt>,
 657         Deprecated for OnGetRowsHeightHint(). }
 658     @row2col{ <tt>virtual void %RefreshLine(size_t line)</tt>,
 659         Deprecated for RefreshRow(). }
 660     @row2col{ <tt>virtual void %RefreshLines(size_t from\, size_t to)</tt>,
 661         Deprecated for RefreshRows(). }
 662     @row2col{ <tt>virtual bool %ScrollLines(int lines)</tt>,
 663         Deprecated for ScrollRows(). }
 664     @row2col{ <tt>virtual bool %ScrollPages(int pages)</tt>,
 665         Deprecated for ScrollRowPages(). }
 666     @row2col{ <tt>bool %ScrollToLine(size_t line)</tt>,
 667         Deprecated for ScrollToRow(). }
 668     @row2col{ <tt>void %SetLineCount(size_t count)</tt>,
 669         Deprecated for SetRowCount(). }
 670     @endTable
 671
 672     @library{wxcore}
 673     @category{miscwnd}
 674
 675     @see wxHScrolledWindow, wxHVScrolledWindow
 676 */
 677 class wxVScrolledWindow : public wxPanel, public wxVarVScrollHelper
 678 {
 679 public:
 680     /**
 681         Default constructor, you must call Create() later.
 682     */
 683     wxVScrolledWindow();
 684     /**
 685         This is the normal constructor, no need to call Create() after using
 686         this constructor.
 687
 688         @note @c wxVSCROLL is always automatically added to the style, there is
 689               no need to specify it explicitly.
 690
 691         @param parent
 692             The parent window, must not be @NULL.
 693         @param id
 694             The identifier of this window, wxID_ANY by default.
 695         @param pos
 696             The initial window position.
 697         @param size
 698             The initial window size.
 699         @param style
 700             The window style. There are no special style bits defined for this
 701             class.
 702         @param name
 703             The name for this window; usually not used.
 704     */
 705     wxVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
 706                       const wxPoint& pos = wxDefaultPosition,
 707                       const wxSize& size = wxDefaultSize, long style = 0,
 708                       const wxString& name = wxPanelNameStr);
 709
 710     /**
 711         Same as the non-default constuctor, but returns a status code: @true if
 712         ok, @false if the window couldn't be created.
 713
 714         Just as with the constructor, the @c wxVSCROLL style is always used,
 715         there is no need to specify it explicitly.
 716     */
 717     bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
 718                 const wxPoint& pos = wxDefaultPosition,
 719                 const wxSize& size = wxDefaultSize, long style = 0,
 720                 const wxString& name = wxPanelNameStr);
 721 };
 722
 723
 724
 725 /**
 726     @class wxHScrolledWindow
 727
 728     In the name of this class, "H" stands for "horizontal" because it can be
 729     used for scrolling columns of variable widths. It is not necessary to know
 730     the widths of all columns in advance -- only those which are shown on the
 731     screen need to be measured.
 732
 733     In any case, this is a generalization of wxScrolled which can be only used
 734     when all columns have the same widths. It lacks some other wxScrolled
 735     features however, notably it can't scroll specific pixel sizes of the
 736     window or its exact client area size.
 737
 738     To use this class, you need to derive from it and implement the
 739     OnGetColumnWidth() pure virtual method. You also must call SetColumnCount()
 740     to let the base class know how many columns it should display, but from
 741     that moment on the scrolling is handled entirely by wxHScrolledWindow. You
 742     only need to draw the visible part of contents in your @c OnPaint() method
 743     as usual. You should use GetVisibleColumnsBegin() and
 744     GetVisibleColumnsEnd() to select the lines to display. Note that the device
 745     context origin is not shifted so the first visible column always appears at
 746     the point (0, 0) in physical as well as logical coordinates.
 747
 748     @library{wxcore}
 749     @category{miscwnd}
 750
 751     @see wxHVScrolledWindow, wxVScrolledWindow
 752 */
 753 class wxHScrolledWindow : public wxPanel, public wxVarHScrollHelper
 754 {
 755 public:
 756     /**
 757         Default constructor, you must call Create() later.
 758     */
 759     wxHScrolledWindow();
 760     /**
 761         This is the normal constructor, no need to call Create() after using
 762         this constructor.
 763
 764         @note @c wxHSCROLL is always automatically added to the style, there is
 765               no need to specify it explicitly.
 766
 767         @param parent
 768             The parent window, must not be @NULL.
 769         @param id
 770             The identifier of this window, wxID_ANY by default.
 771         @param pos
 772             The initial window position.
 773         @param size
 774             The initial window size.
 775         @param style
 776             The window style. There are no special style bits defined for this
 777             class.
 778         @param name
 779             The name for this window; usually not used.
 780     */
 781     wxHScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
 782                       const wxPoint& pos = wxDefaultPosition,
 783                       const wxSize& size = wxDefaultSize, long style = 0,
 784                       const wxString& name = wxPanelNameStr);
 785
 786     /**
 787         Same as the non-default constuctor, but returns a status code: @true if
 788         ok, @false if the window couldn't be created.
 789
 790         Just as with the constructor, the @c wxHSCROLL style is always used,
 791         there is no need to specify it explicitly.
 792     */
 793     bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
 794                 const wxPoint& pos = wxDefaultPosition,
 795                 const wxSize& size = wxDefaultSize, long style = 0,
 796                 const wxString& name = wxPanelNameStr);
 797 };
 798
 799
 800
 801 /**
 802     @class wxHVScrolledWindow
 803
 804     This window inherits all functionality of both vertical and horizontal,
 805     variable scrolled windows. It automatically handles everything needed to
 806     scroll both axis simultaneously with both variable row heights and variable
 807     column widths.
 808
 809     In any case, this is a generalization of wxScrolled which can be only used
 810     when all rows and columns are the same size. It lacks some other wxScrolled
 811     features however, notably it can't scroll specific pixel sizes of the
 812     window or its exact client area size.
 813
 814     To use this class, you must derive from it and implement both the
 815     OnGetRowHeight() and OnGetColumnWidth() pure virtual methods to let the
 816     base class know how many rows and columns it should display. You also need
 817     to set the total rows and columns the window contains, but from that moment
 818     on the scrolling is handled entirely by wxHVScrolledWindow. You only need
 819     to draw the visible part of contents in your @c OnPaint() method as usual.
 820     You should use GetVisibleBegin() and GetVisibleEnd() to select the lines to
 821     display. Note that the device context origin is not shifted so the first
 822     visible row and column always appear at the point (0, 0) in physical as
 823     well as logical coordinates.
 824
 825     @library{wxcore}
 826     @category{miscwnd}
 827
 828     @see wxHScrolledWindow, wxVScrolledWindow
 829 */
 830 class wxHVScrolledWindow : public wxPanel, public wxVarHVScrollHelper
 831 {
 832 public:
 833     /**
 834         Default constructor, you must call Create() later.
 835     */
 836     wxHVScrolledWindow();
 837     /**
 838         This is the normal constructor, no need to call Create() after using
 839         this constructor.
 840
 841         @note @c wxHSCROLL and @c wxVSCROLL are always automatically added to
 842               the style, there is no need to specify it explicitly.
 843
 844         @param parent
 845             The parent window, must not be @NULL.
 846         @param id
 847             The identifier of this window, wxID_ANY by default.
 848         @param pos
 849             The initial window position.
 850         @param size
 851             The initial window size.
 852         @param style
 853             The window style. There are no special style bits defined for this
 854             class.
 855         @param name
 856             The name for this window; usually not used.
 857     */
 858     wxHVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY,
 859                        const wxPoint& pos = wxDefaultPosition,
 860                        const wxSize& size = wxDefaultSize, long style = 0,
 861                        const wxString& name = wxPanelNameStr);
 862
 863     /**
 864         Same as the non-default constuctor, but returns a status code: @true if
 865         ok, @false if the window couldn't be created.
 866
 867         Just as with the constructor, the @c wxHSCROLL and @c wxVSCROLL styles
 868         are always used, there is no need to specify them explicitly.
 869     */
 870     bool Create(wxWindow* parent, wxWindowID id = wxID_ANY,
 871                 const wxPoint& pos = wxDefaultPosition,
 872                 const wxSize& size = wxDefaultSize, long style = 0,
 873                 const wxString& name = wxPanelNameStr);
 874 };
 875