src/common/gbsizer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gbsizer.cpp
   3 // Purpose:     wxGridBagSizer:  A sizer that can lay out items in a grid,
   4 //              with items at specified cells, and with the option of row
   5 //              and/or column spanning
   6 //
   7 // Author:      Robin Dunn
   8 // Created:     03-Nov-2003
   9 // RCS-ID:      $Id$
  10 // Copyright:   (c) Robin Dunn
  11 // Licence:     wxWindows licence
  12 /////////////////////////////////////////////////////////////////////////////
  13
  14
  15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  16 #pragma implementation "gbsizer.h"
  17 #endif
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #include "wx/gbsizer.h"
  27
  28 //---------------------------------------------------------------------------
  29
  30 IMPLEMENT_DYNAMIC_CLASS(wxGBSizerItem, wxSizerItem)
  31 IMPLEMENT_CLASS(wxGridBagSizer, wxFlexGridSizer)
  32
  33 const wxGBSpan wxDefaultSpan;
  34
  35 //---------------------------------------------------------------------------
  36 // wxGBSizerItem
  37 //---------------------------------------------------------------------------
  38
  39 wxGBSizerItem::wxGBSizerItem( int width,
  40                               int height,
  41                               const wxGBPosition& pos,
  42                               const wxGBSpan& span,
  43                               int flag,
  44                               int border,
  45                               wxObject* userData)
  46     : wxSizerItem(width, height, 0, flag, border, userData),
  47       m_pos(pos),
  48       m_span(span),
  49       m_gbsizer(NULL)
  50 {
  51 }
  52
  53
  54 wxGBSizerItem::wxGBSizerItem( wxWindow *window,
  55                               const wxGBPosition& pos,
  56                               const wxGBSpan& span,
  57                               int flag,
  58                               int border,
  59                               wxObject* userData )
  60     : wxSizerItem(window, 0, flag, border, userData),
  61       m_pos(pos),
  62       m_span(span),
  63       m_gbsizer(NULL)
  64 {
  65 }
  66
  67
  68 wxGBSizerItem::wxGBSizerItem( wxSizer *sizer,
  69                               const wxGBPosition& pos,
  70                               const wxGBSpan& span,
  71                               int flag,
  72                               int border,
  73                               wxObject* userData )
  74     : wxSizerItem(sizer, 0, flag, border, userData),
  75       m_pos(pos),
  76       m_span(span),
  77       m_gbsizer(NULL)
  78 {
  79 }
  80
  81 wxGBSizerItem::wxGBSizerItem()
  82     : wxSizerItem(),
  83       m_pos(-1,-1),
  84       m_span(-1,-1),
  85       m_gbsizer(NULL)
  86 {
  87 }
  88
  89 //---------------------------------------------------------------------------
  90
  91
  92 void wxGBSizerItem::GetPos(int& row, int& col) const
  93 {
  94     row = m_pos.GetRow();
  95     col = m_pos.GetCol();
  96 }
  97
  98 void wxGBSizerItem::GetSpan(int& rowspan, int& colspan) const
  99 {
 100     rowspan = m_span.GetRowspan();
 101     colspan = m_span.GetColspan();
 102 }
 103
 104
 105 bool wxGBSizerItem::SetPos( const wxGBPosition& pos )
 106 {
 107     if (m_gbsizer)
 108     {
 109         wxCHECK_MSG( !m_gbsizer->CheckForIntersection(pos, m_span, this), false,
 110                  wxT("An item is already at that position") );
 111     }
 112     m_pos = pos;
 113     return true;
 114 }
 115
 116 bool wxGBSizerItem::SetSpan( const wxGBSpan& span )
 117 {
 118     if (m_gbsizer)
 119     {
 120         wxCHECK_MSG( !m_gbsizer->CheckForIntersection(m_pos, span, this), false,
 121                  wxT("An item is already at that position") );
 122     }
 123     m_span = span;
 124     return true;
 125 }
 126
 127
 128 inline bool InRange(int val, int min, int max)
 129 {
 130     return (val >= min && val <= max);
 131 }
 132
 133 bool wxGBSizerItem::Intersects(const wxGBSizerItem& other)
 134 {
 135     return Intersects(other.GetPos(), other.GetSpan());
 136 }
 137
 138 bool wxGBSizerItem::Intersects(const wxGBPosition& pos, const wxGBSpan& span)
 139 {
 140
 141     int row, col, endrow, endcol;
 142     int otherrow, othercol, otherendrow, otherendcol;
 143
 144     GetPos(row, col);
 145     GetEndPos(endrow, endcol);
 146
 147     otherrow = pos.GetRow();
 148     othercol = pos.GetCol();
 149     otherendrow = otherrow + span.GetRowspan() - 1;
 150     otherendcol = othercol + span.GetColspan() - 1;
 151
 152     // is the other item's start or end in the range of this one?
 153     if (( InRange(otherrow, row, endrow) && InRange(othercol, col, endcol) ) ||
 154         ( InRange(otherendrow, row, endrow) && InRange(otherendcol, col, endcol) ))
 155         return true;
 156
 157     // is this item's start or end in the range of the other one?
 158     if (( InRange(row, otherrow, otherendrow) && InRange(col, othercol, otherendcol) ) ||
 159         ( InRange(endrow, otherrow, otherendrow) && InRange(endcol, othercol, otherendcol) ))
 160         return true;
 161
 162     return false;
 163 }
 164
 165
 166 void wxGBSizerItem::GetEndPos(int& row, int& col)
 167 {
 168     row = m_pos.GetRow() + m_span.GetRowspan() - 1;
 169     col = m_pos.GetCol() + m_span.GetColspan() - 1;
 170 }
 171
 172
 173 //---------------------------------------------------------------------------
 174 // wxGridBagSizer
 175 //---------------------------------------------------------------------------
 176
 177 wxGridBagSizer::wxGridBagSizer(int vgap, int hgap )
 178     : wxFlexGridSizer(1, vgap, hgap),
 179       m_emptyCellSize(10,20)
 180
 181 {
 182 }
 183
 184
 185 bool wxGridBagSizer::Add( wxWindow *window,
 186                           const wxGBPosition& pos, const wxGBSpan& span,
 187                           int flag, int border,  wxObject* userData )
 188 {
 189     wxGBSizerItem* item = new wxGBSizerItem(window, pos, span, flag, border, userData);
 190     if ( Add(item) )
 191         return true;
 192     else
 193     {
 194         delete item;
 195         return false;
 196     }
 197 }
 198
 199 bool wxGridBagSizer::Add( wxSizer *sizer,
 200                           const wxGBPosition& pos, const wxGBSpan& span,
 201                           int flag, int border,  wxObject* userData )
 202 {
 203     wxGBSizerItem* item = new wxGBSizerItem(sizer, pos, span, flag, border, userData);
 204     if ( Add(item) )
 205         return true;
 206     else
 207     {
 208         delete item;
 209         return false;
 210     }
 211 }
 212
 213 bool wxGridBagSizer::Add( int width, int height,
 214                           const wxGBPosition& pos, const wxGBSpan& span,
 215                           int flag, int border,  wxObject* userData )
 216 {
 217     wxGBSizerItem* item = new wxGBSizerItem(width, height, pos, span, flag, border, userData);
 218     if ( Add(item) )
 219         return true;
 220     else
 221     {
 222         delete item;
 223         return false;
 224     }
 225 }
 226
 227 bool wxGridBagSizer::Add( wxGBSizerItem *item )
 228 {
 229     wxCHECK_MSG( !CheckForIntersection(item), false,
 230                  wxT("An item is already at that position") );
 231     m_children.Append(item);
 232     item->SetGBSizer(this);
 233     if ( item->GetWindow() )
 234         item->GetWindow()->SetContainingSizer( this );
 235
 236     return true;
 237 }
 238
 239
 240
 241 //---------------------------------------------------------------------------
 242
 243 wxSize wxGridBagSizer::GetCellSize(int row, int col) const
 244 {
 245     wxCHECK_MSG( (row < m_rows) && (col < m_cols),
 246                  wxDefaultSize,
 247                  wxT("Invalid cell."));
 248     return wxSize( m_colWidths[col], m_rowHeights[row] );
 249 }
 250
 251
 252 wxGBPosition wxGridBagSizer::GetItemPosition(wxWindow *window)
 253 {
 254     wxGBPosition badpos(-1,-1);
 255     wxGBSizerItem* item = FindItem(window);
 256     wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
 257     return item->GetPos();
 258 }
 259
 260
 261 wxGBPosition wxGridBagSizer::GetItemPosition(wxSizer *sizer)
 262 {
 263     wxGBPosition badpos(-1,-1);
 264     wxGBSizerItem* item = FindItem(sizer);
 265     wxCHECK_MSG(item, badpos, wxT("Failed to find item."));
 266     return item->GetPos();
 267 }
 268
 269
 270 wxGBPosition wxGridBagSizer::GetItemPosition(size_t index)
 271 {
 272     wxGBPosition badpos(-1,-1);
 273     wxSizerItemList::compatibility_iterator node = m_children.Item( index );
 274     wxCHECK_MSG( node, badpos, _T("Failed to find item.") );
 275     wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 276     return item->GetPos();
 277 }
 278
 279
 280
 281 bool wxGridBagSizer::SetItemPosition(wxWindow *window, const wxGBPosition& pos)
 282 {
 283     wxGBSizerItem* item = FindItem(window);
 284     wxCHECK_MSG(item, false, wxT("Failed to find item."));
 285     return item->SetPos(pos);
 286 }
 287
 288
 289 bool wxGridBagSizer::SetItemPosition(wxSizer *sizer, const wxGBPosition& pos)
 290 {
 291     wxGBSizerItem* item = FindItem(sizer);
 292     wxCHECK_MSG(item, false, wxT("Failed to find item."));
 293     return item->SetPos(pos);
 294 }
 295
 296
 297 bool wxGridBagSizer::SetItemPosition(size_t index, const wxGBPosition& pos)
 298 {
 299     wxSizerItemList::compatibility_iterator node = m_children.Item( index );
 300     wxCHECK_MSG( node, false, _T("Failed to find item.") );
 301     wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 302     return item->SetPos(pos);
 303 }
 304
 305
 306
 307 wxGBSpan wxGridBagSizer::GetItemSpan(wxWindow *window)
 308 {
 309     wxGBSpan badspan(-1,-1);
 310     wxGBSizerItem* item = FindItem(window);
 311     wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
 312     return item->GetSpan();
 313 }
 314
 315
 316 wxGBSpan wxGridBagSizer::GetItemSpan(wxSizer *sizer)
 317 {
 318     wxGBSpan badspan(-1,-1);
 319     wxGBSizerItem* item = FindItem(sizer);
 320     wxCHECK_MSG( item, badspan, _T("Failed to find item.") );
 321     return item->GetSpan();
 322 }
 323
 324
 325 wxGBSpan wxGridBagSizer::GetItemSpan(size_t index)
 326 {
 327     wxGBSpan badspan(-1,-1);
 328     wxSizerItemList::compatibility_iterator node = m_children.Item( index );
 329     wxCHECK_MSG( node, badspan, _T("Failed to find item.") );
 330     wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 331     return item->GetSpan();
 332 }
 333
 334
 335
 336 bool wxGridBagSizer::SetItemSpan(wxWindow *window, const wxGBSpan& span)
 337 {
 338     wxGBSizerItem* item = FindItem(window);
 339     wxCHECK_MSG(item, false, wxT("Failed to find item."));
 340     return item->SetSpan(span);
 341 }
 342
 343
 344 bool wxGridBagSizer::SetItemSpan(wxSizer *sizer, const wxGBSpan& span)
 345 {
 346     wxGBSizerItem* item = FindItem(sizer);
 347     wxCHECK_MSG(item, false, wxT("Failed to find item."));
 348     return item->SetSpan(span);
 349 }
 350
 351
 352 bool wxGridBagSizer::SetItemSpan(size_t index, const wxGBSpan& span)
 353 {
 354     wxSizerItemList::compatibility_iterator node = m_children.Item( index );
 355     wxCHECK_MSG( node, false, _T("Failed to find item.") );
 356     wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 357     return item->SetSpan(span);
 358 }
 359
 360
 361
 362
 363 wxGBSizerItem* wxGridBagSizer::FindItem(wxWindow* window)
 364 {
 365     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 366     while (node)
 367     {
 368         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 369         if ( item->GetWindow() == window )
 370             return item;
 371         node = node->GetNext();
 372     }
 373     return NULL;
 374 }
 375
 376
 377 wxGBSizerItem* wxGridBagSizer::FindItem(wxSizer* sizer)
 378 {
 379     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 380     while (node)
 381     {
 382         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 383         if ( item->GetSizer() == sizer )
 384             return item;
 385         node = node->GetNext();
 386     }
 387     return NULL;
 388 }
 389
 390
 391
 392
 393 wxGBSizerItem* wxGridBagSizer::FindItemAtPosition(const wxGBPosition& pos)
 394 {
 395     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 396     while (node)
 397     {
 398         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 399         if ( item->Intersects(pos, wxDefaultSpan) )
 400             return item;
 401         node = node->GetNext();
 402     }
 403     return NULL;
 404 }
 405
 406
 407
 408
 409 wxGBSizerItem* wxGridBagSizer::FindItemAtPoint(const wxPoint& pt)
 410 {
 411     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 412     while (node)
 413     {
 414         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 415         wxRect rect(item->GetPosition(), item->GetSize());
 416         rect.Inflate(m_hgap, m_vgap);
 417         if ( rect.Inside(pt) )
 418             return item;
 419         node = node->GetNext();
 420     }
 421     return NULL;
 422 }
 423
 424
 425
 426
 427 wxGBSizerItem* wxGridBagSizer::FindItemWithData(const wxObject* userData)
 428 {
 429     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 430     while (node)
 431     {
 432         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 433         if ( item->GetUserData() == userData )
 434             return item;
 435         node = node->GetNext();
 436     }
 437     return NULL;
 438 }
 439
 440
 441
 442
 443 //---------------------------------------------------------------------------
 444
 445 // Figure out what all the min row heights and col widths are, and calculate
 446 // min size from that.
 447 wxSize wxGridBagSizer::CalcMin()
 448 {
 449     int idx;
 450
 451     if (m_children.GetCount() == 0)
 452         return m_emptyCellSize;
 453
 454     m_rowHeights.Empty();
 455     m_colWidths.Empty();
 456
 457     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 458     while (node)
 459     {
 460         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 461         if ( item->IsShown() )
 462         {
 463             int row, col, endrow, endcol;
 464
 465             item->GetPos(row, col);
 466             item->GetEndPos(endrow, endcol);
 467
 468             // fill heights and widths upto this item if needed
 469             while ( m_rowHeights.GetCount() <= (size_t)endrow )
 470                 m_rowHeights.Add(m_emptyCellSize.GetHeight());
 471             while ( m_colWidths.GetCount() <= (size_t)endcol )
 472                 m_colWidths.Add(m_emptyCellSize.GetWidth());
 473
 474             // See if this item increases the size of its row(s) or col(s)
 475             wxSize size(item->CalcMin());
 476             for (idx=row; idx <= endrow; idx++)
 477                 m_rowHeights[idx] = wxMax(m_rowHeights[idx], size.GetHeight() / (endrow-row+1));
 478             for (idx=col; idx <= endcol; idx++)
 479                 m_colWidths[idx] = wxMax(m_colWidths[idx], size.GetWidth() / (endcol-col+1));
 480         }
 481         node = node->GetNext();
 482     }
 483
 484     AdjustForFlexDirection();
 485
 486     // Now traverse the heights and widths arrays calcing the totals, including gaps
 487     int width = 0;
 488     m_cols = m_colWidths.GetCount();
 489     for (idx=0; idx < m_cols; idx++)
 490         width += m_colWidths[idx] + ( idx == m_cols-1 ? 0 : m_hgap );
 491
 492     int height = 0;
 493     m_rows = m_rowHeights.GetCount();
 494     for (idx=0; idx < m_rows; idx++)
 495         height += m_rowHeights[idx] + ( idx == m_rows-1 ? 0 : m_vgap );
 496
 497     m_calculatedMinSize = wxSize(width, height);
 498     return m_calculatedMinSize;
 499 }
 500
 501
 502
 503 void wxGridBagSizer::RecalcSizes()
 504 {
 505     if (m_children.GetCount() == 0)
 506         return;
 507
 508     wxPoint pt( GetPosition() );
 509     wxSize  sz( GetSize() );
 510
 511     m_rows = m_rowHeights.GetCount();
 512     m_cols = m_colWidths.GetCount();
 513     int idx, width, height;
 514
 515     AdjustForGrowables(sz, m_calculatedMinSize, m_rows, m_cols);
 516
 517     // Find the start positions on the window of the rows and columns
 518     wxArrayInt rowpos;
 519     rowpos.Add(0, m_rows);
 520     int y = pt.y;
 521     for (idx=0; idx < m_rows; idx++)
 522     {
 523         height = m_rowHeights[idx] + m_vgap;
 524         rowpos[idx] = y;
 525         y += height;
 526     }
 527
 528     wxArrayInt colpos;
 529     colpos.Add(0, m_cols);
 530     int x = pt.x;
 531     for (idx=0; idx < m_cols; idx++)
 532     {
 533         width = m_colWidths[idx] + m_hgap;
 534         colpos[idx] = x;
 535         x += width;
 536     }
 537
 538
 539     // Now iterate the children, setting each child's dimensions
 540     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 541     while (node)
 542     {
 543         int row, col, endrow, endcol;
 544         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 545         item->GetPos(row, col);
 546         item->GetEndPos(endrow, endcol);
 547
 548         height = 0;
 549         for(idx=row; idx <= endrow; idx++)
 550             height += m_rowHeights[idx];
 551         height += (endrow - row) * m_vgap; // add a vgap for every row spanned
 552
 553         width = 0;
 554         for (idx=col; idx <= endcol; idx++)
 555             width += m_colWidths[idx];
 556         width += (endcol - col) * m_hgap; // add a hgap for every col spanned
 557
 558         SetItemBounds(item, colpos[col], rowpos[row], width, height);
 559
 560         node = node->GetNext();
 561     }
 562 }
 563
 564
 565
 566 //---------------------------------------------------------------------------
 567
 568 bool wxGridBagSizer::CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem)
 569 {
 570     return CheckForIntersection(item->GetPos(), item->GetSpan(), excludeItem);
 571 }
 572
 573 bool wxGridBagSizer::CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem)
 574 {
 575     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 576     while (node)
 577     {
 578         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 579         node = node->GetNext();
 580
 581         if ( excludeItem && item == excludeItem )
 582             continue;
 583
 584         if ( item->Intersects(pos, span) )
 585             return true;
 586
 587     }
 588     return false;
 589 }
 590
 591
 592 // Assumes a 10x10 grid, and returns the first empty cell found.  This is
 593 // really stupid but it is only used by the Add methods that match the base
 594 // class virtuals, which should normally not be used anyway...
 595 wxGBPosition wxGridBagSizer::FindEmptyCell()
 596 {
 597     int row, col;
 598
 599     for (row=0; row<10; row++)
 600         for (col=0; col<10; col++)
 601         {
 602             wxGBPosition pos(row, col);
 603             if ( !CheckForIntersection(pos, wxDefaultSpan) )
 604                 return pos;
 605         }
 606     return wxGBPosition(-1, -1);
 607 }
 608
 609
 610 //---------------------------------------------------------------------------
 611
 612 // The Add base class virtuals should not be used with this class, but
 613 // we'll try to make them automatically select a location for the item
 614 // anyway.
 615
 616 void wxGridBagSizer::Add( wxWindow *window, int, int flag, int border, wxObject* userData )
 617 {
 618     Add(window, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 619 }
 620
 621 void wxGridBagSizer::Add( wxSizer *sizer, int, int flag, int border, wxObject* userData )
 622 {
 623     Add(sizer, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 624 }
 625
 626 void wxGridBagSizer::Add( int width, int height, int, int flag, int border, wxObject* userData )
 627 {
 628     Add(width, height, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 629 }
 630
 631
 632
 633 // The Insert nad Prepend base class virtuals that are not appropriate for
 634 // this class and should not be used.  Their implementation in this class
 635 // simply fails.
 636
 637 void wxGridBagSizer::Add( wxSizerItem * )
 638 { wxFAIL_MSG(wxT("Invalid Add form called.")); }
 639
 640 void wxGridBagSizer::Prepend( wxWindow *, int, int, int, wxObject*  )
 641 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 642
 643 void wxGridBagSizer::Prepend( wxSizer *, int, int, int, wxObject*  )
 644 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 645
 646 void wxGridBagSizer::Prepend( int, int, int, int, int, wxObject*  )
 647 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 648
 649 void wxGridBagSizer::Prepend( wxSizerItem * )
 650 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 651
 652
 653 void wxGridBagSizer::Insert( size_t, wxWindow *, int, int, int, wxObject*  )
 654 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 655
 656 void wxGridBagSizer::Insert( size_t, wxSizer *, int, int, int, wxObject*  )
 657 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 658
 659 void wxGridBagSizer::Insert( size_t, int, int, int, int, int, wxObject*  )
 660 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 661
 662 void wxGridBagSizer::Insert( size_t, wxSizerItem * )
 663 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 664
 665
 666 //---------------------------------------------------------------------------
 667 //---------------------------------------------------------------------------