]> git.saurik.com Git - wxWidgets.git/blobdiff - contrib/src/gizmos/multicell.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
compilation fix for gcc (closes bug 996701)
[wxWidgets.git] / contrib / src / gizmos / multicell.cpp
diff --git a/contrib/src/gizmos/multicell.cpp b/contrib/src/gizmos/multicell.cpp
index c09a203a731545c09166e5dcc7545f1e36fe0c91..130ecd63eb38d32b3089cc15317bed990c3a7c13 100644 (file)
--- a/contrib/src/gizmos/multicell.cpp
+++ b/contrib/src/gizmos/multicell.cpp
@@ -12,14 +12,14 @@
 // This was inspired by the gbsizer class written by Alex Andruschak
 
 #ifdef __GNUG__
 // This was inspired by the gbsizer class written by Alex Andruschak
 
 #ifdef __GNUG__
-       #pragma implementation "multicell.h"
+    #pragma implementation "multicell.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-       #pragma hdrstop
+    #pragma hdrstop
 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------
@@ -27,10 +27,10 @@
 // ----------------------------------------------------------------------------
 
 #ifndef WX_PRECOMP
 // ----------------------------------------------------------------------------
 
 #ifndef WX_PRECOMP
-       #include "wx/wx.h"
+    #include "wx/wx.h"
 #endif
 
 #endif
 
-#include       "wx/gizmos/multicell.h"
+#include "wx/gizmos/multicell.h"
 
 
 
 
 
 
@@ -38,99 +38,99 @@
 //---------------------------------------------------------------------------
 
 IMPLEMENT_ABSTRACT_CLASS(wxMultiCellSizer, wxSizer);
 //---------------------------------------------------------------------------
 
 IMPLEMENT_ABSTRACT_CLASS(wxMultiCellSizer, wxSizer);
-IMPLEMENT_ABSTRACT_CLASS(wxMultiCellItemHandle, wxRect);
+IMPLEMENT_ABSTRACT_CLASS(wxMultiCellItemHandle, wxObject);
 
 //---------------------------------------------------------------------------
 // wxMultiCellItemHandle
 //---------------------------------------------------------------------------
 /*
 
 //---------------------------------------------------------------------------
 // wxMultiCellItemHandle
 //---------------------------------------------------------------------------
 /*
- *Function Name:       wxMultiCellItemHandle :: wxMultiCellItemHandle
+ *Function Name: wxMultiCellItemHandle :: wxMultiCellItemHandle
  *
  *
- *Parameters:          int             row
- *                                     int                     column
- *                                     int             height
- *                                     int                     width
- *                                     wxSize          size
- *                                     wxResizable Style
- *                                     wxSize          weight
- *                                     int             align
+ *Parameters:    int         row
+ *               int         column
+ *               int         height
+ *               int         width
+ *               wxSize      size
+ *               wxResizable Style
+ *               wxSize      weight
+ *               int         align
  *
  *
- *Description: This is the constructor for the class.
+ *Description:   This is the constructor for the class.
  *
  */
 
 void wxMultiCellItemHandle :: Initialize( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
 {
  *
  */
 
 void wxMultiCellItemHandle :: Initialize( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
 {
-       m_column = column;
-       m_row = row;
-       m_width = width;
-       m_height = height;
+    m_column = column;
+    m_row = row;
+    m_width = width;
+    m_height = height;
 
 
-       m_style = Style;
-       m_fixedSize = size;
-       m_alignment = align;
-       m_weight = weight;
+    m_style = Style;
+    m_fixedSize = size;
+    m_alignment = align;
+    m_weight = weight;
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int height, int width, wxSize size, wxResizable Style, wxSize weight, int align)
 {
-       Initialize(row, column,height, width, size, Style, weight, align);
+    Initialize(row, column,height, width, size, Style, weight, align);
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxSize size, wxResizable style, wxSize weight, int align)
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxSize size, wxResizable style, wxSize weight, int align)
 {
-       Initialize(row, column,1, 1, size, style, weight, align);
+    Initialize(row, column,1, 1, size, style, weight, align);
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxResizable style, wxSize weight, int align)
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, wxResizable style, wxSize weight, int align)
 {
-       Initialize(row, column, 1, 1, wxSize(1, 1), style, weight, align);
+    Initialize(row, column, 1, 1, wxSize(1, 1), style, weight, align);
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int align)
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellItemHandle :: wxMultiCellItemHandle( int row, int column, int align)
 {
-       Initialize(row, column, 1, 1, wxSize(1,1), wxNOT_RESIZABLE, wxSize(1, 1), align);
+    Initialize(row, column, 1, 1, wxSize(1,1), wxNOT_RESIZABLE, wxSize(1, 1), align);
 }
 
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetColumn()
 {
 }
 
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetColumn()
 {
-       return m_column;
+    return m_column;
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetRow()
 {
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetRow()
 {
-       return m_row;
+    return m_row;
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetWidth()
 {
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetWidth()
 {
-       return m_width;
+    return m_width;
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetHeight()
 {
 }
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle::GetHeight()
 {
-       return m_height;
+    return m_height;
 }
 //---------------------------------------------------------------------------
 wxResizable    wxMultiCellItemHandle :: GetStyle()
 {
 }
 //---------------------------------------------------------------------------
 wxResizable    wxMultiCellItemHandle :: GetStyle()
 {
-       return m_style;
+    return m_style;
 };
 //---------------------------------------------------------------------------
 wxSize wxMultiCellItemHandle :: GetLocalSize()
 {
 };
 //---------------------------------------------------------------------------
 wxSize wxMultiCellItemHandle :: GetLocalSize()
 {
-       return m_fixedSize;
+    return m_fixedSize;
 };
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle :: GetAlignment()
 {
 };
 //---------------------------------------------------------------------------
 int wxMultiCellItemHandle :: GetAlignment()
 {
-       return m_alignment;
+    return m_alignment;
 };
 //---------------------------------------------------------------------------
 wxSize wxMultiCellItemHandle :: GetWeight()
 {
 };
 //---------------------------------------------------------------------------
 wxSize wxMultiCellItemHandle :: GetWeight()
 {
-       return m_weight;
+    return m_weight;
 };
 
 
 };
 
 
@@ -142,449 +142,445 @@ wxSize wxMultiCellItemHandle :: GetWeight()
 //---------------------------------------------------------------------------
 
 /*
 //---------------------------------------------------------------------------
 
 /*
- *Function Name:       wxMultiCellSizer::Initialize
+ *Function Name: wxMultiCellSizer::Initialize
  *
  *
- *Parameters:          wxsize          Initial size of sizer
+ *Parameters:    wxsize Initial size of sizer
  *
  *
- *Description:         This is a common function to initialize all the members of
- *                                     this class.  It is only called from the constructors
+ *Description:   This is a common function to initialize all the members of
+ *               this class.  It is only called from the constructors
  *
  */
 
 void wxMultiCellSizer::Initialize( wxSize size )
 {
  *
  */
 
 void wxMultiCellSizer::Initialize( wxSize size )
 {
-       m_cell_count = size;
-       m_maxHeight = (int *)malloc((1 + m_cell_count.GetHeight()) * sizeof(int));
-       m_maxWidth = (int *)malloc( (1 + m_cell_count.GetWidth()) * sizeof(int));
-       m_rowStretch = (int *)malloc( (1 + m_cell_count.GetHeight()) * sizeof(int));
-       m_colStretch = (int *)malloc((1 + m_cell_count.GetWidth()) * sizeof(int));
-
-       m_weights = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
-       m_minSizes = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
-       for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-       {
-               m_weights[x] = new wxSize(0,0);
-               m_minSizes[x] = new wxSize(0,0);
-       }
-
-       m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
-       m_defaultCellSize = wxSize(5, 5);
-       m_win = NULL;
-       m_pen = wxRED_PEN;
+    m_cell_count = size;
+    m_maxHeight = (int *)malloc((1 + m_cell_count.GetHeight()) * sizeof(int));
+    m_maxWidth = (int *)malloc( (1 + m_cell_count.GetWidth()) * sizeof(int));
+    m_rowStretch = (int *)malloc( (1 + m_cell_count.GetHeight()) * sizeof(int));
+    m_colStretch = (int *)malloc((1 + m_cell_count.GetWidth()) * sizeof(int));
+
+    m_weights = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
+    m_minSizes = (wxSize **)malloc((1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
+    for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+    {
+        m_weights[x] = new wxSize(0,0);
+        m_minSizes[x] = new wxSize(0,0);
+    }
+
+    m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
+    m_defaultCellSize = wxSize(5, 5);
+    m_win = NULL;
+    m_pen = wxRED_PEN;
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::wxMultiCellSizer( wxSize & size )
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::wxMultiCellSizer( wxSize & size )
 {
-       Initialize(size);
+    Initialize(size);
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::wxMultiCellSizer( int rows, int cols)
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::wxMultiCellSizer( int rows, int cols)
 {
-       wxSize size(cols, rows);
-       Initialize(size);
+    wxSize size(cols, rows);
+    Initialize(size);
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::~wxMultiCellSizer()
 {
 }
 //---------------------------------------------------------------------------
 wxMultiCellSizer::~wxMultiCellSizer()
 {
-       m_children.DeleteContents(TRUE);
+    WX_CLEAR_LIST(wxSizerItemList, m_children);
 
 
-       free(m_maxHeight);
-       free(m_maxWidth);
-       free(m_rowStretch);
-       free(m_colStretch);
+    free(m_maxHeight);
+    free(m_maxWidth);
+    free(m_rowStretch);
+    free(m_colStretch);
 
 
-       for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-       {
-               delete m_weights[x];
-               delete m_minSizes[x];
-       }
-       free(m_weights);
-       free(m_minSizes);
+    for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+    {
+        delete m_weights[x];
+        delete m_minSizes[x];
+    }
+    free(m_weights);
+    free(m_minSizes);
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::EnableGridLines(wxWindow *win)
 {
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::EnableGridLines(wxWindow *win)
 {
-       m_win = win;
-       return TRUE;
+    m_win = win;
+    return true;
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetGridPen(wxPen *pen)
 {
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetGridPen(wxPen *pen)
 {
-       m_pen = pen;
-       return TRUE;
+    m_pen = pen;
+    return true;
 }
 
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetDefaultCellSize(wxSize size)
 {
 }
 
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetDefaultCellSize(wxSize size)
 {
-       m_defaultCellSize = size;
-       return TRUE;
+    m_defaultCellSize = size;
+    return true;
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetColumnWidth(int column, int colSize, bool expandable)
 {
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetColumnWidth(int column, int colSize, bool expandable)
 {
-       if (expandable)
-       {
-               m_minSizes[column]->SetWidth(-colSize);
-       }
-       else
-       {
-               m_minSizes[column]->SetWidth(colSize);
-       }
-       return TRUE;
+    if (expandable)
+    {
+        m_minSizes[column]->SetWidth(-colSize);
+    }
+    else
+    {
+        m_minSizes[column]->SetWidth(colSize);
+    }
+    return true;
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetRowHeight(int row, int rowSize, bool expandable)
 {
 }
 //---------------------------------------------------------------------------
 bool wxMultiCellSizer::SetRowHeight(int row, int rowSize, bool expandable)
 {
-       if (expandable)
-       {
-               m_minSizes[row]->SetHeight(-rowSize);
-       }
-       else
-       {
-               m_minSizes[row]->SetHeight(rowSize);
-       }
-       return TRUE;
+    if (expandable)
+    {
+        m_minSizes[row]->SetHeight(-rowSize);
+    }
+    else
+    {
+        m_minSizes[row]->SetHeight(rowSize);
+    }
+    return true;
 }
 //---------------------------------------------------------------------------
 void wxMultiCellSizer::RecalcSizes()
 {
 }
 //---------------------------------------------------------------------------
 void wxMultiCellSizer::RecalcSizes()
 {
-       if (m_children.GetCount() == 0)
-               return;
-       wxSize size = GetSize();
-       wxPoint pos = GetPosition();
-
-       GetMinimums();
-
-       // We need to take the unused space and equally give it out to all the rows/columns
-       // which are stretchable
-
-       int unUsedWidth = size.GetWidth() - Sum(m_maxWidth, m_cell_count.GetWidth());
-       int unUsedHeight = size.GetHeight() - Sum(m_maxHeight, m_cell_count.GetHeight());
-       int totalWidthWeight = 0;
-       int totalHeightWeight = 0;
-       int x;
-
-       for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-       {
-               if (m_rowStretch[x])
-               {
-                       totalHeightWeight += m_weights[x]->GetHeight();
-               }
-               if (x < m_cell_count.GetWidth() && m_colStretch[x])
-               {
-                       totalWidthWeight += m_weights[x]->GetWidth();
-               }
-       }
-       for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-       {
-               if (x < m_cell_count.GetHeight() && m_rowStretch[x])
-               {
-                       m_maxHeight[x] += unUsedHeight * m_weights[x]->GetHeight() / totalHeightWeight;
-               }
-               if (x < m_cell_count.GetWidth() && m_colStretch[x])
-               {
-                       m_maxWidth[x] += unUsedWidth * m_weights[x]->GetWidth() / totalWidthWeight;
-               }
-       }
-       // We now have everything we need to figure each cell position and size
-       // The arrays m_maxHeight and m_maxWidth now contain the final widths and height of
-       // each row and column.
-
-       double cell_width = (double)size.GetWidth() / (double)m_cell_count.GetWidth();
-       double cell_height = (double)size.GetHeight() / (double)m_cell_count.GetHeight();
-       wxPoint c_point;
-       wxSize  c_size;
-
-       wxNode *current;
-       current = m_children.GetFirst();
-       while (current != NULL)
-       {
-               wxSizerItem *item = (wxSizerItem*) current->Data();
-
-               wxMultiCellItemHandle *rect;
-               if (item != NULL &&
-                       (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
-               {
-                       c_point.x = pos.x + (int)(rect->GetColumn() * cell_width);
-                       c_point.y = pos.y + (int)(rect->GetRow() * cell_height);
-
-                       c_point.x = pos.x + Sum(m_maxWidth, rect->GetColumn());
-                       c_point.y = pos.y + Sum(m_maxHeight, rect->GetRow());
-
-
-                       c_size = rect->GetLocalSize();
-                       wxSize minSize( item->CalcMin() );
-                       if (c_size.GetHeight() != wxDefaultSize.GetHeight() ||
-                               c_size.GetWidth() != wxDefaultSize.GetWidth())
-                       {
-                               minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
-                               minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
-                       }
-                       if (rect->GetStyle() & wxHORIZENTAL_RESIZABLE ||
-                               rect->GetWidth() > 1
-                               || m_minSizes[rect->GetColumn()]->GetWidth() < 0)
-                       {
-                               int w = 0;
-                               for (int x = 0; x < rect->GetWidth(); x++)
-                               {
-                                       w += m_maxWidth[rect->GetColumn() + x];
-                               }
-                               c_size.SetWidth(w);
-                       }
-                       else
-                       {
-                               c_size.SetWidth(minSize.GetWidth() );
-                       }
-                       if (rect->GetStyle() & wxVERTICAL_RESIZABLE ||
-                               rect->GetHeight() > 1 ||
-                               m_minSizes[rect->GetRow()]->GetHeight() < 0)
-                       {
-                               int h = 0;
-                               for (int x = 0; x < rect->GetHeight(); x++)
-                               {
-                                       h += m_maxHeight[rect->GetRow() + x];
-                               }
-                               c_size.SetHeight(h);
-                       }
-                       else
-                       {
-                               c_size.SetHeight(minSize.GetHeight());
-                       }
-                       int extraHeight = (m_maxHeight[rect->GetRow()] - c_size.GetHeight());
-                       int extraWidth = (m_maxWidth[rect->GetColumn()] - c_size.GetWidth());
-
-                       if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_CENTER_HORIZONTAL)
-                       {
-                               c_point.x += extraWidth / 2;
-                       }
-                       if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_RIGHT)
-                       {
-                               c_point.x += extraWidth;
-                       }
-                       if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_CENTER_VERTICAL)
-                       {
-                               c_point.y += extraHeight / 2;
-                       }
-                       if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_BOTTOM)
-                       {
-                               c_point.y += extraHeight;
-                       }
-                       item->SetDimension(c_point, c_size);
-               }
-               current = current->Next();
-       }
+    if (m_children.GetCount() == 0)
+        return;
+    wxSize size = GetSize();
+    wxPoint pos = GetPosition();
+
+    GetMinimums();
+
+    // We need to take the unused space and equally give it out to all the rows/columns
+    // which are stretchable
+
+    int unUsedWidth = size.GetWidth() - Sum(m_maxWidth, m_cell_count.GetWidth());
+    int unUsedHeight = size.GetHeight() - Sum(m_maxHeight, m_cell_count.GetHeight());
+    int totalWidthWeight = 0;
+    int totalHeightWeight = 0;
+    int x;
+
+    for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+    {
+        if (m_rowStretch[x])
+        {
+            totalHeightWeight += m_weights[x]->GetHeight();
+        }
+        if (x < m_cell_count.GetWidth() && m_colStretch[x])
+        {
+            totalWidthWeight += m_weights[x]->GetWidth();
+        }
+    }
+    for (x = 0; x < wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+    {
+        if (x < m_cell_count.GetHeight() && m_rowStretch[x])
+        {
+            m_maxHeight[x] += unUsedHeight * m_weights[x]->GetHeight() / totalHeightWeight;
+        }
+        if (x < m_cell_count.GetWidth() && m_colStretch[x])
+        {
+            m_maxWidth[x] += unUsedWidth * m_weights[x]->GetWidth() / totalWidthWeight;
+        }
+    }
+    // We now have everything we need to figure each cell position and size
+    // The arrays m_maxHeight and m_maxWidth now contain the final widths and height of
+    // each row and column.
+
+    double cell_width = (double)size.GetWidth() / (double)m_cell_count.GetWidth();
+    double cell_height = (double)size.GetHeight() / (double)m_cell_count.GetHeight();
+    wxPoint c_point;
+    wxSize  c_size;
+
+    wxSizerItemList::compatibility_iterator current = m_children.GetFirst();
+    while (current)
+    {
+        wxSizerItem *item = current->GetData();
+
+        wxMultiCellItemHandle *rect;
+        if (item != NULL &&
+            (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
+        {
+            c_point.x = pos.x + (int)(rect->GetColumn() * cell_width);
+            c_point.y = pos.y + (int)(rect->GetRow() * cell_height);
+
+            c_point.x = pos.x + Sum(m_maxWidth, rect->GetColumn());
+            c_point.y = pos.y + Sum(m_maxHeight, rect->GetRow());
+
+
+            c_size = rect->GetLocalSize();
+            wxSize minSize( item->CalcMin() );
+            if (c_size.GetHeight() != wxDefaultCoord ||
+                c_size.GetWidth() != wxDefaultCoord)
+            {
+                minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
+                minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
+            }
+            if (rect->GetStyle() & wxHORIZONTAL_RESIZABLE ||
+                rect->GetWidth() > 1
+                || m_minSizes[rect->GetColumn()]->GetWidth() < 0)
+            {
+                int w = 0;
+                for (int x = 0; x < rect->GetWidth(); x++)
+                {
+                    w += m_maxWidth[rect->GetColumn() + x];
+                }
+                c_size.SetWidth(w);
+            }
+            else
+            {
+                c_size.SetWidth(minSize.GetWidth() );
+            }
+            if (rect->GetStyle() & wxVERTICAL_RESIZABLE ||
+                rect->GetHeight() > 1 ||
+                m_minSizes[rect->GetRow()]->GetHeight() < 0)
+            {
+                int h = 0;
+                for (int x = 0; x < rect->GetHeight(); x++)
+                {
+                    h += m_maxHeight[rect->GetRow() + x];
+                }
+                c_size.SetHeight(h);
+            }
+            else
+            {
+                c_size.SetHeight(minSize.GetHeight());
+            }
+            int extraHeight = (m_maxHeight[rect->GetRow()] - c_size.GetHeight());
+            int extraWidth = (m_maxWidth[rect->GetColumn()] - c_size.GetWidth());
+
+            if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_CENTER_HORIZONTAL)
+            {
+                c_point.x += extraWidth / 2;
+            }
+            if (rect->GetWidth() == 1 && rect->GetAlignment() & wxALIGN_RIGHT)
+            {
+                c_point.x += extraWidth;
+            }
+            if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_CENTER_VERTICAL)
+            {
+                c_point.y += extraHeight / 2;
+            }
+            if (rect->GetHeight() == 1 && rect->GetAlignment() & wxALIGN_BOTTOM)
+            {
+                c_point.y += extraHeight;
+            }
+            item->SetDimension(c_point, c_size);
+        }
+        current = current->GetNext();
+    }
 }
 //---------------------------------------------------------------------------
 wxSize wxMultiCellSizer::CalcMin()
 {
 }
 //---------------------------------------------------------------------------
 wxSize wxMultiCellSizer::CalcMin()
 {
-       if (m_children.GetCount() == 0)
-               return wxSize(10,10);
+    if (m_children.GetCount() == 0)
+        return wxSize(10,10);
 
 
-       int m_minWidth = 0;
-       int m_minHeight = 0;
-
-       GetMinimums();
-       m_minWidth = Sum(m_maxWidth, m_cell_count.GetWidth());
-       m_minHeight = Sum(m_maxHeight, m_cell_count.GetHeight());
-       return wxSize( m_minWidth, m_minHeight );
+    GetMinimums();
+    int m_minWidth = Sum(m_maxWidth, m_cell_count.GetWidth());
+    int m_minHeight = Sum(m_maxHeight, m_cell_count.GetHeight());
+    return wxSize( m_minWidth, m_minHeight );
 }
 //---------------------------------------------------------------------------
 void wxMultiCellSizer :: GetMinimums()
 {
 }
 //---------------------------------------------------------------------------
 void wxMultiCellSizer :: GetMinimums()
 {
-       // We first initial all the arrays EXCEPT for the m_minsizes array.
-
-       memset(m_maxHeight, 0, sizeof(int) * m_cell_count.GetHeight());
-       memset(m_maxWidth, 0, sizeof(int) * m_cell_count.GetWidth());
-       memset(m_rowStretch, 0, sizeof(int) * m_cell_count.GetHeight());
-       memset(m_colStretch, 0, sizeof(int) * m_cell_count.GetWidth());
-       for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-       {
-               m_weights[x]->SetHeight(0);
-               m_weights[x]->SetWidth(0);
-       }
-
-       wxNode *node = m_children.GetFirst();
-       while (node)
-       {
-               wxSizerItem *item = (wxSizerItem*) node->Data();
-               wxMultiCellItemHandle *rect;
-               if (item != NULL &&
-                       (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
-               {
-                       int row = rect->GetRow();
-                       int col = rect->GetColumn();
-
-                       // First make sure that the control knows about the max rows and columns
-
-                       int changed = FALSE;
-                       if (row + 1 > m_cell_count.GetHeight())
-                       {
-                               changed++;
-                               m_maxHeight = (int *)realloc(m_maxHeight, (1 + row) * sizeof(int));
-                               m_rowStretch = (int *)realloc(m_rowStretch, (1 + row) * sizeof(int));
-                               for (int x = m_cell_count.GetHeight(); x < row + 1; x++)
-                               {
-                                       m_maxHeight[x - 1] = 0;
-                                       m_rowStretch[x - 1] = 0;
-                               }
-                               m_cell_count.SetHeight(row + 1);
-                       }
-                       if (col + 1 > m_cell_count.GetWidth())
-                       {
-                               changed++;
-                               m_maxWidth = (int *)realloc(m_maxWidth, (1 + col) * sizeof(int));
-                               m_colStretch = (int *)realloc(m_colStretch, ( 1 + col) * sizeof(int));
-                               for (int x = m_cell_count.GetWidth(); x < col + 1; x++)
-                               {
-                                       m_maxWidth[x - 1] = 0;
-                                       m_colStretch[x - 1] = 0;
-                               }
-                               m_cell_count.SetWidth(col + 1);
-                       }
-                       if (changed)
-                       {
-                               m_weights = (wxSize **)realloc(m_weights, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
-                               m_minSizes = (wxSize **)realloc(m_minSizes, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
-                               for (int x = m_maxWeights; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
-                               {
-                                       m_weights[x - 1] = new wxSize(0,0);
-                                       m_minSizes[x - 1] = new wxSize(0,0);
-                               }
-                               m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
-                       }
-
-                       // Sum the m_weights for each row/column, but only if they are resizable
-
-                       wxSize minSize( item->CalcMin() );
-                       wxSize c_size = rect->GetLocalSize();
-                       if (c_size.GetHeight() != wxDefaultSize.GetHeight() ||
-                               c_size.GetWidth() != wxDefaultSize.GetWidth())
-                       {
-                               minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
-                               minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
-                       }
-
-                       // For each row, calculate the max height for those fields which are not
-                       // resizable in the vertical pane
-
-                       if (!(rect->GetStyle() & wxVERTICAL_RESIZABLE || m_minSizes[row]->GetHeight() < 0))
-                       {
-                               m_maxHeight[row] = wxMax(m_maxHeight[row], minSize.GetHeight() / rect->GetHeight());
-                       }
-                       else
-                       {
-                               m_rowStretch[row] = 1;
-                               if (m_minSizes[row]->GetHeight())
-                               {
-                                       m_maxHeight[row] = abs(m_minSizes[row]->GetHeight());
-                               }
-                               else
-                               {
-                                       m_maxHeight[row] = wxMax(m_maxHeight[row], m_defaultCellSize.GetHeight());
-                               }
-                               m_weights[row]->SetHeight(wxMax(m_weights[row]->GetHeight(), rect->GetWeight().GetHeight()));
-                       }
-
-                       // For each column, calculate the max width for those fields which are not
-                       // resizable in the horizontal pane
-
-                       if (!(rect->GetStyle() & wxHORIZENTAL_RESIZABLE || m_minSizes[col]->GetWidth() < 0))
-                       {
-                               if (m_minSizes[col]->GetWidth())
-                               {
-                                       m_maxWidth[col] = abs(m_minSizes[col]->GetWidth());
-                               }
-                               else
-                               {
-                                       m_maxWidth[col] = wxMax(m_maxWidth[col], minSize.GetWidth() / rect->GetWidth());
-                               }
-                       }
-                       else
-                       {
-                               m_colStretch[col] = 1;
-                               m_maxWidth[col] = wxMax(m_maxWidth[col], m_defaultCellSize.GetWidth());
-                               m_weights[col]->SetWidth(wxMax(m_weights[col]->GetWidth(), rect->GetWeight().GetWidth()));
-                       }
-                       node = node->Next();
-               }
-       }
+    // We first initial all the arrays EXCEPT for the m_minsizes array.
+
+    memset(m_maxHeight, 0, sizeof(int) * m_cell_count.GetHeight());
+    memset(m_maxWidth, 0, sizeof(int) * m_cell_count.GetWidth());
+    memset(m_rowStretch, 0, sizeof(int) * m_cell_count.GetHeight());
+    memset(m_colStretch, 0, sizeof(int) * m_cell_count.GetWidth());
+    for (int x = 0; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+    {
+        m_weights[x]->SetHeight(0);
+        m_weights[x]->SetWidth(0);
+    }
+
+    wxSizerItemList::compatibility_iterator     node = m_children.GetFirst();
+    while (node)
+    {
+        wxSizerItem     *item = node->GetData();
+        wxMultiCellItemHandle *rect;
+        if (item != NULL &&
+            (rect = (wxMultiCellItemHandle *)item->GetUserData()) != NULL)
+        {
+            int row = rect->GetRow();
+            int col = rect->GetColumn();
+
+            // First make sure that the control knows about the max rows and columns
+
+            int changed = false;
+            if (row + 1 > m_cell_count.GetHeight())
+            {
+                changed++;
+                m_maxHeight = (int *)realloc(m_maxHeight, (1 + row) * sizeof(int));
+                m_rowStretch = (int *)realloc(m_rowStretch, (1 + row) * sizeof(int));
+                for (int x = m_cell_count.GetHeight(); x < row + 1; x++)
+                {
+                    m_maxHeight[x - 1] = 0;
+                    m_rowStretch[x - 1] = 0;
+                }
+                m_cell_count.SetHeight(row + 1);
+            }
+            if (col + 1 > m_cell_count.GetWidth())
+            {
+                changed++;
+                m_maxWidth = (int *)realloc(m_maxWidth, (1 + col) * sizeof(int));
+                m_colStretch = (int *)realloc(m_colStretch, ( 1 + col) * sizeof(int));
+                for (int x = m_cell_count.GetWidth(); x < col + 1; x++)
+                {
+                    m_maxWidth[x - 1] = 0;
+                    m_colStretch[x - 1] = 0;
+                }
+                m_cell_count.SetWidth(col + 1);
+            }
+            if (changed)
+            {
+                m_weights = (wxSize **)realloc(m_weights, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
+                m_minSizes = (wxSize **)realloc(m_minSizes, (1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth())) * sizeof(wxSize *));
+                for (int x = m_maxWeights; x < 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth()); x++)
+                {
+                    m_weights[x - 1] = new wxSize(0,0);
+                    m_minSizes[x - 1] = new wxSize(0,0);
+                }
+                m_maxWeights = 1 + wxMax(m_cell_count.GetHeight(), m_cell_count.GetWidth());
+            }
+
+            // Sum the m_weights for each row/column, but only if they are resizable
+
+            wxSize minSize( item->CalcMin() );
+            wxSize c_size = rect->GetLocalSize();
+            if (c_size.GetHeight() != wxDefaultCoord ||
+                c_size.GetWidth() != wxDefaultCoord)
+            {
+                minSize.SetHeight(wxMax(minSize.GetHeight(), c_size.GetHeight()));
+                minSize.SetWidth(wxMax(minSize.GetWidth(), c_size.GetWidth()));
+            }
+
+            // For each row, calculate the max height for those fields which are not
+            // resizable in the vertical pane
+
+            if (!(rect->GetStyle() & wxVERTICAL_RESIZABLE || m_minSizes[row]->GetHeight() < 0))
+            {
+                m_maxHeight[row] = wxMax(m_maxHeight[row], minSize.GetHeight() / rect->GetHeight());
+            }
+            else
+            {
+                m_rowStretch[row] = 1;
+                if (m_minSizes[row]->GetHeight())
+                {
+                    m_maxHeight[row] = abs(m_minSizes[row]->GetHeight());
+                }
+                else
+                {
+                    m_maxHeight[row] = wxMax(m_maxHeight[row], m_defaultCellSize.GetHeight());
+                }
+                m_weights[row]->SetHeight(wxMax(m_weights[row]->GetHeight(), rect->GetWeight().GetHeight()));
+            }
+
+            // For each column, calculate the max width for those fields which are not
+            // resizable in the horizontal pane
+
+            if (!(rect->GetStyle() & wxHORIZONTAL_RESIZABLE || m_minSizes[col]->GetWidth() < 0))
+            {
+                if (m_minSizes[col]->GetWidth())
+                {
+                    m_maxWidth[col] = abs(m_minSizes[col]->GetWidth());
+                }
+                else
+                {
+                    m_maxWidth[col] = wxMax(m_maxWidth[col], minSize.GetWidth() / rect->GetWidth());
+                }
+            }
+            else
+            {
+                m_colStretch[col] = 1;
+                m_maxWidth[col] = wxMax(m_maxWidth[col], m_defaultCellSize.GetWidth());
+                m_weights[col]->SetWidth(wxMax(m_weights[col]->GetWidth(), rect->GetWeight().GetWidth()));
+            }
+            node = node->GetNext();
+        }
+    }
 } // wxMultiCellSizer :: GetMinimums
 //---------------------------------------------------------------------------
 /*
 } // wxMultiCellSizer :: GetMinimums
 //---------------------------------------------------------------------------
 /*
- *Function Name:       wxMultiCellSizer :: Sum
+ *Function Name: wxMultiCellSizer :: Sum
  *
  *
- *Parameters:          int *           pointer to array of ints
- *                                     int                     Number of cells to sum up
+ *Parameters:    int* pointer to array of ints
+ *               int  Number of cells to sum up
  *
  *
- *Description:         This member function sums up all the elements of the array which
- *                                     preceed the specified cell.
+ *Description:   This member function sums up all the elements of the array which
+ *               preceed the specified cell.
  *
  *
- *Returns:                     int                     Sum
+ *Returns:       int Sum
  *
  */
 
 int wxMultiCellSizer :: Sum(int *array, int x)
 {
  *
  */
 
 int wxMultiCellSizer :: Sum(int *array, int x)
 {
-       int sum = 0;
-       while (x--)
-       {
-               sum += array[x];
-       }
-       return sum;
+    int sum = 0;
+    while (x--)
+    {
+        sum += array[x];
+    }
+    return sum;
 }
 //---------------------------------------------------------------------------
 /*
 }
 //---------------------------------------------------------------------------
 /*
- *Function Name:       wxMultiCellSizer :: DrawGridLines
+ *Function Name: wxMultiCellSizer :: DrawGridLines
  *
  *
- *Parameters:          wxDC            Device context
+ *Parameters:    wxDC Device context
  *
  *
- *Description:         This function draws the grid lines in the specified device context.
+ *Description:   This function draws the grid lines in the specified device context.
  *
  */
 
 void wxMultiCellSizer :: DrawGridLines(wxDC& dc)
 {
  *
  */
 
 void wxMultiCellSizer :: DrawGridLines(wxDC& dc)
 {
-       RecalcSizes();
-       int maxW = Sum(m_maxWidth, m_cell_count.GetWidth());
-       int maxH = Sum(m_maxHeight, m_cell_count.GetHeight());
-       int x;
-
-       // Draw the columns
-       dc.SetPen(* m_pen);
-       for (x = 1; x < m_cell_count.GetWidth(); x++)
-       {
-               int colPos = Sum(m_maxWidth, x) ;
-               dc.DrawLine(colPos, 0, colPos, maxH);
-       }
-
-       // Draw the rows
-       for (x = 1; x < m_cell_count.GetHeight(); x++)
-       {
-               int rowPos = Sum(m_maxHeight, x);
-               dc.DrawLine(0, rowPos, maxW, rowPos);
-       }
+    RecalcSizes();
+    int maxW = Sum(m_maxWidth, m_cell_count.GetWidth());
+    int maxH = Sum(m_maxHeight, m_cell_count.GetHeight());
+    int x;
+
+    // Draw the columns
+    dc.SetPen(* m_pen);
+    for (x = 1; x < m_cell_count.GetWidth(); x++)
+    {
+        int colPos = Sum(m_maxWidth, x) ;
+        dc.DrawLine(colPos, 0, colPos, maxH);
+    }
+
+    // Draw the rows
+    for (x = 1; x < m_cell_count.GetHeight(); x++)
+    {
+        int rowPos = Sum(m_maxHeight, x);
+        dc.DrawLine(0, rowPos, maxW, rowPos);
+    }
 }
 //---------------------------------------------------------------------------
 // Define the repainting behaviour
 /*
 }
 //---------------------------------------------------------------------------
 // Define the repainting behaviour
 /*
- *Function Name:       wxMultiCellSizer::OnPaint
+ *Function Name: wxMultiCellSizer::OnPaint
  *
  *
- *Parameters:          wxDC    Device context
+ *Parameters:    wxDC Device context
  *
  *
- *Description:         This function calls the DrawGridLines() member if a window
- *                                     has been previously specified.  This functions MUST be called
- *                                     from an OnPaint member belonging to the window which the sizer
- *                                     is attached to.
+ *Description:   This function calls the DrawGridLines() member if a window
+ *               has been previously specified.  This functions MUST be called
+ *               from an OnPaint member belonging to the window which the sizer
+ *               is attached to.
  *
  */
 
 void wxMultiCellSizer::OnPaint(wxDC& dc )
 {
  *
  */
 
 void wxMultiCellSizer::OnPaint(wxDC& dc )
 {
-       if (m_win)
-       {
-               DrawGridLines(dc);
-       }
+    if (m_win)
+    {
+        DrawGridLines(dc);
+    }
 }
 
 
 }
 
 
@@ -594,27 +590,27 @@ void wxMultiCellSizer::OnPaint(wxDC& dc )
 
 
 
 
 
 
-#define        CELL_LOC(row, col)      ((row) * m_maxCols + col)
+#define CELL_LOC(row, col) ((row) * m_maxCols + col)
 
 //---------------------------------------------------------------------------
 // wxCell
 //---------------------------------------------------------------------------
 /*
 
 //---------------------------------------------------------------------------
 // wxCell
 //---------------------------------------------------------------------------
 /*
- *Function Name:       wxCell : wxLayoutConstraints
+ *Function Name: wxCell : wxLayoutConstraints
  *
  *
- *Description:         This class is used by wxMultiCellCanvas for internal storage
+ *Description:   This class is used by wxMultiCellCanvas for internal storage
  *
  */
 
 class wxCell : public wxLayoutConstraints
 {
 public:
  *
  */
 
 class wxCell : public wxLayoutConstraints
 {
 public:
-       wxCell(wxWindow *win)
-       {
-               m_window = win;
-       };
+    wxCell(wxWindow *win)
+    {
+        m_window = win;
+    };
 
 
-       wxWindow    *m_window;
+    wxWindow    *m_window;
 };
 
 
 };
 
 
@@ -625,46 +621,44 @@ public:
 wxMultiCellCanvas :: wxMultiCellCanvas(wxWindow *par, int numRows, int numCols)
    : wxFlexGridSizer(numRows, numCols, 0, 0)
 {
 wxMultiCellCanvas :: wxMultiCellCanvas(wxWindow *par, int numRows, int numCols)
    : wxFlexGridSizer(numRows, numCols, 0, 0)
 {
-       m_cells = (wxCell **)calloc(numRows * numCols, sizeof(wxCell *));
+    m_cells = (wxCell **)calloc(numRows * numCols, sizeof(wxCell *));
 
 
-       m_parent = par;
-       m_maxRows = numRows;
-       m_maxCols = numCols;
-       m_minCellSize = wxSize(5, 5);
-}
-//---------------------------------------------------------------------------
-wxString itoa(int x)
-{
-       char    bfr[255];
-       sprintf(bfr, "%d", x);
-       return bfr;
+    m_parent = par;
+    m_maxRows = numRows;
+    m_maxCols = numCols;
+    m_minCellSize = wxSize(5, 5);
 }
 //---------------------------------------------------------------------------
 void wxMultiCellCanvas :: Add(wxWindow *win, unsigned int row, unsigned int col)
 {
 }
 //---------------------------------------------------------------------------
 void wxMultiCellCanvas :: Add(wxWindow *win, unsigned int row, unsigned int col)
 {
-       wxASSERT_MSG(row >= 0 && row < m_maxRows, wxString("Row ") + itoa(row) + " out of bounds (" + itoa(m_maxRows) + ")");
-       wxASSERT_MSG(col >= 0 && col < m_maxCols, wxString("Column ") + itoa(col) + " out of bounds (" + itoa(m_maxCols) + ")");
-       wxASSERT_MSG(m_cells[CELL_LOC(row, col)] == NULL, _("Cell already occupied"));
+  // thanks to unsigned data row and col are always >= 0
+    wxASSERT_MSG( /* row >= 0 && */ row < m_maxRows,
+                 wxString::Format(_T("Row %d out of bounds (0..%d)"), row, m_maxRows) );
+    wxASSERT_MSG( /* col >= 0 && */ col < m_maxCols,
+                 wxString::Format(_T("Column %d out of bounds (0..%d)"), col, m_maxCols) );
+
+    wxASSERT_MSG(m_cells[CELL_LOC(row, col)] == NULL, wxT("Cell already occupied"));
 
 
-       wxCell *newCell = new wxCell(win);
-       m_cells[CELL_LOC(row,col)] = newCell;
+    wxCell *newCell = new wxCell(win);
+    m_cells[CELL_LOC(row,col)] = newCell;
 }
 //---------------------------------------------------------------------------
 void wxMultiCellCanvas :: CalculateConstraints()
 {
 }
 //---------------------------------------------------------------------------
 void wxMultiCellCanvas :: CalculateConstraints()
 {
-       unsigned int    row, col;
-       for (row = 0; row < m_maxRows; row++)
-       {
-               for (col = 0; col < m_maxCols; col++)
-               {
-                       if (!m_cells[CELL_LOC(row, col)])
-                       {
-                               // Create an empty static text field as a placeholder
-                               m_cells[CELL_LOC(row, col)] = new wxCell(new wxStaticText(m_parent, -1, ""));
-                       }
-                       wxFlexGridSizer::Add(m_cells[CELL_LOC(row, col)]->m_window);
-               }
-       }
+    unsigned int    row, col;
+    for (row = 0; row < m_maxRows; row++)
+    {
+        for (col = 0; col < m_maxCols; col++)
+        {
+            if (!m_cells[CELL_LOC(row, col)])
+            {
+                // Create an empty static text field as a placeholder
+                m_cells[CELL_LOC(row, col)] = new wxCell(new wxStaticText(m_parent, wxID_ANY, wxT("")));
+            }
+            wxFlexGridSizer::Add(m_cells[CELL_LOC(row, col)]->m_window);
+        }
+    }
 }
 
 /*** End of File ***/
 }
 
 /*** End of File ***/
+
wxWidgets (Impactor)