// Purpose: interface of wxStdDialogButtonSizer
// Author: wxWidgets team
// RCS-ID: $Id$
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+
/**
- @class wxStdDialogButtonSizer
+ @class wxSizer
- This class creates button layouts which conform to the standard button spacing
- and ordering defined by the platform or toolkit's user interface guidelines
- (if such things exist). By using this class, you can ensure that all your
- standard dialogs look correct on all major platforms. Currently it conforms to
- the Windows, GTK+ and Mac OS X human interface guidelines.
+ wxSizer is the abstract base class used for laying out subwindows in a window.
+ You cannot use wxSizer directly; instead, you will have to use one of the sizer
+ classes derived from it. Currently there are wxBoxSizer, wxStaticBoxSizer,
+ wxGridSizer, wxFlexGridSizer, wxWrapSizer and wxGridBagSizer.
- When there aren't interface guidelines defined for a particular platform or
- toolkit, wxStdDialogButtonSizer reverts to the Windows implementation.
+ The layout algorithm used by sizers in wxWidgets is closely related to layout
+ in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit.
+ It is based upon the idea of the individual subwindows reporting their minimal
+ required size and their ability to get stretched if the size of the parent window
+ has changed.
- To use this class, first add buttons to the sizer by calling
- wxStdDialogButtonSizer::AddButton (or wxStdDialogButtonSizer::SetAffirmativeButton,
- wxStdDialogButtonSizer::SetNegativeButton or wxStdDialogButtonSizer::SetCancelButton)
- and then call Realize in order to create the actual button layout used.
- Other than these special operations, this sizer works like any other sizer.
+ This will most often mean that the programmer does not set the original size of
+ a dialog in the beginning, rather the dialog will be assigned a sizer and this
+ sizer will be queried about the recommended size. The sizer in turn will query
+ its children, which can be normal windows, empty space or other sizers, so that
+ a hierarchy of sizers can be constructed. Note that wxSizer does not derive
+ from wxWindow and thus does not interfere with tab ordering and requires very little
+ resources compared to a real window on screen.
- If you add a button with wxID_SAVE, on Mac OS X the button will be renamed to
- "Save" and the wxID_NO button will be renamed to "Don't Save" in accordance
- with the Mac OS X Human Interface Guidelines.
+ What makes sizers so well fitted for use in wxWidgets is the fact that every
+ control reports its own minimal size and the algorithm can handle differences in
+ font sizes or different window (dialog item) sizes on different platforms without
+ problems. If e.g. the standard font as well as the overall design of Motif widgets
+ requires more space than on Windows, the initial dialog size will automatically
+ be bigger on Motif than on Windows.
+
+ Sizers may also be used to control the layout of custom drawn items on the
+ window. The wxSizer::Add(), wxSizer::Insert(), and wxSizer::Prepend() functions
+ return a pointer to the newly added wxSizerItem.
+ Just add empty space of the desired size and attributes, and then use the
+ wxSizerItem::GetRect() method to determine where the drawing operations
+ should take place.
+
+ Please notice that sizers, like child windows, are owned by the library and
+ will be deleted by it which implies that they must be allocated on the heap.
+ However if you create a sizer and do not add it to another sizer or
+ window, the library wouldn't be able to delete such an orphan sizer and in
+ this, and only this, case it should be deleted explicitly.
+
+ @section wxsizer_flags wxSizer flags
+
+ The "flag" argument accepted by wxSizeItem constructors and other
+ functions, e.g. wxSizer::Add(), is OR-combination of the following flags.
+ Two main behaviours are defined using these flags. One is the border around
+ a window: the border parameter determines the border width whereas the
+ flags given here determine which side(s) of the item that the border will
+ be added. The other flags determine how the sizer item behaves when the
+ space allotted to the sizer changes, and is somewhat dependent on the
+ specific kind of sizer used.
+
+ @beginDefList
+ @itemdef{wxTOP<br>
+ wxBOTTOM<br>
+ wxLEFT<br>
+ wxRIGHT<br>
+ wxALL,
+ These flags are used to specify which side(s) of the sizer item
+ the border width will apply to.}
+ @itemdef{wxEXPAND,
+ The item will be expanded to fill the space assigned to the item.}
+ @itemdef{wxSHAPED,
+ The item will be expanded as much as possible while also
+ maintaining its aspect ratio.}
+ @itemdef{wxFIXED_MINSIZE,
+ Normally wxSizers will use GetAdjustedBestSize() to determine what
+ the minimal size of window items should be, and will use that size
+ to calculate the layout. This allows layouts to adjust when an
+ item changes and its best size becomes different. If you would
+ rather have a window item stay the size it started with then use
+ @c wxFIXED_MINSIZE.}
+ @itemdef{wxRESERVE_SPACE_EVEN_IF_HIDDEN,
+ Normally wxSizers don't allocate space for hidden windows or other
+ items. This flag overrides this behaviour so that sufficient space
+ is allocated for the window even if it isn't visible. This makes
+ it possible to dynamically show and hide controls without resizing
+ parent dialog, for example. (Available since 2.8.8.)}
+ @itemdef{wxALIGN_CENTER<br>
+ wxALIGN_CENTRE<br>
+ wxALIGN_LEFT<br>
+ wxALIGN_RIGHT<br>
+ wxALIGN_TOP<br>
+ wxALIGN_BOTTOM<br>
+ wxALIGN_CENTER_VERTICAL<br>
+ wxALIGN_CENTRE_VERTICAL<br>
+ wxALIGN_CENTER_HORIZONTAL<br>
+ wxALIGN_CENTRE_HORIZONTAL,
+ The @c wxALIGN_* flags allow you to specify the alignment of the item
+ within the space allotted to it by the sizer, adjusted for the
+ border if any.}
+ @endDefList
@library{wxcore}
@category{winlayout}
- @see wxSizer, @ref overview_sizer, wxDialog::CreateButtonSizer
+ @see @ref overview_sizer
*/
-class wxStdDialogButtonSizer : public wxBoxSizer
+class wxSizer : public wxObject
{
public:
/**
- Constructor for a wxStdDialogButtonSizer.
+ The constructor.
+ Note that wxSizer is an abstract base class and may not be instantiated.
*/
- wxStdDialogButtonSizer();
+ wxSizer();
/**
- Adds a button to the wxStdDialogButtonSizer. The @a button must have
- one of the following identifiers:
- - wxID_OK
- - wxID_YES
- - wxID_SAVE
- - wxID_APPLY
- - wxID_CLOSE
- - wxID_NO
- - wxID_CANCEL
- - wxID_HELP
- - wxID_CONTEXT_HELP
+ The destructor.
*/
- void AddButton(wxButton* button);
+ virtual ~wxSizer();
/**
- Rearranges the buttons and applies proper spacing between buttons to make
- them match the platform or toolkit's interface guidelines.
- */
- void Realize();
+ Appends a child to the sizer.
- /**
- Sets the affirmative button for the sizer.
+ wxSizer itself is an abstract class, but the parameters are equivalent
+ in the derived classes that you will instantiate to use it so they are
+ described here:
- This allows you to use identifiers other than the standard identifiers
- outlined above.
+ @param window
+ The window to be added to the sizer. Its initial size (either set
+ explicitly by the user or calculated internally when using
+ wxDefaultSize) is interpreted as the minimal and in many cases also
+ the initial size.
+ @param flags
+ A wxSizerFlags object that enables you to specify most of the above
+ parameters more conveniently.
*/
- void SetAffirmativeButton(wxButton* button);
+ wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags);
/**
- Sets the cancel button for the sizer.
+ Appends a child to the sizer.
- This allows you to use identifiers other than the standard identifiers
- outlined above.
+ wxSizer itself is an abstract class, but the parameters are equivalent
+ in the derived classes that you will instantiate to use it so they are
+ described here:
+
+ @param window
+ The window to be added to the sizer. Its initial size (either set
+ explicitly by the user or calculated internally when using
+ wxDefaultSize) is interpreted as the minimal and in many cases also
+ the initial size.
+ @param proportion
+ Although the meaning of this parameter is undefined in wxSizer, it
+ is used in wxBoxSizer to indicate if a child of a sizer can change
+ its size in the main orientation of the wxBoxSizer - where 0 stands
+ for not changeable and a value of more than zero is interpreted
+ relative to the value of other children of the same wxBoxSizer. For
+ example, you might have a horizontal wxBoxSizer with three
+ children, two of which are supposed to change their size with the
+ sizer. Then the two stretchable windows would get a value of 1 each
+ to make them grow and shrink equally with the sizer's horizontal
+ dimension.
+ @param flag
+ OR-combination of flags affecting sizer's behaviour. See
+ @ref wxsizer_flags "wxSizer flags list" for details.
+ @param border
+ Determines the border width, if the flag parameter is set to
+ include any border flag.
+ @param userData
+ Allows an extra object to be attached to the sizer item, for use in
+ derived classes when sizing information is more complex than the
+ proportion and flag will allow for.
*/
- void SetCancelButton(wxButton* button);
+ wxSizerItem* Add(wxWindow* window,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
/**
- Sets the negative button for the sizer.
+ Appends a child to the sizer.
- This allows you to use identifiers other than the standard identifiers
- outlined above.
+ wxSizer itself is an abstract class, but the parameters are equivalent
+ in the derived classes that you will instantiate to use it so they are
+ described here:
+
+ @param sizer
+ The (child-)sizer to be added to the sizer. This allows placing a
+ child sizer in a sizer and thus to create hierarchies of sizers
+ (typically a vertical box as the top sizer and several horizontal
+ boxes on the level beneath).
+ @param flags
+ A wxSizerFlags object that enables you to specify most of the above
+ parameters more conveniently.
*/
- void SetNegativeButton(wxButton* button);
-};
+ wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags);
+ /**
+ Appends a child to the sizer.
+ wxSizer itself is an abstract class, but the parameters are equivalent
+ in the derived classes that you will instantiate to use it so they are
+ described here:
-/**
- @class wxSizerItem
+ @param sizer
+ The (child-)sizer to be added to the sizer. This allows placing a
+ child sizer in a sizer and thus to create hierarchies of sizers
+ (typically a vertical box as the top sizer and several horizontal
+ boxes on the level beneath).
+ @param proportion
+ Although the meaning of this parameter is undefined in wxSizer, it
+ is used in wxBoxSizer to indicate if a child of a sizer can change
+ its size in the main orientation of the wxBoxSizer - where 0 stands
+ for not changeable and a value of more than zero is interpreted
+ relative to the value of other children of the same wxBoxSizer. For
+ example, you might have a horizontal wxBoxSizer with three
+ children, two of which are supposed to change their size with the
+ sizer. Then the two stretchable windows would get a value of 1 each
+ to make them grow and shrink equally with the sizer's horizontal
+ dimension.
+ @param flag
+ OR-combination of flags affecting sizer's behaviour. See
+ @ref wxsizer_flags "wxSizer flags list" for details.
+ @param border
+ Determines the border width, if the flag parameter is set to
+ include any border flag.
+ @param userData
+ Allows an extra object to be attached to the sizer item, for use in
+ derived classes when sizing information is more complex than the
+ proportion and flag will allow for.
+ */
+ wxSizerItem* Add(wxSizer* sizer,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
- The wxSizerItem class is used to track the position, size and other
- attributes of each item managed by a wxSizer.
+ /**
+ Appends a spacer child to the sizer.
- It is not usually necessary to use this class because the sizer elements can
- also be identified by their positions or window or sizer pointers but sometimes
- it may be more convenient to use it directly.
+ wxSizer itself is an abstract class, but the parameters are equivalent
+ in the derived classes that you will instantiate to use it so they are
+ described here.
- @library{wxcore}
- @category{winlayout}
-*/
-class wxSizerItem : public wxObject
-{
-public:
- //@{
- /**
- Construct a sizer item for tracking a subsizer.
- */
- wxSizerItem(int width, int height, int proportion, int flag,
- int border, wxObject* userData);
- wxSizerItem(wxWindow* window, const wxSizerFlags& flags);
- wxSizerItem(wxWindow* window, int proportion, int flag,
- int border,
- wxObject* userData);
- wxSizerItem(wxSizer* window, const wxSizerFlags& flags);
- wxSizerItem(wxSizer* sizer, int proportion, int flag,
- int border,
- wxObject* userData);
- //@}
+ @a width and @a height specify the dimension of a spacer to be added to
+ the sizer. Adding spacers to sizers gives more flexibility in the
+ design of dialogs; imagine for example a horizontal box with two
+ buttons at the bottom of a dialog: you might want to insert a space
+ between the two buttons and make that space stretchable using the
+ proportion flag and the result will be that the left button will be
+ aligned with the left side of the dialog and the right button with the
+ right side - the space in between will shrink and grow with the dialog.
+ @param width
+ Width of the spacer.
+ @param height
+ Height of the spacer.
+ @param proportion
+ Although the meaning of this parameter is undefined in wxSizer, it
+ is used in wxBoxSizer to indicate if a child of a sizer can change
+ its size in the main orientation of the wxBoxSizer - where 0 stands
+ for not changeable and a value of more than zero is interpreted
+ relative to the value of other children of the same wxBoxSizer. For
+ example, you might have a horizontal wxBoxSizer with three
+ children, two of which are supposed to change their size with the
+ sizer. Then the two stretchable windows would get a value of 1 each
+ to make them grow and shrink equally with the sizer's horizontal
+ dimension.
+ @param flag
+ OR-combination of flags affecting sizer's behaviour. See
+ @ref wxsizer_flags "wxSizer flags list" for details.
+ @param border
+ Determines the border width, if the flag parameter is set to
+ include any border flag.
+ @param userData
+ Allows an extra object to be attached to the sizer item, for use in
+ derived classes when sizing information is more complex than the
+ proportion and flag will allow for.
+ */
+ wxSizerItem* Add(int width, int height,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
+
/**
- Deletes the user data and subsizer, if any.
+ Appends a spacer child to the sizer.
+
+ @param width
+ Width of the spacer.
+ @param height
+ Height of the spacer.
+ @param flags
+ A wxSizerFlags object that enables you to specify most of the other
+ parameters more conveniently.
*/
- virtual ~wxSizerItem();
+ wxSizerItem* Add( int width, int height, const wxSizerFlags& flags);
+ wxSizerItem* Add(wxSizerItem* item);
+
/**
- Calculates the minimum desired size for the item, including any space
- needed by borders.
+ This base function adds non-stretchable space to both the horizontal
+ and vertical orientation of the sizer.
+ More readable way of calling:
+ @code
+ wxSizer::Add(size, size, 0).
+ @endcode
+ @see wxBoxSizer::AddSpacer()
*/
- virtual wxSize CalcMin();
+ virtual wxSizerItem *AddSpacer(int size);
/**
- Destroy the window or the windows in a subsizer, depending on the type
- of item.
+ Adds stretchable space to the sizer.
+ More readable way of calling:
+ @code
+ wxSizer::Add(0, 0, prop).
+ @endcode
*/
- virtual void DeleteWindows();
+ wxSizerItem* AddStretchSpacer(int prop = 1);
/**
- Enable deleting the SizerItem without destroying the contained sizer.
+ This method is abstract and has to be overwritten by any derived class.
+ Here, the sizer will do the actual calculation of its children's minimal sizes.
*/
- void DetachSizer();
+ virtual wxSize CalcMin() = 0;
/**
- Return the border attribute.
+ Detaches all children from the sizer.
+ If @a delete_windows is @true then child windows will also be deleted.
*/
- int GetBorder() const;
+ virtual void Clear(bool delete_windows = false);
/**
- Return the flags attribute.
+ Computes client area size for @a window so that it matches the sizer's
+ minimal size. Unlike GetMinSize(), this method accounts for other
+ constraints imposed on @e window, namely display's size (returned size
+ will never be too large for the display) and maximum window size if
+ previously set by wxWindow::SetMaxSize().
- See @ref wxsizer_flags "wxSizer flags list" for details.
- */
- int GetFlag() const;
+ The returned value is suitable for passing to wxWindow::SetClientSize() or
+ wxWindow::SetMinClientSize().
- /**
- Return the numeric id of wxSizerItem, or @c wxID_NONE if the id has
- not been set.
+ @since 2.8.8
+
+ @see ComputeFittingWindowSize(), Fit()
*/
- int GetId() const;
+ wxSize ComputeFittingClientSize(wxWindow* window);
/**
- Get the minimum size needed for the item.
+ Like ComputeFittingClientSize(), but converts the result into window
+ size. The returned value is suitable for passing to wxWindow::SetSize()
+ or wxWindow::SetMinSize().
+
+ @since 2.8.8
+
+ @see ComputeFittingClientSize(), Fit()
*/
- wxSize GetMinSize() const;
+ wxSize ComputeFittingWindowSize(wxWindow* window);
/**
- Sets the minimum size to be allocated for this item.
+ Detach the child @a window from the sizer without destroying it.
- If this item is a window, the @a size is also passed to
- wxWindow::SetMinSize().
- */
- void SetMinSize(const wxSize& size);
+ This method does not cause any layout or resizing to take place, call Layout()
+ to update the layout "on screen" after detaching a child from the sizer.
- /**
- @overload
- */
- void SetMinSize(int x, int y);
+ Returns @true if the child item was found and detached, @false otherwise.
- /**
- What is the current position of the item, as set in the last Layout.
+ @see Remove()
*/
- wxPoint GetPosition() const;
+ virtual bool Detach(wxWindow* window);
/**
- Get the proportion item attribute.
- */
- int GetProportion() const;
+ Detach the child @a sizer from the sizer without destroying it.
- /**
- Get the ration item attribute.
- */
- float GetRatio() const;
+ This method does not cause any layout or resizing to take place, call Layout()
+ to update the layout "on screen" after detaching a child from the sizer.
- /**
- Get the rectangle of the item on the parent window, excluding borders.
- */
- virtual wxRect GetRect();
+ Returns @true if the child item was found and detached, @false otherwise.
- /**
- Get the current size of the item, as set in the last Layout.
+ @see Remove()
*/
- virtual wxSize GetSize() const;
+ virtual bool Detach(wxSizer* sizer);
/**
- If this item is tracking a sizer, return it. @NULL otherwise.
- */
- wxSizer* GetSizer() const;
+ Detach a item at position @a index from the sizer without destroying it.
- /**
- If this item is tracking a spacer, return its size.
- */
- const wxSize GetSpacer() const;
+ This method does not cause any layout or resizing to take place, call Layout()
+ to update the layout "on screen" after detaching a child from the sizer.
+ Returns @true if the child item was found and detached, @false otherwise.
- /**
- Get the userData item attribute.
+ @see Remove()
*/
- wxObject* GetUserData() const;
+ virtual bool Detach(int index);
/**
- If this item is tracking a window then return it. @NULL otherwise.
+ Tell the sizer to resize the @a window so that its client area matches the
+ sizer's minimal size (ComputeFittingClientSize() is called to determine it).
+ This is commonly done in the constructor of the window itself, see sample
+ in the description of wxBoxSizer.
+
+ @return The new window size.
+
+ @see ComputeFittingClientSize(), ComputeFittingWindowSize()
*/
- wxWindow* GetWindow() const;
+ wxSize Fit(wxWindow* window);
/**
- Returns @true if this item is a window or a spacer and it is shown or
- if this item is a sizer and not all of its elements are hidden.
-
- In other words, for sizer items, all of the child elements must be
- hidden for the sizer itself to be considered hidden.
+ Tell the sizer to resize the virtual size of the @a window to match the sizer's
+ minimal size. This will not alter the on screen size of the window, but may
+ cause the addition/removal/alteration of scrollbars required to view the virtual
+ area in windows which manage it.
- As an exception, if the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was
- used for this sizer item, then IsShown() always returns @true for it
- (see wxSizerFlags::ReserveSpaceEvenIfHidden()).
+ @see wxScrolled::SetScrollbars(), SetVirtualSizeHints()
*/
- bool IsShown() const;
+ void FitInside(wxWindow* window);
/**
- Is this item a sizer?
+ Inform sizer about the first direction that has been decided (by
+ parent item). Returns true if it made use of the information (and
+ recalculated min size).
*/
- bool IsSizer() const;
+ virtual bool InformFirstDirection(int direction, int size, int availableOtherDir);
+
+ //@{
/**
- Is this item a spacer?
+ Returns the list of the items in this sizer.
+
+ The elements of type-safe wxList @c wxSizerItemList are pointers to
+ objects of type wxSizerItem.
*/
- bool IsSpacer() const;
+ wxSizerItemList& GetChildren();
+ const wxSizerItemList& GetChildren() const;
+ //@}
/**
- Is this item a window?
+ Returns the window this sizer is used in or @NULL if none.
*/
- bool IsWindow() const;
+ wxWindow* GetContainingWindow() const;
/**
- Set the border item attribute.
+ Set the window this sizer is used in.
*/
- void SetBorder(int border);
-
+ void SetContainingWindow(wxWindow *window);
+
/**
- Set the position and size of the space allocated to the sizer, and
- adjust the position and size of the item to be within that space
- taking alignment and borders into account.
+ Returns the number of items in the sizer.
+
+ If you just need to test whether the sizer is empty or not you can also
+ use IsEmpty() function.
*/
- virtual void SetDimension(const wxPoint& pos, const wxSize& size);
+ size_t GetItemCount() const;
/**
- Set the flag item attribute.
+ Finds wxSizerItem which holds the given @a window.
+ Use parameter @a recursive to search in subsizers too.
+ Returns pointer to item or @NULL.
*/
- void SetFlag(int flag);
+ wxSizerItem* GetItem(wxWindow* window, bool recursive = false);
/**
- Sets the numeric id of the wxSizerItem to @e id.
+ Finds wxSizerItem which holds the given @a sizer.
+ Use parameter @a recursive to search in subsizers too.
+ Returns pointer to item or @NULL.
*/
- void SetId(int id);
- /**
+ wxSizerItem* GetItem(wxSizer* sizer, bool recursive = false);
+ /**
+ Finds wxSizerItem which is located in the sizer at position @a index.
+ Use parameter @a recursive to search in subsizers too.
+ Returns pointer to item or @NULL.
*/
- void SetInitSize(int x, int y);
+ wxSizerItem* GetItem(size_t index);
/**
- Set the proportion item attribute.
+ Finds item of the sizer which has the given @e id.
+ This @a id is not the window id but the id of the wxSizerItem itself.
+ This is mainly useful for retrieving the sizers created from XRC resources.
+ Use parameter @a recursive to search in subsizers too.
+ Returns pointer to item or @NULL.
*/
- void SetProportion(int proportion);
+ wxSizerItem* GetItemById(int id, bool recursive = false);
- //@{
/**
- Set the ratio item attribute.
+ Returns the minimal size of the sizer.
+
+ This is either the combined minimal size of all the children and their
+ borders or the minimal size set by SetMinSize(), depending on which is bigger.
+ Note that the returned value is client size, not window size.
+ In particular, if you use the value to set toplevel window's minimal or
+ actual size, use wxWindow::SetMinClientSize() or wxWindow::SetClientSize(),
+ not wxWindow::SetMinSize() or wxWindow::SetSize().
*/
- void SetRatio(int width, int height);
- void SetRatio(wxSize size);
- void SetRatio(float ratio);
- //@}
+ wxSize GetMinSize();
/**
- Set the sizer tracked by this item.
- @deprecated @todo provide deprecation description
+ Returns the current position of the sizer.
*/
- void SetSizer(wxSizer* sizer);
+ wxPoint GetPosition() const;
/**
- Set the size of the spacer tracked by this item.
- @deprecated @todo provide deprecation description
+ Returns the current size of the sizer.
*/
- void SetSpacer(const wxSize& size);
+ wxSize GetSize() const;
/**
- Set the window to be tracked by this item.
- @deprecated @todo provide deprecation description
+ Hides the child @a window.
+
+ To make a sizer item disappear, use Hide() followed by Layout().
+
+ Use parameter @a recursive to hide elements found in subsizers.
+ Returns @true if the child item was found, @false otherwise.
+
+ @see IsShown(), Show()
*/
- void SetWindow(wxWindow* window);
+ bool Hide(wxWindow* window, bool recursive = false);
/**
- Set the show item attribute, which sizers use to determine if the item
- is to be made part of the layout or not. If the item is tracking a
- window then it is shown or hidden as needed.
- */
- void Show(bool show);
-};
+ Hides the child @a sizer.
+ To make a sizer item disappear, use Hide() followed by Layout().
+ Use parameter @a recursive to hide elements found in subsizers.
+ Returns @true if the child item was found, @false otherwise.
-/**
- @class wxSizerFlags
+ @see IsShown(), Show()
+ */
+ bool Hide(wxSizer* sizer, bool recursive = false);
- Container for sizer items flags providing readable names for them.
+ /**
+ Hides the item at position @a index.
- Normally, when you add an item to a sizer via wxSizer::Add, you have to
- specify a lot of flags and parameters which can be unwieldy. This is where
- wxSizerFlags comes in: it allows you to specify all parameters using the
- named methods instead. For example, instead of
+ To make a sizer item disappear, use Hide() followed by Layout().
- @code
- sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
- @endcode
+ Use parameter @a recursive to hide elements found in subsizers.
+ Returns @true if the child item was found, @false otherwise.
- you can now write
+ @see IsShown(), Show()
+ */
+ bool Hide(size_t index);
- @code
- sizer->Add(ctrl, wxSizerFlags().Expand().Border(wxALL, 10));
- @endcode
+ /**
+ Insert a child into the sizer before any existing item at @a index.
- This is more readable and also allows you to create wxSizerFlags objects which
- can be reused for several sizer items.
+ See Add() for the meaning of the other parameters.
+ */
+ wxSizerItem* Insert(size_t index, wxWindow* window,
+ const wxSizerFlags& flags);
- @code
- wxSizerFlags flagsExpand(1);
- flagsExpand.Expand().Border(wxALL, 10);
+ /**
+ Insert a child into the sizer before any existing item at @a index.
- sizer->Add(ctrl1, flagsExpand);
- sizer->Add(ctrl2, flagsExpand);
- @endcode
+ See Add() for the meaning of the other parameters.
+ */
+ wxSizerItem* Insert(size_t index, wxWindow* window,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
- Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
- object itself to allowing chaining multiple methods calls like in the examples
- above.
+ /**
+ Insert a child into the sizer before any existing item at @a index.
- @library{wxcore}
- @category{winlayout}
+ See Add() for the meaning of the other parameters.
+ */
+ wxSizerItem* Insert(size_t index, wxSizer* sizer,
+ const wxSizerFlags& flags);
- @see wxSizer
-*/
-class wxSizerFlags
-{
-public:
/**
- Creates the wxSizer with the proportion specified by @e proportion.
+ Insert a child into the sizer before any existing item at @a index.
+
+ See Add() for the meaning of the other parameters.
*/
- wxSizerFlags(int proportion = 0);
+ wxSizerItem* Insert(size_t index, wxSizer* sizer,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
/**
- Sets the alignment of this wxSizerFlags to @e align.
+ Insert a child into the sizer before any existing item at @a index.
- This method replaces the previously set alignment with the specified
- one.
+ See Add() for the meaning of the other parameters.
+ */
+ wxSizerItem* Insert(size_t index, int width, int height,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
+ /**
+ Insert a child into the sizer before any existing item at @a index.
- @see Top(), Left(), Right(), Bottom(), Centre()
+ See Add() for the meaning of the other parameters.
+ */
+ wxSizerItem* Insert(size_t index,
+ int width,
+ int height,
+ const wxSizerFlags& flags);
- @param align Combination of @c wxALIGN_XXX bit masks.
+ wxSizerItem* Insert(size_t index, wxSizerItem* item);
+
+ /**
+ Inserts non-stretchable space to the sizer.
+ More readable way of calling wxSizer::Insert(index, size, size).
*/
- wxSizerFlags& Align(int align = 0);
+ wxSizerItem* InsertSpacer(size_t index, int size);
/**
- Sets the wxSizerFlags to have a border of a number of pixels specified
- by @a borderinpixels with the directions specified by @e direction.
+ Inserts stretchable space to the sizer.
+ More readable way of calling wxSizer::Insert(0, 0, prop).
*/
- wxSizerFlags& Border(int direction, int borderinpixels);
+ wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
/**
- Sets the wxSizerFlags to have a border with size as returned by
- GetDefaultBorder().
+ Return @true if the sizer has no elements.
- @param direction Direction(s) to apply the border in.
+ @see GetItemCount()
+ */
+ bool IsEmpty() const;
+
+ /**
+ Returns @true if the @a window is shown.
+
+ @see Hide(), Show(), wxSizerItem::IsShown()
*/
- wxSizerFlags& Border(int direction = wxALL);
+ bool IsShown(wxWindow* window) const;
/**
- Aligns the object to the bottom, similar for @c Align(wxALIGN_BOTTOM).
+ Returns @true if the @a sizer is shown.
- Unlike Align(), this method doesn't change the horizontal alignment of
- the item.
+ @see Hide(), Show(), wxSizerItem::IsShown()
*/
- wxSizerFlags& Bottom();
+ bool IsShown(wxSizer* sizer) const;
/**
- Sets the object of the wxSizerFlags to center itself in the area it is
- given.
+ Returns @true if the item at @a index is shown.
+
+ @see Hide(), Show(), wxSizerItem::IsShown()
*/
- wxSizerFlags& Center();
+ bool IsShown(size_t index) const;
/**
- Center() for people with the other dialect of English.
+ Call this to force layout of the children anew, e.g.\ after having added a child
+ to or removed a child (window, other sizer or space) from the sizer while
+ keeping the current dimension.
*/
- wxSizerFlags& Centre();
+ virtual void Layout();
/**
- Sets the border in the given @a direction having twice the default
- border size.
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
*/
- wxSizerFlags& DoubleBorder(int direction = wxALL);
+ wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags);
/**
- Sets the border in left and right directions having twice the default
- border size.
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
*/
- wxSizerFlags& DoubleHorzBorder();
+ wxSizerItem* Prepend(wxWindow* window, int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
/**
- Sets the object of the wxSizerFlags to expand to fill as much area as
- it can.
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
*/
- wxSizerFlags& Expand();
+ wxSizerItem* Prepend(wxSizer* sizer,
+ const wxSizerFlags& flags);
/**
- Set the @c wxFIXED_MINSIZE flag which indicates that the initial size
- of the window should be also set as its minimal size.
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
*/
- wxSizerFlags& FixedMinSize();
+ wxSizerItem* Prepend(wxSizer* sizer, int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
/**
- Set the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers
- don't allocate space for hidden windows or other items. This flag
- overrides this behavior so that sufficient space is allocated for the
- window even if it isn't visible. This makes it possible to dynamically
- show and hide controls without resizing parent dialog, for example.
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
+ */
+ wxSizerItem* Prepend(int width, int height,
+ int proportion = 0,
+ int flag = 0,
+ int border = 0,
+ wxObject* userData = NULL);
- @since 2.8.8
+ /**
+ Same as Add(), but prepends the items to the beginning of the
+ list of items (windows, subsizers or spaces) owned by this sizer.
*/
- wxSizerFlags& ReserveSpaceEvenIfHidden();
+ wxSizerItem* Prepend(int width, int height, const wxSizerFlags& flags);
+ wxSizerItem* Prepend(wxSizerItem* item);
+
/**
- Returns the border used by default in Border() method.
+ Prepends non-stretchable space to the sizer.
+ More readable way of calling wxSizer::Prepend(size, size, 0).
*/
- static int GetDefaultBorder();
+ wxSizerItem* PrependSpacer(int size);
/**
- Aligns the object to the left, similar for @c Align(wxALIGN_LEFT).
+ Prepends stretchable space to the sizer.
+ More readable way of calling wxSizer::Prepend(0, 0, prop).
+ */
+ wxSizerItem* PrependStretchSpacer(int prop = 1);
- Unlike Align(), this method doesn't change the vertical alignment of
- the item.
+ /**
+ This method is abstract and has to be overwritten by any derived class.
+ Here, the sizer will do the actual calculation of its children's
+ positions and sizes.
*/
- wxSizerFlags& Left();
+ virtual void RecalcSizes() = 0;
/**
- Sets the proportion of this wxSizerFlags to @e proportion
+ Removes a child window from the sizer, but does @b not destroy it
+ (because windows are owned by their parent window, not the sizer).
+
+ @deprecated
+ The overload of this method taking a wxWindow* parameter
+ is deprecated as it does not destroy the window as would usually be
+ expected from Remove(). You should use Detach() in new code instead.
+ There is currently no wxSizer method that will both detach and destroy
+ a wxWindow item.
+
+ @note This method does not cause any layout or resizing to take
+ place, call Layout() to update the layout "on screen" after
+ removing a child from the sizer.
+
+ @return @true if the child item was found and removed, @false otherwise.
*/
- wxSizerFlags& Proportion(int proportion = 0);
+ virtual bool Remove(wxWindow* window);
/**
- Aligns the object to the right, similar for @c Align(wxALIGN_RIGHT).
+ Removes a sizer child from the sizer and destroys it.
- Unlike Align(), this method doesn't change the vertical alignment of
- the item.
+ @note This method does not cause any layout or resizing to take
+ place, call Layout() to update the layout "on screen" after
+ removing a child from the sizer.
+
+ @param sizer The wxSizer to be removed.
+
+ @return @true if the child item was found and removed, @false otherwise.
*/
- wxSizerFlags& Right();
+ virtual bool Remove(wxSizer* sizer);
/**
- Set the @c wx_SHAPED flag which indicates that the elements should
- always keep the fixed width to height ratio equal to its original value.
+ Removes a child from the sizer and destroys it if it is a sizer or a
+ spacer, but not if it is a window (because windows are owned by their
+ parent window, not the sizer).
+
+ @note This method does not cause any layout or resizing to take
+ place, call Layout() to update the layout "on screen" after
+ removing a child from the sizer.
+
+ @param index
+ The position of the child in the sizer, e.g. 0 for the first item.
+
+ @return @true if the child item was found and removed, @false otherwise.
*/
- wxSizerFlags& Shaped();
+ virtual bool Remove(int index);
/**
- Aligns the object to the top, similar for @c Align(wxALIGN_TOP).
+ Detaches the given @a oldwin from the sizer and replaces it with the
+ given @a newwin. The detached child window is @b not deleted (because
+ windows are owned by their parent window, not the sizer).
- Unlike Align(), this method doesn't change the horizontal alignment of
- the item.
+ Use parameter @a recursive to search the given element recursively in subsizers.
+
+ This method does not cause any layout or resizing to take place,
+ call Layout() to update the layout "on screen" after replacing a
+ child from the sizer.
+
+ Returns @true if the child item was found and removed, @false otherwise.
*/
- wxSizerFlags& Top();
+ virtual bool Replace(wxWindow* oldwin, wxWindow* newwin,
+ bool recursive = false);
/**
- Sets the border in the given @a direction having thrice the default
- border size.
- */
- wxSizerFlags& TripleBorder(int direction = wxALL);
-};
+ Detaches the given @a oldsz from the sizer and replaces it with the
+ given @a newsz. The detached child sizer is deleted.
+ Use parameter @a recursive to search the given element recursively in subsizers.
+ This method does not cause any layout or resizing to take place,
+ call Layout() to update the layout "on screen" after replacing a
+ child from the sizer.
-/**
- @class wxNotebookSizer
+ Returns @true if the child item was found and removed, @false otherwise.
+ */
+ virtual bool Replace(wxSizer* oldsz, wxSizer* newsz,
+ bool recursive = false);
- @deprecated
- This class is deprecated and should not be used in new code! It is no
- longer needed, wxNotebook control can be inserted
- into any sizer class and its minimal size will be determined correctly.
+ /**
+ Detaches the given item at position @a index from the sizer and
+ replaces it with the given wxSizerItem @a newitem.
- wxNotebookSizer is a specialized sizer to make sizers work in connection
- with using notebooks. This sizer is different from any other sizer as you
- must not add any children to it - instead, it queries the notebook class
- itself. The only thing this sizer does is to determine the size of the
- biggest page of the notebook and report an adjusted minimal size to a more
- toplevel sizer.
+ The detached child is deleted @b only if it is a sizer or a spacer
+ (but not if it is a wxWindow because windows are owned by their
+ parent window, not the sizer).
- @library{wxbase}
- @category{winlayout}
+ This method does not cause any layout or resizing to take place,
+ call Layout() to update the layout "on screen" after replacing a
+ child from the sizer.
- @see wxSizer, wxNotebook,
- @ref overview_sizer "Sizers overview"
-*/
-class wxNotebookSizer : public wxSizer
-{
-public:
- /**
- Constructor. It takes an associated notebook as its only parameter.
+ Returns @true if the child item was found and removed, @false otherwise.
*/
- wxNotebookSizer(wxNotebook* notebook);
+ virtual bool Replace(size_t index, wxSizerItem* newitem);
/**
- Returns the notebook associated with the sizer.
+ Call this to force the sizer to take the given dimension and thus force
+ the items owned by the sizer to resize themselves according to the
+ rules defined by the parameter in the Add() and Prepend() methods.
*/
- wxNotebook* GetNotebook();
-};
-
+ void SetDimension(int x, int y, int width, int height);
+ /**
+ @overload
+ */
+ void SetDimension(const wxPoint& pos, const wxSize& size);
-/**
- @class wxFlexGridSizer
+ /**
+ Set an item's minimum size by window, sizer, or position.
- A flex grid sizer is a sizer which lays out its children in a two-dimensional
- table with all table fields in one row having the same
- height and all fields in one column having the same width, but all
- rows or all columns are not necessarily the same height or width as in
- the wxGridSizer.
+ This function enables an application to set the size of an item after
+ initial creation.
- Since wxWidgets 2.5.0, wxFlexGridSizer can also size items equally in one
- direction but unequally ("flexibly") in the other. If the sizer is only
- flexible in one direction (this can be changed using
- wxFlexGridSizer::SetFlexibleDirection),
- it needs to be decided how the sizer should grow in the other ("non-flexible")
- direction in order to fill the available space. The
- wxFlexGridSizer::SetNonFlexibleGrowMode method
- serves this purpose.
+ The @a window or @a sizer will be found recursively in the sizer's
+ descendants.
- @library{wxcore}
- @category{winlayout}
+ @see wxSizerItem::SetMinSize()
- @see wxSizer, @ref overview_sizer "Sizer Overview"
-*/
-class wxFlexGridSizer : public wxGridSizer
-{
-public:
- //@{
- /**
- Constructor for a wxGridSizer. @a rows and @a cols determine the number of
- columns and rows in the sizer - if either of the parameters is zero, it will be
- calculated to form the total number of children in the sizer, thus making the
- sizer grow dynamically. @a vgap and @a hgap define extra space between
- all children.
+ @return
+ @true if the minimal size was successfully set or @false if the
+ item was not found.
*/
- wxFlexGridSizer(int rows, int cols, int vgap, int hgap);
- wxFlexGridSizer(int cols, int vgap = 0, int hgap = 0);
+ //@{
+ bool SetItemMinSize(wxWindow* window, int width, int height);
+ bool SetItemMinSize(wxWindow* window, const wxSize& size);
+
+ bool SetItemMinSize(wxSizer* sizer, int width, int height);
+ bool SetItemMinSize(wxSizer* sizer, const wxSize& size);
+
+ bool SetItemMinSize(size_t index, int width, int height);
+ bool SetItemMinSize(size_t index, const wxSize& size);
//@}
/**
- Specifies that column @a idx (starting from zero) should be grown if
- there is extra space available to the sizer.
-
- The @a proportion parameter has the same meaning as the stretch factor
- for the sizers() except that if all proportions are 0, then all columns
- are resized equally (instead of not being resized at all).
+ Call this to give the sizer a minimal size.
- Notice that the row must not be already growable, if you need to change
- the proportion you must call RemoveGrowableCol() first and then make it
- growable (with a different proportion) again. You can use IsColGrowable()
- to check whether a column is already growable.
+ Normally, the sizer will calculate its minimal size based purely on how
+ much space its children need. After calling this method GetMinSize()
+ will return either the minimal size as requested by its children or the
+ minimal size set here, depending on which is bigger.
*/
- void AddGrowableCol(size_t idx, int proportion = 0);
+ void SetMinSize(const wxSize& size);
/**
- Specifies that row idx (starting from zero) should be grown if there
- is extra space available to the sizer.
+ @overload
+ */
+ void SetMinSize(int width, int height);
- This is identical to AddGrowableCol() except that it works with rows
- and not columns.
+ /**
+ This method first calls Fit() and then wxTopLevelWindow::SetSizeHints()
+ on the @a window passed to it.
+
+ This only makes sense when @a window is actually a wxTopLevelWindow such
+ as a wxFrame or a wxDialog, since SetSizeHints only has any effect in these classes.
+ It does nothing in normal windows or controls.
+
+ This method is implicitly used by wxWindow::SetSizerAndFit() which is
+ commonly invoked in the constructor of a toplevel window itself (see
+ the sample in the description of wxBoxSizer) if the toplevel window is
+ resizable.
*/
- void AddGrowableRow(size_t idx, int proportion = 0);
+ void SetSizeHints(wxWindow* window);
/**
- Returns a wxOrientation value that specifies whether the sizer flexibly
- resizes its columns, rows, or both (default).
+ Tell the sizer to set the minimal size of the @a window virtual area to match
+ the sizer's minimal size. For windows with managed scrollbars this will set them
+ appropriately.
- @return One of the following values:
+ @deprecated This is exactly the same as FitInside() in wxWidgets 2.9
+ and later, please replace calls to it with FitInside().
- @see SetFlexibleDirection()
+ @see wxScrolled::SetScrollbars()
*/
- int GetFlexibleDirection() const;
+ void SetVirtualSizeHints(wxWindow* window);
/**
- Returns the value that specifies how the sizer grows in the "non-flexible"
- direction if there is one.
+ Shows or hides the @a window.
+ To make a sizer item disappear or reappear, use Show() followed by Layout().
+
+ Use parameter @a recursive to show or hide elements found in subsizers.
- @return One of the following values:
+ Returns @true if the child item was found, @false otherwise.
- @see SetFlexibleDirection(),
- SetNonFlexibleGrowMode()
+ @see Hide(), IsShown()
*/
- int GetNonFlexibleGrowMode() const;
+ bool Show(wxWindow* window, bool show = true,
+ bool recursive = false);
/**
- Returns @true if column @a idx is growable.
+ Shows or hides @a sizer.
+ To make a sizer item disappear or reappear, use Show() followed by Layout().
- @since 2.9.0
+ Use parameter @a recursive to show or hide elements found in subsizers.
+
+ Returns @true if the child item was found, @false otherwise.
+
+ @see Hide(), IsShown()
*/
- bool IsColGrowable(size_t idx);
+ bool Show(wxSizer* sizer, bool show = true,
+ bool recursive = false);
/**
- Returns @true if row @a idx is growable.
+ Shows the item at @a index.
+ To make a sizer item disappear or reappear, use Show() followed by Layout().
- @since 2.9.0
+ Returns @true if the child item was found, @false otherwise.
+
+ @see Hide(), IsShown()
*/
- bool IsRowGrowable(size_t idx);
+ bool Show(size_t index, bool show = true);
+
/**
- Specifies that column idx is no longer growable.
+ Show or hide all items managed by the sizer.
*/
- void RemoveGrowableCol(size_t idx);
+ virtual void ShowItems(bool show);
+
+};
+
+
+/**
+ @class wxStdDialogButtonSizer
+
+ This class creates button layouts which conform to the standard button spacing
+ and ordering defined by the platform or toolkit's user interface guidelines
+ (if such things exist). By using this class, you can ensure that all your
+ standard dialogs look correct on all major platforms. Currently it conforms to
+ the Windows, GTK+ and Mac OS X human interface guidelines.
+
+ When there aren't interface guidelines defined for a particular platform or
+ toolkit, wxStdDialogButtonSizer reverts to the Windows implementation.
+
+ To use this class, first add buttons to the sizer by calling
+ wxStdDialogButtonSizer::AddButton (or wxStdDialogButtonSizer::SetAffirmativeButton,
+ wxStdDialogButtonSizer::SetNegativeButton or wxStdDialogButtonSizer::SetCancelButton)
+ and then call Realize in order to create the actual button layout used.
+ Other than these special operations, this sizer works like any other sizer.
+ If you add a button with wxID_SAVE, on Mac OS X the button will be renamed to
+ "Save" and the wxID_NO button will be renamed to "Don't Save" in accordance
+ with the Mac OS X Human Interface Guidelines.
+
+ @library{wxcore}
+ @category{winlayout}
+
+ @see wxSizer, @ref overview_sizer, wxDialog::CreateButtonSizer
+*/
+class wxStdDialogButtonSizer : public wxBoxSizer
+{
+public:
/**
- Specifies that row idx is no longer growable.
+ Constructor for a wxStdDialogButtonSizer.
*/
- void RemoveGrowableRow(size_t idx);
+ wxStdDialogButtonSizer();
/**
- Specifies whether the sizer should flexibly resize its columns, rows, or
- both. Argument @c direction can be @c wxVERTICAL, @c wxHORIZONTAL
- or @c wxBOTH (which is the default value). Any other value is ignored. See
- @ref GetFlexibleDirection() GetFlexibleDirection for the
- explanation of these values.
- Note that this method does not trigger relayout.
+ Adds a button to the wxStdDialogButtonSizer. The @a button must have
+ one of the following identifiers:
+ - wxID_OK
+ - wxID_YES
+ - wxID_SAVE
+ - wxID_APPLY
+ - wxID_CLOSE
+ - wxID_NO
+ - wxID_CANCEL
+ - wxID_HELP
+ - wxID_CONTEXT_HELP
*/
- void SetFlexibleDirection(int direction);
+ void AddButton(wxButton* button);
/**
- Specifies how the sizer should grow in the non-flexible direction if
- there is one (so
- SetFlexibleDirection() must have
- been called previously). Argument @a mode can be one of those documented in
- GetNonFlexibleGrowMode(), please
- see there for their explanation.
- Note that this method does not trigger relayout.
+ Rearranges the buttons and applies proper spacing between buttons to make
+ them match the platform or toolkit's interface guidelines.
*/
- void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
-};
-
-
-
-/**
- @class wxSizer
-
- wxSizer is the abstract base class used for laying out subwindows in a window.
- You
- cannot use wxSizer directly; instead, you will have to use one of the sizer
- classes derived from it. Currently there are wxBoxSizer,
- wxStaticBoxSizer,
- wxGridSizer,
- wxFlexGridSizer,
- wxWrapSizer
- and wxGridBagSizer.
+ void Realize();
- The layout algorithm used by sizers in wxWidgets is closely related to layout
- in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit.
- It is
- based upon the idea of the individual subwindows reporting their minimal
- required
- size and their ability to get stretched if the size of the parent window has
- changed.
- This will most often mean that the programmer does not set the original size of
- a dialog in the beginning, rather the dialog will be assigned a sizer and this
- sizer
- will be queried about the recommended size. The sizer in turn will query its
- children, which can be normal windows, empty space or other sizers, so that
- a hierarchy of sizers can be constructed. Note that wxSizer does not derive
- from wxWindow
- and thus does not interfere with tab ordering and requires very little
- resources compared
- to a real window on screen.
+ /**
+ Sets the affirmative button for the sizer.
- What makes sizers so well fitted for use in wxWidgets is the fact that every
- control
- reports its own minimal size and the algorithm can handle differences in font
- sizes
- or different window (dialog item) sizes on different platforms without
- problems. If e.g.
- the standard font as well as the overall design of Motif widgets requires more
- space than
- on Windows, the initial dialog size will automatically be bigger on Motif than
- on Windows.
+ This allows you to use identifiers other than the standard identifiers
+ outlined above.
+ */
+ void SetAffirmativeButton(wxButton* button);
- Sizers may also be used to control the layout of custom drawn items on the
- window. The Add(), Insert(), and Prepend() functions return a pointer to
- the newly added wxSizerItem. Just add empty space of the desired size and
- attributes, and then use the wxSizerItem::GetRect() method to determine
- where the drawing operations should take place.
+ /**
+ Sets the cancel button for the sizer.
- Please notice that sizers, like child windows, are owned by the library and
- will be deleted by it which implies that they must be allocated on the
- heap. However if you create a sizer and do not add it to another sizer or
- window, the library wouldn't be able to delete such an orphan sizer and in
- this, and only this, case it should be deleted explicitly.
+ This allows you to use identifiers other than the standard identifiers
+ outlined above.
+ */
+ void SetCancelButton(wxButton* button);
- @b wxPython note: If you wish to create a sizer class in wxPython you should
- derive the class from @c wxPySizer in order to get Python-aware
- capabilities for the various virtual methods.
+ /**
+ Sets the negative button for the sizer.
+
+ This allows you to use identifiers other than the standard identifiers
+ outlined above.
+ */
+ void SetNegativeButton(wxButton* button);
+
+ virtual void RecalcSizes();
+ virtual wxSize CalcMin();
+};
- @anchor wxsizer_flags
- @par wxSizer flags
- The "flag" argument accepted by wxSizeItem constructors and other
- functions, e.g. wxSizer::Add(), is OR-combination of the following flags.
- Two main behaviours are defined using these flags. One is the border around
- a window: the border parameter determines the border width whereas the
- flags given here determine which side(s) of the item that the border will
- be added. The other flags determine how the sizer item behaves when the
- space allotted to the sizer changes, and is somewhat dependent on the
- specific kind of sizer used.
- @beginDefList
- @itemdef{wxTOP<br>
- wxBOTTOM<br>
- wxLEFT<br>
- wxRIGHT<br>
- wxALL,
- These flags are used to specify which side(s) of the sizer item
- the border width will apply to.}
- @itemdef{wxEXPAND,
- The item will be expanded to fill the space assigned to the item.}
- @itemdef{wxSHAPED,
- The item will be expanded as much as possible while also
- maintaining its aspect ratio.}
- @itemdef{wxFIXED_MINSIZE,
- Normally wxSizers will use GetAdjustedBestSize() to determine what
- the minimal size of window items should be, and will use that size
- to calculate the layout. This allows layouts to adjust when an
- item changes and its best size becomes different. If you would
- rather have a window item stay the size it started with then use
- wxFIXED_MINSIZE.}
- @itemdef{wxRESERVE_SPACE_EVEN_IF_HIDDEN,
- Normally wxSizers don't allocate space for hidden windows or other
- items. This flag overrides this behavior so that sufficient space
- is allocated for the window even if it isn't visible. This makes
- it possible to dynamically show and hide controls without resizing
- parent dialog, for example. (Available since 2.8.8.)
- }
- @itemdef{wxALIGN_CENTER<br>
- wxALIGN_CENTRE<br>
- wxALIGN_LEFT<br>
- wxALIGN_RIGHT<br>
- wxALIGN_TOP<br>
- wxALIGN_BOTTOM<br>
- wxALIGN_CENTER_VERTICAL<br>
- wxALIGN_CENTRE_VERTICAL<br>
- wxALIGN_CENTER_HORIZONTAL<br>
- wxALIGN_CENTRE_HORIZONTAL,
- The wxALIGN flags allow you to specify the alignment of the item
- within the space allotted to it by the sizer, adjusted for the
- border if any.}
- @endDefList
+/**
+ @class wxSizerItem
+
+ The wxSizerItem class is used to track the position, size and other
+ attributes of each item managed by a wxSizer.
+
+ It is not usually necessary to use this class because the sizer elements can
+ also be identified by their positions or window or sizer pointers but sometimes
+ it may be more convenient to use it directly.
+
@library{wxcore}
@category{winlayout}
-
- @see @ref overview_sizer "Sizer Overview"
*/
-class wxSizer : public wxObject
+class wxSizerItem : public wxObject
{
public:
/**
- The constructor. Note that wxSizer is an abstract base class and may not
- be instantiated.
+ Construct a sizer item for tracking a spacer.
*/
- wxSizer();
+ wxSizerItem(int width, int height, int proportion=0, int flag=0,
+ int border=0, wxObject* userData=NULL);
+ //@{
/**
- The destructor.
+ Construct a sizer item for tracking a window.
*/
- virtual ~wxSizer();
+ wxSizerItem(wxWindow* window, const wxSizerFlags& flags);
+ wxSizerItem(wxWindow* window, int proportion=0, int flag=0,
+ int border=0,
+ wxObject* userData=NULL);
+ //@}
+ //@{
/**
- Appends a child to the sizer.
-
- wxSizer itself is an abstract class, but the parameters are equivalent
- in the derived classes that you will instantiate to use it so they are
- described here:
-
- @param window
- The window to be added to the sizer. Its initial size (either set
- explicitly by the user or calculated internally when using
- wxDefaultSize) is interpreted as the minimal and in many cases also
- the initial size.
- @param flags
- A wxSizerFlags object that enables you to specify most of the above
- parameters more conveniently.
+ Construct a sizer item for tracking a subsizer.
*/
- wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags);
+ wxSizerItem(wxSizer* sizer, const wxSizerFlags& flags);
+ wxSizerItem(wxSizer* sizer, int proportion=0, int flag=0,
+ int border=0,
+ wxObject* userData=NULL);
+ //@}
/**
- Appends a child to the sizer.
-
- wxSizer itself is an abstract class, but the parameters are equivalent
- in the derived classes that you will instantiate to use it so they are
- described here:
-
- @param window
- The window to be added to the sizer. Its initial size (either set
- explicitly by the user or calculated internally when using
- wxDefaultSize) is interpreted as the minimal and in many cases also
- the initial size.
- @param proportion
- Although the meaning of this parameter is undefined in wxSizer, it
- is used in wxBoxSizer to indicate if a child of a sizer can change
- its size in the main orientation of the wxBoxSizer - where 0 stands
- for not changeable and a value of more than zero is interpreted
- relative to the value of other children of the same wxBoxSizer. For
- example, you might have a horizontal wxBoxSizer with three
- children, two of which are supposed to change their size with the
- sizer. Then the two stretchable windows would get a value of 1 each
- to make them grow and shrink equally with the sizer's horizontal
- dimension.
- @param flag
- OR-combination of flags affecting sizer's behavior. See
- @ref wxsizer_flags "wxSizer flags list" for details.
- @param border
- Determines the border width, if the flag parameter is set to
- include any border flag.
- @param userData
- Allows an extra object to be attached to the sizer item, for use in
- derived classes when sizing information is more complex than the
- proportion and flag will allow for.
+ Deletes the user data and subsizer, if any.
*/
- wxSizerItem* Add(wxWindow* window, int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ virtual ~wxSizerItem();
/**
- Appends a child to the sizer.
-
- wxSizer itself is an abstract class, but the parameters are equivalent
- in the derived classes that you will instantiate to use it so they are
- described here:
+ Set the window to be tracked by this item.
- @param sizer
- The (child-)sizer to be added to the sizer. This allows placing a
- child sizer in a sizer and thus to create hierarchies of sizers
- (typically a vertical box as the top sizer and several horizontal
- boxes on the level beneath).
- @param flags
- A wxSizerFlags object that enables you to specify most of the above
- parameters more conveniently.
+ The old window isn't deleted as it is now owned by the sizer item.
*/
- wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags);
+ void AssignWindow(wxWindow *window);
/**
- Appends a child to the sizer.
-
- wxSizer itself is an abstract class, but the parameters are equivalent
- in the derived classes that you will instantiate to use it so they are
- described here:
+ Set the sizer tracked by this item.
- @param sizer
- The (child-)sizer to be added to the sizer. This allows placing a
- child sizer in a sizer and thus to create hierarchies of sizers
- (typically a vertical box as the top sizer and several horizontal
- boxes on the level beneath).
- @param proportion
- Although the meaning of this parameter is undefined in wxSizer, it
- is used in wxBoxSizer to indicate if a child of a sizer can change
- its size in the main orientation of the wxBoxSizer - where 0 stands
- for not changeable and a value of more than zero is interpreted
- relative to the value of other children of the same wxBoxSizer. For
- example, you might have a horizontal wxBoxSizer with three
- children, two of which are supposed to change their size with the
- sizer. Then the two stretchable windows would get a value of 1 each
- to make them grow and shrink equally with the sizer's horizontal
- dimension.
- @param flag
- OR-combination of flags affecting sizer's behavior. See
- @ref wxsizer_flags "wxSizer flags list" for details.
- @param border
- Determines the border width, if the flag parameter is set to
- include any border flag.
- @param userData
- Allows an extra object to be attached to the sizer item, for use in
- derived classes when sizing information is more complex than the
- proportion and flag will allow for.
+ Old sizer, if any, is deleted.
*/
- wxSizerItem* Add(wxSizer* sizer, int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ void AssignSizer(wxSizer *sizer);
+ //@{
/**
- Appends a spacer child to the sizer.
-
- wxSizer itself is an abstract class, but the parameters are equivalent
- in the derived classes that you will instantiate to use it so they are
- described here.
-
- @a width and @a height specify the dimension of a spacer to be added to
- the sizer. Adding spacers to sizers gives more flexibility in the
- design of dialogs; imagine for example a horizontal box with two
- buttons at the bottom of a dialog: you might want to insert a space
- between the two buttons and make that space stretchable using the
- proportion flag and the result will be that the left button will be
- aligned with the left side of the dialog and the right button with the
- right side - the space in between will shrink and grow with the dialog.
+ Set the size of the spacer tracked by this item.
- @param width
- Width of the spacer.
- @param height
- Height of the spacer.
- @param proportion
- Although the meaning of this parameter is undefined in wxSizer, it
- is used in wxBoxSizer to indicate if a child of a sizer can change
- its size in the main orientation of the wxBoxSizer - where 0 stands
- for not changeable and a value of more than zero is interpreted
- relative to the value of other children of the same wxBoxSizer. For
- example, you might have a horizontal wxBoxSizer with three
- children, two of which are supposed to change their size with the
- sizer. Then the two stretchable windows would get a value of 1 each
- to make them grow and shrink equally with the sizer's horizontal
- dimension.
- @param flag
- OR-combination of flags affecting sizer's behavior. See
- @ref wxsizer_flags "wxSizer flags list" for details.
- @param border
- Determines the border width, if the flag parameter is set to
- include any border flag.
- @param userData
- Allows an extra object to be attached to the sizer item, for use in
- derived classes when sizing information is more complex than the
- proportion and flag will allow for.
+ Old spacer, if any, is deleted.
*/
- wxSizerItem* Add(int width, int height, int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ void AssignSpacer(const wxSize& size);
+ void AssignSpacer(int w, int h);
+ //@}
/**
- Adds non-stretchable space to the sizer. More readable way of calling
- wxSizer::Add(size, size, 0).
+ Calculates the minimum desired size for the item, including any space
+ needed by borders.
*/
- wxSizerItem* AddSpacer(int size);
+ virtual wxSize CalcMin();
/**
- Adds stretchable space to the sizer. More readable way of calling
- wxSizer::Add(0, 0, prop).
+ Destroy the window or the windows in a subsizer, depending on the type
+ of item.
*/
- wxSizerItem* AddStretchSpacer(int prop = 1);
+ virtual void DeleteWindows();
/**
- This method is abstract and has to be overwritten by any derived class.
- Here, the sizer will do the actual calculation of its children's minimal sizes.
+ Enable deleting the SizerItem without destroying the contained sizer.
*/
- virtual wxSize CalcMin();
+ void DetachSizer();
/**
- Detaches all children from the sizer. If @a delete_windows is @true then
- child windows will also be deleted.
+ Return the border attribute.
*/
- virtual void Clear(bool delete_windows = false);
+ int GetBorder() const;
/**
- Computes client area size for @a window so that it matches the sizer's
- minimal size. Unlike GetMinSize(), this method accounts for other
- constraints imposed on @e window, namely display's size (returned size
- will never be too large for the display) and maximum window size if
- previously set by wxWindow::SetMaxSize(). The returned value is
- suitable for passing to wxWindow::SetClientSize() or
- wxWindow::SetMinClientSize().
-
- @since 2.8.8
+ Return the flags attribute.
- @see ComputeFittingWindowSize(), Fit()
+ See @ref wxsizer_flags "wxSizer flags list" for details.
*/
- wxSize ComputeFittingClientSize(wxWindow* window);
+ int GetFlag() const;
/**
- Like ComputeFittingClientSize(), but converts the result into window
- size. The returned value is suitable for passing to wxWindow::SetSize()
- or wxWindow::SetMinSize().
-
- @since 2.8.8
+ Return the numeric id of wxSizerItem, or @c wxID_NONE if the id has
+ not been set.
+ */
+ int GetId() const;
- @see ComputeFittingClientSize(), Fit()
+ /**
+ Get the minimum size needed for the item.
*/
- wxSize ComputeFittingWindowSize(wxWindow* window);
+ wxSize GetMinSize() const;
/**
- Detach the child @a window from the sizer without destroying it.
+ Sets the minimum size to be allocated for this item.
- This method does not cause any layout or resizing to take place, call Layout()
- to update the layout "on screen" after detaching a child from the sizer.
+ If this item is a window, the @a size is also passed to
+ wxWindow::SetMinSize().
+ */
+ void SetMinSize(const wxSize& size);
- Returns @true if the child item was found and detached, @false otherwise.
+ /**
+ @overload
+ */
+ void SetMinSize(int x, int y);
- @see Remove()
+ /**
+ What is the current position of the item, as set in the last Layout.
*/
- virtual bool Detach(wxWindow* window);
+ wxPoint GetPosition() const;
/**
- Detach the child @a sizer from the sizer without destroying it.
+ Get the proportion item attribute.
+ */
+ int GetProportion() const;
- This method does not cause any layout or resizing to take place, call Layout()
- to update the layout "on screen" after detaching a child from the sizer.
+ /**
+ Get the ration item attribute.
+ */
+ float GetRatio() const;
- Returns @true if the child item was found and detached, @false otherwise.
+ /**
+ Get the rectangle of the item on the parent window, excluding borders.
+ */
+ virtual wxRect GetRect();
- @see Remove()
+ /**
+ Get the current size of the item, as set in the last Layout.
+ */
+ virtual wxSize GetSize() const;
+
+ /**
+ If this item is tracking a sizer, return it. @NULL otherwise.
*/
- virtual bool Detach(wxSizer* sizer);
+ wxSizer* GetSizer() const;
/**
- Detach a item at position @a index from the sizer without destroying it.
+ If this item is tracking a spacer, return its size.
+ */
+ wxSize GetSpacer() const;
- This method does not cause any layout or resizing to take place, call Layout()
- to update the layout "on screen" after detaching a child from the sizer.
- Returns @true if the child item was found and detached, @false otherwise.
+ /**
+ Get the userData item attribute.
+ */
+ wxObject* GetUserData() const;
- @see Remove()
+ /**
+ If this item is tracking a window then return it. @NULL otherwise.
*/
- bool Detach(size_t index);
+ wxWindow* GetWindow() const;
/**
- Tell the sizer to resize the @a window so that its client area matches the
- sizer's minimal size
- (ComputeFittingClientSize() is called
- to determine it).
- This is commonly done in the constructor of the window
- itself, see sample in the description
- of wxBoxSizer. Returns the new window size.
+ Returns @true if this item is a window or a spacer and it is shown or
+ if this item is a sizer and not all of its elements are hidden.
- @see ComputeFittingClientSize(), ComputeFittingWindowSize()
+ In other words, for sizer items, all of the child elements must be
+ hidden for the sizer itself to be considered hidden.
+
+ As an exception, if the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was
+ used for this sizer item, then IsShown() always returns @true for it
+ (see wxSizerFlags::ReserveSpaceEvenIfHidden()).
*/
- wxSize Fit(wxWindow* window);
+ bool IsShown() const;
/**
- Tell the sizer to resize the virtual size of the @a window to match the sizer's
- minimal size. This will not alter the on screen size of the window, but may
- cause the addition/removal/alteration of scrollbars required to view the virtual
- area in windows which manage it.
-
- @see wxScrolled::SetScrollbars(), SetVirtualSizeHints()
+ Is this item a sizer?
*/
- void FitInside(wxWindow* window);
+ bool IsSizer() const;
/**
- Returns the list of the items in this sizer. The elements of type-safe
- wxList @a wxSizerItemList are pointers to objects of type
- @ref wxSizerItem "wxSizerItem".
+ Is this item a spacer?
*/
- wxSizerItemList& GetChildren();
+ bool IsSpacer() const;
/**
- Returns the list of the items in this sizer. The elements of type-safe
- wxList @a wxSizerItemList are pointers to objects of type
- @ref wxSizerItem "wxSizerItem".
+ Is this item a window?
*/
- const wxSizerItemList& GetChildren() const;
+ bool IsWindow() const;
/**
- Returns the window this sizer is used in or @NULL if none.
+ Set the border item attribute.
*/
- wxWindow* GetContainingWindow() const;
+ void SetBorder(int border);
/**
- Finds wxSizerItem which holds the given @a window
- Use parameter @a recursive to search in subsizers too.
- Returns pointer to item or @NULL.
+ Set the position and size of the space allocated to the sizer, and
+ adjust the position and size of the item to be within that space
+ taking alignment and borders into account.
*/
- wxSizerItem* GetItem(wxWindow* window, bool recursive = false);
+ virtual void SetDimension(const wxPoint& pos, const wxSize& size);
/**
- Finds wxSizerItem which holds the given @a sizer
- Use parameter @a recursive to search in subsizers too.
- Returns pointer to item or @NULL.
+ Set the flag item attribute.
*/
+ void SetFlag(int flag);
- wxSizerItem* GetItem(wxSizer* sizer, bool recursive = false);
/**
- Finds wxSizerItem which is located in the sizer at position
- @a index.
- Use parameter @a recursive to search in subsizers too.
- Returns pointer to item or @NULL.
+ Sets the numeric id of the wxSizerItem to @e id.
*/
- wxSizerItem* GetItem(size_t index);
+ void SetId(int id);
/**
- Finds item of the sizer which has the given @e id. This @a id is not the
- window id but the id of the wxSizerItem itself. This is mainly useful for
- retrieving the sizers created from XRC resources.
- Use parameter @a recursive to search in subsizers too.
- Returns pointer to item or @NULL.
+ @todo docme.
*/
- wxSizerItem* GetItemById(int id, bool recursive = false);
+ void SetInitSize(int x, int y);
/**
- Returns the minimal size of the sizer. This is either the combined minimal
- size of all the children and their borders or the minimal size set by
- SetMinSize(), depending on which is bigger.
- Note that the returned value is client size, not window size.
- In particular, if you use the value to set toplevel window's minimal or
- actual size, use wxWindow::SetMinClientSize
- or wxWindow::SetClientSize, not
- wxWindow::SetMinSize
- or wxWindow::SetSize.
+ Set the proportion item attribute.
*/
- wxSize GetMinSize();
+ void SetProportion(int proportion);
+ //@{
/**
- Returns the current position of the sizer.
+ Set the ratio item attribute.
*/
- wxPoint GetPosition() const;
+ void SetRatio(int width, int height);
+ void SetRatio(wxSize size);
+ void SetRatio(float ratio);
+ //@}
/**
- Returns the current size of the sizer.
+ Set the sizer tracked by this item.
+
+ @deprecated This function does not free the old sizer which may result
+ in memory leaks, use AssignSizer() which does free it instead.
*/
- wxSize GetSize() const;
+ void SetSizer(wxSizer* sizer);
/**
- Hides the child @a window.
+ Set the size of the spacer tracked by this item.
- To make a sizer item disappear, use Hide() followed by Layout().
+ @deprecated This function does not free the old spacer which may result
+ in memory leaks, use AssignSpacer() which does free it instead.
+ */
+ void SetSpacer(const wxSize& size);
- Use parameter @a recursive to hide elements found in subsizers.
- Returns @true if the child item was found, @false otherwise.
+ void SetUserData(wxObject* userData);
- @see IsShown(), Show()
+ /**
+ Set the window to be tracked by this item.
+ @deprecated @todo provide deprecation description
*/
- bool Hide(wxWindow* window, bool recursive = false);
+ void SetWindow(wxWindow* window);
/**
- Hides the child @a sizer.
+ Set the show item attribute, which sizers use to determine if the item
+ is to be made part of the layout or not. If the item is tracking a
+ window then it is shown or hidden as needed.
+ */
+ void Show(bool show);
+};
- To make a sizer item disappear, use Hide() followed by Layout().
- Use parameter @a recursive to hide elements found in subsizers.
- Returns @true if the child item was found, @false otherwise.
- @see IsShown(), Show()
- */
- bool Hide(wxSizer* sizer, bool recursive = false);
+/**
+ @class wxSizerFlags
- /**
- Hides the item at position @a index.
+ Container for sizer items flags providing readable names for them.
- To make a sizer item disappear, use Hide() followed by Layout().
+ Normally, when you add an item to a sizer via wxSizer::Add, you have to
+ specify a lot of flags and parameters which can be unwieldy. This is where
+ wxSizerFlags comes in: it allows you to specify all parameters using the
+ named methods instead. For example, instead of
- Use parameter @a recursive to hide elements found in subsizers.
- Returns @true if the child item was found, @false otherwise.
+ @code
+ sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
+ @endcode
- @see IsShown(), Show()
- */
- bool Hide(size_t index);
+ you can now write
- /**
- Insert a child into the sizer before any existing item at @a index.
+ @code
+ sizer->Add(ctrl, wxSizerFlags().Expand().Border(wxALL, 10));
+ @endcode
- See Add() for the meaning of the other parameters.
- */
- wxSizerItem* Insert(size_t index, wxWindow* window,
- const wxSizerFlags& flags);
+ This is more readable and also allows you to create wxSizerFlags objects which
+ can be reused for several sizer items.
- /**
- Insert a child into the sizer before any existing item at @a index.
+ @code
+ wxSizerFlags flagsExpand(1);
+ flagsExpand.Expand().Border(wxALL, 10);
- See Add() for the meaning of the other parameters.
- */
- wxSizerItem* Insert(size_t index, wxWindow* window,
- int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ sizer->Add(ctrl1, flagsExpand);
+ sizer->Add(ctrl2, flagsExpand);
+ @endcode
- /**
- Insert a child into the sizer before any existing item at @a index.
+ Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
+ object itself to allowing chaining multiple methods calls like in the examples
+ above.
- See Add() for the meaning of the other parameters.
- */
- wxSizerItem* Insert(size_t index, wxSizer* sizer,
- const wxSizerFlags& flags);
+ @library{wxcore}
+ @category{winlayout}
+ @see wxSizer
+*/
+class wxSizerFlags
+{
+public:
/**
- Insert a child into the sizer before any existing item at @a index.
-
- See Add() for the meaning of the other parameters.
+ Creates the wxSizer with the proportion specified by @a proportion.
*/
- wxSizerItem* Insert(size_t index, wxSizer* sizer,
- int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ wxSizerFlags(int proportion = 0);
/**
- Insert a child into the sizer before any existing item at @a index.
+ Sets the alignment of this wxSizerFlags to @a align.
- See Add() for the meaning of the other parameters.
- */
- wxSizerItem* Insert(size_t index, int width, int height,
- int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ This method replaces the previously set alignment with the specified one.
- /**
- Inserts non-stretchable space to the sizer. More readable way of calling
- wxSizer::Insert(size, size, 0).
+ @param alignment
+ Combination of @c wxALIGN_XXX bit masks.
+
+ @see Top(), Left(), Right(), Bottom(), Centre()
*/
- wxSizerItem* InsertSpacer(size_t index, int size);
+ wxSizerFlags& Align(int alignment);
/**
- Inserts stretchable space to the sizer. More readable way of calling
- wxSizer::Insert(0, 0, prop).
+ Sets the wxSizerFlags to have a border of a number of pixels specified
+ by @a borderinpixels with the directions specified by @a direction.
*/
- wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
+ wxSizerFlags& Border(int direction, int borderinpixels);
/**
- Returns @true if the @e window is shown.
+ Sets the wxSizerFlags to have a border with size as returned by
+ GetDefaultBorder().
- @see Hide(), Show(), wxSizerItem::IsShown()
+ @param direction
+ Direction(s) to apply the border in.
*/
- bool IsShown(wxWindow* window) const;
+ wxSizerFlags& Border(int direction = wxALL);
/**
- Returns @true if the @e sizer is shown.
+ Aligns the object to the bottom, similar for @c Align(wxALIGN_BOTTOM).
- @see Hide(), Show(), wxSizerItem::IsShown()
+ Unlike Align(), this method doesn't change the horizontal alignment of
+ the item.
*/
- bool IsShown(wxSizer* sizer) const;
+ wxSizerFlags& Bottom();
/**
- Returns @true if the item at @a index is shown.
-
- @see Hide(), Show(), wxSizerItem::IsShown()
+ Sets the object of the wxSizerFlags to center itself in the area it is
+ given.
*/
- bool IsShown(size_t index) const;
+ wxSizerFlags& Center();
/**
- Call this to force layout of the children anew, e.g. after having added a child
- to or removed a child (window, other sizer or space) from the sizer while
- keeping
- the current dimension.
+ Center() for people with the other dialect of English.
*/
- virtual void Layout();
+ wxSizerFlags& Centre();
/**
- Same as Add(), but prepends the items to the beginning of the
- list of items (windows, subsizers or spaces) owned by this sizer.
+ Sets the border in the given @a direction having twice the default
+ border size.
*/
- wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags);
+ wxSizerFlags& DoubleBorder(int direction = wxALL);
/**
- Same as Add(), but prepends the items to the beginning of the
- list of items (windows, subsizers or spaces) owned by this sizer.
+ Sets the border in left and right directions having twice the default
+ border size.
*/
- wxSizerItem* Prepend(wxWindow* window, int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ wxSizerFlags& DoubleHorzBorder();
/**
- Same as Add(), but prepends the items to the beginning of the
- list of items (windows, subsizers or spaces) owned by this sizer.
+ Sets the object of the wxSizerFlags to expand to fill as much area as
+ it can.
*/
- wxSizerItem* Prepend(wxSizer* sizer,
- const wxSizerFlags& flags);
+ wxSizerFlags& Expand();
/**
- Same as Add(), but prepends the items to the beginning of the
- list of items (windows, subsizers or spaces) owned by this sizer.
+ Set the @c wxFIXED_MINSIZE flag which indicates that the initial size
+ of the window should be also set as its minimal size.
*/
- wxSizerItem* Prepend(wxSizer* sizer, int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ wxSizerFlags& FixedMinSize();
/**
- Same as Add(), but prepends the items to the beginning of the
- list of items (windows, subsizers or spaces) owned by this sizer.
+ Set the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers
+ don't allocate space for hidden windows or other items. This flag
+ overrides this behaviour so that sufficient space is allocated for the
+ window even if it isn't visible. This makes it possible to dynamically
+ show and hide controls without resizing parent dialog, for example.
+
+ @since 2.8.8
*/
- wxSizerItem* Prepend(int width, int height,
- int proportion = 0,
- int flag = 0,
- int border = 0,
- wxObject* userData = NULL);
+ wxSizerFlags& ReserveSpaceEvenIfHidden();
/**
- Prepends non-stretchable space to the sizer. More readable way of
- calling wxSizer::Prepend(size, size, 0).
+ Returns the border used by default in Border() method.
*/
- wxSizerItem* PrependSpacer(int size);
+ static int GetDefaultBorder();
/**
- Prepends stretchable space to the sizer. More readable way of calling
- wxSizer::Prepend(0, 0, prop).
+ Aligns the object to the left, similar for @c Align(wxALIGN_LEFT).
+
+ Unlike Align(), this method doesn't change the vertical alignment of
+ the item.
*/
- wxSizerItem* PrependStretchSpacer(int prop = 1);
+ wxSizerFlags& Left();
/**
- This method is abstract and has to be overwritten by any derived class.
- Here, the sizer will do the actual calculation of its children's
- positions and sizes.
+ Sets the proportion of this wxSizerFlags to @e proportion
*/
- virtual void RecalcSizes();
+ wxSizerFlags& Proportion(int proportion);
/**
- Removes a child window from the sizer, but does @b not destroy it
- (because windows are owned by their parent window, not the sizer).
-
- @deprecated
- The overload of this method taking a wxWindow* parameter
- is deprecated as it does not destroy the window as would usually be
- expected from Remove(). You should use Detach() in new code instead.
- There is currently no wxSizer method that will both detach and destroy
- a wxWindow item.
-
- @note This method does not cause any layout or resizing to take
- place, call Layout() to update the layout "on screen" after
- removing a child from the sizer.
+ Aligns the object to the right, similar for @c Align(wxALIGN_RIGHT).
- @return @true if the child item was found and removed, @false otherwise.
+ Unlike Align(), this method doesn't change the vertical alignment of
+ the item.
*/
- bool Remove(wxWindow* window);
+ wxSizerFlags& Right();
/**
- Removes a sizer child from the sizer and destroys it.
-
- @note This method does not cause any layout or resizing to take
- place, call Layout() to update the layout "on screen" after
- removing a child from the sizer.
-
- @param sizer The wxSizer to be removed.
-
- @return @true if the child item was found and removed, @false otherwise.
+ Set the @c wx_SHAPED flag which indicates that the elements should
+ always keep the fixed width to height ratio equal to its original value.
*/
- virtual bool Remove(wxSizer* sizer);
+ wxSizerFlags& Shaped();
/**
- Removes a child from the sizer and destroys it if it is a sizer or a
- spacer, but not if it is a window (because windows are owned by their
- parent window, not the sizer).
-
- @note This method does not cause any layout or resizing to take
- place, call Layout() to update the layout "on screen" after
- removing a child from the sizer.
-
- @param index The position of the child in the sizer, e.g. 0 for the
- first item.
+ Aligns the object to the top, similar for @c Align(wxALIGN_TOP).
- @return @true if the child item was found and removed, @false otherwise.
+ Unlike Align(), this method doesn't change the horizontal alignment of
+ the item.
*/
- bool Remove(size_t index);
+ wxSizerFlags& Top();
/**
- Detaches the given @a oldwin from the sizer and
- replaces it with the given @a newwin. The detached
- child window is @b not deleted (because windows are
- owned by their parent window, not the sizer).
-
- Use parameter @a recursive to search the given element recursively in subsizers.
-
- This method does not cause any layout or resizing to take place,
- call Layout() to update the layout "on screen" after replacing a
- child from the sizer.
-
- Returns @true if the child item was found and removed, @false otherwise.
+ Sets the border in the given @a direction having thrice the default
+ border size.
*/
- bool Replace(wxWindow* oldwin, wxWindow* newwin,
- bool recursive = false);
+ wxSizerFlags& TripleBorder(int direction = wxALL);
+};
- /**
- Detaches the given @a oldsz from the sizer and
- replaces it with the given @a newsz. The detached
- child sizer is deleted.
- Use parameter @a recursive to search the given element recursively in subsizers.
+/**
+ Values which define the behaviour for resizing wxFlexGridSizer cells in the
+ "non-flexible" direction.
+*/
+enum wxFlexSizerGrowMode
+{
+ /// Don't resize the cells in non-flexible direction at all.
+ wxFLEX_GROWMODE_NONE,
- This method does not cause any layout or resizing to take place,
- call Layout() to update the layout "on screen" after replacing a
- child from the sizer.
+ /// Uniformly resize only the specified ones (default).
+ wxFLEX_GROWMODE_SPECIFIED,
- Returns @true if the child item was found and removed, @false otherwise.
- */
- bool Replace(wxSizer* oldsz, wxSizer* newsz,
- bool recursive = false);
+ /// Uniformly resize all cells.
+ wxFLEX_GROWMODE_ALL
+};
- /**
- Detaches the given item at position @a index from the sizer and
- replaces it with the given wxSizerItem @a newitem.
+/**
+ @class wxFlexGridSizer
- The detached child is deleted @b only if it is a sizer or a spacer
- (but not if it is a wxWindow because windows are owned by their
- parent window, not the sizer).
+ A flex grid sizer is a sizer which lays out its children in a two-dimensional
+ table with all table fields in one row having the same height and all fields
+ in one column having the same width, but all rows or all columns are not
+ necessarily the same height or width as in the wxGridSizer.
- This method does not cause any layout or resizing to take place,
- call Layout() to update the layout "on screen" after replacing a
- child from the sizer.
+ Since wxWidgets 2.5.0, wxFlexGridSizer can also size items equally in one
+ direction but unequally ("flexibly") in the other. If the sizer is only
+ flexible in one direction (this can be changed using wxFlexGridSizer::SetFlexibleDirection),
+ it needs to be decided how the sizer should grow in the other ("non-flexible")
+ direction in order to fill the available space.
+ The wxFlexGridSizer::SetNonFlexibleGrowMode() method serves this purpose.
- Returns @true if the child item was found and removed, @false otherwise.
- */
- virtual bool Replace(size_t index, wxSizerItem* newitem);
+ @library{wxcore}
+ @category{winlayout}
+ @see wxSizer, @ref overview_sizer
+*/
+class wxFlexGridSizer : public wxGridSizer
+{
+public:
+ //@{
/**
- Call this to force the sizer to take the given dimension and thus force
- the items owned by the sizer to resize themselves according to the
- rules defined by the parameter in the Add() and Prepend() methods.
+ wxFlexGridSizer constructors.
+
+ Please see wxGridSizer::wxGridSizer documentation.
+
+ @since 2.9.1 (except for the four argument overload)
*/
- void SetDimension(int x, int y, int width, int height);
+ wxFlexGridSizer( int cols, int vgap, int hgap );
+ wxFlexGridSizer( int cols, const wxSize& gap = wxSize(0, 0) );
- /**
- @overload
- */
- void SetDimension(const wxPoint& pos, const wxSize& size);
+ wxFlexGridSizer( int rows, int cols, int vgap, int hgap );
+ wxFlexGridSizer( int rows, int cols, const wxSize& gap );
+ //@}
/**
- Set an item's minimum size by window, sizer, or position.
+ Specifies that column @a idx (starting from zero) should be grown if
+ there is extra space available to the sizer.
- The item will be found recursively in the sizer's descendants. This
- function enables an application to set the size of an item after
- initial creation.
+ The @a proportion parameter has the same meaning as the stretch factor
+ for the sizers (see wxBoxSizer) except that if all proportions are 0,
+ then all columns are resized equally (instead of not being resized at all).
- @see wxSizerItem::SetMinSize()
+ Notice that the column must not be already growable, if you need to change
+ the proportion you must call RemoveGrowableCol() first and then make it
+ growable (with a different proportion) again. You can use IsColGrowable()
+ to check whether a column is already growable.
*/
- void SetItemMinSize(wxWindow* window, int width, int height);
+ void AddGrowableCol(size_t idx, int proportion = 0);
/**
- Set an item's minimum size by window, sizer, or position.
-
- The item will be found recursively in the sizer's descendants. This
- function enables an application to set the size of an item after
- initial creation.
+ Specifies that row idx (starting from zero) should be grown if there
+ is extra space available to the sizer.
- @see wxSizerItem::SetMinSize()
+ This is identical to AddGrowableCol() except that it works with rows
+ and not columns.
*/
- void SetItemMinSize(wxSizer* sizer, int width, int height);
+ void AddGrowableRow(size_t idx, int proportion = 0);
/**
- Set an item's minimum size by window, sizer, or position.
+ Returns a ::wxOrientation value that specifies whether the sizer flexibly
+ resizes its columns, rows, or both (default).
- The item will be found recursively in the sizer's descendants. This
- function enables an application to set the size of an item after
- initial creation.
+ @return
+ One of the following values:
+ - wxVERTICAL: Rows are flexibly sized.
+ - wxHORIZONTAL: Columns are flexibly sized.
+ - wxBOTH: Both rows and columns are flexibly sized (this is the default value).
- @see wxSizerItem::SetMinSize()
+ @see SetFlexibleDirection()
*/
- void SetItemMinSize(size_t index, int width, int height);
+ int GetFlexibleDirection() const;
/**
- Call this to give the sizer a minimal size. Normally, the sizer will
- calculate its minimal size based purely on how much space its children
- need. After calling this method GetMinSize() will return either the
- minimal size as requested by its children or the minimal size set here,
- depending on which is bigger.
- */
- void SetMinSize(const wxSize& size);
+ Returns the value that specifies how the sizer grows in the "non-flexible"
+ direction if there is one.
- /**
- @overload
- */
- void SetMinSize(int width, int height);
+ The behaviour of the elements in the flexible direction (i.e. both rows
+ and columns by default, or rows only if GetFlexibleDirection() is
+ @c wxVERTICAL or columns only if it is @c wxHORIZONTAL) is always governed
+ by their proportion as specified in the call to AddGrowableRow() or
+ AddGrowableCol(). What happens in the other direction depends on the
+ value of returned by this function as described below.
- /**
- This method first calls Fit() and then
- wxTopLevelWindow::SetSizeHints on the @e window
- passed to it. This only makes sense when @a window is actually a
- wxTopLevelWindow such as a wxFrame or a
- wxDialog, since SetSizeHints only has any effect in these classes.
- It does nothing in normal windows or controls.
- This method is implicitly used by wxWindow::SetSizerAndFit
- which is commonly invoked in the constructor of a toplevel window itself (see
- the sample in the description of wxBoxSizer) if the
- toplevel window is resizable.
+ @return
+ One of the following values:
+ - wxFLEX_GROWMODE_NONE: Sizer doesn't grow its elements at all in
+ the non-flexible direction.
+ - wxFLEX_GROWMODE_SPECIFIED: Sizer honors growable columns/rows set
+ with AddGrowableCol() and AddGrowableRow() in the non-flexible
+ direction as well. In this case equal sizing applies to minimum
+ sizes of columns or rows (this is the default value).
+ - wxFLEX_GROWMODE_ALL: Sizer equally stretches all columns or rows in
+ the non-flexible direction, independently of the proportions
+ applied in the flexible direction.
+
+ @see SetFlexibleDirection(), SetNonFlexibleGrowMode()
*/
- void SetSizeHints(wxWindow* window);
+ wxFlexSizerGrowMode GetNonFlexibleGrowMode() const;
/**
- Tell the sizer to set the minimal size of the @a window virtual area to match
- the sizer's
- minimal size. For windows with managed scrollbars this will set them
- appropriately.
+ Returns @true if column @a idx is growable.
- @see wxScrolled::SetScrollbars()
- @deprecated @todo provide deprecation description
+ @since 2.9.0
*/
- void SetVirtualSizeHints(wxWindow* window);
+ bool IsColGrowable(size_t idx);
/**
- Shows or hides the @a window.
- To make a sizer item disappear or reappear, use Show() followed by Layout().
-
- Use parameter @a recursive to show or hide elements found in subsizers.
+ Returns @true if row @a idx is growable.
- Returns @true if the child item was found, @false otherwise.
+ @since 2.9.0
+ */
+ bool IsRowGrowable(size_t idx);
- @see Hide(), IsShown()
+ /**
+ Specifies that the @a idx column index is no longer growable.
*/
- bool Show(wxWindow* window, bool show = true,
- bool recursive = false);
+ void RemoveGrowableCol(size_t idx);
/**
- Shows or hides @a sizer.
- To make a sizer item disappear or reappear, use Show() followed by Layout().
+ Specifies that the @a idx row index is no longer growable.
+ */
+ void RemoveGrowableRow(size_t idx);
- Use parameter @a recursive to show or hide elements found in subsizers.
+ /**
+ Specifies whether the sizer should flexibly resize its columns, rows, or both.
- Returns @true if the child item was found, @false otherwise.
+ Argument @a direction can be @c wxVERTICAL, @c wxHORIZONTAL or @c wxBOTH
+ (which is the default value). Any other value is ignored.
- @see Hide(), IsShown()
+ See GetFlexibleDirection() for the explanation of these values.
+ Note that this method does not trigger relayout.
*/
- bool Show(wxSizer* sizer, bool show = true,
- bool recursive = false);
+ void SetFlexibleDirection(int direction);
/**
- Shows the item at @a index.
- To make a sizer item disappear or reappear, use Show() followed by Layout().
-
- Returns @true if the child item was found, @false otherwise.
+ Specifies how the sizer should grow in the non-flexible direction if
+ there is one (so SetFlexibleDirection() must have been called previously).
- @see Hide(), IsShown()
+ Argument @a mode can be one of those documented in GetNonFlexibleGrowMode(),
+ please see there for their explanation.
+ Note that this method does not trigger relayout.
*/
- bool Show(size_t index, bool show = true);
+ void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
+
+ virtual void RecalcSizes();
+ virtual wxSize CalcMin();
+
};
-
/**
@class wxGridSizer
A grid sizer is a sizer which lays out its children in a two-dimensional
- table with all table fields having the same size,
- i.e. the width of each field is the width of the widest child,
- the height of each field is the height of the tallest child.
+ table with all table fields having the same size, i.e. the width of each
+ field is the width of the widest child, the height of each field is the
+ height of the tallest child.
@library{wxcore}
@category{winlayout}
- @see wxSizer, @ref overview_sizer "Sizer Overview"
+ @see wxSizer, @ref overview_sizer
*/
class wxGridSizer : public wxSizer
{
public:
//@{
/**
- Constructor for a wxGridSizer. @a rows and @a cols determine the number of
- columns and rows in the sizer - if either of the parameters is zero, it will be
- calculated to form the total number of children in the sizer, thus making the
- sizer grow dynamically. @a vgap and @a hgap define extra space between
- all children.
+ wxGridSizer constructors.
+
+ Usually only the number of columns in the flex grid sizer needs to be
+ specified using @a cols argument. The number of rows will be deduced
+ automatically depending on the number of the elements added to the
+ sizer.
+
+ If a constructor form with @a rows parameter is used (and the value of
+ @a rows argument is not zero, meaning "unspecified") the sizer will
+ check that no more than @c cols*rows elements are added to it, i.e.
+ that no more than the given number of @a rows is used. Adding less than
+ maximally allowed number of items is not an error however.
+
+ Finally, it is also possible to specify the number of rows and use 0
+ for @a cols. In this case, the sizer will use the given fixed number of
+ rows and as many columns as necessary.
+
+ The @a gap (or @a vgap and @a hgap, which correspond to the height and
+ width of the wxSize object) argument defines the size of the padding
+ between the rows (its vertical component, or @a vgap) and columns
+ (its horizontal component, or @a hgap), in pixels.
+
+
+ @since 2.9.1 (except for the four argument overload)
*/
- wxGridSizer(int rows, int cols, int vgap, int hgap);
- wxGridSizer(int cols, int vgap = 0, int hgap = 0);
+ wxGridSizer( int cols, int vgap, int hgap );
+ wxGridSizer( int cols, const wxSize& gap = wxSize(0, 0) );
+
+ wxGridSizer( int rows, int cols, int vgap, int hgap );
+ wxGridSizer( int rows, int cols, const wxSize& gap );
//@}
/**
- Returns the number of columns in the sizer.
+ Returns the number of columns that has been specified for the
+ sizer.
+
+ Returns zero if the sizer is automatically adjusting the number of
+ columns depending on number of its children. To get the effective
+ number of columns or rows being currently used, see GetEffectiveColsCount()
*/
int GetCols() const;
+
+ /**
+ Returns the number of rows that has been specified for the
+ sizer.
+
+ Returns zero if the sizer is automatically adjusting the number of
+ rows depending on number of its children. To get the effective
+ number of columns or rows being currently used, see GetEffectiveRowsCount().
+ */
+ int GetRows() const;
/**
- Returns the horizontal gap (in pixels) between cells in the sizer.
+ Returns the number of columns currently used by the sizer.
+
+ This will depend on the number of children the sizer has if
+ the sizer is automatically adjusting the number of columns/rows.
+
+ @since 2.9.1
*/
- int GetHGap() const;
+ int GetEffectiveColsCount() const;
+
+ /**
+ Returns the number of rows currently used by the sizer.
+
+ This will depend on the number of children the sizer has if
+ the sizer is automatically adjusting the number of columns/rows.
+
+ @since 2.9.1
+ */
+ int GetEffectiveRowsCount() const;
/**
- Returns the number of rows in the sizer.
+ Returns the horizontal gap (in pixels) between cells in the sizer.
*/
- int GetRows() const;
+ int GetHGap() const;
/**
Returns the vertical gap (in pixels) between the cells in the sizer.
Sets the vertical gap (in pixels) between the cells in the sizer.
*/
void SetVGap(int gap);
+
+ virtual wxSize CalcMin();
+ virtual void RecalcSizes();
};
/**
@class wxStaticBoxSizer
- wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
- box around the sizer. This static box may be either created independently or
- the sizer may create it itself as a convenience. In any case, the sizer owns
- the wxStaticBox control and will delete it if it is
- deleted.
+ wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static box around
+ the sizer.
+
+ The static box may be either created independently or the sizer may create it
+ itself as a convenience. In any case, the sizer owns the wxStaticBox control
+ and will delete it in the wxStaticBoxSizer destructor.
+
+ Note that since wxWidgets 2.9.1 you are encouraged to create the windows
+ which are added to wxStaticBoxSizer as children of wxStaticBox itself, see
+ this class documentation for more details.
+
+ Example of use of this class:
+ @code
+ void MyFrame::CreateControls()
+ {
+ wxPanel *panel = new wxPanel(this);
+ ...
+ wxStaticBoxSizer *sz = new wxStaticBoxSizer(wxVERTICAL, panel, "Box");
+ sz->Add(new wxStaticText(sz->GetStaticBox(), wxID_ANY,
+ "This window is a child of the staticbox"));
+ ...
+ }
+ @endcode
@library{wxcore}
@category{winlayout}
@see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizer
- "Sizer Overview"
*/
class wxStaticBoxSizer : public wxBoxSizer
{
public:
- //@{
/**
- The first constructor uses an already existing static box. It takes the
- associated static box and the orientation @e orient, which can be either
- @c wxVERTICAL or @c wxHORIZONTAL as parameters.
- The second one creates a new static box with the given label and parent window.
+ This constructor uses an already existing static box.
+
+ @param box
+ The static box to associate with the sizer (which will take its
+ ownership).
+ @param orient
+ Can be either @c wxVERTICAL or @c wxHORIZONTAL.
*/
wxStaticBoxSizer(wxStaticBox* box, int orient);
- wxStaticBoxSizer(int orient, wxWindow parent,
+
+ /**
+ This constructor creates a new static box with the given label and parent window.
+ */
+ wxStaticBoxSizer(int orient, wxWindow *parent,
const wxString& label = wxEmptyString);
- //@}
/**
Returns the static box associated with the sizer.
*/
wxStaticBox* GetStaticBox() const;
+
+ virtual wxSize CalcMin();
+ virtual void RecalcSizes();
};
@class wxBoxSizer
The basic idea behind a box sizer is that windows will most often be laid out
- in rather
- simple basic geometry, typically in a row or a column or several hierarchies of
- either.
+ in rather simple basic geometry, typically in a row or a column or several
+ hierarchies of either.
- For more information, please see @ref overview_sizer_box
- "Programming with wxBoxSizer".
+ For more information, please see @ref overview_sizer_box.
@library{wxcore}
@category{winlayout}
- @see wxSizer, @ref overview_sizer "Sizers Overview"
+ @see wxSizer, @ref overview_sizer
*/
class wxBoxSizer : public wxSizer
{
wxBoxSizer(int orient);
/**
- Implements the calculation of a box sizer's minimal. It is used internally
- only and must not be called by the user. Documented for information.
+ Adds non-stretchable space to the main orientation of the sizer only.
+ More readable way of calling:
+ @code
+ if ( wxBoxSizer::IsVertical() )
+ {
+ wxBoxSizer::Add(0, size, 0).
+ }
+ else
+ {
+ wxBoxSizer::Add(size, 0, 0).
+ }
+ @endcode
+ */
+ virtual wxSizerItem *AddSpacer(int size);
+
+ /**
+ Implements the calculation of a box sizer's minimal.
+
+ It is used internally only and must not be called by the user.
+ Documented for information.
*/
virtual wxSize CalcMin();
*/
int GetOrientation() const;
+ /**
+ Sets the orientation of the box sizer, either wxVERTICAL
+ or wxHORIZONTAL.
+ */
+ void SetOrientation(int orient);
+
/**
Implements the calculation of a box sizer's dimensions and then sets
- the size of its children (calling wxWindow::SetSize
- if the child is a window). It is used internally only and must not be called
- by the user (call Layout() if you want to resize). Documented for information.
+ the size of its children (calling wxWindow::SetSize if the child is a window).
+
+ It is used internally only and must not be called by the user
+ (call Layout() if you want to resize). Documented for information.
*/
- void RecalcSizes();
+ virtual void RecalcSizes();
};
projects / wxWidgets.git / blobdiff