]> git.saurik.com Git - wxWidgets.git/blob - docs/latex/wx/sizer.tex
interface headers reviewed
[wxWidgets.git] / docs / latex / wx / sizer.tex
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},
9 \helpref{wxWrapSizer}{wxwrapsizer}
10 and \helpref{wxGridBagSizer}{wxgridbagsizer}.
11
12 The layout algorithm used by sizers in wxWidgets is closely related to layout
13 in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit. It is
14 based upon the idea of the individual subwindows reporting their minimal required
15 size and their ability to get stretched if the size of the parent window has changed.
16 This will most often mean that the programmer does not set the original size of
17 a dialog in the beginning, rather the dialog will be assigned a sizer and this sizer
18 will be queried about the recommended size. The sizer in turn will query its
19 children, which can be normal windows, empty space or other sizers, so that
20 a hierarchy of sizers can be constructed. Note that wxSizer does not derive from wxWindow
21 and thus does not interfere with tab ordering and requires very little resources compared
22 to a real window on screen.
23
24 What makes sizers so well fitted for use in wxWidgets is the fact that every control
25 reports its own minimal size and the algorithm can handle differences in font sizes
26 or different window (dialog item) sizes on different platforms without problems. If e.g.
27 the standard font as well as the overall design of Motif widgets requires more space than
28 on Windows, the initial dialog size will automatically be bigger on Motif than on Windows.
29
30 Sizers may also be used to control the layout of custom drawn items on the window. The
31 Add, Insert, and Prepend functions return a pointer to the newly added wxSizerItem. Just
32 add empty space of the desired size and attributes, and then use the wxSizerItem::GetRect
33 method to determine where the drawing operations should take place.
34
35
36 Please notice that sizers, like child windows, are owned by the library and
37 will be deleted by it which implies that they must be allocated on the heap.
38 However if you create a sizer and do not add it to another sizer or window, the
39 library wouldn't be able to delete such an orphan sizer and in this, and only
40 this, case it should be deleted explicitly.
41
42 \pythonnote{If you wish to create a sizer class in wxPython you should
43 derive the class from {\tt wxPySizer} in order to get Python-aware
44 capabilities for the various virtual methods.}
45
46 \wxheading{Derived from}
47
48 \helpref{wxObject}{wxobject}
49
50 \wxheading{Include files}
51
52 <wx/sizer.h>
53
54 \wxheading{Library}
55
56 \helpref{wxCore}{librarieslist}
57
58 \wxheading{See also}
59
60 \helpref{Sizer overview}{sizeroverview}
61
62 \latexignore{\rtfignore{\wxheading{Members}}}
63
64
65 \membersection{wxSizer::wxSizer}\label{wxsizerwxsizer}
66
67 \func{}{wxSizer}{\void}
68
69 The constructor. Note that wxSizer is an abstract base class and may not
70 be instantiated.
71
72
73 \membersection{wxSizer::\destruct{wxSizer}}\label{wxsizerdtor}
74
75 \func{}{\destruct{wxSizer}}{\void}
76
77 The destructor.
78
79
80 \membersection{wxSizer::Add}\label{wxsizeradd}
81
82 \func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
83
84 \func{wxSizerItem*}{Add}{\param{wxWindow* }{window}, \param{int }{proportion = 0},\param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
85
86 \func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
87
88 \func{wxSizerItem*}{Add}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
89
90 \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}}
91
92 Appends a child to the sizer. wxSizer itself is an abstract class, but the parameters are
93 equivalent in the derived classes that you will instantiate to use it so they are described
94 here:
95
96 \docparam{window}{The window to be added to the sizer. Its initial size (either set explicitly by the
97 user or calculated internally when using wxDefaultSize) is interpreted as the minimal and in many
98 cases also the initial size.}
99
100 \docparam{sizer}{The (child-)sizer to be added to the sizer. This allows placing a child sizer in a
101 sizer and thus to create hierarchies of sizers (typically a vertical box as the top sizer and several
102 horizontal boxes on the level beneath).}
103
104 \docparam{width and height}{The dimension of a spacer to be added to the sizer. Adding spacers to sizers
105 gives more flexibility in the design of dialogs; imagine for example a horizontal box with two buttons at the
106 bottom of a dialog: you might want to insert a space between the two buttons and make that space stretchable
107 using the \arg{proportion} flag and the result will be that the left button will be aligned with the left
108 side of the dialog and the right button with the right side - the space in between will shrink and grow with
109 the dialog.}
110
111 \docparam{proportion}{Although the meaning of this parameter is undefined in wxSizer, it is used in wxBoxSizer
112 to indicate if a child of a sizer can change its size in the main orientation of the wxBoxSizer - where
113 0 stands for not changeable and a value of more than zero is interpreted relative to the value of other
114 children of the same wxBoxSizer. For example, you might have a horizontal wxBoxSizer with three children, two
115 of which are supposed to change their size with the sizer. Then the two stretchable windows would get a
116 value of 1 each to make them grow and shrink equally with the sizer's horizontal dimension.}
117
118 \docparam{flag}{This parameter can be used to set a number of flags
119 which can be combined using the binary OR operator |. Two main
120 behaviours are defined using these flags. One is the border around a
121 window: the \arg{border} parameter determines the border width whereas
122 the flags given here determine which side(s) of the item that the
123 border will be added. The other flags determine how the sizer item
124 behaves when the space allotted to the sizer changes, and is somewhat
125 dependent on the specific kind of sizer used.
126
127 \twocolwidtha{5cm}%
128 \begin{twocollist}\itemsep=0pt
129 \twocolitem{\windowstyle{wxTOP}\\
130 \windowstyle{wxBOTTOM}\\
131 \windowstyle{wxLEFT}\\
132 \windowstyle{wxRIGHT}\\
133 \windowstyle{wxALL}}{These flags are used to specify which side(s) of
134 the sizer item the \arg{border} width will apply to. }
135
136 \twocolitem{\windowstyle{wxEXPAND}}{The item will be expanded to fill
137 the space assigned to the item.}
138 \twocolitem{\windowstyle{wxSHAPED}}{The item will be expanded as much
139 as possible while also maintaining its aspect ratio}
140 \twocolitem{\windowstyle{wxFIXED\_MINSIZE}}{Normally wxSizers will use
141 \helpref{GetAdjustedBestSize}{wxwindowgetadjustedbestsize} to
142 determine what the minimal size of window items should be, and will
143 use that size to calculate the layout. This allows layouts to
144 adjust when an item changes and its \arg{best size} becomes
145 different. If you would rather have a window item stay the size it
146 started with then use wxFIXED\_MINSIZE.}
147 \twocolitem{\windowstyle{wxALIGN\_CENTER wxALIGN\_CENTRE}\\
148 \windowstyle{wxALIGN\_LEFT}\\
149 \windowstyle{wxALIGN\_RIGHT}\\
150 \windowstyle{wxALIGN\_TOP}\\
151 \windowstyle{wxALIGN\_BOTTOM}\\
152 \windowstyle{wxALIGN\_CENTER\_VERTICAL wxALIGN\_CENTRE\_VERTICAL}\\
153 \windowstyle{wxALIGN\_CENTER\_HORIZONTAL wxALIGN\_CENTRE\_HORIZONTAL}}{The wxALIGN flags allow you to
154 specify the alignment of the item within the space allotted to it by
155 the sizer, adjusted for the border if any.}
156 \end{twocollist}
157 }
158
159 \docparam{border}{Determines the border width, if the \arg{flag}
160 parameter is set to include any border flag.}
161
162 \docparam{userData}{Allows an extra object to be attached to the sizer
163 item, for use in derived classes when sizing information is more
164 complex than the \arg{proportion} and \arg{flag} will allow for.}
165
166 \docparam{flags}{A \helpref{wxSizerFlags}{wxsizerflags} object that
167 enables you to specify most of the above parameters more conveniently.}
168
169 \membersection{wxSizer::AddSpacer}\label{wxsizeraddspacer}
170
171 \func{wxSizerItem*}{AddSpacer}{\param{int }{size}}
172
173 Adds non-stretchable space to the sizer. More readable way of calling
174 \helpref{Add}{wxsizeradd}(size, size, 0).
175
176
177 \membersection{wxSizer::AddStretchSpacer}\label{wxsizeraddstretchspacer}
178
179 \func{wxSizerItem*}{AddStretchSpacer}{\param{int }{prop = 1}}
180
181 Adds stretchable space to the sizer. More readable way of calling
182 \helpref{Add}{wxsizeradd}(0, 0, prop).
183
184
185 \membersection{wxSizer::CalcMin}\label{wxsizercalcmin}
186
187 \func{wxSize}{CalcMin}{\void}
188
189 This method is abstract and has to be overwritten by any derived class.
190 Here, the sizer will do the actual calculation of its children's minimal sizes.
191
192
193 \membersection{wxSizer::Clear}\label{wxsizerclear}
194
195 \func{void}{Clear}{\param{bool }{delete\_windows = false}}
196
197 Detaches all children from the sizer. If \arg{delete\_windows} is \true then child windows will also be deleted.
198
199
200 \membersection{wxSizer::ComputeFittingClientSize}\label{wxsizercomputefittingclientsize}
201
202 \func{wxSize}{ComputeFittingClientSize}{\param{wxWindow* }{window}}
203
204 Computes client area size for \arg{window} so that it matches the
205 sizer's minimal size. Unlike \helpref{GetMinSize}{wxsizergetminsize}, this
206 method accounts for other constraints imposed on \arg{window}, namely display's
207 size (returned size will never be too large for the display) and maximum
208 window size if previously set by
209 \helpref{wxWindow::SetMaxSize}{wxwindowsetmaxsize}.
210
211 The returned value is suitable for passing to
212 \helpref{wxWindow::SetClientSize}{wxwindowsetclientsize} or
213 \helpref{wxWindow::SetMinClientSize}{wxwindowsetminclientsize}.
214
215 \wxheading{See also}
216
217 \helpref{ComputeFittingWindowSize}{wxsizercomputefittingwindowsize},
218 \helpref{Fit}{wxsizerfit}
219
220
221 \membersection{wxSizer::ComputeFittintWindowSize}\label{wxsizercomputefittingwindowsize}
222
223 \func{wxSize}{ComputeFittingWindowSize}{\param{wxWindow* }{window}}
224
225 Like \helpref{ComputeFittingClientSize}{wxsizercomputefittingclientsize},
226 but converts the result into \emph{window} size.
227
228 The returned value is suitable for passing to
229 \helpref{wxWindow::SetSize}{wxwindowsetsize} or
230 \helpref{wxWindow::SetMinSize}{wxwindowsetminsize}.
231
232 \wxheading{See also}
233
234 \helpref{ComputeFittingClientSize}{wxsizercomputefittingclientsize},
235 \helpref{Fit}{wxsizerfit}
236
237
238 \membersection{wxSizer::Detach}\label{wxsizerdetach}
239
240 \func{bool}{Detach}{\param{wxWindow* }{window}}
241
242 \func{bool}{Detach}{\param{wxSizer* }{sizer}}
243
244 \func{bool}{Detach}{\param{size\_t }{index}}
245
246 Detach a child from the sizer without destroying it. \arg{window} is the window to be
247 detached, \arg{sizer} is the equivalent sizer and \arg{index} is the position of
248 the child in the sizer, typically 0 for the first item. This method does not
249 cause any layout or resizing to take place, call \helpref{wxSizer::Layout}{wxsizerlayout}
250 to update the layout "on screen" after detaching a child from the sizer.
251
252 Returns true if the child item was found and detached, false otherwise.
253
254 \wxheading{See also}
255
256 \helpref{wxSizer::Remove}{wxsizerremove}
257
258
259 \membersection{wxSizer::Fit}\label{wxsizerfit}
260
261 \func{wxSize}{Fit}{\param{wxWindow* }{window}}
262
263 Tell the sizer to resize the \arg{window} so that its client area matches the
264 sizer's minimal size
265 (\helpref{ComputeFittingClientSize}{wxsizercomputefittingclientsize} is called
266 to determine it).
267 This is commonly done in the constructor of the window
268 itself, see sample in the description
269 of \helpref{wxBoxSizer}{wxboxsizer}. Returns the new \emph{window} size.
270
271 \wxheading{See also}
272
273 \helpref{ComputeFittingClientSize}{wxsizercomputefittingclientsize},
274 \helpref{ComputeFittingWindowSize}{wxsizercomputefittingwindowsize}
275
276
277 \membersection{wxSizer::FitInside}\label{wxsizerfitinside}
278
279 \func{void}{FitInside}{\param{wxWindow* }{window}}
280
281 Tell the sizer to resize the virtual size of the \arg{window} to match the sizer's
282 minimal size. This will not alter the on screen size of the window, but may cause
283 the addition/removal/alteration of scrollbars required to view the virtual area in
284 windows which manage it.
285
286 \wxheading{See also}
287
288 \helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars},\rtfsp
289 \helpref{wxSizer::SetVirtualSizeHints}{wxsizersetvirtualsizehints}
290
291
292 \membersection{wxSizer::GetChildren}\label{wxsizergetchildren}
293
294 \constfunc{const wxSizerItemList\&}{GetChildren}{\void}
295
296 \func{wxSizerItemList\&}{GetChildren}{\void}
297
298 Returns the list of the items in this sizer. The elements of type-safe
299 \helpref{wxList}{wxlist} \texttt{wxSizerItemList} are objects of type
300 \helpref{wxSizerItem *}{wxsizeritem}.
301
302
303 \membersection{wxSizer::GetContainingWindow}\label{wxsizergetcontainingwindow}
304
305 \constfunc{wxWindow *}{GetContainingWindow}{\void}
306
307 Returns the window this sizer is used in or \NULL if none.
308
309
310 \membersection{wxSizer::GetItem}\label{wxsizergetitem}
311
312 \func{wxSizerItem *}{GetItem}{\param{wxWindow* }{window}, \param{bool }{recursive = false}}
313
314 \func{wxSizerItem *}{GetItem}{\param{wxSizer* }{sizer}, \param{bool }{recursive = false}}
315
316 \func{wxSizerItem *}{GetItem}{\param{size\_t }{index}}
317
318 Finds item of the sizer which holds given \arg{window}, \arg{sizer} or is located
319 in sizer at position \arg{index}.
320 Use parameter \arg{recursive} to search in subsizers too.
321
322 Returns pointer to item or NULL.
323
324 \membersection{wxSizer::GetItemById}\label{wxsizergetitembyid}
325
326 \func{wxSizerItem *}{GetItemById}{\param{int }{id}, \param{bool }{recursive = false}}
327
328 Finds item of the sizer which has the given \arg{id}. This \arg{id} is not the
329 window id but the id of the wxSizerItem itself. This is mainly useful for
330 retrieving the sizers created from XRC resources.
331
332 Use parameter \arg{recursive} to search in subsizers too.
333
334 Returns pointer to item or \NULL.
335
336
337 \membersection{wxSizer::GetSize}\label{wxsizergetsize}
338
339 \func{wxSize}{GetSize}{\void}
340
341 Returns the current size of the sizer.
342
343
344 \membersection{wxSizer::GetPosition}\label{wxsizergetposition}
345
346 \func{wxPoint}{GetPosition}{\void}
347
348 Returns the current position of the sizer.
349
350
351 \membersection{wxSizer::GetMinSize}\label{wxsizergetminsize}
352
353 \func{wxSize}{GetMinSize}{\void}
354
355 Returns the minimal size of the sizer. This is either the combined minimal
356 size of all the children and their borders or the minimal size set by
357 \helpref{SetMinSize}{wxsizersetminsize}, depending on which is bigger.
358
359 Note that the returned value is \emph{client} size, not window size.
360 In particular, if you use the value to set toplevel window's minimal or
361 actual size, use \helpref{wxWindow::SetMinClientSize}{wxwindowsetminclientsize}
362 or \helpref{wxWindow::SetClientSize}{wxwindowsetclientsize}, \emph{not}
363 \helpref{wxWindow::SetMinSize}{wxwindowsetminsize}
364 or \helpref{wxWindow::SetSize}{wxwindowsetsize}.
365
366
367 \membersection{wxSizer::Hide}\label{wxsizerhide}
368
369 \func{bool}{Hide}{\param{wxWindow* }{window}, \param{bool }{recursive = false}}
370
371 \func{bool}{Hide}{\param{wxSizer* }{sizer}, \param{bool }{recursive = false}}
372
373 \func{bool}{Hide}{\param{size\_t }{index}}
374
375 Hides the \arg{window}, \arg{sizer}, or item at \arg{index}.
376 To make a sizer item disappear, use Hide() followed by \helpref{Layout()}{wxsizerlayout}.
377 Use parameter \arg{recursive} to hide elements found in subsizers.
378
379 Returns \true if the child item was found, \false otherwise.
380
381 \wxheading{See also}
382
383 \helpref{wxSizer::IsShown}{wxsizerisshown},\rtfsp
384 \helpref{wxSizer::Show}{wxsizershow}
385
386
387 \membersection{wxSizer::Insert}\label{wxsizerinsert}
388
389 \func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
390
391 \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}}
392
393 \func{wxSizerItem*}{Insert}{\param{size\_t }{index}, \param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
394
395 \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}}
396
397 \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}}
398
399 Insert a child into the sizer before any existing item at \arg{index}.
400
401 \docparam{index}{The position this child should assume in the sizer.}
402
403 See \helpref{wxSizer::Add}{wxsizeradd} for the meaning of the other parameters.
404
405
406 \membersection{wxSizer::InsertSpacer}\label{wxsizerinsertspacer}
407
408 \func{wxSizerItem*}{InsertSpacer}{\param{size\_t }{index}, \param{int }{size}}
409
410 Inserts non-stretchable space to the sizer. More readable way of calling
411 \helpref{Insert}{wxsizerinsert}(size, size, 0).
412
413
414 \membersection{wxSizer::InsertStretchSpacer}\label{wxsizerinsertstretchspacer}
415
416 \func{wxSizerItem*}{InsertStretchSpacer}{\param{size\_t }{index}, \param{int }{prop = 1}}
417
418 Inserts stretchable space to the sizer. More readable way of calling
419 \helpref{Insert}{wxsizerinsert}(0, 0, prop).
420
421
422 \membersection{wxSizer::IsShown}\label{wxsizerisshown}
423
424 \constfunc{bool}{IsShown}{\param{wxWindow* }{window}}
425
426 \constfunc{bool}{IsShown}{\param{wxSizer* }{sizer}}
427
428 \constfunc{bool}{IsShown}{\param{size\_t }{index}}
429
430 Returns \true if the \arg{window}, \arg{sizer}, or item at \arg{index} is shown.
431
432 \wxheading{See also}
433
434 \helpref{wxSizer::Hide}{wxsizerhide},\rtfsp
435 \helpref{wxSizer::Show}{wxsizershow}
436
437
438 \membersection{wxSizer::Layout}\label{wxsizerlayout}
439
440 \func{void}{Layout}{\void}
441
442 Call this to force layout of the children anew, e.g. after having added a child
443 to or removed a child (window, other sizer or space) from the sizer while keeping
444 the current dimension.
445
446
447 \membersection{wxSizer::Prepend}\label{wxsizerprepend}
448
449 \func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{const wxSizerFlags\& }{flags}}
450
451 \func{wxSizerItem*}{Prepend}{\param{wxWindow* }{window}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
452
453 \func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{const wxSizerFlags\& }{flags}}
454
455 \func{wxSizerItem*}{Prepend}{\param{wxSizer* }{sizer}, \param{int }{proportion = 0}, \param{int }{flag = 0}, \param{int }{border = 0}, \param{wxObject* }{userData = NULL}}
456
457 \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}}
458
459 Same as \helpref{wxSizer::Add}{wxsizeradd}, but prepends the items to the beginning of the
460 list of items (windows, subsizers or spaces) owned by this sizer.
461
462
463 \membersection{wxSizer::PrependSpacer}\label{wxsizerprependspacer}
464
465 \func{wxSizerItem*}{PrependSpacer}{\param{int }{size}}
466
467 Prepends non-stretchable space to the sizer. More readable way of calling
468 \helpref{Prepend}{wxsizerprepend}(size, size, 0).
469
470
471 \membersection{wxSizer::PrependStretchSpacer}\label{wxsizerprependstretchspacer}
472
473 \func{wxSizerItem*}{PrependStretchSpacer}{\param{int }{prop = 1}}
474
475 Prepends stretchable space to the sizer. More readable way of calling
476 \helpref{Prepend}{wxsizerprepend}(0, 0, prop).
477
478
479 \membersection{wxSizer::RecalcSizes}\label{wxsizerrecalcsizes}
480
481 \func{void}{RecalcSizes}{\void}
482
483 This method is abstract and has to be overwritten by any derived class.
484 Here, the sizer will do the actual calculation of its children's positions
485 and sizes.
486
487
488 \membersection{wxSizer::Remove}\label{wxsizerremove}
489
490 \func{bool}{Remove}{\param{wxWindow* }{window}}
491
492 \func{bool}{Remove}{\param{wxSizer* }{sizer}}
493
494 \func{bool}{Remove}{\param{size\_t }{index}}
495
496 Removes a child from the sizer and destroys it if it is a sizer or a spacer,
497 but not if it is a window (because windows are owned by their parent window,
498 not the sizer). \arg{sizer} is the wxSizer to be removed,
499 \arg{index} is the position of the child in the sizer, e.g. $0$ for the first item.
500 This method does not cause any layout or resizing to take place, call
501 \helpref{wxSizer::Layout}{wxsizerlayout} to update the layout "on screen" after removing a
502 child from the sizer.
503
504 {\bf NB:} The method taking a wxWindow* parameter is deprecated as it does not
505 destroy the window as would usually be expected from Remove. You should use
506 \helpref{wxSizer::Detach}{wxsizerdetach} in new code instead. There is
507 currently no wxSizer method that will both detach and destroy a wxWindow item.
508
509 Returns true if the child item was found and removed, false otherwise.
510
511
512 \membersection{wxSizer::Replace}\label{wxsizerreplace}
513
514 \func{bool}{Replace}{\param{wxWindow* }{oldwin}, \param{wxWindow* }{newwin}, \param{bool }{recursive = false}}
515
516 \func{bool}{Replace}{\param{wxSizer* }{oldsz}, \param{wxSizer* }{newsz}, \param{bool }{recursive = false}}
517
518 \func{bool}{Remove}{\param{size\_t }{oldindex}, \param{wxSizerItem* }{newitem}}
519
520 Detaches the given \arg{oldwin}, \arg{oldsz} child from the sizer and
521 replaces it with the given window, sizer, or wxSizerItem.
522
523 The detached child is removed {\bf only} if it is a sizer or a spacer
524 (because windows are owned by their parent window, not the sizer).
525
526 Use parameter \arg{recursive} to search the given element recursively in subsizers.
527
528
529 This method does not cause any layout or resizing to take place, call
530 \helpref{wxSizer::Layout}{wxsizerlayout} to update the layout "on screen" after replacing a
531 child from the sizer.
532
533 Returns true if the child item was found and removed, false otherwise.
534
535
536 \membersection{wxSizer::SetDimension}\label{wxsizersetdimension}
537
538 \func{void}{SetDimension}{\param{int }{x}, \param{int }{y}, \param{int }{width}, \param{int }{height}}
539
540 Call this to force the sizer to take the given dimension and thus force the items owned
541 by the sizer to resize themselves according to the rules defined by the parameter in the
542 \helpref{Add}{wxsizeradd} and \helpref{Prepend}{wxsizerprepend} methods.
543
544
545 \membersection{wxSizer::SetMinSize}\label{wxsizersetminsize}
546
547 \func{void}{SetMinSize}{\param{int }{width}, \param{int }{height}}
548
549 \func{void}{SetMinSize}{\param{const wxSize\& }{size}}
550
551 Call this to give the sizer a minimal size. Normally, the sizer will calculate its
552 minimal size based purely on how much space its children need. After calling this
553 method \helpref{GetMinSize}{wxsizergetminsize} will return either the minimal size
554 as requested by its children or the minimal size set here, depending on which is
555 bigger.
556
557
558 \membersection{wxSizer::SetItemMinSize}\label{wxsizersetitemminsize}
559
560 \func{void}{SetItemMinSize}{\param{wxWindow* }{window}, \param{int}{ width}, \param{int}{ height}}
561
562 \func{void}{SetItemMinSize}{\param{wxSizer* }{sizer}, \param{int}{ width}, \param{int}{ height}}
563
564 \func{void}{SetItemMinSize}{\param{size\_t }{index}, \param{int}{ width}, \param{int}{ height}}
565
566 Set an item's minimum size by window, sizer, or position. The item will be found recursively
567 in the sizer's descendants. This function enables an application to set the size of an item
568 after initial creation.
569
570
571 \membersection{wxSizer::SetSizeHints}\label{wxsizersetsizehints}
572
573 \func{void}{SetSizeHints}{\param{wxWindow* }{window}}
574
575 This method first calls \helpref{wxSizer::Fit}{wxsizerfit} and then
576 \helpref{SetSizeHints}{wxtoplevelwindowsetsizehints} on the {\it window}
577 passed to it. This only makes sense when {\it window} is actually a
578 \helpref{wxTopLevelWindow}{wxtoplevelwindow} such as a wxFrame or a
579 wxDialog, since SetSizeHints only has any effect in these classes.
580 It does nothing in normal windows or controls.
581
582 This method is implicitly used by \helpref{wxWindow::SetSizerAndFit}{wxwindowsetsizerandfit}
583 which is commonly invoked in the constructor of a toplevel window itself (see
584 the sample in the description of \helpref{wxBoxSizer}{wxboxsizer}) if the
585 toplevel window is resizable.
586
587
588 \membersection{wxSizer::SetVirtualSizeHints}\label{wxsizersetvirtualsizehints}
589
590 \func{void}{SetVirtualSizeHints}{\param{wxWindow* }{window}}
591
592 Tell the sizer to set the minimal size of the \arg{window} virtual area to match the sizer's
593 minimal size. For windows with managed scrollbars this will set them appropriately.
594
595 \wxheading{See also}
596
597 \helpref{wxScrolledWindow::SetScrollbars}{wxscrolledwindowsetscrollbars}
598
599
600 \membersection{wxSizer::Show}\label{wxsizershow}
601
602 \func{bool}{Show}{\param{wxWindow* }{window}, \param{bool }{show = true}, \param{bool }{recursive = false}}
603
604 \func{bool}{Show}{\param{wxSizer* }{sizer}, \param{bool }{show = true}, \param{bool }{recursive = false}}
605
606 \func{bool}{Show}{\param{size\_t }{index}, \param{bool }{show = true}}
607
608 Shows or hides the \arg{window}, \arg{sizer}, or item at \arg{index}.
609 To make a sizer item disappear or reappear, use Show() followed by \helpref{Layout()}{wxsizerlayout}.
610 Use parameter \arg{recursive} to show or hide elements found in subsizers.
611
612 Returns true if the child item was found, false otherwise.
613
614 \wxheading{See also}
615
616 \helpref{wxSizer::Hide}{wxsizerhide},\rtfsp
617 \helpref{wxSizer::IsShown}{wxsizerisshown}
618
619
620
621
622 \section{\class{wxSizerFlags}}\label{wxsizerflags}
623
624 Normally, when you add an item to a sizer via
625 \helpref{wxSizer::Add}{wxsizeradd}, you have to specify a lot of flags and
626 parameters which can be unwieldy. This is where wxSizerFlags comes in: it
627 allows you to specify all parameters using the named methods instead. For
628 example, instead of
629
630 \begin{verbatim}
631 sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
632 \end{verbatim}
633
634 you can now write
635
636 \begin{verbatim}
637 sizer->Add(ctrl, wxSizerFlags().Expand().Border(10));
638 \end{verbatim}
639
640 This is more readable and also allows you to create wxSizerFlags objects which
641 can be reused for several sizer items.
642 \begin{verbatim}
643 wxSizerFlags flagsExpand(1);
644 flagsExpand.Expand().Border(10);
645
646 sizer->Add(ctrl1, flagsExpand);
647 sizer->Add(ctrl2, flagsExpand);
648 \end{verbatim}
649
650 Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
651 object itself to allowing chaining multiple methods calls like in the examples
652 above.
653
654 \wxheading{See also}
655
656 \helpref{wxSizer}{wxsizer}
657
658 \wxheading{Derived from}
659
660 No base class
661
662 \wxheading{Include files}
663
664 <wx/sizer.h>
665
666 \wxheading{Library}
667
668 \helpref{wxCore}{librarieslist}
669
670 \latexignore{\rtfignore{\wxheading{Members}}}
671
672 \membersection{wxSizerFlags::wxSizerFlags}\label{wxsizerflagsctor}
673
674 \func{}{wxSizerFlags}{\param{int }{proportion = 0}}
675
676 Creates the wxSizer with the proportion specified by \arg{proportion}.
677
678
679 \membersection{wxSizerFlags::Align}\label{wxsizerflagsalign}
680
681 \func{wxSizerFlags\& }{Align}{\param{int }{align = 0}}
682
683 Sets the alignment of this wxSizerFlags to \arg{align}.
684
685 Note that if this method is not called, the wxSizerFlags has no specified alignment.
686
687 \wxheading{See also}
688
689 \helpref{Top}{wxsizerflagstop},\\
690 \helpref{Left}{wxsizerflagsleft},\\
691 \helpref{Right}{wxsizerflagsright},\\
692 \helpref{Bottom}{wxsizerflagsbottom},\\
693 \helpref{Centre}{wxsizerflagscentre}
694
695
696 \membersection{wxSizerFlags::Border}\label{wxsizerflagsborder}
697
698 \func{wxSizerFlags\& }{Border}{\param{int }{direction}, \param{int }{borderinpixels}}
699
700 \func{wxSizerFlags\& }{Border}{\param{int }{direction = wxALL}}
701
702 Sets the wxSizerFlags to have a border of a number of pixels specified by
703 \arg{borderinpixels} with the directions specified by \arg{direction}.
704
705 In the overloaded version without \arg{borderinpixels} parameter, the border of
706 default size, as returned by \helpref{GetDefaultBorder}{wxsizerflagsgetdefaultborder},
707 is used.
708
709
710 \membersection{wxSizerFlags::Bottom}\label{wxsizerflagsbottom}
711
712 \func{wxSizerFlags\& }{Bottom}{\void}
713
714 Aligns the object to the bottom, shortcut for \texttt{Align(wxALIGN\_BOTTOM)}
715
716 \wxheading{See also}
717
718 \helpref{Align}{wxsizerflagsalign}
719
720
721 \membersection{wxSizerFlags::Center}\label{wxsizerflagscenter}
722
723 \func{wxSizerFlags\& }{Center}{\void}
724
725 Sets the object of the wxSizerFlags to center itself in the area it is given.
726
727
728 \membersection{wxSizerFlags::Centre}\label{wxsizerflagscentre}
729
730 \func{wxSizerFlags\& }{Centre}{\void}
731
732 \helpref{wxSizerFlags::Center}{wxsizerflagscenter} for people with the other dialect of english.
733
734
735 \membersection{wxSizerFlags::DoubleBorder}\label{wxsizerflagsdoubleborder}
736
737 \func{wxSizerFlags\& }{DoubleBorder}{\param{int }{direction = wxALL}}
738
739 Sets the border in the given \arg{direction} having twice the default border
740 size.
741
742
743 \membersection{wxSizerFlags::DoubleHorzBorder}\label{wxsizerflagsdoublehorzborder}
744
745 \func{wxSizerFlags\& }{DoubleHorzBorder}{\void}
746
747 Sets the border in left and right directions having twice the default border
748 size.
749
750
751 \membersection{wxSizerFlags::Expand}\label{wxsizerflagsexpand}
752
753 \func{wxSizerFlags\& }{Expand}{\void}
754
755 Sets the object of the wxSizerFlags to expand to fill as much area as it can.
756
757
758 \membersection{wxSizerFlags::GetDefaultBorder}\label{wxsizerflagsgetdefaultborder}
759
760 \func{static int}{GetDefaultBorder}{\void}
761
762 Returns the border used by default in \helpref{Border}{wxsizerflagsborder} method.
763
764
765 \membersection{wxSizerFlags::Left}\label{wxsizerflagsleft}
766
767 \func{wxSizerFlags\& }{Left}{\void}
768
769 Aligns the object to the left, shortcut for \texttt{Align(wxALIGN\_LEFT)}
770
771 \wxheading{See also}
772
773 \helpref{Align}{wxsizerflagsalign}
774
775
776 \membersection{wxSizerFlags::FixedMinSize}\label{wxsizerflagsfixedminsize}
777
778 \func{wxSizerFlags\& }{FixedMinSize}{\void}
779
780 Set the \texttt{wxFIXED\_MINSIZE} flag which indicates that the initial size of
781 the window should be also set as its minimal size.
782
783
784 \membersection{wxSizerFlags::Proportion}\label{wxsizerflagsproportion}
785
786 \func{wxSizerFlags\& }{Proportion}{\param{int }{proportion = 0}}
787
788 Sets the proportion of this wxSizerFlags to \arg{proportion}
789
790
791 \membersection{wxSizerFlags::Right}\label{wxsizerflagsright}
792
793 \func{wxSizerFlags\& }{Right}{\void}
794
795 Aligns the object to the right, shortcut for \texttt{Align(wxALIGN\_RIGHT)}
796
797 \wxheading{See also}
798
799 \helpref{Align}{wxsizerflagsalign}
800
801
802 \membersection{wxSizerFlags::Shaped}\label{wxsizerflagsshaped}
803
804 \func{wxSizerFlags\& }{Shaped}{\void}
805
806 Set the \texttt{wx\_SHAPED} flag which indicates that the elements should
807 always keep the fixed width to height ratio equal to its original value.
808
809
810 \membersection{wxSizerFlags::Top}\label{wxsizerflagstop}
811
812 \func{wxSizerFlags\& }{Top}{\void}
813
814 Aligns the object to the top, shortcut for \texttt{Align(wxALIGN\_TOP)}
815
816 \wxheading{See also}
817
818 \helpref{Align}{wxsizerflagsalign}
819
820
821 \membersection{wxSizerFlags::TripleBorder}\label{wxsizerflagstriplebleborder}
822
823 \func{wxSizerFlags\& }{TripleBorder}{\param{int }{direction = wxALL}}
824
825 Sets the border in the given \arg{direction} having thrice the default border
826 size.
827
828