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


c4502c852eb40ac7653945cc386f9e9927901eed
[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 #ifdef __WXDEBUG__
1785 // by the time this function is called, the sizer should be already fully
1786 // initialized and hence the number of its columns and rows is known and we
1787 // can check that all indices in m_growableCols/Rows are valid (see also
1788 // comments in AddGrowableCol/Row())
1789 if ( !m_rows || !m_cols )
1790 {
1791 int nrows, ncols;
1792 CalcRowsCols(nrows, ncols);
1793
1794 if ( !m_rows )
1795 {
1796 for ( size_t n = 0; n < m_growableRows.size(); n++ )
1797 {
1798 wxASSERT_MSG( m_growableRows[n] < nrows,
1799 "invalid growable row index" );
1800 }
1801 }
1802
1803 if ( !m_cols )
1804 {
1805 for ( size_t n = 0; n < m_growableCols.size(); n++ )
1806 {
1807 wxASSERT_MSG( m_growableCols[n] < ncols,
1808 "invalid growable column index" );
1809 }
1810 }
1811 }
1812 #endif // __WXDEBUG__
1813
1814
1815 if ( (m_flexDirection & wxHORIZONTAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1816 {
1817 DoAdjustForGrowables
1818 (
1819 sz.x - m_calculatedMinSize.x,
1820 m_growableCols,
1821 m_colWidths,
1822 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1823 : NULL
1824 );
1825
1826 // This gives nested objects that benefit from knowing one size
1827 // component in advance the chance to use that.
1828 bool didAdjustMinSize = false;
1829 int nrows, ncols;
1830 CalcRowsCols(nrows, ncols);
1831
1832 // Iterate over all items and inform about column width
1833 size_t n = 0;
1834 for ( wxSizerItemList::iterator i = m_children.begin();
1835 i != m_children.end();
1836 ++i, ++n )
1837 {
1838 const int col = n % ncols;
1839 didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y);
1840 }
1841
1842 // Only redo if info was actually used
1843 if( didAdjustMinSize )
1844 {
1845 DoAdjustForGrowables
1846 (
1847 sz.x - m_calculatedMinSize.x,
1848 m_growableCols,
1849 m_colWidths,
1850 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1851 : NULL
1852 );
1853 }
1854 }
1855
1856 if ( (m_flexDirection & wxVERTICAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1857 {
1858 // pass NULL instead of proportions if the grow mode is ALL as we
1859 // should treat all rows as having proportion of 1 then
1860 DoAdjustForGrowables
1861 (
1862 sz.y - m_calculatedMinSize.y,
1863 m_growableRows,
1864 m_rowHeights,
1865 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableRowsProportions
1866 : NULL
1867 );
1868 }
1869 }
1870
1871 bool wxFlexGridSizer::IsRowGrowable( size_t idx )
1872 {
1873 return m_growableRows.Index( idx ) != wxNOT_FOUND;
1874 }
1875
1876 bool wxFlexGridSizer::IsColGrowable( size_t idx )
1877 {
1878 return m_growableCols.Index( idx ) != wxNOT_FOUND;
1879 }
1880
1881 void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1882 {
1883 int nrows, ncols;
1884 CalcRowsCols(nrows, ncols);
1885
1886 wxASSERT_MSG( !IsRowGrowable( idx ),
1887 "AddGrowableRow() called for growable row" );
1888
1889 // notice that we intentionally don't check the index validity here in (the
1890 // common) case when the number of rows was not specified in the ctor -- in
1891 // this case it will be computed only later, when all items are added to
1892 // the sizer, and the check will be done in AdjustForGrowables()
1893 wxCHECK_RET( !m_rows || idx < (size_t)m_rows, "invalid row index" );
1894
1895 m_growableRows.Add( idx );
1896 m_growableRowsProportions.Add( proportion );
1897 }
1898
1899 void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1900 {
1901 int nrows, ncols;
1902 CalcRowsCols(nrows, ncols);
1903
1904 wxASSERT_MSG( !IsColGrowable( idx ),
1905 "AddGrowableCol() called for growable column" );
1906
1907 // see comment in AddGrowableRow(): although it's less common to omit the
1908 // specification of the number of columns, it still can also happen
1909 wxCHECK_RET( !m_cols || idx < (size_t)ncols, "invalid column index" );
1910
1911 m_growableCols.Add( idx );
1912 m_growableColsProportions.Add( proportion );
1913 }
1914
1915 // helper function for RemoveGrowableCol/Row()
1916 static void
1917 DoRemoveFromArrays(size_t idx, wxArrayInt& items, wxArrayInt& proportions)
1918 {
1919 const size_t count = items.size();
1920 for ( size_t n = 0; n < count; n++ )
1921 {
1922 if ( (size_t)items[n] == idx )
1923 {
1924 items.RemoveAt(n);
1925 proportions.RemoveAt(n);
1926 return;
1927 }
1928 }
1929
1930 wxFAIL_MSG( _T("column/row is already not growable") );
1931 }
1932
1933 void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
1934 {
1935 DoRemoveFromArrays(idx, m_growableCols, m_growableColsProportions);
1936 }
1937
1938 void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
1939 {
1940 DoRemoveFromArrays(idx, m_growableRows, m_growableRowsProportions);
1941 }
1942
1943 //---------------------------------------------------------------------------
1944 // wxBoxSizer
1945 //---------------------------------------------------------------------------
1946
1947 void wxBoxSizer::RecalcSizes()
1948 {
1949 if ( m_children.empty() )
1950 return;
1951
1952 const wxCoord totalMinorSize = GetSizeInMinorDir(m_size);
1953
1954 // the amount of free space which we should redistribute among the
1955 // stretchable items (i.e. those with non zero proportion)
1956 int delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
1957
1958
1959 // Inform child items about the size in minor direction, that can
1960 // change how much free space we have in major dir and how to distribute it.
1961 int majorMinSum = 0;
1962 wxSizerItemList::const_iterator i ;
1963 for ( i = m_children.begin();
1964 i != m_children.end();
1965 ++i )
1966 {
1967 wxSizerItem * const item = *i;
1968
1969 if ( !item->IsShown() )
1970 continue;
1971
1972 wxSize szMinPrev = item->GetMinSizeWithBorder();
1973 item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta);
1974 wxSize szMin = item->GetMinSizeWithBorder();
1975 int deltaChange = GetSizeInMajorDir(szMin-szMinPrev);
1976 if( deltaChange )
1977 {
1978 // Since we passed available space along to the item, it should not
1979 // take too much, so delta should not become negative.
1980 delta -= deltaChange;
1981 }
1982 majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder());
1983 }
1984 // And update our min size
1985 SizeInMajorDir(m_minSize) = majorMinSum;
1986
1987
1988 // might have a new delta now
1989 delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
1990
1991 // the position at which we put the next child
1992 wxPoint pt(m_position);
1993
1994 int totalProportion = m_totalProportion;
1995 for ( i = m_children.begin();
1996 i != m_children.end();
1997 ++i )
1998 {
1999 wxSizerItem * const item = *i;
2000
2001 if ( !item->IsShown() )
2002 continue;
2003
2004 const wxSize sizeThis(item->GetMinSizeWithBorder());
2005
2006 // adjust the size in the major direction using the proportion
2007 wxCoord majorSize = GetSizeInMajorDir(sizeThis);
2008
2009 // if there is not enough space, don't try to distribute negative space
2010 // among the children, this would result in overlapping windows which
2011 // we don't want
2012 if ( delta > 0 )
2013 {
2014 const int propItem = item->GetProportion();
2015 if ( propItem )
2016 {
2017 const int deltaItem = (delta * propItem) / totalProportion;
2018
2019 majorSize += deltaItem;
2020
2021 delta -= deltaItem;
2022 totalProportion -= propItem;
2023 }
2024 }
2025
2026
2027 // apply the alignment in the minor direction
2028 wxPoint posChild(pt);
2029
2030 wxCoord minorSize = GetSizeInMinorDir(sizeThis);
2031 const int flag = item->GetFlag();
2032 if ( flag & (wxEXPAND | wxSHAPED) )
2033 {
2034 minorSize = totalMinorSize;
2035 }
2036 else if ( flag & (IsVertical() ? wxALIGN_RIGHT : wxALIGN_BOTTOM) )
2037 {
2038 PosInMinorDir(posChild) += totalMinorSize - minorSize;
2039 }
2040 // NB: wxCENTRE is used here only for backwards compatibility,
2041 // wxALIGN_CENTRE should be used in new code
2042 else if ( flag & (wxCENTER | (IsVertical() ? wxALIGN_CENTRE_HORIZONTAL : wxALIGN_CENTRE_VERTICAL)))
2043 {
2044 PosInMinorDir(posChild) += (totalMinorSize - minorSize) / 2;
2045 }
2046
2047
2048 // apply RTL adjustment for horizontal sizers:
2049 if ( !IsVertical() && m_containingWindow )
2050 {
2051 posChild.x = m_containingWindow->AdjustForLayoutDirection
2052 (
2053 posChild.x,
2054 majorSize,
2055 m_size.x
2056 );
2057 }
2058
2059 // finally set size of this child and advance to the next one
2060 item->SetDimension(posChild, SizeFromMajorMinor(majorSize, minorSize));
2061
2062 PosInMajorDir(pt) += majorSize;
2063 }
2064 }
2065
2066 wxSize wxBoxSizer::CalcMin()
2067 {
2068 m_totalProportion = 0;
2069 m_minSize = wxSize(0, 0);
2070
2071 // calculate the minimal sizes for all items and count sum of proportions
2072 for ( wxSizerItemList::const_iterator i = m_children.begin();
2073 i != m_children.end();
2074 ++i )
2075 {
2076 wxSizerItem * const item = *i;
2077
2078 if ( !item->IsShown() )
2079 continue;
2080
2081 const wxSize sizeMinThis = item->CalcMin();
2082 SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
2083 if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) )
2084 SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis);
2085
2086 m_totalProportion += item->GetProportion();
2087 }
2088
2089 return m_minSize;
2090 }
2091
2092 //---------------------------------------------------------------------------
2093 // wxStaticBoxSizer
2094 //---------------------------------------------------------------------------
2095
2096 #if wxUSE_STATBOX
2097
2098 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
2099 : wxBoxSizer( orient ),
2100 m_staticBox( box )
2101 {
2102 wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
2103
2104 // do this so that our Detach() is called if the static box is destroyed
2105 // before we are
2106 m_staticBox->SetContainingSizer(this);
2107 }
2108
2109 wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
2110 : wxBoxSizer(orient),
2111 m_staticBox(new wxStaticBox(win, wxID_ANY, s))
2112 {
2113 // same as above
2114 m_staticBox->SetContainingSizer(this);
2115 }
2116
2117 wxStaticBoxSizer::~wxStaticBoxSizer()
2118 {
2119 delete m_staticBox;
2120 }
2121
2122 static void GetStaticBoxBorders( wxStaticBox *box,
2123 int *borderTop,
2124 int *borderOther)
2125 {
2126 // this has to be done platform by platform as there is no way to
2127 // guess the thickness of a wxStaticBox border
2128 box->GetBordersForSizer(borderTop, borderOther);
2129 }
2130
2131 void wxStaticBoxSizer::RecalcSizes()
2132 {
2133 int top_border, other_border;
2134 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
2135
2136 m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
2137
2138 wxPoint old_pos( m_position );
2139 m_position.x += other_border;
2140 m_position.y += top_border;
2141 wxSize old_size( m_size );
2142 m_size.x -= 2*other_border;
2143 m_size.y -= top_border + other_border;
2144
2145 wxBoxSizer::RecalcSizes();
2146
2147 m_position = old_pos;
2148 m_size = old_size;
2149 }
2150
2151 wxSize wxStaticBoxSizer::CalcMin()
2152 {
2153 int top_border, other_border;
2154 GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
2155
2156 wxSize ret( wxBoxSizer::CalcMin() );
2157 ret.x += 2*other_border;
2158 ret.y += other_border + top_border;
2159
2160 return ret;
2161 }
2162
2163 void wxStaticBoxSizer::ShowItems( bool show )
2164 {
2165 m_staticBox->Show( show );
2166 wxBoxSizer::ShowItems( show );
2167 }
2168
2169 bool wxStaticBoxSizer::Detach( wxWindow *window )
2170 {
2171 // avoid deleting m_staticBox in our dtor if it's being detached from the
2172 // sizer (which can happen because it's being already destroyed for
2173 // example)
2174 if ( window == m_staticBox )
2175 {
2176 m_staticBox = NULL;
2177 return true;
2178 }
2179
2180 return wxSizer::Detach( window );
2181 }
2182
2183 #endif // wxUSE_STATBOX
2184
2185 #if wxUSE_BUTTON
2186
2187 wxStdDialogButtonSizer::wxStdDialogButtonSizer()
2188 : wxBoxSizer(wxHORIZONTAL)
2189 {
2190 // Vertical buttons with lots of space on either side
2191 // looks rubbish on WinCE, so let's not do this for now.
2192 // If we are going to use vertical buttons, we should
2193 // put the sizer to the right of other controls in the dialog,
2194 // and that's beyond the scope of this sizer.
2195 #ifndef __WXWINCE__
2196 bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
2197 // If we have a PDA screen, put yes/no button over
2198 // all other buttons, otherwise on the left side.
2199 if (is_pda)
2200 m_orient = wxVERTICAL;
2201 #endif
2202
2203 m_buttonAffirmative = NULL;
2204 m_buttonApply = NULL;
2205 m_buttonNegative = NULL;
2206 m_buttonCancel = NULL;
2207 m_buttonHelp = NULL;
2208 }
2209
2210 void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
2211 {
2212 switch (mybutton->GetId())
2213 {
2214 case wxID_OK:
2215 case wxID_YES:
2216 case wxID_SAVE:
2217 m_buttonAffirmative = mybutton;
2218 break;
2219 case wxID_APPLY:
2220 m_buttonApply = mybutton;
2221 break;
2222 case wxID_NO:
2223 m_buttonNegative = mybutton;
2224 break;
2225 case wxID_CANCEL:
2226 case wxID_CLOSE:
2227 m_buttonCancel = mybutton;
2228 break;
2229 case wxID_HELP:
2230 case wxID_CONTEXT_HELP:
2231 m_buttonHelp = mybutton;
2232 break;
2233 default:
2234 break;
2235 }
2236 }
2237
2238 void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
2239 {
2240 m_buttonAffirmative = button;
2241 }
2242
2243 void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
2244 {
2245 m_buttonNegative = button;
2246 }
2247
2248 void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
2249 {
2250 m_buttonCancel = button;
2251 }
2252
2253 void wxStdDialogButtonSizer::Realize()
2254 {
2255 #ifdef __WXMAC__
2256 Add(0, 0, 0, wxLEFT, 6);
2257 if (m_buttonHelp)
2258 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2259
2260 if (m_buttonNegative){
2261 // HIG POLICE BULLETIN - destructive buttons need extra padding
2262 // 24 pixels on either side
2263 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
2264 }
2265
2266 // extra whitespace between help/negative and cancel/ok buttons
2267 Add(0, 0, 1, wxEXPAND, 0);
2268
2269 if (m_buttonCancel){
2270 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2271 // Cancel or help should be default
2272 // m_buttonCancel->SetDefaultButton();
2273 }
2274
2275 // Ugh, Mac doesn't really have apply dialogs, so I'll just
2276 // figure the best place is between Cancel and OK
2277 if (m_buttonApply)
2278 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2279
2280 if (m_buttonAffirmative){
2281 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
2282
2283 if (m_buttonAffirmative->GetId() == wxID_SAVE){
2284 // these buttons have set labels under Mac so we should use them
2285 m_buttonAffirmative->SetLabel(_("Save"));
2286 if (m_buttonNegative)
2287 m_buttonNegative->SetLabel(_("Don't Save"));
2288 }
2289 }
2290
2291 // Extra space around and at the right
2292 Add(12, 40);
2293 #elif defined(__WXGTK20__)
2294 Add(0, 0, 0, wxLEFT, 9);
2295 if (m_buttonHelp)
2296 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2297
2298 // extra whitespace between help and cancel/ok buttons
2299 Add(0, 0, 1, wxEXPAND, 0);
2300
2301 if (m_buttonNegative){
2302 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2303 }
2304
2305 // according to HIG, in explicit apply windows the order is:
2306 // [ Help Apply Cancel OK ]
2307 if (m_buttonApply)
2308 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2309
2310 if (m_buttonCancel){
2311 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2312 // Cancel or help should be default
2313 // m_buttonCancel->SetDefaultButton();
2314 }
2315
2316 if (m_buttonAffirmative)
2317 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
2318 #elif defined(__WXMSW__)
2319 // Windows
2320
2321 // right-justify buttons
2322 Add(0, 0, 1, wxEXPAND, 0);
2323
2324 if (m_buttonAffirmative){
2325 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
2326 }
2327
2328 if (m_buttonNegative){
2329 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
2330 }
2331
2332 if (m_buttonCancel){
2333 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
2334 }
2335 if (m_buttonApply)
2336 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
2337
2338 if (m_buttonHelp)
2339 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
2340 #else
2341 // GTK+1 and any other platform
2342
2343 // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
2344 if (m_buttonHelp)
2345 Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
2346
2347 // extra whitespace between help and cancel/ok buttons
2348 Add(0, 0, 1, wxEXPAND, 0);
2349
2350 if (m_buttonApply)
2351 Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
2352
2353 if (m_buttonAffirmative){
2354 Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
2355 }
2356
2357 if (m_buttonNegative){
2358 Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
2359 }
2360
2361 if (m_buttonCancel){
2362 Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
2363 // Cancel or help should be default
2364 // m_buttonCancel->SetDefaultButton();
2365 }
2366
2367 #endif
2368 }
2369
2370 #endif // wxUSE_BUTTON
wxWidgets (Impactor)