src/common/sizer.cpp

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