]> git.saurik.com Git - wxWidgets.git/blob - src/common/sizer.cpp
projects / wxWidgets.git / blob
? search:


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