]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/sizer.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
don't compile wxEventLoopManual for the ports which don't need it
[wxWidgets.git] / src / common / sizer.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: sizer.cpp
3// Purpose: provide new wxSizer class for layout
4// Author: Robert Roebling and Robin Dunn, contributions by
5// Dirk Holtwick, Ron Lee
6// Modified by: Ron Lee
7// Created:
8// RCS-ID: $Id$
9// Copyright: (c) Robin Dunn, Robert Roebling
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13// For compilers that support precompilation, includes "wx.h".
14#include "wx/wxprec.h"
15
16#ifdef __BORLANDC__
17 #pragma hdrstop
18#endif
19
20#ifndef WX_PRECOMP
21 #include "wx/string.h"
22 #include "wx/intl.h"
23 #include "wx/math.h"
24#endif // WX_PRECOMP
25
26#include "wx/sizer.h"
27#include "wx/utils.h"
28#include "wx/statbox.h"
29#include "wx/settings.h"
30#include "wx/listimpl.cpp"
31#include "wx/intl.h"
32#if WXWIN_COMPATIBILITY_2_4
33 #include "wx/notebook.h"
34#endif
35
36//---------------------------------------------------------------------------
37
38IMPLEMENT_CLASS(wxSizerItem, wxObject)
39IMPLEMENT_CLASS(wxSizer, wxObject)
40IMPLEMENT_CLASS(wxGridSizer, wxSizer)
41IMPLEMENT_CLASS(wxFlexGridSizer, wxGridSizer)
42IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
43#if wxUSE_STATBOX
44IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
45#endif
46#if wxUSE_BUTTON
47IMPLEMENT_CLASS(wxStdDialogButtonSizer, wxBoxSizer)
48#endif
49
50WX_DEFINE_EXPORTED_LIST( wxSizerItemList )
51
52/*
53 TODO PROPERTIES
54 sizeritem
55 object
56 object_ref
57 minsize
58 option
59 flag
60 border
61 spacer
62 option
63 flag
64 borfder
65 boxsizer
66 orient
67 staticboxsizer
68 orient
69 label
70 gridsizer
71 rows
72 cols
73 vgap
74 hgap
75 flexgridsizer
76 rows
77 cols
78 vgap
79 hgap
80 growablerows
81 growablecols
82 minsize
83*/
84
85// ----------------------------------------------------------------------------
86// wxSizerItem
87// ----------------------------------------------------------------------------
88
89void wxSizerItem::Init(const wxSizerFlags& flags)
90{
91 Init();
92
93 m_proportion = flags.GetProportion();
94 m_flag = flags.GetFlags();
95 m_border = flags.GetBorderInPixels();
96}
97
98wxSizerItem::wxSizerItem()
99{
100 Init();
101
102 m_proportion = 0;
103 m_border = 0;
104 m_flag = 0;
105
106 m_kind = Item_None;
107}
108
109// window item
110void wxSizerItem::SetWindow(wxWindow *window)
111{
112 wxCHECK_RET( window, _T("NULL window in wxSizerItem::SetWindow()") );
113
114 m_kind = Item_Window;
115 m_window = window;
116
117 // window doesn't become smaller than its initial size, whatever happens
118 m_minSize = window->GetSize();
119
120 if ( m_flag & wxFIXED_MINSIZE )
121 window->SetMinSize(m_minSize);
122
123 // aspect ratio calculated from initial size
124 SetRatio(m_minSize);
125}
126
127wxSizerItem::wxSizerItem(wxWindow *window,
128 int proportion,
129 int flag,
130 int border,
131 wxObject* userData)
132 : m_proportion(proportion),
133 m_border(border),
134 m_flag(flag),
135 m_userData(userData)
136{
137 SetWindow(window);
138}
139
140// sizer item
141void wxSizerItem::SetSizer(wxSizer *sizer)
142{
143 m_kind = Item_Sizer;
144 m_sizer = sizer;
145}
146
147wxSizerItem::wxSizerItem(wxSizer *sizer,
148 int proportion,
149 int flag,
150 int border,
151 wxObject* userData)
152 : m_proportion(proportion),
153 m_border(border),
154 m_flag(flag),
155 m_ratio(0.0),
156 m_userData(userData)
157{
158 SetSizer(sizer);
159
160 // m_minSize is set later
161}
162
163// spacer item
164void wxSizerItem::SetSpacer(const wxSize& size)
165{
166 m_kind = Item_Spacer;
167 m_spacer = new wxSizerSpacer(size);
168 m_minSize = size;
169 SetRatio(size);
170}
171
172wxSizerItem::wxSizerItem(int width,
173 int height,
174 int proportion,
175 int flag,
176 int border,
177 wxObject* userData)
178 : m_minSize(width, height), // minimal size is the initial size
179 m_proportion(proportion),
180 m_border(border),
181 m_flag(flag),
182 m_userData(userData)
183{
184 SetSpacer(width, height);
185}
186
187wxSizerItem::~wxSizerItem()
188{
189 delete m_userData;
190
191 switch ( m_kind )
192 {
193 case Item_None:
194 break;
195
196 case Item_Window:
197 m_window->SetContainingSizer(NULL);
198 break;
199
200 case Item_Sizer:
201 delete m_sizer;
202 break;
203
204 case Item_Spacer:
205 delete m_spacer;
206 break;
207
208 case Item_Max:
209 default:
210 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
211 }
212}
213
214wxSize wxSizerItem::GetSpacer() const
215{
216 wxSize size;
217 if ( m_kind == Item_Spacer )
218 size = m_spacer->GetSize();
219
220 return size;
221}
222
223
224wxSize wxSizerItem::GetSize() const
225{
226 wxSize ret;
227 switch ( m_kind )
228 {
229 case Item_None:
230 break;
231
232 case Item_Window:
233 ret = m_window->GetSize();
234 break;
235
236 case Item_Sizer:
237 ret = m_sizer->GetSize();
238 break;
239
240 case Item_Spacer:
241 ret = m_spacer->GetSize();
242 break;
243
244 case Item_Max:
245 default:
246 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
247 }
248
249 if (m_flag & wxWEST)
250 ret.x += m_border;
251 if (m_flag & wxEAST)
252 ret.x += m_border;
253 if (m_flag & wxNORTH)
254 ret.y += m_border;
255 if (m_flag & wxSOUTH)
256 ret.y += m_border;
257
258 return ret;
259}
260
261wxSize wxSizerItem::CalcMin()
262{
263 if (IsSizer())
264 {
265 m_minSize = m_sizer->GetMinSize();
266
267 // if we have to preserve aspect ratio _AND_ this is
268 // the first-time calculation, consider ret to be initial size
269 if ( (m_flag & wxSHAPED) && wxIsNullDouble(m_ratio) )
270 SetRatio(m_minSize);
271 }
272 else if ( IsWindow() )
273 {
274 // Since the size of the window may change during runtime, we
275 // should use the current minimal/best size.
276 m_minSize = m_window->GetBestFittingSize();
277 }
278
279 return GetMinSizeWithBorder();
280}
281
282wxSize wxSizerItem::GetMinSizeWithBorder() const
283{
284 wxSize ret = m_minSize;
285
286 if (m_flag & wxWEST)
287 ret.x += m_border;
288 if (m_flag & wxEAST)
289 ret.x += m_border;
290 if (m_flag & wxNORTH)
291 ret.y += m_border;
292 if (m_flag & wxSOUTH)
293 ret.y += m_border;
294
295 return ret;
296}
297
298
299void wxSizerItem::SetDimension( const wxPoint& pos_, const wxSize& size_ )
300{
301 wxPoint pos = pos_;
302 wxSize size = size_;
303 if (m_flag & wxSHAPED)
304 {
305 // adjust aspect ratio
306 int rwidth = (int) (size.y * m_ratio);
307 if (rwidth > size.x)
308 {
309 // fit horizontally
310 int rheight = (int) (size.x / m_ratio);
311 // add vertical space
312 if (m_flag & wxALIGN_CENTER_VERTICAL)
313 pos.y += (size.y - rheight) / 2;
314 else if (m_flag & wxALIGN_BOTTOM)
315 pos.y += (size.y - rheight);
316 // use reduced dimensions
317 size.y =rheight;
318 }
319 else if (rwidth < size.x)
320 {
321 // add horizontal space
322 if (m_flag & wxALIGN_CENTER_HORIZONTAL)
323 pos.x += (size.x - rwidth) / 2;
324 else if (m_flag & wxALIGN_RIGHT)
325 pos.x += (size.x - rwidth);
326 size.x = rwidth;
327 }
328 }
329
330 // This is what GetPosition() returns. Since we calculate
331 // borders afterwards, GetPosition() will be the left/top
332 // corner of the surrounding border.
333 m_pos = pos;
334
335 if (m_flag & wxWEST)
336 {
337 pos.x += m_border;
338 size.x -= m_border;
339 }
340 if (m_flag & wxEAST)
341 {
342 size.x -= m_border;
343 }
344 if (m_flag & wxNORTH)
345 {
346 pos.y += m_border;
347 size.y -= m_border;
348 }
349 if (m_flag & wxSOUTH)
350 {
351 size.y -= m_border;
352 }
353
354 m_rect = wxRect(pos, size);
355
356 switch ( m_kind )
357 {
358 case Item_None:
359 wxFAIL_MSG( _T("can't set size of uninitialized sizer item") );
360 break;
361
362 case Item_Window:
363 m_window->SetSize(pos.x, pos.y, size.x, size.y,
364 wxSIZE_ALLOW_MINUS_ONE);
365 break;
366
367 case Item_Sizer:
368 m_sizer->SetDimension(pos.x, pos.y, size.x, size.y);
369 break;
370
371 case Item_Spacer:
372 m_spacer->SetSize(size);
373 break;
374
375 case Item_Max:
376 default:
377 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
378 }
379}
380
381void wxSizerItem::DeleteWindows()
382{
383 switch ( m_kind )
384 {
385 case Item_None:
386 case Item_Spacer:
387 break;
388
389 case Item_Window:
390 //We are deleting the window from this sizer - normally
391 //the window destroys the sizer associated with it,
392 //which might destroy this, which we don't want
393 m_window->SetContainingSizer(NULL);
394 m_window->Destroy();
395 //Putting this after the switch will result in a spacer
396 //not being deleted properly on destruction
397 m_kind = Item_None;
398 break;
399
400 case Item_Sizer:
401 m_sizer->DeleteWindows();
402 break;
403
404 case Item_Max:
405 default:
406 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
407 }
408
409}
410
411void wxSizerItem::Show( bool show )
412{
413 switch ( m_kind )
414 {
415 case Item_None:
416 wxFAIL_MSG( _T("can't show uninitialized sizer item") );
417 break;
418
419 case Item_Window:
420 m_window->Show(show);
421 break;
422
423 case Item_Sizer:
424 m_sizer->Show(show);
425 break;
426
427 case Item_Spacer:
428 m_spacer->Show(show);
429 break;
430
431 case Item_Max:
432 default:
433 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
434 }
435}
436
437bool wxSizerItem::IsShown() const
438{
439 switch ( m_kind )
440 {
441 case Item_None:
442 // we may be called from CalcMin(), just return false so that we're
443 // not used
444 break;
445
446 case Item_Window:
447 return m_window->IsShown();
448
449 case Item_Sizer:
450 return m_sizer->IsShown();
451
452 case Item_Spacer:
453 return m_spacer->IsShown();
454
455 case Item_Max:
456 default:
457 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
458 }
459
460 return false;
461}
462
463void wxSizerItem::SetOption( int option )
464{
465 SetProportion( option );
466}
467
468int wxSizerItem::GetOption() const
469{
470 return GetProportion();
471}
472
473
474//---------------------------------------------------------------------------
475// wxSizer
476//---------------------------------------------------------------------------
477
478wxSizer::wxSizer()
479{
480 m_isShown = true;
481}
482
483wxSizer::~wxSizer()
484{
485 WX_CLEAR_LIST(wxSizerItemList, m_children);
486}
487
488wxSizerItem* wxSizer::Insert( size_t index, wxSizerItem *item )
489{
490 m_children.Insert( index, item );
491
492 if ( item->GetWindow() )
493 item->GetWindow()->SetContainingSizer( this );
494
495 return item;
496}
497
498bool wxSizer::Remove( wxWindow *window )
499{
500 return Detach( window );
501}
502
503bool wxSizer::Remove( wxSizer *sizer )
504{
505 wxASSERT_MSG( sizer, _T("Removing NULL sizer") );
506
507 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
508 while (node)
509 {
510 wxSizerItem *item = node->GetData();
511
512 if (item->GetSizer() == sizer)
513 {
514 delete item;
515 m_children.Erase( node );
516 return true;
517 }
518
519 node = node->GetNext();
520 }
521
522 return false;
523}
524
525bool wxSizer::Remove( int index )
526{
527 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
528 false,
529 _T("Remove index is out of range") );
530
531 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
532
533 wxCHECK_MSG( node, false, _T("Failed to find child node") );
534
535 wxSizerItem *item = node->GetData();
536
537 if ( item->IsWindow() )
538 item->GetWindow()->SetContainingSizer( NULL );
539
540 delete item;
541 m_children.Erase( node );
542 return true;
543}
544
545bool wxSizer::Detach( wxSizer *sizer )
546{
547 wxASSERT_MSG( sizer, _T("Detaching NULL sizer") );
548
549 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
550 while (node)
551 {
552 wxSizerItem *item = node->GetData();
553
554 if (item->GetSizer() == sizer)
555 {
556 item->DetachSizer();
557 delete item;
558 m_children.Erase( node );
559 return true;
560 }
561 node = node->GetNext();
562 }
563
564 return false;
565}
566
567bool wxSizer::Detach( wxWindow *window )
568{
569 wxASSERT_MSG( window, _T("Detaching NULL window") );
570
571 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
572 while (node)
573 {
574 wxSizerItem *item = node->GetData();
575
576 if (item->GetWindow() == window)
577 {
578 item->GetWindow()->SetContainingSizer( NULL );
579 delete item;
580 m_children.Erase( node );
581 return true;
582 }
583 node = node->GetNext();
584 }
585
586 return false;
587}
588
589bool wxSizer::Detach( int index )
590{
591 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
592 false,
593 _T("Detach index is out of range") );
594
595 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
596
597 wxCHECK_MSG( node, false, _T("Failed to find child node") );
598
599 wxSizerItem *item = node->GetData();
600
601 if ( item->IsSizer() )
602 item->DetachSizer();
603 else if ( item->IsWindow() )
604 item->GetWindow()->SetContainingSizer( NULL );
605
606 delete item;
607 m_children.Erase( node );
608 return true;
609}
610
611void wxSizer::Clear( bool delete_windows )
612{
613 // First clear the ContainingSizer pointers
614 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
615 while (node)
616 {
617 wxSizerItem *item = node->GetData();
618
619 if (item->IsWindow())
620 item->GetWindow()->SetContainingSizer( NULL );
621 node = node->GetNext();
622 }
623
624 // Destroy the windows if needed
625 if (delete_windows)
626 DeleteWindows();
627
628 // Now empty the list
629 WX_CLEAR_LIST(wxSizerItemList, m_children);
630}
631
632void wxSizer::DeleteWindows()
633{
634 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
635 while (node)
636 {
637 wxSizerItem *item = node->GetData();
638
639 item->DeleteWindows();
640 node = node->GetNext();
641 }
642}
643
644wxSize wxSizer::Fit( wxWindow *window )
645{
646 wxSize size(window->IsTopLevel() ? FitSize(window)
647 : GetMinWindowSize(window));
648
649 window->SetSize( size );
650
651 return size;
652}
653
654void wxSizer::FitInside( wxWindow *window )
655{
656 wxSize size;
657 if (window->IsTopLevel())
658 size = VirtualFitSize( window );
659 else
660 size = GetMinClientSize( window );
661
662 window->SetVirtualSize( size );
663}
664
665void wxSizer::Layout()
666{
667 // (re)calculates minimums needed for each item and other preparations
668 // for layout
669 CalcMin();
670
671 // Applies the layout and repositions/resizes the items
672 RecalcSizes();
673}
674
675void wxSizer::SetSizeHints( wxWindow *window )
676{
677 // Preserve the window's max size hints, but set the
678 // lower bound according to the sizer calculations.
679
680 wxSize size = Fit( window );
681
682 window->SetSizeHints( size.x,
683 size.y,
684 window->GetMaxWidth(),
685 window->GetMaxHeight() );
686}
687
688void wxSizer::SetVirtualSizeHints( wxWindow *window )
689{
690 // Preserve the window's max size hints, but set the
691 // lower bound according to the sizer calculations.
692
693 FitInside( window );
694 wxSize size( window->GetVirtualSize() );
695 window->SetVirtualSizeHints( size.x,
696 size.y,
697 window->GetMaxWidth(),
698 window->GetMaxHeight() );
699}
700
701wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
702{
703 return window->GetMaxSize();
704}
705
706wxSize wxSizer::GetMinWindowSize( wxWindow *window )
707{
708 wxSize minSize( GetMinSize() );
709 wxSize size( window->GetSize() );
710 wxSize client_size( window->GetClientSize() );
711
712 return wxSize( minSize.x+size.x-client_size.x,
713 minSize.y+size.y-client_size.y );
714}
715
716// TODO on mac we need a function that determines how much free space this
717// min size contains, in order to make sure that we have 20 pixels of free
718// space around the controls
719
720// Return a window size that will fit within the screens dimensions
721wxSize wxSizer::FitSize( wxWindow *window )
722{
723 wxSize size = GetMinWindowSize( window );
724 wxSize sizeMax = GetMaxWindowSize( window );
725
726 // Limit the size if sizeMax != wxDefaultSize
727
728 if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
729 size.x = sizeMax.x;
730 if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
731 size.y = sizeMax.y;
732
733 return size;
734}
735
736wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
737{
738 wxSize maxSize( window->GetMaxSize() );
739
740 if ( maxSize != wxDefaultSize )
741 {
742 wxSize size( window->GetSize() );
743 wxSize client_size( window->GetClientSize() );
744
745 return wxSize( maxSize.x + client_size.x - size.x,
746 maxSize.y + client_size.y - size.y );
747 }
748 else
749 return wxDefaultSize;
750}
751
752wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) )
753{
754 return GetMinSize(); // Already returns client size.
755}
756
757wxSize wxSizer::VirtualFitSize( wxWindow *window )
758{
759 wxSize size = GetMinClientSize( window );
760 wxSize sizeMax = GetMaxClientSize( window );
761
762 // Limit the size if sizeMax != wxDefaultSize
763
764 if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
765 size.x = sizeMax.x;
766 if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
767 size.y = sizeMax.y;
768
769 return size;
770}
771
772void wxSizer::SetDimension( int x, int y, int width, int height )
773{
774 m_position.x = x;
775 m_position.y = y;
776 m_size.x = width;
777 m_size.y = height;
778 Layout();
779}
780
781wxSize wxSizer::GetMinSize()
782{
783 wxSize ret( CalcMin() );
784 if (ret.x < m_minSize.x) ret.x = m_minSize.x;
785 if (ret.y < m_minSize.y) ret.y = m_minSize.y;
786 return ret;
787}
788
789void wxSizer::DoSetMinSize( int width, int height )
790{
791 m_minSize.x = width;
792 m_minSize.y = height;
793}
794
795bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
796{
797 wxASSERT_MSG( window, _T("SetMinSize for NULL window") );
798
799 // Is it our immediate child?
800
801 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
802 while (node)
803 {
804 wxSizerItem *item = node->GetData();
805
806 if (item->GetWindow() == window)
807 {
808 item->SetMinSize( width, height );
809 return true;
810 }
811 node = node->GetNext();
812 }
813
814 // No? Search any subsizers we own then
815
816 node = m_children.GetFirst();
817 while (node)
818 {
819 wxSizerItem *item = node->GetData();
820
821 if ( item->GetSizer() &&
822 item->GetSizer()->DoSetItemMinSize( window, width, height ) )
823 {
824 // A child sizer found the requested windw, exit.
825 return true;
826 }
827 node = node->GetNext();
828 }
829
830 return false;
831}
832
833bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
834{
835 wxASSERT_MSG( sizer, _T("SetMinSize for NULL sizer") );
836
837 // Is it our immediate child?
838
839 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
840 while (node)
841 {
842 wxSizerItem *item = node->GetData();
843
844 if (item->GetSizer() == sizer)
845 {
846 item->GetSizer()->DoSetMinSize( width, height );
847 return true;
848 }
849 node = node->GetNext();
850 }
851
852 // No? Search any subsizers we own then
853
854 node = m_children.GetFirst();
855 while (node)
856 {
857 wxSizerItem *item = node->GetData();
858
859 if ( item->GetSizer() &&
860 item->GetSizer()->DoSetItemMinSize( sizer, width, height ) )
861 {
862 // A child found the requested sizer, exit.
863 return true;
864 }
865 node = node->GetNext();
866 }
867
868 return false;
869}
870
871bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
872{
873 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
874
875 wxCHECK_MSG( node, false, _T("Failed to find child node") );
876
877 wxSizerItem *item = node->GetData();
878
879 if (item->GetSizer())
880 {
881 // Sizers contains the minimal size in them, if not calculated ...
882 item->GetSizer()->DoSetMinSize( width, height );
883 }
884 else
885 {
886 // ... but the minimal size of spacers and windows is stored via the item
887 item->SetMinSize( width, height );
888 }
889
890 return true;
891}
892
893wxSizerItem* wxSizer::GetItem( wxWindow *window, bool recursive )
894{
895 wxASSERT_MSG( window, _T("GetItem for NULL window") );
896
897 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
898 while (node)
899 {
900 wxSizerItem *item = node->GetData();
901
902 if (item->GetWindow() == window)
903 {
904 return item;
905 }
906 else if (recursive && item->IsSizer())
907 {
908 wxSizerItem *subitem = item->GetSizer()->GetItem( window, true );
909 if (subitem)
910 return subitem;
911 }
912
913 node = node->GetNext();
914 }
915
916 return NULL;
917}
918
919wxSizerItem* wxSizer::GetItem( wxSizer *sizer, bool recursive )
920{
921 wxASSERT_MSG( sizer, _T("GetItem for NULL sizer") );
922
923 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
924 while (node)
925 {
926 wxSizerItem *item = node->GetData();
927
928 if (item->GetSizer() == sizer)
929 {
930 return item;
931 }
932 else if (recursive && item->IsSizer())
933 {
934 wxSizerItem *subitem = item->GetSizer()->GetItem( sizer, true );
935 if (subitem)
936 return subitem;
937 }
938
939 node = node->GetNext();
940 }
941
942 return NULL;
943}
944
945wxSizerItem* wxSizer::GetItem( size_t index )
946{
947 wxCHECK_MSG( index < m_children.GetCount(),
948 NULL,
949 _T("GetItem index is out of range") );
950
951 return m_children.Item( index )->GetData();
952}
953
954bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
955{
956 wxSizerItem *item = GetItem( window, recursive );
957
958 if ( item )
959 {
960 item->Show( show );
961 return true;
962 }
963
964 return false;
965}
966
967bool wxSizer::Show( wxSizer *sizer, bool show, bool recursive )
968{
969 wxSizerItem *item = GetItem( sizer, recursive );
970
971 if ( item )
972 {
973 item->Show( show );
974 return true;
975 }
976
977 return false;
978}
979
980bool wxSizer::Show( size_t index, bool show)
981{
982 wxSizerItem *item = GetItem( index );
983
984 if ( item )
985 {
986 item->Show( show );
987 return true;
988 }
989
990 return false;
991}
992
993void wxSizer::ShowItems( bool show )
994{
995 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
996 while (node)
997 {
998 node->GetData()->Show( show );
999 node = node->GetNext();
1000 }
1001}
1002
1003bool wxSizer::IsShown( wxWindow *window ) const
1004{
1005 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1006 while (node)
1007 {
1008 wxSizerItem *item = node->GetData();
1009
1010 if (item->GetWindow() == window)
1011 {
1012 return item->IsShown();
1013 }
1014 node = node->GetNext();
1015 }
1016
1017 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
1018
1019 return false;
1020}
1021
1022bool wxSizer::IsShown( wxSizer *sizer ) const
1023{
1024 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1025 while (node)
1026 {
1027 wxSizerItem *item = node->GetData();
1028
1029 if (item->GetSizer() == sizer)
1030 {
1031 return item->IsShown();
1032 }
1033 node = node->GetNext();
1034 }
1035
1036 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
1037
1038 return false;
1039}
1040
1041bool wxSizer::IsShown( size_t index ) const
1042{
1043 wxCHECK_MSG( index < m_children.GetCount(),
1044 false,
1045 _T("IsShown index is out of range") );
1046
1047 return m_children.Item( index )->GetData()->IsShown();
1048}
1049
1050
1051//---------------------------------------------------------------------------
1052// wxGridSizer
1053//---------------------------------------------------------------------------
1054
1055wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
1056 : m_rows( ( cols == 0 && rows == 0 ) ? 1 : rows )
1057 , m_cols( cols )
1058 , m_vgap( vgap )
1059 , m_hgap( hgap )
1060{
1061}
1062
1063wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
1064 : m_rows( cols == 0 ? 1 : 0 )
1065 , m_cols( cols )
1066 , m_vgap( vgap )
1067 , m_hgap( hgap )
1068{
1069}
1070
1071int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
1072{
1073 int nitems = m_children.GetCount();
1074 if ( nitems)
1075 {
1076 if ( m_cols )
1077 {
1078 ncols = m_cols;
1079 nrows = (nitems + m_cols - 1) / m_cols;
1080 }
1081 else if ( m_rows )
1082 {
1083 ncols = (nitems + m_rows - 1) / m_rows;
1084 nrows = m_rows;
1085 }
1086 else // 0 columns, 0 rows?
1087 {
1088 wxFAIL_MSG( _T("grid sizer must have either rows or columns fixed") );
1089
1090 nrows = ncols = 0;
1091 }
1092 }
1093
1094 return nitems;
1095}
1096
1097void wxGridSizer::RecalcSizes()
1098{
1099 int nitems, nrows, ncols;
1100 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1101 return;
1102
1103 wxSize sz( GetSize() );
1104 wxPoint pt( GetPosition() );
1105
1106 int w = (sz.x - (ncols - 1) * m_hgap) / ncols;
1107 int h = (sz.y - (nrows - 1) * m_vgap) / nrows;
1108
1109 int x = pt.x;
1110 for (int c = 0; c < ncols; c++)
1111 {
1112 int y = pt.y;
1113 for (int r = 0; r < nrows; r++)
1114 {
1115 int i = r * ncols + c;
1116 if (i < nitems)
1117 {
1118 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1119
1120 wxASSERT_MSG( node, _T("Failed to find SizerItemList node") );
1121
1122 SetItemBounds( node->GetData(), x, y, w, h);
1123 }
1124 y = y + h + m_vgap;
1125 }
1126 x = x + w + m_hgap;
1127 }
1128}
1129
1130wxSize wxGridSizer::CalcMin()
1131{
1132 int nrows, ncols;
1133 if ( CalcRowsCols(nrows, ncols) == 0 )
1134 return wxSize(10, 10);
1135
1136 // Find the max width and height for any component
1137 int w = 0;
1138 int h = 0;
1139
1140 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1141 while (node)
1142 {
1143 wxSizerItem *item = node->GetData();
1144 wxSize sz( item->CalcMin() );
1145
1146 w = wxMax( w, sz.x );
1147 h = wxMax( h, sz.y );
1148
1149 node = node->GetNext();
1150 }
1151
1152 return wxSize( ncols * w + (ncols-1) * m_hgap,
1153 nrows * h + (nrows-1) * m_vgap );
1154}
1155
1156void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
1157{
1158 wxPoint pt( x,y );
1159 wxSize sz( item->GetMinSizeWithBorder() );
1160 int flag = item->GetFlag();
1161
1162 if ((flag & wxEXPAND) || (flag & wxSHAPED))
1163 {
1164 sz = wxSize(w, h);
1165 }
1166 else
1167 {
1168 if (flag & wxALIGN_CENTER_HORIZONTAL)
1169 {
1170 pt.x = x + (w - sz.x) / 2;
1171 }
1172 else if (flag & wxALIGN_RIGHT)
1173 {
1174 pt.x = x + (w - sz.x);
1175 }
1176
1177 if (flag & wxALIGN_CENTER_VERTICAL)
1178 {
1179 pt.y = y + (h - sz.y) / 2;
1180 }
1181 else if (flag & wxALIGN_BOTTOM)
1182 {
1183 pt.y = y + (h - sz.y);
1184 }
1185 }
1186
1187 item->SetDimension(pt, sz);
1188}
1189
1190//---------------------------------------------------------------------------
1191// wxFlexGridSizer
1192//---------------------------------------------------------------------------
1193
1194wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
1195 : wxGridSizer( rows, cols, vgap, hgap ),
1196 m_flexDirection(wxBOTH),
1197 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1198{
1199}
1200
1201wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
1202 : wxGridSizer( cols, vgap, hgap ),
1203 m_flexDirection(wxBOTH),
1204 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1205{
1206}
1207
1208wxFlexGridSizer::~wxFlexGridSizer()
1209{
1210}
1211
1212void wxFlexGridSizer::RecalcSizes()
1213{
1214 int nitems, nrows, ncols;
1215 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1216 return;
1217
1218 wxPoint pt( GetPosition() );
1219 wxSize sz( GetSize() );
1220
1221 AdjustForGrowables(sz, m_calculatedMinSize, nrows, ncols);
1222
1223 sz = wxSize( pt.x + sz.x, pt.y + sz.y );
1224
1225 int x = pt.x;
1226 for (int c = 0; c < ncols; c++)
1227 {
1228 int y = pt.y;
1229 for (int r = 0; r < nrows; r++)
1230 {
1231 int i = r * ncols + c;
1232 if (i < nitems)
1233 {
1234 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1235
1236 wxASSERT_MSG( node, _T("Failed to find node") );
1237
1238 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
1239 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
1240
1241 SetItemBounds( node->GetData(), x, y, w, h);
1242 }
1243 if (m_rowHeights[r] != -1)
1244 y = y + m_rowHeights[r] + m_vgap;
1245 }
1246 if (m_colWidths[c] != -1)
1247 x = x + m_colWidths[c] + m_hgap;
1248 }
1249}
1250
1251wxSize wxFlexGridSizer::CalcMin()
1252{
1253 int nrows,
1254 ncols;
1255 size_t i, s;
1256
1257 // Number of rows/columns can change as items are added or removed.
1258 if ( !CalcRowsCols(nrows, ncols) )
1259 return wxSize(10, 10);
1260
1261 m_rowHeights.SetCount(nrows);
1262 m_colWidths.SetCount(ncols);
1263
1264 // We have to recalcuate the sizes in case the item minimum size has
1265 // changed since the previous layout, or the item has been hidden using
1266 // wxSizer::Show(). If all the items in a row/column are hidden, the final
1267 // dimension of the row/column will be -1, indicating that the column
1268 // itself is hidden.
1269 for( s = m_rowHeights.GetCount(), i = 0; i < s; ++i )
1270 m_rowHeights[ i ] = -1;
1271 for( s = m_colWidths.GetCount(), i = 0; i < s; ++i )
1272 m_colWidths[ i ] = -1;
1273
1274 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1275
1276 i = 0;
1277 while (node)
1278 {
1279 wxSizerItem *item = node->GetData();
1280 if ( item->IsShown() )
1281 {
1282 wxSize sz( item->CalcMin() );
1283 int row = i / ncols;
1284 int col = i % ncols;
1285
1286 m_rowHeights[ row ] = wxMax( wxMax( 0, sz.y ), m_rowHeights[ row ] );
1287 m_colWidths[ col ] = wxMax( wxMax( 0, sz.x ), m_colWidths[ col ] );
1288 }
1289
1290 node = node->GetNext();
1291 i++;
1292 }
1293
1294 AdjustForFlexDirection();
1295
1296 // Sum total minimum size, including gaps between rows/columns.
1297 // -1 is used as a magic number meaning empty column.
1298 int width = 0;
1299 for (int col = 0; col < ncols; col++)
1300 if ( m_colWidths[ col ] != -1 )
1301 width += m_colWidths[ col ] + m_hgap;
1302 if (width > 0)
1303 width -= m_hgap;
1304
1305 int height = 0;
1306 for (int row = 0; row < nrows; row++)
1307 if ( m_rowHeights[ row ] != -1 )
1308 height += m_rowHeights[ row ] + m_vgap;
1309 if (height > 0)
1310 height -= m_vgap;
1311
1312 m_calculatedMinSize = wxSize( width, height );
1313 return m_calculatedMinSize;
1314}
1315
1316void wxFlexGridSizer::AdjustForFlexDirection()
1317{
1318 // the logic in CalcMin works when we resize flexibly in both directions
1319 // but maybe this is not the case
1320 if ( m_flexDirection != wxBOTH )
1321 {
1322 // select the array corresponding to the direction in which we do *not*
1323 // resize flexibly
1324 wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
1325 : m_rowHeights;
1326
1327 const size_t count = array.GetCount();
1328
1329 // find the largest value in this array
1330 size_t n;
1331 int largest = 0;
1332
1333 for ( n = 0; n < count; ++n )
1334 {
1335 if ( array[n] > largest )
1336 largest = array[n];
1337 }
1338
1339 // and now fill it with the largest value
1340 for ( n = 0; n < count; ++n )
1341 {
1342 array[n] = largest;
1343 }
1344 }
1345}
1346
1347
1348void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz, const wxSize& minsz,
1349 int nrows, int ncols)
1350{
1351 // what to do with the rows? by default, resize them proportionally
1352 if ( sz.y > minsz.y && ( (m_flexDirection & wxVERTICAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1353 {
1354 int sum_proportions = 0;
1355 int growable_space = 0;
1356 int num = 0;
1357 size_t idx;
1358 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1359 {
1360 // Since the number of rows/columns can change as items are
1361 // inserted/deleted, we need to verify at runtime that the
1362 // requested growable rows/columns are still valid.
1363 if (m_growableRows[idx] >= nrows)
1364 continue;
1365
1366 // If all items in a row/column are hidden, that row/column will
1367 // have a dimension of -1. This causes the row/column to be
1368 // hidden completely.
1369 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1370 continue;
1371 sum_proportions += m_growableRowsProportions[idx];
1372 growable_space += m_rowHeights[ m_growableRows[idx] ];
1373 num++;
1374 }
1375
1376 if (num > 0)
1377 {
1378 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1379 {
1380 if (m_growableRows[idx] >= nrows )
1381 continue;
1382 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1383 m_rowHeights[ m_growableRows[idx] ] = 0;
1384 else
1385 {
1386 int delta = (sz.y - minsz.y);
1387 if (sum_proportions == 0)
1388 delta = (delta/num) + m_rowHeights[ m_growableRows[idx] ];
1389 else
1390 delta = ((delta+growable_space)*m_growableRowsProportions[idx]) / sum_proportions;
1391 m_rowHeights[ m_growableRows[idx] ] = delta;
1392 }
1393 }
1394 }
1395 }
1396 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.y > minsz.y) )
1397 {
1398 // rounding problem?
1399 for ( int row = 0; row < nrows; ++row )
1400 m_rowHeights[ row ] = sz.y / nrows;
1401 }
1402
1403 // the same logic as above but for the columns
1404 if ( sz.x > minsz.x && ( (m_flexDirection & wxHORIZONTAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1405 {
1406 int sum_proportions = 0;
1407 int growable_space = 0;
1408 int num = 0;
1409 size_t idx;
1410 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1411 {
1412 // Since the number of rows/columns can change as items are
1413 // inserted/deleted, we need to verify at runtime that the
1414 // requested growable rows/columns are still valid.
1415 if (m_growableCols[idx] >= ncols)
1416 continue;
1417
1418 // If all items in a row/column are hidden, that row/column will
1419 // have a dimension of -1. This causes the column to be hidden
1420 // completely.
1421 if (m_colWidths[ m_growableCols[idx] ] == -1)
1422 continue;
1423 sum_proportions += m_growableColsProportions[idx];
1424 growable_space += m_colWidths[ m_growableCols[idx] ];
1425 num++;
1426 }
1427
1428 if (num > 0)
1429 {
1430 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1431 {
1432 if (m_growableCols[idx] >= ncols )
1433 continue;
1434 if (m_colWidths[ m_growableCols[idx] ] == -1)
1435 m_colWidths[ m_growableCols[idx] ] = 0;
1436 else
1437 {
1438 int delta = (sz.x - minsz.x);
1439 if (sum_proportions == 0)
1440 delta = (delta/num) + m_colWidths[ m_growableCols[idx] ];
1441 else
1442 delta = ((delta+growable_space)*m_growableColsProportions[idx])/sum_proportions;
1443 m_colWidths[ m_growableCols[idx] ] = delta;
1444 }
1445 }
1446 }
1447 }
1448 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.x > minsz.x) )
1449 {
1450 for ( int col=0; col < ncols; ++col )
1451 m_colWidths[ col ] = sz.x / ncols;
1452 }
1453}
1454
1455
1456void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1457{
1458 m_growableRows.Add( idx );
1459 m_growableRowsProportions.Add( proportion );
1460}
1461
1462void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
1463{
1464 m_growableRows.Remove( idx );
1465}
1466
1467void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1468{
1469 m_growableCols.Add( idx );
1470 m_growableColsProportions.Add( proportion );
1471}
1472
1473void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
1474{
1475 m_growableCols.Remove( idx );
1476}
1477
1478//---------------------------------------------------------------------------
1479// wxBoxSizer
1480//---------------------------------------------------------------------------
1481
1482wxBoxSizer::wxBoxSizer( int orient )
1483 : m_orient( orient )
1484{
1485}
1486
1487void wxBoxSizer::RecalcSizes()
1488{
1489 if (m_children.GetCount() == 0)
1490 return;
1491
1492 int delta = 0;
1493 if (m_stretchable)
1494 {
1495 if (m_orient == wxHORIZONTAL)
1496 delta = m_size.x - m_fixedWidth;
1497 else
1498 delta = m_size.y - m_fixedHeight;
1499 }
1500
1501 wxPoint pt( m_position );
1502
1503 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1504 while (node)
1505 {
1506 wxSizerItem *item = node->GetData();
1507
1508 if (item->IsShown())
1509 {
1510 wxSize size( item->GetMinSizeWithBorder() );
1511
1512 if (m_orient == wxVERTICAL)
1513 {
1514 wxCoord height = size.y;
1515 if (item->GetProportion())
1516 {
1517 // Because of at least one visible item has non-zero
1518 // proportion then m_stretchable is not zero
1519 height = (delta * item->GetProportion()) / m_stretchable;
1520 }
1521
1522 wxPoint child_pos( pt );
1523 wxSize child_size( size.x, height );
1524
1525 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1526 child_size.x = m_size.x;
1527 else if (item->GetFlag() & wxALIGN_RIGHT)
1528 child_pos.x += m_size.x - size.x;
1529 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
1530 // XXX wxCENTER is added for backward compatibility;
1531 // wxALIGN_CENTER should be used in new code
1532 child_pos.x += (m_size.x - size.x) / 2;
1533
1534 item->SetDimension( child_pos, child_size );
1535
1536 pt.y += height;
1537 }
1538 else
1539 {
1540 wxCoord width = size.x;
1541 if (item->GetProportion())
1542 {
1543 // Because of at least one visible item has non-zero
1544 // proportion then m_stretchable is not zero
1545 width = (delta * item->GetProportion()) / m_stretchable;
1546 }
1547
1548 wxPoint child_pos( pt );
1549 wxSize child_size( width, size.y );
1550
1551 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1552 child_size.y = m_size.y;
1553 else if (item->GetFlag() & wxALIGN_BOTTOM)
1554 child_pos.y += m_size.y - size.y;
1555 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
1556 // XXX wxCENTER is added for backward compatibility;
1557 // wxALIGN_CENTER should be used in new code
1558 child_pos.y += (m_size.y - size.y) / 2;
1559
1560 item->SetDimension( child_pos, child_size );
1561
1562 pt.x += width;
1563 }
1564 }
1565
1566 node = node->GetNext();
1567 }
1568}
1569
1570wxSize wxBoxSizer::CalcMin()
1571{
1572 if (m_children.GetCount() == 0)
1573 return wxSize(10,10);
1574
1575 m_stretchable = 0;
1576 m_minWidth = 0;
1577 m_minHeight = 0;
1578 m_fixedWidth = 0;
1579 m_fixedHeight = 0;
1580
1581 // precalc item minsizes and count proportions
1582 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1583 while (node)
1584 {
1585 wxSizerItem *item = node->GetData();
1586
1587 if ( item->IsShown() )
1588 {
1589 item->CalcMin(); // result is stored in the item
1590
1591 m_stretchable += item->GetProportion();
1592 }
1593
1594 node = node->GetNext();
1595 }
1596
1597 // Total minimum size (width or height) of sizer
1598 int maxMinSize = 0;
1599
1600 node = m_children.GetFirst();
1601 while (node)
1602 {
1603 wxSizerItem *item = node->GetData();
1604
1605 if (item->IsShown() && item->GetProportion() != 0)
1606 {
1607 int stretch = item->GetProportion();
1608 wxSize size( item->GetMinSizeWithBorder() );
1609 int minSize;
1610
1611 // Integer division rounded up is (a + b - 1) / b
1612 // Round up needed in order to guarantee that all
1613 // all items will have size not less then their min size
1614 if (m_orient == wxHORIZONTAL)
1615 minSize = ( size.x*m_stretchable + stretch - 1)/stretch;
1616 else
1617 minSize = ( size.y*m_stretchable + stretch - 1)/stretch;
1618
1619 if (minSize > maxMinSize)
1620 maxMinSize = minSize;
1621 }
1622 node = node->GetNext();
1623 }
1624
1625 // Calculate overall minimum size
1626 node = m_children.GetFirst();
1627 while (node)
1628 {
1629 wxSizerItem *item = node->GetData();
1630
1631 if (item->IsShown())
1632 {
1633 wxSize size( item->GetMinSizeWithBorder() );
1634 if (item->GetProportion() != 0)
1635 {
1636 if (m_orient == wxHORIZONTAL)
1637 size.x = (maxMinSize*item->GetProportion())/m_stretchable;
1638 else
1639 size.y = (maxMinSize*item->GetProportion())/m_stretchable;
1640 }
1641 else
1642 {
1643 if (m_orient == wxVERTICAL)
1644 {
1645 m_fixedHeight += size.y;
1646 m_fixedWidth = wxMax( m_fixedWidth, size.x );
1647 }
1648 else
1649 {
1650 m_fixedWidth += size.x;
1651 m_fixedHeight = wxMax( m_fixedHeight, size.y );
1652 }
1653 }
1654
1655 if (m_orient == wxHORIZONTAL)
1656 {
1657 m_minWidth += size.x;
1658 m_minHeight = wxMax( m_minHeight, size.y );
1659 }
1660 else
1661 {
1662 m_minHeight += size.y;
1663 m_minWidth = wxMax( m_minWidth, size.x );
1664 }
1665 }
1666 node = node->GetNext();
1667 }
1668
1669 return wxSize( m_minWidth, m_minHeight );
1670}
1671
1672//---------------------------------------------------------------------------
1673// wxStaticBoxSizer
1674//---------------------------------------------------------------------------
1675
1676#if wxUSE_STATBOX
1677
1678wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
1679 : wxBoxSizer( orient )
1680 , m_staticBox( box )
1681{
1682 wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
1683}
1684
1685wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
1686 : wxBoxSizer(orient),
1687 m_staticBox(new wxStaticBox(win, wxID_ANY, s))
1688{
1689}
1690
1691static void GetStaticBoxBorders( wxStaticBox *box,
1692 int *borderTop,
1693 int *borderOther)
1694{
1695 // this has to be done platform by platform as there is no way to
1696 // guess the thickness of a wxStaticBox border
1697 box->GetBordersForSizer(borderTop, borderOther);
1698}
1699
1700void wxStaticBoxSizer::RecalcSizes()
1701{
1702 int top_border, other_border;
1703 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1704
1705 m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1706
1707 wxPoint old_pos( m_position );
1708 m_position.x += other_border;
1709 m_position.y += top_border;
1710 wxSize old_size( m_size );
1711 m_size.x -= 2*other_border;
1712 m_size.y -= top_border + other_border;
1713
1714 wxBoxSizer::RecalcSizes();
1715
1716 m_position = old_pos;
1717 m_size = old_size;
1718}
1719
1720wxSize wxStaticBoxSizer::CalcMin()
1721{
1722 int top_border, other_border;
1723 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1724
1725 wxSize ret( wxBoxSizer::CalcMin() );
1726 ret.x += 2*other_border;
1727 ret.y += other_border + top_border;
1728
1729 return ret;
1730}
1731
1732void wxStaticBoxSizer::ShowItems( bool show )
1733{
1734 m_staticBox->Show( show );
1735 wxBoxSizer::ShowItems( show );
1736}
1737
1738#endif // wxUSE_STATBOX
1739
1740#if wxUSE_BUTTON
1741
1742wxStdDialogButtonSizer::wxStdDialogButtonSizer()
1743 : wxBoxSizer(wxHORIZONTAL)
1744{
1745 // Vertical buttons with lots of space on either side
1746 // looks rubbish on WinCE, so let's not do this for now.
1747 // If we are going to use vertical buttons, we should
1748 // put the sizer to the right of other controls in the dialog,
1749 // and that's beyond the scope of this sizer.
1750#ifndef __WXWINCE__
1751 bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
1752 // If we have a PDA screen, put yes/no button over
1753 // all other buttons, otherwise on the left side.
1754 if (is_pda)
1755 m_orient = wxVERTICAL;
1756#endif
1757
1758 m_buttonAffirmative = NULL;
1759 m_buttonApply = NULL;
1760 m_buttonNegative = NULL;
1761 m_buttonCancel = NULL;
1762 m_buttonHelp = NULL;
1763}
1764
1765void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
1766{
1767 switch (mybutton->GetId())
1768 {
1769 case wxID_OK:
1770 case wxID_YES:
1771 case wxID_SAVE:
1772 m_buttonAffirmative = mybutton;
1773 break;
1774 case wxID_APPLY:
1775 m_buttonApply = mybutton;
1776 break;
1777 case wxID_NO:
1778 m_buttonNegative = mybutton;
1779 break;
1780 case wxID_CANCEL:
1781 m_buttonCancel = mybutton;
1782 break;
1783 case wxID_HELP:
1784 case wxID_CONTEXT_HELP:
1785 m_buttonHelp = mybutton;
1786 break;
1787 default:
1788 break;
1789 }
1790}
1791
1792void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
1793{
1794 m_buttonAffirmative = button;
1795}
1796
1797void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
1798{
1799 m_buttonNegative = button;
1800}
1801
1802void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
1803{
1804 m_buttonCancel = button;
1805}
1806
1807void wxStdDialogButtonSizer::Realize()
1808{
1809#ifdef __WXMAC__
1810 Add(0, 0, 0, wxLEFT, 6);
1811 if (m_buttonHelp)
1812 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1813
1814 if (m_buttonNegative){
1815 // HIG POLICE BULLETIN - destructive buttons need extra padding
1816 // 24 pixels on either side
1817 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
1818 }
1819
1820 // extra whitespace between help/negative and cancel/ok buttons
1821 Add(0, 0, 1, wxEXPAND, 0);
1822
1823 if (m_buttonCancel){
1824 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1825 // Cancel or help should be default
1826 // m_buttonCancel->SetDefaultButton();
1827 }
1828
1829 // Ugh, Mac doesn't really have apply dialogs, so I'll just
1830 // figure the best place is between Cancel and OK
1831 if (m_buttonApply)
1832 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1833
1834 if (m_buttonAffirmative){
1835 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
1836
1837 if (m_buttonAffirmative->GetId() == wxID_SAVE){
1838 // these buttons have set labels under Mac so we should use them
1839 m_buttonAffirmative->SetLabel(_("Save"));
1840 m_buttonNegative->SetLabel(_("Don't Save"));
1841 }
1842 }
1843
1844 // Extra space around and at the right
1845 Add(12, 24);
1846#elif defined(__WXGTK20__)
1847 Add(0, 0, 0, wxLEFT, 9);
1848 if (m_buttonHelp)
1849 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1850
1851 // extra whitespace between help and cancel/ok buttons
1852 Add(0, 0, 1, wxEXPAND, 0);
1853
1854 if (m_buttonNegative){
1855 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1856 }
1857
1858 if (m_buttonCancel){
1859 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1860 // Cancel or help should be default
1861 // m_buttonCancel->SetDefaultButton();
1862 }
1863
1864 if (m_buttonApply)
1865 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1866
1867 if (m_buttonAffirmative)
1868 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
1869#elif defined(__WXMSW__)
1870 // Windows
1871
1872 // right-justify buttons
1873 Add(0, 0, 1, wxEXPAND, 0);
1874
1875 if (m_buttonAffirmative){
1876 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
1877 }
1878
1879 if (m_buttonNegative){
1880 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
1881 }
1882
1883 if (m_buttonCancel){
1884 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
1885 }
1886 if (m_buttonApply)
1887 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
1888
1889 if (m_buttonHelp)
1890 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
1891#else
1892 // GTK+1 and any other platform
1893
1894 // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
1895 if (m_buttonHelp)
1896 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
1897
1898 // extra whitespace between help and cancel/ok buttons
1899 Add(0, 0, 1, wxEXPAND, 0);
1900
1901 if (m_buttonApply)
1902 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
1903
1904 if (m_buttonAffirmative){
1905 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
1906 }
1907
1908 if (m_buttonNegative){
1909 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
1910 }
1911
1912 if (m_buttonCancel){
1913 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
1914 // Cancel or help should be default
1915 // m_buttonCancel->SetDefaultButton();
1916 }
1917
1918#endif
1919}
1920
1921#endif // wxUSE_BUTTON
1922
1923#if WXWIN_COMPATIBILITY_2_4
1924
1925// ----------------------------------------------------------------------------
1926// wxNotebookSizer
1927// ----------------------------------------------------------------------------
1928
1929#if wxUSE_BOOKCTRL
1930IMPLEMENT_CLASS(wxBookCtrlSizer, wxSizer)
1931#if wxUSE_NOTEBOOK
1932IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
1933#endif // wxUSE_NOTEBOOK
1934#endif // wxUSE_BOOKCTRL
1935
1936#if wxUSE_BOOKCTRL
1937
1938wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrlBase *bookctrl)
1939 : m_bookctrl(bookctrl)
1940{
1941 wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
1942}
1943
1944void wxBookCtrlSizer::RecalcSizes()
1945{
1946 m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1947}
1948
1949wxSize wxBookCtrlSizer::CalcMin()
1950{
1951 wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0,0));
1952
1953 sizeBorder.x += 5;
1954 sizeBorder.y += 5;
1955
1956 if ( m_bookctrl->GetPageCount() == 0 )
1957 {
1958 return wxSize(sizeBorder.x + 10, sizeBorder.y + 10);
1959 }
1960
1961 int maxX = 0;
1962 int maxY = 0;
1963
1964 wxWindowList::compatibility_iterator
1965 node = m_bookctrl->GetChildren().GetFirst();
1966 while (node)
1967 {
1968 wxWindow *item = node->GetData();
1969 wxSizer *itemsizer = item->GetSizer();
1970
1971 if (itemsizer)
1972 {
1973 wxSize subsize( itemsizer->CalcMin() );
1974
1975 if (subsize.x > maxX)
1976 maxX = subsize.x;
1977 if (subsize.y > maxY)
1978 maxY = subsize.y;
1979 }
1980
1981 node = node->GetNext();
1982 }
1983
1984 return wxSize( maxX, maxY ) + sizeBorder;
1985}
1986
1987#if wxUSE_NOTEBOOK
1988
1989wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
1990{
1991 wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a control") );
1992 m_bookctrl = nb;
1993}
1994
1995#endif // wxUSE_NOTEBOOOK
1996#endif // wxUSE_BOOKCTRL
1997
1998#endif // WXWIN_COMPATIBILITY_2_4
wxWidgets (Impactor)