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


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