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 81f8324414746e60a0455b4300e776ca9abf6e9a..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,31 +233,40 @@ private:
 };
 
 
 };
 
 

-

 class wxGridCellEditorEvtHandler : public wxEvtHandler
 {
 public:
 class wxGridCellEditorEvtHandler : public wxEvtHandler
 {
 public:

-    wxGridCellEditorEvtHandler()
-        : m_grid(0), m_editor(0)
-        { }

     wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
     wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)

-        : m_grid(grid), m_editor(editor)
-        { }
+        : m_grid(grid),
+          m_editor(editor),
+          m_inSetFocus(false)
+    {
+    }

 
 

+    void OnKillFocus(wxFocusEvent& event);

     void OnKeyDown(wxKeyEvent& event);
     void OnChar(wxKeyEvent& event);
 
     void OnKeyDown(wxKeyEvent& event);
     void OnChar(wxKeyEvent& event);
 

+    void SetInSetFocus(bool inSetFocus) { m_inSetFocus = inSetFocus; }
+

 private:
     wxGrid*             m_grid;
     wxGridCellEditor*   m_editor;
 private:
     wxGrid*             m_grid;
     wxGridCellEditor*   m_editor;

-    DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
+
+    // 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_EVENT_TABLE()

+    DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)

     DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
 };
 
 
     DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
 };
 
 

-IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
+IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler, wxEvtHandler)
+

 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )

+    EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus )

     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
     EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
 END_EVENT_TABLE()
     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
     EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
 END_EVENT_TABLE()


@@ -568,7 +574,7 @@ bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
     // through in that case.
     if ((ctrl || alt) && !(ctrl && alt))
         return false;
     // through in that case.
     if ((ctrl || alt) && !(ctrl && alt))
         return false;

-    
+

 #if wxUSE_UNICODE
     int key = event.GetUnicodeKey();
     bool keyOk = true;
 #if wxUSE_UNICODE
     int key = event.GetUnicodeKey();
     bool keyOk = true;


@@ -585,7 +591,7 @@ bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
     return keyOk;
 #else // !wxUSE_UNICODE
     int key = event.GetKeyCode();
     return keyOk;
 #else // !wxUSE_UNICODE
     int key = event.GetKeyCode();

-    if (key <= 255) 
+    if (key <= 255)

         return true;
     return false;
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
         return true;
     return false;
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE


@@ -749,7 +755,7 @@ void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
     wxTextCtrl* tc = Text();
     wxChar ch;
     long pos;
     wxTextCtrl* tc = Text();
     wxChar ch;
     long pos;

-    
+

 #if wxUSE_UNICODE
     ch = event.GetUnicodeKey();
     if (ch <= 127)
 #if wxUSE_UNICODE
     ch = event.GetUnicodeKey();
     if (ch <= 127)


@@ -956,9 +962,9 @@ bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
 
 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
 {
 
 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
 {

+    int keycode = event.GetKeyCode();

     if ( !HasRange() )
     {
     if ( !HasRange() )
     {

-        int keycode = event.GetKeyCode();

         if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')
         {
             wxGridCellTextEditor::StartingKey(event);
         if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')
         {
             wxGridCellTextEditor::StartingKey(event);


@@ -967,7 +973,18 @@ void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
             return;
         }
     }
             return;
         }
     }

-
+#if wxUSE_SPINCTRL
+    else
+    {
+        if ( wxIsdigit(keycode) )
+        {
+            wxSpinCtrl* spin = (wxSpinCtrl*)m_control;
+            spin->SetValue(keycode - '0');
+            spin->SetSelection(1,1);
+            return;
+        }
+    }
+#endif

     event.Skip();
 }
 
     event.Skip();
 }
 


@@ -1005,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);


@@ -1068,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);


@@ -1092,8 +1110,12 @@ void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
     tmpbuf[0] = (char) keycode;
     tmpbuf[1] = '\0';
     wxString strbuf(tmpbuf, *wxConvCurrent);
     tmpbuf[0] = (char) keycode;
     tmpbuf[1] = '\0';
     wxString strbuf(tmpbuf, *wxConvCurrent);

+#if wxUSE_INTL

     bool is_decimal_point = ( strbuf ==
        wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );
     bool is_decimal_point = ( strbuf ==
        wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );

+#else
+    bool is_decimal_point = ( strbuf == _T(".") );
+#endif

     if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
          || is_decimal_point )
     {
     if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
          || is_decimal_point )
     {


@@ -1166,10 +1188,14 @@ bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
         tmpbuf[0] = (char) keycode;
         tmpbuf[1] = '\0';
         wxString strbuf(tmpbuf, *wxConvCurrent);
         tmpbuf[0] = (char) keycode;
         tmpbuf[1] = '\0';
         wxString strbuf(tmpbuf, *wxConvCurrent);

+#if wxUSE_INTL

         bool is_decimal_point =
             ( strbuf == wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
                                           wxLOCALE_CAT_NUMBER) );
         bool is_decimal_point =
             ( strbuf == wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
                                           wxLOCALE_CAT_NUMBER) );

-        if ( (keycode < 128) && 
+#else
+        bool is_decimal_point = ( strbuf == _T(".") );
+#endif
+        if ( (keycode < 128) &&

              (wxIsdigit(keycode) || tolower(keycode) == 'e' ||
               is_decimal_point || keycode == '+' || keycode == '-') )
             return true;
              (wxIsdigit(keycode) || tolower(keycode) == 'e' ||
               is_decimal_point || keycode == '+' || keycode == '-') )
             return true;


@@ -1353,11 +1379,11 @@ void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)
         case WXK_SPACE:
             CBox()->SetValue(!CBox()->GetValue());
             break;
         case WXK_SPACE:
             CBox()->SetValue(!CBox()->GetValue());
             break;

-            
+

         case '+':
             CBox()->SetValue(true);
             break;
         case '+':
             CBox()->SetValue(true);
             break;

-                
+

         case '-':
             CBox()->SetValue(false);
             break;
         case '-':
             CBox()->SetValue(false);
             break;


@@ -1438,6 +1464,14 @@ void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 

+    wxGridCellEditorEvtHandler* evtHandler = NULL;
+    if (m_control)
+        evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);
+
+    // Don't immediately end if we get a kill focus event within BeginEdit
+    if (evtHandler)
+        evtHandler->SetInSetFocus(true);
+

     m_startValue = grid->GetTable()->GetValue(row, col);
 
     if (m_allowOthers)
     m_startValue = grid->GetTable()->GetValue(row, col);
 
     if (m_allowOthers)


@@ -1446,12 +1480,21 @@ void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
     {
         // find the right position, or default to the first if not found
         int pos = Combo()->FindString(m_startValue);
     {
         // find the right position, or default to the first if not found
         int pos = Combo()->FindString(m_startValue);

-        if (pos == -1)
+        if (pos == wxNOT_FOUND)

             pos = 0;
         Combo()->SetSelection(pos);
     }
     Combo()->SetInsertionPointEnd();
     Combo()->SetFocus();
             pos = 0;
         Combo()->SetSelection(pos);
     }
     Combo()->SetInsertionPointEnd();
     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);
+#endif
+    }

 }
 
 bool wxGridCellChoiceEditor::EndEdit(int row, int col,
 }
 
 bool wxGridCellChoiceEditor::EndEdit(int row, int col,


@@ -1501,6 +1544,18 @@ wxString wxGridCellChoiceEditor::GetValue() const
 // wxGridCellEditorEvtHandler
 // ----------------------------------------------------------------------------
 
 // wxGridCellEditorEvtHandler
 // ----------------------------------------------------------------------------
 

+void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent& event)
+{
+    // Don't disable the cell if we're just starting to edit it
+    if (m_inSetFocus)
+        return;
+
+    // accept changes
+    m_grid->DisableCellEditControl();
+
+    event.Skip();
+}
+

 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 {
     switch ( event.GetKeyCode() )
 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 {
     switch ( event.GetKeyCode() )


@@ -1572,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 )
         {


@@ -1596,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)
 {


@@ -1606,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 )
       {


@@ -1628,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)
 {


@@ -1702,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


@@ -1749,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;


@@ -1815,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();
 


@@ -1920,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());

-        }
-
+            }

         }
     }
 }
         }
     }
 }


@@ -2118,13 +2173,14 @@ 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);
     }

-
-    mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
+    if ( !HasSize() && mergefrom->HasSize() )
+        mergefrom->GetSize( &m_sizeRows, &m_sizeCols );

 
     // Directly access member functions as GetRender/Editor don't just return
     // m_renderer/m_editor
 
     // Directly access member functions as GetRender/Editor don't just return
     // m_renderer/m_editor


@@ -2220,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);


@@ -2233,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


@@ -2411,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--;

                 }
             }
         }
                 }
             }
         }


@@ -2546,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--;

                 }
             }
         }
                 }
             }
         }


@@ -2578,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):


@@ -2755,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 )


@@ -2763,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 )


@@ -2777,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 )


@@ -2785,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;


@@ -2895,6 +2971,7 @@ wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAtt
         return (wxGridCellAttr *)NULL;
 }
 
         return (wxGridCellAttr *)NULL;
 }
 

+

 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
 {
     if ( m_attrProvider )
 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
 {
     if ( m_attrProvider )


@@ -2986,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;


@@ -3008,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...


@@ -3021,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;


@@ -3228,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 )


@@ -3282,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,


@@ -3300,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 )
     {


@@ -3315,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,


@@ -3396,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,


@@ -3468,7 +3549,6 @@ void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
 }
 
 
 }
 
 

-

 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 


@@ -3509,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
 //


@@ -3541,7 +3618,6 @@ void wxGridRowLabelWindow::OnChar( wxKeyEvent& event )
 }
 
 
 }
 
 

-

 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )


@@ -3581,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 );


@@ -3592,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();

 }
 
 
 }
 
 


@@ -3641,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 );


@@ -3649,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 );


@@ -3659,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);


@@ -3717,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 );


@@ -3739,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 );


@@ -3747,9 +3820,11 @@ 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 )
 {
 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
 {

+    if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
+        SetFocus();
+

     m_owner->ProcessGridCellMouseEvent( event );
 }
 
     m_owner->ProcessGridCellMouseEvent( event );
 }
 


@@ -3763,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) )


@@ -4105,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();


@@ -4300,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();


@@ -4314,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();
     }


@@ -4509,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


@@ -4640,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


@@ -4847,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:
                 {


@@ -4871,6 +4952,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                 break;
 
                 case WXGRID_CURSOR_SELECT_ROW:
                 break;
 
                 case WXGRID_CURSOR_SELECT_ROW:

+                {

                     if ( (row = YToRow( y )) >= 0 )
                     {
                         if ( m_selection )
                     if ( (row = YToRow( y )) >= 0 )
                     {
                         if ( m_selection )


@@ -4882,6 +4964,8 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                                                     event.MetaDown() );
                         }
                     }
                                                     event.MetaDown() );
                         }
                     }

+                }
+                break;

 
                 // default label to suppress warnings about "enumeration value
                 // 'xxx' not handled in switch
 
                 // default label to suppress warnings about "enumeration value
                 // 'xxx' not handled in switch


@@ -4965,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);


@@ -5069,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:
                 {


@@ -5093,6 +5177,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                 break;
 
                 case WXGRID_CURSOR_SELECT_COL:
                 break;
 
                 case WXGRID_CURSOR_SELECT_COL:

+                {

                     if ( (col = XToCol( x )) >= 0 )
                     {
                         if ( m_selection )
                     if ( (col = XToCol( x )) >= 0 )
                     {
                         if ( m_selection )


@@ -5104,6 +5189,8 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                                                     event.MetaDown() );
                         }
                     }
                                                     event.MetaDown() );
                         }
                     }

+                }
+                break;

 
                 // default label to suppress warnings about "enumeration value
                 // 'xxx' not handled in switch
 
                 // default label to suppress warnings about "enumeration value
                 // 'xxx' not handled in switch


@@ -5186,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);


@@ -5397,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)
         {


@@ -5414,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();


@@ -5716,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);


@@ -6147,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;
 }
 


@@ -6185,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


@@ -6202,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)
         {


@@ -6217,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;


@@ -6797,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;


@@ -6833,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
         }


@@ -6848,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--)
                 {


@@ -6869,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();


@@ -6880,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;


@@ -6888,6 +6984,7 @@ void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
                 }
             }
         }
                 }
             }
         }

+

         DrawCell( dc, cells[i] );
     }
 
         DrawCell( dc, cells[i] );
     }
 


@@ -6956,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
     {


@@ -6995,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);
     }


@@ -7015,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);


@@ -7099,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;
 


@@ -7138,8 +7242,10 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
     int topRow    = internalYToRow(top);
     int rightCol  = internalXToCol(right);
     int bottomRow = internalYToRow(bottom);
     int topRow    = internalYToRow(top);
     int rightCol  = internalXToCol(right);
     int bottomRow = internalYToRow(bottom);

-    wxRegion clippedcells(0, 0, cw, ch);

 
 

+#ifndef __WXMAC__
+    // CS: I don't know why suddenly unscrolled coordinates are used for clipping
+    wxRegion clippedcells(0, 0, cw, ch);

 
     int i, j, cell_rows, cell_cols;
     wxRect rect;
 
     int i, j, cell_rows, cell_cols;
     wxRect rect;


@@ -7163,6 +7269,30 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
             }
         }
     }
             }
         }
     }

+#else
+    wxRegion clippedcells( left , top, right - left, bottom - top);
+
+    int i, j, cell_rows, cell_cols;
+    wxRect rect;
+
+    for (j=topRow; j<bottomRow; j++)
+    {
+        for (i=leftCol; i<rightCol; i++)
+        {
+            GetCellSize( j, i, &cell_rows, &cell_cols );
+            if ((cell_rows > 1) || (cell_cols > 1))
+            {
+                rect = CellToRect(j,i);
+                clippedcells.Subtract(rect);
+            }
+            else if ((cell_rows < 0) || (cell_cols < 0))
+            {
+                rect = CellToRect(j+cell_rows, i+cell_cols);
+                clippedcells.Subtract(rect);
+            }
+        }
+    }
+#endif

     dc.SetClippingRegion( clippedcells );
 
     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
     dc.SetClippingRegion( clippedcells );
 
     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );


@@ -7185,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++ )


@@ -7204,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();


@@ -7218,14 +7347,13 @@ void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
     }
 }
 
     }
 }
 

-

 void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {
 void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {

-    if ( GetRowHeight(row) <= 0 )
+    if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )

         return;
 
     wxRect rect;
         return;
 
     wxRect rect;

-#ifdef __WXGTK__
+#ifdef __WXGTK20__

     rect.SetX( 1 );
     rect.SetY( GetRowTop(row) + 1 );
     rect.SetWidth( m_rowLabelWidth - 2 );
     rect.SetX( 1 );
     rect.SetY( GetRowTop(row) + 1 );
     rect.SetWidth( m_rowLabelWidth - 2 );


@@ -7266,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();


@@ -7280,16 +7408,15 @@ void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
     }
 }
 
     }
 }
 

-

 void wxGrid::DrawColLabel( wxDC& dc, int col )
 {
 void wxGrid::DrawColLabel( wxDC& dc, int col )
 {

-    if ( GetColWidth(col) <= 0 )
+    if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )

         return;
 
     int colLeft = GetColLeft(col);
 
     wxRect rect;
         return;
 
     int colLeft = GetColLeft(col);
 
     wxRect rect;

-#ifdef __WXGTK__
+#ifdef __WXGTK20__

     rect.SetX( colLeft + 1 );
     rect.SetY( 1 );
     rect.SetWidth( GetColWidth(col) - 2 );
     rect.SetX( colLeft + 1 );
     rect.SetY( 1 );
     rect.SetWidth( GetColWidth(col) - 2 );


@@ -7340,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,


@@ -7358,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);


@@ -7393,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;


@@ -7401,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);


@@ -7423,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;


@@ -7442,6 +7568,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
             }
         }
     }
             }
         }
     }

+

     dc.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 


@@ -7471,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 ) );


@@ -7480,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++ )


@@ -7540,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)


@@ -7722,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;


@@ -7741,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);


@@ -7762,7 +7892,6 @@ void wxGrid::ShowCellEditControl()
     }
 }
 
     }
 }
 

-

 void wxGrid::HideCellEditControl()
 {
     if ( IsCellEditControlEnabled() )
 void wxGrid::HideCellEditControl()
 {
     if ( IsCellEditControlEnabled() )


@@ -7775,16 +7904,21 @@ void wxGrid::HideCellEditControl()
         editor->Show( false );
         editor->DecRef();
         attr->DecRef();
         editor->Show( false );
         editor->DecRef();
         attr->DecRef();

+

         m_gridWin->SetFocus();
         m_gridWin->SetFocus();

+

         // refresh whole row to the right
         wxRect rect( CellToRect(row, col) );
         CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
         rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
         // refresh whole row to the right
         wxRect rect( CellToRect(row, col) );
         CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
         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);
+#endif

         m_gridWin->Refresh( false, &rect );
     }
 }
 
         m_gridWin->Refresh( false, &rect );
     }
 }
 

-

 void wxGrid::SaveEditControlValue()
 {
     if ( IsCellEditControlEnabled() )
 void wxGrid::SaveEditControlValue()
 {
     if ( IsCellEditControlEnabled() )


@@ -7792,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);


@@ -7805,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);

             }
         }
     }
             }
         }
     }


@@ -7847,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;
 


@@ -7860,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;
     }


@@ -7877,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] )


@@ -7899,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;
 }
 


@@ -7908,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
 //


@@ -7930,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
 //


@@ -7952,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 );


@@ -7984,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


@@ -8025,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;
 


@@ -8129,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;
     }
 


@@ -8163,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  &&


@@ -8197,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  &&


@@ -8231,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 )


@@ -8276,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 )


@@ -8318,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) )


@@ -8329,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


@@ -8358,6 +8493,7 @@ bool wxGrid::MoveCursorUpBlock( bool expandSelection )
             ClearSelection();
             SetCurrentCell( row, col );
         }
             ClearSelection();
             SetCurrentCell( row, col );
         }

+

         return true;
     }
 
         return true;
     }
 


@@ -8381,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) )


@@ -8392,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


@@ -8445,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) )


@@ -8456,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


@@ -8509,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) )


@@ -8520,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


@@ -8770,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;
     }


@@ -8848,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


@@ -8864,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


@@ -9018,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);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -9061,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;
 }
 


@@ -9094,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;
 }
 


@@ -9153,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;
     }
 }


@@ -9171,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);


@@ -9233,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);


@@ -9454,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;
     }


@@ -9468,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;
     }


@@ -9476,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
 // ----------------------------------------------------------------------------


@@ -9486,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;


@@ -9524,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() )
     {


@@ -9574,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() )
     {


@@ -9583,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;


@@ -9593,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;


@@ -9602,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;
     }


@@ -9617,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;
     }


@@ -9627,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;
 }
 


@@ -9634,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
 {


@@ -9673,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 )


@@ -9718,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


@@ -9739,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;


@@ -9821,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);
     }


@@ -9911,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();


@@ -9922,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();


@@ -9935,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();


@@ -9944,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();


@@ -9963,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)


@@ -9977,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;
 }
 


@@ -9997,7 +10154,6 @@ void wxGrid::Fit()
     AutoSize();
 }
 
     AutoSize();
 }
 

-

 wxPen& wxGrid::GetDividerPen() const
 {
     return wxNullPen;
 wxPen& wxGrid::GetDividerPen() const
 {
     return wxNullPen;


@@ -10036,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 )
 {


@@ -10049,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 )


@@ -10059,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 )
 {


@@ -10071,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 )


@@ -10081,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 )
 {


@@ -10151,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;


@@ -10201,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 );


@@ -10231,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;
     }
 


@@ -10245,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 );
 


@@ -10263,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.
+            }

         }
     }
 
         }
     }
 


@@ -10286,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 )