]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/sizer.h
VC5 didn't support partial specialization either, check for VC>=7
[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 WXDLLEXPORT 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& 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
178private:
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
189class WXDLLEXPORT wxSizerSpacer
190{
191public:
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
200private:
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
212class WXDLLEXPORT wxSizerItem : public wxObject
213{
214public:
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 // Called once the first component of an item has been decided. This is
349 // used in algorithms that depend on knowing the size in one direction
350 // before the min size in the other direction can be known.
351 // Returns true if it made use of the information (and min size was changed).
352 bool InformFirstDirection( int direction, int size, int availableOtherDir=-1 );
353
354 // these functions delete the current contents of the item if it's a sizer
355 // or a spacer but not if it is a window
356 void AssignWindow(wxWindow *window)
357 {
358 Free();
359 DoSetWindow(window);
360 }
361
362 void AssignSizer(wxSizer *sizer)
363 {
364 Free();
365 DoSetSizer(sizer);
366 }
367
368 void AssignSpacer(const wxSize& size)
369 {
370 Free();
371 DoSetSpacer(size);
372 }
373
374 void AssignSpacer(int w, int h) { AssignSpacer(wxSize(w, h)); }
375
376#if WXWIN_COMPATIBILITY_2_8
377 // these functions do not free the old sizer/spacer and so can easily
378 // provoke the memory leaks and so shouldn't be used, use Assign() instead
379 wxDEPRECATED( void SetWindow(wxWindow *window) );
380 wxDEPRECATED( void SetSizer(wxSizer *sizer) );
381 wxDEPRECATED( void SetSpacer(const wxSize& size) );
382 wxDEPRECATED( void SetSpacer(int width, int height) );
383#endif // WXWIN_COMPATIBILITY_2_8
384
385protected:
386 // common part of several ctors
387 void Init() { m_userData = NULL; m_kind = Item_None; }
388
389 // common part of ctors taking wxSizerFlags
390 void Init(const wxSizerFlags& flags);
391
392 // free current contents
393 void Free();
394
395 // common parts of Set/AssignXXX()
396 void DoSetWindow(wxWindow *window);
397 void DoSetSizer(wxSizer *sizer);
398 void DoSetSpacer(const wxSize& size);
399
400 // discriminated union: depending on m_kind one of the fields is valid
401 enum
402 {
403 Item_None,
404 Item_Window,
405 Item_Sizer,
406 Item_Spacer,
407 Item_Max
408 } m_kind;
409 union
410 {
411 wxWindow *m_window;
412 wxSizer *m_sizer;
413 wxSizerSpacer *m_spacer;
414 };
415
416 wxPoint m_pos;
417 wxSize m_minSize;
418 int m_proportion;
419 int m_border;
420 int m_flag;
421 int m_id;
422
423 // on screen rectangle of this item (not including borders)
424 wxRect m_rect;
425
426 // Aspect ratio can always be calculated from m_size,
427 // but this would cause precision loss when the window
428 // is shrunk. It is safer to preserve the initial value.
429 float m_ratio;
430
431 wxObject *m_userData;
432
433private:
434 DECLARE_CLASS(wxSizerItem)
435 DECLARE_NO_COPY_CLASS(wxSizerItem)
436};
437
438WX_DECLARE_EXPORTED_LIST( wxSizerItem, wxSizerItemList );
439
440
441//---------------------------------------------------------------------------
442// wxSizer
443//---------------------------------------------------------------------------
444
445class WXDLLEXPORT wxSizer: public wxObject, public wxClientDataContainer
446{
447public:
448 wxSizer() { m_containingWindow = NULL; }
449 virtual ~wxSizer();
450
451 // methods for adding elements to the sizer: there are Add/Insert/Prepend
452 // overloads for each of window/sizer/spacer/wxSizerItem
453 wxSizerItem* Add(wxWindow *window,
454 int proportion = 0,
455 int flag = 0,
456 int border = 0,
457 wxObject* userData = NULL);
458 wxSizerItem* Add(wxSizer *sizer,
459 int proportion = 0,
460 int flag = 0,
461 int border = 0,
462 wxObject* userData = NULL);
463 wxSizerItem* Add(int width,
464 int height,
465 int proportion = 0,
466 int flag = 0,
467 int border = 0,
468 wxObject* userData = NULL);
469 wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags);
470 wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags);
471 wxSizerItem* Add( int width, int height, const wxSizerFlags& flags);
472 wxSizerItem* Add( wxSizerItem *item);
473
474 wxSizerItem* AddSpacer(int size);
475 wxSizerItem* AddStretchSpacer(int prop = 1);
476
477 wxSizerItem* Insert(size_t index,
478 wxWindow *window,
479 int proportion = 0,
480 int flag = 0,
481 int border = 0,
482 wxObject* userData = NULL);
483 wxSizerItem* Insert(size_t index,
484 wxSizer *sizer,
485 int proportion = 0,
486 int flag = 0,
487 int border = 0,
488 wxObject* userData = NULL);
489 wxSizerItem* Insert(size_t index,
490 int width,
491 int height,
492 int proportion = 0,
493 int flag = 0,
494 int border = 0,
495 wxObject* userData = NULL);
496 wxSizerItem* Insert(size_t index,
497 wxWindow *window,
498 const wxSizerFlags& flags);
499 wxSizerItem* Insert(size_t index,
500 wxSizer *sizer,
501 const wxSizerFlags& flags);
502 wxSizerItem* Insert(size_t index,
503 int width,
504 int height,
505 const wxSizerFlags& flags);
506 virtual wxSizerItem* Insert( size_t index, wxSizerItem *item);
507
508 wxSizerItem* InsertSpacer(size_t index, int size);
509 wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
510
511 wxSizerItem* Prepend(wxWindow *window,
512 int proportion = 0,
513 int flag = 0,
514 int border = 0,
515 wxObject* userData = NULL);
516 wxSizerItem* Prepend(wxSizer *sizer,
517 int proportion = 0,
518 int flag = 0,
519 int border = 0,
520 wxObject* userData = NULL);
521 wxSizerItem* Prepend(int width,
522 int height,
523 int proportion = 0,
524 int flag = 0,
525 int border = 0,
526 wxObject* userData = NULL);
527 wxSizerItem* Prepend(wxWindow *window, const wxSizerFlags& flags);
528 wxSizerItem* Prepend(wxSizer *sizer, const wxSizerFlags& flags);
529 wxSizerItem* Prepend(int width, int height, const wxSizerFlags& flags);
530 wxSizerItem* Prepend(wxSizerItem *item);
531
532 wxSizerItem* PrependSpacer(int size);
533 wxSizerItem* PrependStretchSpacer(int prop = 1);
534
535 // set (or possibly unset if window is NULL) or get the window this sizer
536 // is used in
537 void SetContainingWindow(wxWindow *window);
538 wxWindow *GetContainingWindow() const { return m_containingWindow; }
539
540#if WXWIN_COMPATIBILITY_2_6
541 // Deprecated in 2.6 since historically it does not delete the window,
542 // use Detach instead.
543 wxDEPRECATED( virtual bool Remove( wxWindow *window ) );
544#endif // WXWIN_COMPATIBILITY_2_6
545
546 virtual bool Remove( wxSizer *sizer );
547 virtual bool Remove( int index );
548
549 virtual bool Detach( wxWindow *window );
550 virtual bool Detach( wxSizer *sizer );
551 virtual bool Detach( int index );
552
553 virtual bool Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive = false );
554 virtual bool Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive = false );
555 virtual bool Replace( size_t index, wxSizerItem *newitem );
556
557 virtual void Clear( bool delete_windows = false );
558 virtual void DeleteWindows();
559
560 // Inform sizer about the first direction that has been decided (by parent item)
561 // Returns true if it made use of the informtion (and recalculated min size)
562 virtual bool InformFirstDirection( int WXUNUSED(direction), int WXUNUSED(size), int WXUNUSED(availableOtherDir) )
563 { return false; }
564
565 void SetMinSize( int width, int height )
566 { DoSetMinSize( width, height ); }
567 void SetMinSize( const wxSize& size )
568 { DoSetMinSize( size.x, size.y ); }
569
570 // Searches recursively
571 bool SetItemMinSize( wxWindow *window, int width, int height )
572 { return DoSetItemMinSize( window, width, height ); }
573 bool SetItemMinSize( wxWindow *window, const wxSize& size )
574 { return DoSetItemMinSize( window, size.x, size.y ); }
575
576 // Searches recursively
577 bool SetItemMinSize( wxSizer *sizer, int width, int height )
578 { return DoSetItemMinSize( sizer, width, height ); }
579 bool SetItemMinSize( wxSizer *sizer, const wxSize& size )
580 { return DoSetItemMinSize( sizer, size.x, size.y ); }
581
582 bool SetItemMinSize( size_t index, int width, int height )
583 { return DoSetItemMinSize( index, width, height ); }
584 bool SetItemMinSize( size_t index, const wxSize& size )
585 { return DoSetItemMinSize( index, size.x, size.y ); }
586
587 wxSize GetSize() const
588 { return m_size; }
589 wxPoint GetPosition() const
590 { return m_position; }
591
592 // Calculate the minimal size or return m_minSize if bigger.
593 wxSize GetMinSize();
594
595 // These virtual functions are used by the layout algorithm: first
596 // CalcMin() is called to calculate the minimal size of the sizer and
597 // prepare for laying it out and then RecalcSizes() is called to really
598 // update all the sizer items
599 virtual wxSize CalcMin() = 0;
600 virtual void RecalcSizes() = 0;
601
602 virtual void Layout();
603
604 wxSize Fit( wxWindow *window );
605 void FitInside( wxWindow *window );
606 void SetSizeHints( wxWindow *window );
607#if WXWIN_COMPATIBILITY_2_8
608 // This only calls FitInside() since 2.9
609 wxDEPRECATED( void SetVirtualSizeHints( wxWindow *window ) );
610#endif
611
612 wxSizerItemList& GetChildren()
613 { return m_children; }
614 const wxSizerItemList& GetChildren() const
615 { return m_children; }
616
617 void SetDimension( int x, int y, int width, int height );
618
619 wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
620 wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
621 wxSizerItem* GetItem( size_t index );
622 wxSizerItem* GetItemById( int id, bool recursive = false );
623
624 // Manage whether individual scene items are considered
625 // in the layout calculations or not.
626 bool Show( wxWindow *window, bool show = true, bool recursive = false );
627 bool Show( wxSizer *sizer, bool show = true, bool recursive = false );
628 bool Show( size_t index, bool show = true );
629
630 bool Hide( wxSizer *sizer, bool recursive = false )
631 { return Show( sizer, false, recursive ); }
632 bool Hide( wxWindow *window, bool recursive = false )
633 { return Show( window, false, recursive ); }
634 bool Hide( size_t index )
635 { return Show( index, false ); }
636
637 bool IsShown( wxWindow *window ) const;
638 bool IsShown( wxSizer *sizer ) const;
639 bool IsShown( size_t index ) const;
640
641 // Recursively call wxWindow::Show () on all sizer items.
642 virtual void ShowItems (bool show);
643
644 void Show(bool show) { ShowItems(show); }
645
646protected:
647 wxSize m_size;
648 wxSize m_minSize;
649 wxPoint m_position;
650 wxSizerItemList m_children;
651
652 // the window this sizer is used in, can be NULL
653 wxWindow *m_containingWindow;
654
655 wxSize GetMaxWindowSize( wxWindow *window ) const;
656 wxSize GetMinWindowSize( wxWindow *window );
657 wxSize GetMaxClientSize( wxWindow *window ) const;
658 wxSize GetMinClientSize( wxWindow *window );
659 wxSize VirtualFitSize( wxWindow *window );
660
661 virtual void DoSetMinSize( int width, int height );
662 virtual bool DoSetItemMinSize( wxWindow *window, int width, int height );
663 virtual bool DoSetItemMinSize( wxSizer *sizer, int width, int height );
664 virtual bool DoSetItemMinSize( size_t index, int width, int height );
665
666private:
667 DECLARE_CLASS(wxSizer)
668};
669
670//---------------------------------------------------------------------------
671// wxGridSizer
672//---------------------------------------------------------------------------
673
674class WXDLLEXPORT wxGridSizer: public wxSizer
675{
676public:
677 wxGridSizer( int rows, int cols, int vgap, int hgap );
678 wxGridSizer( int cols, int vgap = 0, int hgap = 0 );
679
680 virtual void RecalcSizes();
681 virtual wxSize CalcMin();
682
683 void SetCols( int cols ) { m_cols = cols; }
684 void SetRows( int rows ) { m_rows = rows; }
685 void SetVGap( int gap ) { m_vgap = gap; }
686 void SetHGap( int gap ) { m_hgap = gap; }
687 int GetCols() const { return m_cols; }
688 int GetRows() const { return m_rows; }
689 int GetVGap() const { return m_vgap; }
690 int GetHGap() const { return m_hgap; }
691
692protected:
693 int m_rows;
694 int m_cols;
695 int m_vgap;
696 int m_hgap;
697
698 // return the number of total items and the number of columns and rows
699 int CalcRowsCols(int& rows, int& cols) const;
700
701 void SetItemBounds( wxSizerItem *item, int x, int y, int w, int h );
702
703private:
704 DECLARE_CLASS(wxGridSizer)
705};
706
707//---------------------------------------------------------------------------
708// wxFlexGridSizer
709//---------------------------------------------------------------------------
710
711// the bevaiour for resizing wxFlexGridSizer cells in the "non-flexible"
712// direction
713enum wxFlexSizerGrowMode
714{
715 // don't resize the cells in non-flexible direction at all
716 wxFLEX_GROWMODE_NONE,
717
718 // uniformly resize only the specified ones (default)
719 wxFLEX_GROWMODE_SPECIFIED,
720
721 // uniformly resize all cells
722 wxFLEX_GROWMODE_ALL
723};
724
725class WXDLLEXPORT wxFlexGridSizer: public wxGridSizer
726{
727public:
728 // ctors/dtor
729 wxFlexGridSizer( int rows, int cols, int vgap, int hgap );
730 wxFlexGridSizer( int cols, int vgap = 0, int hgap = 0 );
731 virtual ~wxFlexGridSizer();
732
733
734 // set the rows/columns which will grow (the others will remain of the
735 // constant initial size)
736 void AddGrowableRow( size_t idx, int proportion = 0 );
737 void RemoveGrowableRow( size_t idx );
738 void AddGrowableCol( size_t idx, int proportion = 0 );
739 void RemoveGrowableCol( size_t idx );
740
741
742 // the sizer cells may grow in both directions, not grow at all or only
743 // grow in one direction but not the other
744
745 // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
746 void SetFlexibleDirection(int direction) { m_flexDirection = direction; }
747 int GetFlexibleDirection() const { return m_flexDirection; }
748
749 // note that the grow mode only applies to the direction which is not
750 // flexible
751 void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) { m_growMode = mode; }
752 wxFlexSizerGrowMode GetNonFlexibleGrowMode() const { return m_growMode; }
753
754 // Read-only access to the row heights and col widths arrays
755 const wxArrayInt& GetRowHeights() const { return m_rowHeights; }
756 const wxArrayInt& GetColWidths() const { return m_colWidths; }
757
758 // implementation
759 virtual void RecalcSizes();
760 virtual wxSize CalcMin();
761
762protected:
763 void AdjustForFlexDirection();
764 void AdjustForGrowables(const wxSize& sz);
765 void FindWidthsAndHeights(int nrows, int ncols);
766
767 // the heights/widths of all rows/columns
768 wxArrayInt m_rowHeights,
769 m_colWidths;
770
771 // indices of the growable columns and rows
772 wxArrayInt m_growableRows,
773 m_growableCols;
774
775 // proportion values of the corresponding growable rows and columns
776 wxArrayInt m_growableRowsProportions,
777 m_growableColsProportions;
778
779 // parameters describing whether the growable cells should be resized in
780 // both directions or only one
781 int m_flexDirection;
782 wxFlexSizerGrowMode m_growMode;
783
784 // saves CalcMin result to optimize RecalcSizes
785 wxSize m_calculatedMinSize;
786
787private:
788 DECLARE_CLASS(wxFlexGridSizer)
789 DECLARE_NO_COPY_CLASS(wxFlexGridSizer)
790};
791
792//---------------------------------------------------------------------------
793// wxBoxSizer
794//---------------------------------------------------------------------------
795
796class WXDLLEXPORT wxBoxSizer: public wxSizer
797{
798public:
799 wxBoxSizer(int orient)
800 {
801 m_orient = orient;
802 m_totalProportion = 0;
803
804 wxASSERT_MSG( m_orient == wxHORIZONTAL || m_orient == wxVERTICAL,
805 _T("invalid value for wxBoxSizer orientation") );
806 }
807
808 int GetOrientation() const { return m_orient; }
809
810 bool IsVertical() const { return m_orient == wxVERTICAL; }
811
812 void SetOrientation(int orient) { m_orient = orient; }
813
814 // implementation of our resizing logic
815 virtual wxSize CalcMin();
816 virtual void RecalcSizes();
817
818protected:
819 // helpers for our code: this returns the component of the given wxSize in
820 // the direction of the sizer and in the other direction, respectively
821 int GetSizeInMajorDir(const wxSize& sz) const
822 {
823 return m_orient == wxHORIZONTAL ? sz.x : sz.y;
824 }
825
826 int& SizeInMajorDir(wxSize& sz)
827 {
828 return m_orient == wxHORIZONTAL ? sz.x : sz.y;
829 }
830
831 int& PosInMajorDir(wxPoint& pt)
832 {
833 return m_orient == wxHORIZONTAL ? pt.x : pt.y;
834 }
835
836 int GetSizeInMinorDir(const wxSize& sz) const
837 {
838 return m_orient == wxHORIZONTAL ? sz.y : sz.x;
839 }
840
841 int& SizeInMinorDir(wxSize& sz)
842 {
843 return m_orient == wxHORIZONTAL ? sz.y : sz.x;
844 }
845
846 int& PosInMinorDir(wxPoint& pt)
847 {
848 return m_orient == wxHORIZONTAL ? pt.y : pt.x;
849 }
850
851 // another helper: creates wxSize from major and minor components
852 wxSize SizeFromMajorMinor(int major, int minor) const
853 {
854 if ( m_orient == wxHORIZONTAL )
855 {
856 return wxSize(major, minor);
857 }
858 else // wxVERTICAL
859 {
860 return wxSize(minor, major);
861 }
862 }
863
864
865 // either wxHORIZONTAL or wxVERTICAL
866 int m_orient;
867
868 // the sum of proportion of all of our elements
869 int m_totalProportion;
870
871 // the minimal size needed for this sizer as calculated by the last call to
872 // our CalcMin()
873 wxSize m_minSize;
874
875private:
876 DECLARE_CLASS(wxBoxSizer)
877};
878
879//---------------------------------------------------------------------------
880// wxWrapSizer - A box sizer that can wrap items on several lines when
881// widths exceed available width.
882//---------------------------------------------------------------------------
883
884// Borrow unused flag value
885#define wxEXTEND_LAST_ON_EACH_LINE wxFULL_REPAINT_ON_RESIZE
886
887class WXDLLEXPORT wxWrapSizer: public wxBoxSizer
888{
889public:
890 wxWrapSizer( int orient=wxHORIZONTAL, int flags=wxEXTEND_LAST_ON_EACH_LINE );
891 virtual ~wxWrapSizer();
892
893 virtual void RecalcSizes();
894 virtual wxSize CalcMin();
895
896 virtual bool InformFirstDirection( int direction, int size, int availableOtherDir );
897
898protected:
899 int m_prim_size_last; // Size in primary direction last time
900 int m_n_line; // Number of lines
901 wxBoxSizer m_rows; // Rows of items
902 int m_flags;
903
904 void AdjustPropLastItem(wxSizer *psz, wxSizerItem *itemLast);
905
906 DECLARE_DYNAMIC_CLASS(wxWrapSizer)
907};
908
909//---------------------------------------------------------------------------
910// wxStaticBoxSizer
911//---------------------------------------------------------------------------
912
913#if wxUSE_STATBOX
914
915class WXDLLIMPEXP_FWD_CORE wxStaticBox;
916
917class WXDLLEXPORT wxStaticBoxSizer: public wxBoxSizer
918{
919public:
920 wxStaticBoxSizer(wxStaticBox *box, int orient);
921 wxStaticBoxSizer(int orient, wxWindow *win, const wxString& label = wxEmptyString);
922 virtual ~wxStaticBoxSizer();
923
924 void RecalcSizes();
925 wxSize CalcMin();
926
927 wxStaticBox *GetStaticBox() const
928 { return m_staticBox; }
929
930 // override to hide/show the static box as well
931 virtual void ShowItems (bool show);
932
933 virtual bool Detach( wxWindow *window );
934 virtual bool Detach( wxSizer *sizer ) { return wxBoxSizer::Detach(sizer); }
935 virtual bool Detach( int index ) { return wxBoxSizer::Detach(index); }
936
937protected:
938 wxStaticBox *m_staticBox;
939
940private:
941 DECLARE_CLASS(wxStaticBoxSizer)
942 DECLARE_NO_COPY_CLASS(wxStaticBoxSizer)
943};
944
945#endif // wxUSE_STATBOX
946
947#if wxUSE_BUTTON
948
949class WXDLLEXPORT wxStdDialogButtonSizer: public wxBoxSizer
950{
951public:
952 // Constructor just creates a new wxBoxSizer, not much else.
953 // Box sizer orientation is automatically determined here:
954 // vertical for PDAs, horizontal for everything else?
955 wxStdDialogButtonSizer();
956
957 // Checks button ID against system IDs and sets one of the pointers below
958 // to this button. Does not do any sizer-related things here.
959 void AddButton(wxButton *button);
960
961 // Use these if no standard ID can/should be used
962 void SetAffirmativeButton( wxButton *button );
963 void SetNegativeButton( wxButton *button );
964 void SetCancelButton( wxButton *button );
965
966 // All platform-specific code here, checks which buttons exist and add
967 // them to the sizer accordingly.
968 // Note - one potential hack on Mac we could use here,
969 // if m_buttonAffirmative is wxID_SAVE then ensure wxID_SAVE
970 // is set to _("Save") and m_buttonNegative is set to _("Don't Save")
971 // I wouldn't add any other hacks like that into here,
972 // but this one I can see being useful.
973 void Realize();
974
975 wxButton *GetAffirmativeButton() const { return m_buttonAffirmative; }
976 wxButton *GetApplyButton() const { return m_buttonApply; }
977 wxButton *GetNegativeButton() const { return m_buttonNegative; }
978 wxButton *GetCancelButton() const { return m_buttonCancel; }
979 wxButton *GetHelpButton() const { return m_buttonHelp; }
980
981protected:
982 wxButton *m_buttonAffirmative; // wxID_OK, wxID_YES, wxID_SAVE go here
983 wxButton *m_buttonApply; // wxID_APPLY
984 wxButton *m_buttonNegative; // wxID_NO
985 wxButton *m_buttonCancel; // wxID_CANCEL, wxID_CLOSE
986 wxButton *m_buttonHelp; // wxID_HELP, wxID_CONTEXT_HELP
987
988private:
989 DECLARE_CLASS(wxStdDialogButtonSizer)
990 DECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer)
991};
992
993#endif // wxUSE_BUTTON
994
995
996// ----------------------------------------------------------------------------
997// inline functions implementation
998// ----------------------------------------------------------------------------
999
1000#if WXWIN_COMPATIBILITY_2_8
1001
1002inline void wxSizerItem::SetWindow(wxWindow *window)
1003{
1004 DoSetWindow(window);
1005}
1006
1007inline void wxSizerItem::SetSizer(wxSizer *sizer)
1008{
1009 DoSetSizer(sizer);
1010}
1011
1012inline void wxSizerItem::SetSpacer(const wxSize& size)
1013{
1014 DoSetSpacer(size);
1015}
1016
1017inline void wxSizerItem::SetSpacer(int width, int height)
1018{
1019 DoSetSpacer(wxSize(width, height));
1020}
1021
1022#endif // WXWIN_COMPATIBILITY_2_8
1023
1024
1025inline wxSizerItem*
1026wxSizer::Add( wxSizerItem *item )
1027{
1028 return Insert( m_children.GetCount(), item );
1029}
1030
1031inline wxSizerItem*
1032wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
1033{
1034 return Add( new wxSizerItem( window, proportion, flag, border, userData ) );
1035}
1036
1037inline wxSizerItem*
1038wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
1039{
1040 return Add( new wxSizerItem( sizer, proportion, flag, border, userData ) );
1041}
1042
1043inline wxSizerItem*
1044wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
1045{
1046 return Add( new wxSizerItem( width, height, proportion, flag, border, userData ) );
1047}
1048
1049inline wxSizerItem*
1050wxSizer::Add( wxWindow *window, const wxSizerFlags& flags )
1051{
1052 return Add( new wxSizerItem(window, flags) );
1053}
1054
1055inline wxSizerItem*
1056wxSizer::Add( wxSizer *sizer, const wxSizerFlags& flags )
1057{
1058 return Add( new wxSizerItem(sizer, flags) );
1059}
1060
1061inline wxSizerItem*
1062wxSizer::Add( int width, int height, const wxSizerFlags& flags )
1063{
1064 return Add( new wxSizerItem(width, height, flags) );
1065}
1066
1067inline wxSizerItem*
1068wxSizer::AddSpacer(int size)
1069{
1070 return Add(size, size);
1071}
1072
1073inline wxSizerItem*
1074wxSizer::AddStretchSpacer(int prop)
1075{
1076 return Add(0, 0, prop);
1077}
1078
1079inline wxSizerItem*
1080wxSizer::Prepend( wxSizerItem *item )
1081{
1082 return Insert( 0, item );
1083}
1084
1085inline wxSizerItem*
1086wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
1087{
1088 return Prepend( new wxSizerItem( window, proportion, flag, border, userData ) );
1089}
1090
1091inline wxSizerItem*
1092wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
1093{
1094 return Prepend( new wxSizerItem( sizer, proportion, flag, border, userData ) );
1095}
1096
1097inline wxSizerItem*
1098wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
1099{
1100 return Prepend( new wxSizerItem( width, height, proportion, flag, border, userData ) );
1101}
1102
1103inline wxSizerItem*
1104wxSizer::PrependSpacer(int size)
1105{
1106 return Prepend(size, size);
1107}
1108
1109inline wxSizerItem*
1110wxSizer::PrependStretchSpacer(int prop)
1111{
1112 return Prepend(0, 0, prop);
1113}
1114
1115inline wxSizerItem*
1116wxSizer::Prepend( wxWindow *window, const wxSizerFlags& flags )
1117{
1118 return Prepend( new wxSizerItem(window, flags) );
1119}
1120
1121inline wxSizerItem*
1122wxSizer::Prepend( wxSizer *sizer, const wxSizerFlags& flags )
1123{
1124 return Prepend( new wxSizerItem(sizer, flags) );
1125}
1126
1127inline wxSizerItem*
1128wxSizer::Prepend( int width, int height, const wxSizerFlags& flags )
1129{
1130 return Prepend( new wxSizerItem(width, height, flags) );
1131}
1132
1133inline wxSizerItem*
1134wxSizer::Insert( size_t index,
1135 wxWindow *window,
1136 int proportion,
1137 int flag,
1138 int border,
1139 wxObject* userData )
1140{
1141 return Insert( index, new wxSizerItem( window, proportion, flag, border, userData ) );
1142}
1143
1144inline wxSizerItem*
1145wxSizer::Insert( size_t index,
1146 wxSizer *sizer,
1147 int proportion,
1148 int flag,
1149 int border,
1150 wxObject* userData )
1151{
1152 return Insert( index, new wxSizerItem( sizer, proportion, flag, border, userData ) );
1153}
1154
1155inline wxSizerItem*
1156wxSizer::Insert( size_t index,
1157 int width,
1158 int height,
1159 int proportion,
1160 int flag,
1161 int border,
1162 wxObject* userData )
1163{
1164 return Insert( index, new wxSizerItem( width, height, proportion, flag, border, userData ) );
1165}
1166
1167inline wxSizerItem*
1168wxSizer::Insert( size_t index, wxWindow *window, const wxSizerFlags& flags )
1169{
1170 return Insert( index, new wxSizerItem(window, flags) );
1171}
1172
1173inline wxSizerItem*
1174wxSizer::Insert( size_t index, wxSizer *sizer, const wxSizerFlags& flags )
1175{
1176 return Insert( index, new wxSizerItem(sizer, flags) );
1177}
1178
1179inline wxSizerItem*
1180wxSizer::Insert( size_t index, int width, int height, const wxSizerFlags& flags )
1181{
1182 return Insert( index, new wxSizerItem(width, height, flags) );
1183}
1184
1185inline wxSizerItem*
1186wxSizer::InsertSpacer(size_t index, int size)
1187{
1188 return Insert(index, size, size);
1189}
1190
1191inline wxSizerItem*
1192wxSizer::InsertStretchSpacer(size_t index, int prop)
1193{
1194 return Insert(index, 0, 0, prop);
1195}
1196
1197#endif // __WXSIZER_H__