1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: provide wxSizer class for layout
4 // Author: Robert Roebling and Robin Dunn
5 // Modified by: Ron Lee
8 // Copyright: (c) Robin Dunn, Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
16 #pragma interface "sizer.h"
21 #include "wx/window.h"
23 #include "wx/dialog.h"
25 //---------------------------------------------------------------------------
27 //---------------------------------------------------------------------------
33 //---------------------------------------------------------------------------
35 //---------------------------------------------------------------------------
37 class WXDLLEXPORT wxSizerItem
: public wxObject
41 wxSizerItem( int width
,
49 wxSizerItem( wxWindow
*window
,
56 wxSizerItem( wxSizer
*sizer
,
63 virtual ~wxSizerItem();
65 virtual void DeleteWindows();
67 // Enable deleting the SizerItem without destroying the contained sizer.
71 virtual wxSize
GetSize() const;
72 virtual wxSize
CalcMin();
73 virtual void SetDimension( wxPoint pos
, wxSize size
);
75 wxSize
GetMinSize() const
77 void SetInitSize( int x
, int y
)
78 { m_minSize
.x
= x
; m_minSize
.y
= y
; }
80 void SetRatio( int width
, int height
)
81 // if either of dimensions is zero, ratio is assumed to be 1
82 // to avoid "divide by zero" errors
83 { m_ratio
= (width
&& height
) ? ((float) width
/ (float) height
) : 1; }
84 void SetRatio( wxSize size
)
85 { m_ratio
= (size
.x
&& size
.y
) ? ((float) size
.x
/ (float) size
.y
) : 1; }
86 void SetRatio( float ratio
)
88 float GetRatio() const
91 bool IsWindow() const;
93 bool IsSpacer() const;
95 // Deprecated in 2.6, use {G,S}etProportion instead.
96 wxDEPRECATED( void SetOption( int option
) );
97 wxDEPRECATED( int GetOption() const );
99 void SetProportion( int proportion
)
100 { m_proportion
= proportion
; }
101 int GetProportion() const
102 { return m_proportion
; }
103 void SetFlag( int flag
)
107 void SetBorder( int border
)
108 { m_border
= border
; }
109 int GetBorder() const
112 wxWindow
*GetWindow() const
114 void SetWindow( wxWindow
*window
)
115 { m_window
= window
; }
116 wxSizer
*GetSizer() const
118 void SetSizer( wxSizer
*sizer
)
120 const wxSize
&GetSpacer() const
122 void SetSpacer( const wxSize
&size
)
123 { m_size
= size
; m_minSize
= size
; }
125 void Show ( bool show
);
129 wxObject
* GetUserData() const
130 { return m_userData
; }
131 wxPoint
GetPosition() const
144 // If true, then this item is considered in the layout
145 // calculation. Otherwise, it is skipped over.
148 // Aspect ratio can always be calculated from m_size,
149 // but this would cause precision loss when the window
150 // is shrunk. It is safer to preserve the initial value.
153 wxObject
*m_userData
;
156 DECLARE_CLASS(wxSizerItem
)
157 DECLARE_NO_COPY_CLASS(wxSizerItem
)
160 WX_DECLARE_EXPORTED_LIST( wxSizerItem
, wxSizerItemList
);
163 //---------------------------------------------------------------------------
165 //---------------------------------------------------------------------------
167 class WXDLLEXPORT wxSizer
: public wxObject
, public wxClientDataContainer
173 /* These should be called Append() really. */
174 virtual void Add( wxWindow
*window
,
178 wxObject
* userData
= NULL
);
179 virtual void Add( wxSizer
*sizer
,
183 wxObject
* userData
= NULL
);
184 virtual void Add( int width
,
189 wxObject
* userData
= NULL
);
190 virtual void Add( wxSizerItem
*item
);
192 virtual void Insert( size_t index
,
197 wxObject
* userData
= NULL
);
198 virtual void Insert( size_t index
,
203 wxObject
* userData
= NULL
);
204 virtual void Insert( size_t index
,
210 wxObject
* userData
= NULL
);
211 virtual void Insert( size_t index
,
214 virtual void Prepend( wxWindow
*window
,
218 wxObject
* userData
= NULL
);
219 virtual void Prepend( wxSizer
*sizer
,
223 wxObject
* userData
= NULL
);
224 virtual void Prepend( int width
,
229 wxObject
* userData
= NULL
);
230 virtual void Prepend( wxSizerItem
*item
);
232 // Deprecated in 2.6 since historically it does not delete the window,
233 // use Detach instead.
234 wxDEPRECATED( virtual bool Remove( wxWindow
*window
) );
235 virtual bool Remove( wxSizer
*sizer
);
236 virtual bool Remove( int index
);
238 virtual bool Detach( wxWindow
*window
);
239 virtual bool Detach( wxSizer
*sizer
);
240 virtual bool Detach( int index
);
242 virtual void Clear( bool delete_windows
= false );
243 virtual void DeleteWindows();
245 void SetMinSize( int width
, int height
)
246 { DoSetMinSize( width
, height
); }
247 void SetMinSize( wxSize size
)
248 { DoSetMinSize( size
.x
, size
.y
); }
250 /* Searches recursively */
251 bool SetItemMinSize( wxWindow
*window
, int width
, int height
)
252 { return DoSetItemMinSize( window
, width
, height
); }
253 bool SetItemMinSize( wxWindow
*window
, wxSize size
)
254 { return DoSetItemMinSize( window
, size
.x
, size
.y
); }
256 /* Searches recursively */
257 bool SetItemMinSize( wxSizer
*sizer
, int width
, int height
)
258 { return DoSetItemMinSize( sizer
, width
, height
); }
259 bool SetItemMinSize( wxSizer
*sizer
, wxSize size
)
260 { return DoSetItemMinSize( sizer
, size
.x
, size
.y
); }
262 bool SetItemMinSize( size_t index
, int width
, int height
)
263 { return DoSetItemMinSize( index
, width
, height
); }
264 bool SetItemMinSize( size_t index
, wxSize size
)
265 { return DoSetItemMinSize( index
, size
.x
, size
.y
); }
267 wxSize
GetSize() const
269 wxPoint
GetPosition() const
270 { return m_position
; }
272 /* Calculate the minimal size or return m_minSize if bigger. */
275 virtual void RecalcSizes() = 0;
276 virtual wxSize
CalcMin() = 0;
278 virtual void Layout();
280 wxSize
Fit( wxWindow
*window
);
281 void FitInside( wxWindow
*window
);
282 void SetSizeHints( wxWindow
*window
);
283 void SetVirtualSizeHints( wxWindow
*window
);
285 wxSizerItemList
& GetChildren()
286 { return m_children
; }
288 void SetDimension( int x
, int y
, int width
, int height
);
290 // Manage whether individual scene items are considered
291 // in the layout calculations or not.
292 void Show( wxWindow
*window
, bool show
= true );
293 void Show( wxSizer
*sizer
, bool show
= true );
294 void Show( size_t index
, bool show
= true );
296 void Hide( wxSizer
*sizer
)
297 { Show( sizer
, false ); }
298 void Hide( wxWindow
*window
)
299 { Show( window
, false ); }
300 void Hide( size_t index
)
301 { Show( index
, false ); }
303 bool IsShown( wxWindow
*window
) const;
304 bool IsShown( wxSizer
*sizer
) const;
305 bool IsShown( size_t index
) const;
307 // Recursively call wxWindow::Show () on all sizer items.
308 void ShowItems (bool show
);
314 wxSizerItemList m_children
;
316 wxSize
GetMaxWindowSize( wxWindow
*window
) const;
317 wxSize
GetMinWindowSize( wxWindow
*window
);
318 wxSize
GetMaxClientSize( wxWindow
*window
) const;
319 wxSize
GetMinClientSize( wxWindow
*window
);
320 wxSize
FitSize( wxWindow
*window
);
321 wxSize
VirtualFitSize( wxWindow
*window
);
323 virtual void DoSetMinSize( int width
, int height
);
324 virtual bool DoSetItemMinSize( wxWindow
*window
, int width
, int height
);
325 virtual bool DoSetItemMinSize( wxSizer
*sizer
, int width
, int height
);
326 virtual bool DoSetItemMinSize( size_t index
, int width
, int height
);
329 DECLARE_CLASS(wxSizer
)
332 //---------------------------------------------------------------------------
334 //---------------------------------------------------------------------------
336 class WXDLLEXPORT wxGridSizer
: public wxSizer
339 wxGridSizer( int rows
, int cols
, int vgap
, int hgap
);
340 wxGridSizer( int cols
, int vgap
= 0, int hgap
= 0 );
342 virtual void RecalcSizes();
343 virtual wxSize
CalcMin();
345 void SetCols( int cols
) { m_cols
= cols
; }
346 void SetRows( int rows
) { m_rows
= rows
; }
347 void SetVGap( int gap
) { m_vgap
= gap
; }
348 void SetHGap( int gap
) { m_hgap
= gap
; }
349 int GetCols() const { return m_cols
; }
350 int GetRows() const { return m_rows
; }
351 int GetVGap() const { return m_vgap
; }
352 int GetHGap() const { return m_hgap
; }
360 // return the number of total items and the number of columns and rows
361 int CalcRowsCols(int& rows
, int& cols
) const;
363 void SetItemBounds( wxSizerItem
*item
, int x
, int y
, int w
, int h
);
366 DECLARE_CLASS(wxGridSizer
)
369 //---------------------------------------------------------------------------
371 //---------------------------------------------------------------------------
373 // the bevaiour for resizing wxFlexGridSizer cells in the "non-flexible"
375 enum wxFlexSizerGrowMode
377 // don't resize the cells in non-flexible direction at all
378 wxFLEX_GROWMODE_NONE
,
380 // uniformly resize only the specified ones (default)
381 wxFLEX_GROWMODE_SPECIFIED
,
383 // uniformly resize all cells
387 class WXDLLEXPORT wxFlexGridSizer
: public wxGridSizer
391 wxFlexGridSizer( int rows
, int cols
, int vgap
, int hgap
);
392 wxFlexGridSizer( int cols
, int vgap
= 0, int hgap
= 0 );
393 virtual ~wxFlexGridSizer();
396 // set the rows/columns which will grow (the others will remain of the
397 // constant initial size)
398 void AddGrowableRow( size_t idx
, int proportion
= 0 );
399 void RemoveGrowableRow( size_t idx
);
400 void AddGrowableCol( size_t idx
, int proportion
= 0 );
401 void RemoveGrowableCol( size_t idx
);
404 // the sizer cells may grow in both directions, not grow at all or only
405 // grow in one direction but not the other
407 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
408 void SetFlexibleDirection(int direction
) { m_flexDirection
= direction
; }
409 int GetFlexibleDirection() const { return m_flexDirection
; }
411 // note that the grow mode only applies to the direction which is not
413 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode
) { m_growMode
= mode
; }
414 wxFlexSizerGrowMode
GetNonFlexibleGrowMode() const { return m_growMode
; }
418 virtual void RecalcSizes();
419 virtual wxSize
CalcMin();
422 void AdjustForFlexDirection();
423 void AdjustForGrowables(const wxSize
& sz
, const wxSize
& minsz
,
424 int nrows
, int ncols
);
426 // the heights/widths of all rows/columns
427 wxArrayInt m_rowHeights
,
430 // indices of the growable columns and rows
431 wxArrayInt m_growableRows
,
434 // proportion values of the corresponding growable rows and columns
435 wxArrayInt m_growableRowsProportions
,
436 m_growableColsProportions
;
438 // parameters describing whether the growable cells should be resized in
439 // both directions or only one
441 wxFlexSizerGrowMode m_growMode
;
444 DECLARE_CLASS(wxFlexGridSizer
)
445 DECLARE_NO_COPY_CLASS(wxFlexGridSizer
)
448 //---------------------------------------------------------------------------
450 //---------------------------------------------------------------------------
452 class WXDLLEXPORT wxBoxSizer
: public wxSizer
455 wxBoxSizer( int orient
);
460 int GetOrientation() const
463 void SetOrientation(int orient
)
464 { m_orient
= orient
; }
475 DECLARE_CLASS(wxBoxSizer
)
478 //---------------------------------------------------------------------------
480 //---------------------------------------------------------------------------
484 class WXDLLEXPORT wxStaticBox
;
486 class WXDLLEXPORT wxStaticBoxSizer
: public wxBoxSizer
489 wxStaticBoxSizer( wxStaticBox
*box
, int orient
);
494 wxStaticBox
*GetStaticBox() const
495 { return m_staticBox
; }
498 wxStaticBox
*m_staticBox
;
501 DECLARE_CLASS(wxStaticBoxSizer
)
502 DECLARE_NO_COPY_CLASS(wxStaticBoxSizer
)
505 #endif // wxUSE_STATBOX
507 // ----------------------------------------------------------------------------
509 // ----------------------------------------------------------------------------
513 // this sizer works with wxNotebook/wxListbook/... and sizes the control to
515 class WXDLLEXPORT wxBookCtrl
;
517 class WXDLLEXPORT wxBookCtrlSizer
: public wxSizer
520 wxBookCtrlSizer(wxBookCtrl
*bookctrl
);
522 virtual void RecalcSizes();
523 virtual wxSize
CalcMin();
525 wxBookCtrl
*GetControl() const { return m_bookctrl
; }
528 wxBookCtrl
*m_bookctrl
;
531 DECLARE_CLASS(wxBookCtrlSizer
)
532 DECLARE_NO_COPY_CLASS(wxBookCtrlSizer
)
538 // before wxBookCtrl we only had wxNotebookSizer, keep it for backwards
540 class WXDLLEXPORT wxNotebook
;
542 class WXDLLEXPORT wxNotebookSizer
: public wxBookCtrlSizer
545 wxNotebookSizer(wxNotebook
*nb
);
547 wxNotebook
*GetNotebook() const { return (wxNotebook
*)m_bookctrl
; }
550 DECLARE_CLASS(wxNotebookSizer
)
551 DECLARE_NO_COPY_CLASS(wxNotebookSizer
)
554 #endif // wxUSE_NOTEBOOK
556 #endif // wxUSE_BOOKCTRL
558 #endif // __WXSIZER_H__