-
Notifications
You must be signed in to change notification settings - Fork 1.7k
/
sizer.h
1357 lines (1095 loc) · 41.2 KB
/
sizer.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/////////////////////////////////////////////////////////////////////////////
// Name: wx/sizer.h
// Purpose: provide wxSizer class for layout
// Author: Robert Roebling and Robin Dunn
// Modified by: Ron Lee, Vadim Zeitlin (wxSizerFlags)
// Created:
// Copyright: (c) Robin Dunn, Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __WXSIZER_H__
#define __WXSIZER_H__
#include "wx/defs.h"
#include "wx/window.h"
//---------------------------------------------------------------------------
// classes
//---------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxBoxSizer;
class WXDLLIMPEXP_FWD_CORE wxSizerItem;
class WXDLLIMPEXP_FWD_CORE wxSizer;
#ifndef wxUSE_BORDER_BY_DEFAULT
#define wxUSE_BORDER_BY_DEFAULT 1
#endif
// ----------------------------------------------------------------------------
// wxSizerFlags: flags used for an item in the sizer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSizerFlags
{
public:
// construct the flags object initialized with the given proportion (0 by
// default)
wxSizerFlags(int proportion = 0) : m_proportion(proportion)
{
m_flags = 0;
m_borderInPixels = 0;
}
// setters for all sizer flags, they all return the object itself so that
// calls to them can be chained
wxSizerFlags& Proportion(int proportion)
{
m_proportion = proportion;
return *this;
}
wxSizerFlags& Expand()
{
m_flags |= wxEXPAND;
return *this;
}
// notice that Align() replaces the current alignment flags, use specific
// methods below such as Top(), Left() &c if you want to set just the
// vertical or horizontal alignment
wxSizerFlags& Align(int alignment) // combination of wxAlignment values
{
m_flags &= ~wxALIGN_MASK;
m_flags |= alignment;
return *this;
}
// this is just a shortcut for Align()
wxSizerFlags& Centre() { return Align(wxALIGN_CENTRE); }
wxSizerFlags& Center() { return Centre(); }
// but all the remaining methods turn on the corresponding alignment flag
// without affecting the existing ones
wxSizerFlags& CentreVertical()
{
m_flags = (m_flags & ~wxALIGN_BOTTOM) | wxALIGN_CENTRE_VERTICAL;
return *this;
}
wxSizerFlags& CenterVertical() { return CentreVertical(); }
wxSizerFlags& CentreHorizontal()
{
m_flags = (m_flags & ~wxALIGN_RIGHT) | wxALIGN_CENTRE_HORIZONTAL;
return *this;
}
wxSizerFlags& CenterHorizontal() { return CentreHorizontal(); }
wxSizerFlags& Top()
{
m_flags &= ~(wxALIGN_BOTTOM | wxALIGN_CENTRE_VERTICAL);
return *this;
}
wxSizerFlags& Left()
{
m_flags &= ~(wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL);
return *this;
}
wxSizerFlags& Right()
{
m_flags = (m_flags & ~wxALIGN_CENTRE_HORIZONTAL) | wxALIGN_RIGHT;
return *this;
}
wxSizerFlags& Bottom()
{
m_flags = (m_flags & ~wxALIGN_CENTRE_VERTICAL) | wxALIGN_BOTTOM;
return *this;
}
// default border size used by Border() below
static int GetDefaultBorder()
{
return wxRound(GetDefaultBorderFractional());
}
static float GetDefaultBorderFractional()
{
#if wxUSE_BORDER_BY_DEFAULT
#ifdef __WXGTK20__
// GNOME HIG says to use 6px as the base unit:
// http://library.gnome.org/devel/hig-book/stable/design-window.html.en
return 6;
#elif defined(__WXMAC__)
// Not sure if this is really the correct size for the border.
return 5;
#else
// For the other platforms, we need to scale raw pixel values using the
// current DPI, do it once (and cache the result) in another function.
#define wxNEEDS_BORDER_IN_PX
return DoGetDefaultBorderInPx();
#endif
#else
return 0;
#endif
}
wxSizerFlags& Border(int direction, int borderInPixels)
{
wxCHECK_MSG( !(direction & ~wxALL), *this,
wxS("direction must be a combination of wxDirection ")
wxS("enum values.") );
m_flags &= ~wxALL;
m_flags |= direction;
m_borderInPixels = borderInPixels;
return *this;
}
wxSizerFlags& Border(int direction = wxALL)
{
#if wxUSE_BORDER_BY_DEFAULT
return Border(direction, wxRound(GetDefaultBorderFractional()));
#else
// no borders by default on limited size screen
wxUnusedVar(direction);
return *this;
#endif
}
wxSizerFlags& DoubleBorder(int direction = wxALL)
{
#if wxUSE_BORDER_BY_DEFAULT
return Border(direction, wxRound(2 * GetDefaultBorderFractional()));
#else
wxUnusedVar(direction);
return *this;
#endif
}
wxSizerFlags& TripleBorder(int direction = wxALL)
{
#if wxUSE_BORDER_BY_DEFAULT
return Border(direction, wxRound(3 * GetDefaultBorderFractional()));
#else
wxUnusedVar(direction);
return *this;
#endif
}
wxSizerFlags& HorzBorder()
{
#if wxUSE_BORDER_BY_DEFAULT
return Border(wxLEFT | wxRIGHT, wxRound(GetDefaultBorderFractional()));
#else
return *this;
#endif
}
wxSizerFlags& DoubleHorzBorder()
{
#if wxUSE_BORDER_BY_DEFAULT
return Border(wxLEFT | wxRIGHT, wxRound(2 * GetDefaultBorderFractional()));
#else
return *this;
#endif
}
// setters for the others flags
wxSizerFlags& Shaped()
{
m_flags |= wxSHAPED;
return *this;
}
wxSizerFlags& FixedMinSize()
{
m_flags |= wxFIXED_MINSIZE;
return *this;
}
// makes the item ignore window's visibility status
wxSizerFlags& ReserveSpaceEvenIfHidden()
{
m_flags |= wxRESERVE_SPACE_EVEN_IF_HIDDEN;
return *this;
}
// accessors for wxSizer only
int GetProportion() const { return m_proportion; }
int GetFlags() const { return m_flags; }
int GetBorderInPixels() const { return m_borderInPixels; }
// Disablee sizer flags (in)consistency asserts.
static void DisableConsistencyChecks();
private:
#ifdef wxNEEDS_BORDER_IN_PX
static float DoGetDefaultBorderInPx();
#endif // wxNEEDS_BORDER_IN_PX
int m_proportion;
int m_flags;
int m_borderInPixels;
};
// ----------------------------------------------------------------------------
// wxSizerSpacer: used by wxSizerItem to represent a spacer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSizerSpacer
{
public:
wxSizerSpacer(const wxSize& size) : m_size(size), m_isShown(true) { }
void SetSize(const wxSize& size) { m_size = size; }
const wxSize& GetSize() const { return m_size; }
void Show(bool show) { m_isShown = show; }
bool IsShown() const { return m_isShown; }
private:
// the size, in pixel
wxSize m_size;
// is the spacer currently shown?
bool m_isShown;
};
// ----------------------------------------------------------------------------
// wxSizerItem
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSizerItem : public wxObject
{
public:
// window
wxSizerItem( wxWindow *window,
int proportion=0,
int flag=0,
int border=0,
wxObject* userData=NULL );
// window with flags
wxSizerItem(wxWindow *window, const wxSizerFlags& flags)
{
Init(flags);
DoSetWindow(window);
}
// subsizer
wxSizerItem( wxSizer *sizer,
int proportion=0,
int flag=0,
int border=0,
wxObject* userData=NULL );
// sizer with flags
wxSizerItem(wxSizer *sizer, const wxSizerFlags& flags)
{
Init(flags);
DoSetSizer(sizer);
}
// spacer
wxSizerItem( int width,
int height,
int proportion=0,
int flag=0,
int border=0,
wxObject* userData=NULL);
// spacer with flags
wxSizerItem(int width, int height, const wxSizerFlags& flags)
{
Init(flags);
DoSetSpacer(wxSize(width, height));
}
wxSizerItem();
virtual ~wxSizerItem();
virtual void DeleteWindows();
// Enable deleting the SizerItem without destroying the contained sizer.
void DetachSizer() { m_sizer = NULL; }
// Enable deleting the SizerItem without resetting the sizer in the
// contained window.
void DetachWindow() { m_window = NULL; m_kind = Item_None; }
virtual wxSize GetSize() const;
virtual wxSize CalcMin();
virtual void SetDimension( const wxPoint& pos, const wxSize& size );
wxSize GetMinSize() const
{ return m_minSize; }
wxSize GetMinSizeWithBorder() const;
wxSize GetMaxSize() const
{ return IsWindow() ? m_window->GetMaxSize() : wxDefaultSize; }
wxSize GetMaxSizeWithBorder() const;
void SetMinSize(const wxSize& size)
{
if ( IsWindow() )
m_window->SetMinSize(size);
m_minSize = size;
}
void SetMinSize( int x, int y )
{ SetMinSize(wxSize(x, y)); }
void SetInitSize( int x, int y )
{ SetMinSize(wxSize(x, y)); }
// if either of dimensions is zero, ratio is assumed to be 1
// to avoid "divide by zero" errors
void SetRatio(int width, int height)
{ m_ratio = (width && height) ? ((float) width / (float) height) : 1; }
void SetRatio(const wxSize& size)
{ SetRatio(size.x, size.y); }
void SetRatio(float ratio)
{ m_ratio = ratio; }
float GetRatio() const
{ return m_ratio; }
virtual wxRect GetRect() { return m_rect; }
// set a sizer item id (different from a window id, all sizer items,
// including spacers, can have an associated id)
void SetId(int id) { m_id = id; }
int GetId() const { return m_id; }
bool IsWindow() const { return m_kind == Item_Window; }
bool IsSizer() const { return m_kind == Item_Sizer; }
bool IsSpacer() const { return m_kind == Item_Spacer; }
void SetProportion( int proportion )
{ m_proportion = proportion; }
int GetProportion() const
{ return m_proportion; }
void SetFlag( int flag )
{ m_flag = flag; }
int GetFlag() const
{ return m_flag; }
void SetBorder( int border )
{ m_border = border; }
int GetBorder() const
{ return m_border; }
wxWindow *GetWindow() const
{ return m_kind == Item_Window ? m_window : NULL; }
wxSizer *GetSizer() const
{ return m_kind == Item_Sizer ? m_sizer : NULL; }
wxSize GetSpacer() const;
// This function behaves obviously for the windows and spacers but for the
// sizers it returns true if any sizer element is shown and only returns
// false if all of them are hidden. Also, it always returns true if
// wxRESERVE_SPACE_EVEN_IF_HIDDEN flag was used.
bool IsShown() const;
void Show(bool show);
void SetUserData(wxObject* userData)
{ delete m_userData; m_userData = userData; }
wxObject* GetUserData() const
{ return m_userData; }
wxPoint GetPosition() const
{ return m_pos; }
// Called once the first component of an item has been decided. This is
// used in algorithms that depend on knowing the size in one direction
// before the min size in the other direction can be known.
// Returns true if it made use of the information (and min size was changed).
bool InformFirstDirection( int direction, int size, int availableOtherDir=-1 );
// these functions delete the current contents of the item if it's a sizer
// or a spacer but not if it is a window
void AssignWindow(wxWindow *window)
{
Free();
DoSetWindow(window);
}
void AssignSizer(wxSizer *sizer)
{
Free();
DoSetSizer(sizer);
}
void AssignSpacer(const wxSize& size)
{
Free();
DoSetSpacer(size);
}
void AssignSpacer(int w, int h) { AssignSpacer(wxSize(w, h)); }
#if WXWIN_COMPATIBILITY_2_8
// these functions do not free the old sizer/spacer and so can easily
// provoke the memory leaks and so shouldn't be used, use Assign() instead
wxDEPRECATED( void SetWindow(wxWindow *window) );
wxDEPRECATED( void SetSizer(wxSizer *sizer) );
wxDEPRECATED( void SetSpacer(const wxSize& size) );
wxDEPRECATED( void SetSpacer(int width, int height) );
#endif // WXWIN_COMPATIBILITY_2_8
protected:
// common part of several ctors
void Init() { m_userData = NULL; m_kind = Item_None; }
// common part of ctors taking wxSizerFlags
void Init(const wxSizerFlags& flags);
// free current contents
void Free();
// common parts of Set/AssignXXX()
void DoSetWindow(wxWindow *window);
void DoSetSizer(wxSizer *sizer);
void DoSetSpacer(const wxSize& size);
// Add the border specified for this item to the given size
// if it's != wxDefaultSize, just return wxDefaultSize otherwise.
wxSize AddBorderToSize(const wxSize& size) const;
// discriminated union: depending on m_kind one of the fields is valid
enum
{
Item_None,
Item_Window,
Item_Sizer,
Item_Spacer,
Item_Max
} m_kind;
union
{
wxWindow *m_window;
wxSizer *m_sizer;
wxSizerSpacer *m_spacer;
};
wxPoint m_pos;
wxSize m_minSize;
int m_proportion;
int m_border;
int m_flag;
int m_id;
// on screen rectangle of this item (not including borders)
wxRect m_rect;
// Aspect ratio can always be calculated from m_size,
// but this would cause precision loss when the window
// is shrunk. It is safer to preserve the initial value.
float m_ratio;
wxObject *m_userData;
private:
wxDECLARE_CLASS(wxSizerItem);
wxDECLARE_NO_COPY_CLASS(wxSizerItem);
};
WX_DECLARE_EXPORTED_LIST( wxSizerItem, wxSizerItemList );
//---------------------------------------------------------------------------
// wxSizer
//---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSizer: public wxObject, public wxClientDataContainer
{
public:
wxSizer() { m_containingWindow = NULL; }
virtual ~wxSizer();
// methods for adding elements to the sizer: there are Add/Insert/Prepend
// overloads for each of window/sizer/spacer/wxSizerItem
wxSizerItem* Add(wxWindow *window,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Add(wxSizer *sizer,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Add(int width,
int height,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Add( wxWindow *window, const wxSizerFlags& flags);
wxSizerItem* Add( wxSizer *sizer, const wxSizerFlags& flags);
wxSizerItem* Add( int width, int height, const wxSizerFlags& flags);
wxSizerItem* Add( wxSizerItem *item);
virtual wxSizerItem *AddSpacer(int size);
wxSizerItem* AddStretchSpacer(int prop = 1);
wxSizerItem* Insert(size_t index,
wxWindow *window,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Insert(size_t index,
wxSizer *sizer,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Insert(size_t index,
int width,
int height,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Insert(size_t index,
wxWindow *window,
const wxSizerFlags& flags);
wxSizerItem* Insert(size_t index,
wxSizer *sizer,
const wxSizerFlags& flags);
wxSizerItem* Insert(size_t index,
int width,
int height,
const wxSizerFlags& flags);
// NB: do _not_ override this function in the derived classes, this one is
// virtual for compatibility reasons only to allow old code overriding
// it to continue to work, override DoInsert() instead in the new code
virtual wxSizerItem* Insert(size_t index, wxSizerItem *item);
wxSizerItem* InsertSpacer(size_t index, int size);
wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1);
wxSizerItem* Prepend(wxWindow *window,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Prepend(wxSizer *sizer,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Prepend(int width,
int height,
int proportion = 0,
int flag = 0,
int border = 0,
wxObject* userData = NULL);
wxSizerItem* Prepend(wxWindow *window, const wxSizerFlags& flags);
wxSizerItem* Prepend(wxSizer *sizer, const wxSizerFlags& flags);
wxSizerItem* Prepend(int width, int height, const wxSizerFlags& flags);
wxSizerItem* Prepend(wxSizerItem *item);
wxSizerItem* PrependSpacer(int size);
wxSizerItem* PrependStretchSpacer(int prop = 1);
// set (or possibly unset if window is NULL) or get the window this sizer
// is used in
void SetContainingWindow(wxWindow *window);
wxWindow *GetContainingWindow() const { return m_containingWindow; }
virtual bool Remove( wxSizer *sizer );
virtual bool Remove( int index );
virtual bool Detach( wxWindow *window );
virtual bool Detach( wxSizer *sizer );
virtual bool Detach( int index );
virtual bool Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive = false );
virtual bool Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive = false );
virtual bool Replace( size_t index, wxSizerItem *newitem );
virtual void Clear( bool delete_windows = false );
virtual void DeleteWindows();
// Inform sizer about the first direction that has been decided (by parent item)
// Returns true if it made use of the information (and recalculated min size)
//
// Note that while this method doesn't do anything by default, it should
// almost always be overridden in the derived classes and should have been
// pure virtual if not for backwards compatibility constraints.
virtual bool InformFirstDirection( int WXUNUSED(direction), int WXUNUSED(size), int WXUNUSED(availableOtherDir) )
{ return false; }
void SetMinSize( int width, int height )
{ DoSetMinSize( width, height ); }
void SetMinSize( const wxSize& size )
{ DoSetMinSize( size.x, size.y ); }
// Searches recursively
bool SetItemMinSize( wxWindow *window, int width, int height )
{ return DoSetItemMinSize( window, width, height ); }
bool SetItemMinSize( wxWindow *window, const wxSize& size )
{ return DoSetItemMinSize( window, size.x, size.y ); }
// Searches recursively
bool SetItemMinSize( wxSizer *sizer, int width, int height )
{ return DoSetItemMinSize( sizer, width, height ); }
bool SetItemMinSize( wxSizer *sizer, const wxSize& size )
{ return DoSetItemMinSize( sizer, size.x, size.y ); }
bool SetItemMinSize( size_t index, int width, int height )
{ return DoSetItemMinSize( index, width, height ); }
bool SetItemMinSize( size_t index, const wxSize& size )
{ return DoSetItemMinSize( index, size.x, size.y ); }
wxSize GetSize() const
{ return m_size; }
wxPoint GetPosition() const
{ return m_position; }
// Calculate the minimal size or return m_minSize if bigger.
wxSize GetMinSize();
// These virtual functions are used by the layout algorithm: first
// CalcMin() is called to calculate the minimal size of the sizer and
// prepare for laying it out and then RepositionChildren() is called with
// this size to really update all the sizer items.
virtual wxSize CalcMin() = 0;
// This method should be overridden but isn't pure virtual for backwards
// compatibility.
virtual void RepositionChildren(const wxSize& WXUNUSED(minSize))
{
RecalcSizes();
}
// This is a deprecated version of RepositionChildren() which doesn't take
// the minimal size parameter which is not needed for very simple sizers
// but typically is for anything more complicated, so prefer to override
// RepositionChildren() in new code.
//
// If RepositionChildren() is not overridden, this method must be
// overridden, calling the base class version results in an assertion
// failure.
virtual void RecalcSizes();
virtual void Layout();
wxSize ComputeFittingClientSize(wxWindow *window);
wxSize ComputeFittingWindowSize(wxWindow *window);
wxSize Fit( wxWindow *window );
void FitInside( wxWindow *window );
void SetSizeHints( wxWindow *window );
#if WXWIN_COMPATIBILITY_2_8
// This only calls FitInside() since 2.9
wxDEPRECATED( void SetVirtualSizeHints( wxWindow *window ) );
#endif
wxSizerItemList& GetChildren()
{ return m_children; }
const wxSizerItemList& GetChildren() const
{ return m_children; }
void SetDimension(const wxPoint& pos, const wxSize& size)
{
m_position = pos;
m_size = size;
Layout();
// This call is required for wxWrapSizer to be able to calculate its
// minimal size correctly.
InformFirstDirection(wxHORIZONTAL, size.x, size.y);
}
void SetDimension(int x, int y, int width, int height)
{ SetDimension(wxPoint(x, y), wxSize(width, height)); }
size_t GetItemCount() const { return m_children.GetCount(); }
bool IsEmpty() const { return m_children.IsEmpty(); }
wxSizerItem* GetItem( wxWindow *window, bool recursive = false );
wxSizerItem* GetItem( wxSizer *sizer, bool recursive = false );
wxSizerItem* GetItem( size_t index );
wxSizerItem* GetItemById( int id, bool recursive = false );
// Manage whether individual scene items are considered
// in the layout calculations or not.
bool Show( wxWindow *window, bool show = true, bool recursive = false );
bool Show( wxSizer *sizer, bool show = true, bool recursive = false );
bool Show( size_t index, bool show = true );
bool Hide( wxSizer *sizer, bool recursive = false )
{ return Show( sizer, false, recursive ); }
bool Hide( wxWindow *window, bool recursive = false )
{ return Show( window, false, recursive ); }
bool Hide( size_t index )
{ return Show( index, false ); }
bool IsShown( wxWindow *window ) const;
bool IsShown( wxSizer *sizer ) const;
bool IsShown( size_t index ) const;
// Recursively call wxWindow::Show () on all sizer items.
virtual void ShowItems (bool show);
void Show(bool show) { ShowItems(show); }
// This is the ShowItems() counterpart and returns true if any of the sizer
// items are shown.
virtual bool AreAnyItemsShown() const;
protected:
wxSize m_size;
wxSize m_minSize;
wxPoint m_position;
wxSizerItemList m_children;
// the window this sizer is used in, can be NULL
wxWindow *m_containingWindow;
wxSize GetMaxClientSize( wxWindow *window ) const;
wxSize GetMinClientSize( wxWindow *window );
wxSize VirtualFitSize( wxWindow *window );
virtual void DoSetMinSize( int width, int height );
virtual bool DoSetItemMinSize( wxWindow *window, int width, int height );
virtual bool DoSetItemMinSize( wxSizer *sizer, int width, int height );
virtual bool DoSetItemMinSize( size_t index, int width, int height );
// insert a new item into m_children at given index and return the item
// itself
virtual wxSizerItem* DoInsert(size_t index, wxSizerItem *item);
private:
wxDECLARE_CLASS(wxSizer);
};
//---------------------------------------------------------------------------
// wxGridSizer
//---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGridSizer: public wxSizer
{
public:
// ctors specifying the number of columns only: number of rows will be
// deduced automatically depending on the number of sizer elements
wxGridSizer( int cols, int vgap, int hgap );
wxGridSizer( int cols, const wxSize& gap = wxSize(0, 0) );
// ctors specifying the number of rows and columns
wxGridSizer( int rows, int cols, int vgap, int hgap );
wxGridSizer( int rows, int cols, const wxSize& gap );
virtual void RepositionChildren(const wxSize& minSize) wxOVERRIDE;
virtual wxSize CalcMin() wxOVERRIDE;
void SetCols( int cols )
{
wxASSERT_MSG( cols >= 0, "Number of columns must be non-negative");
m_cols = cols;
}
void SetRows( int rows )
{
wxASSERT_MSG( rows >= 0, "Number of rows must be non-negative");
m_rows = rows;
}
void SetVGap( int gap ) { m_vgap = gap; }
void SetHGap( int gap ) { m_hgap = gap; }
int GetCols() const { return m_cols; }
int GetRows() const { return m_rows; }
int GetVGap() const { return m_vgap; }
int GetHGap() const { return m_hgap; }
int GetEffectiveColsCount() const { return m_cols ? m_cols : CalcCols(); }
int GetEffectiveRowsCount() const { return m_rows ? m_rows : CalcRows(); }
// return the number of total items and the number of columns and rows
// (for internal use only)
int CalcRowsCols(int& rows, int& cols) const;
protected:
// the number of rows/columns in the sizer, if 0 then it is determined
// dynamically depending on the total number of items
int m_rows;
int m_cols;
// gaps between rows and columns
int m_vgap;
int m_hgap;
virtual wxSizerItem *DoInsert(size_t index, wxSizerItem *item) wxOVERRIDE;
void SetItemBounds( wxSizerItem *item, int x, int y, int w, int h );
// returns the number of columns/rows needed for the current total number
// of children (and the fixed number of rows/columns)
int CalcCols() const
{
wxCHECK_MSG
(
m_rows, 0,
"Can't calculate number of cols if number of rows is not specified"
);
return int(m_children.GetCount() + m_rows - 1) / m_rows;
}
int CalcRows() const
{
wxCHECK_MSG
(
m_cols, 0,
"Can't calculate number of cols if number of rows is not specified"
);
return int(m_children.GetCount() + m_cols - 1) / m_cols;
}
private:
wxDECLARE_CLASS(wxGridSizer);
};
//---------------------------------------------------------------------------
// wxFlexGridSizer
//---------------------------------------------------------------------------
// values which define the behaviour for resizing wxFlexGridSizer cells in the
// "non-flexible" direction
enum wxFlexSizerGrowMode
{
// don't resize the cells in non-flexible direction at all
wxFLEX_GROWMODE_NONE,
// uniformly resize only the specified ones (default)
wxFLEX_GROWMODE_SPECIFIED,
// uniformly resize all cells
wxFLEX_GROWMODE_ALL
};
class WXDLLIMPEXP_CORE wxFlexGridSizer: public wxGridSizer
{
public:
// ctors specifying the number of columns only: number of rows will be
// deduced automatically depending on the number of sizer elements
wxFlexGridSizer( int cols, int vgap, int hgap );
wxFlexGridSizer( int cols, const wxSize& gap = wxSize(0, 0) );
// ctors specifying the number of rows and columns
wxFlexGridSizer( int rows, int cols, int vgap, int hgap );
wxFlexGridSizer( int rows, int cols, const wxSize& gap );
// dtor
virtual ~wxFlexGridSizer();
// set the rows/columns which will grow (the others will remain of the
// constant initial size)
void AddGrowableRow( size_t idx, int proportion = 0 );
void RemoveGrowableRow( size_t idx );
void AddGrowableCol( size_t idx, int proportion = 0 );
void RemoveGrowableCol( size_t idx );
bool IsRowGrowable( size_t idx );
bool IsColGrowable( size_t idx );
// the sizer cells may grow in both directions, not grow at all or only
// grow in one direction but not the other
// the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
void SetFlexibleDirection(int direction) { m_flexDirection = direction; }
int GetFlexibleDirection() const { return m_flexDirection; }
// note that the grow mode only applies to the direction which is not
// flexible
void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) { m_growMode = mode; }
wxFlexSizerGrowMode GetNonFlexibleGrowMode() const { return m_growMode; }
// Read-only access to the row heights and col widths arrays
const wxArrayInt& GetRowHeights() const { return m_rowHeights; }
const wxArrayInt& GetColWidths() const { return m_colWidths; }
// implementation
virtual void RepositionChildren(const wxSize& minSize) wxOVERRIDE;
virtual wxSize CalcMin() wxOVERRIDE;
protected:
void AdjustForFlexDirection();
void AdjustForGrowables(const wxSize& sz, const wxSize& minSize);
wxSize FindWidthsAndHeights(int nrows, int ncols);
// the heights/widths of all rows/columns
wxArrayInt m_rowHeights,
m_colWidths;
// indices of the growable columns and rows
wxArrayInt m_growableRows,
m_growableCols;
// proportion values of the corresponding growable rows and columns
wxArrayInt m_growableRowsProportions,
m_growableColsProportions;
// parameters describing whether the growable cells should be resized in
// both directions or only one
int m_flexDirection;
wxFlexSizerGrowMode m_growMode;
private:
wxDECLARE_CLASS(wxFlexGridSizer);
wxDECLARE_NO_COPY_CLASS(wxFlexGridSizer);
};
//---------------------------------------------------------------------------
// wxBoxSizer
//---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBoxSizer: public wxSizer
{
public:
wxBoxSizer(int orient)
{
m_orient = orient;
m_totalProportion = 0;
wxASSERT_MSG( m_orient == wxHORIZONTAL || m_orient == wxVERTICAL,
wxT("invalid value for wxBoxSizer orientation") );
}
virtual wxSizerItem *AddSpacer(int size) wxOVERRIDE;
int GetOrientation() const { return m_orient; }
bool IsVertical() const { return m_orient == wxVERTICAL; }
void SetOrientation(int orient) { m_orient = orient; }
// implementation of our resizing logic
virtual wxSize CalcMin() wxOVERRIDE;
virtual void RepositionChildren(const wxSize& minSize) wxOVERRIDE;
virtual bool InformFirstDirection(int direction,
int size,
int availableOtherDir) wxOVERRIDE;
protected:
// Only overridden to perform extra debugging checks.
virtual wxSizerItem *DoInsert(size_t index, wxSizerItem *item) wxOVERRIDE;