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