8258c3ddbd
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@38782 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
591 lines
23 KiB
TeX
591 lines
23 KiB
TeX
\section{\class{wxSizer}}\label{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 \helpref{wxBoxSizer}{wxboxsizer},
|
|
\helpref{wxStaticBoxSizer}{wxstaticboxsizer},
|
|
\helpref{wxGridSizer}{wxgridsizer}
|
|
\helpref{wxFlexGridSizer}{wxflexgridsizer} and \helpref{wxGridBagSizer}{wxgridbagsizer}.
|
|
|
|
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.
|
|
|
|
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
|
|
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.
|
|
|
|
|
|
\pythonnote{If you wish to create a sizer class in wxPython you should
|
|
derive the class from {\tt wxPySizer} in order to get Python-aware
|
|
capabilities for the various virtual methods.}
|
|
|
|
\wxheading{Derived from}
|
|
|
|
\helpref{wxObject}{wxobject}\\
|
|
\helpref{wxClientDataContainer}{wxclientdatacontainer}
|
|
|
|
\wxheading{Include files}
|
|
|
|
<wx/sizer.h>
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Sizer overview}{sizeroverview}
|
|
|
|
\latexignore{\rtfignore{\wxheading{Members}}}
|
|
|
|
|
|
\membersection{wxSizer::wxSizer}\label{wxsizerwxsizer}
|
|
|
|
\func{}{wxSizer}{\void}
|
|
|
|
The constructor. Note that wxSizer is an abstract base class and may not
|
|
be instantiated.
|
|
|
|
|
|
\membersection{wxSizer::\destruct{wxSizer}}\label{wxsizerdtor}
|
|
|
|
\func{}{\destruct{wxSizer}}{\void}
|
|
|
|
The destructor.
|
|
|
|
|
|
\membersection{wxSizer::Add}\label{wxsizeradd}
|
|
|
|
\func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{int }{proportion = 0},\param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Add}{\param{int }{width}, \param{int }{height}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{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:
|
|
|
|
\docparam{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. This is particularly useful in connection with \helpref{SetSizeHints}{wxsizersetsizehints}.}
|
|
|
|
\docparam{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).}
|
|
|
|
\docparam{width and height}{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 \arg{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.}
|
|
|
|
\docparam{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.}
|
|
|
|
\docparam{flag}{This parameter can be used to set a number of flags
|
|
which can be combined using the binary OR operator |. Two main
|
|
behaviours are defined using these flags. One is the border around a
|
|
window: the \arg{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.
|
|
|
|
\twocolwidtha{5cm}%
|
|
\begin{twocollist}\itemsep=0pt
|
|
\twocolitem{\windowstyle{wxTOP}\\
|
|
\windowstyle{wxBOTTOM}\\
|
|
\windowstyle{wxLEFT}\\
|
|
\windowstyle{wxRIGHT}\\
|
|
\windowstyle{wxALL}}{These flags are used to specify which side(s) of
|
|
the sizer item the \arg{border} width will apply to. }
|
|
|
|
\twocolitem{\windowstyle{wxEXPAND}}{The item will be expanded to fill
|
|
the space assigned to the item.}
|
|
\twocolitem{\windowstyle{wxSHAPED}}{The item will be expanded as much
|
|
as possible while also maintaining its aspect ratio}
|
|
\twocolitem{\windowstyle{wxFIXED\_MINSIZE}}{Normally wxSizers will use
|
|
\helpref{GetAdjustedBestSize}{wxwindowgetadjustedbestsize} 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 \arg{best size} becomes
|
|
different. If you would rather have a window item stay the size it
|
|
started with then use wxFIXED\_MINSIZE.}
|
|
\twocolitem{\windowstyle{wxALIGN\_CENTER}\\
|
|
\windowstyle{wxALIGN\_LEFT}\\
|
|
\windowstyle{wxALIGN\_RIGHT}\\
|
|
\windowstyle{wxALIGN\_TOP}\\
|
|
\windowstyle{wxALIGN\_BOTTOM}\\
|
|
\windowstyle{wxALIGN\_CENTER\_VERTICAL}\\
|
|
\windowstyle{wxALIGN\_CENTER\_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.}
|
|
\end{twocollist}
|
|
}
|
|
|
|
\docparam{border}{Determines the border width, if the \arg{flag}
|
|
parameter is set to include any border flag.}
|
|
|
|
\docparam{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 \arg{proportion} and \arg{flag} will allow for.}
|
|
|
|
\docparam{flags}{A \helpref{wxSizerFlags}{wxsizerflags} object that
|
|
enables you to specify most of the above parameters more conveniently.}
|
|
|
|
\membersection{wxSizer::AddSpacer}\label{wxsizeraddspacer}
|
|
|
|
\func{wxSizerItem*}{AddSpacer}{\param{int }{size}}
|
|
|
|
Adds non-stretchable space to the sizer. More readable way of calling
|
|
\helpref{Add}{wxsizeradd}(size, size, 0).
|
|
|
|
|
|
\membersection{wxSizer::AddStretchSpacer}\label{wxsizeraddstretchspacer}
|
|
|
|
\func{wxSizerItem*}{AddStretchSpacer}{\param{int }{prop = 1}}
|
|
|
|
Adds stretchable space to the sizer. More readable way of calling
|
|
\helpref{Add}{wxsizeradd}(0, 0, prop).
|
|
|
|
|
|
\membersection{wxSizer::CalcMin}\label{wxsizercalcmin}
|
|
|
|
\func{wxSize}{CalcMin}{\void}
|
|
|
|
This method is abstract and has to be overwritten by any derived class.
|
|
Here, the sizer will do the actual calculation of its children minimal sizes.
|
|
|
|
|
|
\membersection{wxSizer::Clear}\label{wxsizerclear}
|
|
|
|
\func{void}{Clear}{\param{bool }{delete\_windows = false}}
|
|
|
|
Detaches all children from the sizer. If \arg{delete\_windows} is \true then child windows will also be deleted.
|
|
|
|
|
|
\membersection{wxSizer::Detach}\label{wxsizerdetach}
|
|
|
|
\func{bool}{Detach}{\param{wxWindow* }{window}}
|
|
|
|
\func{bool}{Detach}{\param{wxSizer* }{sizer}}
|
|
|
|
\func{bool}{Detach}{\param{size\_t }{index}}
|
|
|
|
Detach a child from the sizer without destroying it. \arg{window} is the window to be
|
|
detached, \arg{sizer} is the equivalent sizer and \arg{index} is the position of
|
|
the child in the sizer, typically 0 for the first item. This method does not
|
|
cause any layout or resizing to take place, call \helpref{wxSizer::Layout}{wxsizerlayout}
|
|
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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxSizer::Remove}{wxsizerremove}
|
|
|
|
|
|
\membersection{wxSizer::Fit}\label{wxsizerfit}
|
|
|
|
\func{wxSize}{Fit}{\param{wxWindow* }{window}}
|
|
|
|
Tell the sizer to resize the \arg{window} to match the sizer's minimal size. This
|
|
is commonly done in the constructor of the window itself, see sample in the description
|
|
of \helpref{wxBoxSizer}{wxboxsizer}. Returns the new size.
|
|
|
|
For a top level window this is the total window size, not client size.
|
|
|
|
|
|
\membersection{wxSizer::FitInside}\label{wxsizerfitinside}
|
|
|
|
\func{void}{FitInside}{\param{wxWindow* }{window}}
|
|
|
|
Tell the sizer to resize the virtual size of the \arg{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.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars},\rtfsp
|
|
\helpref{wxSizer::SetVirtualSizeHints}{wxsizersetvirtualsizehints}
|
|
|
|
|
|
\membersection{wxSizer::GetItem}\label{wxsizergetitem}
|
|
|
|
\func{wxSizerItem *}{GetItem}{\param{wxWindow* }{window}, \param{bool }{recursive = false}}
|
|
|
|
\func{wxSizerItem *}{GetItem}{\param{wxSizer* }{sizer}, \param{bool }{recursive = false}}
|
|
|
|
\func{wxSizerItem *}{GetItem}{\param{size\_t }{index}}
|
|
|
|
Finds item of the sizer which holds given \arg{window}, \arg{sizer} or is located
|
|
in sizer at position \arg{index}.
|
|
Use parameter \arg{recursive} to search in subsizers too.
|
|
|
|
Returns pointer to item or NULL.
|
|
|
|
|
|
\membersection{wxSizer::GetSize}\label{wxsizergetsize}
|
|
|
|
\func{wxSize}{GetSize}{\void}
|
|
|
|
Returns the current size of the sizer.
|
|
|
|
|
|
\membersection{wxSizer::GetPosition}\label{wxsizergetposition}
|
|
|
|
\func{wxPoint}{GetPosition}{\void}
|
|
|
|
Returns the current position of the sizer.
|
|
|
|
|
|
\membersection{wxSizer::GetMinSize}\label{wxsizergetminsize}
|
|
|
|
\func{wxSize}{GetMinSize}{\void}
|
|
|
|
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
|
|
\helpref{SetMinSize}{wxsizersetminsize}, depending on which is bigger.
|
|
|
|
|
|
\membersection{wxSizer::Hide}\label{wxsizerhide}
|
|
|
|
\func{bool}{Hide}{\param{wxWindow* }{window}, \param{bool }{recursive = false}}
|
|
|
|
\func{bool}{Hide}{\param{wxSizer* }{sizer}, \param{bool }{recursive = false}}
|
|
|
|
\func{bool}{Hide}{\param{size\_t }{index}}
|
|
|
|
Hides the \arg{window}, \arg{sizer}, or item at \arg{index}.
|
|
To make a sizer item disappear, use Hide() followed by \helpref{Layout()}{wxsizerlayout}.
|
|
Use parameter \arg{recursive} to hide elements found in subsizers.
|
|
|
|
Returns \true if the child item was found, \false otherwise.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxSizer::IsShown}{wxsizerisshown},\rtfsp
|
|
\helpref{wxSizer::Show}{wxsizershow}
|
|
|
|
|
|
\membersection{wxSizer::Insert}\label{wxsizerinsert}
|
|
|
|
\func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxWindow* }{window}, \param{int }{proportion = 0},\param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{int }{width}, \param{int }{height}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
Insert a child into the sizer before any existing item at \arg{index}.
|
|
|
|
\docparam{index}{The position this child should assume in the sizer.}
|
|
|
|
See \helpref{wxSizer::Add}{wxsizeradd} for the meaning of the other parameters.
|
|
|
|
|
|
\membersection{wxSizer::InsertSpacer}\label{wxsizerinsertspacer}
|
|
|
|
\func{wxSizerItem*}{InsertSpacer}{\param{size\_t }{index}, \param{int }{size}}
|
|
|
|
Inserts non-stretchable space to the sizer. More readable way of calling
|
|
\helpref{Insert}{wxsizerinsert}(size, size, 0).
|
|
|
|
|
|
\membersection{wxSizer::InsertStretchSpacer}\label{wxsizerinsertstretchspacer}
|
|
|
|
\func{wxSizerItem*}{InsertStretchSpacer}{\param{size\_t }{index}, \param{int }{prop = 1}}
|
|
|
|
Inserts stretchable space to the sizer. More readable way of calling
|
|
\helpref{Insert}{wxsizerinsert}(0, 0, prop).
|
|
|
|
|
|
\membersection{wxSizer::IsShown}\label{wxsizerisshown}
|
|
|
|
\constfunc{bool}{IsShown}{\param{wxWindow* }{window}}
|
|
|
|
\constfunc{bool}{IsShown}{\param{wxSizer* }{sizer}}
|
|
|
|
\constfunc{bool}{IsShown}{\param{size\_t }{index}}
|
|
|
|
Returns \true if the \arg{window}, \arg{sizer}, or item at \arg{index} is shown.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxSizer::Hide}{wxsizerhide},\rtfsp
|
|
\helpref{wxSizer::Show}{wxsizershow}
|
|
|
|
|
|
\membersection{wxSizer::Layout}\label{wxsizerlayout}
|
|
|
|
\func{void}{Layout}{\void}
|
|
|
|
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.
|
|
|
|
|
|
\membersection{wxSizer::Prepend}\label{wxsizerprepend}
|
|
|
|
\func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
|
|
|
|
\func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
\func{wxSizerItem*}{Prepend}{\param{int }{width}, \param{int }{height}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border= 0}, \param{wxObject* }{userData = NULL}}
|
|
|
|
Same as \helpref{wxSizer::Add}{wxsizeradd}, but prepends the items to the beginning of the
|
|
list of items (windows, subsizers or spaces) owned by this sizer.
|
|
|
|
|
|
\membersection{wxSizer::PrependSpacer}\label{wxsizerprependspacer}
|
|
|
|
\func{wxSizerItem*}{PrependSpacer}{\param{int }{size}}
|
|
|
|
Prepends non-stretchable space to the sizer. More readable way of calling
|
|
\helpref{Prepend}{wxsizerprepend}(size, size, 0).
|
|
|
|
|
|
\membersection{wxSizer::PrependStretchSpacer}\label{wxsizerprependstretchspacer}
|
|
|
|
\func{wxSizerItem*}{PrependStretchSpacer}{\param{int }{prop = 1}}
|
|
|
|
Prepends stretchable space to the sizer. More readable way of calling
|
|
\helpref{Prepend}{wxsizerprepend}(0, 0, prop).
|
|
|
|
|
|
\membersection{wxSizer::RecalcSizes}\label{wxsizerrecalcsizes}
|
|
|
|
\func{void}{RecalcSizes}{\void}
|
|
|
|
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.
|
|
|
|
|
|
\membersection{wxSizer::Remove}\label{wxsizerremove}
|
|
|
|
\func{bool}{Remove}{\param{wxWindow* }{window}}
|
|
|
|
\func{bool}{Remove}{\param{wxSizer* }{sizer}}
|
|
|
|
\func{bool}{Remove}{\param{size\_t }{index}}
|
|
|
|
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). \arg{sizer} is the wxSizer to be removed,
|
|
\arg{index} is the position of the child in the sizer, e.g. $0$ for the first item.
|
|
This method does not cause any layout or resizing to take place, call
|
|
\helpref{wxSizer::Layout}{wxsizerlayout} to update the layout "on screen" after removing a
|
|
child from the sizer.
|
|
|
|
{\bf NB:} The method taking a wxWindow* parameter is deprecated as it does not
|
|
destroy the window as would usually be expected from Remove. You should use
|
|
\helpref{wxSizer::Detach}{wxsizerdetach} in new code instead. There is
|
|
currently no wxSizer method that will both detach and destroy a wxWindow item.
|
|
|
|
Returns true if the child item was found and removed, false otherwise.
|
|
|
|
|
|
\membersection{wxSizer::SetDimension}\label{wxsizersetdimension}
|
|
|
|
\func{void}{SetDimension}{\param{int }{x}, \param{int }{y}, \param{int }{width}, \param{int }{height}}
|
|
|
|
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
|
|
\helpref{Add}{wxsizeradd} and \helpref{Prepend}{wxsizerprepend} methods.
|
|
|
|
|
|
\membersection{wxSizer::SetMinSize}\label{wxsizersetminsize}
|
|
|
|
\func{void}{SetMinSize}{\param{int }{width}, \param{int }{height}}
|
|
|
|
\func{void}{SetMinSize}{\param{const wxSize\& }{size}}
|
|
|
|
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 \helpref{GetMinSize}{wxsizergetminsize} will return either the minimal size
|
|
as requested by its children or the minimal size set here, depending on which is
|
|
bigger.
|
|
|
|
|
|
\membersection{wxSizer::SetItemMinSize}\label{wxsizersetitemminsize}
|
|
|
|
\func{void}{SetItemMinSize}{\param{wxWindow* }{window}, \param{int}{ width}, \param{int}{ height}}
|
|
|
|
\func{void}{SetItemMinSize}{\param{wxSizer* }{sizer}, \param{int}{ width}, \param{int}{ height}}
|
|
|
|
\func{void}{SetItemMinSize}{\param{size\_t }{index}, \param{int}{ width}, \param{int}{ height}}
|
|
|
|
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.
|
|
|
|
|
|
\membersection{wxSizer::SetSizeHints}\label{wxsizersetsizehints}
|
|
|
|
\func{void}{SetSizeHints}{\param{wxWindow* }{window}}
|
|
|
|
Tell the sizer to set (and \helpref{Fit}{wxsizerfit}) the minimal size of the \arg{window} to
|
|
match the sizer's minimal size. This is commonly done in the constructor of the window itself,
|
|
see sample in the description of \helpref{wxBoxSizer}{wxboxsizer} if the window is resizable
|
|
(as are many dialogs under Unix and frames on probably all platforms).
|
|
|
|
|
|
\membersection{wxSizer::SetVirtualSizeHints}\label{wxsizersetvirtualsizehints}
|
|
|
|
\func{void}{SetVirtualSizeHints}{\param{wxWindow* }{window}}
|
|
|
|
Tell the sizer to set the minimal size of the \arg{window} virtual area to match the sizer's
|
|
minimal size. For windows with managed scrollbars this will set them appropriately.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars}
|
|
|
|
|
|
\membersection{wxSizer::Show}\label{wxsizershow}
|
|
|
|
\func{bool}{Show}{\param{wxWindow* }{window}, \param{bool }{show = true}, \param{bool }{recursive = false}}
|
|
|
|
\func{bool}{Show}{\param{wxSizer* }{sizer}, \param{bool }{show = true}, \param{bool }{recursive = false}}
|
|
|
|
\func{bool}{Show}{\param{size\_t }{index}, \param{bool }{show = true}}
|
|
|
|
Shows or hides the \arg{window}, \arg{sizer}, or item at \arg{index}.
|
|
To make a sizer item disappear or reappear, use Show() followed by \helpref{Layout()}{wxsizerlayout}.
|
|
Use parameter \arg{recursive} to show or hide elements found in subsizers.
|
|
|
|
Returns true if the child item was found, false otherwise.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxSizer::Hide}{wxsizerhide},\rtfsp
|
|
\helpref{wxSizer::IsShown}{wxsizerisshown}
|
|
|
|
|
|
|
|
|
|
\section{\class{wxSizerFlags}}\label{wxsizerflags}
|
|
|
|
PRELIMINARY.
|
|
|
|
Normally, when you add something to a sizer via \helpref{wxSizer::Add}{wxsizeradd}, you have to specify a lot of flags and parameters. This can be unwieldy.
|
|
|
|
This is where wxSizerFlags comes in. Instead of a bunch of flags and other stuff, you can use wxSizerFlags, which is a convenient class for doing so.
|
|
|
|
Note that by specification, all methods of wxSizerFlags return the wxSizerFlags object itself to ease the calling of multiple methods at a time.
|
|
|
|
|
|
\membersection{wxSizerFlags::wxSizerFlags}\label{wxsizerflagsctor}
|
|
|
|
\func{}{wxSizerFlags}{\param{int }{proportion = 0}}
|
|
|
|
Creates the wxSizer with the proportion specified by \tt{proportion}.
|
|
|
|
|
|
\membersection{wxSizerFlags::Align}\label{wxsizerflagsalign}
|
|
|
|
\func{wxSizerFlags\& }{Align}{\param{int }{align = 0}}
|
|
|
|
Sets the alignment of this wxSizerFlags to \tt{align}.
|
|
|
|
Note that if this method is not called, the wxSizerFlags has no specified alignment.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Left}{wxsizerflagsleft},\\
|
|
\helpref{Right}{wxsizerflagsright},\\
|
|
\helpref{Centre}{wxsizerflagscentre}
|
|
|
|
|
|
\membersection{wxSizerFlags::Border}\label{wxsizerflagsborder}
|
|
|
|
\func{wxSizerFlags\& }{Border}{\param{int }{direction}, \param{int }{borderinpixels}}
|
|
|
|
Sets the wxSizerFlags to have a border of a number of pixels specified by \tt{borderinpixels} with the directions specified by \tt{direction}.
|
|
|
|
\func{wxSizerFlags\& }{Border}{\param{int }{direction = wxALL}}
|
|
|
|
Sets the wxSizerFlags to have a border of a default size with the directions specified by \tt{direction}.
|
|
|
|
|
|
\membersection{wxSizerFlags::Center}\label{wxsizerflagscenter}
|
|
|
|
\func{wxSizerFlags\& }{Center}{\void}
|
|
|
|
Sets the object of the wxSizerFlags to center itself in the area it is given.
|
|
|
|
|
|
\membersection{wxSizerFlags::Centre}\label{wxsizerflagscentre}
|
|
|
|
\func{wxSizerFlags\& }{Centre}{\void}
|
|
|
|
\helpref{wxSizerFlags::Center}{wxsizerflagscenter} for people with the other dialect of english.
|
|
|
|
|
|
\membersection{wxSizerFlags::Expand}\label{wxsizerflagsexpand}
|
|
|
|
\func{wxSizerFlags\& }{Expand}{\void}
|
|
|
|
Sets the object of the wxSizerFlags to expand to fill as much area as it can.
|
|
|
|
|
|
\membersection{wxSizerFlags::Left}\label{wxsizerflagsleft}
|
|
|
|
\func{wxSizerFlags\& }{Left}{\void}
|
|
|
|
Aligns the object to the left, shortcut for \texttt{Align(wxALIGN\_LEFT)}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Align}{wxsizerflagsalign}
|
|
|
|
|
|
\membersection{wxSizerFlags::Proportion}\label{wxsizerflagsproportion}
|
|
|
|
\func{wxSizerFlags\& }{Proportion}{\param{int }{proportion = 0}}
|
|
|
|
Sets the proportion of this wxSizerFlags to \tt{proportion}
|
|
|
|
|
|
\membersection{wxSizerFlags::Right}\label{wxsizerflagsright}
|
|
|
|
\func{wxSizerFlags\& }{Right}{\void}
|
|
|
|
Aligns the object to the right, shortcut for \texttt{Align(wxALIGN\_RIGHT)}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Align}{wxsizerflagsalign}
|
|
|