]> 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
wx/debug.h is always unconditionally included by wx/defs.h
[wxWidgets.git] / src / common / sizer.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/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 #include "wx/utils.h"
25 #include "wx/settings.h"
26#endif // WX_PRECOMP
27
28#include "wx/sizer.h"
29#include "wx/statbox.h"
30#include "wx/listimpl.cpp"
31
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 // arbitrarily decide that if at least one of our elements is
451 // shown, so are we (this arbitrariness is the reason for
452 // deprecating this function)
453 {
454 for ( wxSizerItemList::compatibility_iterator
455 node = m_sizer->GetChildren().GetFirst();
456 node;
457 node = node->GetNext() )
458 {
459 if ( node->GetData()->IsShown() )
460 return true;
461 }
462 }
463 return false;
464
465 case Item_Spacer:
466 return m_spacer->IsShown();
467
468 case Item_Max:
469 default:
470 wxFAIL_MSG( _T("unexpected wxSizerItem::m_kind") );
471 }
472
473 return false;
474}
475
476#if WXWIN_COMPATIBILITY_2_6
477void wxSizerItem::SetOption( int option )
478{
479 SetProportion( option );
480}
481
482int wxSizerItem::GetOption() const
483{
484 return GetProportion();
485}
486#endif // WXWIN_COMPATIBILITY_2_6
487
488
489//---------------------------------------------------------------------------
490// wxSizer
491//---------------------------------------------------------------------------
492
493wxSizer::~wxSizer()
494{
495 WX_CLEAR_LIST(wxSizerItemList, m_children);
496}
497
498wxSizerItem* wxSizer::Insert( size_t index, wxSizerItem *item )
499{
500 m_children.Insert( index, item );
501
502 if ( item->GetWindow() )
503 item->GetWindow()->SetContainingSizer( this );
504
505 return item;
506}
507
508#if WXWIN_COMPATIBILITY_2_6
509bool wxSizer::Remove( wxWindow *window )
510{
511 return Detach( window );
512}
513#endif // WXWIN_COMPATIBILITY_2_6
514
515bool wxSizer::Remove( wxSizer *sizer )
516{
517 wxASSERT_MSG( sizer, _T("Removing NULL sizer") );
518
519 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
520 while (node)
521 {
522 wxSizerItem *item = node->GetData();
523
524 if (item->GetSizer() == sizer)
525 {
526 delete item;
527 m_children.Erase( node );
528 return true;
529 }
530
531 node = node->GetNext();
532 }
533
534 return false;
535}
536
537bool wxSizer::Remove( int index )
538{
539 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
540 false,
541 _T("Remove index is out of range") );
542
543 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
544
545 wxCHECK_MSG( node, false, _T("Failed to find child node") );
546
547 wxSizerItem *item = node->GetData();
548
549 if ( item->IsWindow() )
550 item->GetWindow()->SetContainingSizer( NULL );
551
552 delete item;
553 m_children.Erase( node );
554 return true;
555}
556
557bool wxSizer::Detach( wxSizer *sizer )
558{
559 wxASSERT_MSG( sizer, _T("Detaching NULL sizer") );
560
561 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
562 while (node)
563 {
564 wxSizerItem *item = node->GetData();
565
566 if (item->GetSizer() == sizer)
567 {
568 item->DetachSizer();
569 delete item;
570 m_children.Erase( node );
571 return true;
572 }
573 node = node->GetNext();
574 }
575
576 return false;
577}
578
579bool wxSizer::Detach( wxWindow *window )
580{
581 wxASSERT_MSG( window, _T("Detaching NULL window") );
582
583 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
584 while (node)
585 {
586 wxSizerItem *item = node->GetData();
587
588 if (item->GetWindow() == window)
589 {
590 item->GetWindow()->SetContainingSizer( NULL );
591 delete item;
592 m_children.Erase( node );
593 return true;
594 }
595 node = node->GetNext();
596 }
597
598 return false;
599}
600
601bool wxSizer::Detach( int index )
602{
603 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
604 false,
605 _T("Detach index is out of range") );
606
607 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
608
609 wxCHECK_MSG( node, false, _T("Failed to find child node") );
610
611 wxSizerItem *item = node->GetData();
612
613 if ( item->IsSizer() )
614 item->DetachSizer();
615 else if ( item->IsWindow() )
616 item->GetWindow()->SetContainingSizer( NULL );
617
618 delete item;
619 m_children.Erase( node );
620 return true;
621}
622
623void wxSizer::Clear( bool delete_windows )
624{
625 // First clear the ContainingSizer pointers
626 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
627 while (node)
628 {
629 wxSizerItem *item = node->GetData();
630
631 if (item->IsWindow())
632 item->GetWindow()->SetContainingSizer( NULL );
633 node = node->GetNext();
634 }
635
636 // Destroy the windows if needed
637 if (delete_windows)
638 DeleteWindows();
639
640 // Now empty the list
641 WX_CLEAR_LIST(wxSizerItemList, m_children);
642}
643
644void wxSizer::DeleteWindows()
645{
646 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
647 while (node)
648 {
649 wxSizerItem *item = node->GetData();
650
651 item->DeleteWindows();
652 node = node->GetNext();
653 }
654}
655
656wxSize wxSizer::Fit( wxWindow *window )
657{
658 wxSize size(window->IsTopLevel() ? FitSize(window)
659 : GetMinWindowSize(window));
660
661 window->SetSize( size );
662
663 return size;
664}
665
666void wxSizer::FitInside( wxWindow *window )
667{
668 wxSize size;
669 if (window->IsTopLevel())
670 size = VirtualFitSize( window );
671 else
672 size = GetMinClientSize( window );
673
674 window->SetVirtualSize( size );
675}
676
677void wxSizer::Layout()
678{
679 // (re)calculates minimums needed for each item and other preparations
680 // for layout
681 CalcMin();
682
683 // Applies the layout and repositions/resizes the items
684 RecalcSizes();
685}
686
687void wxSizer::SetSizeHints( wxWindow *window )
688{
689 // Preserve the window's max size hints, but set the
690 // lower bound according to the sizer calculations.
691
692 wxSize size = Fit( window );
693
694 window->SetSizeHints( size.x,
695 size.y,
696 window->GetMaxWidth(),
697 window->GetMaxHeight() );
698}
699
700void wxSizer::SetVirtualSizeHints( wxWindow *window )
701{
702 // Preserve the window's max size hints, but set the
703 // lower bound according to the sizer calculations.
704
705 FitInside( window );
706 wxSize size( window->GetVirtualSize() );
707 window->SetVirtualSizeHints( size.x,
708 size.y,
709 window->GetMaxWidth(),
710 window->GetMaxHeight() );
711}
712
713wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
714{
715 return window->GetMaxSize();
716}
717
718wxSize wxSizer::GetMinWindowSize( wxWindow *window )
719{
720 wxSize minSize( GetMinSize() );
721 wxSize size( window->GetSize() );
722 wxSize client_size( window->GetClientSize() );
723
724 return wxSize( minSize.x+size.x-client_size.x,
725 minSize.y+size.y-client_size.y );
726}
727
728// TODO on mac we need a function that determines how much free space this
729// min size contains, in order to make sure that we have 20 pixels of free
730// space around the controls
731
732// Return a window size that will fit within the screens dimensions
733wxSize wxSizer::FitSize( wxWindow *window )
734{
735 if ( window->IsTopLevel() )
736 {
737 wxTopLevelWindow *tlw = wxDynamicCast(window, wxTopLevelWindow);
738 if ( tlw && tlw->IsAlwaysMaximized() )
739 {
740 return tlw->GetClientSize();
741 }
742 }
743
744 wxSize size = GetMinWindowSize( window );
745 wxSize sizeMax = GetMaxWindowSize( window );
746
747 // Limit the size if sizeMax != wxDefaultSize
748
749 if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
750 size.x = sizeMax.x;
751 if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
752 size.y = sizeMax.y;
753
754 return size;
755}
756
757wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
758{
759 wxSize maxSize( window->GetMaxSize() );
760
761 if ( maxSize != wxDefaultSize )
762 {
763 wxSize size( window->GetSize() );
764 wxSize client_size( window->GetClientSize() );
765
766 return wxSize( maxSize.x + client_size.x - size.x,
767 maxSize.y + client_size.y - size.y );
768 }
769 else
770 return wxDefaultSize;
771}
772
773wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) )
774{
775 return GetMinSize(); // Already returns client size.
776}
777
778wxSize wxSizer::VirtualFitSize( wxWindow *window )
779{
780 wxSize size = GetMinClientSize( window );
781 wxSize sizeMax = GetMaxClientSize( window );
782
783 // Limit the size if sizeMax != wxDefaultSize
784
785 if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
786 size.x = sizeMax.x;
787 if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
788 size.y = sizeMax.y;
789
790 return size;
791}
792
793void wxSizer::SetDimension( int x, int y, int width, int height )
794{
795 m_position.x = x;
796 m_position.y = y;
797 m_size.x = width;
798 m_size.y = height;
799 Layout();
800}
801
802wxSize wxSizer::GetMinSize()
803{
804 wxSize ret( CalcMin() );
805 if (ret.x < m_minSize.x) ret.x = m_minSize.x;
806 if (ret.y < m_minSize.y) ret.y = m_minSize.y;
807 return ret;
808}
809
810void wxSizer::DoSetMinSize( int width, int height )
811{
812 m_minSize.x = width;
813 m_minSize.y = height;
814}
815
816bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
817{
818 wxASSERT_MSG( window, _T("SetMinSize for NULL window") );
819
820 // Is it our immediate child?
821
822 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
823 while (node)
824 {
825 wxSizerItem *item = node->GetData();
826
827 if (item->GetWindow() == window)
828 {
829 item->SetMinSize( width, height );
830 return true;
831 }
832 node = node->GetNext();
833 }
834
835 // No? Search any subsizers we own then
836
837 node = m_children.GetFirst();
838 while (node)
839 {
840 wxSizerItem *item = node->GetData();
841
842 if ( item->GetSizer() &&
843 item->GetSizer()->DoSetItemMinSize( window, width, height ) )
844 {
845 // A child sizer found the requested windw, exit.
846 return true;
847 }
848 node = node->GetNext();
849 }
850
851 return false;
852}
853
854bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
855{
856 wxASSERT_MSG( sizer, _T("SetMinSize for NULL sizer") );
857
858 // Is it our immediate child?
859
860 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
861 while (node)
862 {
863 wxSizerItem *item = node->GetData();
864
865 if (item->GetSizer() == sizer)
866 {
867 item->GetSizer()->DoSetMinSize( width, height );
868 return true;
869 }
870 node = node->GetNext();
871 }
872
873 // No? Search any subsizers we own then
874
875 node = m_children.GetFirst();
876 while (node)
877 {
878 wxSizerItem *item = node->GetData();
879
880 if ( item->GetSizer() &&
881 item->GetSizer()->DoSetItemMinSize( sizer, width, height ) )
882 {
883 // A child found the requested sizer, exit.
884 return true;
885 }
886 node = node->GetNext();
887 }
888
889 return false;
890}
891
892bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
893{
894 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
895
896 wxCHECK_MSG( node, false, _T("Failed to find child node") );
897
898 wxSizerItem *item = node->GetData();
899
900 if (item->GetSizer())
901 {
902 // Sizers contains the minimal size in them, if not calculated ...
903 item->GetSizer()->DoSetMinSize( width, height );
904 }
905 else
906 {
907 // ... but the minimal size of spacers and windows is stored via the item
908 item->SetMinSize( width, height );
909 }
910
911 return true;
912}
913
914wxSizerItem* wxSizer::GetItem( wxWindow *window, bool recursive )
915{
916 wxASSERT_MSG( window, _T("GetItem for NULL window") );
917
918 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
919 while (node)
920 {
921 wxSizerItem *item = node->GetData();
922
923 if (item->GetWindow() == window)
924 {
925 return item;
926 }
927 else if (recursive && item->IsSizer())
928 {
929 wxSizerItem *subitem = item->GetSizer()->GetItem( window, true );
930 if (subitem)
931 return subitem;
932 }
933
934 node = node->GetNext();
935 }
936
937 return NULL;
938}
939
940wxSizerItem* wxSizer::GetItem( wxSizer *sizer, bool recursive )
941{
942 wxASSERT_MSG( sizer, _T("GetItem for NULL sizer") );
943
944 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
945 while (node)
946 {
947 wxSizerItem *item = node->GetData();
948
949 if (item->GetSizer() == sizer)
950 {
951 return item;
952 }
953 else if (recursive && item->IsSizer())
954 {
955 wxSizerItem *subitem = item->GetSizer()->GetItem( sizer, true );
956 if (subitem)
957 return subitem;
958 }
959
960 node = node->GetNext();
961 }
962
963 return NULL;
964}
965
966wxSizerItem* wxSizer::GetItem( size_t index )
967{
968 wxCHECK_MSG( index < m_children.GetCount(),
969 NULL,
970 _T("GetItem index is out of range") );
971
972 return m_children.Item( index )->GetData();
973}
974
975bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
976{
977 wxSizerItem *item = GetItem( window, recursive );
978
979 if ( item )
980 {
981 item->Show( show );
982 return true;
983 }
984
985 return false;
986}
987
988bool wxSizer::Show( wxSizer *sizer, bool show, bool recursive )
989{
990 wxSizerItem *item = GetItem( sizer, recursive );
991
992 if ( item )
993 {
994 item->Show( show );
995 return true;
996 }
997
998 return false;
999}
1000
1001bool wxSizer::Show( size_t index, bool show)
1002{
1003 wxSizerItem *item = GetItem( index );
1004
1005 if ( item )
1006 {
1007 item->Show( show );
1008 return true;
1009 }
1010
1011 return false;
1012}
1013
1014void wxSizer::ShowItems( bool show )
1015{
1016 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1017 while (node)
1018 {
1019 node->GetData()->Show( show );
1020 node = node->GetNext();
1021 }
1022}
1023
1024bool wxSizer::IsShown( wxWindow *window ) const
1025{
1026 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1027 while (node)
1028 {
1029 wxSizerItem *item = node->GetData();
1030
1031 if (item->GetWindow() == window)
1032 {
1033 return item->IsShown();
1034 }
1035 node = node->GetNext();
1036 }
1037
1038 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
1039
1040 return false;
1041}
1042
1043bool wxSizer::IsShown( wxSizer *sizer ) const
1044{
1045 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1046 while (node)
1047 {
1048 wxSizerItem *item = node->GetData();
1049
1050 if (item->GetSizer() == sizer)
1051 {
1052 return item->IsShown();
1053 }
1054 node = node->GetNext();
1055 }
1056
1057 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
1058
1059 return false;
1060}
1061
1062bool wxSizer::IsShown( size_t index ) const
1063{
1064 wxCHECK_MSG( index < m_children.GetCount(),
1065 false,
1066 _T("IsShown index is out of range") );
1067
1068 return m_children.Item( index )->GetData()->IsShown();
1069}
1070
1071
1072//---------------------------------------------------------------------------
1073// wxGridSizer
1074//---------------------------------------------------------------------------
1075
1076wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
1077 : m_rows( ( cols == 0 && rows == 0 ) ? 1 : rows )
1078 , m_cols( cols )
1079 , m_vgap( vgap )
1080 , m_hgap( hgap )
1081{
1082}
1083
1084wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
1085 : m_rows( cols == 0 ? 1 : 0 )
1086 , m_cols( cols )
1087 , m_vgap( vgap )
1088 , m_hgap( hgap )
1089{
1090}
1091
1092int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
1093{
1094 int nitems = m_children.GetCount();
1095 if ( nitems)
1096 {
1097 if ( m_cols )
1098 {
1099 ncols = m_cols;
1100 nrows = (nitems + m_cols - 1) / m_cols;
1101 }
1102 else if ( m_rows )
1103 {
1104 ncols = (nitems + m_rows - 1) / m_rows;
1105 nrows = m_rows;
1106 }
1107 else // 0 columns, 0 rows?
1108 {
1109 wxFAIL_MSG( _T("grid sizer must have either rows or columns fixed") );
1110
1111 nrows = ncols = 0;
1112 }
1113 }
1114
1115 return nitems;
1116}
1117
1118void wxGridSizer::RecalcSizes()
1119{
1120 int nitems, nrows, ncols;
1121 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1122 return;
1123
1124 wxSize sz( GetSize() );
1125 wxPoint pt( GetPosition() );
1126
1127 int w = (sz.x - (ncols - 1) * m_hgap) / ncols;
1128 int h = (sz.y - (nrows - 1) * m_vgap) / nrows;
1129
1130 int x = pt.x;
1131 for (int c = 0; c < ncols; c++)
1132 {
1133 int y = pt.y;
1134 for (int r = 0; r < nrows; r++)
1135 {
1136 int i = r * ncols + c;
1137 if (i < nitems)
1138 {
1139 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1140
1141 wxASSERT_MSG( node, _T("Failed to find SizerItemList node") );
1142
1143 SetItemBounds( node->GetData(), x, y, w, h);
1144 }
1145 y = y + h + m_vgap;
1146 }
1147 x = x + w + m_hgap;
1148 }
1149}
1150
1151wxSize wxGridSizer::CalcMin()
1152{
1153 int nrows, ncols;
1154 if ( CalcRowsCols(nrows, ncols) == 0 )
1155 return wxSize(10, 10);
1156
1157 // Find the max width and height for any component
1158 int w = 0;
1159 int h = 0;
1160
1161 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1162 while (node)
1163 {
1164 wxSizerItem *item = node->GetData();
1165 wxSize sz( item->CalcMin() );
1166
1167 w = wxMax( w, sz.x );
1168 h = wxMax( h, sz.y );
1169
1170 node = node->GetNext();
1171 }
1172
1173 return wxSize( ncols * w + (ncols-1) * m_hgap,
1174 nrows * h + (nrows-1) * m_vgap );
1175}
1176
1177void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
1178{
1179 wxPoint pt( x,y );
1180 wxSize sz( item->GetMinSizeWithBorder() );
1181 int flag = item->GetFlag();
1182
1183 if ((flag & wxEXPAND) || (flag & wxSHAPED))
1184 {
1185 sz = wxSize(w, h);
1186 }
1187 else
1188 {
1189 if (flag & wxALIGN_CENTER_HORIZONTAL)
1190 {
1191 pt.x = x + (w - sz.x) / 2;
1192 }
1193 else if (flag & wxALIGN_RIGHT)
1194 {
1195 pt.x = x + (w - sz.x);
1196 }
1197
1198 if (flag & wxALIGN_CENTER_VERTICAL)
1199 {
1200 pt.y = y + (h - sz.y) / 2;
1201 }
1202 else if (flag & wxALIGN_BOTTOM)
1203 {
1204 pt.y = y + (h - sz.y);
1205 }
1206 }
1207
1208 item->SetDimension(pt, sz);
1209}
1210
1211//---------------------------------------------------------------------------
1212// wxFlexGridSizer
1213//---------------------------------------------------------------------------
1214
1215wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
1216 : wxGridSizer( rows, cols, vgap, hgap ),
1217 m_flexDirection(wxBOTH),
1218 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1219{
1220}
1221
1222wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
1223 : wxGridSizer( cols, vgap, hgap ),
1224 m_flexDirection(wxBOTH),
1225 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1226{
1227}
1228
1229wxFlexGridSizer::~wxFlexGridSizer()
1230{
1231}
1232
1233void wxFlexGridSizer::RecalcSizes()
1234{
1235 int nitems, nrows, ncols;
1236 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1237 return;
1238
1239 wxPoint pt( GetPosition() );
1240 wxSize sz( GetSize() );
1241
1242 AdjustForGrowables(sz, m_calculatedMinSize, nrows, ncols);
1243
1244 sz = wxSize( pt.x + sz.x, pt.y + sz.y );
1245
1246 int x = pt.x;
1247 for (int c = 0; c < ncols; c++)
1248 {
1249 int y = pt.y;
1250 for (int r = 0; r < nrows; r++)
1251 {
1252 int i = r * ncols + c;
1253 if (i < nitems)
1254 {
1255 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1256
1257 wxASSERT_MSG( node, _T("Failed to find node") );
1258
1259 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
1260 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
1261
1262 SetItemBounds( node->GetData(), x, y, w, h);
1263 }
1264 if (m_rowHeights[r] != -1)
1265 y = y + m_rowHeights[r] + m_vgap;
1266 }
1267 if (m_colWidths[c] != -1)
1268 x = x + m_colWidths[c] + m_hgap;
1269 }
1270}
1271
1272wxSize wxFlexGridSizer::CalcMin()
1273{
1274 int nrows,
1275 ncols;
1276 size_t i, s;
1277
1278 // Number of rows/columns can change as items are added or removed.
1279 if ( !CalcRowsCols(nrows, ncols) )
1280 return wxSize(10, 10);
1281
1282 m_rowHeights.SetCount(nrows);
1283 m_colWidths.SetCount(ncols);
1284
1285 // We have to recalcuate the sizes in case the item minimum size has
1286 // changed since the previous layout, or the item has been hidden using
1287 // wxSizer::Show(). If all the items in a row/column are hidden, the final
1288 // dimension of the row/column will be -1, indicating that the column
1289 // itself is hidden.
1290 for( s = m_rowHeights.GetCount(), i = 0; i < s; ++i )
1291 m_rowHeights[ i ] = -1;
1292 for( s = m_colWidths.GetCount(), i = 0; i < s; ++i )
1293 m_colWidths[ i ] = -1;
1294
1295 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1296
1297 i = 0;
1298 while (node)
1299 {
1300 wxSizerItem *item = node->GetData();
1301 if ( item->IsShown() )
1302 {
1303 wxSize sz( item->CalcMin() );
1304 int row = i / ncols;
1305 int col = i % ncols;
1306
1307 m_rowHeights[ row ] = wxMax( wxMax( 0, sz.y ), m_rowHeights[ row ] );
1308 m_colWidths[ col ] = wxMax( wxMax( 0, sz.x ), m_colWidths[ col ] );
1309 }
1310
1311 node = node->GetNext();
1312 i++;
1313 }
1314
1315 AdjustForFlexDirection();
1316
1317 // Sum total minimum size, including gaps between rows/columns.
1318 // -1 is used as a magic number meaning empty column.
1319 int width = 0;
1320 for (int col = 0; col < ncols; col++)
1321 if ( m_colWidths[ col ] != -1 )
1322 width += m_colWidths[ col ] + m_hgap;
1323 if (width > 0)
1324 width -= m_hgap;
1325
1326 int height = 0;
1327 for (int row = 0; row < nrows; row++)
1328 if ( m_rowHeights[ row ] != -1 )
1329 height += m_rowHeights[ row ] + m_vgap;
1330 if (height > 0)
1331 height -= m_vgap;
1332
1333 m_calculatedMinSize = wxSize( width, height );
1334 return m_calculatedMinSize;
1335}
1336
1337void wxFlexGridSizer::AdjustForFlexDirection()
1338{
1339 // the logic in CalcMin works when we resize flexibly in both directions
1340 // but maybe this is not the case
1341 if ( m_flexDirection != wxBOTH )
1342 {
1343 // select the array corresponding to the direction in which we do *not*
1344 // resize flexibly
1345 wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
1346 : m_rowHeights;
1347
1348 const size_t count = array.GetCount();
1349
1350 // find the largest value in this array
1351 size_t n;
1352 int largest = 0;
1353
1354 for ( n = 0; n < count; ++n )
1355 {
1356 if ( array[n] > largest )
1357 largest = array[n];
1358 }
1359
1360 // and now fill it with the largest value
1361 for ( n = 0; n < count; ++n )
1362 {
1363 array[n] = largest;
1364 }
1365 }
1366}
1367
1368
1369void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz, const wxSize& minsz,
1370 int nrows, int ncols)
1371{
1372 // what to do with the rows? by default, resize them proportionally
1373 if ( sz.y > minsz.y && ( (m_flexDirection & wxVERTICAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1374 {
1375 int sum_proportions = 0;
1376 int growable_space = 0;
1377 int num = 0;
1378 size_t idx;
1379 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1380 {
1381 // Since the number of rows/columns can change as items are
1382 // inserted/deleted, we need to verify at runtime that the
1383 // requested growable rows/columns are still valid.
1384 if (m_growableRows[idx] >= nrows)
1385 continue;
1386
1387 // If all items in a row/column are hidden, that row/column will
1388 // have a dimension of -1. This causes the row/column to be
1389 // hidden completely.
1390 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1391 continue;
1392 sum_proportions += m_growableRowsProportions[idx];
1393 growable_space += m_rowHeights[ m_growableRows[idx] ];
1394 num++;
1395 }
1396
1397 if (num > 0)
1398 {
1399 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1400 {
1401 if (m_growableRows[idx] >= nrows )
1402 continue;
1403 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1404 m_rowHeights[ m_growableRows[idx] ] = 0;
1405 else
1406 {
1407 int delta = (sz.y - minsz.y);
1408 if (sum_proportions == 0)
1409 delta = (delta/num) + m_rowHeights[ m_growableRows[idx] ];
1410 else
1411 delta = ((delta+growable_space)*m_growableRowsProportions[idx]) / sum_proportions;
1412 m_rowHeights[ m_growableRows[idx] ] = delta;
1413 }
1414 }
1415 }
1416 }
1417 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.y > minsz.y) )
1418 {
1419 // rounding problem?
1420 for ( int row = 0; row < nrows; ++row )
1421 m_rowHeights[ row ] = sz.y / nrows;
1422 }
1423
1424 // the same logic as above but for the columns
1425 if ( sz.x > minsz.x && ( (m_flexDirection & wxHORIZONTAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1426 {
1427 int sum_proportions = 0;
1428 int growable_space = 0;
1429 int num = 0;
1430 size_t idx;
1431 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1432 {
1433 // Since the number of rows/columns can change as items are
1434 // inserted/deleted, we need to verify at runtime that the
1435 // requested growable rows/columns are still valid.
1436 if (m_growableCols[idx] >= ncols)
1437 continue;
1438
1439 // If all items in a row/column are hidden, that row/column will
1440 // have a dimension of -1. This causes the column to be hidden
1441 // completely.
1442 if (m_colWidths[ m_growableCols[idx] ] == -1)
1443 continue;
1444 sum_proportions += m_growableColsProportions[idx];
1445 growable_space += m_colWidths[ m_growableCols[idx] ];
1446 num++;
1447 }
1448
1449 if (num > 0)
1450 {
1451 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1452 {
1453 if (m_growableCols[idx] >= ncols )
1454 continue;
1455 if (m_colWidths[ m_growableCols[idx] ] == -1)
1456 m_colWidths[ m_growableCols[idx] ] = 0;
1457 else
1458 {
1459 int delta = (sz.x - minsz.x);
1460 if (sum_proportions == 0)
1461 delta = (delta/num) + m_colWidths[ m_growableCols[idx] ];
1462 else
1463 delta = ((delta+growable_space)*m_growableColsProportions[idx])/sum_proportions;
1464 m_colWidths[ m_growableCols[idx] ] = delta;
1465 }
1466 }
1467 }
1468 }
1469 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.x > minsz.x) )
1470 {
1471 for ( int col=0; col < ncols; ++col )
1472 m_colWidths[ col ] = sz.x / ncols;
1473 }
1474}
1475
1476
1477void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1478{
1479 m_growableRows.Add( idx );
1480 m_growableRowsProportions.Add( proportion );
1481}
1482
1483void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
1484{
1485 m_growableRows.Remove( idx );
1486}
1487
1488void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1489{
1490 m_growableCols.Add( idx );
1491 m_growableColsProportions.Add( proportion );
1492}
1493
1494void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
1495{
1496 m_growableCols.Remove( idx );
1497}
1498
1499//---------------------------------------------------------------------------
1500// wxBoxSizer
1501//---------------------------------------------------------------------------
1502
1503wxBoxSizer::wxBoxSizer( int orient )
1504 : m_orient( orient )
1505{
1506}
1507
1508void wxBoxSizer::RecalcSizes()
1509{
1510 if (m_children.GetCount() == 0)
1511 return;
1512
1513 int delta = 0;
1514 if (m_stretchable)
1515 {
1516 if (m_orient == wxHORIZONTAL)
1517 delta = m_size.x - m_fixedWidth;
1518 else
1519 delta = m_size.y - m_fixedHeight;
1520 }
1521
1522 wxPoint pt( m_position );
1523
1524 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1525 while (node)
1526 {
1527 wxSizerItem *item = node->GetData();
1528
1529 if (item->IsShown())
1530 {
1531 wxSize size( item->GetMinSizeWithBorder() );
1532
1533 if (m_orient == wxVERTICAL)
1534 {
1535 wxCoord height = size.y;
1536 if (item->GetProportion())
1537 {
1538 // Because of at least one visible item has non-zero
1539 // proportion then m_stretchable is not zero
1540 height = (delta * item->GetProportion()) / m_stretchable;
1541 }
1542
1543 wxPoint child_pos( pt );
1544 wxSize child_size( size.x, height );
1545
1546 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1547 child_size.x = m_size.x;
1548 else if (item->GetFlag() & wxALIGN_RIGHT)
1549 child_pos.x += m_size.x - size.x;
1550 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
1551 // XXX wxCENTER is added for backward compatibility;
1552 // wxALIGN_CENTER should be used in new code
1553 child_pos.x += (m_size.x - size.x) / 2;
1554
1555 item->SetDimension( child_pos, child_size );
1556
1557 pt.y += height;
1558 }
1559 else
1560 {
1561 wxCoord width = size.x;
1562 if (item->GetProportion())
1563 {
1564 // Because of at least one visible item has non-zero
1565 // proportion then m_stretchable is not zero
1566 width = (delta * item->GetProportion()) / m_stretchable;
1567 }
1568
1569 wxPoint child_pos( pt );
1570 wxSize child_size( width, size.y );
1571
1572 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1573 child_size.y = m_size.y;
1574 else if (item->GetFlag() & wxALIGN_BOTTOM)
1575 child_pos.y += m_size.y - size.y;
1576 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
1577 // XXX wxCENTER is added for backward compatibility;
1578 // wxALIGN_CENTER should be used in new code
1579 child_pos.y += (m_size.y - size.y) / 2;
1580
1581 item->SetDimension( child_pos, child_size );
1582
1583 pt.x += width;
1584 }
1585 }
1586
1587 node = node->GetNext();
1588 }
1589}
1590
1591wxSize wxBoxSizer::CalcMin()
1592{
1593 if (m_children.GetCount() == 0)
1594 return wxSize(10,10);
1595
1596 m_stretchable = 0;
1597 m_minWidth = 0;
1598 m_minHeight = 0;
1599 m_fixedWidth = 0;
1600 m_fixedHeight = 0;
1601
1602 // precalc item minsizes and count proportions
1603 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1604 while (node)
1605 {
1606 wxSizerItem *item = node->GetData();
1607
1608 if ( item->IsShown() )
1609 {
1610 item->CalcMin(); // result is stored in the item
1611
1612 m_stretchable += item->GetProportion();
1613 }
1614
1615 node = node->GetNext();
1616 }
1617
1618 // Total minimum size (width or height) of sizer
1619 int maxMinSize = 0;
1620
1621 node = m_children.GetFirst();
1622 while (node)
1623 {
1624 wxSizerItem *item = node->GetData();
1625
1626 if (item->IsShown() && item->GetProportion() != 0)
1627 {
1628 int stretch = item->GetProportion();
1629 wxSize size( item->GetMinSizeWithBorder() );
1630 int minSize;
1631
1632 // Integer division rounded up is (a + b - 1) / b
1633 // Round up needed in order to guarantee that all
1634 // all items will have size not less then their min size
1635 if (m_orient == wxHORIZONTAL)
1636 minSize = ( size.x*m_stretchable + stretch - 1)/stretch;
1637 else
1638 minSize = ( size.y*m_stretchable + stretch - 1)/stretch;
1639
1640 if (minSize > maxMinSize)
1641 maxMinSize = minSize;
1642 }
1643 node = node->GetNext();
1644 }
1645
1646 // Calculate overall minimum size
1647 node = m_children.GetFirst();
1648 while (node)
1649 {
1650 wxSizerItem *item = node->GetData();
1651
1652 if (item->IsShown())
1653 {
1654 wxSize size( item->GetMinSizeWithBorder() );
1655 if (item->GetProportion() != 0)
1656 {
1657 if (m_orient == wxHORIZONTAL)
1658 size.x = (maxMinSize*item->GetProportion())/m_stretchable;
1659 else
1660 size.y = (maxMinSize*item->GetProportion())/m_stretchable;
1661 }
1662 else
1663 {
1664 if (m_orient == wxVERTICAL)
1665 {
1666 m_fixedHeight += size.y;
1667 m_fixedWidth = wxMax( m_fixedWidth, size.x );
1668 }
1669 else
1670 {
1671 m_fixedWidth += size.x;
1672 m_fixedHeight = wxMax( m_fixedHeight, size.y );
1673 }
1674 }
1675
1676 if (m_orient == wxHORIZONTAL)
1677 {
1678 m_minWidth += size.x;
1679 m_minHeight = wxMax( m_minHeight, size.y );
1680 }
1681 else
1682 {
1683 m_minHeight += size.y;
1684 m_minWidth = wxMax( m_minWidth, size.x );
1685 }
1686 }
1687 node = node->GetNext();
1688 }
1689
1690 return wxSize( m_minWidth, m_minHeight );
1691}
1692
1693//---------------------------------------------------------------------------
1694// wxStaticBoxSizer
1695//---------------------------------------------------------------------------
1696
1697#if wxUSE_STATBOX
1698
1699wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
1700 : wxBoxSizer( orient )
1701 , m_staticBox( box )
1702{
1703 wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
1704}
1705
1706wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
1707 : wxBoxSizer(orient),
1708 m_staticBox(new wxStaticBox(win, wxID_ANY, s))
1709{
1710}
1711
1712static void GetStaticBoxBorders( wxStaticBox *box,
1713 int *borderTop,
1714 int *borderOther)
1715{
1716 // this has to be done platform by platform as there is no way to
1717 // guess the thickness of a wxStaticBox border
1718 box->GetBordersForSizer(borderTop, borderOther);
1719}
1720
1721void wxStaticBoxSizer::RecalcSizes()
1722{
1723 int top_border, other_border;
1724 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1725
1726 m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1727
1728 wxPoint old_pos( m_position );
1729 m_position.x += other_border;
1730 m_position.y += top_border;
1731 wxSize old_size( m_size );
1732 m_size.x -= 2*other_border;
1733 m_size.y -= top_border + other_border;
1734
1735 wxBoxSizer::RecalcSizes();
1736
1737 m_position = old_pos;
1738 m_size = old_size;
1739}
1740
1741wxSize wxStaticBoxSizer::CalcMin()
1742{
1743 int top_border, other_border;
1744 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1745
1746 wxSize ret( wxBoxSizer::CalcMin() );
1747 ret.x += 2*other_border;
1748 ret.y += other_border + top_border;
1749
1750 return ret;
1751}
1752
1753void wxStaticBoxSizer::ShowItems( bool show )
1754{
1755 m_staticBox->Show( show );
1756 wxBoxSizer::ShowItems( show );
1757}
1758
1759#endif // wxUSE_STATBOX
1760
1761#if wxUSE_BUTTON
1762
1763wxStdDialogButtonSizer::wxStdDialogButtonSizer()
1764 : wxBoxSizer(wxHORIZONTAL)
1765{
1766 // Vertical buttons with lots of space on either side
1767 // looks rubbish on WinCE, so let's not do this for now.
1768 // If we are going to use vertical buttons, we should
1769 // put the sizer to the right of other controls in the dialog,
1770 // and that's beyond the scope of this sizer.
1771#ifndef __WXWINCE__
1772 bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
1773 // If we have a PDA screen, put yes/no button over
1774 // all other buttons, otherwise on the left side.
1775 if (is_pda)
1776 m_orient = wxVERTICAL;
1777#endif
1778
1779 m_buttonAffirmative = NULL;
1780 m_buttonApply = NULL;
1781 m_buttonNegative = NULL;
1782 m_buttonCancel = NULL;
1783 m_buttonHelp = NULL;
1784}
1785
1786void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
1787{
1788 switch (mybutton->GetId())
1789 {
1790 case wxID_OK:
1791 case wxID_YES:
1792 case wxID_SAVE:
1793 m_buttonAffirmative = mybutton;
1794 break;
1795 case wxID_APPLY:
1796 m_buttonApply = mybutton;
1797 break;
1798 case wxID_NO:
1799 m_buttonNegative = mybutton;
1800 break;
1801 case wxID_CANCEL:
1802 m_buttonCancel = mybutton;
1803 break;
1804 case wxID_HELP:
1805 case wxID_CONTEXT_HELP:
1806 m_buttonHelp = mybutton;
1807 break;
1808 default:
1809 break;
1810 }
1811}
1812
1813void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
1814{
1815 m_buttonAffirmative = button;
1816}
1817
1818void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
1819{
1820 m_buttonNegative = button;
1821}
1822
1823void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
1824{
1825 m_buttonCancel = button;
1826}
1827
1828void wxStdDialogButtonSizer::Realize()
1829{
1830#ifdef __WXMAC__
1831 Add(0, 0, 0, wxLEFT, 6);
1832 if (m_buttonHelp)
1833 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1834
1835 if (m_buttonNegative){
1836 // HIG POLICE BULLETIN - destructive buttons need extra padding
1837 // 24 pixels on either side
1838 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
1839 }
1840
1841 // extra whitespace between help/negative and cancel/ok buttons
1842 Add(0, 0, 1, wxEXPAND, 0);
1843
1844 if (m_buttonCancel){
1845 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1846 // Cancel or help should be default
1847 // m_buttonCancel->SetDefaultButton();
1848 }
1849
1850 // Ugh, Mac doesn't really have apply dialogs, so I'll just
1851 // figure the best place is between Cancel and OK
1852 if (m_buttonApply)
1853 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
1854
1855 if (m_buttonAffirmative){
1856 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
1857
1858 if (m_buttonAffirmative->GetId() == wxID_SAVE){
1859 // these buttons have set labels under Mac so we should use them
1860 m_buttonAffirmative->SetLabel(_("Save"));
1861 m_buttonNegative->SetLabel(_("Don't Save"));
1862 }
1863 }
1864
1865 // Extra space around and at the right
1866 Add(12, 24);
1867#elif defined(__WXGTK20__)
1868 Add(0, 0, 0, wxLEFT, 9);
1869 if (m_buttonHelp)
1870 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1871
1872 // extra whitespace between help and cancel/ok buttons
1873 Add(0, 0, 1, wxEXPAND, 0);
1874
1875 if (m_buttonNegative){
1876 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1877 }
1878
1879 if (m_buttonCancel){
1880 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1881 // Cancel or help should be default
1882 // m_buttonCancel->SetDefaultButton();
1883 }
1884
1885 if (m_buttonApply)
1886 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
1887
1888 if (m_buttonAffirmative)
1889 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
1890#elif defined(__WXMSW__)
1891 // Windows
1892
1893 // right-justify buttons
1894 Add(0, 0, 1, wxEXPAND, 0);
1895
1896 if (m_buttonAffirmative){
1897 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
1898 }
1899
1900 if (m_buttonNegative){
1901 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
1902 }
1903
1904 if (m_buttonCancel){
1905 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
1906 }
1907 if (m_buttonApply)
1908 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
1909
1910 if (m_buttonHelp)
1911 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
1912#else
1913 // GTK+1 and any other platform
1914
1915 // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
1916 if (m_buttonHelp)
1917 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
1918
1919 // extra whitespace between help and cancel/ok buttons
1920 Add(0, 0, 1, wxEXPAND, 0);
1921
1922 if (m_buttonApply)
1923 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
1924
1925 if (m_buttonAffirmative){
1926 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
1927 }
1928
1929 if (m_buttonNegative){
1930 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
1931 }
1932
1933 if (m_buttonCancel){
1934 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
1935 // Cancel or help should be default
1936 // m_buttonCancel->SetDefaultButton();
1937 }
1938
1939#endif
1940}
1941
1942#endif // wxUSE_BUTTON
1943
1944#if WXWIN_COMPATIBILITY_2_4
1945
1946// ----------------------------------------------------------------------------
1947// wxNotebookSizer
1948// ----------------------------------------------------------------------------
1949
1950#if wxUSE_BOOKCTRL
1951IMPLEMENT_CLASS(wxBookCtrlSizer, wxSizer)
1952#if wxUSE_NOTEBOOK
1953IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
1954#endif // wxUSE_NOTEBOOK
1955#endif // wxUSE_BOOKCTRL
1956
1957#if wxUSE_BOOKCTRL
1958
1959#if WXWIN_COMPATIBILITY_2_6
1960
1961wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrlBase *bookctrl)
1962 : m_bookctrl(bookctrl)
1963{
1964 wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
1965}
1966
1967#endif // WXWIN_COMPATIBILITY_2_6
1968
1969void wxBookCtrlSizer::RecalcSizes()
1970{
1971 m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1972}
1973
1974wxSize wxBookCtrlSizer::CalcMin()
1975{
1976 wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0,0));
1977
1978 sizeBorder.x += 5;
1979 sizeBorder.y += 5;
1980
1981 if ( m_bookctrl->GetPageCount() == 0 )
1982 {
1983 return wxSize(sizeBorder.x + 10, sizeBorder.y + 10);
1984 }
1985
1986 int maxX = 0;
1987 int maxY = 0;
1988
1989 wxWindowList::compatibility_iterator
1990 node = m_bookctrl->GetChildren().GetFirst();
1991 while (node)
1992 {
1993 wxWindow *item = node->GetData();
1994 wxSizer *itemsizer = item->GetSizer();
1995
1996 if (itemsizer)
1997 {
1998 wxSize subsize( itemsizer->CalcMin() );
1999
2000 if (subsize.x > maxX)
2001 maxX = subsize.x;
2002 if (subsize.y > maxY)
2003 maxY = subsize.y;
2004 }
2005
2006 node = node->GetNext();
2007 }
2008
2009 return wxSize( maxX, maxY ) + sizeBorder;
2010}
2011
2012#if wxUSE_NOTEBOOK
2013
2014#if WXWIN_COMPATIBILITY_2_6
2015
2016wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
2017{
2018 wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a control") );
2019 m_bookctrl = nb;
2020}
2021
2022#endif // WXWIN_COMPATIBILITY_2_6
2023
2024#endif // wxUSE_NOTEBOOOK
2025#endif // wxUSE_BOOKCTRL
2026
2027#endif // WXWIN_COMPATIBILITY_2_4
wxWidgets (Impactor)