src/common/sizer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        sizer.cpp
   3 // Purpose:     provide new wxSizer class for layout
   4 // Author:      Robert Roebling and Robin Dunn
   5 // Modified by:
   6 // Created:
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Robin Dunn, Dirk Holtwick and Robert Roebling
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "sizer.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #include "wx/sizer.h"
  24 #include "wx/utils.h"
  25 #include "wx/statbox.h"
  26 #include "wx/notebook.h"
  27
  28 //---------------------------------------------------------------------------
  29
  30 IMPLEMENT_ABSTRACT_CLASS(wxSizerItem, wxObject);
  31 IMPLEMENT_ABSTRACT_CLASS(wxSizer, wxObject);
  32 IMPLEMENT_ABSTRACT_CLASS(wxGridSizer, wxSizer);
  33 IMPLEMENT_ABSTRACT_CLASS(wxFlexGridSizer, wxGridSizer);
  34 IMPLEMENT_ABSTRACT_CLASS(wxBoxSizer, wxSizer);
  35 IMPLEMENT_ABSTRACT_CLASS(wxStaticBoxSizer, wxBoxSizer);
  36 #if wxUSE_NOTEBOOK
  37 IMPLEMENT_ABSTRACT_CLASS(wxNotebookSizer, wxSizer);
  38 #endif
  39
  40 //---------------------------------------------------------------------------
  41 // wxSizerItem
  42 //---------------------------------------------------------------------------
  43
  44 wxSizerItem::wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData )
  45 {
  46     m_window = (wxWindow *) NULL;
  47     m_sizer = (wxSizer *) NULL;
  48     m_option = option;
  49     m_border = border;
  50     m_flag = flag;
  51     m_userData = userData;
  52
  53     // minimal size is the initial size
  54     m_minSize.x = width;
  55     m_minSize.y = height;
  56
  57     SetRatio(width, height);
  58
  59     // size is set directly
  60     m_size = m_minSize;
  61 }
  62
  63 wxSizerItem::wxSizerItem( wxWindow *window, int option, int flag, int border, wxObject* userData )
  64 {
  65     m_window = window;
  66     m_sizer = (wxSizer *) NULL;
  67     m_option = option;
  68     m_border = border;
  69     m_flag = flag;
  70     m_userData = userData;
  71
  72     // minimal size is the initial size
  73     m_minSize = window->GetSize();
  74
  75     // aspect ratio calculated from initial size
  76     SetRatio(m_minSize);
  77
  78     // size is calculated later
  79     // m_size = ...
  80 }
  81
  82 wxSizerItem::wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
  83 {
  84     m_window = (wxWindow *) NULL;
  85     m_sizer = sizer;
  86     m_option = option;
  87     m_border = border;
  88     m_flag = flag;
  89     m_userData = userData;
  90
  91     // minimal size is calculated later
  92     // m_minSize = ...
  93     m_ratio = 0;
  94
  95     // size is calculated later
  96     // m_size = ...
  97 }
  98
  99 wxSizerItem::~wxSizerItem()
 100 {
 101     if (m_userData)
 102         delete m_userData;
 103     if (m_sizer)
 104         delete m_sizer;
 105 }
 106
 107
 108 wxSize wxSizerItem::GetSize()
 109 {
 110     wxSize ret;
 111     if (IsSizer())
 112         ret = m_sizer->GetSize();
 113     else
 114     if (IsWindow())
 115         ret = m_window->GetSize();
 116     else ret = m_size;
 117
 118     if (m_flag & wxWEST)
 119         ret.x += m_border;
 120     if (m_flag & wxEAST)
 121         ret.x += m_border;
 122     if (m_flag & wxNORTH)
 123         ret.y += m_border;
 124     if (m_flag & wxSOUTH)
 125         ret.y += m_border;
 126
 127     return ret;
 128 }
 129
 130 wxSize wxSizerItem::CalcMin()
 131 {
 132     wxSize ret;
 133     if (IsSizer())
 134     {
 135         ret = m_sizer->GetMinSize();
 136
 137         // if we have to preserve aspect ratio _AND_ this is
 138         // the first-time calculation, consider ret to be initial size
 139         if ((m_flag & wxSHAPED) && !m_ratio)
 140             SetRatio(ret);
 141     }
 142     else
 143     {
 144         if ( IsWindow() && (m_flag & wxADJUST_MINSIZE) )
 145         {
 146             // check if the best (minimal, in fact) window size hadn't changed
 147             // by chance: this may happen for, e.g. static text if its label
 148             // changed
 149             wxSize size = m_window->GetBestSize();
 150             if ( size.x > m_minSize.x )
 151                 m_minSize.x = size.x;
 152             if ( size.y > m_minSize.y )
 153                 m_minSize.y = size.y;
 154         }
 155
 156         ret = m_minSize;
 157     }
 158
 159     if (m_flag & wxWEST)
 160         ret.x += m_border;
 161     if (m_flag & wxEAST)
 162         ret.x += m_border;
 163     if (m_flag & wxNORTH)
 164         ret.y += m_border;
 165     if (m_flag & wxSOUTH)
 166         ret.y += m_border;
 167
 168     return ret;
 169 }
 170
 171 void wxSizerItem::SetDimension( wxPoint pos, wxSize size )
 172 {
 173     if (m_flag & wxSHAPED)
 174     {
 175         // adjust aspect ratio
 176         int rwidth = (int) (size.y * m_ratio);
 177         if (rwidth > size.x)
 178         {
 179             // fit horizontally
 180             int rheight = (int) (size.x / m_ratio);
 181             // add vertical space
 182             if (m_flag & wxALIGN_CENTER_VERTICAL)
 183                 pos.y += (size.y - rheight) / 2;
 184             else if (m_flag & wxALIGN_BOTTOM)
 185                 pos.y += (size.y - rheight);
 186             // use reduced dimensions
 187             size.y =rheight;
 188         }
 189         else if (rwidth < size.x)
 190         {
 191             // add horizontal space
 192             if (m_flag & wxALIGN_CENTER_HORIZONTAL)
 193                 pos.x += (size.x - rwidth) / 2;
 194             else if (m_flag & wxALIGN_RIGHT)
 195                 pos.x += (size.x - rwidth);
 196             size.x = rwidth;
 197         }
 198     }
 199
 200     // This is what GetPosition() returns. Since we calculate
 201     // borders afterwards, GetPosition() will be the left/top
 202     // corner of the surrounding border.
 203     m_pos = pos;
 204
 205     if (m_flag & wxWEST)
 206     {
 207         pos.x += m_border;
 208         size.x -= m_border;
 209     }
 210     if (m_flag & wxEAST)
 211     {
 212         size.x -= m_border;
 213     }
 214     if (m_flag & wxNORTH)
 215     {
 216         pos.y += m_border;
 217         size.y -= m_border;
 218     }
 219     if (m_flag & wxSOUTH)
 220     {
 221         size.y -= m_border;
 222     }
 223
 224     if (IsSizer())
 225         m_sizer->SetDimension( pos.x, pos.y, size.x, size.y );
 226
 227     if (IsWindow())
 228         m_window->SetSize( pos.x, pos.y, size.x, size.y, wxSIZE_ALLOW_MINUS_ONE );
 229
 230     m_size = size;
 231 }
 232
 233 bool wxSizerItem::IsWindow()
 234 {
 235     return (m_window != NULL);
 236 }
 237
 238 bool wxSizerItem::IsSizer()
 239 {
 240     return (m_sizer != NULL);
 241 }
 242
 243 bool wxSizerItem::IsSpacer()
 244 {
 245     return (m_window == NULL) && (m_sizer == NULL);
 246 }
 247
 248 //---------------------------------------------------------------------------
 249 // wxSizer
 250 //---------------------------------------------------------------------------
 251
 252 wxSizer::wxSizer()
 253 {
 254     m_children.DeleteContents( TRUE );
 255     m_minSize.x = 0;
 256     m_minSize.y = 0;
 257 }
 258
 259 wxSizer::~wxSizer()
 260 {
 261 }
 262
 263 void wxSizer::Add( wxWindow *window, int option, int flag, int border, wxObject* userData )
 264 {
 265     m_children.Append( new wxSizerItem( window, option, flag, border, userData ) );
 266 }
 267
 268 void wxSizer::Add( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
 269 {
 270     m_children.Append( new wxSizerItem( sizer, option, flag, border, userData ) );
 271 }
 272
 273 void wxSizer::Add( int width, int height, int option, int flag, int border, wxObject* userData )
 274 {
 275     m_children.Append( new wxSizerItem( width, height, option, flag, border, userData ) );
 276 }
 277
 278 void wxSizer::Prepend( wxWindow *window, int option, int flag, int border, wxObject* userData )
 279 {
 280     m_children.Insert( new wxSizerItem( window, option, flag, border, userData ) );
 281 }
 282
 283 void wxSizer::Prepend( wxSizer *sizer, int option, int flag, int border, wxObject* userData )
 284 {
 285     m_children.Insert( new wxSizerItem( sizer, option, flag, border, userData ) );
 286 }
 287
 288 void wxSizer::Prepend( int width, int height, int option, int flag, int border, wxObject* userData )
 289 {
 290     m_children.Insert( new wxSizerItem( width, height, option, flag, border, userData ) );
 291 }
 292
 293 void wxSizer::Insert( int before, wxWindow *window, int option, int flag, int border, wxObject* userData )
 294 {
 295     m_children.Insert( before, new wxSizerItem( window, option, flag, border, userData ) );
 296 }
 297
 298 void wxSizer::Insert( int before, wxSizer *sizer, int option, int flag, int border, wxObject* userData )
 299 {
 300     m_children.Insert( before, new wxSizerItem( sizer, option, flag, border, userData ) );
 301 }
 302
 303 void wxSizer::Insert( int before, int width, int height, int option, int flag, int border, wxObject* userData )
 304 {
 305     m_children.Insert( before, new wxSizerItem( width, height, option, flag, border, userData ) );
 306 }
 307
 308 bool wxSizer::Remove( wxWindow *window )
 309 {
 310     wxASSERT( window );
 311
 312     wxNode *node = m_children.First();
 313     while (node)
 314     {
 315         wxSizerItem *item = (wxSizerItem*)node->Data();
 316         if (item->GetWindow() == window)
 317         {
 318             m_children.DeleteNode( node );
 319             return TRUE;
 320         }
 321         node = node->Next();
 322     }
 323
 324     return FALSE;
 325 }
 326
 327 bool wxSizer::Remove( wxSizer *sizer )
 328 {
 329     wxASSERT( sizer );
 330
 331     wxNode *node = m_children.First();
 332     while (node)
 333     {
 334         wxSizerItem *item = (wxSizerItem*)node->Data();
 335         if (item->GetSizer() == sizer)
 336         {
 337             m_children.DeleteNode( node );
 338             return TRUE;
 339         }
 340         node = node->Next();
 341     }
 342
 343     return FALSE;
 344 }
 345
 346 bool wxSizer::Remove( int pos )
 347 {
 348     wxNode *node = m_children.Nth( pos );
 349     if (!node) return FALSE;
 350
 351     m_children.DeleteNode( node );
 352
 353     return TRUE;
 354 }
 355
 356 void wxSizer::Fit( wxWindow *window )
 357 {
 358     wxSize size;
 359     if (window->IsTopLevel())
 360         size = FitSize( window );
 361     else
 362         size = GetMinWindowSize( window );
 363
 364     window->SetSize( size );
 365 }
 366
 367 void wxSizer::Layout()
 368 {
 369     CalcMin();
 370     RecalcSizes();
 371 }
 372
 373 void wxSizer::SetSizeHints( wxWindow *window )
 374 {
 375     wxSize size = FitSize( window );
 376     window->SetSizeHints( size.x, size.y );
 377 }
 378
 379 wxSize wxSizer::GetMaxWindowSize( wxWindow *WXUNUSED(window) )
 380 {
 381     wxSize sizeMax = wxGetDisplaySize();
 382     // make the max size a bit smaller than the screen, a window which takes
 383     // the entire screen doesn't look very nice neither
 384     sizeMax.x *= 9;
 385     sizeMax.x /= 10;
 386
 387     sizeMax.y *= 9;
 388     sizeMax.y /= 10;
 389
 390     return sizeMax;
 391 }
 392
 393 wxSize wxSizer::GetMinWindowSize( wxWindow *window )
 394 {
 395     wxSize minSize( GetMinSize() );
 396     wxSize size( window->GetSize() );
 397     wxSize client_size( window->GetClientSize() );
 398     return wxSize( minSize.x+size.x-client_size.x,
 399                    minSize.y+size.y-client_size.y );
 400 }
 401
 402 // Return a window size that will fit within the screens dimensions
 403 wxSize wxSizer::FitSize( wxWindow *window )
 404 {
 405     wxSize size     = GetMinWindowSize( window );
 406     wxSize sizeMax  = GetMaxWindowSize( window );
 407
 408     if ( size.x > sizeMax.x )
 409         size.x = sizeMax.x;
 410     if ( size.y > sizeMax.y )
 411         size.y = sizeMax.y;
 412
 413     return size;
 414 }
 415
 416 void wxSizer::SetDimension( int x, int y, int width, int height )
 417 {
 418     m_position.x = x;
 419     m_position.y = y;
 420     m_size.x = width;
 421     m_size.y = height;
 422     CalcMin();
 423     RecalcSizes();
 424 }
 425
 426 wxSize wxSizer::GetMinSize()
 427 {
 428     wxSize ret( CalcMin() );
 429     if (ret.x < m_minSize.x) ret.x = m_minSize.x;
 430     if (ret.y < m_minSize.y) ret.y = m_minSize.y;
 431     return ret;
 432 }
 433
 434 void wxSizer::DoSetMinSize( int width, int height )
 435 {
 436     m_minSize.x = width;
 437     m_minSize.y = height;
 438 }
 439
 440 bool wxSizer::DoSetItemMinSize( wxWindow *window, int width, int height )
 441 {
 442     wxASSERT( window );
 443
 444     wxNode *node = m_children.First();
 445     while (node)
 446     {
 447         wxSizerItem *item = (wxSizerItem*)node->Data();
 448         if (item->GetWindow() == window)
 449         {
 450             item->SetInitSize( width, height );
 451             return TRUE;
 452         }
 453         node = node->Next();
 454     }
 455
 456     node = m_children.First();
 457     while (node)
 458     {
 459         wxSizerItem *item = (wxSizerItem*)node->Data();
 460         if (item->GetSizer())
 461         {
 462             /* It's a sizer, so lets search recursively. */
 463             if (item->GetSizer()->DoSetItemMinSize( window, width, height ))
 464             {
 465                 /* A child sizer found the requested windw, exit. */
 466                 return TRUE;
 467             }
 468         }
 469         node = node->Next();
 470     }
 471
 472     return FALSE;
 473 }
 474
 475 bool wxSizer::DoSetItemMinSize( wxSizer *sizer, int width, int height )
 476 {
 477     wxASSERT( sizer );
 478
 479     wxNode *node = m_children.First();
 480     while (node)
 481     {
 482         wxSizerItem *item = (wxSizerItem*)node->Data();
 483         if (item->GetSizer() == sizer)
 484         {
 485             item->GetSizer()->DoSetMinSize( width, height );
 486             return TRUE;
 487         }
 488         node = node->Next();
 489     }
 490
 491     node = m_children.First();
 492     while (node)
 493     {
 494         wxSizerItem *item = (wxSizerItem*)node->Data();
 495         if (item->GetSizer())
 496         {
 497             /* It's a sizer, so lets search recursively. */
 498             if (item->GetSizer()->DoSetItemMinSize( sizer, width, height ))
 499             {
 500                 /* A child sizer found the requested windw, exit. */
 501                 return TRUE;
 502             }
 503         }
 504         node = node->Next();
 505     }
 506
 507     return FALSE;
 508 }
 509
 510 bool wxSizer::DoSetItemMinSize( int pos, int width, int height )
 511 {
 512     wxNode *node = m_children.Nth( pos );
 513     if (!node) return FALSE;
 514
 515     wxSizerItem *item = (wxSizerItem*) node->Data();
 516     if (item->GetSizer())
 517     {
 518         /* Sizers contains the minimal size in them, if not calculated ... */
 519         item->GetSizer()->DoSetMinSize( width, height );
 520     }
 521     else
 522     {
 523         /* ... whereas the minimal size of spacers and windows in stored
 524            in the item */
 525         item->SetInitSize( width, height );
 526     }
 527
 528     return TRUE;
 529 }
 530
 531 //---------------------------------------------------------------------------
 532 // wxGridSizer
 533 //---------------------------------------------------------------------------
 534
 535 wxGridSizer::wxGridSizer( int rows, int cols, int vgap, int hgap )
 536 {
 537     m_rows = rows;
 538     m_cols = cols;
 539     m_vgap = vgap;
 540     m_hgap = hgap;
 541 }
 542
 543 wxGridSizer::wxGridSizer( int cols, int vgap, int hgap )
 544 {
 545     m_rows = 0;
 546     m_cols = cols;
 547     m_vgap = vgap;
 548     m_hgap = hgap;
 549 }
 550
 551 void wxGridSizer::RecalcSizes()
 552 {
 553     if (m_children.GetCount() == 0)
 554         return;
 555
 556     int nitems = m_children.GetCount();
 557     int nrows = m_rows;
 558     int ncols = m_cols;
 559
 560     if (ncols > 0)
 561         nrows = (nitems + ncols-1) / ncols;
 562     else
 563         ncols = (nitems + nrows-1) / nrows;
 564
 565     wxSize sz( GetSize() );
 566     wxPoint pt( GetPosition() );
 567
 568     int w = (sz.x - (ncols - 1) * m_hgap) / ncols;
 569     int h = (sz.y - (nrows - 1) * m_vgap) / nrows;
 570
 571     int x = pt.x;
 572     for (int c = 0; c < ncols; c++)
 573     {
 574         int y = pt.y;
 575         for (int r = 0; r < nrows; r++)
 576         {
 577             int i = r * ncols + c;
 578             if (i < nitems)
 579             {
 580                 wxNode *node = m_children.Nth( i );
 581                 wxASSERT( node );
 582
 583                 SetItemBounds( (wxSizerItem*) node->Data(), x, y, w, h);
 584             }
 585             y = y + h + m_vgap;
 586         }
 587         x = x + w + m_hgap;
 588     }
 589 }
 590
 591 wxSize wxGridSizer::CalcMin()
 592 {
 593     if (m_children.GetCount() == 0)
 594         return wxSize(10,10);
 595
 596     int nitems = m_children.GetCount();
 597     int nrows = m_rows;
 598     int ncols = m_cols;
 599
 600     if (ncols > 0)
 601         nrows = (nitems + ncols-1) / ncols;
 602     else
 603         ncols = (nitems + nrows-1) / nrows;
 604
 605     /* Find the max width and height for any component */
 606     int w = 0;
 607     int h = 0;
 608
 609     wxNode *node = m_children.First();
 610     while (node)
 611     {
 612         wxSizerItem *item = (wxSizerItem*)node->Data();
 613         wxSize sz( item->CalcMin() );
 614         w = wxMax( w, sz.x );
 615         h = wxMax( h, sz.y );
 616
 617         node = node->Next();
 618     }
 619
 620     return wxSize(ncols * w + (ncols-1) * m_hgap,
 621                   nrows * h + (nrows-1) * m_vgap);
 622 }
 623
 624 void wxGridSizer::SetItemBounds( wxSizerItem *item, int x, int y, int w, int h )
 625 {
 626     wxPoint pt( x,y );
 627     wxSize sz( item->CalcMin() );
 628     int flag = item->GetFlag();
 629
 630     if ((flag & wxEXPAND) || (flag & wxSHAPED))
 631     {
 632        sz = wxSize(w, h);
 633     }
 634     else
 635     {
 636         if (flag & wxALIGN_CENTER_HORIZONTAL)
 637         {
 638             pt.x = x + (w - sz.x) / 2;
 639         }
 640         else if (flag & wxALIGN_RIGHT)
 641         {
 642             pt.x = x + (w - sz.x);
 643         }
 644
 645         if (flag & wxALIGN_CENTER_VERTICAL)
 646         {
 647             pt.y = y + (h - sz.y) / 2;
 648         }
 649         else if (flag & wxALIGN_BOTTOM)
 650         {
 651             pt.y = y + (h - sz.y);
 652         }
 653     }
 654
 655     item->SetDimension(pt, sz);
 656 }
 657
 658 //---------------------------------------------------------------------------
 659 // wxFlexGridSizer
 660 //---------------------------------------------------------------------------
 661
 662 wxFlexGridSizer::wxFlexGridSizer( int rows, int cols, int vgap, int hgap )
 663    : wxGridSizer( rows, cols, vgap, hgap )
 664 {
 665     m_rowHeights = (int*) NULL;
 666     m_colWidths = (int*) NULL;
 667 }
 668
 669 wxFlexGridSizer::wxFlexGridSizer( int cols, int vgap, int hgap )
 670    : wxGridSizer( cols, vgap, hgap )
 671 {
 672     m_rowHeights = (int*) NULL;
 673     m_colWidths = (int*) NULL;
 674 }
 675
 676 wxFlexGridSizer::~wxFlexGridSizer()
 677 {
 678     if (m_rowHeights)
 679         delete[] m_rowHeights;
 680     if (m_colWidths)
 681         delete[] m_colWidths;
 682 }
 683
 684 void wxFlexGridSizer::CreateArrays()
 685 {
 686     if (m_rowHeights)
 687         delete[] m_rowHeights;
 688     if (m_colWidths)
 689         delete[] m_colWidths;
 690
 691     if (m_children.GetCount() == 0)
 692         return;
 693
 694     int nitems = m_children.GetCount();
 695     int nrows = m_rows;
 696     int ncols = m_cols;
 697
 698     if (ncols > 0)
 699         nrows = (nitems + ncols-1) / ncols;
 700     else
 701         ncols = (nitems + nrows-1) / nrows;
 702
 703     m_rowHeights = new int[nrows];
 704     m_colWidths = new int[ncols];
 705
 706     for (int col = 0; col < ncols; col++)
 707         m_colWidths[ col ] = 0;
 708     for (int row = 0; row < nrows; row++)
 709         m_rowHeights[ row ] = 0;
 710 }
 711
 712 void wxFlexGridSizer::RecalcSizes()
 713 {
 714     if (m_children.GetCount() == 0)
 715         return;
 716
 717     int nitems = m_children.GetCount();
 718     int nrows = m_rows;
 719     int ncols = m_cols;
 720
 721     if (ncols > 0)
 722         nrows = (nitems + ncols-1) / ncols;
 723     else
 724         ncols = (nitems + nrows-1) / nrows;
 725
 726     wxSize sz( GetSize() );
 727     wxSize minsz( CalcMin() );
 728     wxPoint pt( GetPosition() );
 729     int    delta;
 730     size_t idx;
 731
 732     if ((m_growableRows.GetCount() > 0) && (sz.y > minsz.y))
 733     {
 734         delta = (sz.y - minsz.y) / m_growableRows.GetCount();
 735         for (idx = 0; idx < m_growableRows.GetCount(); idx++)
 736             m_rowHeights[ m_growableRows[idx] ] += delta;
 737     }
 738
 739     if ((m_growableCols.GetCount() > 0) && (sz.x > minsz.x))
 740     {
 741         delta = (sz.x - minsz.x) / m_growableCols.GetCount();
 742         for (idx = 0; idx < m_growableCols.GetCount(); idx++)
 743             m_colWidths[ m_growableCols[idx] ] += delta;
 744     }
 745
 746     sz = wxSize( pt.x + sz.x, pt.y + sz.y );
 747
 748     int x = pt.x;
 749     for (int c = 0; c < ncols; c++)
 750     {
 751         int y = pt.y;
 752         for (int r = 0; r < nrows; r++)
 753         {
 754             int i = r * ncols + c;
 755             if (i < nitems)
 756             {
 757                 wxNode *node = m_children.Nth( i );
 758                 wxASSERT( node );
 759
 760                 int w = wxMax( 0, wxMin( m_colWidths[c], sz.x - x ) );
 761                 int h = wxMax( 0, wxMin( m_rowHeights[r], sz.y - y ) );
 762
 763                 SetItemBounds( (wxSizerItem*) node->Data(), x, y, w, h);
 764             }
 765             y = y + m_rowHeights[r] + m_vgap;
 766         }
 767         x = x + m_colWidths[c] + m_hgap;
 768     }
 769 }
 770
 771 wxSize wxFlexGridSizer::CalcMin()
 772 {
 773     if (m_children.GetCount() == 0)
 774         return wxSize(10,10);
 775
 776     int nitems = m_children.GetCount();
 777     int nrows = m_rows;
 778     int ncols = m_cols;
 779
 780     if (ncols > 0)
 781         nrows = (nitems + ncols-1) / ncols;
 782     else
 783         ncols = (nitems + nrows-1) / nrows;
 784
 785     CreateArrays();
 786
 787     int col;
 788     int row;
 789
 790     int i = 0;
 791     wxNode *node = m_children.First();
 792     while (node)
 793     {
 794         wxSizerItem *item = (wxSizerItem*)node->Data();
 795         wxSize sz( item->CalcMin() );
 796         row = i / ncols;
 797         col = i % ncols;
 798         m_rowHeights[ row ] = wxMax( sz.y, m_rowHeights[ row ] );
 799         m_colWidths[ col ] = wxMax( sz.x, m_colWidths[ col ] );
 800
 801         node = node->Next();
 802         i++;
 803     }
 804
 805     int width = 0;
 806     for (col = 0; col < ncols; col++)
 807         width += m_colWidths[ col ];
 808
 809     int height = 0;
 810     for (row = 0; row < nrows; row++)
 811         height += m_rowHeights[ row ];
 812
 813     return wxSize( width +  (ncols-1) * m_hgap,
 814                    height + (nrows-1) * m_vgap);
 815 }
 816
 817 void wxFlexGridSizer::AddGrowableRow( size_t idx )
 818 {
 819     m_growableRows.Add( idx );
 820 }
 821
 822 void wxFlexGridSizer::RemoveGrowableRow( size_t WXUNUSED(idx) )
 823 {
 824 }
 825
 826 void wxFlexGridSizer::AddGrowableCol( size_t idx )
 827 {
 828     m_growableCols.Add( idx );
 829 }
 830
 831 void wxFlexGridSizer::RemoveGrowableCol( size_t WXUNUSED(idx) )
 832 {
 833 }
 834
 835 //---------------------------------------------------------------------------
 836 // wxBoxSizer
 837 //---------------------------------------------------------------------------
 838
 839 wxBoxSizer::wxBoxSizer( int orient )
 840 {
 841     m_orient = orient;
 842 }
 843
 844 void wxBoxSizer::RecalcSizes()
 845 {
 846     if (m_children.GetCount() == 0)
 847         return;
 848
 849     int delta = 0;
 850     int extra = 0;
 851     if (m_stretchable)
 852     {
 853         if (m_orient == wxHORIZONTAL)
 854         {
 855             delta = (m_size.x - m_fixedWidth) / m_stretchable;
 856             extra = (m_size.x - m_fixedWidth) % m_stretchable;
 857         }
 858         else
 859         {
 860             delta = (m_size.y - m_fixedHeight) / m_stretchable;
 861             extra = (m_size.y - m_fixedHeight) % m_stretchable;
 862         }
 863     }
 864
 865     wxPoint pt( m_position );
 866
 867     wxNode *node = m_children.GetFirst();
 868     while (node)
 869     {
 870         wxSizerItem *item = (wxSizerItem*) node->Data();
 871
 872         int weight = 1;
 873         if (item->GetOption())
 874             weight = item->GetOption();
 875
 876         wxSize size( item->CalcMin() );
 877
 878         if (m_orient == wxVERTICAL)
 879         {
 880             wxCoord height = size.y;
 881             if (item->GetOption())
 882             {
 883                 height = (delta * weight) + extra;
 884                 extra = 0; // only the first item will get the remainder as extra size
 885             }
 886
 887             wxPoint child_pos( pt );
 888             wxSize  child_size( wxSize( size.x, height) );
 889
 890             if (item->GetFlag() & (wxEXPAND | wxSHAPED))
 891                 child_size.x = m_size.x;
 892             else if (item->GetFlag() & wxALIGN_RIGHT)
 893                 child_pos.x += m_size.x - size.x;
 894             else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
 895             // XXX wxCENTER is added for backward compatibility;
 896             //     wxALIGN_CENTER should be used in new code
 897                 child_pos.x += (m_size.x - size.x) / 2;
 898
 899             item->SetDimension( child_pos, child_size );
 900
 901             pt.y += height;
 902         }
 903         else
 904         {
 905             wxCoord width = size.x;
 906             if (item->GetOption())
 907             {
 908                 width = (delta * weight) + extra;
 909                 extra = 0; // only the first item will get the remainder as extra size
 910             }
 911
 912             wxPoint child_pos( pt );
 913             wxSize  child_size( wxSize(width, size.y) );
 914
 915             if (item->GetFlag() & (wxEXPAND | wxSHAPED))
 916                 child_size.y = m_size.y;
 917             else if (item->GetFlag() & wxALIGN_BOTTOM)
 918                 child_pos.y += m_size.y - size.y;
 919             else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
 920             // XXX wxCENTER is added for backward compatibility;
 921             //     wxALIGN_CENTER should be used in new code
 922                 child_pos.y += (m_size.y - size.y) / 2;
 923
 924             item->SetDimension( child_pos, child_size );
 925
 926             pt.x += width;
 927         }
 928
 929         node = node->Next();
 930     }
 931 }
 932
 933 wxSize wxBoxSizer::CalcMin()
 934 {
 935     if (m_children.GetCount() == 0)
 936         return wxSize(10,10);
 937
 938     m_stretchable = 0;
 939     m_minWidth = 0;
 940     m_minHeight = 0;
 941     m_fixedWidth = 0;
 942     m_fixedHeight = 0;
 943
 944     wxNode *node = m_children.GetFirst();
 945     while (node)
 946     {
 947         wxSizerItem *item = (wxSizerItem*) node->Data();
 948
 949         m_stretchable += item->GetOption();
 950
 951         wxSize size( item->CalcMin() );
 952
 953         if (m_orient == wxHORIZONTAL)
 954         {
 955             m_minWidth += size.x;
 956             m_minHeight = wxMax( m_minHeight, size.y );
 957         }
 958         else
 959         {
 960             m_minHeight += size.y;
 961             m_minWidth = wxMax( m_minWidth, size.x );
 962         }
 963
 964         if (item->GetOption() == 0)
 965         {
 966             if (m_orient == wxVERTICAL)
 967             {
 968                 m_fixedHeight += size.y;
 969                 m_fixedWidth = wxMax( m_fixedWidth, size.x );
 970             }
 971             else
 972             {
 973                 m_fixedWidth += size.x;
 974                 m_fixedHeight = wxMax( m_fixedHeight, size.y );
 975             }
 976         }
 977
 978         node = node->Next();
 979     }
 980
 981     return wxSize( m_minWidth, m_minHeight );
 982 }
 983
 984 //---------------------------------------------------------------------------
 985 // wxStaticBoxSizer
 986 //---------------------------------------------------------------------------
 987
 988 wxStaticBoxSizer::wxStaticBoxSizer( wxStaticBox *box, int orient )
 989                 : wxBoxSizer( orient )
 990 {
 991     wxASSERT_MSG( box, wxT("wxStaticBoxSizer needs a static box") );
 992
 993     m_staticBox = box;
 994 }
 995
 996 static void GetStaticBoxBorders(wxStaticBox *box,
 997                                 int *borderTop, int *borderOther)
 998 {
 999     // this has to be done platform by platform as there is no way to
1000     // guess the thickness of a wxStaticBox border
1001 #ifdef __WXGTK__
1002     if ( box->GetLabel().IsEmpty() )
1003         *borderTop = 5;
1004     else
1005 #endif // __WXGTK__
1006         *borderTop = 15;
1007         (void)box;
1008     *borderOther = 5;
1009 }
1010
1011 void wxStaticBoxSizer::RecalcSizes()
1012 {
1013     int top_border, other_border;
1014     GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1015
1016     m_staticBox->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1017
1018     wxPoint old_pos( m_position );
1019     m_position.x += other_border;
1020     m_position.y += top_border;
1021     wxSize old_size( m_size );
1022     m_size.x -= 2*other_border;
1023     m_size.y -= top_border + other_border;
1024
1025     wxBoxSizer::RecalcSizes();
1026
1027     m_position = old_pos;
1028     m_size = old_size;
1029 }
1030
1031 wxSize wxStaticBoxSizer::CalcMin()
1032 {
1033     int top_border, other_border;
1034     GetStaticBoxBorders(m_staticBox, &top_border, &other_border);
1035
1036     wxSize ret( wxBoxSizer::CalcMin() );
1037     ret.x += 2*other_border;
1038     ret.y += other_border + top_border;
1039
1040     return ret;
1041 }
1042
1043 //---------------------------------------------------------------------------
1044 // wxNotebookSizer
1045 //---------------------------------------------------------------------------
1046
1047 #if wxUSE_NOTEBOOK
1048
1049 wxNotebookSizer::wxNotebookSizer( wxNotebook *nb )
1050 {
1051     wxASSERT_MSG( nb, wxT("wxNotebookSizer needs a notebook") );
1052
1053     m_notebook = nb;
1054 }
1055
1056 void wxNotebookSizer::RecalcSizes()
1057 {
1058     m_notebook->SetSize( m_position.x, m_position.y, m_size.x, m_size.y );
1059 }
1060
1061 wxSize wxNotebookSizer::CalcMin()
1062 {
1063     // This will have to be done platform by platform
1064     // as there is no way to guess the thickness of
1065     // the wxNotebook tabs and border.
1066
1067     int borderX = 5;
1068     int borderY = 5;
1069     if ((m_notebook->HasFlag(wxNB_RIGHT)) ||
1070         (m_notebook->HasFlag(wxNB_LEFT)))
1071     {
1072         borderX += 90; // improvements later..
1073     }
1074     else
1075     {
1076         borderY += 40; // improvements later..
1077     }
1078
1079     if (m_notebook->GetChildren().GetCount() == 0)
1080         return wxSize(borderX + 10, borderY + 10);
1081
1082     int maxX = 0;
1083     int maxY = 0;
1084
1085     wxWindowList::Node *node = m_notebook->GetChildren().GetFirst();
1086     while (node)
1087     {
1088         wxWindow *item = node->GetData();
1089         wxSizer *itemsizer = item->GetSizer();
1090
1091         if (itemsizer)
1092         {
1093             wxSize subsize( itemsizer->CalcMin() );
1094
1095             if (subsize.x > maxX) maxX = subsize.x;
1096             if (subsize.y > maxY) maxY = subsize.y;
1097         }
1098
1099         node = node->GetNext();
1100     }
1101
1102     return wxSize( borderX + maxX, borderY + maxY );
1103 }
1104
1105 #endif // wxUSE_NOTEBOOK