src/common/sizer.cpp

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