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