]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/sizer.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
use correct fallback file name in SaveFile() (patch 820884)
[wxWidgets.git] / src / common / sizer.cpp
... / ...
CommitLineData
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#include "wx/sizer.h"
25#include "wx/utils.h"
26#include "wx/statbox.h"
27#include "wx/notebook.h"
28#include <wx/listimpl.cpp>
29
30//---------------------------------------------------------------------------
31
32IMPLEMENT_CLASS(wxSizerItem, wxObject)
33IMPLEMENT_CLASS(wxSizer, wxObject)
34IMPLEMENT_CLASS(wxGridSizer, wxSizer)
35IMPLEMENT_CLASS(wxFlexGridSizer, wxGridSizer)
36IMPLEMENT_CLASS(wxBoxSizer, wxSizer)
37#if wxUSE_STATBOX
38IMPLEMENT_CLASS(wxStaticBoxSizer, wxBoxSizer)
39#endif
40#if wxUSE_BOOKCTRL
41IMPLEMENT_CLASS(wxBookCtrlSizer, wxSizer)
42#if wxUSE_NOTEBOOK
43IMPLEMENT_CLASS(wxNotebookSizer, wxBookCtrlSizer)
44#endif // wxUSE_NOTEBOOK
45#endif // wxUSE_BOOKCTRL
46
47WX_DEFINE_EXPORTED_LIST( wxSizerItemList );
48
49/*
50 TODO PROPERTIES
51 sizeritem
52 object
53 object_ref
54 minsize
55 option
56 flag
57 border
58 spacer
59 option
60 flag
61 borfder
62 boxsizer
63 orient
64 staticboxsizer
65 orient
66 label
67 gridsizer
68 rows
69 cols
70 vgap
71 hgap
72 flexgridsizer
73 rows
74 cols
75 vgap
76 hgap
77 growablerows
78 growablecols
79 minsize
80*/
81//---------------------------------------------------------------------------
82// wxSizerItem
83//---------------------------------------------------------------------------
84
85wxSizerItem::wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData )
86 : m_window( NULL )
87 , m_sizer( NULL )
88 , m_size( wxSize( width, height ) ) // size is set directly
89 , m_minSize( m_size ) // minimal size is the initial size
90 , m_proportion( proportion )
91 , m_border( border )
92 , m_flag( flag )
93 , m_show( true )
94 , m_userData( userData )
95{
96 SetRatio( m_size );
97}
98
99wxSizerItem::wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
100 : m_window( window )
101 , m_sizer( NULL )
102 , m_minSize( window->GetSize() ) // minimal size is the initial size
103 , m_proportion( proportion )
104 , m_border( border )
105 , m_flag( flag )
106 , m_show( true )
107 , m_userData( userData )
108{
109 // aspect ratio calculated from initial size
110 SetRatio( m_minSize );
111
112 // m_size is calculated later
113}
114
115wxSizerItem::wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
116 : m_window( NULL )
117 , m_sizer( sizer )
118 , m_proportion( proportion )
119 , m_border( border )
120 , m_flag( flag )
121 , m_show( true )
122 , m_ratio( 0.0 )
123 , m_userData( userData )
124{
125 // m_minSize is calculated later
126 // m_size is calculated later
127}
128
129wxSizerItem::~wxSizerItem()
130{
131 delete m_userData;
132
133 if ( m_window )
134 {
135 m_window->SetContainingSizer(NULL);
136 }
137 else // we must be a sizer
138 {
139 delete m_sizer;
140 }
141}
142
143
144wxSize wxSizerItem::GetSize() const
145{
146 wxSize ret;
147 if (IsSizer())
148 ret = m_sizer->GetSize();
149 else
150 if (IsWindow())
151 ret = m_window->GetSize();
152 else ret = m_size;
153
154 if (m_flag & wxWEST)
155 ret.x += m_border;
156 if (m_flag & wxEAST)
157 ret.x += m_border;
158 if (m_flag & wxNORTH)
159 ret.y += m_border;
160 if (m_flag & wxSOUTH)
161 ret.y += m_border;
162
163 return ret;
164}
165
166wxSize wxSizerItem::CalcMin()
167{
168 wxSize ret;
169 if (IsSizer())
170 {
171 ret = m_sizer->GetMinSize();
172
173 // if we have to preserve aspect ratio _AND_ this is
174 // the first-time calculation, consider ret to be initial size
175 if ((m_flag & wxSHAPED) && !m_ratio)
176 SetRatio(ret);
177 }
178 else
179 {
180 if ( IsWindow() && (m_flag & wxADJUST_MINSIZE) )
181 {
182 // By user request, keep the minimal size for this item
183 // in sync with the largest of BestSize and any user supplied
184 // minimum size hint. Useful in cases where the item is
185 // changeable -- static text labels, etc.
186 m_minSize = m_window->GetAdjustedBestSize();
187 }
188
189 ret = m_minSize;
190 }
191
192 if (m_flag & wxWEST)
193 ret.x += m_border;
194 if (m_flag & wxEAST)
195 ret.x += m_border;
196 if (m_flag & wxNORTH)
197 ret.y += m_border;
198 if (m_flag & wxSOUTH)
199 ret.y += m_border;
200
201 return ret;
202}
203
204void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
205{
206 if (m_flag & wxSHAPED)
207 {
208 // adjust aspect ratio
209 int rwidth = (int) (size.y * m_ratio);
210 if (rwidth > size.x)
211 {
212 // fit horizontally
213 int rheight = (int) (size.x / m_ratio);
214 // add vertical space
215 if (m_flag & wxALIGN_CENTER_VERTICAL)
216 pos.y += (size.y - rheight) / 2;
217 else if (m_flag & wxALIGN_BOTTOM)
218 pos.y += (size.y - rheight);
219 // use reduced dimensions
220 size.y =rheight;
221 }
222 else if (rwidth < size.x)
223 {
224 // add horizontal space
225 if (m_flag & wxALIGN_CENTER_HORIZONTAL)
226 pos.x += (size.x - rwidth) / 2;
227 else if (m_flag & wxALIGN_RIGHT)
228 pos.x += (size.x - rwidth);
229 size.x = rwidth;
230 }
231 }
232
233 // This is what GetPosition() returns. Since we calculate
234 // borders afterwards, GetPosition() will be the left/top
235 // corner of the surrounding border.
236 m_pos = pos;
237
238 if (m_flag & wxWEST)
239 {
240 pos.x += m_border;
241 size.x -= m_border;
242 }
243 if (m_flag & wxEAST)
244 {
245 size.x -= m_border;
246 }
247 if (m_flag & wxNORTH)
248 {
249 pos.y += m_border;
250 size.y -= m_border;
251 }
252 if (m_flag & wxSOUTH)
253 {
254 size.y -= m_border;
255 }
256
257 if (IsSizer())
258 m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
259
260 if (IsWindow())
261 m_window->SetSize( pos.x, pos.y, size.x, size.y, wxSIZE_ALLOW_MINUS_ONE );
262
263 m_size = size;
264}
265
266void wxSizerItem::DeleteWindows()
267{
268 if (m_window)
269 m_window->Destroy();
270
271 if (m_sizer)
272 m_sizer->DeleteWindows();
273}
274
275bool wxSizerItem::IsWindow() const
276{
277 return (m_window != NULL);
278}
279
280bool wxSizerItem::IsSizer() const
281{
282 return (m_sizer != NULL);
283}
284
285bool wxSizerItem::IsSpacer() const
286{
287 return (m_window == NULL) && (m_sizer == NULL);
288}
289
290void wxSizerItem::Show( bool show )
291{
292 m_show = show;
293
294 if( IsWindow() )
295 m_window->Show( show );
296 else if( IsSizer() )
297 m_sizer->ShowItems( show );
298
299 // ... nothing else to do to hide/show spacers
300}
301
302void wxSizerItem::SetOption( int option )
303{
304 SetProportion( option );
305}
306
307int wxSizerItem::GetOption() const
308{
309 return GetProportion();
310}
311
312
313//---------------------------------------------------------------------------
314// wxSizer
315//---------------------------------------------------------------------------
316
317wxSizer::wxSizer()
318 : m_minSize( wxSize( 0, 0 ) )
319{
320}
321
322wxSizer::~wxSizer()
323{
324 WX_CLEAR_LIST(wxSizerItemList, m_children);
325}
326
327void wxSizer::Add( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
328{
329 m_children.Append( new wxSizerItem( window, proportion, flag, border, userData ) );
330 window->SetContainingSizer( this );
331}
332
333void wxSizer::Add( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
334{
335 m_children.Append( new wxSizerItem( sizer, proportion, flag, border, userData ) );
336}
337
338void wxSizer::Add( int width, int height, int proportion, int flag, int border, wxObject* userData )
339{
340 m_children.Append( new wxSizerItem( width, height, proportion, flag, border, userData ) );
341}
342
343void wxSizer::Add( wxSizerItem *item )
344{
345 m_children.Append( item );
346
347 if( item->GetWindow() )
348 item->GetWindow()->SetContainingSizer( this );
349}
350
351void wxSizer::Prepend( wxWindow *window, int proportion, int flag, int border, wxObject* userData )
352{
353 m_children.Insert( new wxSizerItem( window, proportion, flag, border, userData ) );
354 window->SetContainingSizer( this );
355}
356
357void wxSizer::Prepend( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData )
358{
359 m_children.Insert( new wxSizerItem( sizer, proportion, flag, border, userData ) );
360}
361
362void wxSizer::Prepend( int width, int height, int proportion, int flag, int border, wxObject* userData )
363{
364 m_children.Insert( new wxSizerItem( width, height, proportion, flag, border, userData ) );
365}
366
367void wxSizer::Prepend( wxSizerItem *item )
368{
369 m_children.Insert( item );
370
371 if( item->GetWindow() )
372 item->GetWindow()->SetContainingSizer( this );
373}
374
375void wxSizer::Insert( size_t index,
376 wxWindow *window,
377 int proportion,
378 int flag,
379 int border,
380 wxObject* userData )
381{
382 m_children.Insert( index,
383 new wxSizerItem( window, proportion, flag, border, userData ) );
384 window->SetContainingSizer( this );
385}
386
387void wxSizer::Insert( size_t index,
388 wxSizer *sizer,
389 int proportion,
390 int flag,
391 int border,
392 wxObject* userData )
393{
394 m_children.Insert( index,
395 new wxSizerItem( sizer, proportion, flag, border, userData ) );
396}
397
398void wxSizer::Insert( size_t index,
399 int width,
400 int height,
401 int proportion,
402 int flag,
403 int border,
404 wxObject* userData )
405{
406 m_children.Insert( index,
407 new wxSizerItem( width, height, proportion, flag, border, userData ) );
408}
409
410void wxSizer::Insert( size_t index, wxSizerItem *item )
411{
412 m_children.Insert( index, item );
413
414 if( item->GetWindow() )
415 item->GetWindow()->SetContainingSizer( this );
416}
417
418bool wxSizer::Remove( wxWindow *window )
419{
420 return Detach( window );
421}
422
423bool wxSizer::Remove( wxSizer *sizer )
424{
425 wxASSERT_MSG( sizer, _T("Removing NULL sizer") );
426
427 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
428 while (node)
429 {
430 wxSizerItem *item = node->GetData();
431
432 if (item->GetSizer() == sizer)
433 {
434 delete item;
435 m_children.Erase( node );
436 return true;
437 }
438
439 node = node->GetNext();
440 }
441
442 return false;
443}
444
445bool wxSizer::Remove( int index )
446{
447 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
448 false,
449 _T("Remove index is out of range") );
450
451 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
452
453 wxCHECK_MSG( node, false, _T("Failed to find child node") );
454
455 wxSizerItem *item = node->GetData();
456
457 if( item->IsWindow() )
458 item->GetWindow()->SetContainingSizer( NULL );
459
460 delete item;
461 m_children.Erase( node );
462 return true;
463}
464
465bool wxSizer::Detach( wxSizer *sizer )
466{
467 wxASSERT_MSG( sizer, _T("Detaching NULL sizer") );
468
469 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
470 while (node)
471 {
472 wxSizerItem *item = node->GetData();
473
474 if (item->GetSizer() == sizer)
475 {
476 item->DetachSizer();
477 delete item;
478 m_children.Erase( node );
479 return true;
480 }
481 node = node->GetNext();
482 }
483
484 return false;
485}
486
487bool wxSizer::Detach( wxWindow *window )
488{
489 wxASSERT_MSG( window, _T("Detaching NULL window") );
490
491 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
492 while (node)
493 {
494 wxSizerItem *item = node->GetData();
495
496 if (item->GetWindow() == window)
497 {
498 item->GetWindow()->SetContainingSizer( NULL );
499 delete item;
500 m_children.Erase( node );
501 return true;
502 }
503 node = node->GetNext();
504 }
505
506 return false;
507}
508
509bool wxSizer::Detach( int index )
510{
511 wxCHECK_MSG( index >= 0 && (size_t)index < m_children.GetCount(),
512 false,
513 _T("Detach index is out of range") );
514
515 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
516
517 wxCHECK_MSG( node, false, _T("Failed to find child node") );
518
519 wxSizerItem *item = node->GetData();
520
521 if( item->IsSizer() )
522 item->DetachSizer();
523 else if( item->IsWindow() )
524 item->GetWindow()->SetContainingSizer( NULL );
525
526 delete item;
527 m_children.Erase( node );
528 return true;
529}
530
531void wxSizer::Clear( bool delete_windows )
532{
533 // First clear the ContainingSizer pointers
534 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
535 while (node)
536 {
537 wxSizerItem *item = node->GetData();
538
539 if (item->IsWindow())
540 item->GetWindow()->SetContainingSizer( NULL );
541 node = node->GetNext();
542 }
543
544 // Destroy the windows if needed
545 if (delete_windows)
546 DeleteWindows();
547
548 // Now empty the list
549 WX_CLEAR_LIST(wxSizerItemList, m_children);
550}
551
552void wxSizer::DeleteWindows()
553{
554 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
555 while (node)
556 {
557 wxSizerItem *item = node->GetData();
558
559 item->DeleteWindows();
560 node = node->GetNext();
561 }
562}
563
564wxSize wxSizer::Fit( wxWindow *window )
565{
566 wxSize size(window->IsTopLevel() ? FitSize(window)
567 : GetMinWindowSize(window));
568
569 window->SetSize( size );
570
571 return size;
572}
573
574void wxSizer::FitInside( wxWindow *window )
575{
576 wxSize size;
577 if (window->IsTopLevel())
578 size = VirtualFitSize( window );
579 else
580 size = GetMinClientSize( window );
581
582 window->SetVirtualSize( size );
583}
584
585void wxSizer::Layout()
586{
587 CalcMin();
588 RecalcSizes();
589}
590
591void wxSizer::SetSizeHints( wxWindow *window )
592{
593 // Preserve the window's max size hints, but set the
594 // lower bound according to the sizer calculations.
595
596 wxSize size = Fit( window );
597
598 window->SetSizeHints( size.x,
599 size.y,
600 window->GetMaxWidth(),
601 window->GetMaxHeight() );
602}
603
604void wxSizer::SetVirtualSizeHints( wxWindow *window )
605{
606 // Preserve the window's max size hints, but set the
607 // lower bound according to the sizer calculations.
608
609 FitInside( window );
610 wxSize size( window->GetVirtualSize() );
611 window->SetVirtualSizeHints( size.x,
612 size.y,
613 window->GetMaxWidth(),
614 window->GetMaxHeight() );
615}
616
617wxSize wxSizer::GetMaxWindowSize( wxWindow *window ) const
618{
619 return window->GetMaxSize();
620}
621
622wxSize wxSizer::GetMinWindowSize( wxWindow *window )
623{
624 wxSize minSize( GetMinSize() );
625 wxSize size( window->GetSize() );
626 wxSize client_size( window->GetClientSize() );
627
628 return wxSize( minSize.x+size.x-client_size.x,
629 minSize.y+size.y-client_size.y );
630}
631
632// Return a window size that will fit within the screens dimensions
633wxSize wxSizer::FitSize( wxWindow *window )
634{
635 wxSize size = GetMinWindowSize( window );
636 wxSize sizeMax = GetMaxWindowSize( window );
637
638 // Limit the size if sizeMax != wxDefaultSize
639
640 if ( size.x > sizeMax.x && sizeMax.x != -1 )
641 size.x = sizeMax.x;
642 if ( size.y > sizeMax.y && sizeMax.y != -1 )
643 size.y = sizeMax.y;
644
645 return size;
646}
647
648wxSize wxSizer::GetMaxClientSize( wxWindow *window ) const
649{
650 wxSize maxSize( window->GetMaxSize() );
651
652 if( maxSize != wxDefaultSize )
653 {
654 wxSize size( window->GetSize() );
655 wxSize client_size( window->GetClientSize() );
656
657 return wxSize( maxSize.x + client_size.x - size.x,
658 maxSize.y + client_size.y - size.y );
659 }
660 else
661 return wxDefaultSize;
662}
663
664wxSize wxSizer::GetMinClientSize( wxWindow *WXUNUSED(window) )
665{
666 return GetMinSize(); // Already returns client size.
667}
668
669wxSize wxSizer::VirtualFitSize( wxWindow *window )
670{
671 wxSize size = GetMinClientSize( window );
672 wxSize sizeMax = GetMaxClientSize( window );
673
674 // Limit the size if sizeMax != wxDefaultSize
675
676 if ( size.x > sizeMax.x && sizeMax.x != -1 )
677 size.x = sizeMax.x;
678 if ( size.y > sizeMax.y && sizeMax.y != -1 )
679 size.y = sizeMax.y;
680
681 return size;
682}
683
684void wxSizer::SetDimension( int x, int y, int width, int height )
685{
686 m_position.x = x;
687 m_position.y = y;
688 m_size.x = width;
689 m_size.y = height;
690 Layout();
691}
692
693wxSize wxSizer::GetMinSize()
694{
695 wxSize ret( CalcMin() );
696 if (ret.x < m_minSize.x) ret.x = m_minSize.x;
697 if (ret.y < m_minSize.y) ret.y = m_minSize.y;
698 return ret;
699}
700
701void wxSizer::DoSetMinSize( int width, int height )
702{
703 m_minSize.x = width;
704 m_minSize.y = height;
705}
706
707bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
708{
709 wxASSERT_MSG( window, _T("SetMinSize for NULL window") );
710
711 // Is it our immediate child?
712
713 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
714 while (node)
715 {
716 wxSizerItem *item = node->GetData();
717
718 if (item->GetWindow() == window)
719 {
720 item->SetInitSize( width, height );
721 return true;
722 }
723 node = node->GetNext();
724 }
725
726 // No? Search any subsizers we own then
727
728 node = m_children.GetFirst();
729 while (node)
730 {
731 wxSizerItem *item = node->GetData();
732
733 if ( item->GetSizer() &&
734 item->GetSizer()->DoSetItemMinSize( window, width, height ) )
735 {
736 // A child sizer found the requested windw, exit.
737 return true;
738 }
739 node = node->GetNext();
740 }
741
742 return false;
743}
744
745bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
746{
747 wxASSERT_MSG( sizer, _T("SetMinSize for NULL sizer") );
748
749 // Is it our immediate child?
750
751 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
752 while (node)
753 {
754 wxSizerItem *item = node->GetData();
755
756 if (item->GetSizer() == sizer)
757 {
758 item->GetSizer()->DoSetMinSize( width, height );
759 return true;
760 }
761 node = node->GetNext();
762 }
763
764 // No? Search any subsizers we own then
765
766 node = m_children.GetFirst();
767 while (node)
768 {
769 wxSizerItem *item = node->GetData();
770
771 if ( item->GetSizer() &&
772 item->GetSizer()->DoSetItemMinSize( sizer, width, height ) )
773 {
774 // A child found the requested sizer, exit.
775 return true;
776 }
777 node = node->GetNext();
778 }
779
780 return false;
781}
782
783bool wxSizer::DoSetItemMinSize( size_t index, int width, int height )
784{
785 wxSizerItemList::compatibility_iterator node = m_children.Item( index );
786
787 wxCHECK_MSG( node, false, _T("Failed to find child node") );
788
789 wxSizerItem *item = node->GetData();
790
791 if (item->GetSizer())
792 {
793 // Sizers contains the minimal size in them, if not calculated ...
794 item->GetSizer()->DoSetMinSize( width, height );
795 }
796 else
797 {
798 // ... but the minimal size of spacers and windows in stored in them
799 item->SetInitSize( width, height );
800 }
801
802 return true;
803}
804
805void wxSizer::Show( wxWindow *window, bool show )
806{
807 wxASSERT_MSG( window, _T("Show for NULL window") );
808
809 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
810 while (node)
811 {
812 wxSizerItem *item = node->GetData();
813
814 if (item->GetWindow() == window)
815 {
816 item->Show( show );
817 break;
818 }
819 node = node->GetNext();
820 }
821}
822
823void wxSizer::Show( wxSizer *sizer, bool show )
824{
825 wxASSERT_MSG( sizer, _T("Show for NULL sizer") );
826
827 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
828 while (node)
829 {
830 wxSizerItem *item = node->GetData();
831
832 if (item->GetSizer() == sizer)
833 {
834 item->Show( show );
835 break;
836 }
837 node = node->GetNext();
838 }
839}
840
841void wxSizer::Show( size_t index, bool show )
842{
843 wxCHECK_RET( index < m_children.GetCount(),
844 _T("Show index is out of range") );
845
846 m_children.Item( index )->GetData()->Show( show );
847}
848
849void wxSizer::ShowItems( bool show )
850{
851 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
852 while (node)
853 {
854 node->GetData()->Show( show );
855 node = node->GetNext();
856 }
857}
858
859bool wxSizer::IsShown( wxWindow *window ) const
860{
861 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
862 while (node)
863 {
864 wxSizerItem *item = node->GetData();
865
866 if (item->GetWindow() == window)
867 {
868 return item->IsShown();
869 }
870 node = node->GetNext();
871 }
872
873 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
874
875 return false;
876}
877
878bool wxSizer::IsShown( wxSizer *sizer ) const
879{
880 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
881 while (node)
882 {
883 wxSizerItem *item = node->GetData();
884
885 if (item->GetSizer() == sizer)
886 {
887 return item->IsShown();
888 }
889 node = node->GetNext();
890 }
891
892 wxFAIL_MSG( _T("IsShown failed to find sizer item") );
893
894 return false;
895}
896
897bool wxSizer::IsShown( size_t index ) const
898{
899 wxCHECK_MSG( index < m_children.GetCount(),
900 false,
901 _T("IsShown index is out of range") );
902
903 return m_children.Item( index )->GetData()->IsShown();
904}
905
906
907//---------------------------------------------------------------------------
908// wxGridSizer
909//---------------------------------------------------------------------------
910
911wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
912 : m_rows( rows )
913 , m_cols( cols )
914 , m_vgap( vgap )
915 , m_hgap( hgap )
916{
917 if (m_rows == 0 && m_cols == 0)
918 m_rows = 1;
919}
920
921wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
922 : m_rows( 0 )
923 , m_cols( cols )
924 , m_vgap( vgap )
925 , m_hgap( hgap )
926{
927 if (m_rows == 0 && m_cols == 0)
928 m_rows = 1;
929}
930
931int wxGridSizer::CalcRowsCols(int& nrows, int& ncols) const
932{
933 int nitems = m_children.GetCount();
934 if ( nitems)
935 {
936 if ( m_cols )
937 {
938 ncols = m_cols;
939 nrows = (nitems + m_cols - 1) / m_cols;
940 }
941 else if ( m_rows )
942 {
943 ncols = (nitems + m_rows - 1) / m_rows;
944 nrows = m_rows;
945 }
946 else // 0 columns, 0 rows?
947 {
948 wxFAIL_MSG( _T("grid sizer must have either rows or columns fixed") );
949
950 nrows = ncols = 0;
951 }
952 }
953
954 return nitems;
955}
956
957void wxGridSizer::RecalcSizes()
958{
959 int nitems, nrows, ncols;
960 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
961 return;
962
963 wxSize sz( GetSize() );
964 wxPoint pt( GetPosition() );
965
966 int w = (sz.x - (ncols - 1) * m_hgap) / ncols;
967 int h = (sz.y - (nrows - 1) * m_vgap) / nrows;
968
969 int x = pt.x;
970 for (int c = 0; c < ncols; c++)
971 {
972 int y = pt.y;
973 for (int r = 0; r < nrows; r++)
974 {
975 int i = r * ncols + c;
976 if (i < nitems)
977 {
978 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
979
980 wxASSERT_MSG( node, _T("Failed to find SizerItemList node") );
981
982 SetItemBounds( node->GetData(), x, y, w, h);
983 }
984 y = y + h + m_vgap;
985 }
986 x = x + w + m_hgap;
987 }
988}
989
990wxSize wxGridSizer::CalcMin()
991{
992 int nrows, ncols;
993 if ( CalcRowsCols(nrows, ncols) == 0 )
994 return wxSize(10, 10);
995
996 // Find the max width and height for any component
997 int w = 0;
998 int h = 0;
999
1000 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1001 while (node)
1002 {
1003 wxSizerItem *item = node->GetData();
1004 wxSize sz( item->CalcMin() );
1005
1006 w = wxMax( w, sz.x );
1007 h = wxMax( h, sz.y );
1008
1009 node = node->GetNext();
1010 }
1011
1012 return wxSize( ncols * w + (ncols-1) * m_hgap,
1013 nrows * h + (nrows-1) * m_vgap );
1014}
1015
1016void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
1017{
1018 wxPoint pt( x,y );
1019 wxSize sz( item->CalcMin() );
1020 int flag = item->GetFlag();
1021
1022 if ((flag & wxEXPAND) || (flag & wxSHAPED))
1023 {
1024 sz = wxSize(w, h);
1025 }
1026 else
1027 {
1028 if (flag & wxALIGN_CENTER_HORIZONTAL)
1029 {
1030 pt.x = x + (w - sz.x) / 2;
1031 }
1032 else if (flag & wxALIGN_RIGHT)
1033 {
1034 pt.x = x + (w - sz.x);
1035 }
1036
1037 if (flag & wxALIGN_CENTER_VERTICAL)
1038 {
1039 pt.y = y + (h - sz.y) / 2;
1040 }
1041 else if (flag & wxALIGN_BOTTOM)
1042 {
1043 pt.y = y + (h - sz.y);
1044 }
1045 }
1046
1047 item->SetDimension(pt, sz);
1048}
1049
1050//---------------------------------------------------------------------------
1051// wxFlexGridSizer
1052//---------------------------------------------------------------------------
1053
1054wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
1055 : wxGridSizer( rows, cols, vgap, hgap ),
1056 m_flexDirection(wxBOTH),
1057 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1058{
1059}
1060
1061wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
1062 : wxGridSizer( cols, vgap, hgap ),
1063 m_flexDirection(wxBOTH),
1064 m_growMode(wxFLEX_GROWMODE_SPECIFIED)
1065{
1066}
1067
1068wxFlexGridSizer::~wxFlexGridSizer()
1069{
1070}
1071
1072void wxFlexGridSizer::RecalcSizes()
1073{
1074 int nitems, nrows, ncols;
1075 if ( (nitems = CalcRowsCols(nrows, ncols)) == 0 )
1076 return;
1077
1078 wxSize sz( GetSize() );
1079 wxSize minsz( CalcMin() );
1080 wxPoint pt( GetPosition() );
1081
1082 // what to do with the rows? by default, resize them proportionally
1083 if ( sz.y > minsz.y && ( (m_flexDirection & wxVERTICAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1084 {
1085 int sum_proportions = 0;
1086 int growable_space = 0;
1087 int num = 0;
1088 size_t idx;
1089 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1090 {
1091 // Since the number of rows/columns can change as items are inserted/deleted, we need
1092 // to verify at runtime that the requested growable rows/columns are still valid.
1093 if (m_growableRows[idx] >= nrows)
1094 continue;
1095 // If all items in a row/column are hidden, that row/column will have a dimension of -1.
1096 // This causes the row/column to be hidden completely.
1097 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1098 continue;
1099 sum_proportions += m_growableRowsProportions[idx];
1100 growable_space += m_rowHeights[ m_growableRows[idx] ];
1101 num++;
1102 }
1103
1104 if (num > 0)
1105 {
1106 for (idx = 0; idx < m_growableRows.GetCount(); idx++)
1107 {
1108 if (m_growableRows[idx] >= nrows )
1109 continue;
1110 if (m_rowHeights[ m_growableRows[idx] ] == -1)
1111 m_rowHeights[ m_growableRows[idx] ] = 0;
1112 else
1113 {
1114 int delta = (sz.y - minsz.y);
1115 if (sum_proportions == 0)
1116 delta = (delta/num) + m_rowHeights[ m_growableRows[idx] ];
1117 else
1118 delta = ((delta+growable_space)*m_growableRowsProportions[idx]) / sum_proportions;
1119 m_rowHeights[ m_growableRows[idx] ] = delta;
1120 }
1121 }
1122 }
1123 }
1124 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.y > minsz.y) )
1125 {
1126 // rounding problem?
1127 for ( int row = 0; row < nrows; ++row )
1128 m_rowHeights[ row ] = sz.y / nrows;
1129 }
1130
1131 // the same logic as above but for the columns
1132 if ( sz.x > minsz.x && ( (m_flexDirection & wxHORIZONTAL) || (m_growMode == wxFLEX_GROWMODE_SPECIFIED) ) )
1133 {
1134 int sum_proportions = 0;
1135 int growable_space = 0;
1136 int num = 0;
1137 size_t idx;
1138 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1139 {
1140 // Since the number of rows/columns can change as items are inserted/deleted, we need
1141 // to verify at runtime that the requested growable rows/columns are still valid.
1142 if (m_growableCols[idx] >= ncols)
1143 continue;
1144 // If all items in a row/column are hidden, that row/column will have a dimension of -1.
1145 // This causes the column to be hidden completely.
1146 if (m_colWidths[ m_growableCols[idx] ] == -1)
1147 continue;
1148 sum_proportions += m_growableColsProportions[idx];
1149 // wtb 5/12/02 bugfix - was m_ColWidths[idx]!!
1150 growable_space += m_colWidths[ m_growableCols[idx] ];
1151 num++;
1152 }
1153
1154 if (num > 0)
1155 {
1156 for (idx = 0; idx < m_growableCols.GetCount(); idx++)
1157 {
1158 if (m_growableCols[idx] >= ncols )
1159 continue;
1160 if (m_colWidths[ m_growableCols[idx] ] == -1)
1161 m_colWidths[ m_growableCols[idx] ] = 0;
1162 else
1163 {
1164 int delta = (sz.x - minsz.x);
1165 if (sum_proportions == 0)
1166 delta = (delta/num) + m_colWidths[ m_growableCols[idx] ];
1167 else
1168 delta = ((delta+growable_space)*m_growableColsProportions[idx])/sum_proportions;
1169 m_colWidths[ m_growableCols[idx] ] = delta;
1170 }
1171 }
1172 }
1173 }
1174 else if ( (m_growMode == wxFLEX_GROWMODE_ALL) && (sz.x > minsz.x) )
1175 {
1176 for ( int col=0; col < ncols; ++col )
1177 m_colWidths[ col ] = sz.x / ncols;
1178 }
1179
1180 sz = wxSize( pt.x + sz.x, pt.y + sz.y );
1181
1182 int x = pt.x;
1183 for (int c = 0; c < ncols; c++)
1184 {
1185 int y = pt.y;
1186 for (int r = 0; r < nrows; r++)
1187 {
1188 int i = r * ncols + c;
1189 if (i < nitems)
1190 {
1191 wxSizerItemList::compatibility_iterator node = m_children.Item( i );
1192
1193 wxASSERT_MSG( node, _T("Failed to find node") );
1194
1195 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
1196 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
1197
1198 SetItemBounds( node->GetData(), x, y, w, h);
1199 }
1200 y = y + m_rowHeights[r] + m_vgap;
1201 }
1202 x = x + m_colWidths[c] + m_hgap;
1203 }
1204}
1205
1206wxSize wxFlexGridSizer::CalcMin()
1207{
1208 int nrows,
1209 ncols;
1210 size_t i, s;
1211
1212 // Number of rows/columns can change as items are added or removed.
1213 if ( !CalcRowsCols(nrows, ncols) )
1214 return wxSize(10, 10);
1215
1216 m_rowHeights.SetCount(nrows);
1217 m_colWidths.SetCount(ncols);
1218
1219 // We have to recalcuate the sizes in case an item has wxADJUST_MINSIZE, has changed
1220 // minimum size since the previous layout, or has been hidden using wxSizer::Show().
1221 // If all the items in a row/column are hidden, the final dimension of the row/column
1222 // will be -1, indicating that the column itself is hidden.
1223 for( s = m_rowHeights.GetCount(), i = 0; i < s; ++i )
1224 m_rowHeights[ i ] = -1;
1225 for( s = m_colWidths.GetCount(), i = 0; i < s; ++i )
1226 m_colWidths[ i ] = -1;
1227
1228 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1229
1230 i = 0;
1231 while (node)
1232 {
1233 wxSizerItem *item = node->GetData();
1234 if ( item->IsShown() )
1235 {
1236 wxSize sz( item->CalcMin() );
1237 int row = i / ncols;
1238 int col = i % ncols;
1239
1240 m_rowHeights[ row ] = wxMax( wxMax( 0, sz.y ), m_rowHeights[ row ] );
1241 m_colWidths[ col ] = wxMax( wxMax( 0, sz.x ), m_colWidths[ col ] );
1242 }
1243
1244 node = node->GetNext();
1245 i++;
1246 }
1247
1248 // the logic above works when we resize flexibly in both directions but
1249 // maybe this is not the case
1250 if ( m_flexDirection != wxBOTH )
1251 {
1252 // select the array corresponding to the direction in which we do *not*
1253 // resize flexibly
1254 wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
1255 : m_rowHeights;
1256
1257 const int count = array.GetCount();
1258
1259 // find the largest value in this array
1260 int n, largest = 0;
1261 for ( n = 0; n < count; ++n )
1262 {
1263 if ( array[n] > largest )
1264 largest = array[n];
1265 }
1266
1267 // and now fill it with the largest value
1268 for ( n = 0; n < count; ++n )
1269 {
1270 array[n] = largest;
1271 }
1272 }
1273
1274 // Sum total minimum size, including gaps between rows/columns.
1275 // -1 is used as a magic number meaning empty column.
1276 int width = 0;
1277 for (int col = 0; col < ncols; col++)
1278 if ( m_colWidths[ col ] != -1 )
1279 width += m_colWidths[ col ] + ( col == ncols-1 ? 0 : m_hgap );
1280
1281 int height = 0;
1282 for (int row = 0; row < nrows; row++)
1283 if ( m_rowHeights[ row ] != -1 )
1284 height += m_rowHeights[ row ] + ( row == nrows-1 ? 0 : m_vgap );
1285
1286 return wxSize( width, height );
1287}
1288
1289void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1290{
1291 m_growableRows.Add( idx );
1292 m_growableRowsProportions.Add( proportion );
1293}
1294
1295void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
1296{
1297 m_growableRows.Remove( idx );
1298}
1299
1300void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1301{
1302 m_growableCols.Add( idx );
1303 m_growableColsProportions.Add( proportion );
1304}
1305
1306void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
1307{
1308 m_growableCols.Remove( idx );
1309}
1310
1311//---------------------------------------------------------------------------
1312// wxBoxSizer
1313//---------------------------------------------------------------------------
1314
1315wxBoxSizer::wxBoxSizer( int orient )
1316 : m_orient( orient )
1317{
1318}
1319
1320void wxBoxSizer::RecalcSizes()
1321{
1322 if (m_children.GetCount() == 0)
1323 return;
1324
1325 int delta = 0;
1326 if (m_stretchable)
1327 {
1328 if (m_orient == wxHORIZONTAL)
1329 delta = m_size.x - m_fixedWidth;
1330 else
1331 delta = m_size.y - m_fixedHeight;
1332 }
1333
1334 wxPoint pt( m_position );
1335
1336 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1337 while (node)
1338 {
1339 wxSizerItem *item = node->GetData();
1340
1341 if (item->IsShown())
1342 {
1343 wxSize size( item->CalcMin() );
1344
1345 if (m_orient == wxVERTICAL)
1346 {
1347 wxCoord height = size.y;
1348 if (item->GetProportion())
1349 {
1350 // Because of at least one visible item has non-zero
1351 // proportion then m_stretchable is not zero
1352 height = (delta * item->GetProportion()) / m_stretchable;
1353 }
1354
1355 wxPoint child_pos( pt );
1356 wxSize child_size( wxSize( size.x, height) );
1357
1358 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1359 child_size.x = m_size.x;
1360 else if (item->GetFlag() & wxALIGN_RIGHT)
1361 child_pos.x += m_size.x - size.x;
1362 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
1363 // XXX wxCENTER is added for backward compatibility;
1364 // wxALIGN_CENTER should be used in new code
1365 child_pos.x += (m_size.x - size.x) / 2;
1366
1367 item->SetDimension( child_pos, child_size );
1368
1369 pt.y += height;
1370 }
1371 else
1372 {
1373 wxCoord width = size.x;
1374 if (item->GetProportion())
1375 {
1376 // Because of at least one visible item has non-zero
1377 // proportion then m_stretchable is not zero
1378 width = (delta * item->GetProportion()) / m_stretchable;
1379 }
1380
1381 wxPoint child_pos( pt );
1382 wxSize child_size( wxSize(width, size.y) );
1383
1384 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
1385 child_size.y = m_size.y;
1386 else if (item->GetFlag() & wxALIGN_BOTTOM)
1387 child_pos.y += m_size.y - size.y;
1388 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
1389 // XXX wxCENTER is added for backward compatibility;
1390 // wxALIGN_CENTER should be used in new code
1391 child_pos.y += (m_size.y - size.y) / 2;
1392
1393 item->SetDimension( child_pos, child_size );
1394
1395 pt.x += width;
1396 }
1397 }
1398
1399 node = node->GetNext();
1400 }
1401}
1402
1403wxSize wxBoxSizer::CalcMin()
1404{
1405 if (m_children.GetCount() == 0)
1406 return wxSize(10,10);
1407
1408 m_stretchable = 0;
1409 m_minWidth = 0;
1410 m_minHeight = 0;
1411 m_fixedWidth = 0;
1412 m_fixedHeight = 0;
1413
1414 wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
1415 while (node)
1416 {
1417 wxSizerItem *item = node->GetData();
1418
1419 if (item->IsShown() && item->GetProportion() != 0)
1420 m_stretchable += item->GetProportion();
1421
1422 node = node->GetNext();
1423 }
1424
1425 // Total minimum size (width or height) of sizer
1426 int maxMinSize = 0;
1427
1428 node = m_children.GetFirst();
1429 while (node)
1430 {
1431 wxSizerItem *item = node->GetData();
1432
1433 if (item->IsShown() && item->GetProportion() != 0)
1434 {
1435 int stretch = item->GetProportion();
1436 wxSize size( item->CalcMin() );
1437 int minSize;
1438
1439 // Integer division rounded up is (a + b - 1) / b
1440 // Round up needed in order to guarantee that all
1441 // all items will have size not less then their min size
1442 if (m_orient == wxHORIZONTAL)
1443 minSize = ( size.x*m_stretchable + stretch - 1)/stretch;
1444 else
1445 minSize = ( size.y*m_stretchable + stretch - 1)/stretch;
1446
1447 if (minSize > maxMinSize)
1448 maxMinSize = minSize;
1449 }
1450 node = node->GetNext();
1451 }
1452
1453 // Calculate overall minimum size
1454 node = m_children.GetFirst();
1455 while (node)
1456 {
1457 wxSizerItem *item = node->GetData();
1458
1459 if (item->IsShown())
1460 {
1461 wxSize size( item->CalcMin() );
1462 if (item->GetProportion() != 0)
1463 {
1464 if (m_orient == wxHORIZONTAL)
1465 size.x = (maxMinSize*item->GetProportion())/m_stretchable;
1466 else
1467 size.y = (maxMinSize*item->GetProportion())/m_stretchable;
1468 }
1469 else
1470 {
1471 if (m_orient == wxVERTICAL)
1472 {
1473 m_fixedHeight += size.y;
1474 m_fixedWidth = wxMax( m_fixedWidth, size.x );
1475 }
1476 else
1477 {
1478 m_fixedWidth += size.x;
1479 m_fixedHeight = wxMax( m_fixedHeight, size.y );
1480 }
1481 }
1482
1483 if (m_orient == wxHORIZONTAL)
1484 {
1485 m_minWidth += size.x;
1486 m_minHeight = wxMax( m_minHeight, size.y );
1487 }
1488 else
1489 {
1490 m_minHeight += size.y;
1491 m_minWidth = wxMax( m_minWidth, size.x );
1492 }
1493 }
1494 node = node->GetNext();
1495 }
1496
1497 return wxSize( m_minWidth, m_minHeight );
1498}
1499
1500//---------------------------------------------------------------------------
1501// wxStaticBoxSizer
1502//---------------------------------------------------------------------------
1503
1504#if wxUSE_STATBOX
1505
1506wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
1507 : wxBoxSizer( orient )
1508 , m_staticBox( box )
1509{
1510 wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
1511}
1512
1513static void GetStaticBoxBorders( wxStaticBox *box,
1514 int *borderTop,
1515 int *borderOther)
1516{
1517 // this has to be done platform by platform as there is no way to
1518 // guess the thickness of a wxStaticBox border
1519#ifdef __WXCOCOA__
1520 box->GetBordersForSizer(borderTop,borderOther);
1521#else // __WXCOCOA__
1522#ifdef __WXGTK__
1523 if ( box->GetLabel().IsEmpty() )
1524 *borderTop = 5;
1525 else
1526#endif // __WXGTK__
1527 *borderTop = box->GetCharHeight();
1528
1529 *borderOther = 5;
1530#endif // __WXCOCOA__
1531}
1532
1533void wxStaticBoxSizer::RecalcSizes()
1534{
1535 int top_border, other_border;
1536 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1537
1538 m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1539
1540 wxPoint old_pos( m_position );
1541 m_position.x += other_border;
1542 m_position.y += top_border;
1543 wxSize old_size( m_size );
1544 m_size.x -= 2*other_border;
1545 m_size.y -= top_border + other_border;
1546
1547 wxBoxSizer::RecalcSizes();
1548
1549 m_position = old_pos;
1550 m_size = old_size;
1551}
1552
1553wxSize wxStaticBoxSizer::CalcMin()
1554{
1555 int top_border, other_border;
1556 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1557
1558 wxSize ret( wxBoxSizer::CalcMin() );
1559 ret.x += 2*other_border;
1560 ret.y += other_border + top_border;
1561
1562 return ret;
1563}
1564
1565#endif // wxUSE_STATBOX
1566
1567// ----------------------------------------------------------------------------
1568// wxNotebookSizer
1569// ----------------------------------------------------------------------------
1570
1571#if wxUSE_BOOKCTRL
1572
1573wxBookCtrlSizer::wxBookCtrlSizer(wxBookCtrl *bookctrl)
1574 : m_bookctrl(bookctrl)
1575{
1576 wxASSERT_MSG( bookctrl, wxT("wxBookCtrlSizer needs a control") );
1577}
1578
1579void wxBookCtrlSizer::RecalcSizes()
1580{
1581 m_bookctrl->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1582}
1583
1584wxSize wxBookCtrlSizer::CalcMin()
1585{
1586 wxSize sizeBorder = m_bookctrl->CalcSizeFromPage(wxSize(0, 0));
1587
1588 sizeBorder.x += 5;
1589 sizeBorder.y += 5;
1590
1591 if ( m_bookctrl->GetPageCount() == 0 )
1592 {
1593 return wxSize(sizeBorder.x + 10, sizeBorder.y + 10);
1594 }
1595
1596 int maxX = 0;
1597 int maxY = 0;
1598
1599 wxWindowList::compatibility_iterator
1600 node = m_bookctrl->GetChildren().GetFirst();
1601 while (node)
1602 {
1603 wxWindow *item = node->GetData();
1604 wxSizer *itemsizer = item->GetSizer();
1605
1606 if (itemsizer)
1607 {
1608 wxSize subsize( itemsizer->CalcMin() );
1609
1610 if (subsize.x > maxX)
1611 maxX = subsize.x;
1612 if (subsize.y > maxY)
1613 maxY = subsize.y;
1614 }
1615
1616 node = node->GetNext();
1617 }
1618
1619 return wxSize( maxX, maxY ) + sizeBorder;
1620}
1621
1622
1623#if wxUSE_NOTEBOOK
1624
1625wxNotebookSizer::wxNotebookSizer(wxNotebook *nb)
1626 : wxBookCtrlSizer(nb)
1627{
1628}
1629
1630#endif // wxUSE_NOTEBOOOK
1631#endif // wxUSE_BOOKCTRL
1632
wxWidgets (Impactor)