contrib/src/gizmos/multicell.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        multicell.cpp
   3 // Purpose:     provide two new classes for layout, wxMultiCellSizer and wxMultiCellCanvas
   4 // Author:      Jonathan Bayer
   5 // Modified by:
   6 // Created:
   7 // RCS-ID:      $Id:
   8 // Copyright:   (c) Jonathan Bayer
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // This was inspired by the gbsizer class written by Alex Andruschak
  13
  14 #ifdef __GNUG__
  15     #pragma implementation "multicell.h"
  16 #endif
  17
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22     #pragma hdrstop
  23 #endif
  24
  25 // ----------------------------------------------------------------------------
  26 // headers
  27 // ----------------------------------------------------------------------------
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/wx.h"
  31 #endif
  32
  33 #include "wx/gizmos/multicell.h"
  34
  35
  36
  37
  38 //---------------------------------------------------------------------------
  39
  40 IMPLEMENT_ABSTRACT_CLASS(wxMultiCellSizer, wxSizer);
  41 IMPLEMENT_ABSTRACT_CLASS(wxMultiCellItemHandle, wxObject);
  42
  43 //---------------------------------------------------------------------------
  44 // wxMultiCellItemHandle
  45 //---------------------------------------------------------------------------
  46 /*
  47  *Function Name: wxMultiCellItemHandle :: wxMultiCellItemHandle
  48  *
  49  *Parameters:    int         row
  50  *               int         column
  51  *               int         height
  52  *               int         width
  53  *               wxSize      size
  54  *               wxResizable Style
  55  *               wxSize      weight
  56  *               int         align
  57  *
  58  *Description:   This is the constructor for the class.
  59  *
  60  */
  61
  62 void wxMultiCellItemHandle :: Initialize( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
  63 {
  64     m_column = column;
  65     m_row = row;
  66     m_width = width;
  67     m_height = height;
  68
  69     m_style = Style;
  70     m_fixedSize = size;
  71     m_alignment = align;
  72     m_weight = weight;
  73 }
  74 //---------------------------------------------------------------------------
  75 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
  76 {
  77     Initialize(row, column,height, width, size, Style, weight, align);
  78 }
  79 //---------------------------------------------------------------------------
  80 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxSize size, wxResizable style, wxSize weight, int align)
  81 {
  82     Initialize(row, column,1, 1, size, style, weight, align);
  83 }
  84 //---------------------------------------------------------------------------
  85 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxResizable style, wxSize weight, int align)
  86 {
  87     Initialize(row, column, 1, 1, wxSize(1, 1), style, weight, align);
  88 }
  89 //---------------------------------------------------------------------------
  90 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int align)
  91 {
  92     Initialize(row, column, 1, 1, wxSize(1,1), wxNOT_RESIZABLE, wxSize(1, 1), align);
  93 }
  94
  95 //---------------------------------------------------------------------------
  96 int wxMultiCellItemHandle::GetColumn()
  97 {
  98     return m_column;
  99 }
 100 //---------------------------------------------------------------------------
 101 int wxMultiCellItemHandle::GetRow()
 102 {
 103     return m_row;
 104 }
 105 //---------------------------------------------------------------------------
 106 int wxMultiCellItemHandle::GetWidth()
 107 {
 108     return m_width;
 109 }
 110 //---------------------------------------------------------------------------
 111 int wxMultiCellItemHandle::GetHeight()
 112 {
 113     return m_height;
 114 }
 115 //---------------------------------------------------------------------------
 116 wxResizable    wxMultiCellItemHandle :: GetStyle()
 117 {
 118     return m_style;
 119 };
 120 //---------------------------------------------------------------------------
 121 wxSize wxMultiCellItemHandle :: GetLocalSize()
 122 {
 123     return m_fixedSize;
 124 };
 125 //---------------------------------------------------------------------------
 126 int wxMultiCellItemHandle :: GetAlignment()
 127 {
 128     return m_alignment;
 129 };
 130 //---------------------------------------------------------------------------
 131 wxSize wxMultiCellItemHandle :: GetWeight()
 132 {
 133     return m_weight;
 134 };
 135
 136
 137
 138 //---------------------------------------------------------------------------
 139
 140 //---------------------------------------------------------------------------
 141 // wxMultiCellSizer
 142 //---------------------------------------------------------------------------
 143
 144 /*
 145  *Function Name: wxMultiCellSizer::Initialize
 146  *
 147  *Parameters:    wxsize Initial size of sizer
 148  *
 149  *Description:   This is a common function to initialize all the members of
 150  *               this class.  It is only called from the constructors
 151  *
 152  */
 153
 154 void wxMultiCellSizer::Initialize( wxSize size )
 155 {
 156     m_cell_count = size;
 157     m_maxHeight = (int *)malloc((1 + m_cell_count.GetHeight()) * sizeof(int));
 158     m_maxWidth = (int *)malloc( (1 + m_cell_count.GetWidth()) * sizeof(int));
 159     m_rowStretch = (int *)malloc( (1 + m_cell_count.GetHeight()) * sizeof(int));
 160     m_colStretch = (int *)malloc((1 + m_cell_count.GetWidth()) * sizeof(int));
 161
 162     m_weights = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
 163     m_minSizes = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
 164     for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 165     {
 166         m_weights[x] = new wxSize(0,0);
 167         m_minSizes[x] = new wxSize(0,0);
 168     }
 169
 170     m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
 171     m_defaultCellSize = wxSize(5, 5);
 172     m_win = NULL;
 173     m_pen = wxRED_PEN;
 174 }
 175 //---------------------------------------------------------------------------
 176 wxMultiCellSizer::wxMultiCellSizer( wxSize & size )
 177 {
 178     Initialize(size);
 179 }
 180 //---------------------------------------------------------------------------
 181 wxMultiCellSizer::wxMultiCellSizer( int rows, int cols)
 182 {
 183     wxSize size(cols, rows);
 184     Initialize(size);
 185 }
 186 //---------------------------------------------------------------------------
 187 wxMultiCellSizer::~wxMultiCellSizer()
 188 {
 189     WX_CLEAR_LIST(wxSizerItemList, m_children);
 190
 191     free(m_maxHeight);
 192     free(m_maxWidth);
 193     free(m_rowStretch);
 194     free(m_colStretch);
 195
 196     for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 197     {
 198         delete m_weights[x];
 199         delete m_minSizes[x];
 200     }
 201     free(m_weights);
 202     free(m_minSizes);
 203 }
 204 //---------------------------------------------------------------------------
 205 bool wxMultiCellSizer::EnableGridLines(wxWindow *win)
 206 {
 207     m_win = win;
 208     return true;
 209 }
 210 //---------------------------------------------------------------------------
 211 bool wxMultiCellSizer::SetGridPen(wxPen *pen)
 212 {
 213     m_pen = pen;
 214     return true;
 215 }
 216
 217 //---------------------------------------------------------------------------
 218 bool wxMultiCellSizer::SetDefaultCellSize(wxSize size)
 219 {
 220     m_defaultCellSize = size;
 221     return true;
 222 }
 223 //---------------------------------------------------------------------------
 224 bool wxMultiCellSizer::SetColumnWidth(int column, int colSize, bool expandable)
 225 {
 226     if (expandable)
 227     {
 228         m_minSizes[column]->SetWidth(-colSize);
 229     }
 230     else
 231     {
 232         m_minSizes[column]->SetWidth(colSize);
 233     }
 234     return true;
 235 }
 236 //---------------------------------------------------------------------------
 237 bool wxMultiCellSizer::SetRowHeight(int row, int rowSize, bool expandable)
 238 {
 239     if (expandable)
 240     {
 241         m_minSizes[row]->SetHeight(-rowSize);
 242     }
 243     else
 244     {
 245         m_minSizes[row]->SetHeight(rowSize);
 246     }
 247     return true;
 248 }
 249 //---------------------------------------------------------------------------
 250 void wxMultiCellSizer::RecalcSizes()
 251 {
 252     if (m_children.GetCount() == 0)
 253         return;
 254     wxSize size = GetSize();
 255     wxPoint pos = GetPosition();
 256
 257     GetMinimums();
 258
 259     // We need to take the unused space and equally give it out to all the rows/columns
 260     // which are stretchable
 261
 262     int unUsedWidth = size.GetWidth() - Sum(m_maxWidth, m_cell_count.GetWidth());
 263     int unUsedHeight = size.GetHeight() - Sum(m_maxHeight, m_cell_count.GetHeight());
 264     int totalWidthWeight = 0;
 265     int totalHeightWeight = 0;
 266     int x;
 267
 268     for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 269     {
 270         if (m_rowStretch[x])
 271         {
 272             totalHeightWeight += m_weights[x]->GetHeight();
 273         }
 274         if (x < m_cell_count.GetWidth() && m_colStretch[x])
 275         {
 276             totalWidthWeight += m_weights[x]->GetWidth();
 277         }
 278     }
 279     for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 280     {
 281         if (x < m_cell_count.GetHeight() && m_rowStretch[x])
 282         {
 283             m_maxHeight[x] += unUsedHeight * m_weights[x]->GetHeight() / totalHeightWeight;
 284         }
 285         if (x < m_cell_count.GetWidth() && m_colStretch[x])
 286         {
 287             m_maxWidth[x] += unUsedWidth * m_weights[x]->GetWidth() / totalWidthWeight;
 288         }
 289     }
 290     // We now have everything we need to figure each cell position and size
 291     // The arrays m_maxHeight and m_maxWidth now contain the final widths and height of
 292     // each row and column.
 293
 294     double cell_width = (double)size.GetWidth() / (double)m_cell_count.GetWidth();
 295     double cell_height = (double)size.GetHeight() / (double)m_cell_count.GetHeight();
 296     wxPoint c_point;
 297     wxSize  c_size;
 298
 299     wxSizerItemList::compatibility_iterator current = m_children.GetFirst();
 300     while (current)
 301     {
 302         wxSizerItem *item = current->GetData();
 303
 304         wxMultiCellItemHandle *rect;
 305         if (item != NULL &&
 306             (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
 307         {
 308             c_point.x = pos.x + (int)(rect->GetColumn() * cell_width);
 309             c_point.y = pos.y + (int)(rect->GetRow() * cell_height);
 310
 311             c_point.x = pos.x + Sum(m_maxWidth, rect->GetColumn());
 312             c_point.y = pos.y + Sum(m_maxHeight, rect->GetRow());
 313
 314
 315             c_size = rect->GetLocalSize();
 316             wxSize minSize( item->CalcMin() );
 317             if (c_size.GetHeight() != wxDefaultCoord ||
 318                 c_size.GetWidth() != wxDefaultCoord)
 319             {
 320                 minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
 321                 minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
 322             }
 323             if (rect->GetStyle() & wxHORIZONTAL_RESIZABLE ||
 324                 rect->GetWidth() > 1
 325                 || m_minSizes[rect->GetColumn()]->GetWidth() < 0)
 326             {
 327                 int w = 0;
 328                 for (int x = 0; x < rect->GetWidth(); x++)
 329                 {
 330                     w += m_maxWidth[rect->GetColumn() + x];
 331                 }
 332                 c_size.SetWidth(w);
 333             }
 334             else
 335             {
 336                 c_size.SetWidth(minSize.GetWidth() );
 337             }
 338             if (rect->GetStyle() & wxVERTICAL_RESIZABLE ||
 339                 rect->GetHeight() > 1 ||
 340                 m_minSizes[rect->GetRow()]->GetHeight() < 0)
 341             {
 342                 int h = 0;
 343                 for (int x = 0; x < rect->GetHeight(); x++)
 344                 {
 345                     h += m_maxHeight[rect->GetRow() + x];
 346                 }
 347                 c_size.SetHeight(h);
 348             }
 349             else
 350             {
 351                 c_size.SetHeight(minSize.GetHeight());
 352             }
 353             int extraHeight = (m_maxHeight[rect->GetRow()] - c_size.GetHeight());
 354             int extraWidth = (m_maxWidth[rect->GetColumn()] - c_size.GetWidth());
 355
 356             if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_CENTER_HORIZONTAL)
 357             {
 358                 c_point.x += extraWidth / 2;
 359             }
 360             if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_RIGHT)
 361             {
 362                 c_point.x += extraWidth;
 363             }
 364             if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_CENTER_VERTICAL)
 365             {
 366                 c_point.y += extraHeight / 2;
 367             }
 368             if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_BOTTOM)
 369             {
 370                 c_point.y += extraHeight;
 371             }
 372             item->SetDimension(c_point, c_size);
 373         }
 374         current = current->GetNext();
 375     }
 376 }
 377 //---------------------------------------------------------------------------
 378 wxSize wxMultiCellSizer::CalcMin()
 379 {
 380     if (m_children.GetCount() == 0)
 381         return wxSize(10,10);
 382
 383     GetMinimums();
 384     int m_minWidth = Sum(m_maxWidth, m_cell_count.GetWidth());
 385     int m_minHeight = Sum(m_maxHeight, m_cell_count.GetHeight());
 386     return wxSize( m_minWidth, m_minHeight );
 387 }
 388 //---------------------------------------------------------------------------
 389 void wxMultiCellSizer :: GetMinimums()
 390 {
 391     // We first initial all the arrays EXCEPT for the m_minsizes array.
 392
 393     memset(m_maxHeight, 0, sizeof(int) * m_cell_count.GetHeight());
 394     memset(m_maxWidth, 0, sizeof(int) * m_cell_count.GetWidth());
 395     memset(m_rowStretch, 0, sizeof(int) * m_cell_count.GetHeight());
 396     memset(m_colStretch, 0, sizeof(int) * m_cell_count.GetWidth());
 397     for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 398     {
 399         m_weights[x]->SetHeight(0);
 400         m_weights[x]->SetWidth(0);
 401     }
 402
 403     wxSizerItemList::compatibility_iterator     node = m_children.GetFirst();
 404     while (node)
 405     {
 406         wxSizerItem     *item = node->GetData();
 407         wxMultiCellItemHandle *rect;
 408         if (item != NULL &&
 409             (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
 410         {
 411             int row = rect->GetRow();
 412             int col = rect->GetColumn();
 413
 414             // First make sure that the control knows about the max rows and columns
 415
 416             int changed = false;
 417             if (row + 1 > m_cell_count.GetHeight())
 418             {
 419                 changed++;
 420                 m_maxHeight = (int *)realloc(m_maxHeight, (1 + row) * sizeof(int));
 421                 m_rowStretch = (int *)realloc(m_rowStretch, (1 + row) * sizeof(int));
 422                 for (int x = m_cell_count.GetHeight(); x < row + 1; x++)
 423                 {
 424                     m_maxHeight[x - 1] = 0;
 425                     m_rowStretch[x - 1] = 0;
 426                 }
 427                 m_cell_count.SetHeight(row + 1);
 428             }
 429             if (col + 1 > m_cell_count.GetWidth())
 430             {
 431                 changed++;
 432                 m_maxWidth = (int *)realloc(m_maxWidth, (1 + col) * sizeof(int));
 433                 m_colStretch = (int *)realloc(m_colStretch, ( 1 + col) * sizeof(int));
 434                 for (int x = m_cell_count.GetWidth(); x < col + 1; x++)
 435                 {
 436                     m_maxWidth[x - 1] = 0;
 437                     m_colStretch[x - 1] = 0;
 438                 }
 439                 m_cell_count.SetWidth(col + 1);
 440             }
 441             if (changed)
 442             {
 443                 m_weights = (wxSize **)realloc(m_weights, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
 444                 m_minSizes = (wxSize **)realloc(m_minSizes, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
 445                 for (int x = m_maxWeights; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
 446                 {
 447                     m_weights[x - 1] = new wxSize(0,0);
 448                     m_minSizes[x - 1] = new wxSize(0,0);
 449                 }
 450                 m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
 451             }
 452
 453             // Sum the m_weights for each row/column, but only if they are resizable
 454
 455             wxSize minSize( item->CalcMin() );
 456             wxSize c_size = rect->GetLocalSize();
 457             if (c_size.GetHeight() != wxDefaultCoord ||
 458                 c_size.GetWidth() != wxDefaultCoord)
 459             {
 460                 minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
 461                 minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
 462             }
 463
 464             // For each row, calculate the max height for those fields which are not
 465             // resizable in the vertical pane
 466
 467             if (!(rect->GetStyle() & wxVERTICAL_RESIZABLE || m_minSizes[row]->GetHeight() < 0))
 468             {
 469                 m_maxHeight[row] = wxMax(m_maxHeight[row], minSize.GetHeight() / rect->GetHeight());
 470             }
 471             else
 472             {
 473                 m_rowStretch[row] = 1;
 474                 if (m_minSizes[row]->GetHeight())
 475                 {
 476                     m_maxHeight[row] = abs(m_minSizes[row]->GetHeight());
 477                 }
 478                 else
 479                 {
 480                     m_maxHeight[row] = wxMax(m_maxHeight[row], m_defaultCellSize.GetHeight());
 481                 }
 482                 m_weights[row]->SetHeight(wxMax(m_weights[row]->GetHeight(), rect->GetWeight().GetHeight()));
 483             }
 484
 485             // For each column, calculate the max width for those fields which are not
 486             // resizable in the horizontal pane
 487
 488             if (!(rect->GetStyle() & wxHORIZONTAL_RESIZABLE || m_minSizes[col]->GetWidth() < 0))
 489             {
 490                 if (m_minSizes[col]->GetWidth())
 491                 {
 492                     m_maxWidth[col] = abs(m_minSizes[col]->GetWidth());
 493                 }
 494                 else
 495                 {
 496                     m_maxWidth[col] = wxMax(m_maxWidth[col], minSize.GetWidth() / rect->GetWidth());
 497                 }
 498             }
 499             else
 500             {
 501                 m_colStretch[col] = 1;
 502                 m_maxWidth[col] = wxMax(m_maxWidth[col], m_defaultCellSize.GetWidth());
 503                 m_weights[col]->SetWidth(wxMax(m_weights[col]->GetWidth(), rect->GetWeight().GetWidth()));
 504             }
 505             node = node->GetNext();
 506         }
 507     }
 508 } // wxMultiCellSizer :: GetMinimums
 509 //---------------------------------------------------------------------------
 510 /*
 511  *Function Name: wxMultiCellSizer :: Sum
 512  *
 513  *Parameters:    int* pointer to array of ints
 514  *               int  Number of cells to sum up
 515  *
 516  *Description:   This member function sums up all the elements of the array which
 517  *               preceed the specified cell.
 518  *
 519  *Returns:       int Sum
 520  *
 521  */
 522
 523 int wxMultiCellSizer :: Sum(int *array, int x)
 524 {
 525     int sum = 0;
 526     while (x--)
 527     {
 528         sum += array[x];
 529     }
 530     return sum;
 531 }
 532 //---------------------------------------------------------------------------
 533 /*
 534  *Function Name: wxMultiCellSizer :: DrawGridLines
 535  *
 536  *Parameters:    wxDC Device context
 537  *
 538  *Description:   This function draws the grid lines in the specified device context.
 539  *
 540  */
 541
 542 void wxMultiCellSizer :: DrawGridLines(wxDC& dc)
 543 {
 544     RecalcSizes();
 545     int maxW = Sum(m_maxWidth, m_cell_count.GetWidth());
 546     int maxH = Sum(m_maxHeight, m_cell_count.GetHeight());
 547     int x;
 548
 549     // Draw the columns
 550     dc.SetPen(* m_pen);
 551     for (x = 1; x < m_cell_count.GetWidth(); x++)
 552     {
 553         int colPos = Sum(m_maxWidth, x) ;
 554         dc.DrawLine(colPos, 0, colPos, maxH);
 555     }
 556
 557     // Draw the rows
 558     for (x = 1; x < m_cell_count.GetHeight(); x++)
 559     {
 560         int rowPos = Sum(m_maxHeight, x);
 561         dc.DrawLine(0, rowPos, maxW, rowPos);
 562     }
 563 }
 564 //---------------------------------------------------------------------------
 565 // Define the repainting behaviour
 566 /*
 567  *Function Name: wxMultiCellSizer::OnPaint
 568  *
 569  *Parameters:    wxDC Device context
 570  *
 571  *Description:   This function calls the DrawGridLines() member if a window
 572  *               has been previously specified.  This functions MUST be called
 573  *               from an OnPaint member belonging to the window which the sizer
 574  *               is attached to.
 575  *
 576  */
 577
 578 void wxMultiCellSizer::OnPaint(wxDC& dc )
 579 {
 580     if (m_win)
 581     {
 582         DrawGridLines(dc);
 583     }
 584 }
 585
 586
 587 //---------------------------------------------------------------------------
 588 //---------------------------------------------------------------------------
 589
 590
 591
 592
 593 #define CELL_LOC(row, col) ((row) * m_maxCols + col)
 594
 595 //---------------------------------------------------------------------------
 596 // wxCell
 597 //---------------------------------------------------------------------------
 598 /*
 599  *Function Name: wxCell : wxLayoutConstraints
 600  *
 601  *Description:   This class is used by wxMultiCellCanvas for internal storage
 602  *
 603  */
 604
 605 class wxCell : public wxLayoutConstraints
 606 {
 607 public:
 608     wxCell(wxWindow *win)
 609     {
 610         m_window = win;
 611     };
 612
 613     wxWindow    *m_window;
 614 };
 615
 616
 617
 618 //---------------------------------------------------------------------------
 619 // wxMultiCellCanvas
 620 //---------------------------------------------------------------------------
 621 wxMultiCellCanvas :: wxMultiCellCanvas(wxWindow *par, int numRows, int numCols)
 622    : wxFlexGridSizer(numRows, numCols, 0, 0)
 623 {
 624     m_cells = (wxCell **)calloc(numRows * numCols, sizeof(wxCell *));
 625
 626     m_parent = par;
 627     m_maxRows = numRows;
 628     m_maxCols = numCols;
 629     m_minCellSize = wxSize(5, 5);
 630 }
 631 //---------------------------------------------------------------------------
 632 void wxMultiCellCanvas :: Add(wxWindow *win, unsigned int row, unsigned int col)
 633 {
 634   // thanks to unsigned data row and col are always >= 0
 635     wxASSERT_MSG( /* row >= 0 && */ row < m_maxRows,
 636                  wxString::Format(_T("Row %d out of bounds (0..%d)"), row, m_maxRows) );
 637     wxASSERT_MSG( /* col >= 0 && */ col < m_maxCols,
 638                  wxString::Format(_T("Column %d out of bounds (0..%d)"), col, m_maxCols) );
 639
 640     wxASSERT_MSG(m_cells[CELL_LOC(row, col)] == NULL, wxT("Cell already occupied"));
 641
 642     wxCell *newCell = new wxCell(win);
 643     m_cells[CELL_LOC(row,col)] = newCell;
 644 }
 645 //---------------------------------------------------------------------------
 646 void wxMultiCellCanvas :: CalculateConstraints()
 647 {
 648     unsigned int    row, col;
 649     for (row = 0; row < m_maxRows; row++)
 650     {
 651         for (col = 0; col < m_maxCols; col++)
 652         {
 653             if (!m_cells[CELL_LOC(row, col)])
 654             {
 655                 // Create an empty static text field as a placeholder
 656                 m_cells[CELL_LOC(row, col)] = new wxCell(new wxStaticText(m_parent, wxID_ANY, wxT("")));
 657             }
 658             wxFlexGridSizer::Add(m_cells[CELL_LOC(row, col)]->m_window);
 659         }
 660     }
 661 }
 662
 663 /*** End of File ***/
 664