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