]>
git.saurik.com Git - wxWidgets.git/blob - interface/sizer.h
1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: interface of wxStdDialogButtonSizer
4 // Author: wxWidgets team
6 // Licence: wxWindows license
7 /////////////////////////////////////////////////////////////////////////////
10 @class wxStdDialogButtonSizer
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.
21 When there aren't interface guidelines defined for a particular platform or
22 toolkit, wxStdDialogButtonSizer reverts
23 to the Windows implementation.
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.
31 If you add a button with wxID_SAVE, on Mac OS X the button will be renamed to
33 the wxID_NO button will be renamed to "Don't Save" in accordance with the Mac
34 OS X Human Interface Guidelines.
39 @see wxSizer, @ref overview_sizeroverview "Sizer overview",
40 wxDialog::CreateButtonSizer
42 class wxStdDialogButtonSizer
: public wxBoxSizer
46 Constructor for a wxStdDialogButtonSizer.
48 wxStdDialogButtonSizer();
51 Adds a button to the wxStdDialogButtonSizer. The button must have one of the
52 following identifiers:
63 void AddButton(wxButton
* button
);
66 Rearranges the buttons and applies proper spacing between buttons to make them
67 match the platform or toolkit's interface guidelines.
72 Sets the affirmative button for the sizer. This allows you to use identifiers
73 other than the standard identifiers outlined above.
75 void SetAffirmativeButton(wxButton
* button
);
78 Sets the cancel button for the sizer. This allows you to use identifiers other
79 than the standard identifiers outlined above.
81 void SetCancelButton(wxButton
* button
);
84 Sets the negative button for the sizer. This allows you to use identifiers
85 other than the standard identifiers outlined above.
87 void SetNegativeButton(wxButton
* button
);
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.
105 class wxSizerItem
: public wxObject
110 Construct a sizer item for tracking a subsizer.
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
,
118 wxSizerItem(wxSizer
* window
, const wxSizerFlags
& flags
);
119 wxSizerItem(wxSizer
* sizer
, int proportion
, int flag
,
125 Deletes the user data and subsizer, if any.
130 Calculates the minimum desired size for the item, including any space
136 Destroy the window or the windows in a subsizer, depending on the type
139 void DeleteWindows();
142 Enable deleting the SizerItem without destroying the contained sizer.
147 Return the border attribute.
149 int GetBorder() const;
152 Return the flags attribute.
154 See @ref wxsizer_flags "wxSizer flags list" for details.
159 Return the numeric id of wxSizerItem, or @c wxID_NONE if the id has
165 Get the minimum size needed for the item.
167 wxSize
GetMinSize() const;
170 Sets the minimum size to be allocated for this item.
172 If this item is a window, the @a size is also passed to
173 wxWindow::SetMinSize().
175 void SetMinSize(const wxSize
& size
);
180 void SetMinSize(int x
, int y
);
183 What is the current position of the item, as set in the last Layout.
185 wxPoint
GetPosition() const;
188 Get the proportion item attribute.
190 int GetProportion() const;
193 Get the ration item attribute.
195 float GetRatio() const;
198 Get the rectangle of the item on the parent window, excluding borders.
203 Get the current size of the item, as set in the last Layout.
205 wxSize
GetSize() const;
208 If this item is tracking a sizer, return it. @NULL otherwise.
210 wxSizer
* GetSizer() const;
213 If this item is tracking a spacer, return its size.
215 const wxSize
GetSpacer() const;
218 Get the userData item attribute.
220 wxObject
* GetUserData() const;
223 If this item is tracking a window then return it. @NULL otherwise.
225 wxWindow
* GetWindow() const;
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.
231 In other words, for sizer items, all of the child elements must be
232 hidden for the sizer itself to be considered hidden.
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()).
238 bool IsShown() const;
241 Is this item a sizer?
243 bool IsSizer() const;
246 Is this item a spacer?
248 bool IsSpacer() const;
251 Is this item a window?
253 bool IsWindow() const;
256 Set the border item attribute.
258 void SetBorder(int border
);
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.
265 void SetDimension(const wxPoint
& pos
, const wxSize
& size
);
268 Set the flag item attribute.
270 void SetFlag(int flag
);
273 Sets the numeric id of the wxSizerItem to @e id.
280 void SetInitSize(int x
, int y
);
283 Set the proportion item attribute.
285 void SetProportion(int proportion
);
289 Set the ratio item attribute.
291 void SetRatio(int width
, int height
);
292 void SetRatio(wxSize size
);
293 void SetRatio(float ratio
);
297 Set the sizer tracked by this item.
299 void SetSizer(wxSizer
* sizer
);
302 Set the size of the spacer tracked by this item.
304 void SetSpacer(const wxSize
& size
);
307 Set the window to be tracked by thsi item.
309 void SetWindow(wxWindow
* window
);
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.
316 void Show(bool show
);
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
332 sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
338 sizer->Add(ctrl, wxSizerFlags().Expand().Border(10));
341 This is more readable and also allows you to create wxSizerFlags objects which
342 can be reused for several sizer items.
345 wxSizerFlags flagsExpand(1);
346 flagsExpand.Expand().Border(10);
348 sizer->Add(ctrl1, flagsExpand);
349 sizer->Add(ctrl2, flagsExpand);
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
365 Creates the wxSizer with the proportion specified by @e proportion.
367 wxSizerFlags(int proportion
= 0);
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.
373 @see Top(), Left(), Right(), Bottom(), Centre()
375 wxSizerFlags
& Align(int align
= 0);
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.
381 wxSizerFlags
& Border(int direction
, int borderinpixels
);
384 Sets the wxSizerFlags to have a border with size as returned by
387 @param direction Direction(s) to apply the border in.
389 wxSizerFlags
& Border(int direction
= wxALL
);
392 Aligns the object to the bottom, shortcut for @c Align(wxALIGN_BOTTOM).
396 wxSizerFlags
& Bottom();
399 Sets the object of the wxSizerFlags to center itself in the area it is
402 wxSizerFlags
& Center();
405 Center() for people with the other dialect of English.
407 wxSizerFlags
& Centre();
410 Sets the border in the given @a direction having twice the default
413 wxSizerFlags
& DoubleBorder(int direction
= wxALL
);
416 Sets the border in left and right directions having twice the default
419 wxSizerFlags
& DoubleHorzBorder();
422 Sets the object of the wxSizerFlags to expand to fill as much area as
425 wxSizerFlags
& Expand();
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.
431 wxSizerFlags
& FixedMinSize();
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.
442 wxSizerFlags
& ReserveSpaceEvenIfHidden();
445 Returns the border used by default in Border() method.
447 static int GetDefaultBorder();
450 Aligns the object to the left, shortcut for @c Align(wxALIGN_LEFT)
454 wxSizerFlags
& Left();
457 Sets the proportion of this wxSizerFlags to @e proportion
459 wxSizerFlags
& Proportion(int proportion
= 0);
462 Aligns the object to the right, shortcut for @c Align(wxALIGN_RIGHT)
466 wxSizerFlags
& Right();
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.
472 wxSizerFlags
& Shaped();
475 Aligns the object to the top, shortcut for @c Align(wxALIGN_TOP)
482 Sets the border in the given @a direction having thrice the default
485 wxSizerFlags
& TripleBorder(int direction
= wxALL
);
491 @class wxNotebookSizer
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.
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
509 @see wxSizer, wxNotebook,
510 @ref overview_sizer "Sizers overview"
512 class wxNotebookSizer
: public wxSizer
516 Constructor. It takes an associated notebook as its only parameter.
518 wxNotebookSizer(wxNotebook
* notebook
);
521 Returns the notebook associated with the sizer.
523 wxNotebook
* GetNotebook();
529 @class wxFlexGridSizer
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
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
550 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
552 class wxFlexGridSizer
: public wxGridSizer
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
563 wxFlexGridSizer(int rows
, int cols
, int vgap
, int hgap
);
564 wxFlexGridSizer(int cols
, int vgap
= 0, int hgap
= 0);
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).
574 void AddGrowableCol(size_t idx
, int proportion
= 0);
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.
582 void AddGrowableRow(size_t idx
, int proportion
= 0);
585 Returns a wxOrientation value that specifies whether the sizer flexibly
586 resizes its columns, rows, or both (default).
588 @return One of the following values:
590 @see SetFlexibleDirection()
592 int GetFlexibleDirection() const;
595 Returns the value that specifies how the sizer grows in the "non-flexible"
596 direction if there is one.
598 @return One of the following values:
600 @see SetFlexibleDirection(),
601 SetNonFlexibleGrowMode()
603 int GetNonFlexibleGrowMode() const;
606 Specifies that column idx is no longer growable.
608 void RemoveGrowableCol(size_t idx
);
611 Specifies that row idx is no longer growable.
613 void RemoveGrowableRow(size_t idx
);
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.
623 void SetFlexibleDirection(int direction
);
626 Specifies how the sizer should grow in the non-flexible direction if
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.
634 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode
);
643 wxSizer is the abstract base class used for laying out subwindows in a window.
645 cannot use wxSizer directly; instead, you will have to use one of the sizer
646 classes derived from it. Currently there are wxBoxSizer,
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.
656 based upon the idea of the individual subwindows reporting their minimal
658 size and their ability to get stretched if the size of the parent window has
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
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
667 and thus does not interfere with tab ordering and requires very little
669 to a real window on screen.
671 What makes sizers so well fitted for use in wxWidgets is the fact that every
673 reports its own minimal size and the algorithm can handle differences in font
675 or different window (dialog item) sizes on different platforms without
677 the standard font as well as the overall design of Motif widgets requires more
679 on Windows, the initial dialog size will automatically be bigger on Motif than
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.
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.
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.
698 @anchor 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.
714 These flags are used to specify which side(s) of the sizer item
715 the border width will apply to.}
717 The item will be expanded to fill the space assigned to the item.}
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
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.)
735 @itemdef{wxALIGN_CENTER<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
754 @see @ref overview_sizeroverview "Sizer overview"
756 class wxSizer
: public wxObject
760 The constructor. Note that wxSizer is an abstract base class and may not
771 Appends a child to the sizer.
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
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
783 A wxSizerFlags object that enables you to specify most of the above
784 parameters more conveniently.
786 wxSizerItem
* Add(wxWindow
* window
, const wxSizerFlags
& flags
);
789 Appends a child to the sizer.
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
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
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
812 OR-combination of flags affecting sizer's behavior. See
813 @ref wxsizer_flags "wxSizer flags list" for details.
815 Determines the border width, if the flag parameter is set to
816 include any border flag.
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.
822 wxSizerItem
* Add(wxWindow
* window
, int proportion
= 0,
825 wxObject
* userData
= NULL
);
828 Appends a child to the sizer.
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
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).
840 A wxSizerFlags object that enables you to specify most of the above
841 parameters more conveniently.
843 wxSizerItem
* Add(wxSizer
* sizer
, const wxSizerFlags
& flags
);
846 Appends a child to the sizer.
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
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).
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
869 OR-combination of flags affecting sizer's behavior. See
870 @ref wxsizer_flags "wxSizer flags list" for details.
872 Determines the border width, if the flag parameter is set to
873 include any border flag.
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.
879 wxSizerItem
* Add(wxSizer
* sizer
, int proportion
= 0,
882 wxObject
* userData
= NULL
);
885 Appends a spacer child to the sizer.
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
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.
903 Height of the spacer.
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
916 OR-combination of flags affecting sizer's behavior. See
917 @ref wxsizer_flags "wxSizer flags list" for details.
919 Determines the border width, if the flag parameter is set to
920 include any border flag.
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.
926 wxSizerItem
* Add(int width
, int height
, int proportion
= 0,
929 wxObject
* userData
= NULL
);
932 Adds non-stretchable space to the sizer. More readable way of calling
933 wxSizer::Add(size, size, 0).
935 wxSizerItem
* AddSpacer(int size
);
938 Adds stretchable space to the sizer. More readable way of calling
939 wxSizer::Add(0, 0, prop).
941 wxSizerItem
* AddStretchSpacer(int prop
= 1);
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.
950 Detaches all children from the sizer. If @a delete_windows is @true then
951 child windows will also be deleted.
953 void Clear(bool delete_windows
= false);
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().
966 @see ComputeFittingWindowSize(), Fit()
968 wxSize
ComputeFittingClientSize(wxWindow
* window
);
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().
977 @see ComputeFittingClientSize(), Fit()
979 wxSize
ComputeFittingWindowSize(wxWindow
* window
);
983 Detach a child from the sizer without destroying it. @a window is the window to
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.
993 bool Detach(wxWindow
* window
);
994 bool Detach(wxSizer
* sizer
);
995 bool Detach(size_t index
);
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
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.
1007 @see ComputeFittingClientSize(), ComputeFittingWindowSize()
1009 wxSize
Fit(wxWindow
* window
);
1012 Tell the sizer to resize the virtual size of the @a window to match the sizer's
1013 minimal size. This will not alter the on screen size of the window, but may
1014 cause the addition/removal/alteration of scrollbars required to view the virtual
1015 area in windows which manage it.
1017 @see wxScrolled::SetScrollbars(), SetVirtualSizeHints()
1019 void FitInside(wxWindow
* window
);
1023 Returns the list of the items in this sizer. The elements of type-safe
1024 wxList @a wxSizerItemList are objects of type
1025 @ref overview_wxsizeritem "wxSizerItem *".
1027 wxSizerItemList
& GetChildren();
1028 const wxSizerItemList
& GetChildren() const;
1032 Returns the window this sizer is used in or @NULL if none.
1034 wxWindow
* GetContainingWindow() const;
1037 Finds wxSizerItem which holds the given @a window
1038 Use parameter @a recursive to search in subsizers too.
1039 Returns pointer to item or @NULL.
1041 wxSizerItem
* GetItem(wxWindow
* window
, bool recursive
= false);
1044 Finds wxSizerItem which holds the given @a sizer
1045 Use parameter @a recursive to search in subsizers too.
1046 Returns pointer to item or @NULL.
1049 wxSizerItem
* GetItem(wxSizer
* sizer
, bool recursive
= false);
1051 Finds wxSizerItem which is located in the sizer at position
1053 Use parameter @a recursive to search in subsizers too.
1054 Returns pointer to item or @NULL.
1056 wxSizerItem
* GetItem(size_t index
);
1059 Finds item of the sizer which has the given @e id. This @a id is not the
1060 window id but the id of the wxSizerItem itself. This is mainly useful for
1061 retrieving the sizers created from XRC resources.
1062 Use parameter @a recursive to search in subsizers too.
1063 Returns pointer to item or @NULL.
1065 wxSizerItem
* GetItemById(int id
, bool recursive
= false);
1068 Returns the minimal size of the sizer. This is either the combined minimal
1069 size of all the children and their borders or the minimal size set by
1070 SetMinSize(), depending on which is bigger.
1071 Note that the returned value is client size, not window size.
1072 In particular, if you use the value to set toplevel window's minimal or
1073 actual size, use wxWindow::SetMinClientSize
1074 or wxWindow::SetClientSize, not
1075 wxWindow::SetMinSize
1076 or wxWindow::SetSize.
1078 wxSize
GetMinSize();
1081 Returns the current position of the sizer.
1083 wxPoint
GetPosition();
1086 Returns the current size of the sizer.
1092 Hides the @e window, @e sizer, or item at @e index.
1093 To make a sizer item disappear, use Hide() followed by Layout().
1094 Use parameter @a recursive to hide elements found in subsizers.
1095 Returns @true if the child item was found, @false otherwise.
1097 @see IsShown(), Show()
1099 bool Hide(wxWindow
* window
, bool recursive
= false);
1100 bool Hide(wxSizer
* sizer
, bool recursive
= false);
1101 bool Hide(size_t index
);
1106 Insert a child into the sizer before any existing item at
1108 See Add() for the meaning of the other parameters.
1110 @param index The position this child should assume in the sizer.
1112 wxSizerItem
* Insert(size_t index
, wxWindow
* window
,
1113 const wxSizerFlags
& flags
);
1114 wxSizerItem
* Insert(size_t index
, wxWindow
* window
,
1118 wxObject
* userData
= NULL
);
1119 wxSizerItem
* Insert(size_t index
, wxSizer
* sizer
,
1120 const wxSizerFlags
& flags
);
1121 wxSizerItem
* Insert(size_t index
, wxSizer
* sizer
,
1125 wxObject
* userData
= NULL
);
1126 wxSizerItem
* Insert(size_t index
, int width
, int height
,
1130 wxObject
* userData
= NULL
);
1134 Inserts non-stretchable space to the sizer. More readable way of calling
1135 wxSizer::Insert(size, size, 0).
1137 wxSizerItem
* InsertSpacer(size_t index
, int size
);
1140 Inserts stretchable space to the sizer. More readable way of calling
1141 wxSizer::Insert(0, 0, prop).
1143 wxSizerItem
* InsertStretchSpacer(size_t index
, int prop
= 1);
1146 Returns @true if the @e window is shown.
1148 @see Hide(), Show(), wxSizerItem::IsShown()
1150 bool IsShown(wxWindow
* window
) const;
1153 Returns @true if the @e sizer is shown.
1155 @see Hide(), Show(), wxSizerItem::IsShown()
1157 bool IsShown(wxSizer
* sizer
) const;
1160 Returns @true if the item at @a index is shown.
1162 @see Hide(), Show(), wxSizerItem::IsShown()
1164 bool IsShown(size_t index
) const;
1167 Call this to force layout of the children anew, e.g. after having added a child
1168 to or removed a child (window, other sizer or space) from the sizer while
1170 the current dimension.
1175 Same as Add(), but prepends the items to the beginning of the
1176 list of items (windows, subsizers or spaces) owned by this sizer.
1178 wxSizerItem
* Prepend(wxWindow
* window
, const wxSizerFlags
& flags
);
1181 Same as Add(), but prepends the items to the beginning of the
1182 list of items (windows, subsizers or spaces) owned by this sizer.
1184 wxSizerItem
* Prepend(wxWindow
* window
, int proportion
= 0,
1187 wxObject
* userData
= NULL
);
1190 Same as Add(), but prepends the items to the beginning of the
1191 list of items (windows, subsizers or spaces) owned by this sizer.
1193 wxSizerItem
* Prepend(wxSizer
* sizer
,
1194 const wxSizerFlags
& flags
);
1197 Same as Add(), but prepends the items to the beginning of the
1198 list of items (windows, subsizers or spaces) owned by this sizer.
1200 wxSizerItem
* Prepend(wxSizer
* sizer
, int proportion
= 0,
1203 wxObject
* userData
= NULL
);
1206 Same as Add(), but prepends the items to the beginning of the
1207 list of items (windows, subsizers or spaces) owned by this sizer.
1209 wxSizerItem
* Prepend(int width
, int height
,
1213 wxObject
* userData
= NULL
);
1216 Prepends non-stretchable space to the sizer. More readable way of
1217 calling wxSizer::Prepend(size, size, 0).
1219 wxSizerItem
* PrependSpacer(int size
);
1222 Prepends stretchable space to the sizer. More readable way of calling
1223 wxSizer::Prepend(0, 0, prop).
1225 wxSizerItem
* PrependStretchSpacer(int prop
= 1);
1228 This method is abstract and has to be overwritten by any derived class.
1229 Here, the sizer will do the actual calculation of its children's
1230 positions and sizes.
1235 Removes a child window from the sizer, but does @b not destroy it
1236 (because windows are owned by their parent window, not the sizer).
1239 The overload of this method taking a wxWindow* parameter
1240 is deprecated as it does not destroy the window as would usually be
1241 expected from Remove(). You should use Detach() in new code instead.
1242 There is currently no wxSizer method that will both detach and destroy
1245 @note This method does not cause any layout or resizing to take
1246 place, call Layout() to update the layout "on screen" after
1247 removing a child from the sizer.
1249 @return @true if the child item was found and removed, @false otherwise.
1251 bool Remove(wxWindow
* window
);
1254 Removes a sizer child from the sizer and destroys it.
1256 @note This method does not cause any layout or resizing to take
1257 place, call Layout() to update the layout "on screen" after
1258 removing a child from the sizer.
1260 @param sizer The wxSizer to be removed.
1262 @return @true if the child item was found and removed, @false otherwise.
1264 bool Remove(wxSizer
* sizer
);
1267 Removes a child from the sizer and destroys it if it is a sizer or a
1268 spacer, but not if it is a window (because windows are owned by their
1269 parent window, not the sizer).
1271 @note This method does not cause any layout or resizing to take
1272 place, call Layout() to update the layout "on screen" after
1273 removing a child from the sizer.
1275 @param index The position of the child in the sizer, e.g. 0 for the
1278 @return @true if the child item was found and removed, @false otherwise.
1280 bool Remove(size_t index
);
1284 Detaches the given @e oldwin, @a oldsz child from the sizer and
1285 replaces it with the given window, sizer, or wxSizerItem.
1286 The detached child is removed @b only if it is a sizer or a spacer
1287 (because windows are owned by their parent window, not the sizer).
1288 Use parameter @a recursive to search the given element recursively in subsizers.
1290 This method does not cause any layout or resizing to take place, call
1291 Layout() to update the layout "on screen" after replacing a
1292 child from the sizer.
1293 Returns @true if the child item was found and removed, @false otherwise.
1295 bool Replace(wxWindow
* oldwin
, wxWindow
* newwin
,
1296 bool recursive
= false);
1297 bool Replace(wxSizer
* oldsz
, wxSizer
* newsz
,
1298 bool recursive
= false);
1299 bool Remove(size_t oldindex
, wxSizerItem
* newitem
);
1303 Call this to force the sizer to take the given dimension and thus force
1304 the items owned by the sizer to resize themselves according to the
1305 rules defined by the parameter in the Add() and Prepend() methods.
1307 void SetDimension(int x
, int y
, int width
, int height
);
1308 void SetDimension(const wxPoint
& pos
, const wxSize
& size
);
1312 Set an item's minimum size by window, sizer, or position.
1314 The item will be found recursively in the sizer's descendants. This
1315 function enables an application to set the size of an item after
1318 @see wxSizerItem::SetMinSize()
1320 void SetItemMinSize(wxWindow
* window
, int width
, int height
);
1321 void SetItemMinSize(wxSizer
* sizer
, int width
, int height
);
1322 void SetItemMinSize(size_t index
, int width
, int height
);
1326 Call this to give the sizer a minimal size. Normally, the sizer will
1327 calculate its minimal size based purely on how much space its children
1328 need. After calling this method GetMinSize() will return either the
1329 minimal size as requested by its children or the minimal size set here,
1330 depending on which is bigger.
1332 void SetMinSize(const wxSize
& size
);
1337 void SetMinSize(int width
, int height
);
1340 This method first calls Fit() and then
1341 wxTopLevelWindow::SetSizeHints on the @e window
1342 passed to it. This only makes sense when @a window is actually a
1343 wxTopLevelWindow such as a wxFrame or a
1344 wxDialog, since SetSizeHints only has any effect in these classes.
1345 It does nothing in normal windows or controls.
1346 This method is implicitly used by wxWindow::SetSizerAndFit
1347 which is commonly invoked in the constructor of a toplevel window itself (see
1348 the sample in the description of wxBoxSizer) if the
1349 toplevel window is resizable.
1351 void SetSizeHints(wxWindow
* window
);
1354 Tell the sizer to set the minimal size of the @a window virtual area to match
1356 minimal size. For windows with managed scrollbars this will set them
1359 @see wxScrolled::SetScrollbars()
1361 void SetVirtualSizeHints(wxWindow
* window
);
1365 Shows or hides the @e window, @e sizer, or item at @e index.
1366 To make a sizer item disappear or reappear, use Show() followed by Layout().
1367 Use parameter @a recursive to show or hide elements found in subsizers.
1368 Returns @true if the child item was found, @false otherwise.
1370 @see Hide(), IsShown()
1372 bool Show(wxWindow
* window
, bool show
= true,
1373 bool recursive
= false);
1374 bool Show(wxSizer
* sizer
, bool show
= true,
1375 bool recursive
= false);
1376 bool Show(size_t index
, bool show
= true);
1386 A grid sizer is a sizer which lays out its children in a two-dimensional
1387 table with all table fields having the same size,
1388 i.e. the width of each field is the width of the widest child,
1389 the height of each field is the height of the tallest child.
1392 @category{winlayout}
1394 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1396 class wxGridSizer
: public wxSizer
1401 Constructor for a wxGridSizer. @a rows and @a cols determine the number of
1402 columns and rows in the sizer - if either of the parameters is zero, it will be
1403 calculated to form the total number of children in the sizer, thus making the
1404 sizer grow dynamically. @a vgap and @a hgap define extra space between
1407 wxGridSizer(int rows
, int cols
, int vgap
, int hgap
);
1408 wxGridSizer(int cols
, int vgap
= 0, int hgap
= 0);
1412 Returns the number of columns in the sizer.
1417 Returns the horizontal gap (in pixels) between cells in the sizer.
1422 Returns the number of rows in the sizer.
1427 Returns the vertical gap (in pixels) between the cells in the sizer.
1432 Sets the number of columns in the sizer.
1434 void SetCols(int cols
);
1437 Sets the horizontal gap (in pixels) between cells in the sizer.
1439 void SetHGap(int gap
);
1442 Sets the number of rows in the sizer.
1444 void SetRows(int rows
);
1447 Sets the vertical gap (in pixels) between the cells in the sizer.
1449 void SetVGap(int gap
);
1455 @class wxStaticBoxSizer
1458 wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
1459 box around the sizer. This static box may be either created independently or
1460 the sizer may create it itself as a convenience. In any case, the sizer owns
1461 the wxStaticBox control and will delete it if it is
1465 @category{winlayout}
1467 @see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizeroverview "Sizer
1470 class wxStaticBoxSizer
: public wxBoxSizer
1475 The first constructor uses an already existing static box. It takes the
1476 associated static box and the orientation @e orient, which can be either
1477 @c wxVERTICAL or @c wxHORIZONTAL as parameters.
1478 The second one creates a new static box with the given label and parent window.
1480 wxStaticBoxSizer(wxStaticBox
* box
, int orient
);
1481 wxStaticBoxSizer(int orient
, wxWindow parent
,
1482 const wxString
& label
= wxEmptyString
);
1486 Returns the static box associated with the sizer.
1488 wxStaticBox
* GetStaticBox();
1497 The basic idea behind a box sizer is that windows will most often be laid out
1499 simple basic geometry, typically in a row or a column or several hierarchies of
1502 For more information, please see @ref overview_boxsizerprogramming "Programming
1506 @category{winlayout}
1508 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1510 class wxBoxSizer
: public wxSizer
1514 Constructor for a wxBoxSizer. @a orient may be either of wxVERTICAL
1515 or wxHORIZONTAL for creating either a column sizer or a row sizer.
1517 wxBoxSizer(int orient
);
1520 Implements the calculation of a box sizer's minimal. It is used internally
1521 only and must not be called by the user. Documented for information.
1526 Returns the orientation of the box sizer, either wxVERTICAL
1529 int GetOrientation();
1532 Implements the calculation of a box sizer's dimensions and then sets
1533 the size of its children (calling wxWindow::SetSize
1534 if the child is a window). It is used internally only and must not be called
1535 by the user (call Layout() if you want to resize). Documented for information.