src/common/sizer.cpp

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