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