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::FindItemWithData(const wxObject* userData)
 410 {
 411     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 412     while (node)
 413     {
 414         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 415         if ( item->GetUserData() == userData )
 416             return item;
 417         node = node->GetNext();
 418     }
 419     return NULL;
 420 }
 421
 422
 423
 424
 425 //---------------------------------------------------------------------------
 426
 427 // Figure out what all the min row heights and col widths are, and calculate
 428 // min size from that.
 429 wxSize wxGridBagSizer::CalcMin()
 430 {
 431     int idx;
 432
 433     if (m_children.GetCount() == 0)
 434         return m_emptyCellSize;
 435
 436     m_rowHeights.Empty();
 437     m_colWidths.Empty();
 438
 439     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 440     while (node)
 441     {
 442         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 443         if ( item->IsShown() )
 444         {
 445             int row, col, endrow, endcol;
 446
 447             item->GetPos(row, col);
 448             item->GetEndPos(endrow, endcol);
 449
 450             // fill heights and widths upto this item if needed
 451             while ( m_rowHeights.GetCount() <= (size_t)endrow )
 452                 m_rowHeights.Add(m_emptyCellSize.GetHeight());
 453             while ( m_colWidths.GetCount() <= (size_t)endcol )
 454                 m_colWidths.Add(m_emptyCellSize.GetWidth());
 455
 456             // See if this item increases the size of its row(s) or col(s)
 457             wxSize size(item->CalcMin());
 458             for (idx=row; idx <= endrow; idx++)
 459                 m_rowHeights[idx] = wxMax(m_rowHeights[idx], size.GetHeight() / (endrow-row+1));
 460             for (idx=col; idx <= endcol; idx++)
 461                 m_colWidths[idx] = wxMax(m_colWidths[idx], size.GetWidth() / (endcol-col+1));
 462         }
 463         node = node->GetNext();
 464     }
 465
 466     AdjustForFlexDirection();
 467
 468     // Now traverse the heights and widths arrays calcing the totals, including gaps
 469     int width = 0;
 470     m_cols = m_colWidths.GetCount();
 471     for (idx=0; idx < m_cols; idx++)
 472         width += m_colWidths[idx] + ( idx == m_cols-1 ? 0 : m_hgap );
 473
 474     int height = 0;
 475     m_rows = m_rowHeights.GetCount();
 476     for (idx=0; idx < m_rows; idx++)
 477         height += m_rowHeights[idx] + ( idx == m_rows-1 ? 0 : m_vgap );
 478
 479     return wxSize(width, height);
 480 }
 481
 482
 483
 484 void wxGridBagSizer::RecalcSizes()
 485 {
 486     if (m_children.GetCount() == 0)
 487         return;
 488
 489     // Calculates minsize and populates m_rowHeights and m_colWidths
 490     wxSize  minsz( CalcMin() );
 491
 492     wxPoint pt( GetPosition() );
 493     wxSize  sz( GetSize() );
 494
 495     m_rows = m_rowHeights.GetCount();
 496     m_cols = m_colWidths.GetCount();
 497     int idx, width, height;
 498
 499     AdjustForGrowables(sz, minsz, m_rows, m_cols);
 500
 501     // Find the start positions on the window of the rows and columns
 502     wxArrayInt rowpos;
 503     rowpos.Add(0, m_rows);
 504     int y = pt.y;
 505     for (idx=0; idx < m_rows; idx++)
 506     {
 507         height = m_rowHeights[idx] + m_vgap;
 508         rowpos[idx] = y;
 509         y += height;
 510     }
 511
 512     wxArrayInt colpos;
 513     colpos.Add(0, m_cols);
 514     int x = pt.x;
 515     for (idx=0; idx < m_cols; idx++)
 516     {
 517         width = m_colWidths[idx] + m_hgap;
 518         colpos[idx] = x;
 519         x += width;
 520     }
 521
 522
 523     // Now iterate the children, setting each child's dimensions
 524     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 525     while (node)
 526     {
 527         int row, col, endrow, endcol;
 528         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 529         item->GetPos(row, col);
 530         item->GetEndPos(endrow, endcol);
 531
 532         height = 0;
 533         for(idx=row; idx <= endrow; idx++)
 534             height += m_rowHeights[idx] + m_vgap;
 535
 536         width = 0;
 537         for (idx=col; idx <= endcol; idx++)
 538             width += m_colWidths[idx] + m_hgap;
 539
 540         SetItemBounds(item, colpos[col], rowpos[row], width, height);
 541
 542         node = node->GetNext();
 543     }
 544 }
 545
 546
 547
 548 //---------------------------------------------------------------------------
 549
 550 bool wxGridBagSizer::CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem)
 551 {
 552     return CheckForIntersection(item->GetPos(), item->GetSpan(), excludeItem);
 553 }
 554
 555 bool wxGridBagSizer::CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem)
 556 {
 557     wxSizerItemList::compatibility_iterator node = m_children.GetFirst();
 558     while (node)
 559     {
 560         wxGBSizerItem* item = (wxGBSizerItem*)node->GetData();
 561         node = node->GetNext();
 562
 563         if ( excludeItem && item == excludeItem )
 564             continue;
 565
 566         if ( item->Intersects(pos, span) )
 567             return true;
 568
 569     }
 570     return false;
 571 }
 572
 573
 574 // Assumes a 10x10 grid, and returns the first empty cell found.  This is
 575 // really stupid but it is only used by the Add methods that match the base
 576 // class virtuals, which should normally not be used anyway...
 577 wxGBPosition wxGridBagSizer::FindEmptyCell()
 578 {
 579     int row, col;
 580
 581     for (row=0; row<10; row++)
 582         for (col=0; col<10; col++)
 583         {
 584             wxGBPosition pos(row, col);
 585             if ( !CheckForIntersection(pos, wxDefaultSpan) )
 586                 return pos;
 587         }
 588     return wxGBPosition(-1, -1);
 589 }
 590
 591
 592 //---------------------------------------------------------------------------
 593
 594 // The Add base class virtuals should not be used with this class, but
 595 // we'll try to make them automatically select a location for the item
 596 // anyway.
 597
 598 void wxGridBagSizer::Add( wxWindow *window, int, int flag, int border, wxObject* userData )
 599 {
 600     Add(window, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 601 }
 602
 603 void wxGridBagSizer::Add( wxSizer *sizer, int, int flag, int border, wxObject* userData )
 604 {
 605     Add(sizer, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 606 }
 607
 608 void wxGridBagSizer::Add( int width, int height, int, int flag, int border, wxObject* userData )
 609 {
 610     Add(width, height, FindEmptyCell(), wxDefaultSpan, flag, border, userData);
 611 }
 612
 613
 614
 615 // The Insert nad Prepend base class virtuals that are not appropriate for
 616 // this class and should not be used.  Their implementation in this class
 617 // simply fails.
 618
 619 void wxGridBagSizer::Add( wxSizerItem * )
 620 { wxFAIL_MSG(wxT("Invalid Add form called.")); }
 621
 622 void wxGridBagSizer::Prepend( wxWindow *, int, int, int, wxObject*  )
 623 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 624
 625 void wxGridBagSizer::Prepend( wxSizer *, int, int, int, wxObject*  )
 626 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 627
 628 void wxGridBagSizer::Prepend( int, int, int, int, int, wxObject*  )
 629 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 630
 631 void wxGridBagSizer::Prepend( wxSizerItem * )
 632 { wxFAIL_MSG(wxT("Prepend should not be used with wxGridBagSizer.")); }
 633
 634
 635 void wxGridBagSizer::Insert( size_t, wxWindow *, int, int, int, wxObject*  )
 636 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 637
 638 void wxGridBagSizer::Insert( size_t, wxSizer *, int, int, int, wxObject*  )
 639 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 640
 641 void wxGridBagSizer::Insert( size_t, int, int, int, int, int, wxObject*  )
 642 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 643
 644 void wxGridBagSizer::Insert( size_t, wxSizerItem * )
 645 { wxFAIL_MSG(wxT("Insert should not be used with wxGridBagSizer.")); }
 646
 647
 648 //---------------------------------------------------------------------------
 649 //---------------------------------------------------------------------------