1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: provide wxSizer class for layout
4 // Author: Robert Roebling and Robin Dunn
5 // Modified by: Ron Lee, Vadim Zeitlin (wxSizerFlags)
8 // Copyright: (c) Robin Dunn, Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
17 #include "wx/window.h"
19 //---------------------------------------------------------------------------
21 //---------------------------------------------------------------------------
23 class WXDLLEXPORT wxButton
;
24 class WXDLLEXPORT wxBoxSizer
;
25 class WXDLLEXPORT wxSizerItem
;
26 class WXDLLEXPORT wxSizer
;
28 #ifndef wxUSE_BORDER_BY_DEFAULT
30 // no borders by default on limited size screen
31 #define wxUSE_BORDER_BY_DEFAULT 0
33 #define wxUSE_BORDER_BY_DEFAULT 1
37 // ----------------------------------------------------------------------------
38 // wxSizerFlags: flags used for an item in the sizer
39 // ----------------------------------------------------------------------------
41 class WXDLLEXPORT wxSizerFlags
44 // construct the flags object initialized with the given proportion (0 by
46 wxSizerFlags(int proportion
= 0) : m_proportion(proportion
)
52 // setters for all sizer flags, they all return the object itself so that
53 // calls to them can be chained
55 wxSizerFlags
& Proportion(int proportion
)
57 m_proportion
= proportion
;
61 wxSizerFlags
& Align(int alignment
) // combination of wxAlignment values
63 m_flags
&= ~wxALIGN_MASK
;
69 wxSizerFlags
& Expand()
75 // some shortcuts for Align()
76 wxSizerFlags
& Centre() { return Align(wxCENTRE
); }
77 wxSizerFlags
& Center() { return Centre(); }
78 wxSizerFlags
& Top() { return Align(wxALIGN_TOP
); }
79 wxSizerFlags
& Left() { return Align(wxALIGN_LEFT
); }
80 wxSizerFlags
& Right() { return Align(wxALIGN_RIGHT
); }
81 wxSizerFlags
& Bottom() { return Align(wxALIGN_BOTTOM
); }
83 // default border size used by Border() below
84 static int GetDefaultBorder()
86 #if wxUSE_BORDER_BY_DEFAULT
87 // FIXME: default border size shouldn't be hardcoded and at the very
88 // least they should depend on the current font size
96 wxSizerFlags
& Border(int direction
, int borderInPixels
)
101 m_borderInPixels
= borderInPixels
;
106 wxSizerFlags
& Border(int direction
= wxALL
)
108 #if wxUSE_BORDER_BY_DEFAULT
109 return Border(direction
, GetDefaultBorder());
111 // no borders by default on limited size screen
112 wxUnusedVar(direction
);
118 wxSizerFlags
& DoubleBorder(int direction
= wxALL
)
120 #if wxUSE_BORDER_BY_DEFAULT
121 return Border(direction
, 2*GetDefaultBorder());
123 wxUnusedVar(direction
);
129 wxSizerFlags
& TripleBorder(int direction
= wxALL
)
131 #if wxUSE_BORDER_BY_DEFAULT
132 return Border(direction
, 3*GetDefaultBorder());
134 wxUnusedVar(direction
);
140 wxSizerFlags
& HorzBorder()
142 #if wxUSE_BORDER_BY_DEFAULT
143 return Border(wxLEFT
| wxRIGHT
, GetDefaultBorder());
149 wxSizerFlags
& DoubleHorzBorder()
151 #if wxUSE_BORDER_BY_DEFAULT
152 return Border(wxLEFT
| wxRIGHT
, 2*GetDefaultBorder());
158 #if wxABI_VERSION >= 20802
159 // setters for the others flags
160 wxSizerFlags
& Shaped()
167 wxSizerFlags
& FixedMinSize()
169 m_flags
|= wxFIXED_MINSIZE
;
175 // accessors for wxSizer only
176 int GetProportion() const { return m_proportion
; }
177 int GetFlags() const { return m_flags
; }
178 int GetBorderInPixels() const { return m_borderInPixels
; }
183 int m_borderInPixels
;
187 // ----------------------------------------------------------------------------
188 // wxSizerSpacer: used by wxSizerItem to represent a spacer
189 // ----------------------------------------------------------------------------
191 class WXDLLEXPORT wxSizerSpacer
194 wxSizerSpacer(const wxSize
& size
) : m_size(size
), m_isShown(true) { }
196 void SetSize(const wxSize
& size
) { m_size
= size
; }
197 const wxSize
& GetSize() const { return m_size
; }
199 void Show(bool show
) { m_isShown
= show
; }
200 bool IsShown() const { return m_isShown
; }
203 // the size, in pixel
206 // is the spacer currently shown?
210 // ----------------------------------------------------------------------------
212 // ----------------------------------------------------------------------------
214 class WXDLLEXPORT wxSizerItem
: public wxObject
218 wxSizerItem( wxWindow
*window
,
222 wxObject
* userData
);
225 wxSizerItem(wxWindow
*window
, const wxSizerFlags
& flags
)
233 wxSizerItem( wxSizer
*sizer
,
237 wxObject
* userData
);
240 wxSizerItem(wxSizer
*sizer
, const wxSizerFlags
& flags
)
248 wxSizerItem( int width
,
256 wxSizerItem(int width
, int height
, const wxSizerFlags
& flags
)
260 SetSpacer(width
, height
);
264 virtual ~wxSizerItem();
266 virtual void DeleteWindows();
268 // Enable deleting the SizerItem without destroying the contained sizer.
269 void DetachSizer() { m_sizer
= NULL
; }
271 virtual wxSize
GetSize() const;
272 virtual wxSize
CalcMin();
273 virtual void SetDimension( const wxPoint
& pos
, const wxSize
& size
);
275 wxSize
GetMinSize() const
276 { return m_minSize
; }
277 wxSize
GetMinSizeWithBorder() const;
279 void SetMinSize(const wxSize
& size
)
282 m_window
->SetMinSize(size
);
285 void SetMinSize( int x
, int y
)
286 { SetMinSize(wxSize(x
, y
)); }
287 void SetInitSize( int x
, int y
)
288 { SetMinSize(wxSize(x
, y
)); }
290 // if either of dimensions is zero, ratio is assumed to be 1
291 // to avoid "divide by zero" errors
292 void SetRatio(int width
, int height
)
293 { m_ratio
= (width
&& height
) ?
((float) width
/ (float) height
) : 1; }
294 void SetRatio(const wxSize
& size
)
295 { SetRatio(size
.x
, size
.y
); }
296 void SetRatio(float ratio
)
298 float GetRatio() const
301 virtual wxRect
GetRect() { return m_rect
; }
303 bool IsWindow() const { return m_kind
== Item_Window
; }
304 bool IsSizer() const { return m_kind
== Item_Sizer
; }
305 bool IsSpacer() const { return m_kind
== Item_Spacer
; }
307 #if WXWIN_COMPATIBILITY_2_6
308 // Deprecated in 2.6, use {G,S}etProportion instead.
309 wxDEPRECATED( void SetOption( int option
) );
310 wxDEPRECATED( int GetOption() const );
311 #endif // WXWIN_COMPATIBILITY_2_6
313 void SetProportion( int proportion
)
314 { m_proportion
= proportion
; }
315 int GetProportion() const
316 { return m_proportion
; }
317 void SetFlag( int flag
)
321 void SetBorder( int border
)
322 { m_border
= border
; }
323 int GetBorder() const
326 wxWindow
*GetWindow() const
327 { return m_kind
== Item_Window ? m_window
: NULL
; }
328 wxSizer
*GetSizer() const
329 { return m_kind
== Item_Sizer ? m_sizer
: NULL
; }
330 wxSize
GetSpacer() const;
332 // this function behaves obviously for the windows and spacers but for the
333 // sizers it returns true if any sizer element is shown and only returns
334 // false if all of them are hidden
335 bool IsShown() const;
336 void Show(bool show
);
338 void SetUserData(wxObject
* userData
)
339 { delete m_userData
; m_userData
= userData
; }
340 wxObject
* GetUserData() const
341 { return m_userData
; }
342 wxPoint
GetPosition() const
346 // these functions do not free old sizer/spacer
347 void SetWindow(wxWindow
*window
);
348 void SetSizer(wxSizer
*sizer
);
349 void SetSpacer(const wxSize
& size
);
350 void SetSpacer(int width
, int height
) { SetSpacer(wxSize(width
, height
)); }
353 // common part of several ctors
354 void Init() { m_userData
= NULL
; }
356 // common part of ctors taking wxSizerFlags
357 void Init(const wxSizerFlags
& flags
);
360 // discriminated union: depending on m_kind one of the fields is valid
373 wxSizerSpacer
*m_spacer
;
382 // on screen rectangle of this item (not including borders)
385 // Aspect ratio can always be calculated from m_size,
386 // but this would cause precision loss when the window
387 // is shrunk. It is safer to preserve the initial value.
390 wxObject
*m_userData
;
393 DECLARE_CLASS(wxSizerItem
)
394 DECLARE_NO_COPY_CLASS(wxSizerItem
)
397 WX_DECLARE_EXPORTED_LIST( wxSizerItem
, wxSizerItemList
);
400 //---------------------------------------------------------------------------
402 //---------------------------------------------------------------------------
404 class WXDLLEXPORT wxSizer
: public wxObject
, public wxClientDataContainer
407 wxSizer() { m_containingWindow
= NULL
; }
410 // methods for adding elements to the sizer: there are Add/Insert/Prepend
411 // overloads for each of window/sizer/spacer/wxSizerItem
412 wxSizerItem
* Add(wxWindow
*window
,
416 wxObject
* userData
= NULL
);
417 wxSizerItem
* Add(wxSizer
*sizer
,
421 wxObject
* userData
= NULL
);
422 wxSizerItem
* Add(int width
,
427 wxObject
* userData
= NULL
);
428 wxSizerItem
* Add( wxWindow
*window
, const wxSizerFlags
& flags
);
429 wxSizerItem
* Add( wxSizer
*sizer
, const wxSizerFlags
& flags
);
430 wxSizerItem
* Add( wxSizerItem
*item
);
432 wxSizerItem
* AddSpacer(int size
);
433 wxSizerItem
* AddStretchSpacer(int prop
= 1);
435 wxSizerItem
* Insert(size_t index
,
440 wxObject
* userData
= NULL
);
441 wxSizerItem
* Insert(size_t index
,
446 wxObject
* userData
= NULL
);
447 wxSizerItem
* Insert(size_t index
,
453 wxObject
* userData
= NULL
);
454 wxSizerItem
* Insert(size_t index
,
456 const wxSizerFlags
& flags
);
457 wxSizerItem
* Insert(size_t index
,
459 const wxSizerFlags
& flags
);
460 virtual wxSizerItem
* Insert( size_t index
, wxSizerItem
*item
);
462 wxSizerItem
* InsertSpacer(size_t index
, int size
);
463 wxSizerItem
* InsertStretchSpacer(size_t index
, int prop
= 1);
465 wxSizerItem
* Prepend(wxWindow
*window
,
469 wxObject
* userData
= NULL
);
470 wxSizerItem
* Prepend(wxSizer
*sizer
,
474 wxObject
* userData
= NULL
);
475 wxSizerItem
* Prepend(int width
,
480 wxObject
* userData
= NULL
);
481 wxSizerItem
* Prepend(wxWindow
*window
, const wxSizerFlags
& flags
);
482 wxSizerItem
* Prepend(wxSizer
*sizer
, const wxSizerFlags
& flags
);
483 wxSizerItem
* Prepend(wxSizerItem
*item
);
485 wxSizerItem
* PrependSpacer(int size
);
486 wxSizerItem
* PrependStretchSpacer(int prop
= 1);
488 // set (or possibly unset if window is NULL) or get the window this sizer
490 void SetContainingWindow(wxWindow
*window
);
491 wxWindow
*GetContainingWindow() const { return m_containingWindow
; }
493 #if WXWIN_COMPATIBILITY_2_6
494 // Deprecated in 2.6 since historically it does not delete the window,
495 // use Detach instead.
496 wxDEPRECATED( virtual bool Remove( wxWindow
*window
) );
497 #endif // WXWIN_COMPATIBILITY_2_6
499 virtual bool Remove( wxSizer
*sizer
);
500 virtual bool Remove( int index
);
502 virtual bool Detach( wxWindow
*window
);
503 virtual bool Detach( wxSizer
*sizer
);
504 virtual bool Detach( int index
);
506 virtual bool Replace( wxWindow
*oldwin
, wxWindow
*newwin
, bool recursive
= false );
507 virtual bool Replace( wxSizer
*oldsz
, wxSizer
*newsz
, bool recursive
= false );
508 virtual bool Replace( size_t index
, wxSizerItem
*newitem
);
510 virtual void Clear( bool delete_windows
= false );
511 virtual void DeleteWindows();
513 void SetMinSize( int width
, int height
)
514 { DoSetMinSize( width
, height
); }
515 void SetMinSize( const wxSize
& size
)
516 { DoSetMinSize( size
.x
, size
.y
); }
518 // Searches recursively
519 bool SetItemMinSize( wxWindow
*window
, int width
, int height
)
520 { return DoSetItemMinSize( window
, width
, height
); }
521 bool SetItemMinSize( wxWindow
*window
, const wxSize
& size
)
522 { return DoSetItemMinSize( window
, size
.x
, size
.y
); }
524 // Searches recursively
525 bool SetItemMinSize( wxSizer
*sizer
, int width
, int height
)
526 { return DoSetItemMinSize( sizer
, width
, height
); }
527 bool SetItemMinSize( wxSizer
*sizer
, const wxSize
& size
)
528 { return DoSetItemMinSize( sizer
, size
.x
, size
.y
); }
530 bool SetItemMinSize( size_t index
, int width
, int height
)
531 { return DoSetItemMinSize( index
, width
, height
); }
532 bool SetItemMinSize( size_t index
, const wxSize
& size
)
533 { return DoSetItemMinSize( index
, size
.x
, size
.y
); }
535 wxSize
GetSize() const
537 wxPoint
GetPosition() const
538 { return m_position
; }
540 // Calculate the minimal size or return m_minSize if bigger.
543 virtual void RecalcSizes() = 0;
544 virtual wxSize
CalcMin() = 0;
546 virtual void Layout();
548 wxSize
Fit( wxWindow
*window
);
549 void FitInside( wxWindow
*window
);
550 void SetSizeHints( wxWindow
*window
);
551 void SetVirtualSizeHints( wxWindow
*window
);
553 wxSizerItemList
& GetChildren()
554 { return m_children
; }
556 void SetDimension( int x
, int y
, int width
, int height
);
558 wxSizerItem
* GetItem( wxWindow
*window
, bool recursive
= false );
559 wxSizerItem
* GetItem( wxSizer
*sizer
, bool recursive
= false );
560 wxSizerItem
* GetItem( size_t index
);
562 // Manage whether individual scene items are considered
563 // in the layout calculations or not.
564 bool Show( wxWindow
*window
, bool show
= true, bool recursive
= false );
565 bool Show( wxSizer
*sizer
, bool show
= true, bool recursive
= false );
566 bool Show( size_t index
, bool show
= true );
568 bool Hide( wxSizer
*sizer
, bool recursive
= false )
569 { return Show( sizer
, false, recursive
); }
570 bool Hide( wxWindow
*window
, bool recursive
= false )
571 { return Show( window
, false, recursive
); }
572 bool Hide( size_t index
)
573 { return Show( index
, false ); }
575 bool IsShown( wxWindow
*window
) const;
576 bool IsShown( wxSizer
*sizer
) const;
577 bool IsShown( size_t index
) const;
579 // Recursively call wxWindow::Show () on all sizer items.
580 virtual void ShowItems (bool show
);
582 void Show(bool show
) { ShowItems(show
); }
588 wxSizerItemList m_children
;
590 // the window this sizer is used in, can be NULL
591 wxWindow
*m_containingWindow
;
593 wxSize
GetMaxWindowSize( wxWindow
*window
) const;
594 wxSize
GetMinWindowSize( wxWindow
*window
);
595 wxSize
GetMaxClientSize( wxWindow
*window
) const;
596 wxSize
GetMinClientSize( wxWindow
*window
);
597 wxSize
VirtualFitSize( wxWindow
*window
);
599 virtual void DoSetMinSize( int width
, int height
);
600 virtual bool DoSetItemMinSize( wxWindow
*window
, int width
, int height
);
601 virtual bool DoSetItemMinSize( wxSizer
*sizer
, int width
, int height
);
602 virtual bool DoSetItemMinSize( size_t index
, int width
, int height
);
605 DECLARE_CLASS(wxSizer
)
608 //---------------------------------------------------------------------------
610 //---------------------------------------------------------------------------
612 class WXDLLEXPORT wxGridSizer
: public wxSizer
615 wxGridSizer( int rows
, int cols
, int vgap
, int hgap
);
616 wxGridSizer( int cols
, int vgap
= 0, int hgap
= 0 );
618 virtual void RecalcSizes();
619 virtual wxSize
CalcMin();
621 void SetCols( int cols
) { m_cols
= cols
; }
622 void SetRows( int rows
) { m_rows
= rows
; }
623 void SetVGap( int gap
) { m_vgap
= gap
; }
624 void SetHGap( int gap
) { m_hgap
= gap
; }
625 int GetCols() const { return m_cols
; }
626 int GetRows() const { return m_rows
; }
627 int GetVGap() const { return m_vgap
; }
628 int GetHGap() const { return m_hgap
; }
636 // return the number of total items and the number of columns and rows
637 int CalcRowsCols(int& rows
, int& cols
) const;
639 void SetItemBounds( wxSizerItem
*item
, int x
, int y
, int w
, int h
);
642 DECLARE_CLASS(wxGridSizer
)
645 //---------------------------------------------------------------------------
647 //---------------------------------------------------------------------------
649 // the bevaiour for resizing wxFlexGridSizer cells in the "non-flexible"
651 enum wxFlexSizerGrowMode
653 // don't resize the cells in non-flexible direction at all
654 wxFLEX_GROWMODE_NONE
,
656 // uniformly resize only the specified ones (default)
657 wxFLEX_GROWMODE_SPECIFIED
,
659 // uniformly resize all cells
663 class WXDLLEXPORT wxFlexGridSizer
: public wxGridSizer
667 wxFlexGridSizer( int rows
, int cols
, int vgap
, int hgap
);
668 wxFlexGridSizer( int cols
, int vgap
= 0, int hgap
= 0 );
669 virtual ~wxFlexGridSizer();
672 // set the rows/columns which will grow (the others will remain of the
673 // constant initial size)
674 void AddGrowableRow( size_t idx
, int proportion
= 0 );
675 void RemoveGrowableRow( size_t idx
);
676 void AddGrowableCol( size_t idx
, int proportion
= 0 );
677 void RemoveGrowableCol( size_t idx
);
680 // the sizer cells may grow in both directions, not grow at all or only
681 // grow in one direction but not the other
683 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
684 void SetFlexibleDirection(int direction
) { m_flexDirection
= direction
; }
685 int GetFlexibleDirection() const { return m_flexDirection
; }
687 // note that the grow mode only applies to the direction which is not
689 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode
) { m_growMode
= mode
; }
690 wxFlexSizerGrowMode
GetNonFlexibleGrowMode() const { return m_growMode
; }
692 // Read-only access to the row heights and col widths arrays
693 const wxArrayInt
& GetRowHeights() const { return m_rowHeights
; }
694 const wxArrayInt
& GetColWidths() const { return m_colWidths
; }
697 virtual void RecalcSizes();
698 virtual wxSize
CalcMin();
701 void AdjustForFlexDirection();
702 void AdjustForGrowables(const wxSize
& sz
, const wxSize
& minsz
,
703 int nrows
, int ncols
);
705 // the heights/widths of all rows/columns
706 wxArrayInt m_rowHeights
,
709 // indices of the growable columns and rows
710 wxArrayInt m_growableRows
,
713 // proportion values of the corresponding growable rows and columns
714 wxArrayInt m_growableRowsProportions
,
715 m_growableColsProportions
;
717 // parameters describing whether the growable cells should be resized in
718 // both directions or only one
720 wxFlexSizerGrowMode m_growMode
;
722 // saves CalcMin result to optimize RecalcSizes
723 wxSize m_calculatedMinSize
;
726 DECLARE_CLASS(wxFlexGridSizer
)
727 DECLARE_NO_COPY_CLASS(wxFlexGridSizer
)
730 //---------------------------------------------------------------------------
732 //---------------------------------------------------------------------------
734 class WXDLLEXPORT wxBoxSizer
: public wxSizer
737 wxBoxSizer( int orient
);
742 int GetOrientation() const
745 void SetOrientation(int orient
)
746 { m_orient
= orient
; }
757 DECLARE_CLASS(wxBoxSizer
)
760 //---------------------------------------------------------------------------
762 //---------------------------------------------------------------------------
766 class WXDLLEXPORT wxStaticBox
;
768 class WXDLLEXPORT wxStaticBoxSizer
: public wxBoxSizer
771 wxStaticBoxSizer(wxStaticBox
*box
, int orient
);
772 wxStaticBoxSizer(int orient
, wxWindow
*win
, const wxString
& label
= wxEmptyString
);
773 virtual ~wxStaticBoxSizer();
778 wxStaticBox
*GetStaticBox() const
779 { return m_staticBox
; }
781 // override to hide/show the static box as well
782 virtual void ShowItems (bool show
);
784 virtual bool Detach( wxWindow
*window
);
785 virtual bool Detach( wxSizer
*sizer
) { return wxBoxSizer
::Detach(sizer
); }
786 virtual bool Detach( int index
) { return wxBoxSizer
::Detach(index
); }
789 wxStaticBox
*m_staticBox
;
792 DECLARE_CLASS(wxStaticBoxSizer
)
793 DECLARE_NO_COPY_CLASS(wxStaticBoxSizer
)
796 #endif // wxUSE_STATBOX
800 class WXDLLEXPORT wxStdDialogButtonSizer
: public wxBoxSizer
803 // Constructor just creates a new wxBoxSizer, not much else.
804 // Box sizer orientation is automatically determined here:
805 // vertical for PDAs, horizontal for everything else?
806 wxStdDialogButtonSizer();
808 // Checks button ID against system IDs and sets one of the pointers below
809 // to this button. Does not do any sizer-related things here.
810 void AddButton(wxButton
*button
);
812 // Use these if no standard ID can/should be used
813 void SetAffirmativeButton( wxButton
*button
);
814 void SetNegativeButton( wxButton
*button
);
815 void SetCancelButton( wxButton
*button
);
817 // All platform-specific code here, checks which buttons exist and add
818 // them to the sizer accordingly.
819 // Note - one potential hack on Mac we could use here,
820 // if m_buttonAffirmative is wxID_SAVE then ensure wxID_SAVE
821 // is set to _("Save") and m_buttonNegative is set to _("Don't Save")
822 // I wouldn't add any other hacks like that into here,
823 // but this one I can see being useful.
826 wxButton
*GetAffirmativeButton() const { return m_buttonAffirmative
; }
827 wxButton
*GetApplyButton() const { return m_buttonApply
; }
828 wxButton
*GetNegativeButton() const { return m_buttonNegative
; }
829 wxButton
*GetCancelButton() const { return m_buttonCancel
; }
830 wxButton
*GetHelpButton() const { return m_buttonHelp
; }
833 wxButton
*m_buttonAffirmative
; // wxID_OK, wxID_YES, wxID_SAVE go here
834 wxButton
*m_buttonApply
;
835 wxButton
*m_buttonNegative
; // wxID_NO
836 wxButton
*m_buttonCancel
;
837 wxButton
*m_buttonHelp
;
840 DECLARE_CLASS(wxStdDialogButtonSizer
)
841 DECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer
)
844 #endif // wxUSE_BUTTON
846 #if WXWIN_COMPATIBILITY_2_4
847 // NB: wxBookCtrlSizer and wxNotebookSizer are deprecated, they
848 // don't do anything. wxBookCtrlBase::DoGetBestSize does the job now.
850 // ----------------------------------------------------------------------------
852 // ----------------------------------------------------------------------------
856 // this sizer works with wxNotebook/wxListbook/... and sizes the control to
858 class WXDLLEXPORT wxBookCtrlBase
;
860 class WXDLLEXPORT wxBookCtrlSizer
: public wxSizer
863 #if WXWIN_COMPATIBILITY_2_6
864 wxDEPRECATED( wxBookCtrlSizer(wxBookCtrlBase
*bookctrl
) );
865 #endif // WXWIN_COMPATIBILITY_2_6
867 wxBookCtrlBase
*GetControl() const { return m_bookctrl
; }
869 virtual void RecalcSizes();
870 virtual wxSize
CalcMin();
873 // this protected ctor lets us mark the real one above as deprecated
874 // and still have warning-free build of the library itself:
877 wxBookCtrlBase
*m_bookctrl
;
880 DECLARE_CLASS(wxBookCtrlSizer
)
881 DECLARE_NO_COPY_CLASS(wxBookCtrlSizer
)
887 // before wxBookCtrlBase we only had wxNotebookSizer, keep it for backwards
889 class WXDLLEXPORT wxNotebook
;
891 class WXDLLEXPORT wxNotebookSizer
: public wxBookCtrlSizer
894 #if WXWIN_COMPATIBILITY_2_6
895 wxDEPRECATED( wxNotebookSizer(wxNotebook
*nb
) );
896 #endif // WXWIN_COMPATIBILITY_2_6
898 wxNotebook
*GetNotebook() const { return (wxNotebook
*)m_bookctrl
; }
901 DECLARE_CLASS(wxNotebookSizer
)
902 DECLARE_NO_COPY_CLASS(wxNotebookSizer
)
905 #endif // wxUSE_NOTEBOOK
907 #endif // wxUSE_BOOKCTRL
909 #endif // WXWIN_COMPATIBILITY_2_4
911 // ----------------------------------------------------------------------------
912 // inline functions implementation
913 // ----------------------------------------------------------------------------
916 wxSizer
::Add( wxSizerItem
*item
)
918 return Insert( m_children
.GetCount(), item
);
922 wxSizer
::Add( wxWindow
*window
, int proportion
, int flag
, int border
, wxObject
* userData
)
924 return Add( new wxSizerItem( window
, proportion
, flag
, border
, userData
) );
928 wxSizer
::Add( wxSizer
*sizer
, int proportion
, int flag
, int border
, wxObject
* userData
)
930 return Add( new wxSizerItem( sizer
, proportion
, flag
, border
, userData
) );
934 wxSizer
::Add( int width
, int height
, int proportion
, int flag
, int border
, wxObject
* userData
)
936 return Add( new wxSizerItem( width
, height
, proportion
, flag
, border
, userData
) );
940 wxSizer
::Add( wxWindow
*window
, const wxSizerFlags
& flags
)
942 return Add( new wxSizerItem(window
, flags
) );
946 wxSizer
::Add( wxSizer
*sizer
, const wxSizerFlags
& flags
)
948 return Add( new wxSizerItem(sizer
, flags
) );
952 wxSizer
::AddSpacer(int size
)
954 return Add(size
, size
);
958 wxSizer
::AddStretchSpacer(int prop
)
960 return Add(0, 0, prop
);
964 wxSizer
::Prepend( wxSizerItem
*item
)
966 return Insert( 0, item
);
970 wxSizer
::Prepend( wxWindow
*window
, int proportion
, int flag
, int border
, wxObject
* userData
)
972 return Prepend( new wxSizerItem( window
, proportion
, flag
, border
, userData
) );
976 wxSizer
::Prepend( wxSizer
*sizer
, int proportion
, int flag
, int border
, wxObject
* userData
)
978 return Prepend( new wxSizerItem( sizer
, proportion
, flag
, border
, userData
) );
982 wxSizer
::Prepend( int width
, int height
, int proportion
, int flag
, int border
, wxObject
* userData
)
984 return Prepend( new wxSizerItem( width
, height
, proportion
, flag
, border
, userData
) );
988 wxSizer
::PrependSpacer(int size
)
990 return Prepend(size
, size
);
994 wxSizer
::PrependStretchSpacer(int prop
)
996 return Prepend(0, 0, prop
);
1000 wxSizer
::Prepend( wxWindow
*window
, const wxSizerFlags
& flags
)
1002 return Prepend( new wxSizerItem(window
, flags
) );
1006 wxSizer
::Prepend( wxSizer
*sizer
, const wxSizerFlags
& flags
)
1008 return Prepend( new wxSizerItem(sizer
, flags
) );
1012 wxSizer
::Insert( size_t index
,
1017 wxObject
* userData
)
1019 return Insert( index
, new wxSizerItem( window
, proportion
, flag
, border
, userData
) );
1023 wxSizer
::Insert( size_t index
,
1028 wxObject
* userData
)
1030 return Insert( index
, new wxSizerItem( sizer
, proportion
, flag
, border
, userData
) );
1034 wxSizer
::Insert( size_t index
,
1040 wxObject
* userData
)
1042 return Insert( index
, new wxSizerItem( width
, height
, proportion
, flag
, border
, userData
) );
1046 wxSizer
::Insert( size_t index
, wxWindow
*window
, const wxSizerFlags
& flags
)
1048 return Insert( index
, new wxSizerItem(window
, flags
) );
1052 wxSizer
::Insert( size_t index
, wxSizer
*sizer
, const wxSizerFlags
& flags
)
1054 return Insert( index
, new wxSizerItem(sizer
, flags
) );
1058 wxSizer
::InsertSpacer(size_t index
, int size
)
1060 return Insert(index
, size
, size
);
1064 wxSizer
::InsertStretchSpacer(size_t index
, int prop
)
1066 return Insert(index
, 0, 0, prop
);
1070 #endif // __WXSIZER_H__