]> git.saurik.com Git - wxWidgets.git/blob - src/common/sizer.cpp
projects / wxWidgets.git / blob
? search:


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