]>
Commit | Line | Data |
---|---|---|
1 | \section{\class{wxSizer}}\label{wxsizer} | |
2 | ||
3 | wxSizer is the abstract base class used for laying out subwindows in a window. You | |
4 | cannot use wxSizer directly; instead, you will have to use one of the sizer | |
5 | classes derived from it. Currently there are \helpref{wxBoxSizer}{wxboxsizer}, | |
6 | \helpref{wxStaticBoxSizer}{wxstaticboxsizer}, | |
7 | \helpref{wxGridSizer}{wxgridsizer} | |
8 | \helpref{wxFlexGridSizer}{wxflexgridsizer} and \helpref{wxGridBagSizer}{wxgridbagsizer}. | |
9 | ||
10 | The layout algorithm used by sizers in wxWidgets is closely related to layout | |
11 | in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit. It is | |
12 | based upon the idea of the individual subwindows reporting their minimal required | |
13 | size and their ability to get stretched if the size of the parent window has changed. | |
14 | This will most often mean that the programmer does not set the original size of | |
15 | a dialog in the beginning, rather the dialog will be assigned a sizer and this sizer | |
16 | will be queried about the recommended size. The sizer in turn will query its | |
17 | children, which can be normal windows, empty space or other sizers, so that | |
18 | a hierarchy of sizers can be constructed. Note that wxSizer does not derive from wxWindow | |
19 | and thus does not interfere with tab ordering and requires very little resources compared | |
20 | to a real window on screen. | |
21 | ||
22 | What makes sizers so well fitted for use in wxWidgets is the fact that every control | |
23 | reports its own minimal size and the algorithm can handle differences in font sizes | |
24 | or different window (dialog item) sizes on different platforms without problems. If e.g. | |
25 | the standard font as well as the overall design of Motif widgets requires more space than | |
26 | on Windows, the initial dialog size will automatically be bigger on Motif than on Windows. | |
27 | ||
28 | \pythonnote{If you wish to create a sizer class in wxPython you should | |
29 | derive the class from {\tt wxPySizer} in order to get Python-aware | |
30 | capabilities for the various virtual methods.} | |
31 | ||
32 | \wxheading{Derived from} | |
33 | ||
34 | \helpref{wxObject}{wxobject}\\ | |
35 | \helpref{wxClientDataContainer}{wxclientdatacontainer} | |
36 | ||
37 | \wxheading{Include files} | |
38 | ||
39 | <wx/sizer.h> | |
40 | ||
41 | \wxheading{See also} | |
42 | ||
43 | \helpref{Sizer overview}{sizeroverview} | |
44 | ||
45 | \latexignore{\rtfignore{\wxheading{Members}}} | |
46 | ||
47 | ||
48 | \membersection{wxSizer::wxSizer}\label{wxsizerwxsizer} | |
49 | ||
50 | \func{}{wxSizer}{\void} | |
51 | ||
52 | The constructor. Note that wxSizer is an abstract base class and may not | |
53 | be instantiated. | |
54 | ||
55 | ||
56 | \membersection{wxSizer::\destruct{wxSizer}}\label{wxsizerdtor} | |
57 | ||
58 | \func{}{\destruct{wxSizer}}{\void} | |
59 | ||
60 | The destructor. | |
61 | ||
62 | ||
63 | \membersection{wxSizer::Add}\label{wxsizeradd} | |
64 | ||
65 | \func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}} | |
66 | ||
67 | \func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{int }{proportion = 0},\param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}} | |
68 | ||
69 | \func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}} | |
70 | ||
71 | \func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}} | |
72 | ||
73 | \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}} | |
74 | ||
75 | Appends a child to the sizer. wxSizer itself is an abstract class, but the parameters are | |
76 | equivalent in the derived classes that you will instantiate to use it so they are described | |
77 | here: | |
78 | ||
79 | \docparam{window}{The window to be added to the sizer. Its initial size (either set explicitly by the | |
80 | user or calculated internally when using wxDefaultSize) is interpreted as the minimal and in many | |
81 | cases also the initial size. This is particularly useful in connection with \helpref{SetSizeHints}{wxsizersetsizehints}.} | |
82 | ||
83 | \docparam{sizer}{The (child-)sizer to be added to the sizer. This allows placing a child sizer in a | |
84 | sizer and thus to create hierarchies of sizers (typically a vertical box as the top sizer and several | |
85 | horizontal boxes on the level beneath).} | |
86 | ||
87 | \docparam{width and height}{The dimension of a spacer to be added to the sizer. Adding spacers to sizers | |
88 | gives more flexibility in the design of dialogs; imagine for example a horizontal box with two buttons at the | |
89 | bottom of a dialog: you might want to insert a space between the two buttons and make that space stretchable | |
90 | using the {\it proportion} flag and the result will be that the left button will be aligned with the left | |
91 | side of the dialog and the right button with the right side - the space in between will shrink and grow with | |
92 | the dialog.} | |
93 | ||
94 | \docparam{proportion}{Although the meaning of this parameter is undefined in wxSizer, it is used in wxBoxSizer | |
95 | to indicate if a child of a sizer can change its size in the main orientation of the wxBoxSizer - where | |
96 | 0 stands for not changeable and a value of more than zero is interpreted relative to the value of other | |
97 | children of the same wxBoxSizer. For example, you might have a horizontal wxBoxSizer with three children, two | |
98 | of which are supposed to change their size with the sizer. Then the two stretchable windows would get a | |
99 | value of 1 each to make them grow and shrink equally with the sizer's horizontal dimension.} | |
100 | ||
101 | \docparam{flag}{This parameter can be used to set a number of flags | |
102 | which can be combined using the binary OR operator |. Two main | |
103 | behaviours are defined using these flags. One is the border around a | |
104 | window: the {\it border} parameter determines the border width whereas | |
105 | the flags given here determine which side(s) of the item that the | |
106 | border will be added. The other flags determine how the sizer item | |
107 | behaves when the space allotted to the sizer changes, and is somewhat | |
108 | dependent on the specific kind of sizer used. | |
109 | ||
110 | \twocolwidtha{5cm}% | |
111 | \begin{twocollist}\itemsep=0pt | |
112 | \twocolitem{\windowstyle{wxTOP}\\ | |
113 | \windowstyle{wxBOTTOM}\\ | |
114 | \windowstyle{wxLEFT}\\ | |
115 | \windowstyle{wxRIGHT}\\ | |
116 | \windowstyle{wxALL}}{These flags are used to specify which side(s) of | |
117 | the sizer item the {\it border} width will apply to. } | |
118 | ||
119 | \twocolitem{\windowstyle{wxEXPAND}}{The item will be expanded to fill | |
120 | the space assigned to the item.} | |
121 | \twocolitem{\windowstyle{wxSHAPED}}{The item will be expanded as much | |
122 | as possible while also maintaining its aspect ratio} | |
123 | \twocolitem{\windowstyle{wxFIXED\_MINSIZE}}{Normally wxSizers will use | |
124 | \helpref{GetAdjustedBestSize}{wxwindowgetadjustedbestsize} to | |
125 | determine what the minimal size of window items should be, and will | |
126 | use that size to calculate the layout. This allows layouts to | |
127 | adjust when an item changes and its {\it best size} becomes | |
128 | different. If you would rather have a window item stay the size it | |
129 | started with then use wxFIXED\_MINSIZE.} | |
130 | \twocolitem{\windowstyle{wxALIGN\_CENTER}\\ | |
131 | \windowstyle{wxALIGN\_LEFT}\\ | |
132 | \windowstyle{wxALIGN\_RIGHT}\\ | |
133 | \windowstyle{wxALIGN\_TOP}\\ | |
134 | \windowstyle{wxALIGN\_BOTTOM}\\ | |
135 | \windowstyle{wxALIGN\_CENTER\_VERTICAL}\\ | |
136 | \windowstyle{wxALIGN\_CENTER\_HORIZONTAL}}{The wxALIGN flags allow you to | |
137 | specify the alignment of the item within the space allotted to it by | |
138 | the sizer, adjusted for the border if any.} | |
139 | \end{twocollist} | |
140 | } | |
141 | ||
142 | \docparam{border}{Determines the border width, if the {\it flag} | |
143 | parameter is set to include any border flag.} | |
144 | ||
145 | \docparam{userData}{Allows an extra object to be attached to the sizer | |
146 | item, for use in derived classes when sizing information is more | |
147 | complex than the {\it proportion} and {\it flag} will allow for.} | |
148 | ||
149 | \docparam{flags}{A \helpref{wxSizerFlags}{wxsizerflags} object that | |
150 | enables you to specify most of the above parameters more conveniently.} | |
151 | ||
152 | \membersection{wxSizer::AddSpacer}\label{wxsizeraddspacer} | |
153 | ||
154 | \func{wxSizerItem*}{AddSpacer}{\param{int }{size}} | |
155 | ||
156 | Adds non-stretchable space to the sizer. More readable way of calling | |
157 | \helpref{Add}{wxsizeradd}(size, size, 0). | |
158 | ||
159 | ||
160 | \membersection{wxSizer::AddStretchSpacer}\label{wxsizeraddstretchspacer} | |
161 | ||
162 | \func{wxSizerItem*}{AddStretchSpacer}{\param{int }{prop = 1}} | |
163 | ||
164 | Adds stretchable space to the sizer. More readable way of calling | |
165 | \helpref{Add}{wxsizeradd}(0, 0, prop). | |
166 | ||
167 | ||
168 | \membersection{wxSizer::CalcMin}\label{wxsizercalcmin} | |
169 | ||
170 | \func{wxSize}{CalcMin}{\void} | |
171 | ||
172 | This method is abstract and has to be overwritten by any derived class. | |
173 | Here, the sizer will do the actual calculation of its children minimal sizes. | |
174 | ||
175 | ||
176 | \membersection{wxSizer::Detach}\label{wxsizerdetach} | |
177 | ||
178 | \func{bool}{Detach}{\param{wxWindow* }{window}} | |
179 | ||
180 | \func{bool}{Detach}{\param{wxSizer* }{sizer}} | |
181 | ||
182 | \func{bool}{Detach}{\param{size\_t }{index}} | |
183 | ||
184 | Detach a child from the sizer without destroying it. {\it window} is the window to be | |
185 | detached, {\it sizer} is the equivalent sizer and {\it index} is the position of | |
186 | the child in the sizer, typically 0 for the first item. This method does not | |
187 | cause any layout or resizing to take place, call \helpref{wxSizer::Layout}{wxsizerlayout} | |
188 | to update the layout "on screen" after detaching a child from the sizer. | |
189 | ||
190 | Returns true if the child item was found and detached, false otherwise. | |
191 | ||
192 | \wxheading{See also} | |
193 | ||
194 | \helpref{wxSizer::Remove}{wxsizerremove} | |
195 | ||
196 | ||
197 | \membersection{wxSizer::Fit}\label{wxsizerfit} | |
198 | ||
199 | \func{wxSize}{Fit}{\param{wxWindow* }{window}} | |
200 | ||
201 | Tell the sizer to resize the {\it window} to match the sizer's minimal size. This | |
202 | is commonly done in the constructor of the window itself, see sample in the description | |
203 | of \helpref{wxBoxSizer}{wxboxsizer}. Returns the new size. | |
204 | ||
205 | For a top level window this is the total window size, not client size. | |
206 | ||
207 | ||
208 | \membersection{wxSizer::FitInside}\label{wxsizerfitinside} | |
209 | ||
210 | \func{void}{FitInside}{\param{wxWindow* }{window}} | |
211 | ||
212 | Tell the sizer to resize the virtual size of the {\it window} to match the sizer's | |
213 | minimal size. This will not alter the on screen size of the window, but may cause | |
214 | the addition/removal/alteration of scrollbars required to view the virtual area in | |
215 | windows which manage it. | |
216 | ||
217 | \wxheading{See also} | |
218 | ||
219 | \helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars},\rtfsp | |
220 | \helpref{wxSizer::SetVirtualSizeHints}{wxsizersetvirtualsizehints} | |
221 | ||
222 | ||
223 | \membersection{wxSizer::GetItem}\label{wxsizergetitem} | |
224 | ||
225 | \func{wxSizerItem *}{GetItem}{\param{wxWindow* }{window}, \param{bool }{recursive = false}} | |
226 | ||
227 | \func{wxSizerItem *}{GetItem}{\param{wxSizer* }{sizer}, \param{bool }{recursive = false}} | |
228 | ||
229 | \func{wxSizerItem *}{GetItem}{\param{size\_t }{index}} | |
230 | ||
231 | Finds item of the sizer which holds given {\it window}, {\it sizer} or is located | |
232 | in sizer at position {\it index}. | |
233 | Use parameter {\it recursive} to search in subsizers too. | |
234 | ||
235 | Returns pointer to item or NULL. | |
236 | ||
237 | ||
238 | \membersection{wxSizer::GetSize}\label{wxsizergetsize} | |
239 | ||
240 | \func{wxSize}{GetSize}{\void} | |
241 | ||
242 | Returns the current size of the sizer. | |
243 | ||
244 | ||
245 | \membersection{wxSizer::GetPosition}\label{wxsizergetposition} | |
246 | ||
247 | \func{wxPoint}{GetPosition}{\void} | |
248 | ||
249 | Returns the current position of the sizer. | |
250 | ||
251 | ||
252 | \membersection{wxSizer::GetMinSize}\label{wxsizergetminsize} | |
253 | ||
254 | \func{wxSize}{GetMinSize}{\void} | |
255 | ||
256 | Returns the minimal size of the sizer. This is either the combined minimal | |
257 | size of all the children and their borders or the minimal size set by | |
258 | \helpref{SetMinSize}{wxsizersetminsize}, depending on which is bigger. | |
259 | ||
260 | ||
261 | \membersection{wxSizer::Insert}\label{wxsizerinsert} | |
262 | ||
263 | \func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}} | |
264 | ||
265 | \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}} | |
266 | ||
267 | \func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}} | |
268 | ||
269 | \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}} | |
270 | ||
271 | \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}} | |
272 | ||
273 | Insert a child into the sizer before any existing item at {\it index}. | |
274 | ||
275 | \docparam{index}{The position this child should assume in the sizer.} | |
276 | ||
277 | See \helpref{wxSizer::Add}{wxsizeradd} for the meaning of the other parameters. | |
278 | ||
279 | ||
280 | \membersection{wxSizer::InsertSpacer}\label{wxsizerinsertspacer} | |
281 | ||
282 | \func{wxSizerItem*}{InsertSpacer}{\param{size\_t }{index}, \param{int }{size}} | |
283 | ||
284 | Inserts non-stretchable space to the sizer. More readable way of calling | |
285 | \helpref{Insert}{wxsizerinsert}(size, size, 0). | |
286 | ||
287 | ||
288 | \membersection{wxSizer::InsertStretchSpacer}\label{wxsizerinsertstretchspacer} | |
289 | ||
290 | \func{wxSizerItem*}{InsertStretchSpacer}{\param{size\_t }{index}, \param{int }{prop = 1}} | |
291 | ||
292 | Inserts stretchable space to the sizer. More readable way of calling | |
293 | \helpref{Insert}{wxsizerinsert}(0, 0, prop). | |
294 | ||
295 | ||
296 | \membersection{wxSizer::Layout}\label{wxsizerlayout} | |
297 | ||
298 | \func{void}{Layout}{\void} | |
299 | ||
300 | Call this to force layout of the children anew, e.g. after having added a child | |
301 | to or removed a child (window, other sizer or space) from the sizer while keeping | |
302 | the current dimension. | |
303 | ||
304 | ||
305 | \membersection{wxSizer::Prepend}\label{wxsizerprepend} | |
306 | ||
307 | \func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}} | |
308 | ||
309 | \func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}} | |
310 | ||
311 | \func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}} | |
312 | ||
313 | \func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}} | |
314 | ||
315 | \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}} | |
316 | ||
317 | Same as \helpref{wxSizer::Add}{wxsizeradd}, but prepends the items to the beginning of the | |
318 | list of items (windows, subsizers or spaces) owned by this sizer. | |
319 | ||
320 | ||
321 | \membersection{wxSizer::PrependSpacer}\label{wxsizerprependspacer} | |
322 | ||
323 | \func{wxSizerItem*}{PrependSpacer}{\param{int }{size}} | |
324 | ||
325 | Prepends non-stretchable space to the sizer. More readable way of calling | |
326 | \helpref{Prepend}{wxsizerprepend}(size, size, 0). | |
327 | ||
328 | ||
329 | \membersection{wxSizer::PrependStretchSpacer}\label{wxsizerprependstretchspacer} | |
330 | ||
331 | \func{wxSizerItem*}{PrependStretchSpacer}{\param{int }{prop = 1}} | |
332 | ||
333 | Prepends stretchable space to the sizer. More readable way of calling | |
334 | \helpref{Prepend}{wxsizerprepend}(0, 0, prop). | |
335 | ||
336 | ||
337 | \membersection{wxSizer::RecalcSizes}\label{wxsizerrecalcsizes} | |
338 | ||
339 | \func{void}{RecalcSizes}{\void} | |
340 | ||
341 | This method is abstract and has to be overwritten by any derived class. | |
342 | Here, the sizer will do the actual calculation of its children's positions | |
343 | and sizes. | |
344 | ||
345 | ||
346 | \membersection{wxSizer::Remove}\label{wxsizerremove} | |
347 | ||
348 | \func{bool}{Remove}{\param{wxWindow* }{window}} | |
349 | ||
350 | \func{bool}{Remove}{\param{wxSizer* }{sizer}} | |
351 | ||
352 | \func{bool}{Remove}{\param{size\_t }{index}} | |
353 | ||
354 | Removes a child from the sizer and destroys it. {\it sizer} is the wxSizer to be removed, | |
355 | {\it index} is the position of the child in the sizer, typically 0 for the first item. | |
356 | This method does not cause any layout or resizing to take place, call | |
357 | \helpref{wxSizer::Layout}{wxsizerlayout} to update the layout "on screen" after removing a | |
358 | child from the sizer. | |
359 | ||
360 | {\bf NB:} The method taking a wxWindow* parameter is deprecated. For historical reasons | |
361 | it does not destroy the window as would usually be expected from Remove. You should use | |
362 | \helpref{wxSizer::Detach}{wxsizerdetach} in new code instead. There is currently no wxSizer | |
363 | method that will both detach and destroy a wxWindow item. | |
364 | ||
365 | Returns true if the child item was found and removed, false otherwise. | |
366 | ||
367 | ||
368 | \membersection{wxSizer::SetDimension}\label{wxsizersetdimension} | |
369 | ||
370 | \func{void}{SetDimension}{\param{int }{x}, \param{int }{y}, \param{int }{width}, \param{int }{height}} | |
371 | ||
372 | Call this to force the sizer to take the given dimension and thus force the items owned | |
373 | by the sizer to resize themselves according to the rules defined by the parameter in the | |
374 | \helpref{Add}{wxsizeradd} and \helpref{Prepend}{wxsizerprepend} methods. | |
375 | ||
376 | ||
377 | \membersection{wxSizer::SetMinSize}\label{wxsizersetminsize} | |
378 | ||
379 | \func{void}{SetMinSize}{\param{int }{width}, \param{int }{height}} | |
380 | ||
381 | \func{void}{SetMinSize}{\param{wxSize }{size}} | |
382 | ||
383 | Call this to give the sizer a minimal size. Normally, the sizer will calculate its | |
384 | minimal size based purely on how much space its children need. After calling this | |
385 | method \helpref{GetMinSize}{wxsizergetminsize} will return either the minimal size | |
386 | as requested by its children or the minimal size set here, depending on which is | |
387 | bigger. | |
388 | ||
389 | ||
390 | \membersection{wxSizer::SetItemMinSize}\label{wxsizersetitemminsize} | |
391 | ||
392 | \func{void}{SetItemMinSize}{\param{wxWindow* }{window}, \param{int}{ width}, \param{int}{ height}} | |
393 | ||
394 | \func{void}{SetItemMinSize}{\param{wxSizer* }{sizer}, \param{int}{ width}, \param{int}{ height}} | |
395 | ||
396 | \func{void}{SetItemMinSize}{\param{size\_t }{index}, \param{int}{ width}, \param{int}{ height}} | |
397 | ||
398 | Set an item's minimum size by window, sizer, or position. The item will be found recursively | |
399 | in the sizer's descendants. This function enables an application to set the size of an item | |
400 | after initial creation. | |
401 | ||
402 | ||
403 | \membersection{wxSizer::SetSizeHints}\label{wxsizersetsizehints} | |
404 | ||
405 | \func{void}{SetSizeHints}{\param{wxWindow* }{window}} | |
406 | ||
407 | Tell the sizer to set (and \helpref{Fit}{wxsizerfit}) the minimal size of the {\it window} to | |
408 | match the sizer's minimal size. This is commonly done in the constructor of the window itself, | |
409 | see sample in the description of \helpref{wxBoxSizer}{wxboxsizer} if the window is resizable | |
410 | (as are many dialogs under Unix and frames on probably all platforms). | |
411 | ||
412 | ||
413 | \membersection{wxSizer::SetVirtualSizeHints}\label{wxsizersetvirtualsizehints} | |
414 | ||
415 | \func{void}{SetVirtualSizeHints}{\param{wxWindow* }{window}} | |
416 | ||
417 | Tell the sizer to set the minimal size of the {\it window} virtual area to match the sizer's | |
418 | minimal size. For windows with managed scrollbars this will set them appropriately. | |
419 | ||
420 | \wxheading{See also} | |
421 | ||
422 | \helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars} | |
423 | ||
424 | ||
425 | \membersection{wxSizer::Show}\label{wxsizershow} | |
426 | ||
427 | \func{bool}{Show}{\param{wxWindow* }{window}, \param{bool }{show = true}, \param{bool }{recursive = false}} | |
428 | ||
429 | \func{bool}{Show}{\param{wxSizer* }{sizer}, \param{bool }{show = true}, \param{bool }{recursive = false}} | |
430 | ||
431 | \func{bool}{Show}{\param{size\_t }{index}, \param{bool }{show = true}} | |
432 | ||
433 | Shows or hides the {\it window}, {\it sizer}, or item at {\it index}. | |
434 | To make a sizer item disappear or reappear, use Show() followed by Layout(). | |
435 | Use parameter {\it recursive} to show or hide elements found in subsizers. | |
436 | ||
437 | Returns true if the child item was found, false otherwise. | |
438 | ||
439 | Note that this only works with wxBoxSizer and wxFlexGridSizer, since they | |
440 | are the only two sizer classes that can size rows/columns independently. | |
441 | ||
442 | ||
443 | ||
444 | ||
445 | \section{\class{wxSizerFlags}}\label{wxsizerflags} | |
446 | ||
447 | PRELIMINARY. | |
448 | ||
449 | 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. | |
450 | ||
451 | 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. | |
452 | ||
453 | Note that by specification, all methods of wxSizerFlags return the wxSizerFlags object itself to ease the calling of multiple methods at a time. | |
454 | ||
455 | ||
456 | \membersection{wxSizerFlags::wxSizerFlags}\label{wxsizerflagsctor} | |
457 | ||
458 | \func{}{wxSizerFlags}{\param{int }{proportion = 0}} | |
459 | ||
460 | Creates the wxSizer with the proportion specified by \tt{proportion}. | |
461 | ||
462 | ||
463 | \membersection{wxSizerFlags::Align}\label{wxsizerflagsalign} | |
464 | ||
465 | \func{wxSizerFlags\& }{Align}{\param{int }{align = 0}} | |
466 | ||
467 | Sets the alignment of this wxSizerFlags to \tt{align}. | |
468 | ||
469 | Note that if this method is not called, the wxSizerFlags has no specified alignment. | |
470 | ||
471 | \wxheading{See also} | |
472 | ||
473 | \helpref{Left}{wxsizerflagsleft},\\ | |
474 | \helpref{Right}{wxsizerflagsright},\\ | |
475 | \helpref{Centre}{wxsizerflagscentre} | |
476 | ||
477 | ||
478 | \membersection{wxSizerFlags::Border}\label{wxsizerflagsborder} | |
479 | ||
480 | \func{wxSizerFlags\& }{Border}{\param{int }{direction}, \param{int }{borderinpixels}} | |
481 | ||
482 | Sets the wxSizerFlags to have a border of a number of pixels specified by \tt{borderinpixels} with the directions specified by \tt{direction}. | |
483 | ||
484 | \func{wxSizerFlags\& }{Border}{\param{int }{direction = wxALL}} | |
485 | ||
486 | Sets the wxSizerFlags to have a border of a default size with the directions specified by \tt{direction}. | |
487 | ||
488 | ||
489 | \membersection{wxSizerFlags::Center}\label{wxsizerflagscenter} | |
490 | ||
491 | \func{wxSizerFlags\& }{Center}{\void} | |
492 | ||
493 | Sets the object of the wxSizerFlags to center itself in the area it is given. | |
494 | ||
495 | ||
496 | \membersection{wxSizerFlags::Centre}\label{wxsizerflagscentre} | |
497 | ||
498 | \func{wxSizerFlags\& }{Centre}{\void} | |
499 | ||
500 | \helpref{wxSizerFlags::Center}{wxsizerflagscenter} for people with the other dialect of english. | |
501 | ||
502 | ||
503 | \membersection{wxSizerFlags::Expand}\label{wxsizerflagsexpand} | |
504 | ||
505 | \func{wxSizerFlags\& }{Expand}{\void} | |
506 | ||
507 | Sets the object of the wxSizerFlags to expand to fill as much area as it can. | |
508 | ||
509 | ||
510 | \membersection{wxSizerFlags::Left}\label{wxsizerflagsleft} | |
511 | ||
512 | \func{wxSizerFlags\& }{Left}{\void} | |
513 | ||
514 | Aligns the object to the left, shortcut for \texttt{Align(wxALIGN\_LEFT)} | |
515 | ||
516 | \wxheading{See also} | |
517 | ||
518 | \helpref{Align}{wxsizerflagsalign} | |
519 | ||
520 | ||
521 | \membersection{wxSizerFlags::Proportion}\label{wxsizerflagsproportion} | |
522 | ||
523 | \func{wxSizerFlags\& }{Proportion}{\param{int }{proportion = 0}} | |
524 | ||
525 | Sets the proportion of this wxSizerFlags to \tt{proportion} | |
526 | ||
527 | ||
528 | \membersection{wxSizerFlags::Right}\label{wxsizerflagsright} | |
529 | ||
530 | \func{wxSizerFlags\& }{Right}{\void} | |
531 | ||
532 | Aligns the object to the right, shortcut for \texttt{Align(wxALIGN\_RIGHT)} | |
533 | ||
534 | \wxheading{See also} | |
535 | ||
536 | \helpref{Align}{wxsizerflagsalign} | |
537 |