]> git.saurik.com Git - wxWidgets.git/blob - include/wx/sizer.h
cleanup
[wxWidgets.git] / include / wx / sizer.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/sizer.h
3 // Purpose: provide wxSizer class for layout
4 // Author: Robert Roebling and Robin Dunn
5 // Modified by: Ron Lee, Vadim Zeitlin (wxSizerFlags)
6 // Created:
7 // RCS-ID: $Id$
8 // Copyright: (c) Robin Dunn, Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef __WXSIZER_H__
13 #define __WXSIZER_H__
14
15 #include "wx/defs.h"
16
17 #include "wx/window.h"
18
19 //---------------------------------------------------------------------------
20 // classes
21 //---------------------------------------------------------------------------
22
23 class WXDLLIMPEXP_FWD_CORE wxButton;
24 class WXDLLIMPEXP_FWD_CORE wxBoxSizer;
25 class WXDLLIMPEXP_FWD_CORE wxSizerItem;
26 class WXDLLIMPEXP_FWD_CORE wxSizer;
27
28 #ifndef wxUSE_BORDER_BY_DEFAULT
29 #ifdef __SMARTPHONE__
30 // no borders by default on limited size screen
31 #define wxUSE_BORDER_BY_DEFAULT 0
32 #else
33 #define wxUSE_BORDER_BY_DEFAULT 1
34 #endif
35 #endif
36
37 // ----------------------------------------------------------------------------
38 // wxSizerFlags: flags used for an item in the sizer
39 // ----------------------------------------------------------------------------
40
41 class WXDLLEXPORT wxSizerFlags
42 {
43 public:
44 // construct the flags object initialized with the given proportion (0 by
45 // default)
46 wxSizerFlags(int proportion = 0) : m_proportion(proportion)
47 {
48 m_flags = 0;
49 m_borderInPixels = 0;
50 }
51
52 // setters for all sizer flags, they all return the object itself so that
53 // calls to them can be chained
54
55 wxSizerFlags& Proportion(int proportion)
56 {
57 m_proportion = proportion;
58 return *this;
59 }
60
61 wxSizerFlags& Align(int alignment) // combination of wxAlignment values
62 {
63 m_flags &= ~wxALIGN_MASK;
64 m_flags |= alignment;
65
66 return *this;
67 }
68
69 wxSizerFlags& Expand()
70 {
71 m_flags |= wxEXPAND;
72 return *this;
73 }
74
75 // some shortcuts for Align()
76 wxSizerFlags& Centre() { return Align(wxALIGN_CENTRE); }
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); }
82
83 // default border size used by Border() below
84 static int GetDefaultBorder()
85 {
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
89 return 5;
90 #else
91 return 0;
92 #endif
93 }
94
95
96 wxSizerFlags& Border(int direction, int borderInPixels)
97 {
98 m_flags &= ~wxALL;
99 m_flags |= direction;
100
101 m_borderInPixels = borderInPixels;
102
103 return *this;
104 }
105
106 wxSizerFlags& Border(int direction = wxALL)
107 {
108 #if wxUSE_BORDER_BY_DEFAULT
109 return Border(direction, GetDefaultBorder());
110 #else
111 // no borders by default on limited size screen
112 wxUnusedVar(direction);
113
114 return *this;
115 #endif
116 }
117
118 wxSizerFlags& DoubleBorder(int direction = wxALL)
119 {
120 #if wxUSE_BORDER_BY_DEFAULT
121 return Border(direction, 2*GetDefaultBorder());
122 #else
123 wxUnusedVar(direction);
124
125 return *this;
126 #endif
127 }
128
129 wxSizerFlags& TripleBorder(int direction = wxALL)
130 {
131 #if wxUSE_BORDER_BY_DEFAULT
132 return Border(direction, 3*GetDefaultBorder());
133 #else
134 wxUnusedVar(direction);
135
136 return *this;
137 #endif
138 }
139
140 wxSizerFlags& HorzBorder()
141 {
142 #if wxUSE_BORDER_BY_DEFAULT
143 return Border(wxLEFT | wxRIGHT, GetDefaultBorder());
144 #else
145 return *this;
146 #endif
147 }
148
149 wxSizerFlags& DoubleHorzBorder()
150 {
151 #if wxUSE_BORDER_BY_DEFAULT
152 return Border(wxLEFT | wxRIGHT, 2*GetDefaultBorder());
153 #else
154 return *this;
155 #endif
156 }
157
158 // setters for the others flags
159 wxSizerFlags& Shaped()
160 {
161 m_flags |= wxSHAPED;
162
163 return *this;
164 }
165
166 wxSizerFlags& FixedMinSize()
167 {
168 m_flags |= wxFIXED_MINSIZE;
169
170 return *this;
171 }
172
173 // accessors for wxSizer only
174 int GetProportion() const { return m_proportion; }
175 int GetFlags() const { return m_flags; }
176 int GetBorderInPixels() const { return m_borderInPixels; }
177
178 private:
179 int m_proportion;
180 int m_flags;
181 int m_borderInPixels;
182 };
183
184
185 // ----------------------------------------------------------------------------
186 // wxSizerSpacer: used by wxSizerItem to represent a spacer
187 // ----------------------------------------------------------------------------
188
189 class WXDLLEXPORT wxSizerSpacer
190 {
191 public:
192 wxSizerSpacer(const wxSize& size) : m_size(size), m_isShown(true) { }
193
194 void SetSize(const wxSize& size) { m_size = size; }
195 const wxSize& GetSize() const { return m_size; }
196
197 void Show(bool show) { m_isShown = show; }
198 bool IsShown() const { return m_isShown; }
199
200 private:
201 // the size, in pixel
202 wxSize m_size;
203
204 // is the spacer currently shown?
205 bool m_isShown;
206 };
207
208 // ----------------------------------------------------------------------------
209 // wxSizerItem
210 // ----------------------------------------------------------------------------
211
212 class WXDLLEXPORT wxSizerItem : public wxObject
213 {
214 public:
215 // window
216 wxSizerItem( wxWindow *window,
217 int proportion,
218 int flag,
219 int border,
220 wxObject* userData );
221
222 // window with flags
223 wxSizerItem(wxWindow *window, const wxSizerFlags& flags)
224 {
225 Init(flags);
226
227 DoSetWindow(window);
228 }
229
230 // subsizer
231 wxSizerItem( wxSizer *sizer,
232 int proportion,
233 int flag,
234 int border,
235 wxObject* userData );
236
237 // sizer with flags
238 wxSizerItem(wxSizer *sizer, const wxSizerFlags& flags)
239 {
240 Init(flags);
241
242 DoSetSizer(sizer);
243 }
244
245 // spacer
246 wxSizerItem( int width,
247 int height,
248 int proportion,
249 int flag,
250 int border,
251 wxObject* userData);
252
253 // spacer with flags
254 wxSizerItem(int width, int height, const wxSizerFlags& flags)
255 {
256 Init(flags);
257
258 DoSetSpacer(wxSize(width, height));
259 }
260
261 wxSizerItem();
262 virtual ~wxSizerItem();
263
264 virtual void DeleteWindows();
265
266 // Enable deleting the SizerItem without destroying the contained sizer.
267 void DetachSizer() { m_sizer = NULL; }
268
269 virtual wxSize GetSize() const;
270 virtual wxSize CalcMin();
271 virtual void SetDimension( const wxPoint& pos, const wxSize& size );
272
273 wxSize GetMinSize() const
274 { return m_minSize; }
275 wxSize GetMinSizeWithBorder() const;
276
277 void SetMinSize(const wxSize& size)
278 {
279 if ( IsWindow() )
280 m_window->SetMinSize(size);
281 m_minSize = size;
282 }
283 void SetMinSize( int x, int y )
284 { SetMinSize(wxSize(x, y)); }
285 void SetInitSize( int x, int y )
286 { SetMinSize(wxSize(x, y)); }
287
288 // if either of dimensions is zero, ratio is assumed to be 1
289 // to avoid "divide by zero" errors
290 void SetRatio(int width, int height)
291 { m_ratio = (width && height) ? ((float) width / (float) height) : 1; }
292 void SetRatio(const wxSize& size)
293 { SetRatio(size.x, size.y); }
294 void SetRatio(float ratio)
295 { m_ratio = ratio; }
296 float GetRatio() const
297 { return m_ratio; }
298
299 virtual wxRect GetRect() { return m_rect; }
300
301 // set a sizer item id (different from a window id, all sizer items,
302 // including spacers, can have an associated id)
303 void SetId(int id) { m_id = id; }
304 int GetId() const { return m_id; }
305
306 bool IsWindow() const { return m_kind == Item_Window; }
307 bool IsSizer() const { return m_kind == Item_Sizer; }
308 bool IsSpacer() const { return m_kind == Item_Spacer; }
309
310 #if WXWIN_COMPATIBILITY_2_6
311 // Deprecated in 2.6, use {G,S}etProportion instead.
312 wxDEPRECATED( void SetOption( int option ) );
313 wxDEPRECATED( int GetOption() const );
314 #endif // WXWIN_COMPATIBILITY_2_6
315
316 void SetProportion( int proportion )
317 { m_proportion = proportion; }
318 int GetProportion() const
319 { return m_proportion; }
320 void SetFlag( int flag )
321 { m_flag = flag; }
322 int GetFlag() const
323 { return m_flag; }
324 void SetBorder( int border )
325 { m_border = border; }
326 int GetBorder() const
327 { return m_border; }
328
329 wxWindow *GetWindow() const
330 { return m_kind == Item_Window ? m_window : NULL; }
331 wxSizer *GetSizer() const
332 { return m_kind == Item_Sizer ? m_sizer : NULL; }
333 wxSize GetSpacer() const;
334
335 // this function behaves obviously for the windows and spacers but for the
336 // sizers it returns true if any sizer element is shown and only returns
337 // false if all of them are hidden
338 bool IsShown() const;
339 void Show(bool show);
340
341 void SetUserData(wxObject* userData)
342 { delete m_userData; m_userData = userData; }
343 wxObject* GetUserData() const
344 { return m_userData; }
345 wxPoint GetPosition() const
346 { return m_pos; }
347
348 // these functions delete the current contents of the item if it's a sizer
349 // or a spacer but not if it is a window
350 void AssignWindow(wxWindow *window)
351 {
352 Free();
353 DoSetWindow(window);
354 }
355
356 void AssignSizer(wxSizer *sizer)
357 {
358 Free();
359 DoSetSizer(sizer);
360 }
361
362 void AssignSpacer(const wxSize& size)
363 {
364 Free();
365 DoSetSpacer(size);
366 }
367
368 void AssignSpacer(int w, int h) { AssignSpacer(wxSize(w, h)); }
369
370 #if WXWIN_COMPATIBILITY_2_8
371 // these functions do not free the old sizer/spacer and so can easily
372 // provoke the memory leaks and so shouldn't be used, use Assign() instead
373 wxDEPRECATED( void SetWindow(wxWindow *window) );
374 wxDEPRECATED( void SetSizer(wxSizer *sizer) );
375 wxDEPRECATED( void SetSpacer(const wxSize& size) );
376 wxDEPRECATED( void SetSpacer(int width, int height) );
377 #endif // WXWIN_COMPATIBILITY_2_8
378
379 protected:
380 // common part of several ctors
381 void Init() { m_userData = NULL; m_kind = Item_None; }
382
383 // common part of ctors taking wxSizerFlags
384 void Init(const wxSizerFlags& flags);
385
386 // free current contents
387 void Free();
388
389 // common parts of Set/AssignXXX()
390 void DoSetWindow(wxWindow *window);
391 void DoSetSizer(wxSizer *sizer);
392 void DoSetSpacer(const wxSize& size);
393
394 // discriminated union: depending on m_kind one of the fields is valid
395 enum
396 {
397 Item_None,
398 Item_Window,
399 Item_Sizer,
400 Item_Spacer,
401 Item_Max
402 } m_kind;
403 union
404 {
405 wxWindow *m_window;
406 wxSizer *m_sizer;
407 wxSizerSpacer *m_spacer;
408 };
409
410 wxPoint m_pos;
411 wxSize m_minSize;
412 int m_proportion;
413 int m_border;
414 int m_flag;
415 int m_id;
416
417 // on screen rectangle of this item (not including borders)
418 wxRect m_rect;
419
420 // Aspect ratio can always be calculated from m_size,
421 // but this would cause precision loss when the window
422 // is shrunk. It is safer to preserve the initial value.
423 float m_ratio;
424
425 wxObject *m_userData;
426
427 private:
428 DECLARE_CLASS(wxSizerItem)
429 DECLARE_NO_COPY_CLASS(wxSizerItem)
430 };
431
432 WX_DECLARE_EXPORTED_LIST( wxSizerItem, wxSizerItemList );
433
434
435 //---------------------------------------------------------------------------
436 // wxSizer
437 //---------------------------------------------------------------------------
438
439 class WXDLLEXPORT wxSizer: public wxObject, public wxClientDataContainer
440 {
441 public:
442 wxSizer() { m_containingWindow = NULL; }
443 virtual ~wxSizer();
444
445 // methods for adding elements to the sizer: there are Add/Insert/Prepend
446 // overloads for each of window/sizer/spacer/wxSizerItem
447 wxSizerItem* Add(wxWindow *window,
448 int proportion = 0,
449 int flag = 0,
450 int border = 0,
451 wxObject* userData = NULL);
452 wxSizerItem* Add(wxSizer *sizer,
453 int proportion = 0,
454 int flag = 0,
455 int border = 0,
456 wxObject* userData = NULL);
457 wxSizerItem* Add(int width,
458 int height,
459 int proportion = 0,
460 int flag = 0,
461 int border = 0,
462 wxObject* userData = NULL);
463 wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags);
464 wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags);
465 wxSizerItem* Add( int width, int height, const wxSizerFlags& flags);
466 wxSizerItem* Add( wxSizerItem *item);
467
468 wxSizerItem* AddSpacer(int size);
469 wxSizerItem* AddStretchSpacer(int prop = 1);
470
471 wxSizerItem* Insert(size_t index,
472 wxWindow *window,
473 int proportion = 0,
474 int flag = 0,
475 int border = 0,
476 wxObject* userData = NULL);
477 wxSizerItem* Insert(size_t index,
478 wxSizer *sizer,
479 int proportion = 0,
480 int flag = 0,
481 int border = 0,
482 wxObject* userData = NULL);
483 wxSizerItem* Insert(size_t index,
484 int width,
485 int height,
486 int proportion = 0,
487 int flag = 0,
488 int border = 0,
489 wxObject* userData = NULL);
490 wxSizerItem* Insert(size_t index,
491 wxWindow *window,
492 const wxSizerFlags& flags);
493 wxSizerItem* Insert(size_t index,
494 wxSizer *sizer,
495 const wxSizerFlags& flags);
496 wxSizerItem* Insert(size_t index,
497 int width,
498 int height,
499 const wxSizerFlags& flags);
500 virtual wxSizerItem* Insert( size_t index, wxSizerItem *item);
501
502 wxSizerItem* InsertSpacer(size_t index, int size);
503 wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
504
505 wxSizerItem* Prepend(wxWindow *window,
506 int proportion = 0,
507 int flag = 0,
508 int border = 0,
509 wxObject* userData = NULL);
510 wxSizerItem* Prepend(wxSizer *sizer,
511 int proportion = 0,
512 int flag = 0,
513 int border = 0,
514 wxObject* userData = NULL);
515 wxSizerItem* Prepend(int width,
516 int height,
517 int proportion = 0,
518 int flag = 0,
519 int border = 0,
520 wxObject* userData = NULL);
521 wxSizerItem* Prepend(wxWindow *window, const wxSizerFlags& flags);
522 wxSizerItem* Prepend(wxSizer *sizer, const wxSizerFlags& flags);
523 wxSizerItem* Prepend(int width, int height, const wxSizerFlags& flags);
524 wxSizerItem* Prepend(wxSizerItem *item);
525
526 wxSizerItem* PrependSpacer(int size);
527 wxSizerItem* PrependStretchSpacer(int prop = 1);
528
529 // set (or possibly unset if window is NULL) or get the window this sizer
530 // is used in
531 void SetContainingWindow(wxWindow *window);
532 wxWindow *GetContainingWindow() const { return m_containingWindow; }
533
534 #if WXWIN_COMPATIBILITY_2_6
535 // Deprecated in 2.6 since historically it does not delete the window,
536 // use Detach instead.
537 wxDEPRECATED( virtual bool Remove( wxWindow *window ) );
538 #endif // WXWIN_COMPATIBILITY_2_6
539
540 virtual bool Remove( wxSizer *sizer );
541 virtual bool Remove( int index );
542
543 virtual bool Detach( wxWindow *window );
544 virtual bool Detach( wxSizer *sizer );
545 virtual bool Detach( int index );
546
547 virtual bool Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive = false );
548 virtual bool Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive = false );
549 virtual bool Replace( size_t index, wxSizerItem *newitem );
550
551 virtual void Clear( bool delete_windows = false );
552 virtual void DeleteWindows();
553
554 void SetMinSize( int width, int height )
555 { DoSetMinSize( width, height ); }
556 void SetMinSize( const wxSize& size )
557 { DoSetMinSize( size.x, size.y ); }
558
559 // Searches recursively
560 bool SetItemMinSize( wxWindow *window, int width, int height )
561 { return DoSetItemMinSize( window, width, height ); }
562 bool SetItemMinSize( wxWindow *window, const wxSize& size )
563 { return DoSetItemMinSize( window, size.x, size.y ); }
564
565 // Searches recursively
566 bool SetItemMinSize( wxSizer *sizer, int width, int height )
567 { return DoSetItemMinSize( sizer, width, height ); }
568 bool SetItemMinSize( wxSizer *sizer, const wxSize& size )
569 { return DoSetItemMinSize( sizer, size.x, size.y ); }
570
571 bool SetItemMinSize( size_t index, int width, int height )
572 { return DoSetItemMinSize( index, width, height ); }
573 bool SetItemMinSize( size_t index, const wxSize& size )
574 { return DoSetItemMinSize( index, size.x, size.y ); }
575
576 wxSize GetSize() const
577 { return m_size; }
578 wxPoint GetPosition() const
579 { return m_position; }
580
581 // Calculate the minimal size or return m_minSize if bigger.
582 wxSize GetMinSize();
583
584 // These virtual functions are used by the layout algorithm: first
585 // CalcMin() is called to calculate the minimal size of the sizer and
586 // prepare for laying it out and then RecalcSizes() is called to really
587 // update all the sizer items
588 virtual wxSize CalcMin() = 0;
589 virtual void RecalcSizes() = 0;
590
591 virtual void Layout();
592
593 wxSize Fit( wxWindow *window );
594 void FitInside( wxWindow *window );
595 void SetSizeHints( wxWindow *window );
596 void SetVirtualSizeHints( wxWindow *window );
597
598 wxSizerItemList& GetChildren()
599 { return m_children; }
600 const wxSizerItemList& GetChildren() const
601 { return m_children; }
602
603 void SetDimension( int x, int y, int width, int height );
604
605 wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
606 wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
607 wxSizerItem* GetItem( size_t index );
608 wxSizerItem* GetItemById( int id, bool recursive = false );
609
610 // Manage whether individual scene items are considered
611 // in the layout calculations or not.
612 bool Show( wxWindow *window, bool show = true, bool recursive = false );
613 bool Show( wxSizer *sizer, bool show = true, bool recursive = false );
614 bool Show( size_t index, bool show = true );
615
616 bool Hide( wxSizer *sizer, bool recursive = false )
617 { return Show( sizer, false, recursive ); }
618 bool Hide( wxWindow *window, bool recursive = false )
619 { return Show( window, false, recursive ); }
620 bool Hide( size_t index )
621 { return Show( index, false ); }
622
623 bool IsShown( wxWindow *window ) const;
624 bool IsShown( wxSizer *sizer ) const;
625 bool IsShown( size_t index ) const;
626
627 // Recursively call wxWindow::Show () on all sizer items.
628 virtual void ShowItems (bool show);
629
630 void Show(bool show) { ShowItems(show); }
631
632 protected:
633 wxSize m_size;
634 wxSize m_minSize;
635 wxPoint m_position;
636 wxSizerItemList m_children;
637
638 // the window this sizer is used in, can be NULL
639 wxWindow *m_containingWindow;
640
641 wxSize GetMaxWindowSize( wxWindow *window ) const;
642 wxSize GetMinWindowSize( wxWindow *window );
643 wxSize GetMaxClientSize( wxWindow *window ) const;
644 wxSize GetMinClientSize( wxWindow *window );
645 wxSize VirtualFitSize( wxWindow *window );
646
647 virtual void DoSetMinSize( int width, int height );
648 virtual bool DoSetItemMinSize( wxWindow *window, int width, int height );
649 virtual bool DoSetItemMinSize( wxSizer *sizer, int width, int height );
650 virtual bool DoSetItemMinSize( size_t index, int width, int height );
651
652 private:
653 DECLARE_CLASS(wxSizer)
654 };
655
656 //---------------------------------------------------------------------------
657 // wxGridSizer
658 //---------------------------------------------------------------------------
659
660 class WXDLLEXPORT wxGridSizer: public wxSizer
661 {
662 public:
663 wxGridSizer( int rows, int cols, int vgap, int hgap );
664 wxGridSizer( int cols, int vgap = 0, int hgap = 0 );
665
666 virtual void RecalcSizes();
667 virtual wxSize CalcMin();
668
669 void SetCols( int cols ) { m_cols = cols; }
670 void SetRows( int rows ) { m_rows = rows; }
671 void SetVGap( int gap ) { m_vgap = gap; }
672 void SetHGap( int gap ) { m_hgap = gap; }
673 int GetCols() const { return m_cols; }
674 int GetRows() const { return m_rows; }
675 int GetVGap() const { return m_vgap; }
676 int GetHGap() const { return m_hgap; }
677
678 protected:
679 int m_rows;
680 int m_cols;
681 int m_vgap;
682 int m_hgap;
683
684 // return the number of total items and the number of columns and rows
685 int CalcRowsCols(int& rows, int& cols) const;
686
687 void SetItemBounds( wxSizerItem *item, int x, int y, int w, int h );
688
689 private:
690 DECLARE_CLASS(wxGridSizer)
691 };
692
693 //---------------------------------------------------------------------------
694 // wxFlexGridSizer
695 //---------------------------------------------------------------------------
696
697 // the bevaiour for resizing wxFlexGridSizer cells in the "non-flexible"
698 // direction
699 enum wxFlexSizerGrowMode
700 {
701 // don't resize the cells in non-flexible direction at all
702 wxFLEX_GROWMODE_NONE,
703
704 // uniformly resize only the specified ones (default)
705 wxFLEX_GROWMODE_SPECIFIED,
706
707 // uniformly resize all cells
708 wxFLEX_GROWMODE_ALL
709 };
710
711 class WXDLLEXPORT wxFlexGridSizer: public wxGridSizer
712 {
713 public:
714 // ctors/dtor
715 wxFlexGridSizer( int rows, int cols, int vgap, int hgap );
716 wxFlexGridSizer( int cols, int vgap = 0, int hgap = 0 );
717 virtual ~wxFlexGridSizer();
718
719
720 // set the rows/columns which will grow (the others will remain of the
721 // constant initial size)
722 void AddGrowableRow( size_t idx, int proportion = 0 );
723 void RemoveGrowableRow( size_t idx );
724 void AddGrowableCol( size_t idx, int proportion = 0 );
725 void RemoveGrowableCol( size_t idx );
726
727
728 // the sizer cells may grow in both directions, not grow at all or only
729 // grow in one direction but not the other
730
731 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
732 void SetFlexibleDirection(int direction) { m_flexDirection = direction; }
733 int GetFlexibleDirection() const { return m_flexDirection; }
734
735 // note that the grow mode only applies to the direction which is not
736 // flexible
737 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) { m_growMode = mode; }
738 wxFlexSizerGrowMode GetNonFlexibleGrowMode() const { return m_growMode; }
739
740 // Read-only access to the row heights and col widths arrays
741 const wxArrayInt& GetRowHeights() const { return m_rowHeights; }
742 const wxArrayInt& GetColWidths() const { return m_colWidths; }
743
744 // implementation
745 virtual void RecalcSizes();
746 virtual wxSize CalcMin();
747
748 protected:
749 void AdjustForFlexDirection();
750 void AdjustForGrowables(const wxSize& sz);
751
752 // the heights/widths of all rows/columns
753 wxArrayInt m_rowHeights,
754 m_colWidths;
755
756 // indices of the growable columns and rows
757 wxArrayInt m_growableRows,
758 m_growableCols;
759
760 // proportion values of the corresponding growable rows and columns
761 wxArrayInt m_growableRowsProportions,
762 m_growableColsProportions;
763
764 // parameters describing whether the growable cells should be resized in
765 // both directions or only one
766 int m_flexDirection;
767 wxFlexSizerGrowMode m_growMode;
768
769 // saves CalcMin result to optimize RecalcSizes
770 wxSize m_calculatedMinSize;
771
772 private:
773 DECLARE_CLASS(wxFlexGridSizer)
774 DECLARE_NO_COPY_CLASS(wxFlexGridSizer)
775 };
776
777 //---------------------------------------------------------------------------
778 // wxBoxSizer
779 //---------------------------------------------------------------------------
780
781 class WXDLLEXPORT wxBoxSizer: public wxSizer
782 {
783 public:
784 wxBoxSizer(int orient)
785 {
786 m_orient = orient;
787
788 wxASSERT_MSG( m_orient == wxHORIZONTAL || m_orient == wxVERTICAL,
789 _T("invalid value for wxBoxSizer orientation") );
790 }
791
792 int GetOrientation() const { return m_orient; }
793
794 bool IsVertical() const { return m_orient == wxVERTICAL; }
795
796 void SetOrientation(int orient) { m_orient = orient; }
797
798 // implementation of our resizing logic
799 virtual wxSize CalcMin();
800 virtual void RecalcSizes();
801
802 protected:
803 // helpers for our code: this returns the component of the given wxSize in
804 // the direction of the sizer and in the other direction, respectively
805 int SizeInMajorDir(const wxSize& sz) const
806 {
807 return m_orient == wxHORIZONTAL ? sz.x : sz.y;
808 }
809
810 int& SizeInMajorDir(wxSize& sz)
811 {
812 return m_orient == wxHORIZONTAL ? sz.x : sz.y;
813 }
814
815 int& PosInMajorDir(wxPoint& pt)
816 {
817 return m_orient == wxHORIZONTAL ? pt.x : pt.y;
818 }
819
820 int SizeInMinorDir(const wxSize& sz) const
821 {
822 return m_orient == wxHORIZONTAL ? sz.y : sz.x;
823 }
824
825 int& SizeInMinorDir(wxSize& sz)
826 {
827 return m_orient == wxHORIZONTAL ? sz.y : sz.x;
828 }
829
830 int& PosInMinorDir(wxPoint& pt)
831 {
832 return m_orient == wxHORIZONTAL ? pt.y : pt.x;
833 }
834
835 // another helper: creates wxSize from major and minor components
836 wxSize SizeFromMajorMinor(int major, int minor) const
837 {
838 if ( m_orient == wxHORIZONTAL )
839 {
840 return wxSize(major, minor);
841 }
842 else // wxVERTICAL
843 {
844 return wxSize(minor, major);
845 }
846 }
847
848
849 // either wxHORIZONTAL or wxVERTICAL
850 int m_orient;
851
852 // the sum of proportion of all of our elements
853 int m_totalProportion;
854
855 // the minimal size needed for this sizer as calculated by the last call to
856 // our CalcMin()
857 wxSize m_minSize;
858
859 private:
860 DECLARE_CLASS(wxBoxSizer)
861 };
862
863 //---------------------------------------------------------------------------
864 // wxStaticBoxSizer
865 //---------------------------------------------------------------------------
866
867 #if wxUSE_STATBOX
868
869 class WXDLLIMPEXP_FWD_CORE wxStaticBox;
870
871 class WXDLLEXPORT wxStaticBoxSizer: public wxBoxSizer
872 {
873 public:
874 wxStaticBoxSizer(wxStaticBox *box, int orient);
875 wxStaticBoxSizer(int orient, wxWindow *win, const wxString& label = wxEmptyString);
876 virtual ~wxStaticBoxSizer();
877
878 void RecalcSizes();
879 wxSize CalcMin();
880
881 wxStaticBox *GetStaticBox() const
882 { return m_staticBox; }
883
884 // override to hide/show the static box as well
885 virtual void ShowItems (bool show);
886
887 virtual bool Detach( wxWindow *window );
888 virtual bool Detach( wxSizer *sizer ) { return wxBoxSizer::Detach(sizer); }
889 virtual bool Detach( int index ) { return wxBoxSizer::Detach(index); }
890
891 protected:
892 wxStaticBox *m_staticBox;
893
894 private:
895 DECLARE_CLASS(wxStaticBoxSizer)
896 DECLARE_NO_COPY_CLASS(wxStaticBoxSizer)
897 };
898
899 #endif // wxUSE_STATBOX
900
901 #if wxUSE_BUTTON
902
903 class WXDLLEXPORT wxStdDialogButtonSizer: public wxBoxSizer
904 {
905 public:
906 // Constructor just creates a new wxBoxSizer, not much else.
907 // Box sizer orientation is automatically determined here:
908 // vertical for PDAs, horizontal for everything else?
909 wxStdDialogButtonSizer();
910
911 // Checks button ID against system IDs and sets one of the pointers below
912 // to this button. Does not do any sizer-related things here.
913 void AddButton(wxButton *button);
914
915 // Use these if no standard ID can/should be used
916 void SetAffirmativeButton( wxButton *button );
917 void SetNegativeButton( wxButton *button );
918 void SetCancelButton( wxButton *button );
919
920 // All platform-specific code here, checks which buttons exist and add
921 // them to the sizer accordingly.
922 // Note - one potential hack on Mac we could use here,
923 // if m_buttonAffirmative is wxID_SAVE then ensure wxID_SAVE
924 // is set to _("Save") and m_buttonNegative is set to _("Don't Save")
925 // I wouldn't add any other hacks like that into here,
926 // but this one I can see being useful.
927 void Realize();
928
929 wxButton *GetAffirmativeButton() const { return m_buttonAffirmative; }
930 wxButton *GetApplyButton() const { return m_buttonApply; }
931 wxButton *GetNegativeButton() const { return m_buttonNegative; }
932 wxButton *GetCancelButton() const { return m_buttonCancel; }
933 wxButton *GetHelpButton() const { return m_buttonHelp; }
934
935 protected:
936 wxButton *m_buttonAffirmative; // wxID_OK, wxID_YES, wxID_SAVE go here
937 wxButton *m_buttonApply; // wxID_APPLY
938 wxButton *m_buttonNegative; // wxID_NO
939 wxButton *m_buttonCancel; // wxID_CANCEL, wxID_CLOSE
940 wxButton *m_buttonHelp; // wxID_HELP, wxID_CONTEXT_HELP
941
942 private:
943 DECLARE_CLASS(wxStdDialogButtonSizer)
944 DECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer)
945 };
946
947 #endif // wxUSE_BUTTON
948
949
950 // ----------------------------------------------------------------------------
951 // inline functions implementation
952 // ----------------------------------------------------------------------------
953
954 #if WXWIN_COMPATIBILITY_2_8
955
956 inline void wxSizerItem::SetWindow(wxWindow *window)
957 {
958 DoSetWindow(window);
959 }
960
961 inline void wxSizerItem::SetSizer(wxSizer *sizer)
962 {
963 DoSetSizer(sizer);
964 }
965
966 inline void wxSizerItem::SetSpacer(const wxSize& size)
967 {
968 DoSetSpacer(size);
969 }
970
971 inline void wxSizerItem::SetSpacer(int width, int height)
972 {
973 DoSetSpacer(wxSize(width, height));
974 }
975
976 #endif // WXWIN_COMPATIBILITY_2_8
977
978
979 inline wxSizerItem*
980 wxSizer::Add( wxSizerItem *item )
981 {
982 return Insert( m_children.GetCount(), item );
983 }
984
985 inline wxSizerItem*
986 wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
987 {
988 return Add( new wxSizerItem( window, proportion, flag, border, userData ) );
989 }
990
991 inline wxSizerItem*
992 wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
993 {
994 return Add( new wxSizerItem( sizer, proportion, flag, border, userData ) );
995 }
996
997 inline wxSizerItem*
998 wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
999 {
1000 return Add( new wxSizerItem( width, height, proportion, flag, border, userData ) );
1001 }
1002
1003 inline wxSizerItem*
1004 wxSizer::Add( wxWindow *window, const wxSizerFlags& flags )
1005 {
1006 return Add( new wxSizerItem(window, flags) );
1007 }
1008
1009 inline wxSizerItem*
1010 wxSizer::Add( wxSizer *sizer, const wxSizerFlags& flags )
1011 {
1012 return Add( new wxSizerItem(sizer, flags) );
1013 }
1014
1015 inline wxSizerItem*
1016 wxSizer::Add( int width, int height, const wxSizerFlags& flags )
1017 {
1018 return Add( new wxSizerItem(width, height, flags) );
1019 }
1020
1021 inline wxSizerItem*
1022 wxSizer::AddSpacer(int size)
1023 {
1024 return Add(size, size);
1025 }
1026
1027 inline wxSizerItem*
1028 wxSizer::AddStretchSpacer(int prop)
1029 {
1030 return Add(0, 0, prop);
1031 }
1032
1033 inline wxSizerItem*
1034 wxSizer::Prepend( wxSizerItem *item )
1035 {
1036 return Insert( 0, item );
1037 }
1038
1039 inline wxSizerItem*
1040 wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
1041 {
1042 return Prepend( new wxSizerItem( window, proportion, flag, border, userData ) );
1043 }
1044
1045 inline wxSizerItem*
1046 wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
1047 {
1048 return Prepend( new wxSizerItem( sizer, proportion, flag, border, userData ) );
1049 }
1050
1051 inline wxSizerItem*
1052 wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
1053 {
1054 return Prepend( new wxSizerItem( width, height, proportion, flag, border, userData ) );
1055 }
1056
1057 inline wxSizerItem*
1058 wxSizer::PrependSpacer(int size)
1059 {
1060 return Prepend(size, size);
1061 }
1062
1063 inline wxSizerItem*
1064 wxSizer::PrependStretchSpacer(int prop)
1065 {
1066 return Prepend(0, 0, prop);
1067 }
1068
1069 inline wxSizerItem*
1070 wxSizer::Prepend( wxWindow *window, const wxSizerFlags& flags )
1071 {
1072 return Prepend( new wxSizerItem(window, flags) );
1073 }
1074
1075 inline wxSizerItem*
1076 wxSizer::Prepend( wxSizer *sizer, const wxSizerFlags& flags )
1077 {
1078 return Prepend( new wxSizerItem(sizer, flags) );
1079 }
1080
1081 inline wxSizerItem*
1082 wxSizer::Prepend( int width, int height, const wxSizerFlags& flags )
1083 {
1084 return Prepend( new wxSizerItem(width, height, flags) );
1085 }
1086
1087 inline wxSizerItem*
1088 wxSizer::Insert( size_t index,
1089 wxWindow *window,
1090 int proportion,
1091 int flag,
1092 int border,
1093 wxObject* userData )
1094 {
1095 return Insert( index, new wxSizerItem( window, proportion, flag, border, userData ) );
1096 }
1097
1098 inline wxSizerItem*
1099 wxSizer::Insert( size_t index,
1100 wxSizer *sizer,
1101 int proportion,
1102 int flag,
1103 int border,
1104 wxObject* userData )
1105 {
1106 return Insert( index, new wxSizerItem( sizer, proportion, flag, border, userData ) );
1107 }
1108
1109 inline wxSizerItem*
1110 wxSizer::Insert( size_t index,
1111 int width,
1112 int height,
1113 int proportion,
1114 int flag,
1115 int border,
1116 wxObject* userData )
1117 {
1118 return Insert( index, new wxSizerItem( width, height, proportion, flag, border, userData ) );
1119 }
1120
1121 inline wxSizerItem*
1122 wxSizer::Insert( size_t index, wxWindow *window, const wxSizerFlags& flags )
1123 {
1124 return Insert( index, new wxSizerItem(window, flags) );
1125 }
1126
1127 inline wxSizerItem*
1128 wxSizer::Insert( size_t index, wxSizer *sizer, const wxSizerFlags& flags )
1129 {
1130 return Insert( index, new wxSizerItem(sizer, flags) );
1131 }
1132
1133 inline wxSizerItem*
1134 wxSizer::Insert( size_t index, int width, int height, const wxSizerFlags& flags )
1135 {
1136 return Insert( index, new wxSizerItem(width, height, flags) );
1137 }
1138
1139 inline wxSizerItem*
1140 wxSizer::InsertSpacer(size_t index, int size)
1141 {
1142 return Insert(index, size, size);
1143 }
1144
1145 inline wxSizerItem*
1146 wxSizer::InsertStretchSpacer(size_t index, int prop)
1147 {
1148 return Insert(index, 0, 0, prop);
1149 }
1150
1151 #endif // __WXSIZER_H__