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