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