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