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