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