]> git.saurik.com Git - wxWidgets.git/blob - interface/wx/sizer.h
add wxSocket::IsClosed(), use it to implement Eof() in wxSocketStream
[wxWidgets.git] / interface / wx / sizer.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: sizer.h
3 // Purpose: interface of wxStdDialogButtonSizer
4 // Author: wxWidgets team
5 // RCS-ID: $Id$
6 // Licence: wxWindows license
7 /////////////////////////////////////////////////////////////////////////////
8
9 /**
10 @class wxStdDialogButtonSizer
11
12 This class creates button layouts which conform to the standard button spacing
13 and ordering defined by the platform
14 or toolkit's user interface guidelines (if such things exist). By using this
15 class, you can ensure that all your
16 standard dialogs look correct on all major platforms. Currently it conforms to
17 the Windows, GTK+ and Mac OS X
18 human interface guidelines.
19
20 When there aren't interface guidelines defined for a particular platform or
21 toolkit, wxStdDialogButtonSizer reverts
22 to the Windows implementation.
23
24 To use this class, first add buttons to the sizer by calling AddButton (or
25 SetAffirmativeButton, SetNegativeButton,
26 or SetCancelButton) and then call Realize in order to create the actual button
27 layout used. Other than these special
28 operations, this sizer works like any other sizer.
29
30 If you add a button with wxID_SAVE, on Mac OS X the button will be renamed to
31 "Save" and
32 the wxID_NO button will be renamed to "Don't Save" in accordance with the Mac
33 OS X Human Interface Guidelines.
34
35 @library{wxcore}
36 @category{winlayout}
37
38 @see wxSizer, @ref overview_sizer "Sizer Overview",
39 wxDialog::CreateButtonSizer
40 */
41 class wxStdDialogButtonSizer : public wxBoxSizer
42 {
43 public:
44 /**
45 Constructor for a wxStdDialogButtonSizer.
46 */
47 wxStdDialogButtonSizer();
48
49 /**
50 Adds a button to the wxStdDialogButtonSizer. The @a button must have
51 one of the following identifiers:
52 wxID_OK
53 wxID_YES
54 wxID_SAVE
55 wxID_APPLY
56 wxID_CLOSE
57 wxID_NO
58 wxID_CANCEL
59 wxID_HELP
60 wxID_CONTEXT_HELP
61 */
62 void AddButton(wxButton* button);
63
64 /**
65 Rearranges the buttons and applies proper spacing between buttons to make them
66 match the platform or toolkit's interface guidelines.
67 */
68 void Realize();
69
70 /**
71 Sets the affirmative button for the sizer. This allows you to use identifiers
72 other than the standard identifiers outlined above.
73 */
74 void SetAffirmativeButton(wxButton* button);
75
76 /**
77 Sets the cancel button for the sizer. This allows you to use identifiers other
78 than the standard identifiers outlined above.
79 */
80 void SetCancelButton(wxButton* button);
81
82 /**
83 Sets the negative button for the sizer. This allows you to use identifiers
84 other than the standard identifiers outlined above.
85 */
86 void SetNegativeButton(wxButton* button);
87 };
88
89
90
91 /**
92 @class wxSizerItem
93
94 The wxSizerItem class is used to track the position, size and other
95 attributes of each item managed by a wxSizer. It is not usually necessary
96 to use this class because the sizer elements can also be identified by
97 their positions or window or sizer pointers but sometimes it may be more
98 convenient to use it directly.
99
100 @library{wxcore}
101 @category{winlayout}
102 */
103 class wxSizerItem : public wxObject
104 {
105 public:
106 //@{
107 /**
108 Construct a sizer item for tracking a subsizer.
109 */
110 wxSizerItem(int width, int height, int proportion, int flag,
111 int border, wxObject* userData);
112 wxSizerItem(wxWindow* window, const wxSizerFlags& flags);
113 wxSizerItem(wxWindow* window, int proportion, int flag,
114 int border,
115 wxObject* userData);
116 wxSizerItem(wxSizer* window, const wxSizerFlags& flags);
117 wxSizerItem(wxSizer* sizer, int proportion, int flag,
118 int border,
119 wxObject* userData);
120 //@}
121
122 /**
123 Deletes the user data and subsizer, if any.
124 */
125 ~wxSizerItem();
126
127 /**
128 Calculates the minimum desired size for the item, including any space
129 needed by borders.
130 */
131 wxSize CalcMin();
132
133 /**
134 Destroy the window or the windows in a subsizer, depending on the type
135 of item.
136 */
137 void DeleteWindows();
138
139 /**
140 Enable deleting the SizerItem without destroying the contained sizer.
141 */
142 void DetachSizer();
143
144 /**
145 Return the border attribute.
146 */
147 int GetBorder() const;
148
149 /**
150 Return the flags attribute.
151
152 See @ref wxsizer_flags "wxSizer flags list" for details.
153 */
154 int GetFlag() const;
155
156 /**
157 Return the numeric id of wxSizerItem, or @c wxID_NONE if the id has
158 not been set.
159 */
160 int GetId() const;
161
162 /**
163 Get the minimum size needed for the item.
164 */
165 wxSize GetMinSize() const;
166
167 /**
168 Sets the minimum size to be allocated for this item.
169
170 If this item is a window, the @a size is also passed to
171 wxWindow::SetMinSize().
172 */
173 void SetMinSize(const wxSize& size);
174
175 /**
176 @overload
177 */
178 void SetMinSize(int x, int y);
179
180 /**
181 What is the current position of the item, as set in the last Layout.
182 */
183 wxPoint GetPosition() const;
184
185 /**
186 Get the proportion item attribute.
187 */
188 int GetProportion() const;
189
190 /**
191 Get the ration item attribute.
192 */
193 float GetRatio() const;
194
195 /**
196 Get the rectangle of the item on the parent window, excluding borders.
197 */
198 wxRect GetRect();
199
200 /**
201 Get the current size of the item, as set in the last Layout.
202 */
203 wxSize GetSize() const;
204
205 /**
206 If this item is tracking a sizer, return it. @NULL otherwise.
207 */
208 wxSizer* GetSizer() const;
209
210 /**
211 If this item is tracking a spacer, return its size.
212 */
213 const wxSize GetSpacer() const;
214
215 /**
216 Get the userData item attribute.
217 */
218 wxObject* GetUserData() const;
219
220 /**
221 If this item is tracking a window then return it. @NULL otherwise.
222 */
223 wxWindow* GetWindow() const;
224
225 /**
226 Returns @true if this item is a window or a spacer and it is shown or
227 if this item is a sizer and not all of its elements are hidden.
228
229 In other words, for sizer items, all of the child elements must be
230 hidden for the sizer itself to be considered hidden.
231
232 As an exception, if the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was
233 used for this sizer item, then IsShown() always returns @true for it
234 (see wxSizerFlags::ReserveSpaceEvenIfHidden()).
235 */
236 bool IsShown() const;
237
238 /**
239 Is this item a sizer?
240 */
241 bool IsSizer() const;
242
243 /**
244 Is this item a spacer?
245 */
246 bool IsSpacer() const;
247
248 /**
249 Is this item a window?
250 */
251 bool IsWindow() const;
252
253 /**
254 Set the border item attribute.
255 */
256 void SetBorder(int border);
257
258 /**
259 Set the position and size of the space allocated to the sizer, and
260 adjust the position and size of the item to be within that space
261 taking alignment and borders into account.
262 */
263 void SetDimension(const wxPoint& pos, const wxSize& size);
264
265 /**
266 Set the flag item attribute.
267 */
268 void SetFlag(int flag);
269
270 /**
271 Sets the numeric id of the wxSizerItem to @e id.
272 */
273 void SetId(int id);
274
275 /**
276
277 */
278 void SetInitSize(int x, int y);
279
280 /**
281 Set the proportion item attribute.
282 */
283 void SetProportion(int proportion);
284
285 //@{
286 /**
287 Set the ratio item attribute.
288 */
289 void SetRatio(int width, int height);
290 void SetRatio(wxSize size);
291 void SetRatio(float ratio);
292 //@}
293
294 /**
295 Set the sizer tracked by this item.
296 */
297 void SetSizer(wxSizer* sizer);
298
299 /**
300 Set the size of the spacer tracked by this item.
301 */
302 void SetSpacer(const wxSize& size);
303
304 /**
305 Set the window to be tracked by thsi item.
306 */
307 void SetWindow(wxWindow* window);
308
309 /**
310 Set the show item attribute, which sizers use to determine if the item
311 is to be made part of the layout or not. If the item is tracking a
312 window then it is shown or hidden as needed.
313 */
314 void Show(bool show);
315 };
316
317
318
319 /**
320 @class wxSizerFlags
321
322 Container for sizer items flags providing readable names for them.
323
324 Normally, when you add an item to a sizer via wxSizer::Add, you have to
325 specify a lot of flags and parameters which can be unwieldy. This is where
326 wxSizerFlags comes in: it allows you to specify all parameters using the
327 named methods instead. For example, instead of
328
329 @code
330 sizer->Add(ctrl, 0, wxEXPAND | wxALL, 10);
331 @endcode
332
333 you can now write
334
335 @code
336 sizer->Add(ctrl, wxSizerFlags().Expand().Border(10));
337 @endcode
338
339 This is more readable and also allows you to create wxSizerFlags objects which
340 can be reused for several sizer items.
341
342 @code
343 wxSizerFlags flagsExpand(1);
344 flagsExpand.Expand().Border(10);
345
346 sizer->Add(ctrl1, flagsExpand);
347 sizer->Add(ctrl2, flagsExpand);
348 @endcode
349
350 Note that by specification, all methods of wxSizerFlags return the wxSizerFlags
351 object itself to allowing chaining multiple methods calls like in the examples
352 above.
353
354 @library{wxcore}
355 @category{winlayout}
356
357 @see wxSizer
358 */
359 class wxSizerFlags
360 {
361 public:
362 /**
363 Creates the wxSizer with the proportion specified by @e proportion.
364 */
365 wxSizerFlags(int proportion = 0);
366
367 /**
368 Sets the alignment of this wxSizerFlags to @e align.
369
370 This method replaces the previously set alignment with the specified
371 one.
372
373 @see Top(), Left(), Right(), Bottom(), Centre()
374
375 @param align Combination of @c wxALIGN_XXX bit masks.
376 */
377 wxSizerFlags& Align(int align = 0);
378
379 /**
380 Sets the wxSizerFlags to have a border of a number of pixels specified
381 by @a borderinpixels with the directions specified by @e direction.
382 */
383 wxSizerFlags& Border(int direction, int borderinpixels);
384
385 /**
386 Sets the wxSizerFlags to have a border with size as returned by
387 GetDefaultBorder().
388
389 @param direction Direction(s) to apply the border in.
390 */
391 wxSizerFlags& Border(int direction = wxALL);
392
393 /**
394 Aligns the object to the bottom, similar for @c Align(wxALIGN_BOTTOM).
395
396 Unlike Align(), this method doesn't change the horizontal alignment of
397 the item.
398 */
399 wxSizerFlags& Bottom();
400
401 /**
402 Sets the object of the wxSizerFlags to center itself in the area it is
403 given.
404 */
405 wxSizerFlags& Center();
406
407 /**
408 Center() for people with the other dialect of English.
409 */
410 wxSizerFlags& Centre();
411
412 /**
413 Sets the border in the given @a direction having twice the default
414 border size.
415 */
416 wxSizerFlags& DoubleBorder(int direction = wxALL);
417
418 /**
419 Sets the border in left and right directions having twice the default
420 border size.
421 */
422 wxSizerFlags& DoubleHorzBorder();
423
424 /**
425 Sets the object of the wxSizerFlags to expand to fill as much area as
426 it can.
427 */
428 wxSizerFlags& Expand();
429
430 /**
431 Set the @c wxFIXED_MINSIZE flag which indicates that the initial size
432 of the window should be also set as its minimal size.
433 */
434 wxSizerFlags& FixedMinSize();
435
436 /**
437 Set the @c wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers
438 don't allocate space for hidden windows or other items. This flag
439 overrides this behavior so that sufficient space is allocated for the
440 window even if it isn't visible. This makes it possible to dynamically
441 show and hide controls without resizing parent dialog, for example.
442
443 @since 2.8.8
444 */
445 wxSizerFlags& ReserveSpaceEvenIfHidden();
446
447 /**
448 Returns the border used by default in Border() method.
449 */
450 static int GetDefaultBorder();
451
452 /**
453 Aligns the object to the left, similar for @c Align(wxALIGN_LEFT).
454
455 Unlike Align(), this method doesn't change the vertical alignment of
456 the item.
457 */
458 wxSizerFlags& Left();
459
460 /**
461 Sets the proportion of this wxSizerFlags to @e proportion
462 */
463 wxSizerFlags& Proportion(int proportion = 0);
464
465 /**
466 Aligns the object to the right, similar for @c Align(wxALIGN_RIGHT).
467
468 Unlike Align(), this method doesn't change the vertical alignment of
469 the item.
470 */
471 wxSizerFlags& Right();
472
473 /**
474 Set the @c wx_SHAPED flag which indicates that the elements should
475 always keep the fixed width to height ratio equal to its original value.
476 */
477 wxSizerFlags& Shaped();
478
479 /**
480 Aligns the object to the top, similar for @c Align(wxALIGN_TOP).
481
482 Unlike Align(), this method doesn't change the horizontal alignment of
483 the item.
484 */
485 wxSizerFlags& Top();
486
487 /**
488 Sets the border in the given @a direction having thrice the default
489 border size.
490 */
491 wxSizerFlags& TripleBorder(int direction = wxALL);
492 };
493
494
495
496 /**
497 @class wxNotebookSizer
498
499 @deprecated
500 This class is deprecated and should not be used in new code! It is no
501 longer needed, wxNotebook control can be inserted
502 into any sizer class and its minimal size will be determined correctly.
503
504 wxNotebookSizer is a specialized sizer to make sizers work in connection
505 with using notebooks. This sizer is different from any other sizer as you
506 must not add any children to it - instead, it queries the notebook class
507 itself. The only thing this sizer does is to determine the size of the
508 biggest page of the notebook and report an adjusted minimal size to a more
509 toplevel sizer.
510
511 @library{wxbase}
512 @category{winlayout}
513
514 @see wxSizer, wxNotebook,
515 @ref overview_sizer "Sizers overview"
516 */
517 class wxNotebookSizer : public wxSizer
518 {
519 public:
520 /**
521 Constructor. It takes an associated notebook as its only parameter.
522 */
523 wxNotebookSizer(wxNotebook* notebook);
524
525 /**
526 Returns the notebook associated with the sizer.
527 */
528 wxNotebook* GetNotebook();
529 };
530
531
532
533 /**
534 @class wxFlexGridSizer
535
536 A flex grid sizer is a sizer which lays out its children in a two-dimensional
537 table with all table fields in one row having the same
538 height and all fields in one column having the same width, but all
539 rows or all columns are not necessarily the same height or width as in
540 the wxGridSizer.
541
542 Since wxWidgets 2.5.0, wxFlexGridSizer can also size items equally in one
543 direction but unequally ("flexibly") in the other. If the sizer is only
544 flexible in one direction (this can be changed using
545 wxFlexGridSizer::SetFlexibleDirection),
546 it needs to be decided how the sizer should grow in the other ("non-flexible")
547 direction in order to fill the available space. The
548 wxFlexGridSizer::SetNonFlexibleGrowMode method
549 serves this purpose.
550
551 @library{wxcore}
552 @category{winlayout}
553
554 @see wxSizer, @ref overview_sizer "Sizer Overview"
555 */
556 class wxFlexGridSizer : public wxGridSizer
557 {
558 public:
559 //@{
560 /**
561 Constructor for a wxGridSizer. @a rows and @a cols determine the number of
562 columns and rows in the sizer - if either of the parameters is zero, it will be
563 calculated to form the total number of children in the sizer, thus making the
564 sizer grow dynamically. @a vgap and @a hgap define extra space between
565 all children.
566 */
567 wxFlexGridSizer(int rows, int cols, int vgap, int hgap);
568 wxFlexGridSizer(int cols, int vgap = 0, int hgap = 0);
569 //@}
570
571 /**
572 Specifies that column @a idx (starting from zero) should be grown if
573 there is extra space available to the sizer.
574 The @a proportion parameter has the same meaning as the stretch factor for
575 the sizers() except that if all proportions are 0,
576 then all columns are resized equally (instead of not being resized at all).
577 */
578 void AddGrowableCol(size_t idx, int proportion = 0);
579
580 /**
581 Specifies that row idx (starting from zero) should be grown if there
582 is extra space available to the sizer.
583 See AddGrowableCol() for the description
584 of @a proportion parameter.
585 */
586 void AddGrowableRow(size_t idx, int proportion = 0);
587
588 /**
589 Returns a wxOrientation value that specifies whether the sizer flexibly
590 resizes its columns, rows, or both (default).
591
592 @return One of the following values:
593
594 @see SetFlexibleDirection()
595 */
596 int GetFlexibleDirection() const;
597
598 /**
599 Returns the value that specifies how the sizer grows in the "non-flexible"
600 direction if there is one.
601
602 @return One of the following values:
603
604 @see SetFlexibleDirection(),
605 SetNonFlexibleGrowMode()
606 */
607 int GetNonFlexibleGrowMode() const;
608
609 /**
610 Specifies that column idx is no longer growable.
611 */
612 void RemoveGrowableCol(size_t idx);
613
614 /**
615 Specifies that row idx is no longer growable.
616 */
617 void RemoveGrowableRow(size_t idx);
618
619 /**
620 Specifies whether the sizer should flexibly resize its columns, rows, or
621 both. Argument @c direction can be @c wxVERTICAL, @c wxHORIZONTAL
622 or @c wxBOTH (which is the default value). Any other value is ignored. See
623 @ref GetFlexibleDirection() GetFlexibleDirection for the
624 explanation of these values.
625 Note that this method does not trigger relayout.
626 */
627 void SetFlexibleDirection(int direction);
628
629 /**
630 Specifies how the sizer should grow in the non-flexible direction if
631 there is one (so
632 SetFlexibleDirection() must have
633 been called previously). Argument @a mode can be one of those documented in
634 GetNonFlexibleGrowMode(), please
635 see there for their explanation.
636 Note that this method does not trigger relayout.
637 */
638 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
639 };
640
641
642
643 /**
644 @class wxSizer
645
646 wxSizer is the abstract base class used for laying out subwindows in a window.
647 You
648 cannot use wxSizer directly; instead, you will have to use one of the sizer
649 classes derived from it. Currently there are wxBoxSizer,
650 wxStaticBoxSizer,
651 wxGridSizer,
652 wxFlexGridSizer,
653 wxWrapSizer
654 and wxGridBagSizer.
655
656 The layout algorithm used by sizers in wxWidgets is closely related to layout
657 in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit.
658 It is
659 based upon the idea of the individual subwindows reporting their minimal
660 required
661 size and their ability to get stretched if the size of the parent window has
662 changed.
663 This will most often mean that the programmer does not set the original size of
664 a dialog in the beginning, rather the dialog will be assigned a sizer and this
665 sizer
666 will be queried about the recommended size. The sizer in turn will query its
667 children, which can be normal windows, empty space or other sizers, so that
668 a hierarchy of sizers can be constructed. Note that wxSizer does not derive
669 from wxWindow
670 and thus does not interfere with tab ordering and requires very little
671 resources compared
672 to a real window on screen.
673
674 What makes sizers so well fitted for use in wxWidgets is the fact that every
675 control
676 reports its own minimal size and the algorithm can handle differences in font
677 sizes
678 or different window (dialog item) sizes on different platforms without
679 problems. If e.g.
680 the standard font as well as the overall design of Motif widgets requires more
681 space than
682 on Windows, the initial dialog size will automatically be bigger on Motif than
683 on Windows.
684
685 Sizers may also be used to control the layout of custom drawn items on the
686 window. The Add(), Insert(), and Prepend() functions return a pointer to
687 the newly added wxSizerItem. Just add empty space of the desired size and
688 attributes, and then use the wxSizerItem::GetRect() method to determine
689 where the drawing operations should take place.
690
691 Please notice that sizers, like child windows, are owned by the library and
692 will be deleted by it which implies that they must be allocated on the
693 heap. However if you create a sizer and do not add it to another sizer or
694 window, the library wouldn't be able to delete such an orphan sizer and in
695 this, and only this, case it should be deleted explicitly.
696
697 @b wxPython note: If you wish to create a sizer class in wxPython you should
698 derive the class from @c wxPySizer in order to get Python-aware
699 capabilities for the various virtual methods.
700
701 @anchor wxsizer_flags
702 @par wxSizer flags
703 The "flag" argument accepted by wxSizeItem constructors and other
704 functions, e.g. wxSizer::Add(), is OR-combination of the following flags.
705 Two main behaviours are defined using these flags. One is the border around
706 a window: the border parameter determines the border width whereas the
707 flags given here determine which side(s) of the item that the border will
708 be added. The other flags determine how the sizer item behaves when the
709 space allotted to the sizer changes, and is somewhat dependent on the
710 specific kind of sizer used.
711 @beginDefList
712 @itemdef{wxTOP<br>
713 wxBOTTOM<br>
714 wxLEFT<br>
715 wxRIGHT<br>
716 wxALL,
717 These flags are used to specify which side(s) of the sizer item
718 the border width will apply to.}
719 @itemdef{wxEXPAND,
720 The item will be expanded to fill the space assigned to the item.}
721 @itemdef{wxSHAPED,
722 The item will be expanded as much as possible while also
723 maintaining its aspect ratio.}
724 @itemdef{wxFIXED_MINSIZE,
725 Normally wxSizers will use GetAdjustedBestSize() to determine what
726 the minimal size of window items should be, and will use that size
727 to calculate the layout. This allows layouts to adjust when an
728 item changes and its best size becomes different. If you would
729 rather have a window item stay the size it started with then use
730 wxFIXED_MINSIZE.}
731 @itemdef{wxRESERVE_SPACE_EVEN_IF_HIDDEN,
732 Normally wxSizers don't allocate space for hidden windows or other
733 items. This flag overrides this behavior so that sufficient space
734 is allocated for the window even if it isn't visible. This makes
735 it possible to dynamically show and hide controls without resizing
736 parent dialog, for example. (Available since 2.8.8.)
737 }
738 @itemdef{wxALIGN_CENTER<br>
739 wxALIGN_CENTRE<br>
740 wxALIGN_LEFT<br>
741 wxALIGN_RIGHT<br>
742 wxALIGN_TOP<br>
743 wxALIGN_BOTTOM<br>
744 wxALIGN_CENTER_VERTICAL<br>
745 wxALIGN_CENTRE_VERTICAL<br>
746 wxALIGN_CENTER_HORIZONTAL<br>
747 wxALIGN_CENTRE_HORIZONTAL,
748 The wxALIGN flags allow you to specify the alignment of the item
749 within the space allotted to it by the sizer, adjusted for the
750 border if any.}
751 @endDefList
752
753
754 @library{wxcore}
755 @category{winlayout}
756
757 @see @ref overview_sizer "Sizer Overview"
758 */
759 class wxSizer : public wxObject
760 {
761 public:
762 /**
763 The constructor. Note that wxSizer is an abstract base class and may not
764 be instantiated.
765 */
766 wxSizer();
767
768 /**
769 The destructor.
770 */
771 ~wxSizer();
772
773 /**
774 Appends a child to the sizer.
775
776 wxSizer itself is an abstract class, but the parameters are equivalent
777 in the derived classes that you will instantiate to use it so they are
778 described here:
779
780 @param window
781 The window to be added to the sizer. Its initial size (either set
782 explicitly by the user or calculated internally when using
783 wxDefaultSize) is interpreted as the minimal and in many cases also
784 the initial size.
785 @param flags
786 A wxSizerFlags object that enables you to specify most of the above
787 parameters more conveniently.
788 */
789 wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags);
790
791 /**
792 Appends a child to the sizer.
793
794 wxSizer itself is an abstract class, but the parameters are equivalent
795 in the derived classes that you will instantiate to use it so they are
796 described here:
797
798 @param window
799 The window to be added to the sizer. Its initial size (either set
800 explicitly by the user or calculated internally when using
801 wxDefaultSize) is interpreted as the minimal and in many cases also
802 the initial size.
803 @param proportion
804 Although the meaning of this parameter is undefined in wxSizer, it
805 is used in wxBoxSizer to indicate if a child of a sizer can change
806 its size in the main orientation of the wxBoxSizer - where 0 stands
807 for not changeable and a value of more than zero is interpreted
808 relative to the value of other children of the same wxBoxSizer. For
809 example, you might have a horizontal wxBoxSizer with three
810 children, two of which are supposed to change their size with the
811 sizer. Then the two stretchable windows would get a value of 1 each
812 to make them grow and shrink equally with the sizer's horizontal
813 dimension.
814 @param flag
815 OR-combination of flags affecting sizer's behavior. See
816 @ref wxsizer_flags "wxSizer flags list" for details.
817 @param border
818 Determines the border width, if the flag parameter is set to
819 include any border flag.
820 @param userData
821 Allows an extra object to be attached to the sizer item, for use in
822 derived classes when sizing information is more complex than the
823 proportion and flag will allow for.
824 */
825 wxSizerItem* Add(wxWindow* window, int proportion = 0,
826 int flag = 0,
827 int border = 0,
828 wxObject* userData = NULL);
829
830 /**
831 Appends a child to the sizer.
832
833 wxSizer itself is an abstract class, but the parameters are equivalent
834 in the derived classes that you will instantiate to use it so they are
835 described here:
836
837 @param sizer
838 The (child-)sizer to be added to the sizer. This allows placing a
839 child sizer in a sizer and thus to create hierarchies of sizers
840 (typically a vertical box as the top sizer and several horizontal
841 boxes on the level beneath).
842 @param flags
843 A wxSizerFlags object that enables you to specify most of the above
844 parameters more conveniently.
845 */
846 wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags);
847
848 /**
849 Appends a child to the sizer.
850
851 wxSizer itself is an abstract class, but the parameters are equivalent
852 in the derived classes that you will instantiate to use it so they are
853 described here:
854
855 @param sizer
856 The (child-)sizer to be added to the sizer. This allows placing a
857 child sizer in a sizer and thus to create hierarchies of sizers
858 (typically a vertical box as the top sizer and several horizontal
859 boxes on the level beneath).
860 @param proportion
861 Although the meaning of this parameter is undefined in wxSizer, it
862 is used in wxBoxSizer to indicate if a child of a sizer can change
863 its size in the main orientation of the wxBoxSizer - where 0 stands
864 for not changeable and a value of more than zero is interpreted
865 relative to the value of other children of the same wxBoxSizer. For
866 example, you might have a horizontal wxBoxSizer with three
867 children, two of which are supposed to change their size with the
868 sizer. Then the two stretchable windows would get a value of 1 each
869 to make them grow and shrink equally with the sizer's horizontal
870 dimension.
871 @param flag
872 OR-combination of flags affecting sizer's behavior. See
873 @ref wxsizer_flags "wxSizer flags list" for details.
874 @param border
875 Determines the border width, if the flag parameter is set to
876 include any border flag.
877 @param userData
878 Allows an extra object to be attached to the sizer item, for use in
879 derived classes when sizing information is more complex than the
880 proportion and flag will allow for.
881 */
882 wxSizerItem* Add(wxSizer* sizer, int proportion = 0,
883 int flag = 0,
884 int border = 0,
885 wxObject* userData = NULL);
886
887 /**
888 Appends a spacer child to the sizer.
889
890 wxSizer itself is an abstract class, but the parameters are equivalent
891 in the derived classes that you will instantiate to use it so they are
892 described here.
893
894 @a width and @a height specify the dimension of a spacer to be added to
895 the sizer. Adding spacers to sizers gives more flexibility in the
896 design of dialogs; imagine for example a horizontal box with two
897 buttons at the bottom of a dialog: you might want to insert a space
898 between the two buttons and make that space stretchable using the
899 proportion flag and the result will be that the left button will be
900 aligned with the left side of the dialog and the right button with the
901 right side - the space in between will shrink and grow with the dialog.
902
903 @param width
904 Width of the spacer.
905 @param height
906 Height of the spacer.
907 @param proportion
908 Although the meaning of this parameter is undefined in wxSizer, it
909 is used in wxBoxSizer to indicate if a child of a sizer can change
910 its size in the main orientation of the wxBoxSizer - where 0 stands
911 for not changeable and a value of more than zero is interpreted
912 relative to the value of other children of the same wxBoxSizer. For
913 example, you might have a horizontal wxBoxSizer with three
914 children, two of which are supposed to change their size with the
915 sizer. Then the two stretchable windows would get a value of 1 each
916 to make them grow and shrink equally with the sizer's horizontal
917 dimension.
918 @param flag
919 OR-combination of flags affecting sizer's behavior. See
920 @ref wxsizer_flags "wxSizer flags list" for details.
921 @param border
922 Determines the border width, if the flag parameter is set to
923 include any border flag.
924 @param userData
925 Allows an extra object to be attached to the sizer item, for use in
926 derived classes when sizing information is more complex than the
927 proportion and flag will allow for.
928 */
929 wxSizerItem* Add(int width, int height, int proportion = 0,
930 int flag = 0,
931 int border = 0,
932 wxObject* userData = NULL);
933
934 /**
935 Adds non-stretchable space to the sizer. More readable way of calling
936 wxSizer::Add(size, size, 0).
937 */
938 wxSizerItem* AddSpacer(int size);
939
940 /**
941 Adds stretchable space to the sizer. More readable way of calling
942 wxSizer::Add(0, 0, prop).
943 */
944 wxSizerItem* AddStretchSpacer(int prop = 1);
945
946 /**
947 This method is abstract and has to be overwritten by any derived class.
948 Here, the sizer will do the actual calculation of its children's minimal sizes.
949 */
950 wxSize CalcMin();
951
952 /**
953 Detaches all children from the sizer. If @a delete_windows is @true then
954 child windows will also be deleted.
955 */
956 void Clear(bool delete_windows = false);
957
958 /**
959 Computes client area size for @a window so that it matches the sizer's
960 minimal size. Unlike GetMinSize(), this method accounts for other
961 constraints imposed on @e window, namely display's size (returned size
962 will never be too large for the display) and maximum window size if
963 previously set by wxWindow::SetMaxSize(). The returned value is
964 suitable for passing to wxWindow::SetClientSize() or
965 wxWindow::SetMinClientSize().
966
967 @since 2.8.8
968
969 @see ComputeFittingWindowSize(), Fit()
970 */
971 wxSize ComputeFittingClientSize(wxWindow* window);
972
973 /**
974 Like ComputeFittingClientSize(), but converts the result into window
975 size. The returned value is suitable for passing to wxWindow::SetSize()
976 or wxWindow::SetMinSize().
977
978 @since 2.8.8
979
980 @see ComputeFittingClientSize(), Fit()
981 */
982 wxSize ComputeFittingWindowSize(wxWindow* window);
983
984 /**
985 Detach the child @a window from the sizer without destroying it.
986
987 This method does not cause any layout or resizing to take place, call Layout()
988 to update the layout "on screen" after detaching a child from the sizer.
989
990 Returns @true if the child item was found and detached, @false otherwise.
991
992 @see Remove()
993 */
994 bool Detach(wxWindow* window);
995
996 /**
997 Detach the child @a sizer from the sizer without destroying it.
998
999 This method does not cause any layout or resizing to take place, call Layout()
1000 to update the layout "on screen" after detaching a child from the sizer.
1001
1002 Returns @true if the child item was found and detached, @false otherwise.
1003
1004 @see Remove()
1005 */
1006 bool Detach(wxSizer* sizer);
1007
1008 /**
1009 Detach a item at position @a index from the sizer without destroying it.
1010
1011 This method does not cause any layout or resizing to take place, call Layout()
1012 to update the layout "on screen" after detaching a child from the sizer.
1013 Returns @true if the child item was found and detached, @false otherwise.
1014
1015 @see Remove()
1016 */
1017 bool Detach(size_t index);
1018
1019 /**
1020 Tell the sizer to resize the @a window so that its client area matches the
1021 sizer's minimal size
1022 (ComputeFittingClientSize() is called
1023 to determine it).
1024 This is commonly done in the constructor of the window
1025 itself, see sample in the description
1026 of wxBoxSizer. Returns the new window size.
1027
1028 @see ComputeFittingClientSize(), ComputeFittingWindowSize()
1029 */
1030 wxSize Fit(wxWindow* window);
1031
1032 /**
1033 Tell the sizer to resize the virtual size of the @a window to match the sizer's
1034 minimal size. This will not alter the on screen size of the window, but may
1035 cause the addition/removal/alteration of scrollbars required to view the virtual
1036 area in windows which manage it.
1037
1038 @see wxScrolled::SetScrollbars(), SetVirtualSizeHints()
1039 */
1040 void FitInside(wxWindow* window);
1041
1042 /**
1043 Returns the list of the items in this sizer. The elements of type-safe
1044 wxList @a wxSizerItemList are pointers to objects of type
1045 @ref wxSizerItem "wxSizerItem".
1046 */
1047 wxSizerItemList& GetChildren();
1048
1049 /**
1050 Returns the list of the items in this sizer. The elements of type-safe
1051 wxList @a wxSizerItemList are pointers to objects of type
1052 @ref wxSizerItem "wxSizerItem".
1053 */
1054 const wxSizerItemList& GetChildren() const;
1055
1056 /**
1057 Returns the window this sizer is used in or @NULL if none.
1058 */
1059 wxWindow* GetContainingWindow() const;
1060
1061 /**
1062 Finds wxSizerItem which holds the given @a window
1063 Use parameter @a recursive to search in subsizers too.
1064 Returns pointer to item or @NULL.
1065 */
1066 wxSizerItem* GetItem(wxWindow* window, bool recursive = false);
1067
1068 /**
1069 Finds wxSizerItem which holds the given @a sizer
1070 Use parameter @a recursive to search in subsizers too.
1071 Returns pointer to item or @NULL.
1072 */
1073
1074 wxSizerItem* GetItem(wxSizer* sizer, bool recursive = false);
1075 /**
1076 Finds wxSizerItem which is located in the sizer at position
1077 @a index.
1078 Use parameter @a recursive to search in subsizers too.
1079 Returns pointer to item or @NULL.
1080 */
1081 wxSizerItem* GetItem(size_t index);
1082
1083 /**
1084 Finds item of the sizer which has the given @e id. This @a id is not the
1085 window id but the id of the wxSizerItem itself. This is mainly useful for
1086 retrieving the sizers created from XRC resources.
1087 Use parameter @a recursive to search in subsizers too.
1088 Returns pointer to item or @NULL.
1089 */
1090 wxSizerItem* GetItemById(int id, bool recursive = false);
1091
1092 /**
1093 Returns the minimal size of the sizer. This is either the combined minimal
1094 size of all the children and their borders or the minimal size set by
1095 SetMinSize(), depending on which is bigger.
1096 Note that the returned value is client size, not window size.
1097 In particular, if you use the value to set toplevel window's minimal or
1098 actual size, use wxWindow::SetMinClientSize
1099 or wxWindow::SetClientSize, not
1100 wxWindow::SetMinSize
1101 or wxWindow::SetSize.
1102 */
1103 wxSize GetMinSize();
1104
1105 /**
1106 Returns the current position of the sizer.
1107 */
1108 wxPoint GetPosition();
1109
1110 /**
1111 Returns the current size of the sizer.
1112 */
1113 wxSize GetSize();
1114
1115 /**
1116 Hides the child @a window.
1117
1118 To make a sizer item disappear, use Hide() followed by Layout().
1119
1120 Use parameter @a recursive to hide elements found in subsizers.
1121 Returns @true if the child item was found, @false otherwise.
1122
1123 @see IsShown(), Show()
1124 */
1125 bool Hide(wxWindow* window, bool recursive = false);
1126
1127 /**
1128 Hides the child @a sizer.
1129
1130 To make a sizer item disappear, use Hide() followed by Layout().
1131
1132 Use parameter @a recursive to hide elements found in subsizers.
1133 Returns @true if the child item was found, @false otherwise.
1134
1135 @see IsShown(), Show()
1136 */
1137 bool Hide(wxSizer* sizer, bool recursive = false);
1138
1139 /**
1140 Hides the item at position @a index.
1141
1142 To make a sizer item disappear, use Hide() followed by Layout().
1143
1144 Use parameter @a recursive to hide elements found in subsizers.
1145 Returns @true if the child item was found, @false otherwise.
1146
1147 @see IsShown(), Show()
1148 */
1149 bool Hide(size_t index);
1150
1151 /**
1152 Insert a child into the sizer before any existing item at
1153
1154 See Add() for the meaning of the other parameters.
1155 */
1156 wxSizerItem* Insert(size_t index, wxWindow* window,
1157 const wxSizerFlags& flags);
1158
1159 /**
1160 Insert a child into the sizer before any existing item at
1161
1162 See Add() for the meaning of the other parameters.
1163 */
1164 wxSizerItem* Insert(size_t index, wxWindow* window,
1165 int proportion = 0,
1166 int flag = 0,
1167 int border = 0,
1168 wxObject* userData = NULL);
1169
1170 /**
1171 Insert a child into the sizer before any existing item at
1172
1173 See Add() for the meaning of the other parameters.
1174 */
1175 wxSizerItem* Insert(size_t index, wxSizer* sizer,
1176 const wxSizerFlags& flags);
1177
1178 /**
1179 Insert a child into the sizer before any existing item at
1180
1181 See Add() for the meaning of the other parameters.
1182 */
1183 wxSizerItem* Insert(size_t index, wxSizer* sizer,
1184 int proportion = 0,
1185 int flag = 0,
1186 int border = 0,
1187 wxObject* userData = NULL);
1188
1189 /**
1190 Insert a child into the sizer before any existing item at
1191
1192 See Add() for the meaning of the other parameters.
1193 */
1194 wxSizerItem* Insert(size_t index, int width, int height,
1195 int proportion = 0,
1196 int flag = 0,
1197 int border = 0,
1198 wxObject* userData = NULL);
1199
1200 /**
1201 Inserts non-stretchable space to the sizer. More readable way of calling
1202 wxSizer::Insert(size, size, 0).
1203 */
1204 wxSizerItem* InsertSpacer(size_t index, int size);
1205
1206 /**
1207 Inserts stretchable space to the sizer. More readable way of calling
1208 wxSizer::Insert(0, 0, prop).
1209 */
1210 wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
1211
1212 /**
1213 Returns @true if the @e window is shown.
1214
1215 @see Hide(), Show(), wxSizerItem::IsShown()
1216 */
1217 bool IsShown(wxWindow* window) const;
1218
1219 /**
1220 Returns @true if the @e sizer is shown.
1221
1222 @see Hide(), Show(), wxSizerItem::IsShown()
1223 */
1224 bool IsShown(wxSizer* sizer) const;
1225
1226 /**
1227 Returns @true if the item at @a index is shown.
1228
1229 @see Hide(), Show(), wxSizerItem::IsShown()
1230 */
1231 bool IsShown(size_t index) const;
1232
1233 /**
1234 Call this to force layout of the children anew, e.g. after having added a child
1235 to or removed a child (window, other sizer or space) from the sizer while
1236 keeping
1237 the current dimension.
1238 */
1239 void Layout();
1240
1241 /**
1242 Same as Add(), but prepends the items to the beginning of the
1243 list of items (windows, subsizers or spaces) owned by this sizer.
1244 */
1245 wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags);
1246
1247 /**
1248 Same as Add(), but prepends the items to the beginning of the
1249 list of items (windows, subsizers or spaces) owned by this sizer.
1250 */
1251 wxSizerItem* Prepend(wxWindow* window, int proportion = 0,
1252 int flag = 0,
1253 int border = 0,
1254 wxObject* userData = NULL);
1255
1256 /**
1257 Same as Add(), but prepends the items to the beginning of the
1258 list of items (windows, subsizers or spaces) owned by this sizer.
1259 */
1260 wxSizerItem* Prepend(wxSizer* sizer,
1261 const wxSizerFlags& flags);
1262
1263 /**
1264 Same as Add(), but prepends the items to the beginning of the
1265 list of items (windows, subsizers or spaces) owned by this sizer.
1266 */
1267 wxSizerItem* Prepend(wxSizer* sizer, int proportion = 0,
1268 int flag = 0,
1269 int border = 0,
1270 wxObject* userData = NULL);
1271
1272 /**
1273 Same as Add(), but prepends the items to the beginning of the
1274 list of items (windows, subsizers or spaces) owned by this sizer.
1275 */
1276 wxSizerItem* Prepend(int width, int height,
1277 int proportion = 0,
1278 int flag = 0,
1279 int border = 0,
1280 wxObject* userData = NULL);
1281
1282 /**
1283 Prepends non-stretchable space to the sizer. More readable way of
1284 calling wxSizer::Prepend(size, size, 0).
1285 */
1286 wxSizerItem* PrependSpacer(int size);
1287
1288 /**
1289 Prepends stretchable space to the sizer. More readable way of calling
1290 wxSizer::Prepend(0, 0, prop).
1291 */
1292 wxSizerItem* PrependStretchSpacer(int prop = 1);
1293
1294 /**
1295 This method is abstract and has to be overwritten by any derived class.
1296 Here, the sizer will do the actual calculation of its children's
1297 positions and sizes.
1298 */
1299 void RecalcSizes();
1300
1301 /**
1302 Removes a child window from the sizer, but does @b not destroy it
1303 (because windows are owned by their parent window, not the sizer).
1304
1305 @deprecated
1306 The overload of this method taking a wxWindow* parameter
1307 is deprecated as it does not destroy the window as would usually be
1308 expected from Remove(). You should use Detach() in new code instead.
1309 There is currently no wxSizer method that will both detach and destroy
1310 a wxWindow item.
1311
1312 @note This method does not cause any layout or resizing to take
1313 place, call Layout() to update the layout "on screen" after
1314 removing a child from the sizer.
1315
1316 @return @true if the child item was found and removed, @false otherwise.
1317 */
1318 bool Remove(wxWindow* window);
1319
1320 /**
1321 Removes a sizer child from the sizer and destroys it.
1322
1323 @note This method does not cause any layout or resizing to take
1324 place, call Layout() to update the layout "on screen" after
1325 removing a child from the sizer.
1326
1327 @param sizer The wxSizer to be removed.
1328
1329 @return @true if the child item was found and removed, @false otherwise.
1330 */
1331 bool Remove(wxSizer* sizer);
1332
1333 /**
1334 Removes a child from the sizer and destroys it if it is a sizer or a
1335 spacer, but not if it is a window (because windows are owned by their
1336 parent window, not the sizer).
1337
1338 @note This method does not cause any layout or resizing to take
1339 place, call Layout() to update the layout "on screen" after
1340 removing a child from the sizer.
1341
1342 @param index The position of the child in the sizer, e.g. 0 for the
1343 first item.
1344
1345 @return @true if the child item was found and removed, @false otherwise.
1346 */
1347 bool Remove(size_t index);
1348
1349 /**
1350 Detaches the given @a oldwin from the sizer and
1351 replaces it with the given @a newwin. The detached
1352 child window is @b not deleted (because windows are
1353 owned by their parent window, not the sizer).
1354
1355 Use parameter @a recursive to search the given element recursively in subsizers.
1356
1357 This method does not cause any layout or resizing to take place,
1358 call Layout() to update the layout "on screen" after replacing a
1359 child from the sizer.
1360
1361 Returns @true if the child item was found and removed, @false otherwise.
1362 */
1363 bool Replace(wxWindow* oldwin, wxWindow* newwin,
1364 bool recursive = false);
1365
1366 /**
1367 Detaches the given @a oldsz from the sizer and
1368 replaces it with the given @a newsz. The detached
1369 child sizer is deleted.
1370
1371 Use parameter @a recursive to search the given element recursively in subsizers.
1372
1373 This method does not cause any layout or resizing to take place,
1374 call Layout() to update the layout "on screen" after replacing a
1375 child from the sizer.
1376
1377 Returns @true if the child item was found and removed, @false otherwise.
1378 */
1379 bool Replace(wxSizer* oldsz, wxSizer* newsz,
1380 bool recursive = false);
1381
1382 /**
1383 Detaches the given item at position @a index from the sizer and
1384 replaces it with the given wxSizerItem @a newitem.
1385
1386 The detached child is deleted @b only if it is a sizer or a spacer
1387 (but not if it is a wxWindow because windows are owned by their
1388 parent window, not the sizer).
1389
1390 This method does not cause any layout or resizing to take place,
1391 call Layout() to update the layout "on screen" after replacing a
1392 child from the sizer.
1393
1394 Returns @true if the child item was found and removed, @false otherwise.
1395 */
1396 bool Replace(size_t index, wxSizerItem* newitem);
1397
1398 /**
1399 Call this to force the sizer to take the given dimension and thus force
1400 the items owned by the sizer to resize themselves according to the
1401 rules defined by the parameter in the Add() and Prepend() methods.
1402 */
1403 void SetDimension(int x, int y, int width, int height);
1404
1405 /**
1406 @overload
1407 */
1408 void SetDimension(const wxPoint& pos, const wxSize& size);
1409
1410 /**
1411 Set an item's minimum size by window, sizer, or position.
1412
1413 The item will be found recursively in the sizer's descendants. This
1414 function enables an application to set the size of an item after
1415 initial creation.
1416
1417 @see wxSizerItem::SetMinSize()
1418 */
1419 void SetItemMinSize(wxWindow* window, int width, int height);
1420
1421 /**
1422 Set an item's minimum size by window, sizer, or position.
1423
1424 The item will be found recursively in the sizer's descendants. This
1425 function enables an application to set the size of an item after
1426 initial creation.
1427
1428 @see wxSizerItem::SetMinSize()
1429 */
1430 void SetItemMinSize(wxSizer* sizer, int width, int height);
1431
1432 /**
1433 Set an item's minimum size by window, sizer, or position.
1434
1435 The item will be found recursively in the sizer's descendants. This
1436 function enables an application to set the size of an item after
1437 initial creation.
1438
1439 @see wxSizerItem::SetMinSize()
1440 */
1441 void SetItemMinSize(size_t index, int width, int height);
1442
1443 /**
1444 Call this to give the sizer a minimal size. Normally, the sizer will
1445 calculate its minimal size based purely on how much space its children
1446 need. After calling this method GetMinSize() will return either the
1447 minimal size as requested by its children or the minimal size set here,
1448 depending on which is bigger.
1449 */
1450 void SetMinSize(const wxSize& size);
1451
1452 /**
1453 @overload
1454 */
1455 void SetMinSize(int width, int height);
1456
1457 /**
1458 This method first calls Fit() and then
1459 wxTopLevelWindow::SetSizeHints on the @e window
1460 passed to it. This only makes sense when @a window is actually a
1461 wxTopLevelWindow such as a wxFrame or a
1462 wxDialog, since SetSizeHints only has any effect in these classes.
1463 It does nothing in normal windows or controls.
1464 This method is implicitly used by wxWindow::SetSizerAndFit
1465 which is commonly invoked in the constructor of a toplevel window itself (see
1466 the sample in the description of wxBoxSizer) if the
1467 toplevel window is resizable.
1468 */
1469 void SetSizeHints(wxWindow* window);
1470
1471 /**
1472 Tell the sizer to set the minimal size of the @a window virtual area to match
1473 the sizer's
1474 minimal size. For windows with managed scrollbars this will set them
1475 appropriately.
1476
1477 @see wxScrolled::SetScrollbars()
1478 */
1479 void SetVirtualSizeHints(wxWindow* window);
1480
1481 /**
1482 Shows or hides the @a window.
1483 To make a sizer item disappear or reappear, use Show() followed by Layout().
1484
1485 Use parameter @a recursive to show or hide elements found in subsizers.
1486
1487 Returns @true if the child item was found, @false otherwise.
1488
1489 @see Hide(), IsShown()
1490 */
1491 bool Show(wxWindow* window, bool show = true,
1492 bool recursive = false);
1493
1494 /**
1495 Shows or hides @a sizer.
1496 To make a sizer item disappear or reappear, use Show() followed by Layout().
1497
1498 Use parameter @a recursive to show or hide elements found in subsizers.
1499
1500 Returns @true if the child item was found, @false otherwise.
1501
1502 @see Hide(), IsShown()
1503 */
1504 bool Show(wxSizer* sizer, bool show = true,
1505 bool recursive = false);
1506
1507 /**
1508 Shows the item at @a index.
1509 To make a sizer item disappear or reappear, use Show() followed by Layout().
1510
1511 Returns @true if the child item was found, @false otherwise.
1512
1513 @see Hide(), IsShown()
1514 */
1515 bool Show(size_t index, bool show = true);
1516 };
1517
1518
1519
1520 /**
1521 @class wxGridSizer
1522
1523 A grid sizer is a sizer which lays out its children in a two-dimensional
1524 table with all table fields having the same size,
1525 i.e. the width of each field is the width of the widest child,
1526 the height of each field is the height of the tallest child.
1527
1528 @library{wxcore}
1529 @category{winlayout}
1530
1531 @see wxSizer, @ref overview_sizer "Sizer Overview"
1532 */
1533 class wxGridSizer : public wxSizer
1534 {
1535 public:
1536 //@{
1537 /**
1538 Constructor for a wxGridSizer. @a rows and @a cols determine the number of
1539 columns and rows in the sizer - if either of the parameters is zero, it will be
1540 calculated to form the total number of children in the sizer, thus making the
1541 sizer grow dynamically. @a vgap and @a hgap define extra space between
1542 all children.
1543 */
1544 wxGridSizer(int rows, int cols, int vgap, int hgap);
1545 wxGridSizer(int cols, int vgap = 0, int hgap = 0);
1546 //@}
1547
1548 /**
1549 Returns the number of columns in the sizer.
1550 */
1551 int GetCols();
1552
1553 /**
1554 Returns the horizontal gap (in pixels) between cells in the sizer.
1555 */
1556 int GetHGap();
1557
1558 /**
1559 Returns the number of rows in the sizer.
1560 */
1561 int GetRows();
1562
1563 /**
1564 Returns the vertical gap (in pixels) between the cells in the sizer.
1565 */
1566 int GetVGap();
1567
1568 /**
1569 Sets the number of columns in the sizer.
1570 */
1571 void SetCols(int cols);
1572
1573 /**
1574 Sets the horizontal gap (in pixels) between cells in the sizer.
1575 */
1576 void SetHGap(int gap);
1577
1578 /**
1579 Sets the number of rows in the sizer.
1580 */
1581 void SetRows(int rows);
1582
1583 /**
1584 Sets the vertical gap (in pixels) between the cells in the sizer.
1585 */
1586 void SetVGap(int gap);
1587 };
1588
1589
1590
1591 /**
1592 @class wxStaticBoxSizer
1593
1594 wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
1595 box around the sizer. This static box may be either created independently or
1596 the sizer may create it itself as a convenience. In any case, the sizer owns
1597 the wxStaticBox control and will delete it if it is
1598 deleted.
1599
1600 @library{wxcore}
1601 @category{winlayout}
1602
1603 @see wxSizer, wxStaticBox, wxBoxSizer, @ref overview_sizer
1604 "Sizer Overview"
1605 */
1606 class wxStaticBoxSizer : public wxBoxSizer
1607 {
1608 public:
1609 //@{
1610 /**
1611 The first constructor uses an already existing static box. It takes the
1612 associated static box and the orientation @e orient, which can be either
1613 @c wxVERTICAL or @c wxHORIZONTAL as parameters.
1614 The second one creates a new static box with the given label and parent window.
1615 */
1616 wxStaticBoxSizer(wxStaticBox* box, int orient);
1617 wxStaticBoxSizer(int orient, wxWindow parent,
1618 const wxString& label = wxEmptyString);
1619 //@}
1620
1621 /**
1622 Returns the static box associated with the sizer.
1623 */
1624 wxStaticBox* GetStaticBox();
1625 };
1626
1627
1628
1629 /**
1630 @class wxBoxSizer
1631
1632 The basic idea behind a box sizer is that windows will most often be laid out
1633 in rather
1634 simple basic geometry, typically in a row or a column or several hierarchies of
1635 either.
1636
1637 For more information, please see @ref overview_sizer_box
1638 "Programming with wxBoxSizer".
1639
1640 @library{wxcore}
1641 @category{winlayout}
1642
1643 @see wxSizer, @ref overview_sizer "Sizers Overview"
1644 */
1645 class wxBoxSizer : public wxSizer
1646 {
1647 public:
1648 /**
1649 Constructor for a wxBoxSizer. @a orient may be either of wxVERTICAL
1650 or wxHORIZONTAL for creating either a column sizer or a row sizer.
1651 */
1652 wxBoxSizer(int orient);
1653
1654 /**
1655 Implements the calculation of a box sizer's minimal. It is used internally
1656 only and must not be called by the user. Documented for information.
1657 */
1658 wxSize CalcMin();
1659
1660 /**
1661 Returns the orientation of the box sizer, either wxVERTICAL
1662 or wxHORIZONTAL.
1663 */
1664 int GetOrientation();
1665
1666 /**
1667 Implements the calculation of a box sizer's dimensions and then sets
1668 the size of its children (calling wxWindow::SetSize
1669 if the child is a window). It is used internally only and must not be called
1670 by the user (call Layout() if you want to resize). Documented for information.
1671 */
1672 void RecalcSizes();
1673 };
1674