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