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