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