src/common/sizer.cpp

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