projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wiring OnInit on osx to a later point in event processing
[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/sizer.h"
21 #include "wx/private/flagscheck.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/display.h"
35 #include "wx/vector.h"
36 #include "wx/listimpl.cpp"
37
38
39 //---------------------------------------------------------------------------
40
41 IMPLEMENT_CLASS(wxSizerItem, wxObject)
42 IMPLEMENT_CLASS(wxSizer, wxObject)
43 IMPLEMENT_CLASS(wxGridSizer, wxSizer)
44 IMPLEMENT_CLASS(wxFlexGridSizer, wxGridSizer)
45 IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
46 #if wxUSE_STATBOX
47 IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
48 #endif
49 #if wxUSE_BUTTON
50 IMPLEMENT_CLASS(wxStdDialogButtonSizer, wxBoxSizer)
51 #endif
52
53 WX_DEFINE_EXPORTED_LIST( wxSizerItemList )
54
55 /*
56 TODO PROPERTIES
57 sizeritem
58 object
59 object_ref
60 minsize
61 option
62 flag
63 border
64 spacer
65 option
66 flag
67 borfder
68 boxsizer
69 orient
70 staticboxsizer
71 orient
72 label
73 gridsizer
74 rows
75 cols
76 vgap
77 hgap
78 flexgridsizer
79 rows
80 cols
81 vgap
82 hgap
83 growablerows
84 growablecols
85 minsize
86 */
87
88 // ----------------------------------------------------------------------------
89 // wxSizerItem
90 // ----------------------------------------------------------------------------
91
92 // check for flags conflicts
93 static const int SIZER_FLAGS_MASK =
94 wxADD_FLAG(wxCENTRE,
95 wxADD_FLAG(wxHORIZONTAL,
96 wxADD_FLAG(wxVERTICAL,
97 wxADD_FLAG(wxLEFT,
98 wxADD_FLAG(wxRIGHT,
99 wxADD_FLAG(wxUP,
100 wxADD_FLAG(wxDOWN,
101 wxADD_FLAG(wxALIGN_NOT,
102 wxADD_FLAG(wxALIGN_CENTER_HORIZONTAL,
103 wxADD_FLAG(wxALIGN_RIGHT,
104 wxADD_FLAG(wxALIGN_BOTTOM,
105 wxADD_FLAG(wxALIGN_CENTER_VERTICAL,
106 wxADD_FLAG(wxFIXED_MINSIZE,
107 wxADD_FLAG(wxRESERVE_SPACE_EVEN_IF_HIDDEN,
108 wxADD_FLAG(wxSTRETCH_NOT,
109 wxADD_FLAG(wxSHRINK,
110 wxADD_FLAG(wxGROW,
111 wxADD_FLAG(wxSHAPED,
112 0))))))))))))))))));
113
114 #define ASSERT_VALID_SIZER_FLAGS(f) wxASSERT_VALID_FLAGS(f, SIZER_FLAGS_MASK)
115
116
117 void wxSizerItem::Init(const wxSizerFlags& flags)
118 {
119 Init();
120
121 m_proportion = flags.GetProportion();
122 m_flag = flags.GetFlags();
123 m_border = flags.GetBorderInPixels();
124
125 ASSERT_VALID_SIZER_FLAGS( m_flag );
126 }
127
128 wxSizerItem::wxSizerItem()
129 {
130 Init();
131
132 m_proportion = 0;
133 m_border = 0;
134 m_flag = 0;
135 m_id = wxID_NONE;
136 }
137
138 // window item
139 void wxSizerItem::DoSetWindow(wxWindow *window)
140 {
141 wxCHECK_RET( window, wxT("NULL window in wxSizerItem::SetWindow()") );
142
143 m_kind = Item_Window;
144 m_window = window;
145
146 // window doesn't become smaller than its initial size, whatever happens
147 m_minSize = window->GetSize();
148
149 if ( m_flag & wxFIXED_MINSIZE )
150 window->SetMinSize(m_minSize);
151
152 // aspect ratio calculated from initial size
153 SetRatio(m_minSize);
154 }
155
156 wxSizerItem::wxSizerItem(wxWindow *window,
157 int proportion,
158 int flag,
159 int border,
160 wxObject* userData)
161 : m_kind(Item_None),
162 m_proportion(proportion),
163 m_border(border),
164 m_flag(flag),
165 m_id(wxID_NONE),
166 m_userData(userData)
167 {
168 ASSERT_VALID_SIZER_FLAGS( m_flag );
169
170 DoSetWindow(window);
171 }
172
173 // sizer item
174 void wxSizerItem::DoSetSizer(wxSizer *sizer)
175 {
176 m_kind = Item_Sizer;
177 m_sizer = sizer;
178 }
179
180 wxSizerItem::wxSizerItem(wxSizer *sizer,
181 int proportion,
182 int flag,
183 int border,
184 wxObject* userData)
185 : m_kind(Item_None),
186 m_sizer(NULL),
187 m_proportion(proportion),
188 m_border(border),
189 m_flag(flag),
190 m_id(wxID_NONE),
191 m_ratio(0.0),
192 m_userData(userData)
193 {
194 ASSERT_VALID_SIZER_FLAGS( m_flag );
195
196 DoSetSizer(sizer);
197
198 // m_minSize is set later
199 }
200
201 // spacer item
202 void wxSizerItem::DoSetSpacer(const wxSize& size)
203 {
204 m_kind = Item_Spacer;
205 m_spacer = new wxSizerSpacer(size);
206 m_minSize = size;
207 SetRatio(size);
208 }
209
210 wxSize wxSizerItem::AddBorderToSize(const wxSize& size) const
211 {
212 wxSize result = size;
213
214 // Notice that we shouldn't modify the unspecified component(s) of the
215 // size, it's perfectly valid to have either min or max size specified in
216 // one direction only and it shouldn't be applied in the other one then.
217
218 if ( result.x != wxDefaultCoord )
219 {
220 if (m_flag & wxWEST)
221 result.x += m_border;
222 if (m_flag & wxEAST)
223 result.x += m_border;
224 }
225
226 if ( result.y != wxDefaultCoord )
227 {
228 if (m_flag & wxNORTH)
229 result.y += m_border;
230 if (m_flag & wxSOUTH)
231 result.y += m_border;
232 }
233
234 return result;
235 }
236
237 wxSizerItem::wxSizerItem(int width,
238 int height,
239 int proportion,
240 int flag,
241 int border,
242 wxObject* userData)
243 : m_kind(Item_None),
244 m_sizer(NULL),
245 m_minSize(width, height), // minimal size is the initial size
246 m_proportion(proportion),
247 m_border(border),
248 m_flag(flag),
249 m_id(wxID_NONE),
250 m_userData(userData)
251 {
252 ASSERT_VALID_SIZER_FLAGS( m_flag );
253
254 DoSetSpacer(wxSize(width, height));
255 }
256
257 wxSizerItem::~wxSizerItem()
258 {
259 delete m_userData;
260 Free();
261 }
262
263 void wxSizerItem::Free()
264 {
265 switch ( m_kind )
266 {
267 case Item_None:
268 break;
269
270 case Item_Window:
271 m_window->SetContainingSizer(NULL);
272 break;
273
274 case Item_Sizer:
275 delete m_sizer;
276 break;
277
278 case Item_Spacer:
279 delete m_spacer;
280 break;
281
282 case Item_Max:
283 default:
284 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
285 }
286
287 m_kind = Item_None;
288 }
289
290 wxSize wxSizerItem::GetSpacer() const
291 {
292 wxSize size;
293 if ( m_kind == Item_Spacer )
294 size = m_spacer->GetSize();
295
296 return size;
297 }
298
299
300 wxSize wxSizerItem::GetSize() const
301 {
302 wxSize ret;
303 switch ( m_kind )
304 {
305 case Item_None:
306 break;
307
308 case Item_Window:
309 ret = m_window->GetSize();
310 break;
311
312 case Item_Sizer:
313 ret = m_sizer->GetSize();
314 break;
315
316 case Item_Spacer:
317 ret = m_spacer->GetSize();
318 break;
319
320 case Item_Max:
321 default:
322 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
323 }
324
325 if (m_flag & wxWEST)
326 ret.x += m_border;
327 if (m_flag & wxEAST)
328 ret.x += m_border;
329 if (m_flag & wxNORTH)
330 ret.y += m_border;
331 if (m_flag & wxSOUTH)
332 ret.y += m_border;
333
334 return ret;
335 }
336
337 bool wxSizerItem::InformFirstDirection(int direction, int size, int availableOtherDir)
338 {
339 // The size that come here will be including borders. Child items should get it
340 // without borders.
341 if( size>0 )
342 {
343 if( direction==wxHORIZONTAL )
344 {
345 if (m_flag & wxWEST)
346 size -= m_border;
347 if (m_flag & wxEAST)
348 size -= m_border;
349 }
350 else if( direction==wxVERTICAL )
351 {
352 if (m_flag & wxNORTH)
353 size -= m_border;
354 if (m_flag & wxSOUTH)
355 size -= m_border;
356 }
357 }
358
359 bool didUse = false;
360 // Pass the information along to the held object
361 if (IsSizer())
362 {
363 didUse = GetSizer()->InformFirstDirection(direction,size,availableOtherDir);
364 if (didUse)
365 m_minSize = GetSizer()->CalcMin();
366 }
367 else if (IsWindow())
368 {
369 didUse = GetWindow()->InformFirstDirection(direction,size,availableOtherDir);
370 if (didUse)
371 m_minSize = m_window->GetEffectiveMinSize();
372
373 // This information is useful for items with wxSHAPED flag, since
374 // we can request an optimal min size for such an item. Even if
375 // we overwrite the m_minSize member here, we can read it back from
376 // the owned window (happens automatically).
377 if( (m_flag & wxSHAPED) && (m_flag & wxEXPAND) && direction )
378 {
379 if( !wxIsNullDouble(m_ratio) )
380 {
381 wxCHECK_MSG( (m_proportion==0), false, wxT("Shaped item, non-zero proportion in wxSizerItem::InformFirstDirection()") );
382 if( direction==wxHORIZONTAL && !wxIsNullDouble(m_ratio) )
383 {
384 // Clip size so that we don't take too much
385 if( availableOtherDir>=0 && int(size/m_ratio)-m_minSize.y>availableOtherDir )
386 size = int((availableOtherDir+m_minSize.y)*m_ratio);
387 m_minSize = wxSize(size,int(size/m_ratio));
388 }
389 else if( direction==wxVERTICAL )
390 {
391 // Clip size so that we don't take too much
392 if( availableOtherDir>=0 && int(size*m_ratio)-m_minSize.x>availableOtherDir )
393 size = int((availableOtherDir+m_minSize.x)/m_ratio);
394 m_minSize = wxSize(int(size*m_ratio),size);
395 }
396 didUse = true;
397 }
398 }
399 }
400
401 return didUse;
402 }
403
404 wxSize wxSizerItem::CalcMin()
405 {
406 if (IsSizer())
407 {
408 m_minSize = m_sizer->GetMinSize();
409
410 // if we have to preserve aspect ratio _AND_ this is
411 // the first-time calculation, consider ret to be initial size
412 if ( (m_flag & wxSHAPED) && wxIsNullDouble(m_ratio) )
413 SetRatio(m_minSize);
414 }
415 else if ( IsWindow() )
416 {
417 // Since the size of the window may change during runtime, we
418 // should use the current minimal/best size.
419 m_minSize = m_window->GetEffectiveMinSize();
420 }
421
422 return GetMinSizeWithBorder();
423 }
424
425 wxSize wxSizerItem::GetMinSizeWithBorder() const
426 {
427 return AddBorderToSize(m_minSize);
428 }
429
430 wxSize wxSizerItem::GetMaxSizeWithBorder() const
431 {
432 return AddBorderToSize(GetMaxSize());
433 }
434
435 void wxSizerItem::SetDimension( const wxPoint& pos_, const wxSize& size_ )
436 {
437 wxPoint pos = pos_;
438 wxSize size = size_;
439 if (m_flag & wxSHAPED)
440 {
441 // adjust aspect ratio
442 int rwidth = (int) (size.y * m_ratio);
443 if (rwidth > size.x)
444 {
445 // fit horizontally
446 int rheight = (int) (size.x / m_ratio);
447 // add vertical space
448 if (m_flag & wxALIGN_CENTER_VERTICAL)
449 pos.y += (size.y - rheight) / 2;
450 else if (m_flag & wxALIGN_BOTTOM)
451 pos.y += (size.y - rheight);
452 // use reduced dimensions
453 size.y =rheight;
454 }
455 else if (rwidth < size.x)
456 {
457 // add horizontal space
458 if (m_flag & wxALIGN_CENTER_HORIZONTAL)
459 pos.x += (size.x - rwidth) / 2;
460 else if (m_flag & wxALIGN_RIGHT)
461 pos.x += (size.x - rwidth);
462 size.x = rwidth;
463 }
464 }
465
466 // This is what GetPosition() returns. Since we calculate
467 // borders afterwards, GetPosition() will be the left/top
468 // corner of the surrounding border.
469 m_pos = pos;
470
471 if (m_flag & wxWEST)
472 {
473 pos.x += m_border;
474 size.x -= m_border;
475 }
476 if (m_flag & wxEAST)
477 {
478 size.x -= m_border;
479 }
480 if (m_flag & wxNORTH)
481 {
482 pos.y += m_border;
483 size.y -= m_border;
484 }
485 if (m_flag & wxSOUTH)
486 {
487 size.y -= m_border;
488 }
489
490 if (size.x < 0)
491 size.x = 0;
492 if (size.y < 0)
493 size.y = 0;
494
495 m_rect = wxRect(pos, size);
496
497 switch ( m_kind )
498 {
499 case Item_None:
500 wxFAIL_MSG( wxT("can't set size of uninitialized sizer item") );
501 break;
502
503 case Item_Window:
504 {
505 // Use wxSIZE_FORCE_EVENT here since a sizer item might
506 // have changed alignment or some other property which would
507 // not change the size of the window. In such a case, no
508 // wxSizeEvent would normally be generated and thus the
509 // control wouldn't get laid out correctly here.
510 #if 1
511 m_window->SetSize(pos.x, pos.y, size.x, size.y,
512 wxSIZE_ALLOW_MINUS_ONE|wxSIZE_FORCE_EVENT );
513 #else
514 m_window->SetSize(pos.x, pos.y, size.x, size.y,
515 wxSIZE_ALLOW_MINUS_ONE );
516 #endif
517 break;
518 }
519 case Item_Sizer:
520 m_sizer->SetDimension(pos, size);
521 break;
522
523 case Item_Spacer:
524 m_spacer->SetSize(size);
525 break;
526
527 case Item_Max:
528 default:
529 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
530 }
531 }
532
533 void wxSizerItem::DeleteWindows()
534 {
535 switch ( m_kind )
536 {
537 case Item_None:
538 case Item_Spacer:
539 break;
540
541 case Item_Window:
542 //We are deleting the window from this sizer - normally
543 //the window destroys the sizer associated with it,
544 //which might destroy this, which we don't want
545 m_window->SetContainingSizer(NULL);
546 m_window->Destroy();
547 //Putting this after the switch will result in a spacer
548 //not being deleted properly on destruction
549 m_kind = Item_None;
550 break;
551
552 case Item_Sizer:
553 m_sizer->DeleteWindows();
554 break;
555
556 case Item_Max:
557 default:
558 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
559 }
560
561 }
562
563 void wxSizerItem::Show( bool show )
564 {
565 switch ( m_kind )
566 {
567 case Item_None:
568 wxFAIL_MSG( wxT("can't show uninitialized sizer item") );
569 break;
570
571 case Item_Window:
572 m_window->Show(show);
573 break;
574
575 case Item_Sizer:
576 m_sizer->Show(show);
577 break;
578
579 case Item_Spacer:
580 m_spacer->Show(show);
581 break;
582
583 case Item_Max:
584 default:
585 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
586 }
587 }
588
589 bool wxSizerItem::IsShown() const
590 {
591 if ( m_flag & wxRESERVE_SPACE_EVEN_IF_HIDDEN )
592 return true;
593
594 switch ( m_kind )
595 {
596 case Item_None:
597 // we may be called from CalcMin(), just return false so that we're
598 // not used
599 break;
600
601 case Item_Window:
602 return m_window->IsShown();
603
604 case Item_Sizer:
605 // arbitrarily decide that if at least one of our elements is
606 // shown, so are we (this arbitrariness is the reason for
607 // deprecating this function)
608 return m_sizer->AreAnyItemsShown();
609
610 case Item_Spacer:
611 return m_spacer->IsShown();
612
613 case Item_Max:
614 default:
615 wxFAIL_MSG( wxT("unexpected wxSizerItem::m_kind") );
616 }
617
618 return false;
619 }
620
621 #if WXWIN_COMPATIBILITY_2_6
622 void wxSizerItem::SetOption( int option )
623 {
624 SetProportion( option );
625 }
626
627 int wxSizerItem::GetOption() const
628 {
629 return GetProportion();
630 }
631 #endif // WXWIN_COMPATIBILITY_2_6
632
633
634 //---------------------------------------------------------------------------
635 // wxSizer
636 //---------------------------------------------------------------------------
637
638 wxSizer::~wxSizer()
639 {
640 WX_CLEAR_LIST(wxSizerItemList, m_children);
641 }
642
643 wxSizerItem* wxSizer::DoInsert( size_t index, wxSizerItem *item )
644 {
645 m_children.Insert( index, item );
646
647 if ( item->GetWindow() )
648 item->GetWindow()->SetContainingSizer( this );
649
650 if ( item->GetSizer() )
651 item->GetSizer()->SetContainingWindow( m_containingWindow );
652
653 return item;
654 }
655
656 void wxSizer::SetContainingWindow(wxWindow *win)
657 {
658 if ( win == m_containingWindow )
659 return;
660
661 m_containingWindow = win;
662
663 // set the same window for all nested sizers as well, they also are in the
664 // same window
665 for ( wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
666 node;
667 node = node->GetNext() )
668 {
669 wxSizerItem *const item = node->GetData();
670 wxSizer *const sizer = item->GetSizer();
671
672 if ( sizer )
673 {
674 sizer->SetContainingWindow(win);
675 }
676 }
677 }
678
679 #if WXWIN_COMPATIBILITY_2_6
680 bool wxSizer::Remove( wxWindow *window )
681 {
682 return Detach( window );
683 }
684 #endif // WXWIN_COMPATIBILITY_2_6
685
686 bool wxSizer::Remove( wxSizer *sizer )
687 {
688 wxASSERT_MSG( sizer, wxT("Removing NULL sizer") );
689
690 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
691 while (node)
692 {
693 wxSizerItem *item = node->GetData();
694
695 if (item->GetSizer() == sizer)
696 {
697 delete item;
698 m_children.Erase( node );
699 return true;
700 }
701
702 node = node->GetNext();
703 }
704
705 return false;
706 }
707
708 bool wxSizer::Remove( int index )
709 {
710 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
711 false,
712 wxT("Remove index is out of range") );
713
714 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
715
716 wxCHECK_MSG( node, false, wxT("Failed to find child node") );
717
718 delete node->GetData();
719 m_children.Erase( node );
720
721 return true;
722 }
723
724 bool wxSizer::Detach( wxSizer *sizer )
725 {
726 wxASSERT_MSG( sizer, wxT("Detaching NULL sizer") );
727
728 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
729 while (node)
730 {
731 wxSizerItem *item = node->GetData();
732
733 if (item->GetSizer() == sizer)
734 {
735 item->DetachSizer();
736 delete item;
737 m_children.Erase( node );
738 return true;
739 }
740 node = node->GetNext();
741 }
742
743 return false;
744 }
745
746 bool wxSizer::Detach( wxWindow *window )
747 {
748 wxASSERT_MSG( window, wxT("Detaching NULL window") );
749
750 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
751 while (node)
752 {
753 wxSizerItem *item = node->GetData();
754
755 if (item->GetWindow() == window)
756 {
757 delete item;
758 m_children.Erase( node );
759 return true;
760 }
761 node = node->GetNext();
762 }
763
764 return false;
765 }
766
767 bool wxSizer::Detach( int index )
768 {
769 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
770 false,
771 wxT("Detach index is out of range") );
772
773 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
774
775 wxCHECK_MSG( node, false, wxT("Failed to find child node") );
776
777 wxSizerItem *item = node->GetData();
778
779 if ( item->IsSizer() )
780 item->DetachSizer();
781
782 delete item;
783 m_children.Erase( node );
784 return true;
785 }
786
787 bool wxSizer::Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive )
788 {
789 wxASSERT_MSG( oldwin, wxT("Replacing NULL window") );
790 wxASSERT_MSG( newwin, wxT("Replacing with NULL window") );
791
792 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
793 while (node)
794 {
795 wxSizerItem *item = node->GetData();
796
797 if (item->GetWindow() == oldwin)
798 {
799 item->AssignWindow(newwin);
800 newwin->SetContainingSizer( this );
801 return true;
802 }
803 else if (recursive && item->IsSizer())
804 {
805 if (item->GetSizer()->Replace( oldwin, newwin, true ))
806 return true;
807 }
808
809 node = node->GetNext();
810 }
811
812 return false;
813 }
814
815 bool wxSizer::Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive )
816 {
817 wxASSERT_MSG( oldsz, wxT("Replacing NULL sizer") );
818 wxASSERT_MSG( newsz, wxT("Replacing with NULL sizer") );
819
820 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
821 while (node)
822 {
823 wxSizerItem *item = node->GetData();
824
825 if (item->GetSizer() == oldsz)
826 {
827 item->AssignSizer(newsz);
828 return true;
829 }
830 else if (recursive && item->IsSizer())
831 {
832 if (item->GetSizer()->Replace( oldsz, newsz, true ))
833 return true;
834 }
835
836 node = node->GetNext();
837 }
838
839 return false;
840 }
841
842 bool wxSizer::Replace( size_t old, wxSizerItem *newitem )
843 {
844 wxCHECK_MSG( old < m_children.GetCount(), false, wxT("Replace index is out of range") );
845 wxASSERT_MSG( newitem, wxT("Replacing with NULL item") );
846
847 wxSizerItemList::compatibility_iterator node = m_children.Item( old );
848
849 wxCHECK_MSG( node, false, wxT("Failed to find child node") );
850
851 wxSizerItem *item = node->GetData();
852 node->SetData(newitem);
853
854 if (item->IsWindow() && item->GetWindow())
855 item->GetWindow()->SetContainingSizer(NULL);
856
857 delete item;
858
859 return true;
860 }
861
862 void wxSizer::Clear( bool delete_windows )
863 {
864 // First clear the ContainingSizer pointers
865 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
866 while (node)
867 {
868 wxSizerItem *item = node->GetData();
869
870 if (item->IsWindow())
871 item->GetWindow()->SetContainingSizer( NULL );
872 node = node->GetNext();
873 }
874
875 // Destroy the windows if needed
876 if (delete_windows)
877 DeleteWindows();
878
879 // Now empty the list
880 WX_CLEAR_LIST(wxSizerItemList, m_children);
881 }
882
883 void wxSizer::DeleteWindows()
884 {
885 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
886 while (node)
887 {
888 wxSizerItem *item = node->GetData();
889
890 item->DeleteWindows();
891 node = node->GetNext();
892 }
893 }
894
895 wxSize wxSizer::ComputeFittingClientSize(wxWindow *window)
896 {
897 wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" );
898
899 // take the min size by default and limit it by max size
900 wxSize size = GetMinClientSize(window);
901 wxSize sizeMax;
902
903 wxTopLevelWindow *tlw = wxDynamicCast(window, wxTopLevelWindow);
904 if ( tlw )
905 {
906 // hack for small screen devices where TLWs are always full screen
907 if ( tlw->IsAlwaysMaximized() )
908 {
909 return tlw->GetClientSize();
910 }
911
912 // limit the window to the size of the display it is on
913 int disp = wxDisplay::GetFromWindow(window);
914 if ( disp == wxNOT_FOUND )
915 {
916 // or, if we don't know which one it is, of the main one
917 disp = 0;
918 }
919
920 sizeMax = wxDisplay(disp).GetClientArea().GetSize();
921
922 // If determining the display size failed, skip the max size checks as
923 // we really don't want to create windows of (0, 0) size.
924 if ( !sizeMax.x || !sizeMax.y )
925 return size;
926
927 // space for decorations and toolbars etc.
928 sizeMax = tlw->WindowToClientSize(sizeMax);
929 }
930 else
931 {
932 sizeMax = GetMaxClientSize(window);
933 }
934
935 if ( sizeMax.x != wxDefaultCoord && size.x > sizeMax.x )
936 size.x = sizeMax.x;
937 if ( sizeMax.y != wxDefaultCoord && size.y > sizeMax.y )
938 size.y = sizeMax.y;
939
940 return size;
941 }
942
943 wxSize wxSizer::ComputeFittingWindowSize(wxWindow *window)
944 {
945 wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" );
946
947 return window->ClientToWindowSize(ComputeFittingClientSize(window));
948 }
949
950 wxSize wxSizer::Fit( wxWindow *window )
951 {
952 wxCHECK_MSG( window, wxDefaultSize, "window can't be NULL" );
953
954 // set client size
955 window->SetClientSize(ComputeFittingClientSize(window));
956
957 // return entire size
958 return window->GetSize();
959 }
960
961 void wxSizer::FitInside( wxWindow *window )
962 {
963 wxSize size;
964 if (window->IsTopLevel())
965 size = VirtualFitSize( window );
966 else
967 size = GetMinClientSize( window );
968
969 window->SetVirtualSize( size );
970 }
971
972 void wxSizer::Layout()
973 {
974 // (re)calculates minimums needed for each item and other preparations
975 // for layout
976 CalcMin();
977
978 // Applies the layout and repositions/resizes the items
979 wxWindow::ChildrenRepositioningGuard repositionGuard(m_containingWindow);
980
981 RecalcSizes();
982 }
983
984 void wxSizer::SetSizeHints( wxWindow *window )
985 {
986 // Preserve the window's max size hints, but set the
987 // lower bound according to the sizer calculations.
988
989 // This is equivalent to calling Fit(), except that we need to set
990 // the size hints _in between_ the two steps performed by Fit
991 // (1. ComputeFittingClientSize, 2. SetClientSize). That's because
992 // otherwise SetClientSize() could have no effect if there already are
993 // size hints in effect that forbid requested client size.
994
995 const wxSize clientSize = ComputeFittingClientSize(window);
996
997 window->SetMinClientSize(clientSize);
998 window->SetClientSize(clientSize);
999 }
1000
1001 #if WXWIN_COMPATIBILITY_2_8
1002 void wxSizer::SetVirtualSizeHints( wxWindow *window )
1003 {
1004 FitInside( window );
1005 }
1006 #endif // WXWIN_COMPATIBILITY_2_8
1007
1008 // TODO on mac we need a function that determines how much free space this
1009 // min size contains, in order to make sure that we have 20 pixels of free
1010 // space around the controls
1011 wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
1012 {
1013 return window->WindowToClientSize(window->GetMaxSize());
1014 }
1015
1016 wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) )
1017 {
1018 return GetMinSize(); // Already returns client size.
1019 }
1020
1021 wxSize wxSizer::VirtualFitSize( wxWindow *window )
1022 {
1023 wxSize size = GetMinClientSize( window );
1024 wxSize sizeMax = GetMaxClientSize( window );
1025
1026 // Limit the size if sizeMax != wxDefaultSize
1027
1028 if ( size.x > sizeMax.x && sizeMax.x != wxDefaultCoord )
1029 size.x = sizeMax.x;
1030 if ( size.y > sizeMax.y && sizeMax.y != wxDefaultCoord )
1031 size.y = sizeMax.y;
1032
1033 return size;
1034 }
1035
1036 wxSize wxSizer::GetMinSize()
1037 {
1038 wxSize ret( CalcMin() );
1039 if (ret.x < m_minSize.x) ret.x = m_minSize.x;
1040 if (ret.y < m_minSize.y) ret.y = m_minSize.y;
1041 return ret;
1042 }
1043
1044 void wxSizer::DoSetMinSize( int width, int height )
1045 {
1046 m_minSize.x = width;
1047 m_minSize.y = height;
1048 }
1049
1050 bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
1051 {
1052 wxASSERT_MSG( window, wxT("SetMinSize for NULL window") );
1053
1054 // Is it our immediate child?
1055
1056 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1057 while (node)
1058 {
1059 wxSizerItem *item = node->GetData();
1060
1061 if (item->GetWindow() == window)
1062 {
1063 item->SetMinSize( width, height );
1064 return true;
1065 }
1066 node = node->GetNext();
1067 }
1068
1069 // No? Search any subsizers we own then
1070
1071 node = m_children.GetFirst();
1072 while (node)
1073 {
1074 wxSizerItem *item = node->GetData();
1075
1076 if ( item->GetSizer() &&
1077 item->GetSizer()->DoSetItemMinSize( window, width, height ) )
1078 {
1079 // A child sizer found the requested windw, exit.
1080 return true;
1081 }
1082 node = node->GetNext();
1083 }
1084
1085 return false;
1086 }
1087
1088 bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
1089 {
1090 wxASSERT_MSG( sizer, wxT("SetMinSize for NULL sizer") );
1091
1092 // Is it our immediate child?
1093
1094 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1095 while (node)
1096 {
1097 wxSizerItem *item = node->GetData();
1098
1099 if (item->GetSizer() == sizer)
1100 {
1101 item->GetSizer()->DoSetMinSize( width, height );
1102 return true;
1103 }
1104 node = node->GetNext();
1105 }
1106
1107 // No? Search any subsizers we own then
1108
1109 node = m_children.GetFirst();
1110 while (node)
1111 {
1112 wxSizerItem *item = node->GetData();
1113
1114 if ( item->GetSizer() &&
1115 item->GetSizer()->DoSetItemMinSize( sizer, width, height ) )
1116 {
1117 // A child found the requested sizer, exit.
1118 return true;
1119 }
1120 node = node->GetNext();
1121 }
1122
1123 return false;
1124 }
1125
1126 bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
1127 {
1128 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
1129
1130 wxCHECK_MSG( node, false, wxT("Failed to find child node") );
1131
1132 wxSizerItem *item = node->GetData();
1133
1134 if (item->GetSizer())
1135 {
1136 // Sizers contains the minimal size in them, if not calculated ...
1137 item->GetSizer()->DoSetMinSize( width, height );
1138 }
1139 else
1140 {
1141 // ... but the minimal size of spacers and windows is stored via the item
1142 item->SetMinSize( width, height );
1143 }
1144
1145 return true;
1146 }
1147
1148 wxSizerItem* wxSizer::GetItem( wxWindow *window, bool recursive )
1149 {
1150 wxASSERT_MSG( window, wxT("GetItem for NULL window") );
1151
1152 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1153 while (node)
1154 {
1155 wxSizerItem *item = node->GetData();
1156
1157 if (item->GetWindow() == window)
1158 {
1159 return item;
1160 }
1161 else if (recursive && item->IsSizer())
1162 {
1163 wxSizerItem *subitem = item->GetSizer()->GetItem( window, true );
1164 if (subitem)
1165 return subitem;
1166 }
1167
1168 node = node->GetNext();
1169 }
1170
1171 return NULL;
1172 }
1173
1174 wxSizerItem* wxSizer::GetItem( wxSizer *sizer, bool recursive )
1175 {
1176 wxASSERT_MSG( sizer, wxT("GetItem for NULL sizer") );
1177
1178 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1179 while (node)
1180 {
1181 wxSizerItem *item = node->GetData();
1182
1183 if (item->GetSizer() == sizer)
1184 {
1185 return item;
1186 }
1187 else if (recursive && item->IsSizer())
1188 {
1189 wxSizerItem *subitem = item->GetSizer()->GetItem( sizer, true );
1190 if (subitem)
1191 return subitem;
1192 }
1193
1194 node = node->GetNext();
1195 }
1196
1197 return NULL;
1198 }
1199
1200 wxSizerItem* wxSizer::GetItem( size_t index )
1201 {
1202 wxCHECK_MSG( index < m_children.GetCount(),
1203 NULL,
1204 wxT("GetItem index is out of range") );
1205
1206 return m_children.Item( index )->GetData();
1207 }
1208
1209 wxSizerItem* wxSizer::GetItemById( int id, bool recursive )
1210 {
1211 // This gets a sizer item by the id of the sizer item
1212 // and NOT the id of a window if the item is a window.
1213
1214 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1215 while (node)
1216 {
1217 wxSizerItem *item = node->GetData();
1218
1219 if (item->GetId() == id)
1220 {
1221 return item;
1222 }
1223 else if (recursive && item->IsSizer())
1224 {
1225 wxSizerItem *subitem = item->GetSizer()->GetItemById( id, true );
1226 if (subitem)
1227 return subitem;
1228 }
1229
1230 node = node->GetNext();
1231 }
1232
1233 return NULL;
1234 }
1235
1236 bool wxSizer::Show( wxWindow *window, bool show, bool recursive )
1237 {
1238 wxSizerItem *item = GetItem( window, recursive );
1239
1240 if ( item )
1241 {
1242 item->Show( show );
1243 return true;
1244 }
1245
1246 return false;
1247 }
1248
1249 bool wxSizer::Show( wxSizer *sizer, bool show, bool recursive )
1250 {
1251 wxSizerItem *item = GetItem( sizer, recursive );
1252
1253 if ( item )
1254 {
1255 item->Show( show );
1256 return true;
1257 }
1258
1259 return false;
1260 }
1261
1262 bool wxSizer::Show( size_t index, bool show)
1263 {
1264 wxSizerItem *item = GetItem( index );
1265
1266 if ( item )
1267 {
1268 item->Show( show );
1269 return true;
1270 }
1271
1272 return false;
1273 }
1274
1275 void wxSizer::ShowItems( bool show )
1276 {
1277 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1278 while (node)
1279 {
1280 node->GetData()->Show( show );
1281 node = node->GetNext();
1282 }
1283 }
1284
1285 bool wxSizer::AreAnyItemsShown() const
1286 {
1287 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1288 while (node)
1289 {
1290 if ( node->GetData()->IsShown() )
1291 return true;
1292 node = node->GetNext();
1293 }
1294
1295 return false;
1296 }
1297
1298 bool wxSizer::IsShown( wxWindow *window ) const
1299 {
1300 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1301 while (node)
1302 {
1303 wxSizerItem *item = node->GetData();
1304
1305 if (item->GetWindow() == window)
1306 {
1307 return item->IsShown();
1308 }
1309 node = node->GetNext();
1310 }
1311
1312 wxFAIL_MSG( wxT("IsShown failed to find sizer item") );
1313
1314 return false;
1315 }
1316
1317 bool wxSizer::IsShown( wxSizer *sizer ) const
1318 {
1319 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1320 while (node)
1321 {
1322 wxSizerItem *item = node->GetData();
1323
1324 if (item->GetSizer() == sizer)
1325 {
1326 return item->IsShown();
1327 }
1328 node = node->GetNext();
1329 }
1330
1331 wxFAIL_MSG( wxT("IsShown failed to find sizer item") );
1332
1333 return false;
1334 }
1335
1336 bool wxSizer::IsShown( size_t index ) const
1337 {
1338 wxCHECK_MSG( index < m_children.GetCount(),
1339 false,
1340 wxT("IsShown index is out of range") );
1341
1342 return m_children.Item( index )->GetData()->IsShown();
1343 }
1344
1345
1346 //---------------------------------------------------------------------------
1347 // wxGridSizer
1348 //---------------------------------------------------------------------------
1349
1350 wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
1351 : m_rows( cols == 0 ? 1 : 0 ),
1352 m_cols( cols ),
1353 m_vgap( vgap ),
1354 m_hgap( hgap )
1355 {
1356 wxASSERT(cols >= 0);
1357 }
1358
1359 wxGridSizer::wxGridSizer( int cols, const wxSize& gap )
1360 : m_rows( cols == 0 ? 1 : 0 ),
1361 m_cols( cols ),
1362 m_vgap( gap.GetHeight() ),
1363 m_hgap( gap.GetWidth() )
1364 {
1365 wxASSERT(cols >= 0);
1366 }
1367
1368 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
1369 : m_rows( rows || cols ? rows : 1 ),
1370 m_cols( cols ),
1371 m_vgap( vgap ),
1372 m_hgap( hgap )
1373 {
1374 wxASSERT(rows >= 0 && cols >= 0);
1375 }
1376
1377 wxGridSizer::wxGridSizer( int rows, int cols, const wxSize& gap )
1378 : m_rows( rows || cols ? rows : 1 ),
1379 m_cols( cols ),
1380 m_vgap( gap.GetHeight() ),
1381 m_hgap( gap.GetWidth() )
1382 {
1383 wxASSERT(rows >= 0 && cols >= 0);
1384 }
1385
1386 wxSizerItem *wxGridSizer::DoInsert(size_t index, wxSizerItem *item)
1387 {
1388 // if only the number of columns or the number of rows is specified for a
1389 // sizer, arbitrarily many items can be added to it but if both of them are
1390 // fixed, then the sizer can't have more than that many items -- check for
1391 // this here to ensure that we detect errors as soon as possible
1392 if ( m_cols && m_rows )
1393 {
1394 const int nitems = m_children.GetCount();
1395 if ( nitems == m_cols*m_rows )
1396 {
1397 wxFAIL_MSG(
1398 wxString::Format(
1399 "too many items (%d > %d*%d) in grid sizer (maybe you "
1400 "should omit the number of either rows or columns?)",
1401 nitems + 1, m_cols, m_rows)
1402 );
1403
1404 // additionally, continuing to use the specified number of columns
1405 // and rows is not a good idea as callers of CalcRowsCols() expect
1406 // that all sizer items can fit into m_cols-/m_rows-sized arrays
1407 // which is not the case if there are too many items and results in
1408 // crashes, so let it compute the number of rows automatically by
1409 // forgetting the (wrong) number of rows specified (this also has a
1410 // nice side effect of giving only one assert even if there are
1411 // many more items than allowed in this sizer)
1412 m_rows = 0;
1413 }
1414 }
1415
1416 return wxSizer::DoInsert(index, item);
1417 }
1418
1419 int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
1420 {
1421 const int nitems = m_children.GetCount();
1422
1423 ncols = GetEffectiveColsCount();
1424 nrows = GetEffectiveRowsCount();
1425
1426 // Since Insert() checks for overpopulation, the following
1427 // should only assert if the grid was shrunk via SetRows() / SetCols()
1428 wxASSERT_MSG( nitems <= ncols*nrows, "logic error in wxGridSizer" );
1429
1430 return nitems;
1431 }
1432
1433 void wxGridSizer::RecalcSizes()
1434 {
1435 int nitems, nrows, ncols;
1436 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1437 return;
1438
1439 wxSize sz( GetSize() );
1440 wxPoint pt( GetPosition() );
1441
1442 int w = (sz.x - (ncols - 1) * m_hgap) / ncols;
1443 int h = (sz.y - (nrows - 1) * m_vgap) / nrows;
1444
1445 int x = pt.x;
1446 for (int c = 0; c < ncols; c++)
1447 {
1448 int y = pt.y;
1449 for (int r = 0; r < nrows; r++)
1450 {
1451 int i = r * ncols + c;
1452 if (i < nitems)
1453 {
1454 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1455
1456 wxASSERT_MSG( node, wxT("Failed to find SizerItemList node") );
1457
1458 SetItemBounds( node->GetData(), x, y, w, h);
1459 }
1460 y = y + h + m_vgap;
1461 }
1462 x = x + w + m_hgap;
1463 }
1464 }
1465
1466 wxSize wxGridSizer::CalcMin()
1467 {
1468 int nrows, ncols;
1469 if ( CalcRowsCols(nrows, ncols) == 0 )
1470 return wxSize();
1471
1472 // Find the max width and height for any component
1473 int w = 0;
1474 int h = 0;
1475
1476 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1477 while (node)
1478 {
1479 wxSizerItem *item = node->GetData();
1480 wxSize sz( item->CalcMin() );
1481
1482 w = wxMax( w, sz.x );
1483 h = wxMax( h, sz.y );
1484
1485 node = node->GetNext();
1486 }
1487
1488 // In case we have a nested sizer with a two step algo , give it
1489 // a chance to adjust to that (we give it width component)
1490 node = m_children.GetFirst();
1491 bool didChangeMinSize = false;
1492 while (node)
1493 {
1494 wxSizerItem *item = node->GetData();
1495 didChangeMinSize |= item->InformFirstDirection( wxHORIZONTAL, w, -1 );
1496
1497 node = node->GetNext();
1498 }
1499
1500 // And redo iteration in case min size changed
1501 if( didChangeMinSize )
1502 {
1503 node = m_children.GetFirst();
1504 w = h = 0;
1505 while (node)
1506 {
1507 wxSizerItem *item = node->GetData();
1508 wxSize sz( item->GetMinSizeWithBorder() );
1509
1510 w = wxMax( w, sz.x );
1511 h = wxMax( h, sz.y );
1512
1513 node = node->GetNext();
1514 }
1515 }
1516
1517 return wxSize( ncols * w + (ncols-1) * m_hgap,
1518 nrows * h + (nrows-1) * m_vgap );
1519 }
1520
1521 void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
1522 {
1523 wxPoint pt( x,y );
1524 wxSize sz( item->GetMinSizeWithBorder() );
1525 int flag = item->GetFlag();
1526
1527 if ((flag & wxEXPAND) || (flag & wxSHAPED))
1528 {
1529 sz = wxSize(w, h);
1530 }
1531 else
1532 {
1533 if (flag & wxALIGN_CENTER_HORIZONTAL)
1534 {
1535 pt.x = x + (w - sz.x) / 2;
1536 }
1537 else if (flag & wxALIGN_RIGHT)
1538 {
1539 pt.x = x + (w - sz.x);
1540 }
1541
1542 if (flag & wxALIGN_CENTER_VERTICAL)
1543 {
1544 pt.y = y + (h - sz.y) / 2;
1545 }
1546 else if (flag & wxALIGN_BOTTOM)
1547 {
1548 pt.y = y + (h - sz.y);
1549 }
1550 }
1551
1552 item->SetDimension(pt, sz);
1553 }
1554
1555 //---------------------------------------------------------------------------
1556 // wxFlexGridSizer
1557 //---------------------------------------------------------------------------
1558
1559 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
1560 : wxGridSizer( cols, vgap, hgap ),
1561 m_flexDirection(wxBOTH),
1562 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1563 {
1564 }
1565
1566 wxFlexGridSizer::wxFlexGridSizer( int cols, const wxSize& gap )
1567 : wxGridSizer( cols, gap ),
1568 m_flexDirection(wxBOTH),
1569 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1570 {
1571 }
1572
1573 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
1574 : wxGridSizer( rows, cols, vgap, hgap ),
1575 m_flexDirection(wxBOTH),
1576 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1577 {
1578 }
1579
1580 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, const wxSize& gap )
1581 : wxGridSizer( rows, cols, gap ),
1582 m_flexDirection(wxBOTH),
1583 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1584 {
1585 }
1586
1587 wxFlexGridSizer::~wxFlexGridSizer()
1588 {
1589 }
1590
1591 void wxFlexGridSizer::RecalcSizes()
1592 {
1593 int nrows, ncols;
1594 if ( !CalcRowsCols(nrows, ncols) )
1595 return;
1596
1597 const wxPoint pt(GetPosition());
1598 const wxSize sz(GetSize());
1599
1600 AdjustForGrowables(sz);
1601
1602 wxSizerItemList::const_iterator i = m_children.begin();
1603 const wxSizerItemList::const_iterator end = m_children.end();
1604
1605 int y = 0;
1606 for ( int r = 0; r < nrows; r++ )
1607 {
1608 if ( m_rowHeights[r] == -1 )
1609 {
1610 // this row is entirely hidden, skip it
1611 for ( int c = 0; c < ncols; c++ )
1612 {
1613 if ( i == end )
1614 return;
1615
1616 ++i;
1617 }
1618
1619 continue;
1620 }
1621
1622 const int hrow = m_rowHeights[r];
1623 int h = sz.y - y; // max remaining height, don't overflow it
1624 if ( hrow < h )
1625 h = hrow;
1626
1627 int x = 0;
1628 for ( int c = 0; c < ncols && i != end; c++, ++i )
1629 {
1630 const int wcol = m_colWidths[c];
1631
1632 if ( wcol == -1 )
1633 continue;
1634
1635 int w = sz.x - x; // max possible value, ensure we don't overflow
1636 if ( wcol < w )
1637 w = wcol;
1638
1639 SetItemBounds(*i, pt.x + x, pt.y + y, w, h);
1640
1641 x += wcol + m_hgap;
1642 }
1643
1644 if ( i == end )
1645 return;
1646
1647 y += hrow + m_vgap;
1648 }
1649 }
1650
1651 // helper function used in CalcMin() to sum up the sizes of non-hidden items
1652 static int SumArraySizes(const wxArrayInt& sizes, int gap)
1653 {
1654 // Sum total minimum size, including gaps between rows/columns.
1655 // -1 is used as a magic number meaning empty row/column.
1656 int total = 0;
1657
1658 const size_t count = sizes.size();
1659 for ( size_t n = 0; n < count; n++ )
1660 {
1661 if ( sizes[n] != -1 )
1662 {
1663 if ( total )
1664 total += gap; // separate from the previous column
1665
1666 total += sizes[n];
1667 }
1668 }
1669
1670 return total;
1671 }
1672
1673 void wxFlexGridSizer::FindWidthsAndHeights(int nrows, int ncols)
1674 {
1675 // We have to recalculate the sizes in case the item minimum size has
1676 // changed since the previous layout, or the item has been hidden using
1677 // wxSizer::Show(). If all the items in a row/column are hidden, the final
1678 // dimension of the row/column will be -1, indicating that the column
1679 // itself is hidden.
1680 m_rowHeights.assign(nrows, -1);
1681 m_colWidths.assign(ncols, -1);
1682
1683 // n is the index of the item in left-to-right top-to-bottom order
1684 size_t n = 0;
1685 for ( wxSizerItemList::iterator i = m_children.begin();
1686 i != m_children.end();
1687 ++i, ++n )
1688 {
1689 wxSizerItem * const item = *i;
1690 if ( item->IsShown() )
1691 {
1692 // NOTE: Not doing the calculation here, this is just
1693 // for finding max values.
1694 const wxSize sz(item->GetMinSizeWithBorder());
1695
1696 const int row = n / ncols;
1697 const int col = n % ncols;
1698
1699 if ( sz.y > m_rowHeights[row] )
1700 m_rowHeights[row] = sz.y;
1701 if ( sz.x > m_colWidths[col] )
1702 m_colWidths[col] = sz.x;
1703 }
1704 }
1705
1706 AdjustForFlexDirection();
1707
1708 m_calculatedMinSize = wxSize(SumArraySizes(m_colWidths, m_hgap),
1709 SumArraySizes(m_rowHeights, m_vgap));
1710 }
1711
1712 wxSize wxFlexGridSizer::CalcMin()
1713 {
1714 int nrows,
1715 ncols;
1716
1717 // Number of rows/columns can change as items are added or removed.
1718 if ( !CalcRowsCols(nrows, ncols) )
1719 return wxSize();
1720
1721
1722 // We have to recalculate the sizes in case the item minimum size has
1723 // changed since the previous layout, or the item has been hidden using
1724 // wxSizer::Show(). If all the items in a row/column are hidden, the final
1725 // dimension of the row/column will be -1, indicating that the column
1726 // itself is hidden.
1727 m_rowHeights.assign(nrows, -1);
1728 m_colWidths.assign(ncols, -1);
1729
1730 for ( wxSizerItemList::iterator i = m_children.begin();
1731 i != m_children.end();
1732 ++i)
1733 {
1734 wxSizerItem * const item = *i;
1735 if ( item->IsShown() )
1736 {
1737 item->CalcMin();
1738 }
1739 }
1740
1741 // The stage of looking for max values in each row/column has been
1742 // made a separate function, since it's reused in AdjustForGrowables.
1743 FindWidthsAndHeights(nrows,ncols);
1744
1745 return m_calculatedMinSize;
1746 }
1747
1748 void wxFlexGridSizer::AdjustForFlexDirection()
1749 {
1750 // the logic in CalcMin works when we resize flexibly in both directions
1751 // but maybe this is not the case
1752 if ( m_flexDirection != wxBOTH )
1753 {
1754 // select the array corresponding to the direction in which we do *not*
1755 // resize flexibly
1756 wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
1757 : m_rowHeights;
1758
1759 const size_t count = array.GetCount();
1760
1761 // find the largest value in this array
1762 size_t n;
1763 int largest = 0;
1764
1765 for ( n = 0; n < count; ++n )
1766 {
1767 if ( array[n] > largest )
1768 largest = array[n];
1769 }
1770
1771 // and now fill it with the largest value
1772 for ( n = 0; n < count; ++n )
1773 {
1774 // don't touch hidden rows
1775 if ( array[n] != -1 )
1776 array[n] = largest;
1777 }
1778 }
1779 }
1780
1781 // helper of AdjustForGrowables() which is called for rows/columns separately
1782 //
1783 // parameters:
1784 // delta: the extra space, we do nothing unless it's positive
1785 // growable: indices or growable rows/cols in sizes array
1786 // sizes: the height/widths of rows/cols to adjust
1787 // proportions: proportions of the growable rows/cols or NULL if they all
1788 // should be assumed to have proportion of 1
1789 static void
1790 DoAdjustForGrowables(int delta,
1791 const wxArrayInt& growable,
1792 wxArrayInt& sizes,
1793 const wxArrayInt *proportions)
1794 {
1795 if ( delta <= 0 )
1796 return;
1797
1798 // total sum of proportions of all non-hidden rows
1799 int sum_proportions = 0;
1800
1801 // number of currently shown growable rows
1802 int num = 0;
1803
1804 const int max_idx = sizes.size();
1805
1806 const size_t count = growable.size();
1807 size_t idx;
1808 for ( idx = 0; idx < count; idx++ )
1809 {
1810 // Since the number of rows/columns can change as items are
1811 // inserted/deleted, we need to verify at runtime that the
1812 // requested growable rows/columns are still valid.
1813 if ( growable[idx] >= max_idx )
1814 continue;
1815
1816 // If all items in a row/column are hidden, that row/column will
1817 // have a dimension of -1. This causes the row/column to be
1818 // hidden completely.
1819 if ( sizes[growable[idx]] == -1 )
1820 continue;
1821
1822 if ( proportions )
1823 sum_proportions += (*proportions)[idx];
1824
1825 num++;
1826 }
1827
1828 if ( !num )
1829 return;
1830
1831 // the remaining extra free space, adjusted during each iteration
1832 for ( idx = 0; idx < count; idx++ )
1833 {
1834 if ( growable[idx] >= max_idx )
1835 continue;
1836
1837 if ( sizes[ growable[idx] ] == -1 )
1838 continue;
1839
1840 int cur_delta;
1841 if ( sum_proportions == 0 )
1842 {
1843 // no growable rows -- divide extra space evenly among all
1844 cur_delta = delta/num;
1845 num--;
1846 }
1847 else // allocate extra space proportionally
1848 {
1849 const int cur_prop = (*proportions)[idx];
1850 cur_delta = (delta*cur_prop)/sum_proportions;
1851 sum_proportions -= cur_prop;
1852 }
1853
1854 sizes[growable[idx]] += cur_delta;
1855 delta -= cur_delta;
1856 }
1857 }
1858
1859 void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz)
1860 {
1861 #if wxDEBUG_LEVEL
1862 // by the time this function is called, the sizer should be already fully
1863 // initialized and hence the number of its columns and rows is known and we
1864 // can check that all indices in m_growableCols/Rows are valid (see also
1865 // comments in AddGrowableCol/Row())
1866 if ( !m_rows || !m_cols )
1867 {
1868 if ( !m_rows )
1869 {
1870 int nrows = CalcRows();
1871
1872 for ( size_t n = 0; n < m_growableRows.size(); n++ )
1873 {
1874 wxASSERT_MSG( m_growableRows[n] < nrows,
1875 "invalid growable row index" );
1876 }
1877 }
1878
1879 if ( !m_cols )
1880 {
1881 int ncols = CalcCols();
1882
1883 for ( size_t n = 0; n < m_growableCols.size(); n++ )
1884 {
1885 wxASSERT_MSG( m_growableCols[n] < ncols,
1886 "invalid growable column index" );
1887 }
1888 }
1889 }
1890 #endif // wxDEBUG_LEVEL
1891
1892
1893 if ( (m_flexDirection & wxHORIZONTAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1894 {
1895 DoAdjustForGrowables
1896 (
1897 sz.x - m_calculatedMinSize.x,
1898 m_growableCols,
1899 m_colWidths,
1900 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1901 : NULL
1902 );
1903
1904 // This gives nested objects that benefit from knowing one size
1905 // component in advance the chance to use that.
1906 bool didAdjustMinSize = false;
1907
1908 // Iterate over all items and inform about column width
1909 const int ncols = GetEffectiveColsCount();
1910 int col = 0;
1911 for ( wxSizerItemList::iterator i = m_children.begin();
1912 i != m_children.end();
1913 ++i )
1914 {
1915 didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y);
1916 if ( ++col == ncols )
1917 col = 0;
1918 }
1919
1920 // Only redo if info was actually used
1921 if( didAdjustMinSize )
1922 {
1923 DoAdjustForGrowables
1924 (
1925 sz.x - m_calculatedMinSize.x,
1926 m_growableCols,
1927 m_colWidths,
1928 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1929 : NULL
1930 );
1931 }
1932 }
1933
1934 if ( (m_flexDirection & wxVERTICAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1935 {
1936 // pass NULL instead of proportions if the grow mode is ALL as we
1937 // should treat all rows as having proportion of 1 then
1938 DoAdjustForGrowables
1939 (
1940 sz.y - m_calculatedMinSize.y,
1941 m_growableRows,
1942 m_rowHeights,
1943 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableRowsProportions
1944 : NULL
1945 );
1946 }
1947 }
1948
1949 bool wxFlexGridSizer::IsRowGrowable( size_t idx )
1950 {
1951 return m_growableRows.Index( idx ) != wxNOT_FOUND;
1952 }
1953
1954 bool wxFlexGridSizer::IsColGrowable( size_t idx )
1955 {
1956 return m_growableCols.Index( idx ) != wxNOT_FOUND;
1957 }
1958
1959 void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1960 {
1961 wxASSERT_MSG( !IsRowGrowable( idx ),
1962 "AddGrowableRow() called for growable row" );
1963
1964 // notice that we intentionally don't check the index validity here in (the
1965 // common) case when the number of rows was not specified in the ctor -- in
1966 // this case it will be computed only later, when all items are added to
1967 // the sizer, and the check will be done in AdjustForGrowables()
1968 wxCHECK_RET( !m_rows || idx < (size_t)m_rows, "invalid row index" );
1969
1970 m_growableRows.Add( idx );
1971 m_growableRowsProportions.Add( proportion );
1972 }
1973
1974 void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1975 {
1976 wxASSERT_MSG( !IsColGrowable( idx ),
1977 "AddGrowableCol() called for growable column" );
1978
1979 // see comment in AddGrowableRow(): although it's less common to omit the
1980 // specification of the number of columns, it still can also happen
1981 wxCHECK_RET( !m_cols || idx < (size_t)m_cols, "invalid column index" );
1982
1983 m_growableCols.Add( idx );
1984 m_growableColsProportions.Add( proportion );
1985 }
1986
1987 // helper function for RemoveGrowableCol/Row()
1988 static void
1989 DoRemoveFromArrays(size_t idx, wxArrayInt& items, wxArrayInt& proportions)
1990 {
1991 const size_t count = items.size();
1992 for ( size_t n = 0; n < count; n++ )
1993 {
1994 if ( (size_t)items[n] == idx )
1995 {
1996 items.RemoveAt(n);
1997 proportions.RemoveAt(n);
1998 return;
1999 }
2000 }
2001
2002 wxFAIL_MSG( wxT("column/row is already not growable") );
2003 }
2004
2005 void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
2006 {
2007 DoRemoveFromArrays(idx, m_growableCols, m_growableColsProportions);
2008 }
2009
2010 void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
2011 {
2012 DoRemoveFromArrays(idx, m_growableRows, m_growableRowsProportions);
2013 }
2014
2015 //---------------------------------------------------------------------------
2016 // wxBoxSizer
2017 //---------------------------------------------------------------------------
2018
2019 wxSizerItem *wxBoxSizer::AddSpacer(int size)
2020 {
2021 return IsVertical() ? Add(0, size) : Add(size, 0);
2022 }
2023
2024 namespace
2025 {
2026
2027 /*
2028 Helper of RecalcSizes(): checks if there is enough remaining space for the
2029 min size of the given item and returns its min size or the entire remaining
2030 space depending on which one is greater.
2031
2032 This function updates the remaining space parameter to account for the size
2033 effectively allocated to the item.
2034 */
2035 int
2036 GetMinOrRemainingSize(int orient, const wxSizerItem *item, int *remainingSpace_)
2037 {
2038 int& remainingSpace = *remainingSpace_;
2039
2040 wxCoord size;
2041 if ( remainingSpace > 0 )
2042 {
2043 const wxSize sizeMin = item->GetMinSizeWithBorder();
2044 size = orient == wxHORIZONTAL ? sizeMin.x : sizeMin.y;
2045
2046 if ( size >= remainingSpace )
2047 {
2048 // truncate the item to fit in the remaining space, this is better
2049 // than showing it only partially in general, even if both choices
2050 // are bad -- but there is nothing else we can do
2051 size = remainingSpace;
2052 }
2053
2054 remainingSpace -= size;
2055 }
2056 else // no remaining space
2057 {
2058 // no space at all left, no need to even query the item for its min
2059 // size as we can't give it to it anyhow
2060 size = 0;
2061 }
2062
2063 return size;
2064 }
2065
2066 } // anonymous namespace
2067
2068 void wxBoxSizer::RecalcSizes()
2069 {
2070 if ( m_children.empty() )
2071 return;
2072
2073 const wxCoord totalMinorSize = GetSizeInMinorDir(m_size);
2074 const wxCoord totalMajorSize = GetSizeInMajorDir(m_size);
2075
2076 // the amount of free space which we should redistribute among the
2077 // stretchable items (i.e. those with non zero proportion)
2078 int delta = totalMajorSize - GetSizeInMajorDir(m_minSize);
2079
2080 // declare loop variables used below:
2081 wxSizerItemList::const_iterator i; // iterator in m_children list
2082 unsigned n = 0; // item index in majorSizes array
2083
2084
2085 // First, inform item about the available size in minor direction as this
2086 // can change their size in the major direction. Also compute the number of
2087 // visible items and sum of their min sizes in major direction.
2088
2089 int minMajorSize = 0;
2090 for ( i = m_children.begin(); i != m_children.end(); ++i )
2091 {
2092 wxSizerItem * const item = *i;
2093
2094 if ( !item->IsShown() )
2095 continue;
2096
2097 wxSize szMinPrev = item->GetMinSizeWithBorder();
2098 item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta);
2099 wxSize szMin = item->GetMinSizeWithBorder();
2100 int deltaChange = GetSizeInMajorDir(szMin-szMinPrev);
2101 if( deltaChange )
2102 {
2103 // Since we passed available space along to the item, it should not
2104 // take too much, so delta should not become negative.
2105 delta -= deltaChange;
2106 }
2107 minMajorSize += GetSizeInMajorDir(item->GetMinSizeWithBorder());
2108 }
2109
2110 // update our min size have changed
2111 SizeInMajorDir(m_minSize) = minMajorSize;
2112
2113
2114 // space and sum of proportions for the remaining items, both may change
2115 // below
2116 wxCoord remaining = totalMajorSize;
2117 int totalProportion = m_totalProportion;
2118
2119 // size of the (visible) items in major direction, -1 means "not fixed yet"
2120 wxVector<int> majorSizes(GetItemCount(), wxDefaultCoord);
2121
2122
2123 // Check for the degenerated case when we don't have enough space for even
2124 // the min sizes of all the items: in this case we really can't do much
2125 // more than to allocate the min size to as many of fixed size items as
2126 // possible (on the assumption that variable size items such as text zones
2127 // or list boxes may use scrollbars to show their content even if their
2128 // size is less than min size but that fixed size items such as buttons
2129 // will suffer even more if we don't give them their min size)
2130 if ( totalMajorSize < minMajorSize )
2131 {
2132 // Second degenerated case pass: allocate min size to all fixed size
2133 // items.
2134 for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
2135 {
2136 wxSizerItem * const item = *i;
2137
2138 if ( !item->IsShown() )
2139 continue;
2140
2141 // deal with fixed size items only during this pass
2142 if ( item->GetProportion() )
2143 continue;
2144
2145 majorSizes[n] = GetMinOrRemainingSize(m_orient, item, &remaining);
2146 }
2147
2148
2149 // Third degenerated case pass: allocate min size to all the remaining,
2150 // i.e. non-fixed size, items.
2151 for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
2152 {
2153 wxSizerItem * const item = *i;
2154
2155 if ( !item->IsShown() )
2156 continue;
2157
2158 // we've already dealt with fixed size items above
2159 if ( !item->GetProportion() )
2160 continue;
2161
2162 majorSizes[n] = GetMinOrRemainingSize(m_orient, item, &remaining);
2163 }
2164 }
2165 else // we do have enough space to give at least min sizes to all items
2166 {
2167 // Second and maybe more passes in the non-degenerated case: deal with
2168 // fixed size items and items whose min size is greater than what we
2169 // would allocate to them taking their proportion into account. For
2170 // both of them, we will just use their min size, but for the latter we
2171 // also need to reexamine all the items as the items which fitted
2172 // before we adjusted their size upwards might not fit any more. This
2173 // does make for a quadratic algorithm but it's not obvious how to
2174 // avoid it and hopefully it's not a huge problem in practice as the
2175 // sizers don't have many items usually (and, of course, the algorithm
2176 // still reduces into a linear one if there is enough space for all the
2177 // min sizes).
2178 bool nonFixedSpaceChanged = false;
2179 for ( i = m_children.begin(), n = 0; ; ++i, ++n )
2180 {
2181 if ( nonFixedSpaceChanged )
2182 {
2183 i = m_children.begin();
2184 n = 0;
2185 nonFixedSpaceChanged = false;
2186 }
2187
2188 // check for the end of the loop only after the check above as
2189 // otherwise we wouldn't do another pass if the last child resulted
2190 // in non fixed space reduction
2191 if ( i == m_children.end() )
2192 break;
2193
2194 wxSizerItem * const item = *i;
2195
2196 if ( !item->IsShown() )
2197 continue;
2198
2199 // don't check the item which we had already dealt with during a
2200 // previous pass (this is more than an optimization, the code
2201 // wouldn't work correctly if we kept adjusting for the same item
2202 // over and over again)
2203 if ( majorSizes[n] != wxDefaultCoord )
2204 continue;
2205
2206 wxCoord minMajor = GetSizeInMajorDir(item->GetMinSizeWithBorder());
2207
2208 // it doesn't make sense for min size to be negative but right now
2209 // it's possible to create e.g. a spacer with (-1, 10) as size and
2210 // people do it in their code apparently (see #11842) so ensure
2211 // that we don't use this -1 as real min size as it conflicts with
2212 // the meaning we use for it here and negative min sizes just don't
2213 // make sense anyhow (which is why it might be a better idea to
2214 // deal with them at wxSizerItem level in the future but for now
2215 // this is the minimal fix for the bug)
2216 if ( minMajor < 0 )
2217 minMajor = 0;
2218
2219 const int propItem = item->GetProportion();
2220 if ( propItem )
2221 {
2222 // is the desired size of this item big enough?
2223 if ( (remaining*propItem)/totalProportion >= minMajor )
2224 {
2225 // yes, it is, we'll determine the real size of this
2226 // item later, for now just leave it as wxDefaultCoord
2227 continue;
2228 }
2229
2230 // the proportion of this item won't count, it has
2231 // effectively become fixed
2232 totalProportion -= propItem;
2233 }
2234
2235 // we can already allocate space for this item
2236 majorSizes[n] = minMajor;
2237
2238 // change the amount of the space remaining to the other items,
2239 // as this can result in not being able to satisfy their
2240 // proportions any more we will need to redo another loop
2241 // iteration
2242 remaining -= minMajor;
2243
2244 nonFixedSpaceChanged = true;
2245 }
2246
2247 // Similar to the previous loop, but dealing with items whose max size
2248 // is less than what we would allocate to them taking their proportion
2249 // into account.
2250 nonFixedSpaceChanged = false;
2251 for ( i = m_children.begin(), n = 0; ; ++i, ++n )
2252 {
2253 if ( nonFixedSpaceChanged )
2254 {
2255 i = m_children.begin();
2256 n = 0;
2257 nonFixedSpaceChanged = false;
2258 }
2259
2260 // check for the end of the loop only after the check above as
2261 // otherwise we wouldn't do another pass if the last child resulted
2262 // in non fixed space reduction
2263 if ( i == m_children.end() )
2264 break;
2265
2266 wxSizerItem * const item = *i;
2267
2268 if ( !item->IsShown() )
2269 continue;
2270
2271 // don't check the item which we had already dealt with during a
2272 // previous pass (this is more than an optimization, the code
2273 // wouldn't work correctly if we kept adjusting for the same item
2274 // over and over again)
2275 if ( majorSizes[n] != wxDefaultCoord )
2276 continue;
2277
2278 wxCoord maxMajor = GetSizeInMajorDir(item->GetMaxSizeWithBorder());
2279
2280 // must be nonzero, fixed-size items were dealt with in previous loop
2281 const int propItem = item->GetProportion();
2282
2283 // is the desired size of this item small enough?
2284 if ( maxMajor < 0 ||
2285 (remaining*propItem)/totalProportion <= maxMajor )
2286 {
2287 // yes, it is, we'll determine the real size of this
2288 // item later, for now just leave it as wxDefaultCoord
2289 continue;
2290 }
2291
2292 // the proportion of this item won't count, it has
2293 // effectively become fixed
2294 totalProportion -= propItem;
2295
2296 // we can already allocate space for this item
2297 majorSizes[n] = maxMajor;
2298
2299 // change the amount of the space remaining to the other items,
2300 // as this can result in not being able to satisfy their
2301 // proportions any more we will need to redo another loop
2302 // iteration
2303 remaining -= maxMajor;
2304
2305 nonFixedSpaceChanged = true;
2306 }
2307
2308 // Last by one pass: distribute the remaining space among the non-fixed
2309 // items whose size weren't fixed yet according to their proportions.
2310 for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
2311 {
2312 wxSizerItem * const item = *i;
2313
2314 if ( !item->IsShown() )
2315 continue;
2316
2317 if ( majorSizes[n] == wxDefaultCoord )
2318 {
2319 const int propItem = item->GetProportion();
2320 majorSizes[n] = (remaining*propItem)/totalProportion;
2321
2322 remaining -= majorSizes[n];
2323 totalProportion -= propItem;
2324 }
2325 }
2326 }
2327
2328
2329 // the position at which we put the next child
2330 wxPoint pt(m_position);
2331
2332
2333 // Final pass: finally do position the items correctly using their sizes as
2334 // determined above.
2335 for ( i = m_children.begin(), n = 0; i != m_children.end(); ++i, ++n )
2336 {
2337 wxSizerItem * const item = *i;
2338
2339 if ( !item->IsShown() )
2340 continue;
2341
2342 const int majorSize = majorSizes[n];
2343
2344 const wxSize sizeThis(item->GetMinSizeWithBorder());
2345
2346 // apply the alignment in the minor direction
2347 wxPoint posChild(pt);
2348
2349 wxCoord minorSize = GetSizeInMinorDir(sizeThis);
2350 const int flag = item->GetFlag();
2351 if ( (flag & (wxEXPAND | wxSHAPED)) || (minorSize > totalMinorSize) )
2352 {
2353 // occupy all the available space if wxEXPAND was given and also if
2354 // the item is too big to fit -- in this case we truncate it below
2355 // its minimal size which is bad but better than not showing parts
2356 // of the window at all
2357 minorSize = totalMinorSize;
2358
2359 // do not allow the size in the minor direction to grow beyond the max
2360 // size of the item in the minor direction
2361 const wxCoord maxMinorSize = GetSizeInMinorDir(item->GetMaxSizeWithBorder());
2362 if ( maxMinorSize >= 0 && minorSize > maxMinorSize )
2363 minorSize = maxMinorSize;
2364 }
2365
2366 if ( flag & (IsVertical() ? wxALIGN_RIGHT : wxALIGN_BOTTOM) )
2367 {
2368 PosInMinorDir(posChild) += totalMinorSize - minorSize;
2369 }
2370 // NB: wxCENTRE is used here only for backwards compatibility,
2371 // wxALIGN_CENTRE should be used in new code
2372 else if ( flag & (wxCENTER | (IsVertical() ? wxALIGN_CENTRE_HORIZONTAL
2373 : wxALIGN_CENTRE_VERTICAL)) )
2374 {
2375 PosInMinorDir(posChild) += (totalMinorSize - minorSize) / 2;
2376 }
2377
2378
2379 // apply RTL adjustment for horizontal sizers:
2380 if ( !IsVertical() && m_containingWindow )
2381 {
2382 posChild.x = m_containingWindow->AdjustForLayoutDirection
2383 (
2384 posChild.x,
2385 majorSize,
2386 m_size.x
2387 );
2388 }
2389
2390 // finally set size of this child and advance to the next one
2391 item->SetDimension(posChild, SizeFromMajorMinor(majorSize, minorSize));
2392
2393 PosInMajorDir(pt) += majorSize;
2394 }
2395 }
2396
2397 wxSize wxBoxSizer::CalcMin()
2398 {
2399 m_totalProportion = 0;
2400 m_minSize = wxSize(0, 0);
2401
2402 // The minimal size for the sizer should be big enough to allocate its
2403 // element at least its minimal size but also, and this is the non trivial
2404 // part, to respect the children proportion. To satisfy the latter
2405 // condition we must find the greatest min-size-to-proportion ratio for all
2406 // elements with non-zero proportion.
2407 float maxMinSizeToProp = 0.;
2408 for ( wxSizerItemList::const_iterator i = m_children.begin();
2409 i != m_children.end();
2410 ++i )
2411 {
2412 wxSizerItem * const item = *i;
2413
2414 if ( !item->IsShown() )
2415 continue;
2416
2417 const wxSize sizeMinThis = item->CalcMin();
2418 if ( const int propThis = item->GetProportion() )
2419 {
2420 float minSizeToProp = GetSizeInMajorDir(sizeMinThis);
2421 minSizeToProp /= propThis;
2422
2423 if ( minSizeToProp > maxMinSizeToProp )
2424 maxMinSizeToProp = minSizeToProp;
2425
2426 m_totalProportion += item->GetProportion();
2427 }
2428 else // fixed size item
2429 {
2430 // Just account for its size directly
2431 SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
2432 }
2433
2434 // In the transversal direction we just need to find the maximum.
2435 if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) )
2436 SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis);
2437 }
2438
2439 // Using the max ratio ensures that the min size is big enough for all
2440 // items to have their min size and satisfy the proportions among them.
2441 SizeInMajorDir(m_minSize) += (int)(maxMinSizeToProp*m_totalProportion);
2442
2443 return m_minSize;
2444 }
2445
2446 //---------------------------------------------------------------------------
2447 // wxStaticBoxSizer
2448 //---------------------------------------------------------------------------
2449
2450 #if wxUSE_STATBOX
2451
2452 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
2453 : wxBoxSizer( orient ),
2454 m_staticBox( box )
2455 {
2456 wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
2457
2458 // do this so that our Detach() is called if the static box is destroyed
2459 // before we are
2460 m_staticBox->SetContainingSizer(this);
2461 }
2462
2463 wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
2464 : wxBoxSizer(orient),
2465 m_staticBox(new wxStaticBox(win, wxID_ANY, s))
2466 {
2467 // same as above
2468 m_staticBox->SetContainingSizer(this);
2469 }
2470
2471 wxStaticBoxSizer::~wxStaticBoxSizer()
2472 {
2473 delete m_staticBox;
2474 }
2475
2476 void wxStaticBoxSizer::RecalcSizes()
2477 {
2478 int top_border, other_border;
2479 m_staticBox->GetBordersForSizer(&top_border, &other_border);
2480
2481 m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
2482
2483 wxSize old_size( m_size );
2484 m_size.x -= 2*other_border;
2485 m_size.y -= top_border + other_border;
2486
2487 wxPoint old_pos( m_position );
2488 if (m_staticBox->GetChildren().GetCount() > 0)
2489 {
2490 #if defined( __WXGTK20__ )
2491 // if the wxStaticBox has created a wxPizza to contain its children
2492 // (see wxStaticBox::AddChild) then we need to place the items it contains
2493 // in the wxBoxSizer::RecalcSizes() call below using coordinates relative
2494 // to the top-left corner of the staticbox:
2495 m_position.x = m_position.y = 0;
2496 #elif defined(__WXOSX__) && wxOSX_USE_COCOA
2497 // the distance from the 'inner' content view to the embedded controls
2498 // this is independent of the title, therefore top_border is not relevant
2499 m_position.x = m_position.y = 10;
2500 #else
2501 // if the wxStaticBox has children, then these windows must be placed
2502 // by the wxBoxSizer::RecalcSizes() call below using coordinates relative
2503 // to the top-left corner of the staticbox (but unlike wxGTK, we need
2504 // to keep in count the static borders here!):
2505 m_position.x = other_border;
2506 m_position.y = top_border;
2507 #endif
2508 }
2509 else
2510 {
2511 // the windows contained in the staticbox have been created as siblings of the
2512 // staticbox (this is the "old" way of staticbox contents creation); in this
2513 // case we need to position them with coordinates relative to our common parent
2514 m_position.x += other_border;
2515 m_position.y += top_border;
2516 }
2517
2518 wxBoxSizer::RecalcSizes();
2519
2520 m_position = old_pos;
2521 m_size = old_size;
2522 }
2523
2524 wxSize wxStaticBoxSizer::CalcMin()
2525 {
2526 int top_border, other_border;
2527 m_staticBox->GetBordersForSizer(&top_border, &other_border);
2528
2529 wxSize ret( wxBoxSizer::CalcMin() );
2530 ret.x += 2*other_border;
2531
2532 // ensure that we're wide enough to show the static box label (there is no
2533 // need to check for the static box best size in vertical direction though)
2534 const int boxWidth = m_staticBox->GetBestSize().x;
2535 if ( ret.x < boxWidth )
2536 ret.x = boxWidth;
2537
2538 ret.y += other_border + top_border;
2539
2540 return ret;
2541 }
2542
2543 void wxStaticBoxSizer::ShowItems( bool show )
2544 {
2545 m_staticBox->Show( show );
2546 wxBoxSizer::ShowItems( show );
2547 }
2548
2549 bool wxStaticBoxSizer::AreAnyItemsShown() const
2550 {
2551 // We don't need to check the status of our child items: if the box is
2552 // shown, this sizer should be considered shown even if all its elements
2553 // are hidden (or, more prosaically, there are no elements at all). And,
2554 // conversely, if the box is hidden then all our items, which are its
2555 // children, are hidden too.
2556 return m_staticBox->IsShown();
2557 }
2558
2559 bool wxStaticBoxSizer::Detach( wxWindow *window )
2560 {
2561 // avoid deleting m_staticBox in our dtor if it's being detached from the
2562 // sizer (which can happen because it's being already destroyed for
2563 // example)
2564 if ( window == m_staticBox )
2565 {
2566 m_staticBox = NULL;
2567 return true;
2568 }
2569
2570 return wxSizer::Detach( window );
2571 }
2572
2573 #endif // wxUSE_STATBOX
2574
2575 //---------------------------------------------------------------------------
2576 // wxStdDialogButtonSizer
2577 //---------------------------------------------------------------------------
2578
2579 #if wxUSE_BUTTON
2580
2581 wxStdDialogButtonSizer::wxStdDialogButtonSizer()
2582 : wxBoxSizer(wxHORIZONTAL)
2583 {
2584 // Vertical buttons with lots of space on either side
2585 // looks rubbish on WinCE, so let's not do this for now.
2586 // If we are going to use vertical buttons, we should
2587 // put the sizer to the right of other controls in the dialog,
2588 // and that's beyond the scope of this sizer.
2589 #ifndef __WXWINCE__
2590 bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
2591 // If we have a PDA screen, put yes/no button over
2592 // all other buttons, otherwise on the left side.
2593 if (is_pda)
2594 m_orient = wxVERTICAL;
2595 #endif
2596
2597 m_buttonAffirmative = NULL;
2598 m_buttonApply = NULL;
2599 m_buttonNegative = NULL;
2600 m_buttonCancel = NULL;
2601 m_buttonHelp = NULL;
2602 }
2603
2604 void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
2605 {
2606 switch (mybutton->GetId())
2607 {
2608 case wxID_OK:
2609 case wxID_YES:
2610 case wxID_SAVE:
2611 m_buttonAffirmative = mybutton;
2612 break;
2613 case wxID_APPLY:
2614 m_buttonApply = mybutton;
2615 break;
2616 case wxID_NO:
2617 m_buttonNegative = mybutton;
2618 break;
2619 case wxID_CANCEL:
2620 case wxID_CLOSE:
2621 m_buttonCancel = mybutton;
2622 break;
2623 case wxID_HELP:
2624 case wxID_CONTEXT_HELP:
2625 m_buttonHelp = mybutton;
2626 break;
2627 default:
2628 break;
2629 }
2630 }
2631
2632 void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
2633 {
2634 m_buttonAffirmative = button;
2635 }
2636
2637 void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
2638 {
2639 m_buttonNegative = button;
2640 }
2641
2642 void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
2643 {
2644 m_buttonCancel = button;
2645 }
2646
2647 void wxStdDialogButtonSizer::Realize()
2648 {
2649 #ifdef __WXMAC__
2650 Add(0, 0, 0, wxLEFT, 6);
2651 if (m_buttonHelp)
2652 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2653
2654 if (m_buttonNegative){
2655 // HIG POLICE BULLETIN - destructive buttons need extra padding
2656 // 24 pixels on either side
2657 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
2658 }
2659
2660 // extra whitespace between help/negative and cancel/ok buttons
2661 Add(0, 0, 1, wxEXPAND, 0);
2662
2663 if (m_buttonCancel){
2664 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2665 // Cancel or help should be default
2666 // m_buttonCancel->SetDefaultButton();
2667 }
2668
2669 // Ugh, Mac doesn't really have apply dialogs, so I'll just
2670 // figure the best place is between Cancel and OK
2671 if (m_buttonApply)
2672 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2673
2674 if (m_buttonAffirmative){
2675 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
2676
2677 if (m_buttonAffirmative->GetId() == wxID_SAVE){
2678 // these buttons have set labels under Mac so we should use them
2679 m_buttonAffirmative->SetLabel(_("Save"));
2680 if (m_buttonNegative)
2681 m_buttonNegative->SetLabel(_("Don't Save"));
2682 }
2683 }
2684
2685 // Extra space around and at the right
2686 Add(12, 40);
2687 #elif defined(__WXGTK20__)
2688 // http://library.gnome.org/devel/hig-book/stable/windows-alert.html.en
2689 // says that the correct button order is
2690 //
2691 // [Help] [Alternative] [Cancel] [Affirmative]
2692
2693 // Flags ensuring that margins between the buttons are 6 pixels.
2694 const wxSizerFlags
2695 flagsBtn = wxSizerFlags().Centre().Border(wxLEFT | wxRIGHT, 3);
2696
2697 // Margin around the entire sizer button should be 12.
2698 AddSpacer(9);
2699
2700 if (m_buttonHelp)
2701 Add(m_buttonHelp, flagsBtn);
2702
2703 // Align the rest of the buttons to the right.
2704 AddStretchSpacer();
2705
2706 if (m_buttonNegative)
2707 Add(m_buttonNegative, flagsBtn);
2708
2709 if (m_buttonApply)
2710 Add(m_buttonApply, flagsBtn);
2711
2712 if (m_buttonCancel)
2713 Add(m_buttonCancel, flagsBtn);
2714
2715 if (m_buttonAffirmative)
2716 Add(m_buttonAffirmative, flagsBtn);
2717
2718 // Ensure that the right margin is 12 as well.
2719 AddSpacer(9);
2720 #elif defined(__WXMSW__)
2721 // Windows
2722
2723 // right-justify buttons
2724 Add(0, 0, 1, wxEXPAND, 0);
2725
2726 if (m_buttonAffirmative){
2727 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
2728 }
2729
2730 if (m_buttonNegative){
2731 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
2732 }
2733
2734 if (m_buttonCancel){
2735 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
2736 }
2737 if (m_buttonApply)
2738 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
2739
2740 if (m_buttonHelp)
2741 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
2742 #else
2743 // GTK+1 and any other platform
2744
2745 // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
2746 if (m_buttonHelp)
2747 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
2748
2749 // extra whitespace between help and cancel/ok buttons
2750 Add(0, 0, 1, wxEXPAND, 0);
2751
2752 if (m_buttonApply)
2753 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
2754
2755 if (m_buttonAffirmative){
2756 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
2757 }
2758
2759 if (m_buttonNegative){
2760 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
2761 }
2762
2763 if (m_buttonCancel){
2764 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
2765 // Cancel or help should be default
2766 // m_buttonCancel->SetDefaultButton();
2767 }
2768
2769 #endif
2770 }
2771
2772 #endif // wxUSE_BUTTON
wxWidgets (Impactor)