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