]> git.saurik.com Git - wxWidgets.git/blame - include/wx/sizer.h
Commit wxComboCtrl clipping patch from J. Salli
[wxWidgets.git] / include / wx / sizer.h
CommitLineData
5279a24d
RR
1/////////////////////////////////////////////////////////////////////////////
2// Name: sizer.h
a4ab8ed5 3// Purpose: provide wxSizer class for layout
5279a24d 4// Author: Robert Roebling and Robin Dunn
5f813ad6 5// Modified by: Ron Lee, Vadim Zeitlin (wxSizerFlags)
0c0d686f 6// Created:
5279a24d 7// RCS-ID: $Id$
a4ab8ed5 8// Copyright: (c) Robin Dunn, Robert Roebling
65571936 9// Licence: wxWindows licence
5279a24d
RR
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef __WXSIZER_H__
13#define __WXSIZER_H__
14
5279a24d
RR
15#include "wx/defs.h"
16
acf2ac37 17#include "wx/button.h"
5279a24d
RR
18#include "wx/window.h"
19#include "wx/frame.h"
20#include "wx/dialog.h"
21
22//---------------------------------------------------------------------------
23// classes
24//---------------------------------------------------------------------------
25
446e5259
VS
26class WXDLLEXPORT wxSizerItem;
27class WXDLLEXPORT wxSizer;
28class WXDLLEXPORT wxBoxSizer;
5279a24d 29
5f813ad6
VZ
30
31// ----------------------------------------------------------------------------
32// wxSizerFlags: flags used for an item in the sizer
33// ----------------------------------------------------------------------------
34
35class WXDLLEXPORT wxSizerFlags
36{
37public:
38 // construct the flags object initialized with the given proportion (0 by
39 // default)
40 wxSizerFlags(int proportion = 0) : m_proportion(proportion)
41 {
42 m_flags = 0;
43 m_borderInPixels = 0;
44 }
45
46 // setters for all sizer flags, they all return the object itself so that
47 // calls to them can be chained
48
49 wxSizerFlags& Proportion(int proportion)
50 {
51 m_proportion = proportion;
52 return *this;
53 }
54
55 wxSizerFlags& Align(int alignment) // combination of wxAlignment values
56 {
ddfcd9aa 57 m_flags &= ~wxALIGN_MASK;
5f813ad6
VZ
58 m_flags |= alignment;
59
60 return *this;
61 }
62
00dc67b8
VZ
63 wxSizerFlags& Expand()
64 {
65 m_flags |= wxEXPAND;
66 return *this;
67 }
68
5f813ad6 69 // some shortcuts for Align()
5f813ad6
VZ
70 wxSizerFlags& Centre() { return Align(wxCENTRE); }
71 wxSizerFlags& Center() { return Centre(); }
e72ac082
VZ
72 wxSizerFlags& Left() { return Align(wxALIGN_LEFT); }
73 wxSizerFlags& Right() { return Align(wxALIGN_RIGHT); }
5f813ad6
VZ
74
75
76 wxSizerFlags& Border(int direction, int borderInPixels)
77 {
78 m_flags &= ~wxALL;
79 m_flags |= direction;
80
81 m_borderInPixels = borderInPixels;
82
83 return *this;
84 }
85
86 wxSizerFlags& Border(int direction = wxALL)
87 {
88 // FIXME: default border size shouldn't be hardcoded
92b0cd9e
VZ
89#ifdef __SMARTPHONE__
90 // no borders by default on limited size screen
91 wxUnusedVar(direction);
92
93 return *this;
94#else
5f813ad6 95 return Border(direction, 5);
92b0cd9e 96#endif
5f813ad6
VZ
97 }
98
99
100 // accessors for wxSizer only
101 int GetProportion() const { return m_proportion; }
102 int GetFlags() const { return m_flags; }
103 int GetBorderInPixels() const { return m_borderInPixels; }
104
105private:
106 int m_proportion;
107 int m_flags;
108 int m_borderInPixels;
109};
110
111
50c06297
VZ
112// ----------------------------------------------------------------------------
113// wxSizerSpacer: used by wxSizerItem to represent a spacer
114// ----------------------------------------------------------------------------
5279a24d 115
50c06297 116class WXDLLEXPORT wxSizerSpacer
5279a24d
RR
117{
118public:
50c06297 119 wxSizerSpacer(const wxSize& size) : m_size(size), m_isShown(true) { }
5f813ad6 120
50c06297
VZ
121 void SetSize(const wxSize& size) { m_size = size; }
122 const wxSize& GetSize() const { return m_size; }
5f813ad6 123
50c06297
VZ
124 void Show(bool show) { m_isShown = show; }
125 bool IsShown() const { return m_isShown; }
5f813ad6 126
50c06297
VZ
127private:
128 // the size, in pixel
129 wxSize m_size;
df5ddbca 130
50c06297
VZ
131 // is the spacer currently shown?
132 bool m_isShown;
133};
134
135// ----------------------------------------------------------------------------
136// wxSizerItem
137// ----------------------------------------------------------------------------
138
139class WXDLLEXPORT wxSizerItem : public wxObject
140{
141public:
df5ddbca 142 // window
12a3f227
RL
143 wxSizerItem( wxWindow *window,
144 int proportion,
145 int flag,
146 int border,
147 wxObject* userData );
df5ddbca 148
50c06297
VZ
149 // window with flags
150 wxSizerItem(wxWindow *window, const wxSizerFlags& flags)
151 {
152 Init(flags);
153
154 SetWindow(window);
155 }
156
df5ddbca 157 // subsizer
12a3f227
RL
158 wxSizerItem( wxSizer *sizer,
159 int proportion,
160 int flag,
161 int border,
162 wxObject* userData );
df5ddbca 163
50c06297
VZ
164 // sizer with flags
165 wxSizerItem(wxSizer *sizer, const wxSizerFlags& flags)
166 {
167 Init(flags);
168
169 SetSizer(sizer);
170 }
171
5f813ad6
VZ
172 // spacer
173 wxSizerItem( int width,
174 int height,
175 int proportion,
176 int flag,
177 int border,
178 wxObject* userData);
179
50c06297
VZ
180 // spacer with flags
181 wxSizerItem(int width, int height, const wxSizerFlags& flags)
182 {
183 Init(flags);
184
185 SetSpacer(width, height);
186 }
187
20b35a69
RD
188 wxSizerItem();
189 virtual ~wxSizerItem();
dc259b79 190
84f7908b 191 virtual void DeleteWindows();
df5ddbca 192
96fdbb60 193 // Enable deleting the SizerItem without destroying the contained sizer.
50c06297 194 void DetachSizer() { m_sizer = NULL; }
96fdbb60 195
9cbee2ce 196 virtual wxSize GetSize() const;
df5ddbca 197 virtual wxSize CalcMin();
fbfb8bcc 198 virtual void SetDimension( const wxPoint& pos, const wxSize& size );
df5ddbca 199
9cbee2ce 200 wxSize GetMinSize() const
df5ddbca 201 { return m_minSize; }
ba763a45
RD
202 wxSize GetMinSizeWithBorder() const;
203
1eba2193 204 void SetMinSize(const wxSize& size)
50c06297
VZ
205 {
206 if ( IsWindow() )
207 m_window->SetMinSize(size);
208 m_minSize = size;
209 }
1eba2193 210 void SetMinSize( int x, int y )
8b2bac62 211 { SetMinSize(wxSize(x, y)); }
12a3f227 212 void SetInitSize( int x, int y )
1eba2193 213 { SetMinSize(wxSize(x, y)); }
df5ddbca 214
50c06297
VZ
215 // if either of dimensions is zero, ratio is assumed to be 1
216 // to avoid "divide by zero" errors
217 void SetRatio(int width, int height)
df5ddbca 218 { m_ratio = (width && height) ? ((float) width / (float) height) : 1; }
50c06297
VZ
219 void SetRatio(const wxSize& size)
220 { SetRatio(size.x, size.y); }
221 void SetRatio(float ratio)
df5ddbca 222 { m_ratio = ratio; }
2aab8f16 223 float GetRatio() const
df5ddbca
RR
224 { return m_ratio; }
225
50c06297 226 virtual wxRect GetRect() { return m_rect; }
56eee37f 227
50c06297
VZ
228 bool IsWindow() const { return m_kind == Item_Window; }
229 bool IsSizer() const { return m_kind == Item_Sizer; }
230 bool IsSpacer() const { return m_kind == Item_Spacer; }
2aab8f16 231
6a9e54bd 232#if WXWIN_COMPATIBILITY_2_6
12a3f227
RL
233 // Deprecated in 2.6, use {G,S}etProportion instead.
234 wxDEPRECATED( void SetOption( int option ) );
235 wxDEPRECATED( int GetOption() const );
6a9e54bd 236#endif // WXWIN_COMPATIBILITY_2_6
12a3f227
RL
237
238 void SetProportion( int proportion )
239 { m_proportion = proportion; }
240 int GetProportion() const
241 { return m_proportion; }
df5ddbca
RR
242 void SetFlag( int flag )
243 { m_flag = flag; }
12a3f227
RL
244 int GetFlag() const
245 { return m_flag; }
df5ddbca
RR
246 void SetBorder( int border )
247 { m_border = border; }
12a3f227
RL
248 int GetBorder() const
249 { return m_border; }
df5ddbca
RR
250
251 wxWindow *GetWindow() const
50c06297 252 { return m_kind == Item_Window ? m_window : NULL; }
df5ddbca 253 wxSizer *GetSizer() const
50c06297
VZ
254 { return m_kind == Item_Sizer ? m_sizer : NULL; }
255 wxSize GetSpacer() const;
12a3f227 256
c86fd3a7
VZ
257 // this function behaves obviously for the windows and spacers but for the
258 // sizers it returns true if any sizer element is shown and only returns
259 // false if all of them are hidden
260 bool IsShown() const;
50c06297 261 void Show(bool show);
12a3f227 262
e8c1be04 263 void SetUserData(wxObject* userData)
1737dac2 264 { delete m_userData; m_userData = userData; }
9cbee2ce 265 wxObject* GetUserData() const
df5ddbca 266 { return m_userData; }
9cbee2ce 267 wxPoint GetPosition() const
df5ddbca 268 { return m_pos; }
0c0d686f 269
50c06297
VZ
270
271 // these functions do not free old sizer/spacer
272 void SetWindow(wxWindow *window);
273 void SetSizer(wxSizer *sizer);
274 void SetSpacer(const wxSize& size);
275 void SetSpacer(int width, int height) { SetSpacer(wxSize(width, height)); }
276
c62ac5b6 277protected:
5f813ad6 278 // common part of several ctors
50c06297 279 void Init() { m_userData = NULL; }
5f813ad6
VZ
280
281 // common part of ctors taking wxSizerFlags
282 void Init(const wxSizerFlags& flags);
283
f303d69f
VZ
284
285 // discriminated union: depending on m_kind one of the fields is valid
50c06297
VZ
286 enum
287 {
288 Item_None,
289 Item_Window,
290 Item_Sizer,
291 Item_Spacer,
292 Item_Max
293 } m_kind;
294 union
295 {
296 wxWindow *m_window;
297 wxSizer *m_sizer;
298 wxSizerSpacer *m_spacer;
299 };
5f813ad6 300
df5ddbca
RR
301 wxPoint m_pos;
302 wxSize m_minSize;
12a3f227 303 int m_proportion;
df5ddbca
RR
304 int m_border;
305 int m_flag;
2b5f62a0 306
50c06297
VZ
307 // on screen rectangle of this item (not including borders)
308 wxRect m_rect;
12a3f227
RL
309
310 // Aspect ratio can always be calculated from m_size,
311 // but this would cause precision loss when the window
312 // is shrunk. It is safer to preserve the initial value.
df5ddbca 313 float m_ratio;
2b5f62a0 314
df5ddbca 315 wxObject *m_userData;
2aab8f16 316
9cbee2ce 317private:
4393b50c 318 DECLARE_CLASS(wxSizerItem)
22f3361e 319 DECLARE_NO_COPY_CLASS(wxSizerItem)
c62ac5b6 320};
5279a24d 321
12a3f227
RL
322WX_DECLARE_EXPORTED_LIST( wxSizerItem, wxSizerItemList );
323
5f813ad6 324
5279a24d 325//---------------------------------------------------------------------------
3417c2cd 326// wxSizer
5279a24d
RR
327//---------------------------------------------------------------------------
328
2aab8f16 329class WXDLLEXPORT wxSizer: public wxObject, public wxClientDataContainer
5279a24d
RR
330{
331public:
f303d69f 332 wxSizer() { }
f6bcfd97
BP
333 ~wxSizer();
334
436ae7cf
VZ
335 // methods for adding elements to the sizer: there are Add/Insert/Prepend
336 // overloads for each of window/sizer/spacer/wxSizerItem
56eee37f
WS
337 inline wxSizerItem* Add( wxWindow *window,
338 int proportion = 0,
339 int flag = 0,
340 int border = 0,
341 wxObject* userData = NULL );
342 inline wxSizerItem* Add( wxSizer *sizer,
343 int proportion = 0,
344 int flag = 0,
345 int border = 0,
346 wxObject* userData = NULL );
347 inline wxSizerItem* Add( int width,
348 int height,
349 int proportion = 0,
350 int flag = 0,
351 int border = 0,
352 wxObject* userData = NULL );
353 inline wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags );
354 inline wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags );
355 inline wxSizerItem* Add( wxSizerItem *item );
356
357 inline wxSizerItem* AddSpacer(int size);
358 inline wxSizerItem* AddStretchSpacer(int prop = 1);
359
360 inline wxSizerItem* Insert( size_t index,
361 wxWindow *window,
362 int proportion = 0,
363 int flag = 0,
364 int border = 0,
365 wxObject* userData = NULL );
366 inline wxSizerItem* Insert( size_t index,
367 wxSizer *sizer,
368 int proportion = 0,
369 int flag = 0,
370 int border = 0,
371 wxObject* userData = NULL );
372 inline wxSizerItem* Insert( size_t index,
373 int width,
374 int height,
375 int proportion = 0,
376 int flag = 0,
377 int border = 0,
378 wxObject* userData = NULL );
379 inline wxSizerItem* Insert( size_t index,
380 wxWindow *window,
381 const wxSizerFlags& flags );
382 inline wxSizerItem* Insert( size_t index,
383 wxSizer *sizer,
384 const wxSizerFlags& flags );
385 virtual wxSizerItem* Insert( size_t index, wxSizerItem *item );
386
387 inline wxSizerItem* InsertSpacer(size_t index, int size);
388 inline wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
389
390 inline wxSizerItem* Prepend( wxWindow *window,
391 int proportion = 0,
392 int flag = 0,
393 int border = 0,
394 wxObject* userData = NULL );
395 inline wxSizerItem* Prepend( wxSizer *sizer,
396 int proportion = 0,
397 int flag = 0,
398 int border = 0,
399 wxObject* userData = NULL );
400 inline wxSizerItem* Prepend( int width,
401 int height,
402 int proportion = 0,
403 int flag = 0,
404 int border = 0,
405 wxObject* userData = NULL );
406 inline wxSizerItem* Prepend( wxWindow *window, const wxSizerFlags& flags );
407 inline wxSizerItem* Prepend( wxSizer *sizer, const wxSizerFlags& flags );
408 inline wxSizerItem* Prepend( wxSizerItem *item );
409
410 inline wxSizerItem* PrependSpacer(int size);
411 inline wxSizerItem* PrependStretchSpacer(int prop = 1);
8e32ea1c 412
749bb9f1 413
6a9e54bd 414#if WXWIN_COMPATIBILITY_2_6
12a3f227
RL
415 // Deprecated in 2.6 since historically it does not delete the window,
416 // use Detach instead.
417 wxDEPRECATED( virtual bool Remove( wxWindow *window ) );
6a9e54bd
WS
418#endif // WXWIN_COMPATIBILITY_2_6
419
f6bcfd97 420 virtual bool Remove( wxSizer *sizer );
e0d8fb45 421 virtual bool Remove( int index );
00976fe5 422
12a3f227 423 virtual bool Detach( wxWindow *window );
00976fe5 424 virtual bool Detach( wxSizer *sizer );
e0d8fb45 425 virtual bool Detach( int index );
00976fe5 426
eae0338f
RR
427 virtual bool Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive = false );
428 virtual bool Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive = false );
429 virtual bool Replace( size_t index, wxSizerItem *newitem );
430
e0d8fb45 431 virtual void Clear( bool delete_windows = false );
84f7908b 432 virtual void DeleteWindows();
f6bcfd97
BP
433
434 void SetMinSize( int width, int height )
435 { DoSetMinSize( width, height ); }
fbfb8bcc 436 void SetMinSize( const wxSize& size )
f6bcfd97 437 { DoSetMinSize( size.x, size.y ); }
1e6feb95 438
50c06297 439 // Searches recursively
f6bcfd97
BP
440 bool SetItemMinSize( wxWindow *window, int width, int height )
441 { return DoSetItemMinSize( window, width, height ); }
fbfb8bcc 442 bool SetItemMinSize( wxWindow *window, const wxSize& size )
f6bcfd97 443 { return DoSetItemMinSize( window, size.x, size.y ); }
1e6feb95 444
50c06297 445 // Searches recursively
f6bcfd97
BP
446 bool SetItemMinSize( wxSizer *sizer, int width, int height )
447 { return DoSetItemMinSize( sizer, width, height ); }
fbfb8bcc 448 bool SetItemMinSize( wxSizer *sizer, const wxSize& size )
f6bcfd97 449 { return DoSetItemMinSize( sizer, size.x, size.y ); }
1e6feb95 450
12a3f227
RL
451 bool SetItemMinSize( size_t index, int width, int height )
452 { return DoSetItemMinSize( index, width, height ); }
fbfb8bcc 453 bool SetItemMinSize( size_t index, const wxSize& size )
12a3f227 454 { return DoSetItemMinSize( index, size.x, size.y ); }
1e6feb95 455
9cbee2ce 456 wxSize GetSize() const
f6bcfd97 457 { return m_size; }
9cbee2ce 458 wxPoint GetPosition() const
f6bcfd97 459 { return m_position; }
1e6feb95 460
50c06297 461 // Calculate the minimal size or return m_minSize if bigger.
f6bcfd97
BP
462 wxSize GetMinSize();
463
464 virtual void RecalcSizes() = 0;
465 virtual wxSize CalcMin() = 0;
466
467 virtual void Layout();
468
e5251d4f 469 wxSize Fit( wxWindow *window );
566d84a7 470 void FitInside( wxWindow *window );
f6bcfd97 471 void SetSizeHints( wxWindow *window );
566d84a7 472 void SetVirtualSizeHints( wxWindow *window );
f6bcfd97 473
12a3f227 474 wxSizerItemList& GetChildren()
f6bcfd97
BP
475 { return m_children; }
476
477 void SetDimension( int x, int y, int width, int height );
0c0d686f 478
9f13661f
WS
479 wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
480 wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
481 wxSizerItem* GetItem( size_t index );
482
12a3f227 483 // Manage whether individual scene items are considered
2b5f62a0 484 // in the layout calculations or not.
8b2bac62
WS
485 bool Show( wxWindow *window, bool show = true, bool recursive = false );
486 bool Show( wxSizer *sizer, bool show = true, bool recursive = false );
487 bool Show( size_t index, bool show = true );
12a3f227 488
8b2bac62
WS
489 bool Hide( wxSizer *sizer, bool recursive = false )
490 { return Show( sizer, false, recursive ); }
491 bool Hide( wxWindow *window, bool recursive = false )
492 { return Show( window, false, recursive ); }
493 bool Hide( size_t index )
494 { return Show( index, false ); }
2b5f62a0 495
9cbee2ce
RL
496 bool IsShown( wxWindow *window ) const;
497 bool IsShown( wxSizer *sizer ) const;
498 bool IsShown( size_t index ) const;
dc259b79 499
2b5f62a0 500 // Recursively call wxWindow::Show () on all sizer items.
eb2a7883 501 virtual void ShowItems (bool show);
2b5f62a0 502
f303d69f 503 void Show(bool show) { ShowItems(show); }
50c06297 504
f6bcfd97 505protected:
12a3f227
RL
506 wxSize m_size;
507 wxSize m_minSize;
508 wxPoint m_position;
509 wxSizerItemList m_children;
f6bcfd97 510
9cbee2ce 511 wxSize GetMaxWindowSize( wxWindow *window ) const;
f6bcfd97 512 wxSize GetMinWindowSize( wxWindow *window );
9cbee2ce 513 wxSize GetMaxClientSize( wxWindow *window ) const;
566d84a7 514 wxSize GetMinClientSize( wxWindow *window );
65ba4113 515 wxSize FitSize( wxWindow *window );
566d84a7 516 wxSize VirtualFitSize( wxWindow *window );
65ba4113 517
f6bcfd97
BP
518 virtual void DoSetMinSize( int width, int height );
519 virtual bool DoSetItemMinSize( wxWindow *window, int width, int height );
520 virtual bool DoSetItemMinSize( wxSizer *sizer, int width, int height );
12a3f227 521 virtual bool DoSetItemMinSize( size_t index, int width, int height );
1e6feb95 522
9cbee2ce 523private:
4393b50c 524 DECLARE_CLASS(wxSizer)
f6bcfd97 525};
c62ac5b6 526
f6bcfd97
BP
527//---------------------------------------------------------------------------
528// wxGridSizer
529//---------------------------------------------------------------------------
0c0d686f 530
f6bcfd97
BP
531class WXDLLEXPORT wxGridSizer: public wxSizer
532{
533public:
534 wxGridSizer( int rows, int cols, int vgap, int hgap );
535 wxGridSizer( int cols, int vgap = 0, int hgap = 0 );
1e6feb95 536
5d76f462
VZ
537 virtual void RecalcSizes();
538 virtual wxSize CalcMin();
f6bcfd97
BP
539
540 void SetCols( int cols ) { m_cols = cols; }
541 void SetRows( int rows ) { m_rows = rows; }
542 void SetVGap( int gap ) { m_vgap = gap; }
543 void SetHGap( int gap ) { m_hgap = gap; }
9cbee2ce
RL
544 int GetCols() const { return m_cols; }
545 int GetRows() const { return m_rows; }
546 int GetVGap() const { return m_vgap; }
547 int GetHGap() const { return m_hgap; }
1e6feb95 548
f6bcfd97
BP
549protected:
550 int m_rows;
551 int m_cols;
552 int m_vgap;
553 int m_hgap;
1e6feb95 554
0ca5105b
VZ
555 // return the number of total items and the number of columns and rows
556 int CalcRowsCols(int& rows, int& cols) const;
557
f6bcfd97 558 void SetItemBounds( wxSizerItem *item, int x, int y, int w, int h );
1e6feb95 559
9cbee2ce 560private:
4393b50c 561 DECLARE_CLASS(wxGridSizer)
f6bcfd97 562};
5279a24d 563
f6bcfd97
BP
564//---------------------------------------------------------------------------
565// wxFlexGridSizer
566//---------------------------------------------------------------------------
0c0d686f 567
5d76f462
VZ
568// the bevaiour for resizing wxFlexGridSizer cells in the "non-flexible"
569// direction
570enum wxFlexSizerGrowMode
571{
572 // don't resize the cells in non-flexible direction at all
573 wxFLEX_GROWMODE_NONE,
574
575 // uniformly resize only the specified ones (default)
576 wxFLEX_GROWMODE_SPECIFIED,
577
578 // uniformly resize all cells
579 wxFLEX_GROWMODE_ALL
580};
581
f6bcfd97
BP
582class WXDLLEXPORT wxFlexGridSizer: public wxGridSizer
583{
584public:
5d76f462 585 // ctors/dtor
f6bcfd97
BP
586 wxFlexGridSizer( int rows, int cols, int vgap, int hgap );
587 wxFlexGridSizer( int cols, int vgap = 0, int hgap = 0 );
5d76f462 588 virtual ~wxFlexGridSizer();
1e6feb95 589
1e6feb95 590
5d76f462
VZ
591 // set the rows/columns which will grow (the others will remain of the
592 // constant initial size)
e8800dcf 593 void AddGrowableRow( size_t idx, int proportion = 0 );
f6bcfd97 594 void RemoveGrowableRow( size_t idx );
e8800dcf 595 void AddGrowableCol( size_t idx, int proportion = 0 );
f6bcfd97 596 void RemoveGrowableCol( size_t idx );
0c0d686f 597
1e6feb95 598
5d76f462
VZ
599 // the sizer cells may grow in both directions, not grow at all or only
600 // grow in one direction but not the other
601
602 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
603 void SetFlexibleDirection(int direction) { m_flexDirection = direction; }
604 int GetFlexibleDirection() const { return m_flexDirection; }
605
606 // note that the grow mode only applies to the direction which is not
607 // flexible
608 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) { m_growMode = mode; }
609 wxFlexSizerGrowMode GetNonFlexibleGrowMode() const { return m_growMode; }
610
fc1fcd0e
RD
611 // Read-only access to the row heights and col widths arrays
612 const wxArrayInt& GetRowHeights() const { return m_rowHeights; }
613 const wxArrayInt& GetColWidths() const { return m_colWidths; }
8b2bac62 614
5d76f462
VZ
615 // implementation
616 virtual void RecalcSizes();
617 virtual wxSize CalcMin();
618
619protected:
20b35a69
RD
620 void AdjustForFlexDirection();
621 void AdjustForGrowables(const wxSize& sz, const wxSize& minsz,
622 int nrows, int ncols);
8b2bac62 623
5d76f462
VZ
624 // the heights/widths of all rows/columns
625 wxArrayInt m_rowHeights,
626 m_colWidths;
627
628 // indices of the growable columns and rows
629 wxArrayInt m_growableRows,
630 m_growableCols;
631
e8800dcf
VZ
632 // proportion values of the corresponding growable rows and columns
633 wxArrayInt m_growableRowsProportions,
634 m_growableColsProportions;
635
5d76f462
VZ
636 // parameters describing whether the growable cells should be resized in
637 // both directions or only one
638 int m_flexDirection;
639 wxFlexSizerGrowMode m_growMode;
1e6feb95 640
ba763a45
RD
641 // saves CalcMin result to optimize RecalcSizes
642 wxSize m_calculatedMinSize;
643
9cbee2ce 644private:
4393b50c 645 DECLARE_CLASS(wxFlexGridSizer)
22f3361e 646 DECLARE_NO_COPY_CLASS(wxFlexGridSizer)
c62ac5b6
RR
647};
648
649//---------------------------------------------------------------------------
92afa2b1 650// wxBoxSizer
c62ac5b6
RR
651//---------------------------------------------------------------------------
652
92afa2b1 653class WXDLLEXPORT wxBoxSizer: public wxSizer
61d514bb
RR
654{
655public:
f6bcfd97 656 wxBoxSizer( int orient );
0c0d686f 657
f6bcfd97
BP
658 void RecalcSizes();
659 wxSize CalcMin();
0c0d686f 660
9cbee2ce 661 int GetOrientation() const
f6bcfd97 662 { return m_orient; }
0c0d686f 663
b657b4c9
JS
664 void SetOrientation(int orient)
665 { m_orient = orient; }
666
61d514bb
RR
667protected:
668 int m_orient;
669 int m_stretchable;
670 int m_minWidth;
671 int m_minHeight;
672 int m_fixedWidth;
673 int m_fixedHeight;
1e6feb95 674
9cbee2ce 675private:
4393b50c 676 DECLARE_CLASS(wxBoxSizer)
61d514bb 677};
0c0d686f 678
27ea1d8a
RR
679//---------------------------------------------------------------------------
680// wxStaticBoxSizer
681//---------------------------------------------------------------------------
682
1e6feb95
VZ
683#if wxUSE_STATBOX
684
649cfca1 685class WXDLLEXPORT wxStaticBox;
1e6feb95 686
27ea1d8a
RR
687class WXDLLEXPORT wxStaticBoxSizer: public wxBoxSizer
688{
689public:
6c1635b5 690 wxStaticBoxSizer(wxStaticBox *box, int orient);
450a1593 691 wxStaticBoxSizer(int orient, wxWindow *win, const wxString& label = wxEmptyString);
649cfca1 692 virtual ~wxStaticBoxSizer();
0c0d686f 693
f6bcfd97
BP
694 void RecalcSizes();
695 wxSize CalcMin();
0c0d686f 696
9cbee2ce 697 wxStaticBox *GetStaticBox() const
f6bcfd97 698 { return m_staticBox; }
0c0d686f 699
eb2a7883
VZ
700 // override to hide/show the static box as well
701 virtual void ShowItems (bool show);
7e2b7860 702
e978011a 703 virtual bool Detach( wxWindow *window );
7e2b7860
VZ
704 virtual bool Detach( wxSizer *sizer ) { return wxBoxSizer::Detach(sizer); }
705 virtual bool Detach( int index ) { return wxBoxSizer::Detach(index); }
eb2a7883 706
27ea1d8a 707protected:
f6bcfd97 708 wxStaticBox *m_staticBox;
1e6feb95 709
9cbee2ce 710private:
4393b50c 711 DECLARE_CLASS(wxStaticBoxSizer)
22f3361e 712 DECLARE_NO_COPY_CLASS(wxStaticBoxSizer)
27ea1d8a
RR
713};
714
1e6feb95
VZ
715#endif // wxUSE_STATBOX
716
974c2a59
WS
717#if wxUSE_BUTTON
718
acf2ac37
RR
719class WXDLLEXPORT wxStdDialogButtonSizer: public wxBoxSizer
720{
721public:
acf2ac37
RR
722 // Constructor just creates a new wxBoxSizer, not much else.
723 // Box sizer orientation is automatically determined here:
724 // vertical for PDAs, horizontal for everything else?
b181a505 725 wxStdDialogButtonSizer();
acf2ac37 726
acf2ac37 727 // Checks button ID against system IDs and sets one of the pointers below
b181a505
RR
728 // to this button. Does not do any sizer-related things here.
729 void AddButton(wxButton *button);
acf2ac37 730
b181a505
RR
731 // Use these if no standard ID can/should be used
732 void SetAffirmativeButton( wxButton *button );
733 void SetNegativeButton( wxButton *button );
734 void SetCancelButton( wxButton *button );
acf2ac37 735
acf2ac37
RR
736 // All platform-specific code here, checks which buttons exist and add
737 // them to the sizer accordingly.
738 // Note - one potential hack on Mac we could use here,
739 // if m_buttonAffirmative is wxID_SAVE then ensure wxID_SAVE
740 // is set to _("Save") and m_buttonNegative is set to _("Don't Save")
741 // I wouldn't add any other hacks like that into here,
742 // but this one I can see being useful.
718903fe 743 void Realize();
974c2a59 744
acf2ac37
RR
745 wxButton *GetAffirmativeButton() const { return m_buttonAffirmative; }
746 wxButton *GetApplyButton() const { return m_buttonApply; }
747 wxButton *GetNegativeButton() const { return m_buttonNegative; }
748 wxButton *GetCancelButton() const { return m_buttonCancel; }
749 wxButton *GetHelpButton() const { return m_buttonHelp; }
750
751protected:
b181a505 752 wxButton *m_buttonAffirmative; // wxID_OK, wxID_YES, wxID_SAVE go here
acf2ac37 753 wxButton *m_buttonApply;
b181a505 754 wxButton *m_buttonNegative; // wxID_NO
acf2ac37
RR
755 wxButton *m_buttonCancel;
756 wxButton *m_buttonHelp;
974c2a59 757
acf2ac37
RR
758private:
759 DECLARE_CLASS(wxStdDialogButtonSizer)
b181a505 760 DECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer)
acf2ac37 761};
adbf2d73 762
6b5c4761 763#endif // wxUSE_BUTTON
974c2a59 764
adbf2d73
VS
765#if WXWIN_COMPATIBILITY_2_4
766// NB: wxBookCtrlSizer and wxNotebookSizer are deprecated, they
61c083e7 767// don't do anything. wxBookCtrlBase::DoGetBestSize does the job now.
adbf2d73 768
ade4eb65
VZ
769// ----------------------------------------------------------------------------
770// wxBookCtrlSizer
771// ----------------------------------------------------------------------------
83edc0a5 772
ade4eb65 773#if wxUSE_BOOKCTRL
65e4f9b9 774
8e32ea1c 775// this sizer works with wxNotebook/wxListbook/... and sizes the control to
ade4eb65 776// fit its pages
61c083e7 777class WXDLLEXPORT wxBookCtrlBase;
1e6feb95 778
ade4eb65 779class WXDLLEXPORT wxBookCtrlSizer : public wxSizer
83edc0a5 780{
83edc0a5 781public:
6a9e54bd 782#if WXWIN_COMPATIBILITY_2_6
61c083e7 783 wxDEPRECATED( wxBookCtrlSizer(wxBookCtrlBase *bookctrl) );
6a9e54bd 784#endif // WXWIN_COMPATIBILITY_2_6
83edc0a5 785
61c083e7 786 wxBookCtrlBase *GetControl() const { return m_bookctrl; }
8b2bac62 787
ade4eb65
VZ
788 virtual void RecalcSizes();
789 virtual wxSize CalcMin();
83edc0a5 790
83edc0a5 791protected:
adbf2d73 792 // this protected ctor lets us mark the real one above as deprecated
749bb9f1 793 // and still have warning-free build of the library itself:
adbf2d73 794 wxBookCtrlSizer() {}
8b2bac62 795
61c083e7 796 wxBookCtrlBase *m_bookctrl;
ade4eb65
VZ
797
798private:
799 DECLARE_CLASS(wxBookCtrlSizer)
800 DECLARE_NO_COPY_CLASS(wxBookCtrlSizer)
801};
802
803
804#if wxUSE_NOTEBOOK
805
61c083e7 806// before wxBookCtrlBase we only had wxNotebookSizer, keep it for backwards
ade4eb65
VZ
807// compatibility
808class WXDLLEXPORT wxNotebook;
809
810class WXDLLEXPORT wxNotebookSizer : public wxBookCtrlSizer
811{
812public:
6a9e54bd 813#if WXWIN_COMPATIBILITY_2_6
adbf2d73 814 wxDEPRECATED( wxNotebookSizer(wxNotebook *nb) );
6a9e54bd 815#endif // WXWIN_COMPATIBILITY_2_6
ade4eb65
VZ
816
817 wxNotebook *GetNotebook() const { return (wxNotebook *)m_bookctrl; }
1e6feb95 818
9cbee2ce 819private:
4393b50c 820 DECLARE_CLASS(wxNotebookSizer)
22f3361e 821 DECLARE_NO_COPY_CLASS(wxNotebookSizer)
83edc0a5
RR
822};
823
1e6feb95 824#endif // wxUSE_NOTEBOOK
65e4f9b9 825
ade4eb65
VZ
826#endif // wxUSE_BOOKCTRL
827
adbf2d73
VS
828#endif // WXWIN_COMPATIBILITY_2_4
829
8e32ea1c
VZ
830// ----------------------------------------------------------------------------
831// inline functions implementation
832// ----------------------------------------------------------------------------
833
56eee37f 834inline wxSizerItem*
8e32ea1c
VZ
835wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
836{
56eee37f 837 return Add( new wxSizerItem( window, proportion, flag, border, userData ) );
8e32ea1c
VZ
838}
839
56eee37f 840inline wxSizerItem*
8e32ea1c
VZ
841wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
842{
56eee37f 843 return Add( new wxSizerItem( sizer, proportion, flag, border, userData ) );
8e32ea1c
VZ
844}
845
56eee37f 846inline wxSizerItem*
8e32ea1c
VZ
847wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
848{
56eee37f 849 return Add( new wxSizerItem( width, height, proportion, flag, border, userData ) );
8e32ea1c
VZ
850}
851
56eee37f 852inline wxSizerItem*
5f813ad6
VZ
853wxSizer::Add( wxWindow *window, const wxSizerFlags& flags )
854{
56eee37f 855 return Add( new wxSizerItem(window, flags) );
5f813ad6
VZ
856}
857
56eee37f 858inline wxSizerItem*
5f813ad6
VZ
859wxSizer::Add( wxSizer *sizer, const wxSizerFlags& flags )
860{
56eee37f 861 return Add( new wxSizerItem(sizer, flags) );
5f813ad6
VZ
862}
863
56eee37f 864inline wxSizerItem*
8e32ea1c
VZ
865wxSizer::Add( wxSizerItem *item )
866{
56eee37f 867 return Insert( m_children.GetCount(), item );
8e32ea1c
VZ
868}
869
56eee37f 870inline wxSizerItem*
8e32ea1c
VZ
871wxSizer::AddSpacer(int size)
872{
56eee37f 873 return Add(size, size);
8e32ea1c
VZ
874}
875
56eee37f 876inline wxSizerItem*
8e32ea1c
VZ
877wxSizer::AddStretchSpacer(int prop)
878{
56eee37f 879 return Add(0, 0, prop);
8e32ea1c
VZ
880}
881
56eee37f 882inline wxSizerItem*
8e32ea1c
VZ
883wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
884{
56eee37f 885 return Prepend( new wxSizerItem( window, proportion, flag, border, userData ) );
8e32ea1c
VZ
886}
887
56eee37f 888inline wxSizerItem*
8e32ea1c
VZ
889wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
890{
56eee37f 891 return Prepend( new wxSizerItem( sizer, proportion, flag, border, userData ) );
8e32ea1c
VZ
892}
893
56eee37f 894inline wxSizerItem*
8e32ea1c
VZ
895wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
896{
56eee37f 897 return Prepend( new wxSizerItem( width, height, proportion, flag, border, userData ) );
8e32ea1c
VZ
898}
899
56eee37f 900inline wxSizerItem*
8e32ea1c
VZ
901wxSizer::Prepend( wxSizerItem *item )
902{
56eee37f 903 return Insert( 0, item );
8e32ea1c
VZ
904}
905
56eee37f 906inline wxSizerItem*
8e32ea1c
VZ
907wxSizer::PrependSpacer(int size)
908{
56eee37f 909 return Prepend(size, size);
8e32ea1c
VZ
910}
911
56eee37f 912inline wxSizerItem*
8e32ea1c
VZ
913wxSizer::PrependStretchSpacer(int prop)
914{
56eee37f 915 return Prepend(0, 0, prop);
8e32ea1c
VZ
916}
917
56eee37f 918inline wxSizerItem*
5f813ad6
VZ
919wxSizer::Prepend( wxWindow *window, const wxSizerFlags& flags )
920{
56eee37f 921 return Prepend( new wxSizerItem(window, flags) );
5f813ad6
VZ
922}
923
56eee37f 924inline wxSizerItem*
5f813ad6
VZ
925wxSizer::Prepend( wxSizer *sizer, const wxSizerFlags& flags )
926{
56eee37f 927 return Prepend( new wxSizerItem(sizer, flags) );
5f813ad6
VZ
928}
929
56eee37f 930inline wxSizerItem*
8e32ea1c 931wxSizer::Insert( size_t index,
5f813ad6
VZ
932 wxWindow *window,
933 int proportion,
934 int flag,
935 int border,
936 wxObject* userData )
8e32ea1c 937{
56eee37f 938 return Insert( index, new wxSizerItem( window, proportion, flag, border, userData ) );
8e32ea1c
VZ
939}
940
56eee37f 941inline wxSizerItem*
8e32ea1c 942wxSizer::Insert( size_t index,
5f813ad6
VZ
943 wxSizer *sizer,
944 int proportion,
945 int flag,
946 int border,
947 wxObject* userData )
8e32ea1c 948{
56eee37f 949 return Insert( index, new wxSizerItem( sizer, proportion, flag, border, userData ) );
8e32ea1c
VZ
950}
951
56eee37f 952inline wxSizerItem*
8e32ea1c 953wxSizer::Insert( size_t index,
5f813ad6
VZ
954 int width,
955 int height,
956 int proportion,
957 int flag,
958 int border,
959 wxObject* userData )
8e32ea1c 960{
56eee37f 961 return Insert( index, new wxSizerItem( width, height, proportion, flag, border, userData ) );
8e32ea1c
VZ
962}
963
56eee37f 964inline wxSizerItem*
5f813ad6
VZ
965wxSizer::Insert( size_t index, wxWindow *window, const wxSizerFlags& flags )
966{
56eee37f 967 return Insert( index, new wxSizerItem(window, flags) );
5f813ad6
VZ
968}
969
56eee37f 970inline wxSizerItem*
5f813ad6
VZ
971wxSizer::Insert( size_t index, wxSizer *sizer, const wxSizerFlags& flags )
972{
56eee37f 973 return Insert( index, new wxSizerItem(sizer, flags) );
5f813ad6
VZ
974}
975
56eee37f 976inline wxSizerItem*
8e32ea1c
VZ
977wxSizer::InsertSpacer(size_t index, int size)
978{
56eee37f 979 return Insert(index, size, size);
8e32ea1c
VZ
980}
981
56eee37f 982inline wxSizerItem*
8e32ea1c
VZ
983wxSizer::InsertStretchSpacer(size_t index, int prop)
984{
56eee37f 985 return Insert(index, 0, 0, prop);
8e32ea1c
VZ
986}
987
adbf2d73 988
ade4eb65 989#endif // __WXSIZER_H__
65e4f9b9 990