interface/sizer.h

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