no real changes

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

index 5e8559b6c4e58c838b4c0df58dfadbe3eb664d0c..e2b9e3580721124017104ac5a4c6e8e0901d0ad4 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -30,9 +30,11 @@
      #pragma hdrstop
  #endif
  
      #pragma hdrstop
  #endif
  
+#if wxUSE_GRID
+
  #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
  #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
-#include "gridg.cpp"
-#else
+    #include "gridg.cpp"
+#else // wxUSE_NEW_GRID
  
  #ifndef WX_PRECOMP
      #include "wx/utils.h"
  
  #ifndef WX_PRECOMP
      #include "wx/utils.h"
@@ -96,6 +98,27 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
  WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
  WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
  
  WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
  WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
  
+// ----------------------------------------------------------------------------
+// events
+// ----------------------------------------------------------------------------
+
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE)
+DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE)
+DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE)
+DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
+DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
+DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)
+DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)
+
  // ----------------------------------------------------------------------------
  // private classes
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // private classes
  // ----------------------------------------------------------------------------
@@ -112,6 +135,7 @@ private:
  
      void OnPaint( wxPaintEvent& event );
      void OnMouseEvent( wxMouseEvent& event );
  
      void OnPaint( wxPaintEvent& event );
      void OnMouseEvent( wxMouseEvent& event );
+    void OnMouseWheel( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
  
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
  
@@ -132,6 +156,7 @@ private:
  
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
  
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
+    void OnMouseWheel( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
  
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
  
@@ -151,6 +176,7 @@ private:
      wxGrid *m_owner;
  
      void OnMouseEvent( wxMouseEvent& event );
      wxGrid *m_owner;
  
      void OnMouseEvent( wxMouseEvent& event );
+    void OnMouseWheel( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
      void OnPaint( wxPaintEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnKeyUp( wxKeyEvent& );
      void OnPaint( wxPaintEvent& event );
@@ -183,6 +209,7 @@ private:
      wxGridColLabelWindow     *m_colLabelWin;
  
      void OnPaint( wxPaintEvent &event );
      wxGridColLabelWindow     *m_colLabelWin;
  
      void OnPaint( wxPaintEvent &event );
+    void OnMouseWheel( wxMouseEvent& event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& );
      void OnKeyUp( wxKeyEvent& );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& );
      void OnKeyUp( wxKeyEvent& );
@@ -354,8 +381,15 @@ wxGridCellCoords wxGridNoCellCoords( -1, -1 );
  wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
  
  // scroll line size
  wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
  
  // scroll line size
-// TODO: fixed so far - make configurable later (and also different for x/y)
-static const size_t GRID_SCROLL_LINE = 10;
+// TODO: this doesn't work at all, grid cells have different sizes and approx
+//       calculations don't work as because of the size mismatch scrollbars
+//       sometimes fail to be shown when they should be or vice versa
+//
+//       The scroll bars may be a little flakey once in a while, but that is
+//       surely much less horrible than having scroll lines of only 1!!!
+//       -- Robin
+static const size_t GRID_SCROLL_LINE = 15;  // 1;
+
  
  // the size of hash tables used a bit everywhere (the max number of elements
  // in these hash tables is the number of rows/columns)
  
  // the size of hash tables used a bit everywhere (the max number of elements
  // in these hash tables is the number of rows/columns)
@@ -474,7 +508,7 @@ void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
  bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
  {
      // accept the simple key presses, not anything with Ctrl/Alt/Meta
  bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
  {
      // accept the simple key presses, not anything with Ctrl/Alt/Meta
-    return !event.HasModifiers();
+    return !(event.ControlDown() || event.AltDown());
  }
  
  void wxGridCellEditor::StartingKey(wxKeyEvent& event)
  }
  
  void wxGridCellEditor::StartingKey(wxKeyEvent& event)
@@ -486,6 +520,8 @@ void wxGridCellEditor::StartingClick()
  {
  }
  
  {
  }
  
+#if wxUSE_TEXTCTRL
+
  // ----------------------------------------------------------------------------
  // wxGridCellTextEditor
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellTextEditor
  // ----------------------------------------------------------------------------
@@ -502,7 +538,8 @@ void wxGridCellTextEditor::Create(wxWindow* parent,
      m_control = new wxTextCtrl(parent, id, wxEmptyString,
                                 wxDefaultPosition, wxDefaultSize
  #if defined(__WXMSW__)
      m_control = new wxTextCtrl(parent, id, wxEmptyString,
                                 wxDefaultPosition, wxDefaultSize
  #if defined(__WXMSW__)
-                               , wxTE_MULTILINE | wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
+                               , wxTE_PROCESS_TAB | wxTE_MULTILINE |
+                                 wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
  #endif
                                );
  
  #endif
                                );
  
@@ -538,9 +575,9 @@ void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
      }
  #else // !GTK
      int extra_x = ( rect.x > 2 )? 2 : 1;
      }
  #else // !GTK
      int extra_x = ( rect.x > 2 )? 2 : 1;
-    
-// MB: treat MSW separately here otherwise the caret doesn't show 
-// when the editor is in the first row. 
+
+// MB: treat MSW separately here otherwise the caret doesn't show
+// when the editor is in the first row.
  #if defined(__WXMSW__)
      int extra_y = 2;
  #else
  #if defined(__WXMSW__)
      int extra_y = 2;
  #else
@@ -1111,6 +1148,10 @@ bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
      return FALSE;
  }
  
      return FALSE;
  }
  
+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_CHECKBOX
+
  // ----------------------------------------------------------------------------
  // wxGridCellBoolEditor
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellBoolEditor
  // ----------------------------------------------------------------------------
@@ -1255,6 +1296,10 @@ bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
      return FALSE;
  }
  
      return FALSE;
  }
  
+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_COMBOBOX
+
  // ----------------------------------------------------------------------------
  // wxGridCellChoiceEditor
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellChoiceEditor
  // ----------------------------------------------------------------------------
@@ -1375,6 +1420,8 @@ void wxGridCellChoiceEditor::SetParameters(const wxString& params)
      }
  }
  
      }
  }
  
+#endif // wxUSE_COMBOBOX
+
  // ----------------------------------------------------------------------------
  // wxGridCellEditorEvtHandler
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellEditorEvtHandler
  // ----------------------------------------------------------------------------
@@ -1389,11 +1436,12 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
              break;
  
          case WXK_TAB:
              break;
  
          case WXK_TAB:
-            event.Skip( m_grid->ProcessEvent( event ) );
+            m_grid->GetEventHandler()->ProcessEvent( event );
              break;
  
          case WXK_RETURN:
              break;
  
          case WXK_RETURN:
-            if (!m_grid->ProcessEvent(event))
+        case WXK_NUMPAD_ENTER:
+            if (!m_grid->GetEventHandler()->ProcessEvent(event))
                  m_editor->HandleReturn(event);
              break;
  
                  m_editor->HandleReturn(event);
              break;
  
@@ -1410,6 +1458,7 @@ void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
          case WXK_ESCAPE:
          case WXK_TAB:
          case WXK_RETURN:
          case WXK_ESCAPE:
          case WXK_TAB:
          case WXK_RETURN:
+        case WXK_NUMPAD_ENTER:
              break;
  
          default:
              break;
  
          default:
@@ -1630,8 +1679,15 @@ wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
          {
              if ( m_width == -1 )
              {
          {
              if ( m_width == -1 )
              {
+                if ( m_precision == -1 )
+                {
                  // default width/precision
                  m_format = _T("%f");
                  // default width/precision
                  m_format = _T("%f");
+            }
+                else
+                {
+                    m_format.Printf(_T("%%.%df"), m_precision);
+                }
              }
              else if ( m_precision == -1 )
              {
              }
              else if ( m_precision == -1 )
              {
@@ -1645,6 +1701,7 @@ wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
          }
  
          text.Printf(m_format, val);
          }
  
          text.Printf(m_format, val);
+
      }
      //else: text already contains the string
  
      }
      //else: text already contains the string
  
@@ -1683,8 +1740,6 @@ wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
  
  void wxGridCellFloatRenderer::SetParameters(const wxString& params)
  {
  
  void wxGridCellFloatRenderer::SetParameters(const wxString& params)
  {
-    bool ok = TRUE;
-
      if ( !params )
      {
          // reset to defaults
      if ( !params )
      {
          // reset to defaults
@@ -1697,37 +1752,34 @@ void wxGridCellFloatRenderer::SetParameters(const wxString& params)
          if ( !!tmp )
          {
              long width;
          if ( !!tmp )
          {
              long width;
-            if ( !tmp.ToLong(&width) )
+            if ( tmp.ToLong(&width) )
              {
              {
-                ok = FALSE;
+                SetWidth((int)width);
              }
              else
              {
              }
              else
              {
-                SetWidth((int)width);
+                wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
+            }
  
  
+        }
                  tmp = params.AfterFirst(_T(','));
                  if ( !!tmp )
                  {
                      long precision;
                  tmp = params.AfterFirst(_T(','));
                  if ( !!tmp )
                  {
                      long precision;
-                    if ( !tmp.ToLong(&precision) )
+            if ( tmp.ToLong(&precision) )
                      {
                      {
-                        ok = FALSE;
+                SetPrecision((int)precision);
                      }
                      else
                      {
                      }
                      else
                      {
-                        SetPrecision((int)precision);
-                    }
-                }
-            }
+                wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
          }
  
          }
  
-        if ( !ok )
-        {
-            wxLogDebug(_T("Invalid wxGridCellFloatRenderer parameter string '%s ignored"), params.c_str());
          }
      }
  }
  
          }
      }
  }
  
+
  // ----------------------------------------------------------------------------
  // wxGridCellBoolRenderer
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellBoolRenderer
  // ----------------------------------------------------------------------------
@@ -1854,11 +1906,47 @@ wxGridCellAttr *wxGridCellAttr::Clone() const
      if ( IsReadOnly() )
          attr->SetReadOnly();
  
      if ( IsReadOnly() )
          attr->SetReadOnly();
  
+    attr->SetKind( m_attrkind );
+
      attr->SetDefAttr(m_defGridAttr);
  
      return attr;
  }
  
      attr->SetDefAttr(m_defGridAttr);
  
      return attr;
  }
  
+void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
+{
+    if ( !HasTextColour() && mergefrom->HasTextColour() )
+        SetTextColour(mergefrom->GetTextColour());
+    if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
+        SetBackgroundColour(mergefrom->GetBackgroundColour());
+    if ( !HasFont() && mergefrom->HasFont() )
+        SetFont(mergefrom->GetFont());
+    if ( !!HasAlignment() && mergefrom->HasAlignment() ){
+        int hAlign, vAlign;
+        mergefrom->GetAlignment( &hAlign, &vAlign);
+        SetAlignment(hAlign, vAlign);
+    }
+
+    // Directly access member functions as GetRender/Editor don't just return
+    // m_renderer/m_editor
+    //
+    // Maybe add support for merge of Render and Editor?
+    if (!HasRenderer() && mergefrom->HasRenderer() )
+    {
+        m_renderer = mergefrom->m_renderer;
+        m_renderer->IncRef();
+    }
+    if ( !HasEditor() && mergefrom->HasEditor() )
+    {
+        m_editor =  mergefrom->m_editor;
+        m_editor->IncRef();
+    }
+    if ( !HasReadWriteMode()  && mergefrom->HasReadWriteMode() )
+        SetReadOnly(mergefrom->IsReadOnly());
+
+    SetDefAttr(mergefrom->m_defGridAttr);
+}
+
  const wxColour& wxGridCellAttr::GetTextColour() const
  {
      if (HasTextColour())
  const wxColour& wxGridCellAttr::GetTextColour() const
  {
      if (HasTextColour())
@@ -1932,7 +2020,7 @@ wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col)
  {
      wxGridCellRenderer* renderer = NULL;
  
  {
      wxGridCellRenderer* renderer = NULL;
  
-    if ( m_defGridAttr != this || grid == NULL )
+    if ( m_defGridAttr == this || grid == NULL )
      {
          renderer = m_renderer;      // use local attribute
          if ( renderer )
      {
          renderer = m_renderer;      // use local attribute
          if ( renderer )
@@ -2000,6 +2088,9 @@ void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
      }
      else
      {
      }
      else
      {
+        // free the old attribute
+        m_attrs[(size_t)n].attr->DecRef();
+
          if ( attr )
          {
              // change the attribute
          if ( attr )
          {
              // change the attribute
@@ -2211,28 +2302,77 @@ void wxGridCellAttrProvider::InitData()
      m_data = new wxGridCellAttrProviderData;
  }
  
      m_data = new wxGridCellAttrProviderData;
  }
  
-wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
+wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
+                                                wxGridCellAttr::wxAttrKind  kind ) const
  {
      wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
      if ( m_data )
      {
  {
      wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
      if ( m_data )
      {
-        // first look for the attribute of this specific cell
-        attr = m_data->m_cellAttrs.GetAttr(row, col);
-
-        if ( !attr )
+        switch(kind)
          {
          {
-            // then look for the col attr (col attributes are more common than
-            // the row ones, hence they have priority)
-            attr = m_data->m_colAttrs.GetAttr(col);
-        }
-
-        if ( !attr )
+            case (wxGridCellAttr::Any):
+                //Get cached merge attributes.
+                // Currenlty not used as no cache implemented as not mutiable
+                // attr = m_data->m_mergeAttr.GetAttr(row, col);
+                if(!attr)
+                {
+                    //Basicaly implement old version.
+                    //Also check merge cache, so we don't have to re-merge every time..
+                    wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
+                                   *attrrow = (wxGridCellAttr *)NULL,
+                                   *attrcol = (wxGridCellAttr *)NULL;
+
+                    attrcell = m_data->m_cellAttrs.GetAttr(row, col);
+                    attrcol = m_data->m_colAttrs.GetAttr(col);
+                    attrrow = m_data->m_rowAttrs.GetAttr(row);
+
+                    if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){
+                        // Two or move are non NULL
+                        attr = new wxGridCellAttr;
+                        attr->SetKind(wxGridCellAttr::Merged);
+
+                        //Order important..
+                        if(attrcell){
+                            attr->MergeWith(attrcell);
+                            attrcell->DecRef();
+                        }
+                        if(attrcol){
+                            attr->MergeWith(attrcol);
+                            attrcol->DecRef();
+                        }
+                        if(attrrow){
+                            attr->MergeWith(attrrow);
+                            attrrow->DecRef();
+                        }
+                        //store merge attr if cache implemented
+                        //attr->IncRef();
+                        //m_data->m_mergeAttr.SetAttr(attr, row, col);
+                    }
+                    else
          {
          {
-            // finally try the row attributes
+                        // one or none is non null return it or null.
+                        if(attrrow) attr = attrrow;
+                        if(attrcol) attr = attrcol;
+                        if(attrcell) attr = attrcell;
+                    }
+                }
+            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::Row):
              attr = m_data->m_rowAttrs.GetAttr(row);
              attr = m_data->m_rowAttrs.GetAttr(row);
+            break;
+            default:
+                // unused as yet...
+                // (wxGridCellAttr::Default):
+                // (wxGridCellAttr::Merged):
+            break;
          }
      }
          }
      }
-
      return attr;
  }
  
      return attr;
  }
  
@@ -2333,19 +2473,24 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
      {
          // check whether this is one of the standard ones, in which case
          // register it "on the fly"
      {
          // check whether this is one of the standard ones, in which case
          // register it "on the fly"
+#if wxUSE_TEXTCTRL
          if ( typeName == wxGRID_VALUE_STRING )
          {
              RegisterDataType(wxGRID_VALUE_STRING,
                               new wxGridCellStringRenderer,
                               new wxGridCellTextEditor);
          if ( typeName == wxGRID_VALUE_STRING )
          {
              RegisterDataType(wxGRID_VALUE_STRING,
                               new wxGridCellStringRenderer,
                               new wxGridCellTextEditor);
-        }
-        else if ( typeName == wxGRID_VALUE_BOOL )
+        } else
+#endif // wxUSE_TEXTCTRL
+#if wxUSE_CHECKBOX
+        if ( typeName == wxGRID_VALUE_BOOL )
          {
              RegisterDataType(wxGRID_VALUE_BOOL,
                               new wxGridCellBoolRenderer,
                               new wxGridCellBoolEditor);
          {
              RegisterDataType(wxGRID_VALUE_BOOL,
                               new wxGridCellBoolRenderer,
                               new wxGridCellBoolEditor);
-        }
-        else if ( typeName == wxGRID_VALUE_NUMBER )
+        } else
+#endif // wxUSE_CHECKBOX
+#if wxUSE_TEXTCTRL
+        if ( typeName == wxGRID_VALUE_NUMBER )
          {
              RegisterDataType(wxGRID_VALUE_NUMBER,
                               new wxGridCellNumberRenderer,
          {
              RegisterDataType(wxGRID_VALUE_NUMBER,
                               new wxGridCellNumberRenderer,
@@ -2356,14 +2501,16 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
              RegisterDataType(wxGRID_VALUE_FLOAT,
                               new wxGridCellFloatRenderer,
                               new wxGridCellFloatEditor);
              RegisterDataType(wxGRID_VALUE_FLOAT,
                               new wxGridCellFloatRenderer,
                               new wxGridCellFloatEditor);
-        }
-        else if ( typeName == wxGRID_VALUE_CHOICE )
+        } else
+#endif // wxUSE_TEXTCTRL
+#if wxUSE_COMBOBOX
+        if ( typeName == wxGRID_VALUE_CHOICE )
          {
              RegisterDataType(wxGRID_VALUE_CHOICE,
                               new wxGridCellStringRenderer,
                               new wxGridCellChoiceEditor);
          {
              RegisterDataType(wxGRID_VALUE_CHOICE,
                               new wxGridCellStringRenderer,
                               new wxGridCellChoiceEditor);
-        }
-        else
+        } else
+#endif // wxUSE_COMBOBOX
          {
              return wxNOT_FOUND;
          }
          {
              return wxNOT_FOUND;
          }
@@ -2417,14 +2564,16 @@ int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
  wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
  {
      wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
  wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
  {
      wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
-    renderer->IncRef();
+    if (renderer)
+        renderer->IncRef();
      return renderer;
  }
  
  wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
  {
      wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
      return renderer;
  }
  
  wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
  {
      wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
-    editor->IncRef();
+    if (editor)
+        editor->IncRef();
      return editor;
  }
  
      return editor;
  }
  
@@ -2462,10 +2611,10 @@ bool wxGridTableBase::CanHaveAttributes()
      return TRUE;
  }
  
      return TRUE;
  }
  
-wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
+wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind  kind)
  {
      if ( m_attrProvider )
  {
      if ( m_attrProvider )
-        return m_attrProvider->GetAttr(row, col);
+        return m_attrProvider->GetAttr(row, col, kind);
      else
          return (wxGridCellAttr *)NULL;
  }
      else
          return (wxGridCellAttr *)NULL;
  }
@@ -2474,6 +2623,7 @@ void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
  {
      if ( m_attrProvider )
      {
  {
      if ( m_attrProvider )
      {
+        attr->SetKind(wxGridCellAttr::Cell);
          m_attrProvider->SetAttr(attr, row, col);
      }
      else
          m_attrProvider->SetAttr(attr, row, col);
      }
      else
@@ -2488,6 +2638,7 @@ void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
  {
      if ( m_attrProvider )
      {
  {
      if ( m_attrProvider )
      {
+        attr->SetKind(wxGridCellAttr::Row);
          m_attrProvider->SetRowAttr(attr, row);
      }
      else
          m_attrProvider->SetRowAttr(attr, row);
      }
      else
@@ -2502,6 +2653,7 @@ void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
  {
      if ( m_attrProvider )
      {
  {
      if ( m_attrProvider )
      {
+        attr->SetKind(wxGridCellAttr::Col);
          m_attrProvider->SetColAttr(attr, col);
      }
      else
          m_attrProvider->SetColAttr(attr, col);
      }
      else
@@ -2875,7 +3027,7 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
      {
          for ( n = 0;  n < numRows;  n++ )
          {
      {
          for ( n = 0;  n < numRows;  n++ )
          {
-            m_data.Remove( pos );
+            m_data.RemoveAt( pos );
          }
      }
      if ( GetView() )
          }
      }
      if ( GetView() )
@@ -2991,7 +3143,7 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
          {
              for ( n = 0;  n < numCols;  n++ )
              {
          {
              for ( n = 0;  n < numCols;  n++ )
              {
-                m_data[row].Remove( pos );
+                m_data[row].RemoveAt( pos );
              }
          }
      }
              }
          }
      }
@@ -3075,6 +3227,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
  
  BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
      EVT_PAINT( wxGridRowLabelWindow::OnPaint )
  
  BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
      EVT_PAINT( wxGridRowLabelWindow::OnPaint )
+    EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)
      EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
      EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
      EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
      EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
@@ -3102,8 +3255,8 @@ void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
      dc.SetDeviceOrigin( 0, -y );
  
      m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
      dc.SetDeviceOrigin( 0, -y );
  
-    m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
-    m_owner->DrawRowLabels( dc );
+    wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawRowLabels( dc , rows );
  }
  
  
  }
  
  
@@ -3113,17 +3266,23 @@ void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& 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
  //
  void wxGridRowLabelWindow::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 wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
  {
-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
  }
  
  void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  
  }
  
  
@@ -3134,6 +3293,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
  
  BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
      EVT_PAINT( wxGridColLabelWindow::OnPaint )
  
  BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
      EVT_PAINT( wxGridColLabelWindow::OnPaint )
+    EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)
      EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
      EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
      EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
      EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
@@ -3161,8 +3321,8 @@ void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
      m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
      dc.SetDeviceOrigin( -x, 0 );
  
      m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
      dc.SetDeviceOrigin( -x, 0 );
  
-    m_owner->CalcColLabelsExposed( GetUpdateRegion() );
-    m_owner->DrawColLabels( dc );
+    wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawColLabels( dc , cols );
  }
  
  
  }
  
  
@@ -3171,18 +3331,23 @@ void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
      m_owner->ProcessColLabelMouseEvent( event );
  }
  
      m_owner->ProcessColLabelMouseEvent( event );
  }
  
+void wxGridColLabelWindow::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
  //
  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->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->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  
  }
  
  
@@ -3192,6 +3357,7 @@ void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
  IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
  
  BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
  IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
  
  BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
+    EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)
      EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
      EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
      EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
      EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
      EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
      EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
@@ -3230,17 +3396,22 @@ void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
  }
  
  
  }
  
  
+void wxGridCornerLabelWindow::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
  //
  void wxGridCornerLabelWindow::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 wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
  {
-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
  }
  
  void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
  {
-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  
  }
  
  
@@ -3251,6 +3422,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
  
  BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
      EVT_PAINT( wxGridWindow::OnPaint )
  
  BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
      EVT_PAINT( wxGridWindow::OnPaint )
+    EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)
      EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
      EVT_KEY_UP( wxGridWindow::OnKeyUp )
      EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
      EVT_KEY_UP( wxGridWindow::OnKeyUp )
@@ -3266,7 +3438,7 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
      m_owner = parent;
      m_rowLabelWin = rowLblWin;
      m_colLabelWin = colLblWin;
      m_owner = parent;
      m_rowLabelWin = rowLblWin;
      m_colLabelWin = colLblWin;
-    SetBackgroundColour( "WHITE" );
+    SetBackgroundColour(_T("WHITE"));
  }
  
  
  }
  
  
@@ -3280,13 +3452,13 @@ void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
      wxPaintDC dc( this );
      m_owner->PrepareDC( dc );
      wxRegion reg = GetUpdateRegion();
      wxPaintDC dc( this );
      m_owner->PrepareDC( dc );
      wxRegion reg = GetUpdateRegion();
-    m_owner->CalcCellsExposed( reg );
-    m_owner->DrawGridCellArea( dc );
+    wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
+    m_owner->DrawGridCellArea( dc , DirtyCells);
  #if WXGRID_DRAW_LINES
      m_owner->DrawAllGridLines( dc, reg );
  #endif
      m_owner->DrawGridSpace( dc );
  #if WXGRID_DRAW_LINES
      m_owner->DrawAllGridLines( dc, reg );
  #endif
      m_owner->DrawGridSpace( dc );
-    m_owner->DrawHighlight( dc );
+    m_owner->DrawHighlight( dc , DirtyCells );
  }
  
  
  }
  
  
@@ -3303,18 +3475,22 @@ void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
      m_owner->ProcessGridCellMouseEvent( event );
  }
  
      m_owner->ProcessGridCellMouseEvent( event );
  }
  
+void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
+{
+    m_owner->GetEventHandler()->ProcessEvent(event);
+}
  
  // This seems to be required for wxMotif/wxGTK otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
  void wxGridWindow::OnKeyDown( wxKeyEvent& event )
  {
  
  // This seems to be required for wxMotif/wxGTK otherwise the mouse
  // cursor must be in the cell edit control to get key events
  //
  void wxGridWindow::OnKeyDown( wxKeyEvent& event )
  {
-    if ( !m_owner->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->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
  }
  
  void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
  }
  
  void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
@@ -3351,6 +3527,8 @@ wxGrid::wxGrid( wxWindow *parent,
  
  wxGrid::~wxGrid()
  {
  
  wxGrid::~wxGrid()
  {
+    // Must do this or ~wxScrollHelper will pop the wrong event handler
+    SetTargetWindow(this);
      ClearAttrCache();
      wxSafeDecRef(m_defaultCellAttr);
  
      ClearAttrCache();
      wxSafeDecRef(m_defaultCellAttr);
  
@@ -3387,6 +3565,7 @@ void wxGrid::Create()
      m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
  
      // Set default cell attributes
      m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
  
      // Set default cell attributes
+    m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
      m_defaultCellAttr->SetFont(GetFont());
      m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
      m_defaultCellAttr->SetTextColour(
      m_defaultCellAttr->SetFont(GetFont());
      m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
      m_defaultCellAttr->SetTextColour(
@@ -3431,6 +3610,8 @@ void wxGrid::Create()
                                    wxDefaultSize );
  
      SetTargetWindow( m_gridWin );
                                    wxDefaultSize );
  
      SetTargetWindow( m_gridWin );
+
+    Init();
  }
  
  
  }
  
  
@@ -3448,7 +3629,9 @@ bool wxGrid::CreateGrid( int numRows, int numCols,
      m_table->SetView( this );
      m_ownTable = TRUE;
      m_selection = new wxGridSelection( this, selmode );
      m_table->SetView( this );
      m_ownTable = TRUE;
      m_selection = new wxGridSelection( this, selmode );
-    Init();
+
+    CalcDimensions();
+
      m_created = TRUE;
  
      return m_created;
      m_created = TRUE;
  
      return m_created;
@@ -3456,12 +3639,10 @@ bool wxGrid::CreateGrid( int numRows, int numCols,
  
  void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
  {
  
  void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
  {
-    if ( !m_created )
-    {
-        wxFAIL_MSG( wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
-    }
-    else
-        m_selection->SetSelectionMode( selmode );
+    wxCHECK_RET( m_created,
+                 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
+
+    m_selection->SetSelectionMode( selmode );
  }
  
  bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
  }
  
  bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
@@ -3488,7 +3669,9 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
          if (takeOwnership)
              m_ownTable = TRUE;
          m_selection = new wxGridSelection( this, selmode );
          if (takeOwnership)
              m_ownTable = TRUE;
          m_selection = new wxGridSelection( this, selmode );
-        Init();
+
+        CalcDimensions();
+
          m_created = TRUE;
      }
  
          m_created = TRUE;
      }
  
@@ -3538,6 +3721,8 @@ void wxGrid::Init()
      m_gridLineColour = wxColour( 128, 128, 255 );
      m_gridLinesEnabled = TRUE;
      m_cellHighlightColour = m_gridLineColour;
      m_gridLineColour = wxColour( 128, 128, 255 );
      m_gridLinesEnabled = TRUE;
      m_cellHighlightColour = m_gridLineColour;
+    m_cellHighlightPenWidth = 2;
+    m_cellHighlightROPenWidth = 1;
  
      m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
      m_winCapture = (wxWindow *)NULL;
  
      m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
      m_winCapture = (wxWindow *)NULL;
@@ -3568,8 +3753,6 @@ void wxGrid::Init()
  
      m_extraWidth =
      m_extraHeight = 50;
  
      m_extraWidth =
      m_extraHeight = 50;
-
-    CalcDimensions();
  }
  
  // ----------------------------------------------------------------------------
  }
  
  // ----------------------------------------------------------------------------
@@ -3654,19 +3837,44 @@ void wxGrid::CalcDimensions()
      int cw, ch;
      GetClientSize( &cw, &ch );
  
      int cw, ch;
      GetClientSize( &cw, &ch );
  
-    if ( m_numRows > 0  ||  m_numCols > 0 )
-    {
-        int right = m_numCols > 0 ? GetColRight( m_numCols-1 ) + m_extraWidth : 0;
-        int bottom = m_numRows > 0 ? GetRowBottom( m_numRows-1 ) + m_extraHeight : 0;
+    if ( m_colLabelWin->IsShown() )
+        cw -= m_rowLabelWidth;
+    if ( m_rowLabelWin->IsShown() )
+        ch -= m_colLabelHeight;
  
  
-        // TODO: restore the scroll position that we had before sizing
-        //
-        int x, y;
-        GetViewStart( &x, &y );
-        SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
-                       right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
-                       x, y );
+    // grid total size
+    int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
+    int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
+
+    // preserve (more or less) the previous position
+    int x, y;
+    GetViewStart( &x, &y );
+    // maybe we don't need scrollbars at all? and if we do, transform w and h
+    // from pixels into logical units
+    if ( w <= cw )
+    {
+        w = 0; x= 0;
+    }
+    else
+    {
+        w = (w + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
+        if ( x >= w )
+            x = w - 1;
+    }
+    if ( h <= ch )
+    {
+        h = 0; y = 0;
+    }
+    else
+    {
+        h = (h + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
+        if ( y >= h )
+            y = h - 1;
      }
      }
+
+    // do set scrollbar parameters
+    SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
+                   w, h, x, y, (GetBatchCount() != 0));
  }
  
  
  }
  
  
@@ -3807,8 +4015,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              {
                  for ( i = 0;  i < numRows;  i++ )
                  {
              {
                  for ( i = 0;  i < numRows;  i++ )
                  {
-                    m_rowHeights.Remove( pos );
-                    m_rowBottoms.Remove( pos );
+                    m_rowHeights.RemoveAt( pos );
+                    m_rowBottoms.RemoveAt( pos );
                  }
  
                  int h = 0;
                  }
  
                  int h = 0;
@@ -3831,8 +4039,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if (attrProvider) {
                  attrProvider->UpdateAttrRows( pos, -((int)numRows) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if (attrProvider) {
                  attrProvider->UpdateAttrRows( pos, -((int)numRows) );
-// ifdef'd out following patch from Paul Gammans                
-#if 0                
+// ifdef'd out following patch from Paul Gammans
+#if 0
                  // No need to touch column attributes, unless we
                  // removed _all_ rows, in this case, we remove
                  // all column attributes.
                  // No need to touch column attributes, unless we
                  // removed _all_ rows, in this case, we remove
                  // all column attributes.
@@ -3840,7 +4048,7 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                  // needed data is not available inside UpdateAttrRows.
                  if ( !GetNumberRows() )
                      attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
                  // needed data is not available inside UpdateAttrRows.
                  if ( !GetNumberRows() )
                      attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
-#endif                    
+#endif
              }
              if ( !GetBatchCount() )
              {
              }
              if ( !GetBatchCount() )
              {
@@ -3943,8 +4151,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              {
                  for ( i = 0;  i < numCols;  i++ )
                  {
              {
                  for ( i = 0;  i < numCols;  i++ )
                  {
-                    m_colWidths.Remove( pos );
-                    m_colRights.Remove( pos );
+                    m_colWidths.RemoveAt( pos );
+                    m_colRights.RemoveAt( pos );
                  }
  
                  int w = 0;
                  }
  
                  int w = 0;
@@ -3967,8 +4175,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if (attrProvider) {
                  attrProvider->UpdateAttrCols( pos, -((int)numCols) );
              wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
              if (attrProvider) {
                  attrProvider->UpdateAttrCols( pos, -((int)numCols) );
-// ifdef'd out following patch from Paul Gammans                
-#if 0                
+// ifdef'd out following patch from Paul Gammans
+#if 0
                  // No need to touch row attributes, unless we
                  // removed _all_ columns, in this case, we remove
                  // all row attributes.
                  // No need to touch row attributes, unless we
                  // removed _all_ columns, in this case, we remove
                  // all row attributes.
@@ -3976,20 +4184,16 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                  // needed data is not available inside UpdateAttrCols.
                  if ( !GetNumberCols() )
                      attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
                  // needed data is not available inside UpdateAttrCols.
                  if ( !GetNumberCols() )
                      attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
-#endif                    
+#endif
              }
              if ( !GetBatchCount() )
              {
                  CalcDimensions();
                  m_colLabelWin->Refresh();
              }
              }
              if ( !GetBatchCount() )
              {
                  CalcDimensions();
                  m_colLabelWin->Refresh();
              }
-            return TRUE;
          }
          }
-#if 0
-// There is no path to this code !!!!!!
-       result = TRUE;
+        result = TRUE;
          break;
          break;
-#endif
      }
  
      if (result && !GetBatchCount() )
      }
  
      if (result && !GetBatchCount() )
@@ -3998,12 +4202,12 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
  }
  
  
  }
  
  
-void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
-    m_rowLabelsExposed.Empty();
+    wxArrayInt  rowlabels;
  
      int top, bottom;
      while ( iter )
  
      int top, bottom;
      while ( iter )
@@ -4039,20 +4243,22 @@ void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
              if ( GetRowTop(row) > bottom )
                  break;
  
              if ( GetRowTop(row) > bottom )
                  break;
  
-            m_rowLabelsExposed.Add( row );
+            rowlabels.Add( row );
          }
  
          iter++ ;
      }
          }
  
          iter++ ;
      }
+
+    return rowlabels;
  }
  
  
  }
  
  
-void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
-    m_colLabelsExposed.Empty();
+    wxArrayInt colLabels;
  
      int left, right;
      while ( iter )
  
      int left, right;
      while ( iter )
@@ -4088,22 +4294,21 @@ void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
              if ( GetColLeft(col) > right )
                  break;
  
              if ( GetColLeft(col) > right )
                  break;
  
-            m_colLabelsExposed.Add( col );
+            colLabels.Add( col );
          }
  
          iter++ ;
      }
          }
  
          iter++ ;
      }
+    return colLabels;
  }
  
  
  }
  
  
-void wxGrid::CalcCellsExposed( const wxRegion& reg )
+wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
  {
      wxRegionIterator iter( reg );
      wxRect r;
  
-    m_cellsExposed.Empty();
-    m_rowsExposed.Empty();
-    m_colsExposed.Empty();
+    wxGridCellCoordsArray  cellsExposed;
  
      int left, top, right, bottom;
      while ( iter )
  
      int left, top, right, bottom;
      while ( iter )
@@ -4140,7 +4345,6 @@ void wxGrid::CalcCellsExposed( const wxRegion& reg )
              if ( GetRowTop(row) > bottom )
                  break;
  
              if ( GetRowTop(row) > bottom )
                  break;
  
-            m_rowsExposed.Add( row );
  
              for ( col = 0;  col < m_numCols;  col++ )
              {
  
              for ( col = 0;  col < m_numCols;  col++ )
              {
@@ -4150,14 +4354,14 @@ void wxGrid::CalcCellsExposed( const wxRegion& reg )
                  if ( GetColLeft(col) > right )
                      break;
  
                  if ( GetColLeft(col) > right )
                      break;
  
-                if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
-                    m_colsExposed.Add( col );
-                m_cellsExposed.Add( wxGridCellCoords( row, col ) );
+                cellsExposed.Add( wxGridCellCoords( row, col ) );
              }
          }
  
          iter++;
      }
              }
          }
  
          iter++;
      }
+
+    return cellsExposed;
  }
  
  
  }
  
  
@@ -4589,7 +4793,9 @@ void wxGrid::ChangeCursorMode(CursorMode mode,
                 cursorModes[m_cursorMode], cursorModes[mode]);
  #endif // __WXDEBUG__
  
                 cursorModes[m_cursorMode], cursorModes[mode]);
  #endif // __WXDEBUG__
  
-    if ( mode == m_cursorMode )
+    if ( mode == m_cursorMode &&
+         win == m_winCapture &&
+         captureMouse == (m_winCapture != NULL))
          return;
  
      if ( !win )
          return;
  
      if ( !win )
@@ -5248,11 +5454,14 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
  // Generate a grid event based on a mouse event and
  // return the result of ProcessEvent()
  //
  // Generate a grid event based on a mouse event and
  // return the result of ProcessEvent()
  //
-bool wxGrid::SendEvent( const wxEventType type,
+int wxGrid::SendEvent( const wxEventType type,
                          int row, int col,
                          wxMouseEvent& mouseEv )
  {
                          int row, int col,
                          wxMouseEvent& mouseEv )
  {
-    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
+   bool claimed;
+   bool vetoed= FALSE;
+       
+   if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
      {
          int rowOrCol = (row == -1 ? col : row);
  
      {
          int rowOrCol = (row == -1 ? col : row);
  
@@ -5260,16 +5469,18 @@ bool wxGrid::SendEvent( const wxEventType type,
                                   type,
                                   this,
                                   rowOrCol,
                                   type,
                                   this,
                                   rowOrCol,
-                                 mouseEv.GetX() + GetColLabelSize(),
-                                 mouseEv.GetY() + GetRowLabelSize(),
+                                 mouseEv.GetX() + GetRowLabelSize(),
+                                 mouseEv.GetY() + GetColLabelSize(),
                                   mouseEv.ControlDown(),
                                   mouseEv.ShiftDown(),
                                   mouseEv.AltDown(),
                                   mouseEv.MetaDown() );
  
                                   mouseEv.ControlDown(),
                                   mouseEv.ShiftDown(),
                                   mouseEv.AltDown(),
                                   mouseEv.MetaDown() );
  
-        return GetEventHandler()->ProcessEvent(gridEvt);
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+       vetoed = !gridEvt.IsAllowed();
+
      }
      }
-    else if ( type == wxEVT_GRID_RANGE_SELECT )
+   else if ( type == wxEVT_GRID_RANGE_SELECT )
      {
          // Right now, it should _never_ end up here!
          wxGridRangeSelectEvent gridEvt( GetId(),
      {
          // Right now, it should _never_ end up here!
          wxGridRangeSelectEvent gridEvt( GetId(),
@@ -5283,33 +5494,44 @@ bool wxGrid::SendEvent( const wxEventType type,
                                          mouseEv.AltDown(),
                                          mouseEv.MetaDown() );
  
                                          mouseEv.AltDown(),
                                          mouseEv.MetaDown() );
  
-        return GetEventHandler()->ProcessEvent(gridEvt);
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+       vetoed = !gridEvt.IsAllowed();
+       
      }
      }
-    else
+   else
      {
          wxGridEvent gridEvt( GetId(),
                               type,
                               this,
                               row, col,
      {
          wxGridEvent gridEvt( GetId(),
                               type,
                               this,
                               row, col,
-                             mouseEv.GetX() + GetColLabelSize(),
-                             mouseEv.GetY() + GetRowLabelSize(),
+                             mouseEv.GetX() + GetRowLabelSize(),
+                             mouseEv.GetY() + GetColLabelSize(),
                               FALSE,
                               mouseEv.ControlDown(),
                               mouseEv.ShiftDown(),
                               mouseEv.AltDown(),
                               mouseEv.MetaDown() );
                               FALSE,
                               mouseEv.ControlDown(),
                               mouseEv.ShiftDown(),
                               mouseEv.AltDown(),
                               mouseEv.MetaDown() );
-
-        return GetEventHandler()->ProcessEvent(gridEvt);
+         claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed = !gridEvt.IsAllowed();
      }
      }
+
+  // A Veto'd event may not be `claimed' so test this first
+  if (vetoed) return -1;
+  return claimed ? 1 : 0;
+
+
  }
  
  
  // Generate a grid event of specified type and return the result
  // of ProcessEvent().
  //
  }
  
  
  // Generate a grid event of specified type and return the result
  // of ProcessEvent().
  //
-bool wxGrid::SendEvent( const wxEventType type,
+int wxGrid::SendEvent( const wxEventType type,
                          int row, int col )
  {
                          int row, int col )
  {
+   bool claimed;
+   bool vetoed= FALSE;
+
      if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
      {
          int rowOrCol = (row == -1 ? col : row);
      if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
      {
          int rowOrCol = (row == -1 ? col : row);
@@ -5319,7 +5541,8 @@ bool wxGrid::SendEvent( const wxEventType type,
                                   this,
                                   rowOrCol );
  
                                   this,
                                   rowOrCol );
  
-        return GetEventHandler()->ProcessEvent(gridEvt);
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed  = !gridEvt.IsAllowed();
      }
      else
      {
      }
      else
      {
@@ -5328,8 +5551,14 @@ bool wxGrid::SendEvent( const wxEventType type,
                               this,
                               row, col );
  
                               this,
                               row, col );
  
-        return GetEventHandler()->ProcessEvent(gridEvt);
-    }
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed  = !gridEvt.IsAllowed();
+     }
+
+       // A Veto'd event may not be `claimed' so test this first
+       if (vetoed) return -1;
+       return claimed ? 1 : 0;
+
  }
  
  
  }
  
  
@@ -5419,6 +5648,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                  break;
  
              case WXK_RETURN:
                  break;
  
              case WXK_RETURN:
+            case WXK_NUMPAD_ENTER:
                  if ( event.ControlDown() )
                  {
                      event.Skip();  // to let the edit control have the return
                  if ( event.ControlDown() )
                  {
                      event.Skip();  // to let the edit control have the return
@@ -5605,7 +5835,7 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
          if ( IsVisible( m_currentCellCoords, FALSE ) )
          {
              wxRect r;
          if ( IsVisible( m_currentCellCoords, FALSE ) )
          {
              wxRect r;
-            r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
+            r = BlockToDeviceRect(m_currentCellCoords, coords);
              if ( !m_gridLinesEnabled )
              {
                  r.x--;
              if ( !m_gridLinesEnabled )
              {
                  r.x--;
@@ -5614,12 +5844,12 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
                  r.height++;
              }
  
                  r.height++;
              }
  
-            CalcCellsExposed( r );
-    
+             wxGridCellCoordsArray cells = CalcCellsExposed( r );
+
              // Otherwise refresh redraws the highlight!
              m_currentCellCoords = coords;
  
              // Otherwise refresh redraws the highlight!
              m_currentCellCoords = coords;
  
-            DrawGridCellArea(dc);
+            DrawGridCellArea(dc,cells);
              DrawAllGridLines( dc, r );
          }
      }
              DrawAllGridLines( dc, r );
          }
      }
@@ -5766,7 +5996,6 @@ void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCo
      // (old comment from when this was the body of SelectBlock)
  }
  
      // (old comment from when this was the body of SelectBlock)
  }
  
-
  //
  // ------ functions to get/send data (see also public functions)
  //
  //
  // ------ functions to get/send data (see also public functions)
  //
@@ -5811,16 +6040,16 @@ bool wxGrid::SetModelValues()
  // exposed cells (usually set from the update region by
  // CalcExposedCells)
  //
  // exposed cells (usually set from the update region by
  // CalcExposedCells)
  //
-void wxGrid::DrawGridCellArea( wxDC& dc )
+void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
  {
      if ( !m_numRows || !m_numCols ) return;
  
      size_t i;
  {
      if ( !m_numRows || !m_numCols ) return;
  
      size_t i;
-    size_t numCells = m_cellsExposed.GetCount();
+    size_t numCells = cells.GetCount();
  
      for ( i = 0;  i < numCells;  i++ )
      {
  
      for ( i = 0;  i < numCells;  i++ )
      {
-        DrawCell( dc, m_cellsExposed[i] );
+        DrawCell( dc, cells[i] );
      }
  }
  
      }
  }
  
@@ -5910,10 +6139,27 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
      // hmmm... what could we do here to show that the cell is disabled?
      // for now, I just draw a thinner border than for the other ones, but
      // it doesn't look really good
      // hmmm... what could we do here to show that the cell is disabled?
      // for now, I just draw a thinner border than for the other ones, but
      // it doesn't look really good
-    dc.SetPen(wxPen(m_cellHighlightColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
  
  
-    dc.DrawRectangle(rect);
+    int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
+
+    if (penWidth > 0) {
+
+        // The center of th drawn line is where the position/width/height of
+        // the rectangle is actually at, (on wxMSW atr least,) so we will
+        // 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;
+
+
+        // Now draw the rectangle
+        dc.SetPen(wxPen(m_cellHighlightColour, penWidth, wxSOLID));
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.DrawRectangle(rect);
+    }
  
  #if 0
          // VZ: my experiments with 3d borders...
  
  #if 0
          // VZ: my experiments with 3d borders...
@@ -5958,7 +6204,7 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
                   GetColRight(col), GetRowBottom(row) );
  }
  
                   GetColRight(col), GetRowBottom(row) );
  }
  
-void wxGrid::DrawHighlight(wxDC& dc)
+void wxGrid::DrawHighlight(wxDC& dc,const  wxGridCellCoordsArray& cells)
  {
      // This if block was previously in wxGrid::OnPaint but that doesn't
      // seem to get called under wxGTK - MB
  {
      // This if block was previously in wxGrid::OnPaint but that doesn't
      // seem to get called under wxGTK - MB
@@ -5977,10 +6223,10 @@ void wxGrid::DrawHighlight(wxDC& dc)
  
      // if the active cell was repainted, repaint its highlight too because it
      // might have been damaged by the grid lines
  
      // if the active cell was repainted, repaint its highlight too because it
      // might have been damaged by the grid lines
-    size_t count = m_cellsExposed.GetCount();
+    size_t count = cells.GetCount();
      for ( size_t n = 0; n < count; n++ )
      {
      for ( size_t n = 0; n < count; n++ )
      {
-        if ( m_cellsExposed[n] == m_currentCellCoords )
+        if ( cells[n] == m_currentCellCoords )
          {
              wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
              DrawCellHighlight(dc, attr);
          {
              wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
              DrawCellHighlight(dc, attr);
@@ -5995,7 +6241,7 @@ void wxGrid::DrawHighlight(wxDC& dc)
  // This is used to redraw all grid lines e.g. when the grid line colour
  // has been changed
  //
  // This is used to redraw all grid lines e.g. when the grid line colour
  // has been changed
  //
-void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
+void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
  {
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
  {
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
@@ -6072,16 +6318,16 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
  }
  
  
  }
  
  
-void wxGrid::DrawRowLabels( wxDC& dc )
+void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
  {
      if ( !m_numRows ) return;
  
      size_t i;
  {
      if ( !m_numRows ) return;
  
      size_t i;
-    size_t numLabels = m_rowLabelsExposed.GetCount();
+    size_t numLabels = rows.GetCount();
  
      for ( i = 0;  i < numLabels;  i++ )
      {
  
      for ( i = 0;  i < numLabels;  i++ )
      {
-        DrawRowLabel( dc, m_rowLabelsExposed[i] );
+        DrawRowLabel( dc, rows[i] );
      }
  }
  
      }
  }
  
@@ -6120,16 +6366,16 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
  }
  
  
  }
  
  
-void wxGrid::DrawColLabels( wxDC& dc )
+void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
  {
      if ( !m_numCols ) return;
  
      size_t i;
  {
      if ( !m_numCols ) return;
  
      size_t i;
-    size_t numLabels = m_colLabelsExposed.GetCount();
+    size_t numLabels = cols.GetCount();
  
      for ( i = 0;  i < numLabels;  i++ )
      {
  
      for ( i = 0;  i < numLabels;  i++ )
      {
-        DrawColLabel( dc, m_colLabelsExposed[i] );
+        DrawColLabel( dc, cols[i] );
      }
  }
  
      }
  }
  
@@ -6172,19 +6418,36 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
      DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
  }
  
      DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
  }
  
-
  void wxGrid::DrawTextRectangle( wxDC& dc,
                                  const wxString& value,
                                  const wxRect& rect,
                                  int horizAlign,
                                  int vertAlign )
  {
  void wxGrid::DrawTextRectangle( wxDC& dc,
                                  const wxString& value,
                                  const wxRect& rect,
                                  int horizAlign,
                                  int vertAlign )
  {
-    long textWidth, textHeight;
-    long lineWidth, lineHeight;
      wxArrayString lines;
  
      dc.SetClippingRegion( rect );
      StringToLines( value, lines );
      wxArrayString lines;
  
      dc.SetClippingRegion( rect );
      StringToLines( value, lines );
+
+
+    //Forward to new API.
+    DrawTextRectangle(  dc,
+                        lines,
+                        rect,
+                        horizAlign,
+                        vertAlign );
+
+}
+
+void wxGrid::DrawTextRectangle( wxDC& dc,
+                                const wxArrayString& lines,
+                                const wxRect& rect,
+                                int horizAlign,
+                                int vertAlign )
+{
+    long textWidth, textHeight;
+    long lineWidth, lineHeight;
+
      if ( lines.GetCount() )
      {
          GetTextBoxSize( dc, lines, &textWidth, &textHeight );
      if ( lines.GetCount() )
      {
          GetTextBoxSize( dc, lines, &textWidth, &textHeight );
@@ -6269,7 +6532,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
  
  
  void wxGrid::GetTextBoxSize( wxDC& dc,
  
  
  void wxGrid::GetTextBoxSize( wxDC& dc,
-                             wxArrayString& lines,
+                             const wxArrayString& lines,
                               long *width, long *height )
  {
      long w = 0;
                               long *width, long *height )
  {
      long w = 0;
@@ -6345,12 +6608,12 @@ void wxGrid::EnableCellEditControl( bool enable )
  
      if ( enable != m_cellEditCtrlEnabled )
      {
  
      if ( enable != m_cellEditCtrlEnabled )
      {
-        // TODO allow the app to Veto() this event?
-        SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
-
          if ( enable )
          {
          if ( enable )
          {
-            // this should be checked by the caller!
+           if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
+               return;
+
+           // this should be checked by the caller!
              wxASSERT_MSG( CanEnableCellControl(),
                            _T("can't enable editing for this cell!") );
  
              wxASSERT_MSG( CanEnableCellControl(),
                            _T("can't enable editing for this cell!") );
  
@@ -6361,7 +6624,10 @@ void wxGrid::EnableCellEditControl( bool enable )
          }
          else
          {
          }
          else
          {
-            HideCellEditControl();
+           //FIXME:add veto support
+           SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
+
+           HideCellEditControl();
              SaveEditControlValue();
  
              // do it after HideCellEditControl()
              SaveEditControlValue();
  
              // do it after HideCellEditControl()
@@ -6458,6 +6724,14 @@ void wxGrid::ShowCellEditControl()
              {
                  editor->Create(m_gridWin, -1,
                                 new wxGridCellEditorEvtHandler(this, editor));
              {
                  editor->Create(m_gridWin, -1,
                                 new wxGridCellEditorEvtHandler(this, editor));
+
+                wxGridEditorCreatedEvent evt(GetId(),
+                                             wxEVT_GRID_EDITOR_CREATED,
+                                             this,
+                                             row,
+                                             col,
+                                             editor->GetControl());
+                GetEventHandler()->ProcessEvent(evt);
              }
  
              editor->Show( TRUE, attr );
              }
  
              editor->Show( TRUE, attr );
@@ -6499,6 +6773,8 @@ 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);
+
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
          bool changed = editor->EndEdit(row, col, this);
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
          bool changed = editor->EndEdit(row, col, this);
@@ -6508,9 +6784,13 @@ void wxGrid::SaveEditControlValue()
  
          if (changed)
          {
  
          if (changed)
          {
-            SendEvent( wxEVT_GRID_CELL_CHANGE,
+            if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
                         m_currentCellCoords.GetRow(),
                         m_currentCellCoords.GetRow(),
-                       m_currentCellCoords.GetCol() );
+                       m_currentCellCoords.GetCol() ) < 0 ) {
+
+                             //Event has been veto set the data back.
+                              SetCellValue(row,col,oldval);
+              }
          }
      }
  }
          }
      }
  }
@@ -6670,6 +6950,7 @@ bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
  //
  void wxGrid::MakeCellVisible( int row, int col )
  {
  //
  void wxGrid::MakeCellVisible( int row, int col )
  {
+
      int i;
      int xpos = -1, ypos = -1;
  
      int i;
      int xpos = -1, ypos = -1;
  
@@ -6710,7 +6991,10 @@ void wxGrid::MakeCellVisible( int row, int col )
              // we divide it later by GRID_SCROLL_LINE, make sure that we don't
              // have rounding errors (this is important, because if we do, we
              // might not scroll at all and some cells won't be redrawn)
              // we divide it later by GRID_SCROLL_LINE, make sure that we don't
              // have rounding errors (this is important, because if we do, we
              // might not scroll at all and some cells won't be redrawn)
-            ypos += GRID_SCROLL_LINE / 2;
+            //
+            // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
+            // scroll unit...
+            ypos += GRID_SCROLL_LINE;
          }
  
          if ( left < 0 )
          }
  
          if ( left < 0 )
@@ -6732,7 +7016,7 @@ void wxGrid::MakeCellVisible( int row, int col )
              }
  
              // see comment for ypos above
              }
  
              // see comment for ypos above
-            xpos += GRID_SCROLL_LINE / 2;
+            xpos += GRID_SCROLL_LINE;
          }
  
          if ( xpos != -1  ||  ypos != -1 )
          }
  
          if ( xpos != -1  ||  ypos != -1 )
@@ -7344,14 +7628,14 @@ void wxGrid::SetRowLabelAlignment( int horiz, int vert )
          case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
          case wxCENTRE: horiz = wxALIGN_CENTRE; break;
      }
          case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
          case wxCENTRE: horiz = wxALIGN_CENTRE; break;
      }
-    
+
      switch ( vert )
      {
          case wxTOP:    vert = wxALIGN_TOP;    break;
          case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
          case wxCENTRE: vert = wxALIGN_CENTRE; break;
      }
      switch ( vert )
      {
          case wxTOP:    vert = wxALIGN_TOP;    break;
          case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
          case wxCENTRE: vert = wxALIGN_CENTRE; break;
      }
-    
+
      if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_rowLabelHorizAlign = horiz;
      if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_rowLabelHorizAlign = horiz;
@@ -7377,14 +7661,14 @@ void wxGrid::SetColLabelAlignment( int horiz, int vert )
          case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
          case wxCENTRE: horiz = wxALIGN_CENTRE; break;
      }
          case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
          case wxCENTRE: horiz = wxALIGN_CENTRE; break;
      }
-    
+
      switch ( vert )
      {
          case wxTOP:    vert = wxALIGN_TOP;    break;
          case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
          case wxCENTRE: vert = wxALIGN_CENTRE; break;
      }
      switch ( vert )
      {
          case wxTOP:    vert = wxALIGN_TOP;    break;
          case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
          case wxCENTRE: vert = wxALIGN_CENTRE; break;
      }
-    
+
      if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_colLabelHorizAlign = horiz;
      if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_colLabelHorizAlign = horiz;
@@ -7466,6 +7750,38 @@ void wxGrid::SetCellHighlightColour( const wxColour& colour )
      }
  }
  
      }
  }
  
+void wxGrid::SetCellHighlightPenWidth(int width)
+{
+    if (m_cellHighlightPenWidth != width) {
+        m_cellHighlightPenWidth = width;
+
+        // Just redrawing the cell highlight is not enough since that won't
+        // make any visible change if the the thickness is getting smaller.
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+        if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+            return;
+        wxRect rect = CellToRect(row, col);
+        m_gridWin->Refresh(TRUE, &rect);
+    }
+}
+
+void wxGrid::SetCellHighlightROPenWidth(int width)
+{
+    if (m_cellHighlightROPenWidth != width) {
+        m_cellHighlightROPenWidth = width;
+
+        // Just redrawing the cell highlight is not enough since that won't
+        // make any visible change if the the thickness is getting smaller.
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+        if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+            return;
+        wxRect rect = CellToRect(row, col);
+        m_gridWin->Refresh(TRUE, &rect);
+    }
+}
+
  void wxGrid::EnableGridLines( bool enable )
  {
      if ( enable != m_gridLinesEnabled )
  void wxGrid::EnableGridLines( bool enable )
  {
      if ( enable != m_gridLinesEnabled )
@@ -7669,6 +7985,7 @@ void wxGrid::ClearAttrCache()
      if ( m_attrCache.row != -1 )
      {
          wxSafeDecRef(m_attrCache.attr);
      if ( m_attrCache.row != -1 )
      {
          wxSafeDecRef(m_attrCache.attr);
+        m_attrCache.attr = NULL;
          m_attrCache.row = -1;
      }
  }
          m_attrCache.row = -1;
      }
  }
@@ -7711,7 +8028,7 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
      wxGridCellAttr *attr;
      if ( !LookupAttr(row, col, &attr) )
      {
      wxGridCellAttr *attr;
      if ( !LookupAttr(row, col, &attr) )
      {
-        attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
+        attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any) : (wxGridCellAttr *)NULL;
          CacheAttr(row, col, attr);
      }
      if (attr)
          CacheAttr(row, col, attr);
      }
      if (attr)
@@ -7729,25 +8046,19 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
  
  wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
  {
  
  wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
  {
-    wxGridCellAttr *attr;
-    if ( !LookupAttr(row, col, &attr) || !attr )
-    {
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
          wxASSERT_MSG( m_table,
                        _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
  
          wxASSERT_MSG( m_table,
                        _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
  
-        attr = m_table->GetAttr(row, col);
+    attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell );
          if ( !attr )
          {
              attr = new wxGridCellAttr;
  
              // artificially inc the ref count to match DecRef() in caller
              attr->IncRef();
          if ( !attr )
          {
              attr = new wxGridCellAttr;
  
              // artificially inc the ref count to match DecRef() in caller
              attr->IncRef();
-
              m_table->SetAttr(attr, row, col);
          }
              m_table->SetAttr(attr, row, col);
          }
-
-        CacheAttr(row, col, attr);
-    }
      attr->SetDefAttr(m_defaultCellAttr);
      return attr;
  }
      attr->SetDefAttr(m_defaultCellAttr);
      return attr;
  }
@@ -7779,11 +8090,16 @@ void wxGrid::SetColFormatFloat(int col, int width, int precision)
  
  void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
  {
  
  void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
  {
-    wxGridCellAttr *attr = new wxGridCellAttr;
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
+
+    attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
+    if(!attr)
+        attr = new wxGridCellAttr;
      wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
      attr->SetRenderer(renderer);
  
      SetColAttr(col, attr);
      wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
      attr->SetRenderer(renderer);
  
      SetColAttr(col, attr);
+
  }
  
  // ----------------------------------------------------------------------------
  }
  
  // ----------------------------------------------------------------------------
@@ -7795,6 +8111,7 @@ void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
      if ( CanHaveAttributes() )
      {
          m_table->SetRowAttr(attr, row);
      if ( CanHaveAttributes() )
      {
          m_table->SetRowAttr(attr, row);
+        ClearAttrCache();
      }
      else
      {
      }
      else
      {
@@ -7807,6 +8124,7 @@ void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
      if ( CanHaveAttributes() )
      {
          m_table->SetColAttr(attr, col);
      if ( CanHaveAttributes() )
      {
          m_table->SetColAttr(attr, col);
+        ClearAttrCache();
      }
      else
      {
      }
      else
      {
@@ -7965,8 +8283,8 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
      if ( resizeExistingRows )
      {
          InitRowHeights();
      if ( resizeExistingRows )
      {
          InitRowHeights();
-
-        CalcDimensions();
+        if ( !GetBatchCount() )
+            CalcDimensions();
      }
  }
  
      }
  }
  
@@ -7989,7 +8307,8 @@ void wxGrid::SetRowSize( int row, int height )
      {
          m_rowBottoms[i] += diff;
      }
      {
          m_rowBottoms[i] += diff;
      }
-    CalcDimensions();
+    if ( !GetBatchCount() )
+        CalcDimensions();
  }
  
  void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
  }
  
  void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
@@ -7999,8 +8318,8 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
      if ( resizeExistingCols )
      {
          InitColWidths();
      if ( resizeExistingCols )
      {
          InitColWidths();
-
-        CalcDimensions();
+        if ( !GetBatchCount() )
+            CalcDimensions();
      }
  }
  
      }
  }
  
@@ -8025,7 +8344,8 @@ void wxGrid::SetColSize( int col, int width )
      {
          m_colRights[i] += diff;
      }
      {
          m_colRights[i] += diff;
      }
-    CalcDimensions();
+    if ( !GetBatchCount() )
+        CalcDimensions();
  }
  
  
  }
  
  
@@ -8100,7 +8420,7 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
      if ( column )
          dc.GetTextExtent( GetColLabelValue(col), &w, &h );
      else
      if ( column )
          dc.GetTextExtent( GetColLabelValue(col), &w, &h );
      else
-        dc.GetTextExtent( GetRowLabelValue(col), &w, &h );
+        dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
  
      extent = column ? w : h;
      if ( extent > extentMax )
  
      extent = column ? w : h;
      if ( extent > extentMax )
@@ -8128,10 +8448,35 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
      }
  
      if ( column )
      }
  
      if ( column )
+    {
          SetColSize(col, extentMax);
          SetColSize(col, extentMax);
+        if ( !GetBatchCount() )
+        {
+            int cw, ch, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            wxRect rect ( CellToRect( 0, col ) );
+            rect.y = 0;
+            CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
+            rect.width = cw - rect.x;
+            rect.height = m_colLabelHeight;
+            m_colLabelWin->Refresh( TRUE, &rect );
+        }
+    }
      else
      else
+    {
          SetRowSize(row, extentMax);
          SetRowSize(row, extentMax);
-
+        if ( !GetBatchCount() )
+        {
+            int cw, ch, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            wxRect rect ( CellToRect( row, 0 ) );
+            rect.x = 0;
+            CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
+            rect.width = m_rowLabelWidth;
+            rect.height = ch - rect.y;
+            m_rowLabelWin->Refresh( TRUE, &rect );
+        }
+    }
      if ( setAsMin )
      {
          if ( column )
      if ( setAsMin )
      {
          if ( column )
@@ -8145,6 +8490,8 @@ int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
  {
      int width = m_rowLabelWidth;
  
  {
      int width = m_rowLabelWidth;
  
+    if ( !calcOnly )
+        BeginBatch();
      for ( int col = 0; col < m_numCols; col++ )
      {
          if ( !calcOnly )
      for ( int col = 0; col < m_numCols; col++ )
      {
          if ( !calcOnly )
@@ -8154,7 +8501,8 @@ int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
  
          width += GetColWidth(col);
      }
  
          width += GetColWidth(col);
      }
-
+    if ( !calcOnly )
+        EndBatch();
      return width;
  }
  
      return width;
  }
  
@@ -8162,6 +8510,8 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
  {
      int height = m_colLabelHeight;
  
  {
      int height = m_colLabelHeight;
  
+    if ( !calcOnly )
+        BeginBatch();
      for ( int row = 0; row < m_numRows; row++ )
      {
          if ( !calcOnly )
      for ( int row = 0; row < m_numRows; row++ )
      {
          if ( !calcOnly )
@@ -8171,14 +8521,15 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
  
          height += GetRowHeight(row);
      }
  
          height += GetRowHeight(row);
      }
-
+    if ( !calcOnly )
+        EndBatch();
      return height;
  }
  
  void wxGrid::AutoSize()
  {
      // set the size too
      return height;
  }
  
  void wxGrid::AutoSize()
  {
      // set the size too
-    SetSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
+    SetClientSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
  }
  
  wxSize wxGrid::DoGetBestSize() const
  }
  
  wxSize wxGrid::DoGetBestSize() const
@@ -8253,20 +8604,67 @@ void wxGrid::SelectCol( int col, bool addToSelected )
  }
  
  
  }
  
  
-void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol, 
+void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
                            bool addToSelected )
  {
      if ( IsSelection() && !addToSelected )
          ClearSelection();
  
                            bool addToSelected )
  {
      if ( IsSelection() && !addToSelected )
          ClearSelection();
  
-    m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol, 
-                              FALSE, addToSelected );    
+    m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
+                              FALSE, addToSelected );
  }
  
  
  void wxGrid::SelectAll()
  {
  }
  
  
  void wxGrid::SelectAll()
  {
-    m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+    if ( m_numRows > 0 && m_numCols > 0 )
+        m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+}
+
+//
+// ------ Cell, row and col deselection
+//
+
+void wxGrid::DeselectRow( int row )
+{
+    if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
+    {
+        if ( m_selection->IsInSelection(row, 0 ) )
+            m_selection->ToggleCellSelection( row, 0);
+    }
+    else
+    {
+        int nCols = GetNumberCols();
+        for ( int i = 0; i < nCols ; i++ )
+        {
+            if ( m_selection->IsInSelection(row, i ) )
+                m_selection->ToggleCellSelection( row, i);
+        }
+    }
+}
+
+void wxGrid::DeselectCol( int col )
+{
+    if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
+    {
+        if ( m_selection->IsInSelection(0, col ) )
+            m_selection->ToggleCellSelection( 0, col);
+    }
+    else
+    {
+        int nRows = GetNumberRows();
+        for ( int i = 0; i < nRows ; i++ )
+        {
+            if ( m_selection->IsInSelection(i, col ) )
+                m_selection->ToggleCellSelection(i, col);
+        }
+    }
+}
+
+void wxGrid::DeselectCell( int row, int col )
+{
+    if ( m_selection->IsInSelection(row, col) )
+        m_selection->ToggleCellSelection(row, col);
  }
  
  bool wxGrid::IsSelection()
  }
  
  bool wxGrid::IsSelection()
@@ -8348,7 +8746,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
  // ------ Grid event classes
  //
  
  // ------ Grid event classes
  //
  
-IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
  
  wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
                            int row, int col, int x, int y, bool sel,
  
  wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
                            int row, int col, int x, int y, bool sel,
@@ -8369,7 +8767,7 @@ wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
  }
  
  
  }
  
  
-IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
  
  wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
                                    int rowOrCol, int x, int y,
  
  wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
                                    int rowOrCol, int x, int y,
@@ -8388,7 +8786,7 @@ wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
  }
  
  
  }
  
  
-IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
  
  wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                 const wxGridCellCoords& topLeft,
  
  wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                 const wxGridCellCoords& topLeft,
@@ -8409,4 +8807,21 @@ wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObjec
  }
  
  
  }
  
  
-#endif // ifndef wxUSE_NEW_GRID
+IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
+
+wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
+                                                   wxObject* obj, int row,
+                                                   int col, wxControl* ctrl)
+    : wxCommandEvent(type, id)
+{
+    SetEventObject(obj);
+    m_row = row;
+    m_col = col;
+    m_ctrl = ctrl;
+}
+
+
+#endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
+
+#endif // wxUSE_GRID
+