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