src/common/gbsizer.cpp

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