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             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     for ( wxSizerItemList::iterator i = m_children.begin();
1635           i != m_children.end();
1636           ++i)
1637     {
1638         wxSizerItem * const item = *i;
1639         if ( item->IsShown() )
1640         {
1641             item->CalcMin();
1642         }
1643     }
1644
1645     // The stage of looking for max values in each row/column has been
1646     // made a separate function, since it's reused in AdjustForGrowables.
1647     FindWidthsAndHeights(nrows,ncols);
1648
1649     return m_calculatedMinSize;
1650 }
1651
1652 void wxFlexGridSizer::AdjustForFlexDirection()
1653 {
1654     // the logic in CalcMin works when we resize flexibly in both directions
1655     // but maybe this is not the case
1656     if ( m_flexDirection != wxBOTH )
1657     {
1658         // select the array corresponding to the direction in which we do *not*
1659         // resize flexibly
1660         wxArrayInt& array = m_flexDirection == wxVERTICAL ? m_colWidths
1661                                                           : m_rowHeights;
1662
1663         const size_t count = array.GetCount();
1664
1665         // find the largest value in this array
1666         size_t n;
1667         int largest = 0;
1668
1669         for ( n = 0; n < count; ++n )
1670         {
1671             if ( array[n] > largest )
1672                 largest = array[n];
1673         }
1674
1675         // and now fill it with the largest value
1676         for ( n = 0; n < count; ++n )
1677         {
1678             // don't touch hidden rows
1679             if ( array[n] != -1 )
1680                 array[n] = largest;
1681         }
1682     }
1683 }
1684
1685 // helper of AdjustForGrowables() which is called for rows/columns separately
1686 //
1687 // parameters:
1688 //      delta: the extra space, we do nothing unless it's positive
1689 //      growable: indices or growable rows/cols in sizes array
1690 //      sizes: the height/widths of rows/cols to adjust
1691 //      proportions: proportions of the growable rows/cols or NULL if they all
1692 //                   should be assumed to have proportion of 1
1693 static void
1694 DoAdjustForGrowables(int delta,
1695                      const wxArrayInt& growable,
1696                      wxArrayInt& sizes,
1697                      const wxArrayInt *proportions)
1698 {
1699     if ( delta <= 0 )
1700         return;
1701
1702     // total sum of proportions of all non-hidden rows
1703     int sum_proportions = 0;
1704
1705     // number of currently shown growable rows
1706     int num = 0;
1707
1708     const int max_idx = sizes.size();
1709
1710     const size_t count = growable.size();
1711     size_t idx;
1712     for ( idx = 0; idx < count; idx++ )
1713     {
1714         // Since the number of rows/columns can change as items are
1715         // inserted/deleted, we need to verify at runtime that the
1716         // requested growable rows/columns are still valid.
1717         if ( growable[idx] >= max_idx )
1718             continue;
1719
1720         // If all items in a row/column are hidden, that row/column will
1721         // have a dimension of -1.  This causes the row/column to be
1722         // hidden completely.
1723         if ( sizes[growable[idx]] == -1 )
1724             continue;
1725
1726         if ( proportions )
1727             sum_proportions += (*proportions)[idx];
1728
1729         num++;
1730     }
1731
1732     if ( !num )
1733         return;
1734
1735     // the remaining extra free space, adjusted during each iteration
1736     for ( idx = 0; idx < count; idx++ )
1737     {
1738         if ( growable[idx] >= max_idx )
1739             continue;
1740
1741         if ( sizes[ growable[idx] ] == -1 )
1742             continue;
1743
1744         int cur_delta;
1745         if ( sum_proportions == 0 )
1746         {
1747             // no growable rows -- divide extra space evenly among all
1748             cur_delta = delta/num;
1749             num--;
1750         }
1751         else // allocate extra space proportionally
1752         {
1753             const int cur_prop = (*proportions)[idx];
1754             cur_delta = (delta*cur_prop)/sum_proportions;
1755             sum_proportions -= cur_prop;
1756         }
1757
1758         sizes[growable[idx]] += cur_delta;
1759         delta -= cur_delta;
1760     }
1761 }
1762
1763 void wxFlexGridSizer::AdjustForGrowables(const wxSize& sz)
1764 {
1765     if ( (m_flexDirection & wxHORIZONTAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1766     {
1767         DoAdjustForGrowables
1768         (
1769             sz.x - m_calculatedMinSize.x,
1770             m_growableCols,
1771             m_colWidths,
1772             m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1773                                                     : NULL
1774         );
1775
1776         // This gives nested objects that benefit from knowing one size
1777         // component in advance the chance to use that.
1778         bool didAdjustMinSize = false;
1779         int nrows, ncols;
1780         CalcRowsCols(nrows, ncols);
1781
1782         // Iterate over all items and inform about column width
1783         size_t n = 0;
1784         for ( wxSizerItemList::iterator i = m_children.begin();
1785               i != m_children.end();
1786               ++i, ++n )
1787         {
1788             const int col = n % ncols;
1789             didAdjustMinSize |= (*i)->InformFirstDirection(wxHORIZONTAL, m_colWidths[col], sz.y - m_calculatedMinSize.y);
1790         }
1791
1792         // Only redo if info was actually used
1793         if( didAdjustMinSize )
1794         {
1795             DoAdjustForGrowables
1796             (
1797                 sz.x - m_calculatedMinSize.x,
1798                 m_growableCols,
1799                 m_colWidths,
1800                 m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableColsProportions
1801                                                         : NULL
1802             );
1803         }
1804     }
1805
1806     if ( (m_flexDirection & wxVERTICAL) || (m_growMode != wxFLEX_GROWMODE_NONE) )
1807     {
1808         // pass NULL instead of proportions if the grow mode is ALL as we
1809         // should treat all rows as having proportion of 1 then
1810         DoAdjustForGrowables
1811         (
1812             sz.y - m_calculatedMinSize.y,
1813             m_growableRows,
1814             m_rowHeights,
1815             m_growMode == wxFLEX_GROWMODE_SPECIFIED ? &m_growableRowsProportions
1816                                                     : NULL
1817         );
1818     }
1819 }
1820
1821 bool wxFlexGridSizer::IsRowGrowable( size_t idx )
1822 {
1823     return m_growableRows.Index( idx ) != wxNOT_FOUND;
1824 }
1825
1826 bool wxFlexGridSizer::IsColGrowable( size_t idx )
1827 {
1828     return m_growableCols.Index( idx ) != wxNOT_FOUND;
1829 }
1830
1831 void wxFlexGridSizer::AddGrowableRow( size_t idx, int proportion )
1832 {
1833     wxASSERT_MSG( !IsRowGrowable( idx ),
1834                   "AddGrowableRow() called for growable row" );
1835     m_growableRows.Add( idx );
1836     m_growableRowsProportions.Add( proportion );
1837 }
1838
1839 void wxFlexGridSizer::AddGrowableCol( size_t idx, int proportion )
1840 {
1841     wxASSERT_MSG( !IsColGrowable( idx ),
1842                   "AddGrowableCol() called for growable column" );
1843     m_growableCols.Add( idx );
1844     m_growableColsProportions.Add( proportion );
1845 }
1846
1847 // helper function for RemoveGrowableCol/Row()
1848 static void
1849 DoRemoveFromArrays(size_t idx, wxArrayInt& items, wxArrayInt& proportions)
1850 {
1851     const size_t count = items.size();
1852     for ( size_t n = 0; n < count; n++ )
1853     {
1854         if ( (size_t)items[n] == idx )
1855         {
1856             items.RemoveAt(n);
1857             proportions.RemoveAt(n);
1858             return;
1859         }
1860     }
1861
1862     wxFAIL_MSG( _T("column/row is already not growable") );
1863 }
1864
1865 void wxFlexGridSizer::RemoveGrowableCol( size_t idx )
1866 {
1867     DoRemoveFromArrays(idx, m_growableCols, m_growableColsProportions);
1868 }
1869
1870 void wxFlexGridSizer::RemoveGrowableRow( size_t idx )
1871 {
1872     DoRemoveFromArrays(idx, m_growableRows, m_growableRowsProportions);
1873 }
1874
1875 //---------------------------------------------------------------------------
1876 // wxBoxSizer
1877 //---------------------------------------------------------------------------
1878
1879 void wxBoxSizer::RecalcSizes()
1880 {
1881     if ( m_children.empty() )
1882         return;
1883
1884     const wxCoord totalMinorSize = GetSizeInMinorDir(m_size);
1885
1886     // the amount of free space which we should redistribute among the
1887     // stretchable items (i.e. those with non zero proportion)
1888     int delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
1889
1890
1891     // Inform child items about the size in minor direction, that can
1892     // change how much free space we have in major dir and how to distribute it.
1893     int majorMinSum = 0;
1894     wxSizerItemList::const_iterator i ;
1895     for ( i = m_children.begin();
1896           i != m_children.end();
1897           ++i )
1898     {
1899         wxSizerItem * const item = *i;
1900
1901         if ( !item->IsShown() )
1902             continue;
1903
1904         wxSize szMinPrev = item->GetMinSizeWithBorder();
1905         item->InformFirstDirection(m_orient^wxBOTH,totalMinorSize,delta);
1906         wxSize szMin = item->GetMinSizeWithBorder();
1907         int deltaChange = GetSizeInMajorDir(szMin-szMinPrev);
1908         if( deltaChange )
1909         {
1910             // Since we passed available space along to the item, it should not
1911             // take too much, so delta should not become negative.
1912             delta -= deltaChange;
1913         }
1914         majorMinSum += GetSizeInMajorDir(item->GetMinSizeWithBorder());
1915     }
1916     // And update our min size
1917     SizeInMajorDir(m_minSize) = majorMinSum;
1918
1919
1920     // might have a new delta now
1921     delta = GetSizeInMajorDir(m_size) - GetSizeInMajorDir(m_minSize);
1922
1923     // the position at which we put the next child
1924     wxPoint pt(m_position);
1925
1926     int totalProportion = m_totalProportion;
1927     for ( i = m_children.begin();
1928           i != m_children.end();
1929           ++i )
1930     {
1931         wxSizerItem * const item = *i;
1932
1933         if ( !item->IsShown() )
1934             continue;
1935
1936         const wxSize sizeThis(item->GetMinSizeWithBorder());
1937
1938         // adjust the size in the major direction using the proportion
1939         wxCoord majorSize = GetSizeInMajorDir(sizeThis);
1940
1941         // if there is not enough space, don't try to distribute negative space
1942         // among the children, this would result in overlapping windows which
1943         // we don't want
1944         if ( delta > 0 )
1945         {
1946             const int propItem = item->GetProportion();
1947             if ( propItem )
1948             {
1949                 const int deltaItem = (delta * propItem) / totalProportion;
1950
1951                 majorSize += deltaItem;
1952
1953                 delta -= deltaItem;
1954                 totalProportion -= propItem;
1955             }
1956         }
1957
1958
1959         // apply the alignment in the minor direction
1960         wxPoint posChild(pt);
1961
1962         wxCoord minorSize = GetSizeInMinorDir(sizeThis);
1963         const int flag = item->GetFlag();
1964         if ( flag & (wxEXPAND | wxSHAPED) )
1965         {
1966             minorSize = totalMinorSize;
1967         }
1968         else if ( flag & (IsVertical() ? wxALIGN_RIGHT : wxALIGN_BOTTOM) )
1969         {
1970             PosInMinorDir(posChild) += totalMinorSize - minorSize;
1971         }
1972         // NB: wxCENTRE is used here only for backwards compatibility,
1973         //     wxALIGN_CENTRE should be used in new code
1974         else if ( flag & (wxCENTER | wxALIGN_CENTRE) )
1975         {
1976             PosInMinorDir(posChild) += (totalMinorSize - minorSize) / 2;
1977         }
1978
1979
1980         // apply RTL adjustment for horizontal sizers:
1981         if ( !IsVertical() && m_containingWindow )
1982         {
1983             posChild.x = m_containingWindow->AdjustForLayoutDirection
1984                                              (
1985                                                 posChild.x,
1986                                                 majorSize,
1987                                                 m_size.x
1988                                              );
1989         }
1990
1991         // finally set size of this child and advance to the next one
1992         item->SetDimension(posChild, SizeFromMajorMinor(majorSize, minorSize));
1993
1994         PosInMajorDir(pt) += majorSize;
1995     }
1996 }
1997
1998 wxSize wxBoxSizer::CalcMin()
1999 {
2000     m_totalProportion = 0;
2001     m_minSize = wxSize(0, 0);
2002
2003     // calculate the minimal sizes for all items and count sum of proportions
2004     for ( wxSizerItemList::const_iterator i = m_children.begin();
2005           i != m_children.end();
2006           ++i )
2007     {
2008         wxSizerItem * const item = *i;
2009
2010         if ( !item->IsShown() )
2011             continue;
2012
2013         const wxSize sizeMinThis = item->CalcMin();
2014         SizeInMajorDir(m_minSize) += GetSizeInMajorDir(sizeMinThis);
2015         if ( GetSizeInMinorDir(sizeMinThis) > GetSizeInMinorDir(m_minSize) )
2016             SizeInMinorDir(m_minSize) = GetSizeInMinorDir(sizeMinThis);
2017
2018         m_totalProportion += item->GetProportion();
2019     }
2020
2021     return m_minSize;
2022 }
2023
2024 //---------------------------------------------------------------------------
2025 // wxStaticBoxSizer
2026 //---------------------------------------------------------------------------
2027
2028 #if wxUSE_STATBOX
2029
2030 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
2031     : wxBoxSizer( orient ),
2032       m_staticBox( box )
2033 {
2034     wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
2035
2036     // do this so that our Detach() is called if the static box is destroyed
2037     // before we are
2038     m_staticBox->SetContainingSizer(this);
2039 }
2040
2041 wxStaticBoxSizer::wxStaticBoxSizer(int orient, wxWindow *win, const wxString& s)
2042                 : wxBoxSizer(orient),
2043                   m_staticBox(new wxStaticBox(win, wxID_ANY, s))
2044 {
2045     // same as above
2046     m_staticBox->SetContainingSizer(this);
2047 }
2048
2049 wxStaticBoxSizer::~wxStaticBoxSizer()
2050 {
2051     delete m_staticBox;
2052 }
2053
2054 static void GetStaticBoxBorders( wxStaticBox *box,
2055                                  int *borderTop,
2056                                  int *borderOther)
2057 {
2058     // this has to be done platform by platform as there is no way to
2059     // guess the thickness of a wxStaticBox border
2060     box->GetBordersForSizer(borderTop, borderOther);
2061 }
2062
2063 void wxStaticBoxSizer::RecalcSizes()
2064 {
2065     int top_border, other_border;
2066     GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
2067
2068     m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
2069
2070     wxPoint old_pos( m_position );
2071     m_position.x += other_border;
2072     m_position.y += top_border;
2073     wxSize old_size( m_size );
2074     m_size.x -= 2*other_border;
2075     m_size.y -= top_border + other_border;
2076
2077     wxBoxSizer::RecalcSizes();
2078
2079     m_position = old_pos;
2080     m_size = old_size;
2081 }
2082
2083 wxSize wxStaticBoxSizer::CalcMin()
2084 {
2085     int top_border, other_border;
2086     GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
2087
2088     wxSize ret( wxBoxSizer::CalcMin() );
2089     ret.x += 2*other_border;
2090     ret.y += other_border + top_border;
2091
2092     return ret;
2093 }
2094
2095 void wxStaticBoxSizer::ShowItems( bool show )
2096 {
2097     m_staticBox->Show( show );
2098     wxBoxSizer::ShowItems( show );
2099 }
2100
2101 bool wxStaticBoxSizer::Detach( wxWindow *window )
2102 {
2103     // avoid deleting m_staticBox in our dtor if it's being detached from the
2104     // sizer (which can happen because it's being already destroyed for
2105     // example)
2106     if ( window == m_staticBox )
2107     {
2108         m_staticBox = NULL;
2109         return true;
2110     }
2111
2112     return wxSizer::Detach( window );
2113 }
2114
2115 #endif // wxUSE_STATBOX
2116
2117 #if wxUSE_BUTTON
2118
2119 wxStdDialogButtonSizer::wxStdDialogButtonSizer()
2120     : wxBoxSizer(wxHORIZONTAL)
2121 {
2122     // Vertical buttons with lots of space on either side
2123     // looks rubbish on WinCE, so let's not do this for now.
2124     // If we are going to use vertical buttons, we should
2125     // put the sizer to the right of other controls in the dialog,
2126     // and that's beyond the scope of this sizer.
2127 #ifndef __WXWINCE__
2128     bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
2129     // If we have a PDA screen, put yes/no button over
2130     // all other buttons, otherwise on the left side.
2131     if (is_pda)
2132         m_orient = wxVERTICAL;
2133 #endif
2134
2135     m_buttonAffirmative = NULL;
2136     m_buttonApply = NULL;
2137     m_buttonNegative = NULL;
2138     m_buttonCancel = NULL;
2139     m_buttonHelp = NULL;
2140 }
2141
2142 void wxStdDialogButtonSizer::AddButton(wxButton *mybutton)
2143 {
2144     switch (mybutton->GetId())
2145     {
2146         case wxID_OK:
2147         case wxID_YES:
2148         case wxID_SAVE:
2149             m_buttonAffirmative = mybutton;
2150             break;
2151         case wxID_APPLY:
2152             m_buttonApply = mybutton;
2153             break;
2154         case wxID_NO:
2155             m_buttonNegative = mybutton;
2156             break;
2157         case wxID_CANCEL:
2158         case wxID_CLOSE:
2159             m_buttonCancel = mybutton;
2160             break;
2161         case wxID_HELP:
2162         case wxID_CONTEXT_HELP:
2163             m_buttonHelp = mybutton;
2164             break;
2165         default:
2166             break;
2167     }
2168 }
2169
2170 void wxStdDialogButtonSizer::SetAffirmativeButton( wxButton *button )
2171 {
2172     m_buttonAffirmative = button;
2173 }
2174
2175 void wxStdDialogButtonSizer::SetNegativeButton( wxButton *button )
2176 {
2177     m_buttonNegative = button;
2178 }
2179
2180 void wxStdDialogButtonSizer::SetCancelButton( wxButton *button )
2181 {
2182     m_buttonCancel = button;
2183 }
2184
2185 void wxStdDialogButtonSizer::Realize()
2186 {
2187 #ifdef __WXMAC__
2188         Add(0, 0, 0, wxLEFT, 6);
2189         if (m_buttonHelp)
2190             Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2191
2192         if (m_buttonNegative){
2193             // HIG POLICE BULLETIN - destructive buttons need extra padding
2194             // 24 pixels on either side
2195             Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 12);
2196         }
2197
2198         // extra whitespace between help/negative and cancel/ok buttons
2199         Add(0, 0, 1, wxEXPAND, 0);
2200
2201         if (m_buttonCancel){
2202             Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2203             // Cancel or help should be default
2204             // m_buttonCancel->SetDefaultButton();
2205         }
2206
2207         // Ugh, Mac doesn't really have apply dialogs, so I'll just
2208         // figure the best place is between Cancel and OK
2209         if (m_buttonApply)
2210             Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 6);
2211
2212         if (m_buttonAffirmative){
2213             Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
2214
2215             if (m_buttonAffirmative->GetId() == wxID_SAVE){
2216                 // these buttons have set labels under Mac so we should use them
2217                 m_buttonAffirmative->SetLabel(_("Save"));
2218                 if (m_buttonNegative)
2219                     m_buttonNegative->SetLabel(_("Don't Save"));
2220             }
2221         }
2222
2223         // Extra space around and at the right
2224         Add(12, 24);
2225 #elif defined(__WXGTK20__)
2226         Add(0, 0, 0, wxLEFT, 9);
2227         if (m_buttonHelp)
2228             Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2229
2230         // extra whitespace between help and cancel/ok buttons
2231         Add(0, 0, 1, wxEXPAND, 0);
2232
2233         if (m_buttonNegative){
2234             Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2235         }
2236
2237         // according to HIG, in explicit apply windows the order is:
2238         // [ Help                     Apply   Cancel   OK ]
2239         if (m_buttonApply)
2240             Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2241
2242         if (m_buttonCancel){
2243             Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, 3);
2244             // Cancel or help should be default
2245             // m_buttonCancel->SetDefaultButton();
2246         }
2247
2248         if (m_buttonAffirmative)
2249             Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT, 6);
2250 #elif defined(__WXMSW__)
2251         // Windows
2252
2253         // right-justify buttons
2254         Add(0, 0, 1, wxEXPAND, 0);
2255
2256         if (m_buttonAffirmative){
2257             Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(2, 0)).x);
2258         }
2259
2260         if (m_buttonNegative){
2261             Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(2, 0)).x);
2262         }
2263
2264         if (m_buttonCancel){
2265             Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(2, 0)).x);
2266         }
2267         if (m_buttonApply)
2268             Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(2, 0)).x);
2269
2270         if (m_buttonHelp)
2271             Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(2, 0)).x);
2272 #else
2273         // GTK+1 and any other platform
2274
2275         // Add(0, 0, 0, wxLEFT, 5); // Not sure what this was for but it unbalances the dialog
2276         if (m_buttonHelp)
2277             Add((wxWindow*)m_buttonHelp, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonHelp->ConvertDialogToPixels(wxSize(4, 0)).x);
2278
2279         // extra whitespace between help and cancel/ok buttons
2280         Add(0, 0, 1, wxEXPAND, 0);
2281
2282         if (m_buttonApply)
2283             Add((wxWindow*)m_buttonApply, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonApply->ConvertDialogToPixels(wxSize(4, 0)).x);
2284
2285         if (m_buttonAffirmative){
2286             Add((wxWindow*)m_buttonAffirmative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonAffirmative->ConvertDialogToPixels(wxSize(4, 0)).x);
2287         }
2288
2289         if (m_buttonNegative){
2290             Add((wxWindow*)m_buttonNegative, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonNegative->ConvertDialogToPixels(wxSize(4, 0)).x);
2291         }
2292
2293         if (m_buttonCancel){
2294             Add((wxWindow*)m_buttonCancel, 0, wxALIGN_CENTRE | wxLEFT | wxRIGHT, m_buttonCancel->ConvertDialogToPixels(wxSize(4, 0)).x);
2295             // Cancel or help should be default
2296             // m_buttonCancel->SetDefaultButton();
2297         }
2298
2299 #endif
2300 }
2301
2302 #endif // wxUSE_BUTTON