interface/sizer.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        sizer.h
   3 // Purpose:     interface of wxStdDialogButtonSizer
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxStdDialogButtonSizer
  11     @wxheader{sizer.h}
  12
  13     This class creates button layouts which conform to the standard button spacing
  14     and ordering defined by the platform
  15     or toolkit's user interface guidelines (if such things exist). By using this
  16     class, you can ensure that all your
  17     standard dialogs look correct on all major platforms. Currently it conforms to
  18     the Windows, GTK+ and Mac OS X
  19     human interface guidelines.
  20
  21     When there aren't interface guidelines defined for a particular platform or
  22     toolkit, wxStdDialogButtonSizer reverts
  23     to the Windows implementation.
  24
  25     To use this class, first add buttons to the sizer by calling AddButton (or
  26     SetAffirmativeButton, SetNegativeButton,
  27     or SetCancelButton) and then call Realize in order to create the actual button
  28     layout used. Other than these special
  29     operations, this sizer works like any other sizer.
  30
  31     If you add a button with wxID_SAVE, on Mac OS X the button will be renamed to
  32     "Save" and
  33     the wxID_NO button will be renamed to "Don't Save" in accordance with the Mac
  34     OS X Human Interface Guidelines.
  35
  36     @library{wxcore}
  37     @category{FIXME}
  38
  39     @see wxSizer, @ref overview_sizeroverview "Sizer overview",
  40     wxDialog::CreateButtonSizer
  41 */
  42 class wxStdDialogButtonSizer : public wxBoxSizer
  43 {
  44 public:
  45     /**
  46         Constructor for a wxStdDialogButtonSizer.
  47     */
  48     wxStdDialogButtonSizer();
  49
  50     /**
  51         Adds a button to the wxStdDialogButtonSizer. The button must have one of the
  52         following identifiers:
  53          wxID_OK
  54          wxID_YES
  55          wxID_SAVE
  56          wxID_APPLY
  57          wxID_CLOSE
  58          wxID_NO
  59          wxID_CANCEL
  60          wxID_HELP
  61          wxID_CONTEXT_HELP
  62     */
  63     void AddButton(wxButton* button);
  64
  65     /**
  66         Rearranges the buttons and applies proper spacing between buttons to make them
  67         match the platform or toolkit's interface guidelines.
  68     */
  69     void Realize();
  70
  71     /**
  72         Sets the affirmative button for the sizer. This allows you to use identifiers
  73         other than the standard identifiers outlined above.
  74     */
  75     void SetAffirmativeButton(wxButton* button);
  76
  77     /**
  78         Sets the cancel button for the sizer. This allows you to use identifiers other
  79         than the standard identifiers outlined above.
  80     */
  81     void SetCancelButton(wxButton* button);
  82
  83     /**
  84         Sets the negative button for the sizer. This allows you to use identifiers
  85         other than the standard identifiers outlined above.
  86     */
  87     void SetNegativeButton(wxButton* button);
  88 };
  89
  90
  91
  92 /**
  93     @class wxSizerItem
  94     @wxheader{sizer.h}
  95
  96     The wxSizerItem class is used to track the position, size and other
  97     attributes of each item managed by a wxSizer. It is not usually necessary
  98     to use this class because the sizer elements can also be identified by
  99     their positions or window or sizer pointers but sometimes it may be more
 100     convenient to use it directly.
 101
 102     @library{wxcore}
 103     @category{winlayout}
 104 */
 105 class wxSizerItem : public wxObject
 106 {
 107 public:
 108     //@{
 109     /**
 110         Construct a sizer item for tracking a subsizer.
 111     */
 112     wxSizerItem(int width, int height, int proportion, int flag,
 113                 int border, wxObject* userData);
 114     wxSizerItem(wxWindow* window, const wxSizerFlags& flags);
 115     wxSizerItem(wxWindow* window, int proportion, int flag,
 116                 int border,
 117                 wxObject* userData);
 118     wxSizerItem(wxSizer* window, const wxSizerFlags& flags);
 119     wxSizerItem(wxSizer* sizer, int proportion, int flag,
 120                 int border,
 121                 wxObject* userData);
 122     //@}
 123
 124     /**
 125         Deletes the user data and subsizer, if any.
 126     */
 127     ~wxSizerItem();
 128
 129     /**
 130         Calculates the minimum desired size for the item, including any space
 131         needed by borders.
 132     */
 133     wxSize CalcMin();
 134
 135     /**
 136         Destroy the window or the windows in a subsizer, depending on the type
 137         of item.
 138     */
 139     void DeleteWindows();
 140
 141     /**
 142         Enable deleting the SizerItem without destroying the contained sizer.
 143     */
 144     void DetachSizer();
 145
 146     /**
 147         Return the border attribute.
 148     */
 149     int GetBorder() const;
 150
 151     /**
 152         Return the flags attribute.
 153
 154         See @ref wxsizer_flags "wxSizer flags list" for details.
 155     */
 156     int GetFlag() const;
 157
 158     /**
 159         Return the numeric id of wxSizerItem, or @c wxID_NONE if the id has
 160         not been set.
 161     */
 162     int GetId() const;
 163
 164     /**
 165         Get the minimum size needed for the item.
 166     */
 167     wxSize GetMinSize() const;
 168
 169     /**
 170         Sets the minimum size to be allocated for this item.
 171
 172         If this item is a window, the @a size is also passed to
 173         wxWindow::SetMinSize().
 174      */
 175     void SetMinSize(const wxSize& size);
 176
 177     /**
 178         @overload
 179      */
 180     void SetMinSize(int x, int y);
 181
 182     /**
 183         What is the current position of the item, as set in the last Layout.
 184     */
 185     wxPoint GetPosition() const;
 186
 187     /**
 188         Get the proportion item attribute.
 189     */
 190     int GetProportion() const;
 191
 192     /**
 193         Get the ration item attribute.
 194     */
 195     float GetRatio() const;
 196
 197     /**
 198         Get the rectangle of the item on the parent window, excluding borders.
 199     */
 200     wxRect GetRect();
 201
 202     /**
 203         Get the current size of the item, as set in the last Layout.
 204     */
 205     wxSize GetSize() const;
 206
 207     /**
 208         If this item is tracking a sizer, return it.  @NULL otherwise.
 209     */
 210     wxSizer* GetSizer() const;
 211
 212     /**
 213         If this item is tracking a spacer, return its size.
 214     */
 215     const wxSize GetSpacer() const;
 216
 217     /**
 218         Get the userData item attribute.
 219     */
 220     wxObject* GetUserData() const;
 221
 222     /**
 223         If this item is tracking a window then return it.  @NULL otherwise.
 224     */
 225     wxWindow* GetWindow() const;
 226
 227     /**
 228         Returns @true if this item is a window or a spacer and it is shown or
 229         if this item is a sizer and not all of its elements are hidden.
 230
 231         In other words, for sizer items, all of the child elements must be
 232         hidden for the sizer itself to be considered hidden.
 233
 234         As an exception, if the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was
 235         used for this sizer item, then IsShown() always returns @true for it
 236         (see wxSizerFlags::ReserveSpaceEvenIfHidden()).
 237     */
 238     bool IsShown() const;
 239
 240     /**
 241         Is this item a sizer?
 242     */
 243     bool IsSizer() const;
 244
 245     /**
 246         Is this item a spacer?
 247     */
 248     bool IsSpacer() const;
 249
 250     /**
 251         Is this item a window?
 252     */
 253     bool IsWindow() const;
 254
 255     /**
 256         Set the border item attribute.
 257     */
 258     void SetBorder(int border);
 259
 260     /**
 261         Set the position and size of the space allocated to the sizer, and
 262         adjust the position and size of the item to be within that space
 263         taking alignment and borders into account.
 264     */
 265     void SetDimension(const wxPoint& pos, const wxSize& size);
 266
 267     /**
 268         Set the flag  item attribute.
 269     */
 270     void SetFlag(int flag);
 271
 272     /**
 273         Sets the numeric id of the wxSizerItem to @e id.
 274     */
 275     void SetId(int id);
 276
 277     /**
 278
 279     */
 280     void SetInitSize(int x, int y);
 281
 282     /**
 283         Set the proportion item attribute.
 284     */
 285     void SetProportion(int proportion);
 286
 287     //@{
 288     /**
 289         Set the ratio item attribute.
 290     */
 291     void SetRatio(int width, int height);
 292     void SetRatio(wxSize size);
 293     void SetRatio(float ratio);
 294     //@}
 295
 296     /**
 297         Set the sizer tracked by this item.
 298     */
 299     void SetSizer(wxSizer* sizer);
 300
 301     /**
 302         Set the size of the spacer tracked by this item.
 303     */
 304     void SetSpacer(const wxSize& size);
 305
 306     /**
 307         Set the window to be tracked by thsi item.
 308     */
 309     void SetWindow(wxWindow* window);
 310
 311     /**
 312         Set the show item attribute, which sizers use to determine if the item
 313         is to be made part of the layout or not.  If the item is tracking a
 314         window then it is shown or hidden as needed.
 315     */
 316     void Show(bool show);
 317 };
 318
 319
 320
 321 /**
 322     @class wxSizerFlags
 323     @wxheader{sizer.h}
 324
 325     Normally, when you add an item to a sizer via
 326     wxSizer::Add, you have to specify a lot of flags and
 327     parameters which can be unwieldy. This is where wxSizerFlags comes in: it
 328     allows you to specify all parameters using the named methods instead. For
 329     example, instead of
 330
 331     @code
 332     sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
 333     @endcode
 334
 335     you can now write
 336
 337     @code
 338     sizer->Add(ctrl, wxSizerFlags().Expand().Border(10));
 339     @endcode
 340
 341     This is more readable and also allows you to create wxSizerFlags objects which
 342     can be reused for several sizer items.
 343
 344     @code
 345     wxSizerFlags flagsExpand(1);
 346         flagsExpand.Expand().Border(10);
 347
 348         sizer->Add(ctrl1, flagsExpand);
 349         sizer->Add(ctrl2, flagsExpand);
 350     @endcode
 351
 352     Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
 353     object itself to allowing chaining multiple methods calls like in the examples
 354     above.
 355
 356     @library{wxcore}
 357     @category{winlayout}
 358
 359     @see wxSizer
 360 */
 361 class wxSizerFlags
 362 {
 363 public:
 364     /**
 365         Creates the wxSizer with the proportion specified by @e proportion.
 366     */
 367     wxSizerFlags(int proportion = 0);
 368
 369     /**
 370         Sets the alignment of this wxSizerFlags to @e align.  Note that if this
 371         method is not called, the wxSizerFlags has no specified alignment.
 372
 373         @see Top(), Left(), Right(), Bottom(), Centre()
 374     */
 375     wxSizerFlags& Align(int align = 0);
 376
 377     /**
 378         Sets the wxSizerFlags to have a border of a number of pixels specified
 379         by @a borderinpixels with the directions specified by @e direction.
 380     */
 381     wxSizerFlags& Border(int direction, int borderinpixels);
 382
 383     /**
 384         Sets the wxSizerFlags to have a border with size as returned by
 385         GetDefaultBorder().
 386
 387         @param direction Direction(s) to apply the border in.
 388     */
 389     wxSizerFlags& Border(int direction = wxALL);
 390
 391     /**
 392         Aligns the object to the bottom, shortcut for @c Align(wxALIGN_BOTTOM).
 393
 394         @see Align()
 395     */
 396     wxSizerFlags& Bottom();
 397
 398     /**
 399         Sets the object of the wxSizerFlags to center itself in the area it is
 400         given.
 401     */
 402     wxSizerFlags& Center();
 403
 404     /**
 405         Center() for people with the other dialect of English.
 406     */
 407     wxSizerFlags& Centre();
 408
 409     /**
 410         Sets the border in the given @a direction having twice the default
 411         border size.
 412     */
 413     wxSizerFlags& DoubleBorder(int direction = wxALL);
 414
 415     /**
 416         Sets the border in left and right directions having twice the default
 417         border size.
 418     */
 419     wxSizerFlags& DoubleHorzBorder();
 420
 421     /**
 422         Sets the object of the wxSizerFlags to expand to fill as much area as
 423         it can.
 424     */
 425     wxSizerFlags& Expand();
 426
 427     /**
 428         Set the @c wxFIXED_MINSIZE flag which indicates that the initial size
 429         of the window should be also set as its minimal size.
 430     */
 431     wxSizerFlags& FixedMinSize();
 432
 433     /**
 434         Set the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers
 435         don't allocate space for hidden windows or other items. This flag
 436         overrides this behavior so that sufficient space is allocated for the
 437         window even if it isn't visible. This makes it possible to dynamically
 438         show and hide controls without resizing parent dialog, for example.
 439
 440         @since 2.8.8
 441     */
 442     wxSizerFlags& ReserveSpaceEvenIfHidden();
 443
 444     /**
 445         Returns the border used by default in Border() method.
 446     */
 447     static int GetDefaultBorder();
 448
 449     /**
 450         Aligns the object to the left, shortcut for @c Align(wxALIGN_LEFT)
 451
 452         @see Align()
 453     */
 454     wxSizerFlags& Left();
 455
 456     /**
 457         Sets the proportion of this wxSizerFlags to @e proportion
 458     */
 459     wxSizerFlags& Proportion(int proportion = 0);
 460
 461     /**
 462         Aligns the object to the right, shortcut for @c Align(wxALIGN_RIGHT)
 463
 464         @see Align()
 465     */
 466     wxSizerFlags& Right();
 467
 468     /**
 469         Set the @c wx_SHAPED flag which indicates that the elements should
 470         always keep the fixed width to height ratio equal to its original value.
 471     */
 472     wxSizerFlags& Shaped();
 473
 474     /**
 475         Aligns the object to the top, shortcut for @c Align(wxALIGN_TOP)
 476
 477         @see Align()
 478     */
 479     wxSizerFlags& Top();
 480
 481     /**
 482         Sets the border in the given @a direction having thrice the default
 483         border size.
 484     */
 485     wxSizerFlags& TripleBorder(int direction = wxALL);
 486 };
 487
 488
 489
 490 /**
 491     @class wxNotebookSizer
 492     @wxheader{sizer.h}
 493
 494     @deprecated
 495     This class is deprecated and should not be used in new code! It is no
 496     longer needed, wxNotebook control can be inserted
 497     into any sizer class and its minimal size will be determined correctly.
 498
 499     wxNotebookSizer is a specialized sizer to make sizers work in connection
 500     with using notebooks. This sizer is different from any other sizer as you
 501     must not add any children to it - instead, it queries the notebook class
 502     itself.  The only thing this sizer does is to determine the size of the
 503     biggest page of the notebook and report an adjusted minimal size to a more
 504     toplevel sizer.
 505
 506     @library{wxbase}
 507     @category{winlayout}
 508
 509     @see wxSizer, wxNotebook,
 510          @ref overview_sizer "Sizers overview"
 511 */
 512 class wxNotebookSizer : public wxSizer
 513 {
 514 public:
 515     /**
 516         Constructor. It takes an associated notebook as its only parameter.
 517     */
 518     wxNotebookSizer(wxNotebook* notebook);
 519
 520     /**
 521         Returns the notebook associated with the sizer.
 522     */
 523     wxNotebook* GetNotebook();
 524 };
 525
 526
 527
 528 /**
 529     @class wxFlexGridSizer
 530     @wxheader{sizer.h}
 531
 532     A flex grid sizer is a sizer which lays out its children in a two-dimensional
 533     table with all table fields in one row having the same
 534     height and all fields in one column having the same width, but all
 535     rows or all columns are not necessarily the same height or width as in
 536     the wxGridSizer.
 537
 538     Since wxWidgets 2.5.0, wxFlexGridSizer can also size items equally in one
 539     direction but unequally ("flexibly") in the other. If the sizer is only
 540     flexible in one direction (this can be changed using
 541     wxFlexGridSizer::SetFlexibleDirection),
 542     it needs to be decided how the sizer should grow in the other ("non-flexible")
 543     direction in order to fill the available space. The
 544     wxFlexGridSizer::SetNonFlexibleGrowMode method
 545     serves this purpose.
 546
 547     @library{wxcore}
 548     @category{winlayout}
 549
 550     @see wxSizer, @ref overview_sizeroverview "Sizer overview"
 551 */
 552 class wxFlexGridSizer : public wxGridSizer
 553 {
 554 public:
 555     //@{
 556     /**
 557         Constructor for a wxGridSizer. @a rows and @a cols determine the number of
 558         columns and rows in the sizer - if either of the parameters is zero, it will be
 559         calculated to form the total number of children in the sizer, thus making the
 560         sizer grow dynamically. @a vgap and @a hgap define extra space between
 561         all children.
 562     */
 563     wxFlexGridSizer(int rows, int cols, int vgap, int hgap);
 564     wxFlexGridSizer(int cols, int vgap = 0, int hgap = 0);
 565     //@}
 566
 567     /**
 568         Specifies that column @a idx (starting from zero) should be grown if
 569         there is extra space available to the sizer.
 570         The @a proportion parameter has the same meaning as the stretch factor for
 571         the sizers() except that if all proportions are 0,
 572         then all columns are resized equally (instead of not being resized at all).
 573     */
 574     void AddGrowableCol(size_t idx, int proportion = 0);
 575
 576     /**
 577         Specifies that row idx (starting from zero) should be grown if there
 578         is extra space available to the sizer.
 579         See AddGrowableCol() for the description
 580         of @a proportion parameter.
 581     */
 582     void AddGrowableRow(size_t idx, int proportion = 0);
 583
 584     /**
 585         Returns a wxOrientation value that specifies whether the sizer flexibly
 586         resizes its columns, rows, or both (default).
 587
 588         @return One of the following values:
 589
 590         @see SetFlexibleDirection()
 591     */
 592     int GetFlexibleDirection() const;
 593
 594     /**
 595         Returns the value that specifies how the sizer grows in the "non-flexible"
 596         direction if there is one.
 597
 598         @return One of the following values:
 599
 600         @see SetFlexibleDirection(),
 601              SetNonFlexibleGrowMode()
 602     */
 603     int GetNonFlexibleGrowMode() const;
 604
 605     /**
 606         Specifies that column idx is no longer growable.
 607     */
 608     void RemoveGrowableCol(size_t idx);
 609
 610     /**
 611         Specifies that row idx is no longer growable.
 612     */
 613     void RemoveGrowableRow(size_t idx);
 614
 615     /**
 616         Specifies whether the sizer should flexibly resize its columns, rows, or
 617         both. Argument @c direction can be @c wxVERTICAL, @c wxHORIZONTAL
 618         or @c wxBOTH (which is the default value). Any other value is ignored. See
 619         @ref getflexibledrection() GetFlexibleDirection for the
 620         explanation of these values.
 621         Note that this method does not trigger relayout.
 622     */
 623     void SetFlexibleDirection(int direction);
 624
 625     /**
 626         Specifies how the sizer should grow in the non-flexible direction if
 627         there is one (so
 628         SetFlexibleDirection() must have
 629         been called previously). Argument @a mode can be one of those documented in
 630         GetNonFlexibleGrowMode(), please
 631         see there for their explanation.
 632         Note that this method does not trigger relayout.
 633     */
 634     void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
 635 };
 636
 637
 638
 639 /**
 640     @class wxSizer
 641     @wxheader{sizer.h}
 642
 643     wxSizer is the abstract base class used for laying out subwindows in a window.
 644     You
 645     cannot use wxSizer directly; instead, you will have to use one of the sizer
 646     classes derived from it. Currently there are wxBoxSizer,
 647     wxStaticBoxSizer,
 648     wxGridSizer,
 649     wxFlexGridSizer,
 650     wxWrapSizer
 651      and wxGridBagSizer.
 652
 653     The layout algorithm used by sizers in wxWidgets is closely related to layout
 654     in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit.
 655     It is
 656     based upon the idea of the individual subwindows reporting their minimal
 657     required
 658     size and their ability to get stretched if the size of the parent window has
 659     changed.
 660     This will most often mean that the programmer does not set the original size of
 661     a dialog in the beginning, rather the dialog will be assigned a sizer and this
 662     sizer
 663     will be queried about the recommended size. The sizer in turn will query its
 664     children, which can be normal windows, empty space or other sizers, so that
 665     a hierarchy of sizers can be constructed. Note that wxSizer does not derive
 666     from wxWindow
 667     and thus does not interfere with tab ordering and requires very little
 668     resources compared
 669     to a real window on screen.
 670
 671     What makes sizers so well fitted for use in wxWidgets is the fact that every
 672     control
 673     reports its own minimal size and the algorithm can handle differences in font
 674     sizes
 675     or different window (dialog item) sizes on different platforms without
 676     problems. If e.g.
 677     the standard font as well as the overall design of Motif widgets requires more
 678     space than
 679     on Windows, the initial dialog size will automatically be bigger on Motif than
 680     on Windows.
 681
 682     Sizers may also be used to control the layout of custom drawn items on the
 683     window.  The Add(), Insert(), and Prepend() functions return a pointer to
 684     the newly added wxSizerItem. Just add empty space of the desired size and
 685     attributes, and then use the wxSizerItem::GetRect() method to determine
 686     where the drawing operations should take place.
 687
 688     Please notice that sizers, like child windows, are owned by the library and
 689     will be deleted by it which implies that they must be allocated on the
 690     heap.  However if you create a sizer and do not add it to another sizer or
 691     window, the library wouldn't be able to delete such an orphan sizer and in
 692     this, and only this, case it should be deleted explicitly.
 693
 694     @b wxPython note: If you wish to create a sizer class in wxPython you should
 695     derive the class from @c wxPySizer in order to get Python-aware
 696     capabilities for the various virtual methods.
 697
 698     @anchor wxsizer_flags
 699     @par wxSizer flags
 700     The "flag" argument accepted by wxSizeItem constructors and other
 701     functions, e.g. wxSizer::Add(), is OR-combination of the following flags.
 702     Two main behaviours are defined using these flags. One is the border around
 703     a window: the border parameter determines the border width whereas the
 704     flags given here determine which side(s) of the item that the border will
 705     be added.  The other flags determine how the sizer item behaves when the
 706     space allotted to the sizer changes, and is somewhat dependent on the
 707     specific kind of sizer used.
 708     @beginDefList
 709     @itemdef{wxTOP<br>
 710              wxBOTTOM<br>
 711              wxLEFT<br>
 712              wxRIGHT<br>
 713              wxALL,
 714              These flags are used to specify which side(s) of the sizer item
 715              the border width will apply to.}
 716     @itemdef{wxEXPAND,
 717              The item will be expanded to fill the space assigned to the item.}
 718     @itemdef{wxSHAPED,
 719              The item will be expanded as much as possible while also
 720              maintaining its aspect ratio.}
 721     @itemdef{wxFIXED_MINSIZE,
 722              Normally wxSizers will use GetAdjustedBestSize() to determine what
 723              the minimal size of window items should be, and will use that size
 724              to calculate the layout. This allows layouts to adjust when an
 725              item changes and its best size becomes different. If you would
 726              rather have a window item stay the size it started with then use
 727              wxFIXED_MINSIZE.}
 728     @itemdef{wxRESERVE_SPACE_EVEN_IF_HIDDEN,
 729              Normally wxSizers don't allocate space for hidden windows or other
 730              items. This flag overrides this behavior so that sufficient space
 731              is allocated for the window even if it isn't visible. This makes
 732              it possible to dynamically show and hide controls without resizing
 733              parent dialog, for example. (Available since 2.8.8.)
 734              }
 735     @itemdef{wxALIGN_CENTER<br>
 736              wxALIGN_CENTRE<br>
 737              wxALIGN_LEFT<br>
 738              wxALIGN_RIGHT<br>
 739              wxALIGN_TOP<br>
 740              wxALIGN_BOTTOM<br>
 741              wxALIGN_CENTER_VERTICAL<br>
 742              wxALIGN_CENTRE_VERTICAL<br>
 743              wxALIGN_CENTER_HORIZONTAL<br>
 744              wxALIGN_CENTRE_HORIZONTAL,
 745              The wxALIGN flags allow you to specify the alignment of the item
 746              within the space allotted to it by the sizer, adjusted for the
 747              border if any.}
 748     @endDefList
 749
 750
 751     @library{wxcore}
 752     @category{winlayout}
 753
 754     @see @ref overview_sizeroverview "Sizer overview"
 755 */
 756 class wxSizer : public wxObject
 757 {
 758 public:
 759     /**
 760         The constructor. Note that wxSizer is an abstract base class and may not
 761         be instantiated.
 762     */
 763     wxSizer();
 764
 765     /**
 766         The destructor.
 767     */
 768     ~wxSizer();
 769
 770     /**
 771         Appends a child to the sizer.
 772
 773         wxSizer itself is an abstract class, but the parameters are equivalent
 774         in the derived classes that you will instantiate to use it so they are
 775         described here:
 776
 777         @param window
 778             The window to be added to the sizer. Its initial size (either set
 779             explicitly by the user or calculated internally when using
 780             wxDefaultSize) is interpreted as the minimal and in many cases also
 781             the initial size.
 782         @param flags
 783             A wxSizerFlags object that enables you to specify most of the above
 784             parameters more conveniently.
 785     */
 786     wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags);
 787
 788     /**
 789         Appends a child to the sizer.
 790
 791         wxSizer itself is an abstract class, but the parameters are equivalent
 792         in the derived classes that you will instantiate to use it so they are
 793         described here:
 794
 795         @param window
 796             The window to be added to the sizer. Its initial size (either set
 797             explicitly by the user or calculated internally when using
 798             wxDefaultSize) is interpreted as the minimal and in many cases also
 799             the initial size.
 800         @param proportion
 801             Although the meaning of this parameter is undefined in wxSizer, it
 802             is used in wxBoxSizer to indicate if a child of a sizer can change
 803             its size in the main orientation of the wxBoxSizer - where 0 stands
 804             for not changeable and a value of more than zero is interpreted
 805             relative to the value of other children of the same wxBoxSizer. For
 806             example, you might have a horizontal wxBoxSizer with three
 807             children, two of which are supposed to change their size with the
 808             sizer. Then the two stretchable windows would get a value of 1 each
 809             to make them grow and shrink equally with the sizer's horizontal
 810             dimension.
 811         @param flag
 812             OR-combination of flags affecting sizer's behavior. See
 813             @ref wxsizer_flags "wxSizer flags list" for details.
 814         @param border
 815             Determines the border width, if the flag parameter is set to
 816             include any border flag.
 817         @param userData
 818             Allows an extra object to be attached to the sizer item, for use in
 819             derived classes when sizing information is more complex than the
 820             proportion and flag will allow for.
 821     */
 822     wxSizerItem* Add(wxWindow* window, int proportion = 0,
 823                      int flag = 0,
 824                      int border = 0,
 825                      wxObject* userData = NULL);
 826
 827     /**
 828         Appends a child to the sizer.
 829
 830         wxSizer itself is an abstract class, but the parameters are equivalent
 831         in the derived classes that you will instantiate to use it so they are
 832         described here:
 833
 834         @param sizer
 835             The (child-)sizer to be added to the sizer. This allows placing a
 836             child sizer in a sizer and thus to create hierarchies of sizers
 837             (typically a vertical box as the top sizer and several horizontal
 838             boxes on the level beneath).
 839         @param flags
 840             A wxSizerFlags object that enables you to specify most of the above
 841             parameters more conveniently.
 842     */
 843     wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags);
 844
 845     /**
 846         Appends a child to the sizer.
 847
 848         wxSizer itself is an abstract class, but the parameters are equivalent
 849         in the derived classes that you will instantiate to use it so they are
 850         described here:
 851
 852         @param sizer
 853             The (child-)sizer to be added to the sizer. This allows placing a
 854             child sizer in a sizer and thus to create hierarchies of sizers
 855             (typically a vertical box as the top sizer and several horizontal
 856             boxes on the level beneath).
 857         @param proportion
 858             Although the meaning of this parameter is undefined in wxSizer, it
 859             is used in wxBoxSizer to indicate if a child of a sizer can change
 860             its size in the main orientation of the wxBoxSizer - where 0 stands
 861             for not changeable and a value of more than zero is interpreted
 862             relative to the value of other children of the same wxBoxSizer. For
 863             example, you might have a horizontal wxBoxSizer with three
 864             children, two of which are supposed to change their size with the
 865             sizer. Then the two stretchable windows would get a value of 1 each
 866             to make them grow and shrink equally with the sizer's horizontal
 867             dimension.
 868         @param flag
 869             OR-combination of flags affecting sizer's behavior. See
 870             @ref wxsizer_flags "wxSizer flags list" for details.
 871         @param border
 872             Determines the border width, if the flag parameter is set to
 873             include any border flag.
 874         @param userData
 875             Allows an extra object to be attached to the sizer item, for use in
 876             derived classes when sizing information is more complex than the
 877             proportion and flag will allow for.
 878     */
 879     wxSizerItem* Add(wxSizer* sizer, int proportion = 0,
 880                      int flag = 0,
 881                      int border = 0,
 882                      wxObject* userData = NULL);
 883
 884     /**
 885         Appends a spacer child to the sizer.
 886
 887         wxSizer itself is an abstract class, but the parameters are equivalent
 888         in the derived classes that you will instantiate to use it so they are
 889         described here.
 890
 891         @a width and @a height specify the dimension of a spacer to be added to
 892         the sizer. Adding spacers to sizers gives more flexibility in the
 893         design of dialogs; imagine for example a horizontal box with two
 894         buttons at the bottom of a dialog: you might want to insert a space
 895         between the two buttons and make that space stretchable using the
 896         proportion flag and the result will be that the left button will be
 897         aligned with the left side of the dialog and the right button with the
 898         right side - the space in between will shrink and grow with the dialog.
 899
 900         @param width
 901             Width of the spacer.
 902         @param height
 903             Height of the spacer.
 904         @param proportion
 905             Although the meaning of this parameter is undefined in wxSizer, it
 906             is used in wxBoxSizer to indicate if a child of a sizer can change
 907             its size in the main orientation of the wxBoxSizer - where 0 stands
 908             for not changeable and a value of more than zero is interpreted
 909             relative to the value of other children of the same wxBoxSizer. For
 910             example, you might have a horizontal wxBoxSizer with three
 911             children, two of which are supposed to change their size with the
 912             sizer. Then the two stretchable windows would get a value of 1 each
 913             to make them grow and shrink equally with the sizer's horizontal
 914             dimension.
 915         @param flag
 916             OR-combination of flags affecting sizer's behavior. See
 917             @ref wxsizer_flags "wxSizer flags list" for details.
 918         @param border
 919             Determines the border width, if the flag parameter is set to
 920             include any border flag.
 921         @param userData
 922             Allows an extra object to be attached to the sizer item, for use in
 923             derived classes when sizing information is more complex than the
 924             proportion and flag will allow for.
 925     */
 926     wxSizerItem* Add(int width, int height, int proportion = 0,
 927                      int flag = 0,
 928                      int border = 0,
 929                      wxObject* userData = NULL);
 930
 931     /**
 932         Adds non-stretchable space to the sizer. More readable way of calling
 933         wxSizer::Add(size, size, 0).
 934     */
 935     wxSizerItem* AddSpacer(int size);
 936
 937     /**
 938         Adds stretchable space to the sizer. More readable way of calling
 939         wxSizer::Add(0, 0, prop).
 940     */
 941     wxSizerItem* AddStretchSpacer(int prop = 1);
 942
 943     /**
 944         This method is abstract and has to be overwritten by any derived class.
 945         Here, the sizer will do the actual calculation of its children's minimal sizes.
 946     */
 947     wxSize CalcMin();
 948
 949     /**
 950         Detaches all children from the sizer. If @a delete_windows is @true then
 951         child windows will also be deleted.
 952     */
 953     void Clear(bool delete_windows = false);
 954
 955     /**
 956         Computes client area size for @a window so that it matches the sizer's
 957         minimal size. Unlike GetMinSize(), this method accounts for other
 958         constraints imposed on @e window, namely display's size (returned size
 959         will never be too large for the display) and maximum window size if
 960         previously set by wxWindow::SetMaxSize(). The returned value is
 961         suitable for passing to wxWindow::SetClientSize() or
 962         wxWindow::SetMinClientSize().
 963
 964         @since 2.8.8
 965
 966         @see ComputeFittingWindowSize(), Fit()
 967     */
 968     wxSize ComputeFittingClientSize(wxWindow* window);
 969
 970     /**
 971         Like ComputeFittingClientSize(), but converts the result into window
 972         size. The returned value is suitable for passing to wxWindow::SetSize()
 973         or wxWindow::SetMinSize().
 974
 975         @since 2.8.8
 976
 977         @see ComputeFittingClientSize(), Fit()
 978     */
 979     wxSize ComputeFittingWindowSize(wxWindow* window);
 980
 981     //@{
 982     /**
 983         Detach a child from the sizer without destroying it. @a window is the window to
 984         be
 985         detached, @a sizer is the equivalent sizer and @a index is the position of
 986         the child in the sizer, typically 0 for the first item. This method does not
 987         cause any layout or resizing to take place, call Layout()
 988         to update the layout "on screen" after detaching a child from the sizer.
 989         Returns @true if the child item was found and detached, @false otherwise.
 990
 991         @see Remove()
 992     */
 993     bool Detach(wxWindow* window);
 994     bool Detach(wxSizer* sizer);
 995     bool Detach(size_t index);
 996     //@}
 997
 998     /**
 999         Tell the sizer to resize the @a window so that its client area matches the
1000         sizer's minimal size
1001         (ComputeFittingClientSize() is called
1002         to determine it).
1003         This is commonly done in the constructor of the window
1004         itself, see sample in the description
1005         of wxBoxSizer. Returns the new window size.
1006
1007         @see ComputeFittingClientSize(), ComputeFittingWindowSize()
1008     */
1009     wxSize Fit(wxWindow* window);
1010
1011     /**
1012         Tell the sizer to resize the virtual size of the @a window to match the sizer's
1013         minimal size.  This will not alter the on screen size of the window, but may
1014         cause the addition/removal/alteration of scrollbars required to view the virtual
1015         area in windows which manage it.
1016
1017         @see wxScrolled::SetScrollbars(), SetVirtualSizeHints()
1018     */
1019     void FitInside(wxWindow* window);
1020
1021     //@{
1022     /**
1023         Returns the list of the items in this sizer. The elements of type-safe
1024         wxList @a wxSizerItemList are objects of type
1025         @ref overview_wxsizeritem "wxSizerItem *".
1026     */
1027     wxSizerItemList& GetChildren();
1028     const wxSizerItemList& GetChildren() const;
1029     //@}
1030
1031     /**
1032         Returns the window this sizer is used in or @NULL if none.
1033     */
1034     wxWindow* GetContainingWindow() const;
1035
1036     /**
1037         Finds wxSizerItem which holds the given @a window
1038         Use parameter @a recursive to search in subsizers too.
1039         Returns pointer to item or @NULL.
1040     */
1041     wxSizerItem* GetItem(wxWindow* window, bool recursive = false);
1042
1043     /**
1044         Finds wxSizerItem which holds the given @a sizer
1045         Use parameter @a recursive to search in subsizers too.
1046         Returns pointer to item or @NULL.
1047     */
1048
1049     wxSizerItem* GetItem(wxSizer* sizer, bool recursive = false);
1050     /**
1051         Finds wxSizerItem which is located in the sizer at position
1052         @a index.
1053         Use parameter @a recursive to search in subsizers too.
1054         Returns pointer to item or @NULL.
1055     */
1056     wxSizerItem* GetItem(size_t index);
1057
1058     /**
1059         Finds item of the sizer which has the given @e id.  This @a id is not the
1060         window id but the id of the wxSizerItem itself.  This is mainly useful for
1061         retrieving the sizers created from XRC resources.
1062         Use parameter @a recursive to search in subsizers too.
1063         Returns pointer to item or @NULL.
1064     */
1065     wxSizerItem* GetItemById(int id, bool recursive = false);
1066
1067     /**
1068         Returns the minimal size of the sizer. This is either the combined minimal
1069         size of all the children and their borders or the minimal size set by
1070         SetMinSize(), depending on which is bigger.
1071         Note that the returned value is client size, not window size.
1072         In particular, if you use the value to set toplevel window's minimal or
1073         actual size, use wxWindow::SetMinClientSize
1074         or wxWindow::SetClientSize, not
1075         wxWindow::SetMinSize
1076         or wxWindow::SetSize.
1077     */
1078     wxSize GetMinSize();
1079
1080     /**
1081         Returns the current position of the sizer.
1082     */
1083     wxPoint GetPosition();
1084
1085     /**
1086         Returns the current size of the sizer.
1087     */
1088     wxSize GetSize();
1089
1090     //@{
1091     /**
1092         Hides the @e window, @e sizer, or item at @e index.
1093         To make a sizer item disappear, use Hide() followed by Layout().
1094         Use parameter @a recursive to hide elements found in subsizers.
1095         Returns @true if the child item was found, @false otherwise.
1096
1097         @see IsShown(), Show()
1098     */
1099     bool Hide(wxWindow* window, bool recursive = false);
1100     bool Hide(wxSizer* sizer, bool recursive = false);
1101     bool Hide(size_t index);
1102     //@}
1103
1104     //@{
1105     /**
1106         Insert a child into the sizer before any existing item at
1107
1108         See Add() for the meaning of the other parameters.
1109
1110         @param index The position this child should assume in the sizer.
1111     */
1112     wxSizerItem* Insert(size_t index, wxWindow* window,
1113                         const wxSizerFlags& flags);
1114     wxSizerItem* Insert(size_t index, wxWindow* window,
1115                         int proportion = 0,
1116                         int flag = 0,
1117                         int border = 0,
1118                         wxObject* userData = NULL);
1119     wxSizerItem* Insert(size_t index, wxSizer* sizer,
1120                         const wxSizerFlags& flags);
1121     wxSizerItem* Insert(size_t index, wxSizer* sizer,
1122                         int proportion = 0,
1123                         int flag = 0,
1124                         int border = 0,
1125                         wxObject* userData = NULL);
1126     wxSizerItem* Insert(size_t index, int width, int height,
1127                         int proportion = 0,
1128                         int flag = 0,
1129                         int border = 0,
1130                         wxObject* userData = NULL);
1131     //@}
1132
1133     /**
1134         Inserts non-stretchable space to the sizer. More readable way of calling
1135         wxSizer::Insert(size, size, 0).
1136     */
1137     wxSizerItem* InsertSpacer(size_t index, int size);
1138
1139     /**
1140         Inserts stretchable space to the sizer. More readable way of calling
1141         wxSizer::Insert(0, 0, prop).
1142     */
1143     wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
1144
1145     /**
1146         Returns @true if the @e window is shown.
1147
1148         @see Hide(), Show(), wxSizerItem::IsShown()
1149     */
1150     bool IsShown(wxWindow* window) const;
1151
1152     /**
1153         Returns @true if the @e sizer is shown.
1154
1155         @see Hide(), Show(), wxSizerItem::IsShown()
1156     */
1157     bool IsShown(wxSizer* sizer) const;
1158
1159     /**
1160         Returns @true if the item at @a index is shown.
1161
1162         @see Hide(), Show(), wxSizerItem::IsShown()
1163     */
1164     bool IsShown(size_t index) const;
1165
1166     /**
1167         Call this to force layout of the children anew, e.g. after having added a child
1168         to or removed a child (window, other sizer or space) from the sizer while
1169         keeping
1170         the current dimension.
1171     */
1172     void Layout();
1173
1174     /**
1175         Same as Add(), but prepends the items to the beginning of the
1176         list of items (windows, subsizers or spaces) owned by this sizer.
1177     */
1178     wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags);
1179
1180     /**
1181         Same as Add(), but prepends the items to the beginning of the
1182         list of items (windows, subsizers or spaces) owned by this sizer.
1183     */
1184     wxSizerItem* Prepend(wxWindow* window, int proportion = 0,
1185                          int flag = 0,
1186                          int border = 0,
1187                          wxObject* userData = NULL);
1188
1189     /**
1190         Same as Add(), but prepends the items to the beginning of the
1191         list of items (windows, subsizers or spaces) owned by this sizer.
1192     */
1193     wxSizerItem* Prepend(wxSizer* sizer,
1194                          const wxSizerFlags& flags);
1195
1196     /**
1197         Same as Add(), but prepends the items to the beginning of the
1198         list of items (windows, subsizers or spaces) owned by this sizer.
1199     */
1200     wxSizerItem* Prepend(wxSizer* sizer, int proportion = 0,
1201                          int flag = 0,
1202                          int border = 0,
1203                          wxObject* userData = NULL);
1204
1205     /**
1206         Same as Add(), but prepends the items to the beginning of the
1207         list of items (windows, subsizers or spaces) owned by this sizer.
1208     */
1209     wxSizerItem* Prepend(int width, int height,
1210                          int proportion = 0,
1211                          int flag = 0,
1212                          int border = 0,
1213                          wxObject* userData = NULL);
1214
1215     /**
1216         Prepends non-stretchable space to the sizer. More readable way of
1217         calling wxSizer::Prepend(size, size, 0).
1218     */
1219     wxSizerItem* PrependSpacer(int size);
1220
1221     /**
1222         Prepends stretchable space to the sizer. More readable way of calling
1223         wxSizer::Prepend(0, 0, prop).
1224     */
1225     wxSizerItem* PrependStretchSpacer(int prop = 1);
1226
1227     /**
1228         This method is abstract and has to be overwritten by any derived class.
1229         Here, the sizer will do the actual calculation of its children's
1230         positions and sizes.
1231     */
1232     void RecalcSizes();
1233
1234     /**
1235         Removes a child window from the sizer, but does @b not destroy it
1236         (because windows are owned by their parent window, not the sizer).
1237
1238         @deprecated
1239         The overload of this method taking a wxWindow* parameter
1240         is deprecated as it does not destroy the window as would usually be
1241         expected from Remove(). You should use Detach() in new code instead.
1242         There is currently no wxSizer method that will both detach and destroy
1243         a wxWindow item.
1244
1245         @note This method does not cause any layout or resizing to take
1246               place, call Layout() to update the layout "on screen" after
1247               removing a child from the sizer.
1248
1249         @return @true if the child item was found and removed, @false otherwise.
1250     */
1251     bool Remove(wxWindow* window);
1252
1253     /**
1254         Removes a sizer child from the sizer and destroys it.
1255
1256         @note This method does not cause any layout or resizing to take
1257               place, call Layout() to update the layout "on screen" after
1258               removing a child from the sizer.
1259
1260         @param sizer The wxSizer to be removed.
1261
1262         @return @true if the child item was found and removed, @false otherwise.
1263     */
1264     bool Remove(wxSizer* sizer);
1265
1266     /**
1267         Removes a child from the sizer and destroys it if it is a sizer or a
1268         spacer, but not if it is a window (because windows are owned by their
1269         parent window, not the sizer).
1270
1271         @note This method does not cause any layout or resizing to take
1272               place, call Layout() to update the layout "on screen" after
1273               removing a child from the sizer.
1274
1275         @param index  The position of the child in the sizer, e.g. 0 for the
1276                       first item.
1277
1278         @return @true if the child item was found and removed, @false otherwise.
1279     */
1280     bool Remove(size_t index);
1281
1282     //@{
1283     /**
1284         Detaches the given @e oldwin, @a oldsz child from the sizer and
1285         replaces it with the given window, sizer, or wxSizerItem.
1286         The detached child is removed @b only if it is a sizer or a spacer
1287         (because windows are owned by their parent window, not the sizer).
1288         Use parameter @a recursive to search the given element recursively in subsizers.
1289
1290         This method does not cause any layout or resizing to take place, call
1291         Layout() to update the layout "on screen" after replacing a
1292         child from the sizer.
1293         Returns @true if the child item was found and removed, @false otherwise.
1294     */
1295     bool Replace(wxWindow* oldwin, wxWindow* newwin,
1296                  bool recursive = false);
1297     bool Replace(wxSizer* oldsz, wxSizer* newsz,
1298                  bool recursive = false);
1299     bool Remove(size_t oldindex, wxSizerItem* newitem);
1300     //@}
1301
1302     /**
1303         Call this to force the sizer to take the given dimension and thus force
1304         the items owned by the sizer to resize themselves according to the
1305         rules defined by the parameter in the Add() and Prepend() methods.
1306     */
1307     void SetDimension(int x, int y, int width, int height);
1308     void SetDimension(const wxPoint& pos, const wxSize& size);
1309
1310     //@{
1311     /**
1312         Set an item's minimum size by window, sizer, or position.
1313
1314         The item will be found recursively in the sizer's descendants. This
1315         function enables an application to set the size of an item after
1316         initial creation.
1317
1318         @see wxSizerItem::SetMinSize()
1319     */
1320     void SetItemMinSize(wxWindow* window, int width, int height);
1321     void SetItemMinSize(wxSizer* sizer, int width, int height);
1322     void SetItemMinSize(size_t index, int width, int height);
1323     //@}
1324
1325     /**
1326         Call this to give the sizer a minimal size. Normally, the sizer will
1327         calculate its minimal size based purely on how much space its children
1328         need. After calling this method GetMinSize() will return either the
1329         minimal size as requested by its children or the minimal size set here,
1330         depending on which is bigger.
1331     */
1332     void SetMinSize(const wxSize& size);
1333
1334     /**
1335         @overload
1336      */
1337     void SetMinSize(int width, int height);
1338
1339     /**
1340         This method first calls Fit() and then
1341         wxTopLevelWindow::SetSizeHints on the @e window
1342         passed to it. This only makes sense when @a window is actually a
1343         wxTopLevelWindow such as a wxFrame or a
1344         wxDialog, since SetSizeHints only has any effect in these classes.
1345         It does nothing in normal windows or controls.
1346         This method is implicitly used by wxWindow::SetSizerAndFit
1347         which is commonly invoked in the constructor of a toplevel window itself (see
1348         the sample in the description of wxBoxSizer) if the
1349         toplevel window is resizable.
1350     */
1351     void SetSizeHints(wxWindow* window);
1352
1353     /**
1354         Tell the sizer to set the minimal size of the @a window virtual area to match
1355         the sizer's
1356         minimal size. For windows with managed scrollbars this will set them
1357         appropriately.
1358
1359         @see wxScrolled::SetScrollbars()
1360     */
1361     void SetVirtualSizeHints(wxWindow* window);
1362
1363     //@{
1364     /**
1365         Shows or hides the @e window, @e sizer, or item at @e index.
1366         To make a sizer item disappear or reappear, use Show() followed by Layout().
1367         Use parameter @a recursive to show or hide elements found in subsizers.
1368         Returns @true if the child item was found, @false otherwise.
1369
1370         @see Hide(), IsShown()
1371     */
1372     bool Show(wxWindow* window, bool show = true,
1373               bool recursive = false);
1374     bool Show(wxSizer* sizer, bool show = true,
1375               bool recursive = false);
1376     bool Show(size_t index, bool show = true);
1377     //@}
1378 };
1379
1380
1381
1382 /**
1383     @class wxGridSizer
1384     @wxheader{sizer.h}
1385
1386     A grid sizer is a sizer which lays out its children in a two-dimensional
1387     table with all table fields having the same size,
1388     i.e. the width of each field is the width of the widest child,
1389     the height of each field is the height of the tallest child.
1390
1391     @library{wxcore}
1392     @category{winlayout}
1393
1394     @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1395 */
1396 class wxGridSizer : public wxSizer
1397 {
1398 public:
1399     //@{
1400     /**
1401         Constructor for a wxGridSizer. @a rows and @a cols determine the number of
1402         columns and rows in the sizer - if either of the parameters is zero, it will be
1403         calculated to form the total number of children in the sizer, thus making the
1404         sizer grow dynamically. @a vgap and @a hgap define extra space between
1405         all children.
1406     */
1407     wxGridSizer(int rows, int cols, int vgap, int hgap);
1408     wxGridSizer(int cols, int vgap = 0, int hgap = 0);
1409     //@}
1410
1411     /**
1412         Returns the number of columns in the sizer.
1413     */
1414     int GetCols();
1415
1416     /**
1417         Returns the horizontal gap (in pixels) between cells in the sizer.
1418     */
1419     int GetHGap();
1420
1421     /**
1422         Returns the number of rows in the sizer.
1423     */
1424     int GetRows();
1425
1426     /**
1427         Returns the vertical gap (in pixels) between the cells in the sizer.
1428     */
1429     int GetVGap();
1430
1431     /**
1432         Sets the number of columns in the sizer.
1433     */
1434     void SetCols(int cols);
1435
1436     /**
1437         Sets the horizontal gap (in pixels) between cells in the sizer.
1438     */
1439     void SetHGap(int gap);
1440
1441     /**
1442         Sets the number of rows in the sizer.
1443     */
1444     void SetRows(int rows);
1445
1446     /**
1447         Sets the vertical gap (in pixels) between the cells in the sizer.
1448     */
1449     void SetVGap(int gap);
1450 };
1451
1452
1453
1454 /**
1455     @class wxStaticBoxSizer
1456     @wxheader{sizer.h}
1457
1458     wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
1459     box around the sizer. This static box may be either created independently or
1460     the sizer may create it itself as a convenience. In any case, the sizer owns
1461     the wxStaticBox control and will delete it if it is
1462     deleted.
1463
1464     @library{wxcore}
1465     @category{winlayout}
1466
1467     @see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizeroverview "Sizer
1468     overview"
1469 */
1470 class wxStaticBoxSizer : public wxBoxSizer
1471 {
1472 public:
1473     //@{
1474     /**
1475         The first constructor uses an already existing static box. It takes the
1476         associated static box and the orientation @e orient, which can be either
1477         @c wxVERTICAL or @c wxHORIZONTAL as parameters.
1478         The second one creates a new static box with the given label and parent window.
1479     */
1480     wxStaticBoxSizer(wxStaticBox* box, int orient);
1481     wxStaticBoxSizer(int orient, wxWindow parent,
1482                      const wxString& label = wxEmptyString);
1483     //@}
1484
1485     /**
1486         Returns the static box associated with the sizer.
1487     */
1488     wxStaticBox* GetStaticBox();
1489 };
1490
1491
1492
1493 /**
1494     @class wxBoxSizer
1495     @wxheader{sizer.h}
1496
1497     The basic idea behind a box sizer is that windows will most often be laid out
1498     in rather
1499     simple basic geometry, typically in a row or a column or several hierarchies of
1500     either.
1501
1502     For more information, please see @ref overview_boxsizerprogramming "Programming
1503     with wxBoxSizer".
1504
1505     @library{wxcore}
1506     @category{winlayout}
1507
1508     @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1509 */
1510 class wxBoxSizer : public wxSizer
1511 {
1512 public:
1513     /**
1514         Constructor for a wxBoxSizer. @a orient may be either of wxVERTICAL
1515         or wxHORIZONTAL for creating either a column sizer or a row sizer.
1516     */
1517     wxBoxSizer(int orient);
1518
1519     /**
1520         Implements the calculation of a box sizer's minimal. It is used internally
1521         only and must not be called by the user. Documented for information.
1522     */
1523     wxSize CalcMin();
1524
1525     /**
1526         Returns the orientation of the box sizer, either wxVERTICAL
1527         or wxHORIZONTAL.
1528     */
1529     int GetOrientation();
1530
1531     /**
1532         Implements the calculation of a box sizer's dimensions and then sets
1533         the size of its children (calling wxWindow::SetSize
1534         if the child is a window). It is used internally only and must not be called
1535         by the user (call Layout() if you want to resize). Documented for information.
1536     */
1537     void RecalcSizes();
1538 };
1539