Use GTK+ function to obtain GdkWindow for wxListBox.

[wxWidgets.git] / src / generic / grid.cpp
diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp

index 874499b1e2d4d26ceebda854c1707c9f7f02e21c..e27d34ae3e3563751781a3f8a67689fa7e00e29a 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -17,10 +17,6 @@
  // headers
  // ----------------------------------------------------------------------------
  
  // headers
  // ----------------------------------------------------------------------------
  
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "grid.h"
-#endif
-
  // For compilers that support precompilatixon, includes "wx/wx.h".
  #include "wx/wxprec.h"
  
  // For compilers that support precompilatixon, includes "wx/wx.h".
  #include "wx/wxprec.h"
  
@@ -42,6 +38,7 @@
      #include "wx/combobox.h"
      #include "wx/valtext.h"
      #include "wx/intl.h"
      #include "wx/combobox.h"
      #include "wx/valtext.h"
      #include "wx/intl.h"
+    #include "wx/math.h"
  #endif
  
  #include "wx/textfile.h"
  #endif
  
  #include "wx/textfile.h"
@@ -210,7 +207,7 @@ public:
                    wxGridRowLabelWindow *rowLblWin,
                    wxGridColLabelWindow *colLblWin,
                    wxWindowID id, const wxPoint &pos, const wxSize &size );
                    wxGridRowLabelWindow *rowLblWin,
                    wxGridColLabelWindow *colLblWin,
                    wxWindowID id, const wxPoint &pos, const wxSize &size );
-    ~wxGridWindow(){}
+    ~wxGridWindow() {}
  
      void ScrollWindow( int dx, int dy, const wxRect *rect );
  
  
      void ScrollWindow( int dx, int dy, const wxRect *rect );
  
@@ -236,7 +233,6 @@ private:
  };
  
  
  };
  
  
-
  class wxGridCellEditorEvtHandler : public wxEvtHandler
  {
  public:
  class wxGridCellEditorEvtHandler : public wxEvtHandler
  {
  public:
@@ -260,7 +256,7 @@ private:
      // Work around the fact that a focus kill event can be sent to
      // a combobox within a set focus event.
      bool                m_inSetFocus;
      // Work around the fact that a focus kill event can be sent to
      // a combobox within a set focus event.
      bool                m_inSetFocus;
-    
+
      DECLARE_EVENT_TABLE()
      DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
      DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
      DECLARE_EVENT_TABLE()
      DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
      DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
@@ -1026,7 +1022,7 @@ wxString wxGridCellNumberEditor::GetValue() const
      wxString s;
  
  #if wxUSE_SPINCTRL
      wxString s;
  
  #if wxUSE_SPINCTRL
-    if( HasRange() )
+    if ( HasRange() )
      {
          long value = Spin()->GetValue();
          s.Printf(wxT("%ld"), value);
      {
          long value = Spin()->GetValue();
          s.Printf(wxT("%ld"), value);
@@ -1089,7 +1085,8 @@ bool wxGridCellFloatEditor::EndEdit(int row, int col,
      double value = 0.0;
      wxString text(Text()->GetValue());
  
      double value = 0.0;
      wxString text(Text()->GetValue());
  
-    if ( (text.empty() || text.ToDouble(&value)) && (value != m_valueOld) )
+    if ( (text.empty() || text.ToDouble(&value)) &&
+            !wxIsSameDouble(value, m_valueOld) )
      {
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
              grid->GetTable()->SetValueAsDouble(row, col, value);
      {
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
              grid->GetTable()->SetValueAsDouble(row, col, value);
@@ -1491,7 +1488,13 @@ void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
      Combo()->SetFocus();
  
      if (evtHandler)
      Combo()->SetFocus();
  
      if (evtHandler)
+    {
+        // When dropping down the menu, a kill focus event
+        // happens after this point, so we can't reset the flag yet.
+#if !defined(__WXGTK20__)
          evtHandler->SetInSetFocus(false);
          evtHandler->SetInSetFocus(false);
+#endif
+    }
  }
  
  bool wxGridCellChoiceEditor::EndEdit(int row, int col,
  }
  
  bool wxGridCellChoiceEditor::EndEdit(int row, int col,
@@ -1624,7 +1627,7 @@ void wxGridCellRenderer::Draw(wxGrid& grid,
      dc.SetBackgroundMode( wxSOLID );
  
      // grey out fields if the grid is disabled
      dc.SetBackgroundMode( wxSOLID );
  
      // grey out fields if the grid is disabled
-    if( grid.IsEnabled() )
+    if ( grid.IsEnabled() )
      {
          if ( isSelected )
          {
      {
          if ( isSelected )
          {
@@ -1648,8 +1651,8 @@ void wxGridCellRenderer::Draw(wxGrid& grid,
  // wxGridCellStringRenderer
  // ----------------------------------------------------------------------------
  
  // wxGridCellStringRenderer
  // ----------------------------------------------------------------------------
  
-void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
-                                                     wxGridCellAttr& attr,
+void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid& grid,
+                                                     const wxGridCellAttr& attr,
                                                       wxDC& dc,
                                                       bool isSelected)
  {
                                                       wxDC& dc,
                                                       bool isSelected)
  {
@@ -1658,7 +1661,7 @@ void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
      // TODO some special colours for attr.IsReadOnly() case?
  
      // different coloured text when the grid is disabled
      // TODO some special colours for attr.IsReadOnly() case?
  
      // different coloured text when the grid is disabled
-    if( grid.IsEnabled() )
+    if ( grid.IsEnabled() )
      {
        if ( isSelected )
        {
      {
        if ( isSelected )
        {
@@ -1680,7 +1683,7 @@ void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
      dc.SetFont( attr.GetFont() );
  }
  
      dc.SetFont( attr.GetFont() );
  }
  
-wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
+wxSize wxGridCellStringRenderer::DoGetBestSize(const wxGridCellAttr& attr,
                                                 wxDC& dc,
                                                 const wxString& text)
  {
                                                 wxDC& dc,
                                                 const wxString& text)
  {
@@ -1754,10 +1757,12 @@ void wxGridCellStringRenderer::Draw(wxGrid& grid,
                      i--;
                      break;
                  }
                      i--;
                      break;
                  }
-                if (rect.width >= best_width) break;
+                if (rect.width >= best_width)
+                    break;
              }
              overflowCols = i - col - cell_cols + 1;
              }
              overflowCols = i - col - cell_cols + 1;
-            if (overflowCols >= cols) overflowCols = cols - 1;
+            if (overflowCols >= cols)
+                overflowCols = cols - 1;
          }
  
          if (overflowCols > 0) // redraw overflow cells w/ proper hilight
          }
  
          if (overflowCols > 0) // redraw overflow cells w/ proper hilight
@@ -1801,7 +1806,7 @@ void wxGridCellStringRenderer::Draw(wxGrid& grid,
  // wxGridCellNumberRenderer
  // ----------------------------------------------------------------------------
  
  // wxGridCellNumberRenderer
  // ----------------------------------------------------------------------------
  
-wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
+wxString wxGridCellNumberRenderer::GetString(const wxGrid& grid, int row, int col)
  {
      wxGridTableBase *table = grid.GetTable();
      wxString text;
  {
      wxGridTableBase *table = grid.GetTable();
      wxString text;
@@ -1867,7 +1872,7 @@ wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
      return renderer;
  }
  
      return renderer;
  }
  
-wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
+wxString wxGridCellFloatRenderer::GetString(const wxGrid& grid, int row, int col)
  {
      wxGridTableBase *table = grid.GetTable();
  
  {
      wxGridTableBase *table = grid.GetTable();
  
@@ -1972,21 +1977,19 @@ void wxGridCellFloatRenderer::SetParameters(const wxString& params)
              {
                  wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
              }
              {
                  wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
              }
-
          }
          }
-                tmp = params.AfterFirst(_T(','));
-                if ( !tmp.empty() )
-                {
-                    long precision;
+        tmp = params.AfterFirst(_T(','));
+        if ( !tmp.empty() )
+        {
+            long precision;
              if ( tmp.ToLong(&precision) )
              if ( tmp.ToLong(&precision) )
-                    {
+            {
                  SetPrecision((int)precision);
                  SetPrecision((int)precision);
-                    }
-                    else
-                    {
+            }
+            else
+            {
                  wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
                  wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
-        }
-
+            }
          }
      }
  }
          }
      }
  }
@@ -2170,7 +2173,8 @@ void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
          SetBackgroundColour(mergefrom->GetBackgroundColour());
      if ( !HasFont() && mergefrom->HasFont() )
          SetFont(mergefrom->GetFont());
          SetBackgroundColour(mergefrom->GetBackgroundColour());
      if ( !HasFont() && mergefrom->HasFont() )
          SetFont(mergefrom->GetFont());
-    if ( !HasAlignment() && mergefrom->HasAlignment() ){
+    if ( !HasAlignment() && mergefrom->HasAlignment() )
+    {
          int hAlign, vAlign;
          mergefrom->GetAlignment( &hAlign, &vAlign);
          SetAlignment(hAlign, vAlign);
          int hAlign, vAlign;
          mergefrom->GetAlignment( &hAlign, &vAlign);
          SetAlignment(hAlign, vAlign);
@@ -2272,8 +2276,10 @@ void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
  {
      if (HasAlignment())
      {
  {
      if (HasAlignment())
      {
-        if ( hAlign ) *hAlign = m_hAlign;
-        if ( vAlign ) *vAlign = m_vAlign;
+        if ( hAlign )
+            *hAlign = m_hAlign;
+        if ( vAlign )
+            *vAlign = m_vAlign;
      }
      else if (m_defGridAttr && m_defGridAttr != this)
          m_defGridAttr->GetAlignment(hAlign, vAlign);
      }
      else if (m_defGridAttr && m_defGridAttr != this)
          m_defGridAttr->GetAlignment(hAlign, vAlign);
@@ -2285,8 +2291,10 @@ void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
  
  void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
  {
  
  void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
  {
-    if ( num_rows ) *num_rows = m_sizeRows;
-    if ( num_cols ) *num_cols = m_sizeCols;
+    if ( num_rows )
+        *num_rows = m_sizeRows;
+    if ( num_cols )
+        *num_cols = m_sizeCols;
  }
  
  // GetRenderer and GetEditor use a slightly different decision path about
  }
  
  // GetRenderer and GetEditor use a slightly different decision path about
@@ -2463,7 +2471,8 @@ void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
                      // No need to DecRef the attribute itself since this is
                      // done be wxGridCellWithAttr's destructor!
                      m_attrs.RemoveAt(n);
                      // No need to DecRef the attribute itself since this is
                      // done be wxGridCellWithAttr's destructor!
                      m_attrs.RemoveAt(n);
-                    n--; count--;
+                    n--;
+                    count--;
                  }
              }
          }
                  }
              }
          }
@@ -2598,7 +2607,8 @@ void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols
                      m_rowsOrCols.RemoveAt(n);
                      m_attrs[n]->DecRef();
                      m_attrs.RemoveAt(n);
                      m_rowsOrCols.RemoveAt(n);
                      m_attrs[n]->DecRef();
                      m_attrs.RemoveAt(n);
-                    n--; count--;
+                    n--;
+                    count--;
                  }
              }
          }
                  }
              }
          }
@@ -2630,70 +2640,80 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
      wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
      if ( m_data )
      {
      wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
      if ( m_data )
      {
-        switch(kind)
+        switch (kind)
          {
              case (wxGridCellAttr::Any):
          {
              case (wxGridCellAttr::Any):
-                //Get cached merge attributes.
-                // Currenlty not used as no cache implemented as not mutiable
+                // Get cached merge attributes.
+                // Currently not used as no cache implemented as not mutable
                  // attr = m_data->m_mergeAttr.GetAttr(row, col);
                  // attr = m_data->m_mergeAttr.GetAttr(row, col);
-                if(!attr)
+                if (!attr)
                  {
                  {
-                    //Basicaly implement old version.
-                    //Also check merge cache, so we don't have to re-merge every time..
+                    // Basically implement old version.
+                    // Also check merge cache, so we don't have to re-merge every time..
                      wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
                      wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
                      wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
  
                      wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
                      wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
                      wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
  
-                    if((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol)){
+                    if ((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol))
+                    {
                          // Two or more are non NULL
                          attr = new wxGridCellAttr;
                          attr->SetKind(wxGridCellAttr::Merged);
  
                          // Two or more are non NULL
                          attr = new wxGridCellAttr;
                          attr->SetKind(wxGridCellAttr::Merged);
  
-                        //Order important..
-                        if(attrcell){
+                        // Order is important..
+                        if (attrcell)
+                        {
                              attr->MergeWith(attrcell);
                              attrcell->DecRef();
                          }
                              attr->MergeWith(attrcell);
                              attrcell->DecRef();
                          }
-                        if(attrcol){
+                        if (attrcol)
+                        {
                              attr->MergeWith(attrcol);
                              attrcol->DecRef();
                          }
                              attr->MergeWith(attrcol);
                              attrcol->DecRef();
                          }
-                        if(attrrow){
+                        if (attrrow)
+                        {
                              attr->MergeWith(attrrow);
                              attrrow->DecRef();
                          }
                              attr->MergeWith(attrrow);
                              attrrow->DecRef();
                          }
-                        //store merge attr if cache implemented
+
+                        // store merge attr if cache implemented
                          //attr->IncRef();
                          //m_data->m_mergeAttr.SetAttr(attr, row, col);
                      }
                      else
                      {
                          // one or none is non null return it or null.
                          //attr->IncRef();
                          //m_data->m_mergeAttr.SetAttr(attr, row, col);
                      }
                      else
                      {
                          // one or none is non null return it or null.
-                        if(attrrow) attr = attrrow;
-                        if(attrcol)
+                        if (attrrow)
+                            attr = attrrow;
+                        if (attrcol)
                          {
                          {
-                            if(attr)
+                            if (attr)
                                  attr->DecRef();
                              attr = attrcol;
                          }
                                  attr->DecRef();
                              attr = attrcol;
                          }
-                        if(attrcell)
+                        if (attrcell)
                          {
                          {
-                            if(attr)
+                            if (attr)
                                  attr->DecRef();
                              attr = attrcell;
                          }
                      }
                  }
              break;
                                  attr->DecRef();
                              attr = attrcell;
                          }
                      }
                  }
              break;
+
              case (wxGridCellAttr::Cell):
                  attr = m_data->m_cellAttrs.GetAttr(row, col);
              break;
              case (wxGridCellAttr::Cell):
                  attr = m_data->m_cellAttrs.GetAttr(row, col);
              break;
+
              case (wxGridCellAttr::Col):
                  attr = m_data->m_colAttrs.GetAttr(col);
              break;
              case (wxGridCellAttr::Col):
                  attr = m_data->m_colAttrs.GetAttr(col);
              break;
+
              case (wxGridCellAttr::Row):
                  attr = m_data->m_rowAttrs.GetAttr(row);
              break;
              case (wxGridCellAttr::Row):
                  attr = m_data->m_rowAttrs.GetAttr(row);
              break;
+
              default:
                  // unused as yet...
                  // (wxGridCellAttr::Default):
              default:
                  // unused as yet...
                  // (wxGridCellAttr::Default):
@@ -2807,7 +2827,8 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
              RegisterDataType(wxGRID_VALUE_STRING,
                               new wxGridCellStringRenderer,
                               new wxGridCellTextEditor);
              RegisterDataType(wxGRID_VALUE_STRING,
                               new wxGridCellStringRenderer,
                               new wxGridCellTextEditor);
-        } else
+        }
+        else
  #endif // wxUSE_TEXTCTRL
  #if wxUSE_CHECKBOX
          if ( typeName == wxGRID_VALUE_BOOL )
  #endif // wxUSE_TEXTCTRL
  #if wxUSE_CHECKBOX
          if ( typeName == wxGRID_VALUE_BOOL )
@@ -2815,7 +2836,8 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
              RegisterDataType(wxGRID_VALUE_BOOL,
                               new wxGridCellBoolRenderer,
                               new wxGridCellBoolEditor);
              RegisterDataType(wxGRID_VALUE_BOOL,
                               new wxGridCellBoolRenderer,
                               new wxGridCellBoolEditor);
-        } else
+        }
+        else
  #endif // wxUSE_CHECKBOX
  #if wxUSE_TEXTCTRL
          if ( typeName == wxGRID_VALUE_NUMBER )
  #endif // wxUSE_CHECKBOX
  #if wxUSE_TEXTCTRL
          if ( typeName == wxGRID_VALUE_NUMBER )
@@ -2829,7 +2851,8 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
              RegisterDataType(wxGRID_VALUE_FLOAT,
                               new wxGridCellFloatRenderer,
                               new wxGridCellFloatEditor);
              RegisterDataType(wxGRID_VALUE_FLOAT,
                               new wxGridCellFloatRenderer,
                               new wxGridCellFloatEditor);
-        } else
+        }
+        else
  #endif // wxUSE_TEXTCTRL
  #if wxUSE_COMBOBOX
          if ( typeName == wxGRID_VALUE_CHOICE )
  #endif // wxUSE_TEXTCTRL
  #if wxUSE_COMBOBOX
          if ( typeName == wxGRID_VALUE_CHOICE )
@@ -2837,7 +2860,8 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
              RegisterDataType(wxGRID_VALUE_CHOICE,
                               new wxGridCellStringRenderer,
                               new wxGridCellChoiceEditor);
              RegisterDataType(wxGRID_VALUE_CHOICE,
                               new wxGridCellStringRenderer,
                               new wxGridCellChoiceEditor);
-        } else
+        }
+        else
  #endif // wxUSE_COMBOBOX
          {
              return wxNOT_FOUND;
  #endif // wxUSE_COMBOBOX
          {
              return wxNOT_FOUND;
@@ -3039,7 +3063,6 @@ bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
      return false;
  }
  
      return false;
  }
  
-
  wxString wxGridTableBase::GetRowLabelValue( int row )
  {
      wxString s;
  wxString wxGridTableBase::GetRowLabelValue( int row )
  {
      wxString s;
@@ -3061,7 +3084,8 @@ wxString wxGridTableBase::GetColLabelValue( int col )
      {
          s += (wxChar) (_T('A') + (wxChar)( col%26 ));
          col = col/26 - 1;
      {
          s += (wxChar) (_T('A') + (wxChar)( col%26 ));
          col = col/26 - 1;
-        if ( col < 0 ) break;
+        if ( col < 0 )
+            break;
      }
  
      // reverse the string...
      }
  
      // reverse the string...
@@ -3074,7 +3098,6 @@ wxString wxGridTableBase::GetColLabelValue( int col )
      return s2;
  }
  
      return s2;
  }
  
-
  wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
  {
      return wxGRID_VALUE_STRING;
  wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
  {
      return wxGRID_VALUE_STRING;
@@ -3281,8 +3304,9 @@ bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
  bool wxGridStringTable::AppendRows( size_t numRows )
  {
      size_t curNumRows = m_data.GetCount();
  bool wxGridStringTable::AppendRows( size_t numRows )
  {
      size_t curNumRows = m_data.GetCount();
-    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
-                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
+    size_t curNumCols = ( curNumRows > 0
+                         ? m_data[0].GetCount()
+                         : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      wxArrayString sa;
      if ( curNumCols > 0 )
  
      wxArrayString sa;
      if ( curNumCols > 0 )
@@ -3335,6 +3359,7 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
      {
          m_data.RemoveAt( pos, numRows );
      }
      {
          m_data.RemoveAt( pos, numRows );
      }
+
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -3353,8 +3378,9 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
      size_t row, col;
  
      size_t curNumRows = m_data.GetCount();
      size_t row, col;
  
      size_t curNumRows = m_data.GetCount();
-    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
-                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
+    size_t curNumCols = ( curNumRows > 0
+                         ? m_data[0].GetCount()
+                         : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      if ( pos >= curNumCols )
      {
  
      if ( pos >= curNumCols )
      {
@@ -3368,6 +3394,7 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
              m_data[row].Insert( wxEmptyString, col );
          }
      }
              m_data[row].Insert( wxEmptyString, col );
          }
      }
+
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -3449,6 +3476,7 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
              m_data[row].RemoveAt( pos, numCols );
          }
      }
              m_data[row].RemoveAt( pos, numCols );
          }
      }
+
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -3521,7 +3549,6 @@ void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
  }
  
  
  }
  
  
-
  //////////////////////////////////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////
  
  //////////////////////////////////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////
  
@@ -3562,19 +3589,16 @@ void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      m_owner->DrawRowLabels( dc , rows );
  }
  
      m_owner->DrawRowLabels( dc , rows );
  }
  
-
  void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessRowLabelMouseEvent( event );
  }
  
  void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessRowLabelMouseEvent( event );
  }
  
-
  void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
  {
      m_owner->GetEventHandler()->ProcessEvent(event);
  }
  
  void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
  {
      m_owner->GetEventHandler()->ProcessEvent(event);
  }
  
-
  // This seems to be required for wxMotif otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
  // This seems to be required for wxMotif otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
@@ -3594,7 +3618,6 @@ void wxGridRowLabelWindow::OnChar( wxKeyEvent& event )
  }
  
  
  }
  
  
-
  //////////////////////////////////////////////////////////////////////
  
  IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
  //////////////////////////////////////////////////////////////////////
  
  IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
@@ -3634,7 +3657,6 @@ void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      m_owner->DrawColLabels( dc , cols );
  }
  
      m_owner->DrawColLabels( dc , cols );
  }
  
-
  void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessColLabelMouseEvent( event );
  void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessColLabelMouseEvent( event );
@@ -3645,23 +3667,25 @@ void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
      m_owner->GetEventHandler()->ProcessEvent(event);
  }
  
      m_owner->GetEventHandler()->ProcessEvent(event);
  }
  
-
  // This seems to be required for wxMotif otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
  void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
  {
  // This seems to be required for wxMotif otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
  void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
  }
  
  void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  void wxGridColLabelWindow::OnChar( wxKeyEvent& event )
  {
  }
  
  void wxGridColLabelWindow::OnChar( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  
  }
  
  
@@ -3694,7 +3718,8 @@ void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      int client_width = 0;
      GetClientSize( &client_width, &client_height );
  
      int client_width = 0;
      GetClientSize( &client_width, &client_height );
  
-#if __WXGTK__
+    // VZ: any reason for this ifdef? (FIXME)
+#ifdef __WXGTK__
      wxRect rect;
      rect.SetX( 1 );
      rect.SetY( 1 );
      wxRect rect;
      rect.SetX( 1 );
      rect.SetY( 1 );
@@ -3702,7 +3727,7 @@ void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      rect.SetHeight( client_height - 2 );
  
      wxRendererNative::Get().DrawHeaderButton( this, dc, rect, 0 );
      rect.SetHeight( client_height - 2 );
  
      wxRendererNative::Get().DrawHeaderButton( this, dc, rect, 0 );
-#else
+#else // !__WXGTK__
      dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
      dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
      dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
      dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
      dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
      dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
@@ -3712,16 +3737,14 @@ void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      dc.SetPen( *wxWHITE_PEN );
      dc.DrawLine( 1, 1, client_width-1, 1 );
      dc.DrawLine( 1, 1, 1, client_height-1 );
      dc.SetPen( *wxWHITE_PEN );
      dc.DrawLine( 1, 1, client_width-1, 1 );
      dc.DrawLine( 1, 1, 1, client_height-1 );
-#endif
+#endif // __WXGTK__/!__WXGTK__
  }
  
  }
  
-
  void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessCornerLabelMouseEvent( event );
  }
  
  void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
  {
      m_owner->ProcessCornerLabelMouseEvent( event );
  }
  
-
  void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
  {
      m_owner->GetEventHandler()->ProcessEvent(event);
  void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
  {
      m_owner->GetEventHandler()->ProcessEvent(event);
@@ -3770,14 +3793,12 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
                              const wxSize &size )
              : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN|wxFULL_REPAINT_ON_RESIZE,
                          wxT("grid window") )
                              const wxSize &size )
              : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN|wxFULL_REPAINT_ON_RESIZE,
                          wxT("grid window") )
-
  {
      m_owner = parent;
      m_rowLabelWin = rowLblWin;
      m_colLabelWin = colLblWin;
  }
  
  {
      m_owner = parent;
      m_rowLabelWin = rowLblWin;
      m_colLabelWin = colLblWin;
  }
  
-
  void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
  {
      wxPaintDC dc( this );
  void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
  {
      wxPaintDC dc( this );
@@ -3792,7 +3813,6 @@ void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
      m_owner->DrawHighlight( dc , DirtyCells );
  }
  
      m_owner->DrawHighlight( dc , DirtyCells );
  }
  
-
  void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
  {
      wxWindow::ScrollWindow( dx, dy, rect );
  void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
  {
      wxWindow::ScrollWindow( dx, dy, rect );
@@ -3800,7 +3820,6 @@ void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
      m_colLabelWin->ScrollWindow( dx, 0, rect );
  }
  
      m_colLabelWin->ScrollWindow( dx, 0, rect );
  }
  
-
  void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
  {
      if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
  void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
  {
      if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
@@ -3819,17 +3838,20 @@ void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
  //
  void wxGridWindow::OnKeyDown( wxKeyEvent& event )
  {
  //
  void wxGridWindow::OnKeyDown( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  void wxGridWindow::OnKeyUp( wxKeyEvent& event )
  {
  }
  
  void wxGridWindow::OnKeyUp( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  void wxGridWindow::OnChar( wxKeyEvent& event )
  {
  }
  
  void wxGridWindow::OnChar( wxKeyEvent& event )
  {
-    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+        event.Skip();
  }
  
  void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
  }
  
  void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
@@ -4161,8 +4183,7 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
  
          m_table = table;
          m_table->SetView( this );
  
          m_table = table;
          m_table->SetView( this );
-        if (takeOwnership)
-            m_ownTable = true;
+        m_ownTable = takeOwnership;
          m_selection = new wxGridSelection( this, selmode );
  
          CalcDimensions();
          m_selection = new wxGridSelection( this, selmode );
  
          CalcDimensions();
@@ -4356,7 +4377,7 @@ void wxGrid::CalcDimensions()
      int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
  
      // take into account editor if shown
      int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
  
      // take into account editor if shown
-    if( IsCellEditControlShown() )
+    if ( IsCellEditControlShown() )
      {
        int w2, h2;
        int r = m_currentCellCoords.GetRow();
      {
        int w2, h2;
        int r = m_currentCellCoords.GetRow();
@@ -4370,8 +4391,10 @@ void wxGrid::CalcDimensions()
        editor->GetControl()->GetSize(&w2, &h2);
        w2 += x;
        h2 += y;
        editor->GetControl()->GetSize(&w2, &h2);
        w2 += x;
        h2 += y;
-      if( w2 > w ) w = w2;
-      if( h2 > h ) h = h2;
+      if ( w2 > w )
+          w = w2;
+      if ( h2 > h )
+          h = h2;
        editor->DecRef();
        attr->DecRef();
      }
        editor->DecRef();
        attr->DecRef();
      }
@@ -4565,7 +4588,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              if ( m_selection )
                  m_selection->UpdateRows( pos, -((int)numRows) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if ( m_selection )
                  m_selection->UpdateRows( pos, -((int)numRows) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
-            if (attrProvider) {
+            if (attrProvider)
+            {
                  attrProvider->UpdateAttrRows( pos, -((int)numRows) );
  // ifdef'd out following patch from Paul Gammans
  #if 0
                  attrProvider->UpdateAttrRows( pos, -((int)numRows) );
  // ifdef'd out following patch from Paul Gammans
  #if 0
@@ -4696,7 +4720,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              if ( m_selection )
                  m_selection->UpdateCols( pos, -((int)numCols) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if ( m_selection )
                  m_selection->UpdateCols( pos, -((int)numCols) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
-            if (attrProvider) {
+            if (attrProvider)
+            {
                  attrProvider->UpdateAttrCols( pos, -((int)numCols) );
  // ifdef'd out following patch from Paul Gammans
  #if 0
                  attrProvider->UpdateAttrCols( pos, -((int)numCols) );
  // ifdef'd out following patch from Paul Gammans
  #if 0
@@ -4903,7 +4928,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
  
          if ( event.LeftIsDown() )
          {
  
          if ( event.LeftIsDown() )
          {
-            switch( m_cursorMode )
+            switch ( m_cursorMode )
              {
                  case WXGRID_CURSOR_RESIZE_ROW:
                  {
              {
                  case WXGRID_CURSOR_RESIZE_ROW:
                  {
@@ -5024,7 +5049,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
      //
      else if (event.LeftDClick() )
      {
      //
      else if (event.LeftDClick() )
      {
-        int row = YToEdgeOfRow(y);
+        row = YToEdgeOfRow(y);
          if ( row < 0 )
          {
              row = YToRow(y);
          if ( row < 0 )
          {
              row = YToRow(y);
@@ -5128,7 +5153,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
  
          if ( event.LeftIsDown() )
          {
  
          if ( event.LeftIsDown() )
          {
-            switch( m_cursorMode )
+            switch ( m_cursorMode )
              {
                  case WXGRID_CURSOR_RESIZE_COL:
                  {
              {
                  case WXGRID_CURSOR_RESIZE_COL:
                  {
@@ -5248,7 +5273,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
      //
      if ( event.LeftDClick() )
      {
      //
      if ( event.LeftDClick() )
      {
-        int col = XToEdgeOfCol(x);
+        col = XToEdgeOfCol(x);
          if ( col < 0 )
          {
              col = XToCol(x);
          if ( col < 0 )
          {
              col = XToCol(x);
@@ -5459,7 +5484,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
      {
          //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
  
      {
          //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
  
-        // Don't start doing anything until the mouse has been drug at
+        // Don't start doing anything until the mouse has been dragged at
          // least 3 pixels in any direction...
          if (! m_isDragging)
          {
          // least 3 pixels in any direction...
          if (! m_isDragging)
          {
@@ -5476,7 +5501,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
          if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
          {
              // Hide the edit control, so it
          if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
          {
              // Hide the edit control, so it
-            // won't interfer with drag-shrinking.
+            // won't interfere with drag-shrinking.
              if ( IsCellEditControlShown() )
              {
                  HideCellEditControl();
              if ( IsCellEditControlShown() )
              {
                  HideCellEditControl();
@@ -5778,7 +5803,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
      //
      else if ( event.Moving() && !event.IsButton() )
      {
      //
      else if ( event.Moving() && !event.IsButton() )
      {
-        if( coords.GetRow() < 0 || coords.GetCol() < 0 )
+        if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
          {
              // out of grid cell area
              ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
          {
              // out of grid cell area
              ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
@@ -6209,7 +6234,9 @@ int wxGrid::SendEvent( const wxEventType type,
     }
  
     // A Veto'd event may not be `claimed' so test this first
     }
  
     // A Veto'd event may not be `claimed' so test this first
-   if (vetoed) return -1;
+   if (vetoed)
+       return -1;
+
     return claimed ? 1 : 0;
  }
  
     return claimed ? 1 : 0;
  }
  
@@ -6247,11 +6274,12 @@ int wxGrid::SendEvent( const wxEventType type,
       }
  
      // A Veto'd event may not be `claimed' so test this first
       }
  
      // A Veto'd event may not be `claimed' so test this first
-    if (vetoed) return -1;
+    if (vetoed)
+        return -1;
+
      return claimed ? 1 : 0;
  }
  
      return claimed ? 1 : 0;
  }
  
-
  void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
      wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
  void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
      wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
@@ -6264,7 +6292,7 @@ void wxGrid::Refresh(bool eraseb, const wxRect* rect)
      if (! GetBatchCount())
      {
          // Refresh to get correct scrolled position:
      if (! GetBatchCount())
      {
          // Refresh to get correct scrolled position:
-        wxScrolledWindow::Refresh(eraseb,rect);
+        wxScrolledWindow::Refresh(eraseb, rect);
  
          if (rect)
          {
  
          if (rect)
          {
@@ -6279,7 +6307,8 @@ void wxGrid::Refresh(bool eraseb, const wxRect* rect)
              rectHeight = rect->GetHeight();
  
              width_label = m_rowLabelWidth - rect_x;
              rectHeight = rect->GetHeight();
  
              width_label = m_rowLabelWidth - rect_x;
-            if (width_label > rectWidth) width_label = rectWidth;
+            if (width_label > rectWidth)
+                width_label = rectWidth;
  
              height_label = m_colLabelHeight - rect_y;
              if (height_label > rectHeight) height_label = rectHeight;
  
              height_label = m_colLabelHeight - rect_y;
              if (height_label > rectHeight) height_label = rectHeight;
@@ -6859,7 +6888,8 @@ bool wxGrid::SetModelValues()
  //
  void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
  {
  //
  void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
  {
-    if ( !m_numRows || !m_numCols ) return;
+    if ( !m_numRows || !m_numCols )
+        return;
  
      int i, numCells = cells.GetCount();
      int row, col, cell_rows, cell_cols;
  
      int i, numCells = cells.GetCount();
      int row, col, cell_rows, cell_cols;
@@ -6895,7 +6925,8 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                          break;
                      }
                  }
                          break;
                      }
                  }
-                if (!marked) redrawCells.Add( cell );
+                if (!marked)
+                    redrawCells.Add( cell );
              }
              continue; // don't bother drawing this cell
          }
              }
              continue; // don't bother drawing this cell
          }
@@ -6910,9 +6941,10 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                  for (int k = 0; k < int(redrawCells.GetCount()); k++)
                      if ((redrawCells[k].GetCol() < left) &&
                          (redrawCells[k].GetRow() == row))
                  for (int k = 0; k < int(redrawCells.GetCount()); k++)
                      if ((redrawCells[k].GetCol() < left) &&
                          (redrawCells[k].GetRow() == row))
-                        left=redrawCells[k].GetCol();
+                        left = redrawCells[k].GetCol();
  
  
-                if (left == col) left = 0; // oh well
+                if (left == col)
+                    left = 0; // oh well
  
                  for (int j = col-1; j >= left; j--)
                  {
  
                  for (int j = col-1; j >= left; j--)
                  {
@@ -6931,6 +6963,7 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                                      break;
                                  }
                              }
                                      break;
                                  }
                              }
+
                              if (!marked)
                              {
                                  int count = redrawCells.GetCount();
                              if (!marked)
                              {
                                  int count = redrawCells.GetCount();
@@ -6942,7 +6975,8 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                                          break;
                                      }
                                  }
                                          break;
                                      }
                                  }
-                                if (!marked) redrawCells.Add( cell );
+                                if (!marked)
+                                    redrawCells.Add( cell );
                              }
                          }
                          break;
                              }
                          }
                          break;
@@ -6950,6 +6984,7 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                  }
              }
          }
                  }
              }
          }
+
          DrawCell( dc, cells[i] );
      }
  
          DrawCell( dc, cells[i] );
      }
  
@@ -7018,9 +7053,15 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
      // Note: However, only if it is really _shown_, i.e. not hidden!
      if ( isCurrent && IsCellEditControlShown() )
      {
      // Note: However, only if it is really _shown_, i.e. not hidden!
      if ( isCurrent && IsCellEditControlShown() )
      {
+        // OSAF NB: this "#if..." is temporary and fixes a problem where the
+        // edit control is erased by this code after being rendered.
+        // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
+        // implicitly, causing this out-of order render.
+#if !defined(__WXMAC__) || wxMAC_USE_CORE_GRAPHICS
          wxGridCellEditor *editor = attr->GetEditor(this, row, col);
          editor->PaintBackground(rect, attr);
          editor->DecRef();
          wxGridCellEditor *editor = attr->GetEditor(this, row, col);
          editor->PaintBackground(rect, attr);
          editor->DecRef();
+#endif
      }
      else
      {
      }
      else
      {
@@ -7057,16 +7098,16 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
          // reduce the size of the rectangle to compensate for the thickness of
          // the line.  If this is too strange on non wxMSW platforms then
          // please #ifdef this appropriately.
          // reduce the size of the rectangle to compensate for the thickness of
          // the line.  If this is too strange on non wxMSW platforms then
          // please #ifdef this appropriately.
-        rect.x += penWidth/2;
-        rect.y += penWidth/2;
-        rect.width -= penWidth-1;
-        rect.height -= penWidth-1;
+        rect.x += penWidth / 2;
+        rect.y += penWidth / 2;
+        rect.width -= penWidth - 1;
+        rect.height -= penWidth - 1;
  
  
          // Now draw the rectangle
          // use the cellHighlightColour if the cell is inside a selection, this
          // will ensure the cell is always visible.
  
  
          // Now draw the rectangle
          // use the cellHighlightColour if the cell is inside a selection, this
          // will ensure the cell is always visible.
-        dc.SetPen(wxPen(IsInSelection(row,col)?m_selectionForeground:m_cellHighlightColour, penWidth, wxSOLID));
+        dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground : m_cellHighlightColour, penWidth, wxSOLID));
          dc.SetBrush(*wxTRANSPARENT_BRUSH);
          dc.DrawRectangle(rect);
      }
          dc.SetBrush(*wxTRANSPARENT_BRUSH);
          dc.DrawRectangle(rect);
      }
@@ -7077,8 +7118,8 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
          // how to properly set colours for arbitrary bg?
          wxCoord x1 = rect.x,
                  y1 = rect.y,
          // how to properly set colours for arbitrary bg?
          wxCoord x1 = rect.x,
                  y1 = rect.y,
-                x2 = rect.x + rect.width -1,
-                y2 = rect.y + rect.height -1;
+                x2 = rect.x + rect.width - 1,
+                y2 = rect.y + rect.height - 1;
  
          dc.SetPen(*wxWHITE_PEN);
          dc.DrawLine(x1, y1, x2, y1);
  
          dc.SetPen(*wxWHITE_PEN);
          dc.DrawLine(x1, y1, x2, y1);
@@ -7161,7 +7202,8 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
  
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
  
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
-         !m_numCols ) return;
+         !m_numCols )
+         return;
  
      int top, bottom, left, right;
  
  
      int top, bottom, left, right;
  
@@ -7273,7 +7315,6 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
          }
      }
  
          }
      }
  
-
      // vertical grid lines
      //
      for ( i = internalXToCol(left); i < m_numCols; i++ )
      // vertical grid lines
      //
      for ( i = internalXToCol(left); i < m_numCols; i++ )
@@ -7292,10 +7333,10 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
      dc.DestroyClippingRegion();
  }
  
      dc.DestroyClippingRegion();
  }
  
-
  void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
  {
  void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
  {
-    if ( !m_numRows ) return;
+    if ( !m_numRows )
+        return;
  
      size_t i;
      size_t numLabels = rows.GetCount();
  
      size_t i;
      size_t numLabels = rows.GetCount();
@@ -7306,7 +7347,6 @@ void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
      }
  }
  
      }
  }
  
-
  void wxGrid::DrawRowLabel( wxDC& dc, int row )
  {
      if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
  void wxGrid::DrawRowLabel( wxDC& dc, int row )
  {
      if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
@@ -7354,10 +7394,10 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
      DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
  }
  
      DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
  }
  
-
  void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
  {
  void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
  {
-    if ( !m_numCols ) return;
+    if ( !m_numCols )
+        return;
  
      size_t i;
      size_t numLabels = cols.GetCount();
  
      size_t i;
      size_t numLabels = cols.GetCount();
@@ -7368,7 +7408,6 @@ void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
      }
  }
  
      }
  }
  
-
  void wxGrid::DrawColLabel( wxDC& dc, int col )
  {
      if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
  void wxGrid::DrawColLabel( wxDC& dc, int col )
  {
      if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
@@ -7428,7 +7467,6 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
  
      StringToLines( value, lines );
  
  
      StringToLines( value, lines );
  
-
      //Forward to new API.
      DrawTextRectangle(  dc,
          lines,
      //Forward to new API.
      DrawTextRectangle(  dc,
          lines,
@@ -7446,34 +7484,34 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
                                 int vertAlign,
                                 int textOrientation )
  {
                                 int vertAlign,
                                 int textOrientation )
  {
-    long textWidth, textHeight;
-    long lineWidth, lineHeight;
+    long textWidth = 0, textHeight = 0;
+    long lineWidth = 0, lineHeight = 0;
      int nLines;
  
      dc.SetClippingRegion( rect );
  
      nLines = lines.GetCount();
      int nLines;
  
      dc.SetClippingRegion( rect );
  
      nLines = lines.GetCount();
-    if( nLines > 0 )
+    if ( nLines > 0 )
      {
          int l;
          float x = 0.0, y = 0.0;
  
      {
          int l;
          float x = 0.0, y = 0.0;
  
-        if( textOrientation == wxHORIZONTAL )
+        if ( textOrientation == wxHORIZONTAL )
              GetTextBoxSize(dc, lines, &textWidth, &textHeight);
          else
              GetTextBoxSize( dc, lines, &textHeight, &textWidth );
  
              GetTextBoxSize(dc, lines, &textWidth, &textHeight);
          else
              GetTextBoxSize( dc, lines, &textHeight, &textWidth );
  
-        switch( vertAlign )
+        switch ( vertAlign )
          {
          case wxALIGN_BOTTOM:
          {
          case wxALIGN_BOTTOM:
-            if( textOrientation == wxHORIZONTAL )
+            if ( textOrientation == wxHORIZONTAL )
                  y = rect.y + (rect.height - textHeight - 1);
              else
                  x = rect.x + rect.width - textWidth;
              break;
  
          case wxALIGN_CENTRE:
                  y = rect.y + (rect.height - textHeight - 1);
              else
                  x = rect.x + rect.width - textWidth;
              break;
  
          case wxALIGN_CENTRE:
-            if( textOrientation == wxHORIZONTAL )
+            if ( textOrientation == wxHORIZONTAL )
                  y = rect.y + ((rect.height - textHeight)/2);
              else
                  x = rect.x + ((rect.width - textWidth)/2);
                  y = rect.y + ((rect.height - textHeight)/2);
              else
                  x = rect.x + ((rect.width - textWidth)/2);
@@ -7481,7 +7519,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
  
          case wxALIGN_TOP:
          default:
  
          case wxALIGN_TOP:
          default:
-            if( textOrientation == wxHORIZONTAL )
+            if ( textOrientation == wxHORIZONTAL )
                  y = rect.y + 1;
              else
                  x = rect.x + 1;
                  y = rect.y + 1;
              else
                  x = rect.x + 1;
@@ -7489,21 +7527,21 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
          }
  
          // Align each line of a multi-line label
          }
  
          // Align each line of a multi-line label
-        for( l = 0; l < nLines; l++ )
+        for ( l = 0; l < nLines; l++ )
          {
              dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
  
          {
              dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
  
-            switch( horizAlign )
+            switch ( horizAlign )
              {
              case wxALIGN_RIGHT:
              {
              case wxALIGN_RIGHT:
-                if( textOrientation == wxHORIZONTAL )
+                if ( textOrientation == wxHORIZONTAL )
                      x = rect.x + (rect.width - lineWidth - 1);
                  else
                      y = rect.y + lineWidth + 1;
                  break;
  
              case wxALIGN_CENTRE:
                      x = rect.x + (rect.width - lineWidth - 1);
                  else
                      y = rect.y + lineWidth + 1;
                  break;
  
              case wxALIGN_CENTRE:
-                if( textOrientation == wxHORIZONTAL )
+                if ( textOrientation == wxHORIZONTAL )
                      x = rect.x + ((rect.width - lineWidth)/2);
                  else
                      y = rect.y + rect.height - ((rect.height - lineWidth)/2);
                      x = rect.x + ((rect.width - lineWidth)/2);
                  else
                      y = rect.y + rect.height - ((rect.height - lineWidth)/2);
@@ -7511,14 +7549,14 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
  
              case wxALIGN_LEFT:
              default:
  
              case wxALIGN_LEFT:
              default:
-                if( textOrientation == wxHORIZONTAL )
+                if ( textOrientation == wxHORIZONTAL )
                      x = rect.x + 1;
                  else
                      y = rect.y + rect.height - 1;
                  break;
              }
  
                      x = rect.x + 1;
                  else
                      y = rect.y + rect.height - 1;
                  break;
              }
  
-            if( textOrientation == wxHORIZONTAL )
+            if ( textOrientation == wxHORIZONTAL )
              {
                  dc.DrawText( lines[l], (int)x, (int)y );
                  y += lineHeight;
              {
                  dc.DrawText( lines[l], (int)x, (int)y );
                  y += lineHeight;
@@ -7530,6 +7568,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
              }
          }
      }
              }
          }
      }
+
      dc.DestroyClippingRegion();
  }
  
      dc.DestroyClippingRegion();
  }
  
@@ -7559,8 +7598,9 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
          {
              lines.Add( value.Mid(startPos, pos) );
          }
          {
              lines.Add( value.Mid(startPos, pos) );
          }
-        startPos += pos+1;
+        startPos += pos + 1;
      }
      }
+
      if ( startPos < (int)value.Length() )
      {
          lines.Add( value.Mid( startPos ) );
      if ( startPos < (int)value.Length() )
      {
          lines.Add( value.Mid( startPos ) );
@@ -7568,13 +7608,13 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
  }
  
  
  }
  
  
-void wxGrid::GetTextBoxSize( wxDC& dc,
+void wxGrid::GetTextBoxSize( const wxDC& dc,
                               const wxArrayString& lines,
                               long *width, long *height )
  {
      long w = 0;
      long h = 0;
                               const wxArrayString& lines,
                               long *width, long *height )
  {
      long w = 0;
      long h = 0;
-    long lineW, lineH;
+    long lineW = 0, lineH = 0;
  
      size_t i;
      for ( i = 0;  i < lines.GetCount();  i++ )
  
      size_t i;
      for ( i = 0;  i < lines.GetCount();  i++ )
@@ -7628,23 +7668,23 @@ bool wxGrid::Enable(bool enable)
      return true;
  }
  
      return true;
  }
  
+
  //
  // ------ Edit control functions
  //
  
  //
  // ------ Edit control functions
  //
  
-
  void wxGrid::EnableEditing( bool edit )
  {
      // TODO: improve this ?
      //
      if ( edit != m_editable )
      {
  void wxGrid::EnableEditing( bool edit )
  {
      // TODO: improve this ?
      //
      if ( edit != m_editable )
      {
-        if(!edit) EnableCellEditControl(edit);
+        if (!edit)
+            EnableCellEditControl(edit);
          m_editable = edit;
      }
  }
  
          m_editable = edit;
      }
  }
  
-
  void wxGrid::EnableCellEditControl( bool enable )
  {
      if (! m_editable)
  void wxGrid::EnableCellEditControl( bool enable )
  {
      if (! m_editable)
@@ -7810,6 +7850,7 @@ void wxGrid::ShowCellEditControl()
                          NULL, NULL, &attr->GetFont());
                  if (maxWidth < rect.width) maxWidth = rect.width;
              }
                          NULL, NULL, &attr->GetFont());
                  if (maxWidth < rect.width) maxWidth = rect.width;
              }
+
              int client_right = m_gridWin->GetClientSize().GetWidth();
              if (rect.x+maxWidth > client_right)
                  maxWidth = client_right - rect.x;
              int client_right = m_gridWin->GetClientSize().GetWidth();
              if (rect.x+maxWidth > client_right)
                  maxWidth = client_right - rect.x;
@@ -7829,8 +7870,9 @@ void wxGrid::ShowCellEditControl()
                      else
                          break;
                  }
                      else
                          break;
                  }
+
                  if (rect.GetRight() > client_right)
                  if (rect.GetRight() > client_right)
-                    rect.SetRight(client_right-1);
+                    rect.SetRight(client_right - 1);
              }
  
              editor->SetCellAttr(attr);
              }
  
              editor->SetCellAttr(attr);
@@ -7850,7 +7892,6 @@ void wxGrid::ShowCellEditControl()
      }
  }
  
      }
  }
  
-
  void wxGrid::HideCellEditControl()
  {
      if ( IsCellEditControlEnabled() )
  void wxGrid::HideCellEditControl()
  {
      if ( IsCellEditControlEnabled() )
@@ -7864,11 +7905,7 @@ void wxGrid::HideCellEditControl()
          editor->DecRef();
          attr->DecRef();
  
          editor->DecRef();
          attr->DecRef();
  
-        // if the focus moved completely outside this application, set it to
-        // ourselves so that it's not "lost" when the user switches back to
-        // this app
-        if ( !FindFocus() )
-            m_gridWin->SetFocus();
+        m_gridWin->SetFocus();
  
          // refresh whole row to the right
          wxRect rect( CellToRect(row, col) );
  
          // refresh whole row to the right
          wxRect rect( CellToRect(row, col) );
@@ -7876,13 +7913,12 @@ void wxGrid::HideCellEditControl()
          rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
  #ifdef __WXMAC__
          // ensure that the pixels under the focus ring get refreshed as well
          rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
  #ifdef __WXMAC__
          // ensure that the pixels under the focus ring get refreshed as well
-        rect.Inflate(10,10);
+        rect.Inflate(10, 10);
  #endif
          m_gridWin->Refresh( false, &rect );
      }
  }
  
  #endif
          m_gridWin->Refresh( false, &rect );
      }
  }
  
-
  void wxGrid::SaveEditControlValue()
  {
      if ( IsCellEditControlEnabled() )
  void wxGrid::SaveEditControlValue()
  {
      if ( IsCellEditControlEnabled() )
@@ -7890,7 +7926,7 @@ void wxGrid::SaveEditControlValue()
          int row = m_currentCellCoords.GetRow();
          int col = m_currentCellCoords.GetCol();
  
          int row = m_currentCellCoords.GetRow();
          int col = m_currentCellCoords.GetCol();
  
-        wxString oldval = GetCellValue(row,col);
+        wxString oldval = GetCellValue(row, col);
  
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
  
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
@@ -7903,10 +7939,10 @@ void wxGrid::SaveEditControlValue()
          {
              if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
                         m_currentCellCoords.GetRow(),
          {
              if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
                         m_currentCellCoords.GetRow(),
-                       m_currentCellCoords.GetCol() ) < 0 ) {
-
+                       m_currentCellCoords.GetCol() ) < 0 )
+            {
                  // Event has been vetoed, set the data back.
                  // Event has been vetoed, set the data back.
-                SetCellValue(row,col,oldval);
+                SetCellValue(row, col, oldval);
              }
          }
      }
              }
          }
      }
@@ -7945,11 +7981,9 @@ static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
                             const wxArrayInt& BorderArray, int nMax,
                             bool clipToMinMax)
  {
                             const wxArrayInt& BorderArray, int nMax,
                             bool clipToMinMax)
  {
-
      if (coord < 0)
          return clipToMinMax && (nMax > 0) ? 0 : -1;
  
      if (coord < 0)
          return clipToMinMax && (nMax > 0) ? 0 : -1;
  
-
      if (!defaultDist)
          defaultDist = 1;
  
      if (!defaultDist)
          defaultDist = 1;
  
@@ -7958,7 +7992,7 @@ static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
  
      if (BorderArray.IsEmpty())
      {
  
      if (BorderArray.IsEmpty())
      {
-        if((int) i_max < nMax)
+        if ((int) i_max < nMax)
              return i_max;
          return clipToMinMax ? nMax - 1 : -1;
      }
              return i_max;
          return clipToMinMax ? nMax - 1 : -1;
      }
@@ -7975,9 +8009,11 @@ static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
              else
                  i_max =  BorderArray.GetCount() - 1;
          }
              else
                  i_max =  BorderArray.GetCount() - 1;
          }
+
          if ( i_max >= BorderArray.GetCount())
              i_max = BorderArray.GetCount() - 1;
      }
          if ( i_max >= BorderArray.GetCount())
              i_max = BorderArray.GetCount() - 1;
      }
+
      if ( coord >= BorderArray[i_max])
          return clipToMinMax ? (int)i_max : -1;
      if ( coord < BorderArray[0] )
      if ( coord >= BorderArray[i_max])
          return clipToMinMax ? (int)i_max : -1;
      if ( coord < BorderArray[0] )
@@ -7997,6 +8033,7 @@ static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
          else
              i_min = median;
      }
          else
              i_min = median;
      }
+
      return i_max;
  }
  
      return i_max;
  }
  
@@ -8006,14 +8043,12 @@ int wxGrid::YToRow( int y )
                             m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
  }
  
                             m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
  }
  
-
  int wxGrid::XToCol( int x )
  {
      return CoordToRowOrCol(x, m_defaultColWidth,
                             m_minAcceptableColWidth, m_colRights, m_numCols, false);
  }
  
  int wxGrid::XToCol( int x )
  {
      return CoordToRowOrCol(x, m_defaultColWidth,
                             m_minAcceptableColWidth, m_colRights, m_numCols, false);
  }
  
-
  // return the row number that that the y coord is near the edge of, or
  // -1 if not near an edge
  //
  // return the row number that that the y coord is near the edge of, or
  // -1 if not near an edge
  //
@@ -8028,14 +8063,13 @@ int wxGrid::YToEdgeOfRow( int y )
          // close enough to lower or upper border, respectively.
          if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
              return i;
          // close enough to lower or upper border, respectively.
          if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
              return i;
-        else if( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
+        else if ( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
              return i - 1;
      }
  
      return -1;
  }
  
              return i - 1;
      }
  
      return -1;
  }
  
-
  // return the col number that that the x coord is near the edge of, or
  // -1 if not near an edge
  //
  // return the col number that that the x coord is near the edge of, or
  // -1 if not near an edge
  //
@@ -8050,14 +8084,13 @@ int wxGrid::XToEdgeOfCol( int x )
          // close enough to right or left border, respectively.
          if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
              return i;
          // close enough to right or left border, respectively.
          if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
              return i;
-        else if( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
+        else if ( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
              return i - 1;
      }
  
      return -1;
  }
  
              return i - 1;
      }
  
      return -1;
  }
  
-
  wxRect wxGrid::CellToRect( int row, int col )
  {
      wxRect rect( -1, -1, -1, -1 );
  wxRect wxGrid::CellToRect( int row, int col )
  {
      wxRect rect( -1, -1, -1, -1 );
@@ -8082,14 +8115,15 @@ wxRect wxGrid::CellToRect( int row, int col )
      }
  
      // if grid lines are enabled, then the area of the cell is a bit smaller
      }
  
      // if grid lines are enabled, then the area of the cell is a bit smaller
-    if (m_gridLinesEnabled) {
+    if (m_gridLinesEnabled)
+    {
          rect.width -= 1;
          rect.height -= 1;
      }
          rect.width -= 1;
          rect.height -= 1;
      }
+
      return rect;
  }
  
      return rect;
  }
  
-
  bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
  {
      // get the cell rectangle in logical coords
  bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
  {
      // get the cell rectangle in logical coords
@@ -8123,13 +8157,11 @@ bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
      }
  }
  
      }
  }
  
-
  // make the specified cell location visible by doing a minimal amount
  // of scrolling
  //
  void wxGrid::MakeCellVisible( int row, int col )
  {
  // make the specified cell location visible by doing a minimal amount
  // of scrolling
  //
  void wxGrid::MakeCellVisible( int row, int col )
  {
-
      int i;
      int xpos = -1, ypos = -1;
  
      int i;
      int xpos = -1, ypos = -1;
  
@@ -8227,14 +8259,15 @@ bool wxGrid::MoveCursorUp( bool expandSelection )
          }
          else if ( m_currentCellCoords.GetRow() > 0 )
          {
          }
          else if ( m_currentCellCoords.GetRow() > 0 )
          {
+            int row = m_currentCellCoords.GetRow() - 1;
+            int col = m_currentCellCoords.GetCol();
              ClearSelection();
              ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow() - 1,
-                             m_currentCellCoords.GetCol() );
-            SetCurrentCell( m_currentCellCoords.GetRow() - 1,
-                            m_currentCellCoords.GetCol() );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
          }
          else
              return false;
          }
          else
              return false;
+
          return true;
      }
  
          return true;
      }
  
@@ -8261,21 +8294,21 @@ bool wxGrid::MoveCursorDown( bool expandSelection )
          }
          else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
          {
          }
          else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
          {
+            int row = m_currentCellCoords.GetRow() + 1;
+            int col = m_currentCellCoords.GetCol();
              ClearSelection();
              ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow() + 1,
-                             m_currentCellCoords.GetCol() );
-            SetCurrentCell( m_currentCellCoords.GetRow() + 1,
-                            m_currentCellCoords.GetCol() );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
          }
          else
              return false;
          }
          else
              return false;
+
          return true;
      }
  
      return false;
  }
  
          return true;
      }
  
      return false;
  }
  
-
  bool wxGrid::MoveCursorLeft( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
  bool wxGrid::MoveCursorLeft( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
@@ -8295,21 +8328,21 @@ bool wxGrid::MoveCursorLeft( bool expandSelection )
          }
          else if ( m_currentCellCoords.GetCol() > 0 )
          {
          }
          else if ( m_currentCellCoords.GetCol() > 0 )
          {
+            int row = m_currentCellCoords.GetRow();
+            int col = m_currentCellCoords.GetCol() - 1;
              ClearSelection();
              ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow(),
-                             m_currentCellCoords.GetCol() - 1 );
-            SetCurrentCell( m_currentCellCoords.GetRow(),
-                            m_currentCellCoords.GetCol() - 1 );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
          }
          else
              return false;
          }
          else
              return false;
+
          return true;
      }
  
      return false;
  }
  
          return true;
      }
  
      return false;
  }
  
-
  bool wxGrid::MoveCursorRight( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
  bool wxGrid::MoveCursorRight( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
@@ -8329,24 +8362,25 @@ bool wxGrid::MoveCursorRight( bool expandSelection )
          }
          else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
          {
          }
          else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
          {
+            int row = m_currentCellCoords.GetRow();
+            int col = m_currentCellCoords.GetCol() + 1;
              ClearSelection();
              ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow(),
-                             m_currentCellCoords.GetCol() + 1 );
-            SetCurrentCell( m_currentCellCoords.GetRow(),
-                            m_currentCellCoords.GetCol() + 1 );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
          }
          else
              return false;
          }
          else
              return false;
+
          return true;
      }
  
      return false;
  }
  
          return true;
      }
  
      return false;
  }
  
-
  bool wxGrid::MovePageUp()
  {
  bool wxGrid::MovePageUp()
  {
-    if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
+    if ( m_currentCellCoords == wxGridNoCellCoords )
+        return false;
  
      int row = m_currentCellCoords.GetRow();
      if ( row > 0 )
  
      int row = m_currentCellCoords.GetRow();
      if ( row > 0 )
@@ -8374,7 +8408,8 @@ bool wxGrid::MovePageUp()
  
  bool wxGrid::MovePageDown()
  {
  
  bool wxGrid::MovePageDown()
  {
-    if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
+    if ( m_currentCellCoords == wxGridNoCellCoords )
+        return false;
  
      int row = m_currentCellCoords.GetRow();
      if ( (row+1) < m_numRows )
  
      int row = m_currentCellCoords.GetRow();
      if ( (row+1) < m_numRows )
@@ -8416,7 +8451,8 @@ bool wxGrid::MoveCursorUpBlock( bool expandSelection )
              while ( row > 0 )
              {
                  row-- ;
              while ( row > 0 )
              {
                  row-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else if ( m_table->IsEmptyCell(row-1, col) )
              }
          }
          else if ( m_table->IsEmptyCell(row-1, col) )
@@ -8427,7 +8463,8 @@ bool wxGrid::MoveCursorUpBlock( bool expandSelection )
              while ( row > 0 )
              {
                  row-- ;
              while ( row > 0 )
              {
                  row-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else
              }
          }
          else
@@ -8456,6 +8493,7 @@ bool wxGrid::MoveCursorUpBlock( bool expandSelection )
              ClearSelection();
              SetCurrentCell( row, col );
          }
              ClearSelection();
              SetCurrentCell( row, col );
          }
+
          return true;
      }
  
          return true;
      }
  
@@ -8479,7 +8517,8 @@ bool wxGrid::MoveCursorDownBlock( bool expandSelection )
              while ( row < m_numRows-1 )
              {
                  row++ ;
              while ( row < m_numRows-1 )
              {
                  row++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else if ( m_table->IsEmptyCell(row+1, col) )
              }
          }
          else if ( m_table->IsEmptyCell(row+1, col) )
@@ -8490,7 +8529,8 @@ bool wxGrid::MoveCursorDownBlock( bool expandSelection )
              while ( row < m_numRows-1 )
              {
                  row++ ;
              while ( row < m_numRows-1 )
              {
                  row++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else
              }
          }
          else
@@ -8543,7 +8583,8 @@ bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
              while ( col > 0 )
              {
                  col-- ;
              while ( col > 0 )
              {
                  col-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else if ( m_table->IsEmptyCell(row, col-1) )
              }
          }
          else if ( m_table->IsEmptyCell(row, col-1) )
@@ -8554,7 +8595,8 @@ bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
              while ( col > 0 )
              {
                  col-- ;
              while ( col > 0 )
              {
                  col-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else
              }
          }
          else
@@ -8607,7 +8649,8 @@ bool wxGrid::MoveCursorRightBlock( bool expandSelection )
              while ( col < m_numCols-1 )
              {
                  col++ ;
              while ( col < m_numCols-1 )
              {
                  col++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else if ( m_table->IsEmptyCell(row, col+1) )
              }
          }
          else if ( m_table->IsEmptyCell(row, col+1) )
@@ -8618,7 +8661,8 @@ bool wxGrid::MoveCursorRightBlock( bool expandSelection )
              while ( col < m_numCols-1 )
              {
                  col++ ;
              while ( col < m_numCols-1 )
              {
                  col++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                if ( !(m_table->IsEmptyCell(row, col)) )
+                    break;
              }
          }
          else
              }
          }
          else
@@ -8868,7 +8912,7 @@ void wxGrid::SetColLabelAlignment( int horiz, int vert )
  //
  void wxGrid::SetColLabelTextOrientation( int textOrientation )
  {
  //
  void wxGrid::SetColLabelTextOrientation( int textOrientation )
  {
-    if( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
+    if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
      {
          m_colLabelTextOrientation = textOrientation;
      }
      {
          m_colLabelTextOrientation = textOrientation;
      }
@@ -8946,7 +8990,8 @@ void wxGrid::SetCellHighlightColour( const wxColour& colour )
  
  void wxGrid::SetCellHighlightPenWidth(int width)
  {
  
  void wxGrid::SetCellHighlightPenWidth(int width)
  {
-    if (m_cellHighlightPenWidth != width) {
+    if (m_cellHighlightPenWidth != width)
+    {
          m_cellHighlightPenWidth = width;
  
          // Just redrawing the cell highlight is not enough since that won't
          m_cellHighlightPenWidth = width;
  
          // Just redrawing the cell highlight is not enough since that won't
@@ -8962,7 +9007,8 @@ void wxGrid::SetCellHighlightPenWidth(int width)
  
  void wxGrid::SetCellHighlightROPenWidth(int width)
  {
  
  void wxGrid::SetCellHighlightROPenWidth(int width)
  {
-    if (m_cellHighlightROPenWidth != width) {
+    if (m_cellHighlightROPenWidth != width)
+    {
          m_cellHighlightROPenWidth = width;
  
          // Just redrawing the cell highlight is not enough since that won't
          m_cellHighlightROPenWidth = width;
  
          // Just redrawing the cell highlight is not enough since that won't
@@ -9116,7 +9162,7 @@ wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
  
  wxGridCellEditor *wxGrid::GetDefaultEditor() const
  {
  
  wxGridCellEditor *wxGrid::GetDefaultEditor() const
  {
-    return m_defaultCellAttr->GetEditor(NULL,0,0);
+    return m_defaultCellAttr->GetEditor(NULL, 0, 0);
  }
  
  // ----------------------------------------------------------------------------
  }
  
  // ----------------------------------------------------------------------------
@@ -9159,6 +9205,7 @@ bool wxGrid::GetCellOverflow( int row, int col )
      wxGridCellAttr *attr = GetCellAttr(row, col);
      bool allow = attr->GetOverflow();
      attr->DecRef();
      wxGridCellAttr *attr = GetCellAttr(row, col);
      bool allow = attr->GetOverflow();
      attr->DecRef();
+
      return allow;
  }
  
      return allow;
  }
  
@@ -9192,6 +9239,7 @@ bool wxGrid::IsReadOnly(int row, int col) const
      wxGridCellAttr* attr = GetCellAttr(row, col);
      bool isReadOnly = attr->IsReadOnly();
      attr->DecRef();
      wxGridCellAttr* attr = GetCellAttr(row, col);
      bool isReadOnly = attr->IsReadOnly();
      attr->DecRef();
+
      return isReadOnly;
  }
  
      return isReadOnly;
  }
  
@@ -9251,6 +9299,7 @@ bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
  #ifdef DEBUG_ATTR_CACHE
          gs_nAttrCacheMisses++;
  #endif
  #ifdef DEBUG_ATTR_CACHE
          gs_nAttrCacheMisses++;
  #endif
+
          return false;
      }
  }
          return false;
      }
  }
@@ -9269,6 +9318,7 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
              CacheAttr(row, col, attr);
          }
      }
              CacheAttr(row, col, attr);
          }
      }
+
      if (attr)
      {
          attr->SetDefAttr(m_defaultCellAttr);
      if (attr)
      {
          attr->SetDefAttr(m_defaultCellAttr);
@@ -9331,7 +9381,7 @@ void wxGrid::SetColFormatFloat(int col, int width, int precision)
  void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
  {
      wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
  void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
  {
      wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
-    if(!attr)
+    if (!attr)
          attr = new wxGridCellAttr;
      wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
      attr->SetRenderer(renderer);
          attr = new wxGridCellAttr;
      wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
      attr->SetRenderer(renderer);
@@ -9552,7 +9602,10 @@ wxGrid::GetDefaultEditorForType(const wxString& typeName) const
      int index = m_typeRegistry->FindOrCloneDataType(typeName);
      if ( index == wxNOT_FOUND )
      {
      int index = m_typeRegistry->FindOrCloneDataType(typeName);
      if ( index == wxNOT_FOUND )
      {
-        wxFAIL_MSG(wxT("Unknown data type name"));
+    wxString errStr;
+
+        errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
+        wxFAIL_MSG(errStr.c_str());
  
          return NULL;
      }
  
          return NULL;
      }
@@ -9566,7 +9619,10 @@ wxGrid::GetDefaultRendererForType(const wxString& typeName) const
      int index = m_typeRegistry->FindOrCloneDataType(typeName);
      if ( index == wxNOT_FOUND )
      {
      int index = m_typeRegistry->FindOrCloneDataType(typeName);
      if ( index == wxNOT_FOUND )
      {
-        wxFAIL_MSG(wxT("Unknown data type name"));
+    wxString errStr;
+
+        errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
+        wxFAIL_MSG(errStr.c_str());
  
          return NULL;
      }
  
          return NULL;
      }
@@ -9574,7 +9630,6 @@ wxGrid::GetDefaultRendererForType(const wxString& typeName) const
      return m_typeRegistry->GetRenderer(index);
  }
  
      return m_typeRegistry->GetRenderer(index);
  }
  
-
  // ----------------------------------------------------------------------------
  // row/col size
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // row/col size
  // ----------------------------------------------------------------------------
@@ -9584,7 +9639,6 @@ void wxGrid::EnableDragRowSize( bool enable )
      m_canDragRowSize = enable;
  }
  
      m_canDragRowSize = enable;
  }
  
-
  void wxGrid::EnableDragColSize( bool enable )
  {
      m_canDragColSize = enable;
  void wxGrid::EnableDragColSize( bool enable )
  {
      m_canDragColSize = enable;
@@ -9622,7 +9676,8 @@ void wxGrid::SetRowSize( int row, int height )
      wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
  
      // See comment in SetColSize
      wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
  
      // See comment in SetColSize
-    if ( height < GetRowMinimalAcceptableHeight()) { return; }
+    if ( height < GetRowMinimalAcceptableHeight())
+        return;
  
      if ( m_rowHeights.IsEmpty() )
      {
  
      if ( m_rowHeights.IsEmpty() )
      {
@@ -9672,7 +9727,8 @@ void wxGrid::SetColSize( int col, int width )
      //
      // This test then fixes sf.net bug #645734
  
      //
      // This test then fixes sf.net bug #645734
  
-    if ( width < GetColMinimalAcceptableWidth()) { return; }
+    if ( width < GetColMinimalAcceptableWidth() )
+        return;
  
      if ( m_colWidths.IsEmpty() )
      {
  
      if ( m_colWidths.IsEmpty() )
      {
@@ -9681,7 +9737,7 @@ void wxGrid::SetColSize( int col, int width )
      }
  
      // if < 0 calc new width from label
      }
  
      // if < 0 calc new width from label
-    if( width < 0 )
+    if ( width < 0 )
      {
        long w, h;
        wxArrayString lines;
      {
        long w, h;
        wxArrayString lines;
@@ -9691,6 +9747,7 @@ void wxGrid::SetColSize( int col, int width )
        GetTextBoxSize(dc, lines, &w, &h);
        width = w + 6;
      }
        GetTextBoxSize(dc, lines, &w, &h);
        width = w + 6;
      }
+
      int w = wxMax( 0, width );
      int diff = w - m_colWidths[col];
      m_colWidths[col] = w;
      int w = wxMax( 0, width );
      int diff = w - m_colWidths[col];
      m_colWidths[col] = w;
@@ -9700,14 +9757,15 @@ void wxGrid::SetColSize( int col, int width )
      {
          m_colRights[i] += diff;
      }
      {
          m_colRights[i] += diff;
      }
+
      if ( !GetBatchCount() )
          CalcDimensions();
  }
  
      if ( !GetBatchCount() )
          CalcDimensions();
  }
  
-
  void wxGrid::SetColMinimalWidth( int col, int width )
  {
  void wxGrid::SetColMinimalWidth( int col, int width )
  {
-    if (width > GetColMinimalAcceptableWidth()) {
+    if (width > GetColMinimalAcceptableWidth())
+    {
          wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
          m_colMinWidths[key] = width;
      }
          wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
          m_colMinWidths[key] = width;
      }
@@ -9715,7 +9773,8 @@ void wxGrid::SetColMinimalWidth( int col, int width )
  
  void wxGrid::SetRowMinimalHeight( int row, int width )
  {
  
  void wxGrid::SetRowMinimalHeight( int row, int width )
  {
-    if (width > GetRowMinimalAcceptableHeight()) {
+    if (width > GetRowMinimalAcceptableHeight())
+    {
          wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
          m_rowMinHeights[key] = width;
      }
          wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
          m_rowMinHeights[key] = width;
      }
@@ -9725,6 +9784,7 @@ int wxGrid::GetColMinimalWidth(int col) const
  {
      wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
      wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
  {
      wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
      wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
+
      return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
  }
  
      return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
  }
  
@@ -9732,26 +9792,25 @@ int wxGrid::GetRowMinimalHeight(int row) const
  {
      wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
      wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
  {
      wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
      wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
+
      return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
  }
  
  void wxGrid::SetColMinimalAcceptableWidth( int width )
  {
      // We do allow a width of 0 since this gives us
      return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
  }
  
  void wxGrid::SetColMinimalAcceptableWidth( int width )
  {
      // We do allow a width of 0 since this gives us
-    // an easy way to temporarily hidding columns.
-    if ( width<0 )
-        return;
-    m_minAcceptableColWidth = width;
+    // an easy way to temporarily hiding columns.
+    if ( width >= 0 )
+        m_minAcceptableColWidth = width;
  }
  
  void wxGrid::SetRowMinimalAcceptableHeight( int height )
  {
      // We do allow a height of 0 since this gives us
  }
  
  void wxGrid::SetRowMinimalAcceptableHeight( int height )
  {
      // We do allow a height of 0 since this gives us
-    // an easy way to temporarily hidding rows.
-    if ( height<0 )
-        return;
-    m_minAcceptableRowHeight = height;
-};
+    // an easy way to temporarily hiding rows.
+    if ( height >= 0 )
+        m_minAcceptableRowHeight = height;
+}
  
  int  wxGrid::GetColMinimalAcceptableWidth() const
  {
  
  int  wxGrid::GetColMinimalAcceptableWidth() const
  {
@@ -9771,11 +9830,11 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
  {
      wxClientDC dc(m_gridWin);
  
  {
      wxClientDC dc(m_gridWin);
  
-    //Cancel editting of cell
+    // cancel editing of cell
      HideCellEditControl();
      SaveEditControlValue();
  
      HideCellEditControl();
      SaveEditControlValue();
  
-    // init both of them to avoid compiler warnings, even if weo nly need one
+    // init both of them to avoid compiler warnings, even if we only need one
      int row = -1,
          col = -1;
      if ( column )
      int row = -1,
          col = -1;
      if ( column )
@@ -9816,7 +9875,7 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
      if ( column )
      {
          dc.GetTextExtent( GetColLabelValue(col), &w, &h );
      if ( column )
      {
          dc.GetTextExtent( GetColLabelValue(col), &w, &h );
-        if( GetColLabelTextOrientation() == wxVERTICAL )
+        if ( GetColLabelTextOrientation() == wxVERTICAL )
              w = h;
      }
      else
              w = h;
      }
      else
@@ -9837,19 +9896,15 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
      else
      {
          if ( column )
      else
      {
          if ( column )
-        {
              // leave some space around text
              extentMax += 10;
              // leave some space around text
              extentMax += 10;
-        }
          else
          else
-        {
              extentMax += 6;
              extentMax += 6;
-        }
      }
  
      if ( column )
      {
      }
  
      if ( column )
      {
-        SetColSize(col, extentMax);
+        SetColSize( col, extentMax );
          if ( !GetBatchCount() )
          {
              int cw, ch, dummy;
          if ( !GetBatchCount() )
          {
              int cw, ch, dummy;
@@ -9919,9 +9974,7 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
      for ( int row = 0; row < m_numRows; row++ )
      {
          if ( !calcOnly )
      for ( int row = 0; row < m_numRows; row++ )
      {
          if ( !calcOnly )
-        {
              AutoSizeRow(row, setAsMin);
              AutoSizeRow(row, setAsMin);
-        }
  
          height += GetRowHeight(row);
      }
  
          height += GetRowHeight(row);
      }
@@ -10009,8 +10062,8 @@ void wxGrid::AutoSizeRowLabelSize( int row )
      long w, h;
  
      // Hide the edit control, so it
      long w, h;
  
      // Hide the edit control, so it
-    // won't interfer with drag-shrinking.
-    if( IsCellEditControlShown() )
+    // won't interfere with drag-shrinking.
+    if ( IsCellEditControlShown() )
      {
          HideCellEditControl();
          SaveEditControlValue();
      {
          HideCellEditControl();
          SaveEditControlValue();
@@ -10020,7 +10073,7 @@ void wxGrid::AutoSizeRowLabelSize( int row )
      StringToLines( GetRowLabelValue( row ), lines );
      wxClientDC dc( m_rowLabelWin );
      GetTextBoxSize( dc, lines, &w, &h);
      StringToLines( GetRowLabelValue( row ), lines );
      wxClientDC dc( m_rowLabelWin );
      GetTextBoxSize( dc, lines, &w, &h);
-    if( h < m_defaultRowHeight )
+    if ( h < m_defaultRowHeight )
          h = m_defaultRowHeight;
      SetRowSize(row, h);
      ForceRefresh();
          h = m_defaultRowHeight;
      SetRowSize(row, h);
      ForceRefresh();
@@ -10033,7 +10086,7 @@ void wxGrid::AutoSizeColLabelSize( int col )
  
      // Hide the edit control, so it
      // won't interfer with drag-shrinking.
  
      // Hide the edit control, so it
      // won't interfer with drag-shrinking.
-    if( IsCellEditControlShown() )
+    if ( IsCellEditControlShown() )
      {
          HideCellEditControl();
          SaveEditControlValue();
      {
          HideCellEditControl();
          SaveEditControlValue();
@@ -10042,11 +10095,11 @@ void wxGrid::AutoSizeColLabelSize( int col )
      // autosize column width depending on label text
      StringToLines( GetColLabelValue( col ), lines );
      wxClientDC dc( m_colLabelWin );
      // autosize column width depending on label text
      StringToLines( GetColLabelValue( col ), lines );
      wxClientDC dc( m_colLabelWin );
-    if( GetColLabelTextOrientation() == wxHORIZONTAL )
+    if ( GetColLabelTextOrientation() == wxHORIZONTAL )
          GetTextBoxSize( dc, lines, &w, &h);
      else
          GetTextBoxSize( dc, lines, &h, &w);
          GetTextBoxSize( dc, lines, &w, &h);
      else
          GetTextBoxSize( dc, lines, &h, &w);
-    if( w < m_defaultColWidth )
+    if ( w < m_defaultColWidth )
          w = m_defaultColWidth;
      SetColSize(col, w);
      ForceRefresh();
          w = m_defaultColWidth;
      SetColSize(col, w);
      ForceRefresh();
@@ -10061,11 +10114,14 @@ wxSize wxGrid::DoGetBestSize() const
      width = self->SetOrCalcColumnSizes(true);
      height = self->SetOrCalcRowSizes(true);
  
      width = self->SetOrCalcColumnSizes(true);
      height = self->SetOrCalcRowSizes(true);
  
-    if (!width) width=100;
-    if (!height) height=80;
+    if (!width)
+        width = 100;
+    if (!height)
+        height = 80;
  
  
-    // Round up to a multiple the scroll rate NOTE: this still doesn't get rid
-    // of the scrollbars, is there any magic incantaion for that?
+    // Round up to a multiple the scroll rate
+    // NOTE: this still doesn't get rid  of the scrollbars;
+    // is there any magic incantation for that?
      int xpu, ypu;
      GetScrollPixelsPerUnit(&xpu, &ypu);
      if (xpu)
      int xpu, ypu;
      GetScrollPixelsPerUnit(&xpu, &ypu);
      if (xpu)
@@ -10075,18 +10131,21 @@ wxSize wxGrid::DoGetBestSize() const
  
      // limit to 1/4 of the screen size
      int maxwidth, maxheight;
  
      // limit to 1/4 of the screen size
      int maxwidth, maxheight;
-    wxDisplaySize( & maxwidth, & maxheight );
+    wxDisplaySize( &maxwidth, &maxheight );
      maxwidth /= 2;
      maxheight /= 2;
      maxwidth /= 2;
      maxheight /= 2;
-    if ( width > maxwidth ) width = maxwidth;
-    if ( height > maxheight ) height = maxheight;
-
+    if ( width > maxwidth )
+        width = maxwidth;
+    if ( height > maxheight )
+        height = maxheight;
  
      wxSize best(width, height);
  
      wxSize best(width, height);
+
      // NOTE: This size should be cached, but first we need to add calls to
      // InvalidateBestSize everywhere that could change the results of this
      // calculation.
      // CacheBestSize(size);
      // NOTE: This size should be cached, but first we need to add calls to
      // InvalidateBestSize everywhere that could change the results of this
      // calculation.
      // CacheBestSize(size);
+
      return best;
  }
  
      return best;
  }
  
@@ -10095,7 +10154,6 @@ void wxGrid::Fit()
      AutoSize();
  }
  
      AutoSize();
  }
  
-
  wxPen& wxGrid::GetDividerPen() const
  {
      return wxNullPen;
  wxPen& wxGrid::GetDividerPen() const
  {
      return wxNullPen;
@@ -10134,9 +10192,9 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
  }
  
  
  }
  
  
-//
-// ------ Block, row and col selection
-//
+// ----------------------------------------------------------------------------
+// block, row and col selection
+// ----------------------------------------------------------------------------
  
  void wxGrid::SelectRow( int row, bool addToSelected )
  {
  
  void wxGrid::SelectRow( int row, bool addToSelected )
  {
@@ -10147,7 +10205,6 @@ void wxGrid::SelectRow( int row, bool addToSelected )
          m_selection->SelectRow( row, false, addToSelected );
  }
  
          m_selection->SelectRow( row, false, addToSelected );
  }
  
-
  void wxGrid::SelectCol( int col, bool addToSelected )
  {
      if ( IsSelection() && !addToSelected )
  void wxGrid::SelectCol( int col, bool addToSelected )
  {
      if ( IsSelection() && !addToSelected )
@@ -10157,7 +10214,6 @@ void wxGrid::SelectCol( int col, bool addToSelected )
          m_selection->SelectCol( col, false, addToSelected );
  }
  
          m_selection->SelectCol( col, false, addToSelected );
  }
  
-
  void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
                            bool addToSelected )
  {
  void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
                            bool addToSelected )
  {
@@ -10169,7 +10225,6 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
                                    false, addToSelected );
  }
  
                                    false, addToSelected );
  }
  
-
  void wxGrid::SelectAll()
  {
      if ( m_numRows > 0 && m_numCols > 0 )
  void wxGrid::SelectAll()
  {
      if ( m_numRows > 0 && m_numCols > 0 )
@@ -10179,9 +10234,9 @@ void wxGrid::SelectAll()
      }
  }
  
      }
  }
  
-//
-// ------ Cell, row and col deselection
-//
+// ----------------------------------------------------------------------------
+// cell, row and col deselection
+// ----------------------------------------------------------------------------
  
  void wxGrid::DeselectRow( int row )
  {
  
  void wxGrid::DeselectRow( int row )
  {
@@ -10249,31 +10304,59 @@ bool wxGrid::IsInSelection( int row, int col ) const
  
  wxGridCellCoordsArray wxGrid::GetSelectedCells() const
  {
  
  wxGridCellCoordsArray wxGrid::GetSelectedCells() const
  {
-    if (!m_selection) { wxGridCellCoordsArray a; return a; }
+    if (!m_selection)
+    {
+        wxGridCellCoordsArray a;
+        return a;
+    }
+
      return m_selection->m_cellSelection;
  }
      return m_selection->m_cellSelection;
  }
+
  wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
  {
  wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
  {
-    if (!m_selection) { wxGridCellCoordsArray a; return a; }
+    if (!m_selection)
+    {
+        wxGridCellCoordsArray a;
+        return a;
+    }
+
      return m_selection->m_blockSelectionTopLeft;
  }
      return m_selection->m_blockSelectionTopLeft;
  }
+
  wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
  {
  wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
  {
-    if (!m_selection) { wxGridCellCoordsArray a; return a; }
+    if (!m_selection)
+    {
+        wxGridCellCoordsArray a;
+        return a;
+    }
+
      return m_selection->m_blockSelectionBottomRight;
  }
      return m_selection->m_blockSelectionBottomRight;
  }
+
  wxArrayInt wxGrid::GetSelectedRows() const
  {
  wxArrayInt wxGrid::GetSelectedRows() const
  {
-    if (!m_selection) { wxArrayInt a; return a; }
+    if (!m_selection)
+    {
+        wxArrayInt a;
+        return a;
+    }
+
      return m_selection->m_rowSelection;
  }
      return m_selection->m_rowSelection;
  }
+
  wxArrayInt wxGrid::GetSelectedCols() const
  {
  wxArrayInt wxGrid::GetSelectedCols() const
  {
-    if (!m_selection) { wxArrayInt a; return a; }
+    if (!m_selection)
+    {
+        wxArrayInt a;
+        return a;
+    }
+
      return m_selection->m_colSelection;
  }
  
      return m_selection->m_colSelection;
  }
  
-
  void wxGrid::ClearSelection()
  {
      m_selectingTopLeft = wxGridNoCellCoords;
  void wxGrid::ClearSelection()
  {
      m_selectingTopLeft = wxGridNoCellCoords;
@@ -10299,7 +10382,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
      }
      else
      {
      }
      else
      {
-        rect = wxRect(0,0,0,0);
+        rect = wxRect(0, 0, 0, 0);
      }
  
      cellRect = CellToRect( bottomRight );
      }
  
      cellRect = CellToRect( bottomRight );
@@ -10329,7 +10412,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
          left = right;
          right = i;
          i = leftCol;
          left = right;
          right = i;
          i = leftCol;
-        leftCol=rightCol;
+        leftCol = rightCol;
          rightCol = i;
      }
  
          rightCol = i;
      }
  
@@ -10343,12 +10426,11 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
          bottomRow = i;
      }
  
          bottomRow = i;
      }
  
-
      for ( j = topRow; j <= bottomRow; j++ )
      {
          for ( i = leftCol; i <= rightCol; i++ )
          {
      for ( j = topRow; j <= bottomRow; j++ )
      {
          for ( i = leftCol; i <= rightCol; i++ )
          {
-            if ((j==topRow) || (j==bottomRow) || (i==leftCol) || (i==rightCol))
+            if ((j == topRow) || (j == bottomRow) || (i == leftCol) || (i == rightCol))
              {
                  cellRect = CellToRect( j, i );
  
              {
                  cellRect = CellToRect( j, i );
  
@@ -10361,7 +10443,10 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
                  if (cellRect.y + cellRect.height > bottom)
                      bottom = cellRect.y + cellRect.height;
              }
                  if (cellRect.y + cellRect.height > bottom)
                      bottom = cellRect.y + cellRect.height;
              }
-            else i = rightCol; // jump over inner cells.
+            else
+            {
+                i = rightCol; // jump over inner cells.
+            }
          }
      }
  
          }
      }
  
@@ -10384,9 +10469,9 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
      return rect;
  }
  
      return rect;
  }
  
-//
-// ------ Grid event classes
-//
+// ----------------------------------------------------------------------------
+// grid event classes
+// ----------------------------------------------------------------------------
  
  IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
  
  
  IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )