]>
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 What is the current position of the item, as set in the last Layout.
172 wxPoint
GetPosition() const;
175 Get the proportion item attribute.
177 int GetProportion() const;
180 Get the ration item attribute.
182 float GetRatio() const;
185 Get the rectangle of the item on the parent window, excluding borders.
190 Get the current size of the item, as set in the last Layout.
192 wxSize
GetSize() const;
195 If this item is tracking a sizer, return it. @NULL otherwise.
197 wxSizer
* GetSizer() const;
200 If this item is tracking a spacer, return its size.
202 const wxSize
GetSpacer() const;
205 Get the userData item attribute.
207 wxObject
* GetUserData() const;
210 If this item is tracking a window then return it. @NULL otherwise.
212 wxWindow
* GetWindow() const;
215 Returns @true if this item is a window or a spacer and it is shown or
216 if this item is a sizer and not all of its elements are hidden.
218 In other words, for sizer items, all of the child elements must be
219 hidden for the sizer itself to be considered hidden.
221 As an exception, if the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was
222 used for this sizer item, then IsShown() always returns @true for it
223 (see wxSizerFlags::ReserveSpaceEvenIfHidden()).
225 bool IsShown() const;
228 Is this item a sizer?
230 bool IsSizer() const;
233 Is this item a spacer?
235 bool IsSpacer() const;
238 Is this item a window?
240 bool IsWindow() const;
243 Set the border item attribute.
245 void SetBorder(int border
);
248 Set the position and size of the space allocated to the sizer, and
249 adjust the position and size of the item to be within that space
250 taking alignment and borders into account.
252 void SetDimension(const wxPoint
& pos
, const wxSize
& size
);
255 Set the flag item attribute.
257 void SetFlag(int flag
);
260 Sets the numeric id of the wxSizerItem to @e id.
267 void SetInitSize(int x
, int y
);
270 Set the proportion item attribute.
272 void SetProportion(int proportion
);
276 Set the ratio item attribute.
278 void SetRatio(int width
, int height
);
279 void SetRatio(wxSize size
);
280 void SetRatio(float ratio
);
284 Set the sizer tracked by this item.
286 void SetSizer(wxSizer
* sizer
);
289 Set the size of the spacer tracked by this item.
291 void SetSpacer(const wxSize
& size
);
294 Set the window to be tracked by thsi item.
296 void SetWindow(wxWindow
* window
);
299 Set the show item attribute, which sizers use to determine if the item
300 is to be made part of the layout or not. If the item is tracking a
301 window then it is shown or hidden as needed.
303 void Show(bool show
);
312 Normally, when you add an item to a sizer via
313 wxSizer::Add, you have to specify a lot of flags and
314 parameters which can be unwieldy. This is where wxSizerFlags comes in: it
315 allows you to specify all parameters using the named methods instead. For
319 sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
325 sizer->Add(ctrl, wxSizerFlags().Expand().Border(10));
328 This is more readable and also allows you to create wxSizerFlags objects which
329 can be reused for several sizer items.
332 wxSizerFlags flagsExpand(1);
333 flagsExpand.Expand().Border(10);
335 sizer->Add(ctrl1, flagsExpand);
336 sizer->Add(ctrl2, flagsExpand);
339 Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
340 object itself to allowing chaining multiple methods calls like in the examples
352 Creates the wxSizer with the proportion specified by @e proportion.
354 wxSizerFlags(int proportion
= 0);
357 Sets the alignment of this wxSizerFlags to @e align.
358 Note that if this method is not called, the wxSizerFlags has no specified
361 @see Top(), Left(), Right(),
364 wxSizerFlags
Align(int align
= 0);
368 Sets the wxSizerFlags to have a border of a number of pixels specified by
369 @a borderinpixels with the directions specified by @e direction.
370 In the overloaded version without @a borderinpixels parameter, the border of
371 default size, as returned by GetDefaultBorder(),
374 wxSizerFlags
Border(int direction
, int borderinpixels
);
375 wxSizerFlags
Border(int direction
= wxALL
);
379 Aligns the object to the bottom, shortcut for @c Align(wxALIGN_BOTTOM)
383 wxSizerFlags
Bottom();
386 Sets the object of the wxSizerFlags to center itself in the area it is given.
388 wxSizerFlags
Center();
391 Center() for people with the other dialect of english.
393 wxSizerFlags
Centre();
396 Sets the border in the given @a direction having twice the default border
399 wxSizerFlags
DoubleBorder(int direction
= wxALL
);
402 Sets the border in left and right directions having twice the default border
405 wxSizerFlags
DoubleHorzBorder();
408 Sets the object of the wxSizerFlags to expand to fill as much area as it can.
410 wxSizerFlags
Expand();
413 Set the @c wxFIXED_MINSIZE flag which indicates that the initial size of
414 the window should be also set as its minimal size.
416 wxSizerFlags
FixedMinSize();
419 Set the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers
420 don't allocate space for hidden windows or other items. This flag
421 overrides this behavior so that sufficient space is allocated for the
422 window even if it isn't visible. This makes it possible to dynamically
423 show and hide controls without resizing parent dialog, for example.
427 wxSizerFlags
& ReserveSpaceEvenIfHidden();
430 Returns the border used by default in Border() method.
432 static int GetDefaultBorder();
435 Aligns the object to the left, shortcut for @c Align(wxALIGN_LEFT)
442 Sets the proportion of this wxSizerFlags to @e proportion
444 wxSizerFlags
Proportion(int proportion
= 0);
447 Aligns the object to the right, shortcut for @c Align(wxALIGN_RIGHT)
451 wxSizerFlags
Right();
454 Set the @c wx_SHAPED flag which indicates that the elements should
455 always keep the fixed width to height ratio equal to its original value.
457 wxSizerFlags
Shaped();
460 Aligns the object to the top, shortcut for @c Align(wxALIGN_TOP)
467 Sets the border in the given @a direction having thrice the default border
470 wxSizerFlags
TripleBorder(int direction
= wxALL
);
476 @class wxNotebookSizer
480 This class is deprecated and should not be used in new code! It is no
481 longer needed, wxNotebook control can be inserted
482 into any sizer class and its minimal size will be determined correctly.
484 wxNotebookSizer is a specialized sizer to make sizers work in connection
485 with using notebooks. This sizer is different from any other sizer as you
486 must not add any children to it - instead, it queries the notebook class
487 itself. The only thing this sizer does is to determine the size of the
488 biggest page of the notebook and report an adjusted minimal size to a more
494 @see wxSizer, wxNotebook,
495 @ref overview_sizer "Sizers overview"
497 class wxNotebookSizer
: public wxSizer
501 Constructor. It takes an associated notebook as its only parameter.
503 wxNotebookSizer(wxNotebook
* notebook
);
506 Returns the notebook associated with the sizer.
508 wxNotebook
* GetNotebook();
514 @class wxFlexGridSizer
517 A flex grid sizer is a sizer which lays out its children in a two-dimensional
518 table with all table fields in one row having the same
519 height and all fields in one column having the same width, but all
520 rows or all columns are not necessarily the same height or width as in
523 Since wxWidgets 2.5.0, wxFlexGridSizer can also size items equally in one
524 direction but unequally ("flexibly") in the other. If the sizer is only
525 flexible in one direction (this can be changed using
526 wxFlexGridSizer::SetFlexibleDirection),
527 it needs to be decided how the sizer should grow in the other ("non-flexible")
528 direction in order to fill the available space. The
529 wxFlexGridSizer::SetNonFlexibleGrowMode method
535 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
537 class wxFlexGridSizer
: public wxGridSizer
542 Constructor for a wxGridSizer. @a rows and @a cols determine the number of
543 columns and rows in the sizer - if either of the parameters is zero, it will be
544 calculated to form the total number of children in the sizer, thus making the
545 sizer grow dynamically. @a vgap and @a hgap define extra space between
548 wxFlexGridSizer(int rows
, int cols
, int vgap
, int hgap
);
549 wxFlexGridSizer(int cols
, int vgap
= 0, int hgap
= 0);
553 Specifies that column @a idx (starting from zero) should be grown if
554 there is extra space available to the sizer.
555 The @a proportion parameter has the same meaning as the stretch factor for
556 the sizers() except that if all proportions are 0,
557 then all columns are resized equally (instead of not being resized at all).
559 void AddGrowableCol(size_t idx
, int proportion
= 0);
562 Specifies that row idx (starting from zero) should be grown if there
563 is extra space available to the sizer.
564 See AddGrowableCol() for the description
565 of @a proportion parameter.
567 void AddGrowableRow(size_t idx
, int proportion
= 0);
570 Returns a wxOrientation value that specifies whether the sizer flexibly
571 resizes its columns, rows, or both (default).
573 @returns One of the following values:
575 @see SetFlexibleDirection()
577 int GetFlexibleDirection() const;
580 Returns the value that specifies how the sizer grows in the "non-flexible"
581 direction if there is one.
583 @returns One of the following values:
585 @see SetFlexibleDirection(),
586 SetNonFlexibleGrowMode()
588 int GetNonFlexibleGrowMode() const;
591 Specifies that column idx is no longer growable.
593 void RemoveGrowableCol(size_t idx
);
596 Specifies that row idx is no longer growable.
598 void RemoveGrowableRow(size_t idx
);
601 Specifies whether the sizer should flexibly resize its columns, rows, or
602 both. Argument @c direction can be @c wxVERTICAL, @c wxHORIZONTAL
603 or @c wxBOTH (which is the default value). Any other value is ignored. See
604 @ref getflexibledrection() GetFlexibleDirection for the
605 explanation of these values.
606 Note that this method does not trigger relayout.
608 void SetFlexibleDirection(int direction
);
611 Specifies how the sizer should grow in the non-flexible direction if
613 SetFlexibleDirection() must have
614 been called previously). Argument @a mode can be one of those documented in
615 GetNonFlexibleGrowMode(), please
616 see there for their explanation.
617 Note that this method does not trigger relayout.
619 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode
);
628 wxSizer is the abstract base class used for laying out subwindows in a window.
630 cannot use wxSizer directly; instead, you will have to use one of the sizer
631 classes derived from it. Currently there are wxBoxSizer,
638 The layout algorithm used by sizers in wxWidgets is closely related to layout
639 in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit.
641 based upon the idea of the individual subwindows reporting their minimal
643 size and their ability to get stretched if the size of the parent window has
645 This will most often mean that the programmer does not set the original size of
646 a dialog in the beginning, rather the dialog will be assigned a sizer and this
648 will be queried about the recommended size. The sizer in turn will query its
649 children, which can be normal windows, empty space or other sizers, so that
650 a hierarchy of sizers can be constructed. Note that wxSizer does not derive
652 and thus does not interfere with tab ordering and requires very little
654 to a real window on screen.
656 What makes sizers so well fitted for use in wxWidgets is the fact that every
658 reports its own minimal size and the algorithm can handle differences in font
660 or different window (dialog item) sizes on different platforms without
662 the standard font as well as the overall design of Motif widgets requires more
664 on Windows, the initial dialog size will automatically be bigger on Motif than
667 Sizers may also be used to control the layout of custom drawn items on the
668 window. The Add(), Insert(), and Prepend() functions return a pointer to
669 the newly added wxSizerItem. Just add empty space of the desired size and
670 attributes, and then use the wxSizerItem::GetRect() method to determine
671 where the drawing operations should take place.
673 Please notice that sizers, like child windows, are owned by the library and
674 will be deleted by it which implies that they must be allocated on the
675 heap. However if you create a sizer and do not add it to another sizer or
676 window, the library wouldn't be able to delete such an orphan sizer and in
677 this, and only this, case it should be deleted explicitly.
679 @b wxPython note: If you wish to create a sizer class in wxPython you should
680 derive the class from @c wxPySizer in order to get Python-aware
681 capabilities for the various virtual methods.
683 @anchor wxsizer_flags
685 The "flag" argument accepted by wxSizeItem constructors and other
686 functions, e.g. wxSizer::Add(), is OR-combination of the following flags.
687 Two main behaviours are defined using these flags. One is the border around
688 a window: the border parameter determines the border width whereas the
689 flags given here determine which side(s) of the item that the border will
690 be added. The other flags determine how the sizer item behaves when the
691 space allotted to the sizer changes, and is somewhat dependent on the
692 specific kind of sizer used.
699 These flags are used to specify which side(s) of the sizer item
700 the border width will apply to.}
702 The item will be expanded to fill the space assigned to the item.}
704 The item will be expanded as much as possible while also
705 maintaining its aspect ratio.}
706 @itemdef{wxFIXED_MINSIZE,
707 Normally wxSizers will use GetAdjustedBestSize() to determine what
708 the minimal size of window items should be, and will use that size
709 to calculate the layout. This allows layouts to adjust when an
710 item changes and its best size becomes different. If you would
711 rather have a window item stay the size it started with then use
713 @itemdef{wxRESERVE_SPACE_EVEN_IF_HIDDEN,
714 Normally wxSizers don't allocate space for hidden windows or other
715 items. This flag overrides this behavior so that sufficient space
716 is allocated for the window even if it isn't visible. This makes
717 it possible to dynamically show and hide controls without resizing
718 parent dialog, for example. (Available since 2.8.8.)
720 @itemdef{wxALIGN_CENTER<br>
726 wxALIGN_CENTER_VERTICAL<br>
727 wxALIGN_CENTRE_VERTICAL<br>
728 wxALIGN_CENTER_HORIZONTAL<br>
729 wxALIGN_CENTRE_HORIZONTAL,
730 The wxALIGN flags allow you to specify the alignment of the item
731 within the space allotted to it by the sizer, adjusted for the
739 @see @ref overview_sizeroverview "Sizer overview"
741 class wxSizer
: public wxObject
745 The constructor. Note that wxSizer is an abstract base class and may not
756 Appends a child to the sizer.
758 wxSizer itself is an abstract class, but the parameters are equivalent
759 in the derived classes that you will instantiate to use it so they are
763 The window to be added to the sizer. Its initial size (either set
764 explicitly by the user or calculated internally when using
765 wxDefaultSize) is interpreted as the minimal and in many cases also
768 A wxSizerFlags object that enables you to specify most of the above
769 parameters more conveniently.
771 wxSizerItem
* Add(wxWindow
* window
, const wxSizerFlags
& flags
);
774 Appends a child to the sizer.
776 wxSizer itself is an abstract class, but the parameters are equivalent
777 in the derived classes that you will instantiate to use it so they are
781 The window to be added to the sizer. Its initial size (either set
782 explicitly by the user or calculated internally when using
783 wxDefaultSize) is interpreted as the minimal and in many cases also
786 Although the meaning of this parameter is undefined in wxSizer, it
787 is used in wxBoxSizer to indicate if a child of a sizer can change
788 its size in the main orientation of the wxBoxSizer - where 0 stands
789 for not changeable and a value of more than zero is interpreted
790 relative to the value of other children of the same wxBoxSizer. For
791 example, you might have a horizontal wxBoxSizer with three
792 children, two of which are supposed to change their size with the
793 sizer. Then the two stretchable windows would get a value of 1 each
794 to make them grow and shrink equally with the sizer's horizontal
797 OR-combination of flags affecting sizer's behavior. See
798 @ref wxsizer_flags "wxSizer flags list" for details.
800 Determines the border width, if the flag parameter is set to
801 include any border flag.
803 Allows an extra object to be attached to the sizer item, for use in
804 derived classes when sizing information is more complex than the
805 proportion and flag will allow for.
807 wxSizerItem
* Add(wxWindow
* window
, int proportion
= 0,
810 wxObject
* userData
= NULL
);
813 Appends a child to the sizer.
815 wxSizer itself is an abstract class, but the parameters are equivalent
816 in the derived classes that you will instantiate to use it so they are
820 The (child-)sizer to be added to the sizer. This allows placing a
821 child sizer in a sizer and thus to create hierarchies of sizers
822 (typically a vertical box as the top sizer and several horizontal
823 boxes on the level beneath).
825 A wxSizerFlags object that enables you to specify most of the above
826 parameters more conveniently.
828 wxSizerItem
* Add(wxSizer
* sizer
, const wxSizerFlags
& flags
);
831 Appends a child to the sizer.
833 wxSizer itself is an abstract class, but the parameters are equivalent
834 in the derived classes that you will instantiate to use it so they are
838 The (child-)sizer to be added to the sizer. This allows placing a
839 child sizer in a sizer and thus to create hierarchies of sizers
840 (typically a vertical box as the top sizer and several horizontal
841 boxes on the level beneath).
843 Although the meaning of this parameter is undefined in wxSizer, it
844 is used in wxBoxSizer to indicate if a child of a sizer can change
845 its size in the main orientation of the wxBoxSizer - where 0 stands
846 for not changeable and a value of more than zero is interpreted
847 relative to the value of other children of the same wxBoxSizer. For
848 example, you might have a horizontal wxBoxSizer with three
849 children, two of which are supposed to change their size with the
850 sizer. Then the two stretchable windows would get a value of 1 each
851 to make them grow and shrink equally with the sizer's horizontal
854 OR-combination of flags affecting sizer's behavior. See
855 @ref wxsizer_flags "wxSizer flags list" for details.
857 Determines the border width, if the flag parameter is set to
858 include any border flag.
860 Allows an extra object to be attached to the sizer item, for use in
861 derived classes when sizing information is more complex than the
862 proportion and flag will allow for.
864 wxSizerItem
* Add(wxSizer
* sizer
, int proportion
= 0,
867 wxObject
* userData
= NULL
);
870 Appends a spacer child to the sizer.
872 wxSizer itself is an abstract class, but the parameters are equivalent
873 in the derived classes that you will instantiate to use it so they are
876 @a width and @a height specify the dimension of a spacer to be added to
877 the sizer. Adding spacers to sizers gives more flexibility in the
878 design of dialogs; imagine for example a horizontal box with two
879 buttons at the bottom of a dialog: you might want to insert a space
880 between the two buttons and make that space stretchable using the
881 proportion flag and the result will be that the left button will be
882 aligned with the left side of the dialog and the right button with the
883 right side - the space in between will shrink and grow with the dialog.
888 Height of the spacer.
890 Although the meaning of this parameter is undefined in wxSizer, it
891 is used in wxBoxSizer to indicate if a child of a sizer can change
892 its size in the main orientation of the wxBoxSizer - where 0 stands
893 for not changeable and a value of more than zero is interpreted
894 relative to the value of other children of the same wxBoxSizer. For
895 example, you might have a horizontal wxBoxSizer with three
896 children, two of which are supposed to change their size with the
897 sizer. Then the two stretchable windows would get a value of 1 each
898 to make them grow and shrink equally with the sizer's horizontal
901 OR-combination of flags affecting sizer's behavior. See
902 @ref wxsizer_flags "wxSizer flags list" for details.
904 Determines the border width, if the flag parameter is set to
905 include any border flag.
907 Allows an extra object to be attached to the sizer item, for use in
908 derived classes when sizing information is more complex than the
909 proportion and flag will allow for.
911 wxSizerItem
* Add(int width
, int height
, int proportion
= 0,
914 wxObject
* userData
= NULL
);
917 Adds non-stretchable space to the sizer. More readable way of calling
918 wxSizer::Add(size, size, 0).
920 wxSizerItem
* AddSpacer(int size
);
923 Adds stretchable space to the sizer. More readable way of calling
924 wxSizer::Add(0, 0, prop).
926 wxSizerItem
* AddStretchSpacer(int prop
= 1);
929 This method is abstract and has to be overwritten by any derived class.
930 Here, the sizer will do the actual calculation of its children's minimal sizes.
935 Detaches all children from the sizer. If @a delete_windows is @true then
936 child windows will also be deleted.
938 void Clear(bool delete_windows
= false);
941 Computes client area size for @a window so that it matches the sizer's
942 minimal size. Unlike GetMinSize(), this method accounts for other
943 constraints imposed on @e window, namely display's size (returned size
944 will never be too large for the display) and maximum window size if
945 previously set by wxWindow::SetMaxSize(). The returned value is
946 suitable for passing to wxWindow::SetClientSize() or
947 wxWindow::SetMinClientSize().
951 @see ComputeFittingWindowSize(), Fit()
953 wxSize
ComputeFittingClientSize(wxWindow
* window
);
956 Like ComputeFittingClientSize(), but converts the result into window
957 size. The returned value is suitable for passing to wxWindow::SetSize()
958 or wxWindow::SetMinSize().
962 @see ComputeFittingClientSize(), Fit()
964 wxSize
ComputeFittingWindowSize(wxWindow
* window
);
968 Detach a child from the sizer without destroying it. @a window is the window to
970 detached, @a sizer is the equivalent sizer and @a index is the position of
971 the child in the sizer, typically 0 for the first item. This method does not
972 cause any layout or resizing to take place, call Layout()
973 to update the layout "on screen" after detaching a child from the sizer.
974 Returns @true if the child item was found and detached, @false otherwise.
978 bool Detach(wxWindow
* window
);
979 bool Detach(wxSizer
* sizer
);
980 bool Detach(size_t index
);
984 Tell the sizer to resize the @a window so that its client area matches the
986 (ComputeFittingClientSize() is called
988 This is commonly done in the constructor of the window
989 itself, see sample in the description
990 of wxBoxSizer. Returns the new window size.
992 @see ComputeFittingClientSize(), ComputeFittingWindowSize()
994 wxSize
Fit(wxWindow
* window
);
997 Tell the sizer to resize the virtual size of the @a window to match the sizer's
998 minimal size. This will not alter the on screen size of the window, but may
1000 the addition/removal/alteration of scrollbars required to view the virtual area
1002 windows which manage it.
1004 @see wxScrolledWindow::SetScrollbars, SetVirtualSizeHints()
1006 void FitInside(wxWindow
* window
);
1010 Returns the list of the items in this sizer. The elements of type-safe
1011 wxList @c wxSizerItemList are objects of type
1012 @ref overview_wxsizeritem "wxSizerItem *".
1014 const wxSizerItemList
GetChildren();
1015 const wxSizerItemList
GetChildren();
1019 Returns the window this sizer is used in or @NULL if none.
1021 wxWindow
* GetContainingWindow() const;
1025 Finds item of the sizer which holds given @e window, @a sizer or is located
1026 in sizer at position @e index.
1027 Use parameter @a recursive to search in subsizers too.
1028 Returns pointer to item or @NULL.
1030 wxSizerItem
* GetItem(wxWindow
* window
, bool recursive
= false);
1031 wxSizerItem
* GetItem(wxSizer
* sizer
, bool recursive
= false);
1032 wxSizerItem
* GetItem(size_t index
);
1036 Finds item of the sizer which has the given @e id. This @a id is not the
1037 window id but the id of the wxSizerItem itself. This is mainly useful for
1038 retrieving the sizers created from XRC resources.
1039 Use parameter @a recursive to search in subsizers too.
1040 Returns pointer to item or @NULL.
1042 wxSizerItem
* GetItemById(int id
, bool recursive
= false);
1045 Returns the minimal size of the sizer. This is either the combined minimal
1046 size of all the children and their borders or the minimal size set by
1047 SetMinSize(), depending on which is bigger.
1048 Note that the returned value is client size, not window size.
1049 In particular, if you use the value to set toplevel window's minimal or
1050 actual size, use wxWindow::SetMinClientSize
1051 or wxWindow::SetClientSize, not
1052 wxWindow::SetMinSize
1053 or wxWindow::SetSize.
1055 wxSize
GetMinSize();
1058 Returns the current position of the sizer.
1060 wxPoint
GetPosition();
1063 Returns the current size of the sizer.
1069 Hides the @e window, @e sizer, or item at @e index.
1070 To make a sizer item disappear, use Hide() followed by Layout().
1071 Use parameter @a recursive to hide elements found in subsizers.
1072 Returns @true if the child item was found, @false otherwise.
1074 @see IsShown(), Show()
1076 bool Hide(wxWindow
* window
, bool recursive
= false);
1077 bool Hide(wxSizer
* sizer
, bool recursive
= false);
1078 bool Hide(size_t index
);
1083 Insert a child into the sizer before any existing item at
1085 See Add() for the meaning of the other parameters.
1087 @param index The position this child should assume in the sizer.
1089 wxSizerItem
* Insert(size_t index
, wxWindow
* window
,
1090 const wxSizerFlags
& flags
);
1091 wxSizerItem
* Insert(size_t index
, wxWindow
* window
,
1095 wxObject
* userData
= NULL
);
1096 wxSizerItem
* Insert(size_t index
, wxSizer
* sizer
,
1097 const wxSizerFlags
& flags
);
1098 wxSizerItem
* Insert(size_t index
, wxSizer
* sizer
,
1102 wxObject
* userData
= NULL
);
1103 wxSizerItem
* Insert(size_t index
, int width
, int height
,
1107 wxObject
* userData
= NULL
);
1111 Inserts non-stretchable space to the sizer. More readable way of calling
1112 wxSizer::Insert(size, size, 0).
1114 wxSizerItem
* InsertSpacer(size_t index
, int size
);
1117 Inserts stretchable space to the sizer. More readable way of calling
1118 wxSizer::Insert(0, 0, prop).
1120 wxSizerItem
* InsertStretchSpacer(size_t index
, int prop
= 1);
1123 Returns @true if the @e window is shown.
1125 @see Hide(), Show(), wxSizerItem::IsShown()
1127 bool IsShown(wxWindow
* window
) const;
1130 Returns @true if the @e sizer is shown.
1132 @see Hide(), Show(), wxSizerItem::IsShown()
1134 bool IsShown(wxSizer
* sizer
) const;
1137 Returns @true if the item at @a index is shown.
1139 @see Hide(), Show(), wxSizerItem::IsShown()
1141 bool IsShown(size_t index
) const;
1144 Call this to force layout of the children anew, e.g. after having added a child
1145 to or removed a child (window, other sizer or space) from the sizer while
1147 the current dimension.
1152 Same as Add(), but prepends the items to the beginning of the
1153 list of items (windows, subsizers or spaces) owned by this sizer.
1155 wxSizerItem
* Prepend(wxWindow
* window
, const wxSizerFlags
& flags
);
1158 Same as Add(), but prepends the items to the beginning of the
1159 list of items (windows, subsizers or spaces) owned by this sizer.
1161 wxSizerItem
* Prepend(wxWindow
* window
, int proportion
= 0,
1164 wxObject
* userData
= NULL
);
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.
1170 wxSizerItem
* Prepend(wxSizer
* sizer
,
1171 const wxSizerFlags
& flags
);
1174 Same as Add(), but prepends the items to the beginning of the
1175 list of items (windows, subsizers or spaces) owned by this sizer.
1177 wxSizerItem
* Prepend(wxSizer
* sizer
, int proportion
= 0,
1180 wxObject
* userData
= NULL
);
1183 Same as Add(), but prepends the items to the beginning of the
1184 list of items (windows, subsizers or spaces) owned by this sizer.
1186 wxSizerItem
* Prepend(int width
, int height
,
1190 wxObject
* userData
= NULL
);
1193 Prepends non-stretchable space to the sizer. More readable way of
1194 calling wxSizer::Prepend(size, size, 0).
1196 wxSizerItem
* PrependSpacer(int size
);
1199 Prepends stretchable space to the sizer. More readable way of calling
1200 wxSizer::Prepend(0, 0, prop).
1202 wxSizerItem
* PrependStretchSpacer(int prop
= 1);
1205 This method is abstract and has to be overwritten by any derived class.
1206 Here, the sizer will do the actual calculation of its children's
1207 positions and sizes.
1212 Removes a child window from the sizer, but does @b not destroy it
1213 (because windows are owned by their parent window, not the sizer).
1216 The overload of this method taking a wxWindow* parameter
1217 is deprecated as it does not destroy the window as would usually be
1218 expected from Remove(). You should use Detach() in new code instead.
1219 There is currently no wxSizer method that will both detach and destroy
1222 @note This method does not cause any layout or resizing to take
1223 place, call Layout() to update the layout "on screen" after
1224 removing a child from the sizer.
1226 @return @true if the child item was found and removed, @false otherwise.
1228 bool Remove(wxWindow
* window
);
1231 Removes a sizer child from the sizer and destroys it.
1233 @note This method does not cause any layout or resizing to take
1234 place, call Layout() to update the layout "on screen" after
1235 removing a child from the sizer.
1237 @param sizer The wxSizer to be removed.
1239 @return @true if the child item was found and removed, @false otherwise.
1241 bool Remove(wxSizer
* sizer
);
1244 Removes a child from the sizer and destroys it if it is a sizer or a
1245 spacer, but not if it is a window (because windows are owned by their
1246 parent window, not the sizer).
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.
1252 @param index The position of the child in the sizer, e.g. 0 for the
1255 @return @true if the child item was found and removed, @false otherwise.
1257 bool Remove(size_t index
);
1261 Detaches the given @e oldwin, @a oldsz child from the sizer and
1262 replaces it with the given window, sizer, or wxSizerItem.
1263 The detached child is removed @b only if it is a sizer or a spacer
1264 (because windows are owned by their parent window, not the sizer).
1265 Use parameter @a recursive to search the given element recursively in subsizers.
1267 This method does not cause any layout or resizing to take place, call
1268 Layout() to update the layout "on screen" after replacing a
1269 child from the sizer.
1270 Returns @true if the child item was found and removed, @false otherwise.
1272 bool Replace(wxWindow
* oldwin
, wxWindow
* newwin
,
1273 bool recursive
= false);
1274 bool Replace(wxSizer
* oldsz
, wxSizer
* newsz
,
1275 bool recursive
= false);
1276 bool Remove(size_t oldindex
, wxSizerItem
* newitem
);
1280 Call this to force the sizer to take the given dimension and thus force
1281 the items owned by the sizer to resize themselves according to the
1282 rules defined by the parameter in the Add() and Prepend() methods.
1284 void SetDimension(int x
, int y
, int width
, int height
);
1288 Set an item's minimum size by window, sizer, or position. The item will be
1290 in the sizer's descendants. This function enables an application to set the
1292 after initial creation.
1294 void SetItemMinSize(wxWindow
* window
, int width
, int height
);
1295 void SetItemMinSize(wxSizer
* sizer
, int width
, int height
);
1296 void SetItemMinSize(size_t index
, int width
, int height
);
1300 Call this to give the sizer a minimal size. Normally, the sizer will
1301 calculate its minimal size based purely on how much space its children
1302 need. After calling this method GetMinSize() will return either the
1303 minimal size as requested by its children or the minimal size set here,
1304 depending on which is bigger.
1306 void SetMinSize(const wxSize
& size
);
1311 void SetMinSize(int width
, int height
);
1314 This method first calls Fit() and then
1315 wxTopLevelWindow::SetSizeHints on the @e window
1316 passed to it. This only makes sense when @a window is actually a
1317 wxTopLevelWindow such as a wxFrame or a
1318 wxDialog, since SetSizeHints only has any effect in these classes.
1319 It does nothing in normal windows or controls.
1320 This method is implicitly used by wxWindow::SetSizerAndFit
1321 which is commonly invoked in the constructor of a toplevel window itself (see
1322 the sample in the description of wxBoxSizer) if the
1323 toplevel window is resizable.
1325 void SetSizeHints(wxWindow
* window
);
1328 Tell the sizer to set the minimal size of the @a window virtual area to match
1330 minimal size. For windows with managed scrollbars this will set them
1333 @see wxScrolledWindow::SetScrollbars
1335 void SetVirtualSizeHints(wxWindow
* window
);
1339 Shows or hides the @e window, @e sizer, or item at @e index.
1340 To make a sizer item disappear or reappear, use Show() followed by Layout().
1341 Use parameter @a recursive to show or hide elements found in subsizers.
1342 Returns @true if the child item was found, @false otherwise.
1344 @see Hide(), IsShown()
1346 bool Show(wxWindow
* window
, bool show
= true,
1347 bool recursive
= false);
1348 bool Show(wxSizer
* sizer
, bool show
= true,
1349 bool recursive
= false);
1350 bool Show(size_t index
, bool show
= true);
1360 A grid sizer is a sizer which lays out its children in a two-dimensional
1361 table with all table fields having the same size,
1362 i.e. the width of each field is the width of the widest child,
1363 the height of each field is the height of the tallest child.
1366 @category{winlayout}
1368 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1370 class wxGridSizer
: public wxSizer
1375 Constructor for a wxGridSizer. @a rows and @a cols determine the number of
1376 columns and rows in the sizer - if either of the parameters is zero, it will be
1377 calculated to form the total number of children in the sizer, thus making the
1378 sizer grow dynamically. @a vgap and @a hgap define extra space between
1381 wxGridSizer(int rows
, int cols
, int vgap
, int hgap
);
1382 wxGridSizer(int cols
, int vgap
= 0, int hgap
= 0);
1386 Returns the number of columns in the sizer.
1391 Returns the horizontal gap (in pixels) between cells in the sizer.
1396 Returns the number of rows in the sizer.
1401 Returns the vertical gap (in pixels) between the cells in the sizer.
1406 Sets the number of columns in the sizer.
1408 void SetCols(int cols
);
1411 Sets the horizontal gap (in pixels) between cells in the sizer.
1413 void SetHGap(int gap
);
1416 Sets the number of rows in the sizer.
1418 void SetRows(int rows
);
1421 Sets the vertical gap (in pixels) between the cells in the sizer.
1423 void SetVGap(int gap
);
1429 @class wxStaticBoxSizer
1432 wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
1433 box around the sizer. This static box may be either created independently or
1434 the sizer may create it itself as a convenience. In any case, the sizer owns
1435 the wxStaticBox control and will delete it if it is
1439 @category{winlayout}
1441 @see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizeroverview "Sizer
1444 class wxStaticBoxSizer
: public wxBoxSizer
1449 The first constructor uses an already existing static box. It takes the
1450 associated static box and the orientation @e orient, which can be either
1451 @c wxVERTICAL or @c wxHORIZONTAL as parameters.
1452 The second one creates a new static box with the given label and parent window.
1454 wxStaticBoxSizer(wxStaticBox
* box
, int orient
);
1455 wxStaticBoxSizer(int orient
, wxWindow parent
,
1456 const wxString
& label
= wxEmptyString
);
1460 Returns the static box associated with the sizer.
1462 wxStaticBox
* GetStaticBox();
1471 The basic idea behind a box sizer is that windows will most often be laid out
1473 simple basic geometry, typically in a row or a column or several hierarchies of
1476 For more information, please see @ref overview_boxsizerprogramming "Programming
1480 @category{winlayout}
1482 @see wxSizer, @ref overview_sizeroverview "Sizer overview"
1484 class wxBoxSizer
: public wxSizer
1488 Constructor for a wxBoxSizer. @a orient may be either of wxVERTICAL
1489 or wxHORIZONTAL for creating either a column sizer or a row sizer.
1491 wxBoxSizer(int orient
);
1494 Implements the calculation of a box sizer's minimal. It is used internally
1495 only and must not be called by the user. Documented for information.
1500 Returns the orientation of the box sizer, either wxVERTICAL
1503 int GetOrientation();
1506 Implements the calculation of a box sizer's dimensions and then sets
1507 the size of its children (calling wxWindow::SetSize
1508 if the child is a window). It is used internally only and must not be called
1509 by the user (call Layout() if you want to resize). Documented for information.