Ported new double idle handlers for pending events

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

index 431115b10fb6de7a46133c51f55d52ea4a5d0c79..2a92e9b7487827d48d2cd189ad874a8d777254ec 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -21,7 +21,7 @@
      #pragma implementation "grid.h"
  #endif
  
      #pragma implementation "grid.h"
  #endif
  
-// For compilers that support precompilation, includes "wx/wx.h".
+// For compilers that support precompilatixon, includes "wx/wx.h".
  #include "wx/wxprec.h"
  
  #include "wx/defs.h"
  #include "wx/wxprec.h"
  
  #include "wx/defs.h"
@@ -47,14 +47,31 @@
  
  #include "wx/textfile.h"
  #include "wx/spinctrl.h"
  
  #include "wx/textfile.h"
  #include "wx/spinctrl.h"
+#include "wx/tokenzr.h"
  
  #include "wx/grid.h"
  
  #include "wx/grid.h"
+#include "wx/generic/gridsel.h"
+
+#if defined(__WXMOTIF__)
+    #define WXUNUSED_MOTIF(identifier)  WXUNUSED(identifier)
+#else
+    #define WXUNUSED_MOTIF(identifier)  identifier
+#endif
+
+#if defined(__WXGTK__)
+    #define WXUNUSED_GTK(identifier)    WXUNUSED(identifier)
+#else
+    #define WXUNUSED_GTK(identifier)    identifier
+#endif
+
+// Required for wxIs... functions
+#include <ctype.h>
  
  // ----------------------------------------------------------------------------
  // array classes
  // ----------------------------------------------------------------------------
  
  
  // ----------------------------------------------------------------------------
  // array classes
  // ----------------------------------------------------------------------------
  
-WX_DEFINE_ARRAY(wxGridCellAttr *, wxArrayAttrs);
+WX_DEFINE_EXPORTED_ARRAY(wxGridCellAttr *, wxArrayAttrs);
  
  struct wxGridCellWithAttr
  {
  
  struct wxGridCellWithAttr
  {
@@ -72,7 +89,7 @@ struct wxGridCellWithAttr
      wxGridCellAttr  *attr;
  };
  
      wxGridCellAttr  *attr;
  };
  
-WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
+WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
  
  #include "wx/arrimpl.cpp"
  
  
  #include "wx/arrimpl.cpp"
  
@@ -96,6 +113,7 @@ private:
      void OnPaint( wxPaintEvent& event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnPaint( wxPaintEvent& event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
+    void OnKeyUp( wxKeyEvent& );
  
      DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
      DECLARE_EVENT_TABLE()
  
      DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
      DECLARE_EVENT_TABLE()
@@ -115,6 +133,7 @@ private:
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
+    void OnKeyUp( wxKeyEvent& );
  
      DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
      DECLARE_EVENT_TABLE()
  
      DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
      DECLARE_EVENT_TABLE()
@@ -133,6 +152,7 @@ private:
  
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
  
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& event );
+    void OnKeyUp( wxKeyEvent& );
      void OnPaint( wxPaintEvent& event );
  
      DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
      void OnPaint( wxPaintEvent& event );
  
      DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
@@ -165,6 +185,7 @@ private:
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& );
      void OnPaint( wxPaintEvent &event );
      void OnMouseEvent( wxMouseEvent& event );
      void OnKeyDown( wxKeyEvent& );
+    void OnKeyUp( wxKeyEvent& );
      void OnEraseBackground( wxEraseEvent& );
  
  
      void OnEraseBackground( wxEraseEvent& );
  
  
@@ -263,7 +284,11 @@ struct wxGridDataTypeInfo
          : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
          { }
  
          : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
          { }
  
-    ~wxGridDataTypeInfo() { delete m_renderer; delete m_editor; }
+    ~wxGridDataTypeInfo()
+    {
+        wxSafeDecRef(m_renderer);
+        wxSafeDecRef(m_editor);
+    }
  
      wxString            m_typeName;
      wxGridCellRenderer* m_renderer;
  
      wxString            m_typeName;
      wxGridCellRenderer* m_renderer;
@@ -271,18 +296,31 @@ struct wxGridDataTypeInfo
  };
  
  
  };
  
  
-WX_DEFINE_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
+WX_DEFINE_EXPORTED_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
  
  
  class WXDLLEXPORT wxGridTypeRegistry
  {
  public:
  
  
  class WXDLLEXPORT wxGridTypeRegistry
  {
  public:
+  wxGridTypeRegistry() {}
      ~wxGridTypeRegistry();
  
      void RegisterDataType(const wxString& typeName,
                       wxGridCellRenderer* renderer,
                       wxGridCellEditor* editor);
      ~wxGridTypeRegistry();
  
      void RegisterDataType(const wxString& typeName,
                       wxGridCellRenderer* renderer,
                       wxGridCellEditor* editor);
+
+    // find one of already registered data types
+    int FindRegisteredDataType(const wxString& typeName);
+
+    // try to FindRegisteredDataType(), if this fails and typeName is one of
+    // standard typenames, register it and return its index
      int FindDataType(const wxString& typeName);
      int FindDataType(const wxString& typeName);
+
+    // try to FindDataType(), if it fails see if it is not one of already
+    // registered data types with some params in which case clone the
+    // registered data type and set params for it
+    int FindOrCloneDataType(const wxString& typeName);
+
      wxGridCellRenderer* GetRenderer(int index);
      wxGridCellEditor*   GetEditor(int index);
  
      wxGridCellRenderer* GetRenderer(int index);
      wxGridCellEditor*   GetEditor(int index);
  
@@ -433,6 +471,11 @@ void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
      event.Skip();
  }
  
      event.Skip();
  }
  
+bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
+{
+    // accept the simple key presses, not anything with Ctrl/Alt/Meta
+    return !(event.ControlDown() || event.AltDown());
+}
  
  void wxGridCellEditor::StartingKey(wxKeyEvent& event)
  {
  
  void wxGridCellEditor::StartingKey(wxKeyEvent& event)
  {
@@ -449,6 +492,7 @@ void wxGridCellEditor::StartingClick()
  
  wxGridCellTextEditor::wxGridCellTextEditor()
  {
  
  wxGridCellTextEditor::wxGridCellTextEditor()
  {
+    m_maxChars = 0;
  }
  
  void wxGridCellTextEditor::Create(wxWindow* parent,
  }
  
  void wxGridCellTextEditor::Create(wxWindow* parent,
@@ -458,10 +502,13 @@ 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 // necessary ???
+                               , wxTE_PROCESS_TAB | wxTE_MULTILINE |
+                                 wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
  #endif
                                );
  
  #endif
                                );
  
+    // TODO: use m_maxChars
+
      wxGridCellEditor::Create(parent, id, evtHandler);
  }
  
      wxGridCellEditor::Create(parent, id, evtHandler);
  }
  
@@ -492,7 +539,15 @@ 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.
+#if defined(__WXMSW__)
+    int extra_y = 2;
+#else
      int extra_y = ( rect.y > 2 )? 2 : 1;
      int extra_y = ( rect.y > 2 )? 2 : 1;
+#endif // MSW
+
  #if defined(__WXMOTIF__)
      extra_x *= 2;
      extra_y *= 2;
  #if defined(__WXMOTIF__)
      extra_x *= 2;
      extra_y *= 2;
@@ -558,35 +613,125 @@ void wxGridCellTextEditor::DoReset(const wxString& startValue)
      Text()->SetInsertionPointEnd();
  }
  
      Text()->SetInsertionPointEnd();
  }
  
+bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
+{
+    if ( wxGridCellEditor::IsAcceptedKey(event) )
+    {
+        int keycode = event.GetKeyCode();
+        switch ( keycode )
+        {
+            case WXK_NUMPAD0:
+            case WXK_NUMPAD1:
+            case WXK_NUMPAD2:
+            case WXK_NUMPAD3:
+            case WXK_NUMPAD4:
+            case WXK_NUMPAD5:
+            case WXK_NUMPAD6:
+            case WXK_NUMPAD7:
+            case WXK_NUMPAD8:
+            case WXK_NUMPAD9:
+            case WXK_MULTIPLY:
+            case WXK_NUMPAD_MULTIPLY:
+            case WXK_ADD:
+            case WXK_NUMPAD_ADD:
+            case WXK_SUBTRACT:
+            case WXK_NUMPAD_SUBTRACT:
+            case WXK_DECIMAL:
+            case WXK_NUMPAD_DECIMAL:
+            case WXK_DIVIDE:
+            case WXK_NUMPAD_DIVIDE:
+                return TRUE;
+
+            default:
+                // accept 8 bit chars too if isprint() agrees
+                if ( (keycode < 255) && (isprint(keycode)) )
+                    return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
  void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
  {
  void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
  {
-    if ( !event.AltDown() && !event.MetaDown() && !event.ControlDown() )
-    {
-        // insert the key in the control
-        long keycode = event.KeyCode();
-        if ( isprint(keycode) )
-        {
-            // FIXME this is not going to work for non letters...
-            if ( !event.ShiftDown() )
-            {
-                keycode = tolower(keycode);
-            }
+    // we don't check for !HasModifiers() because IsAcceptedKey() did it
+
+    // insert the key in the control
+    wxChar ch;
+    int keycode = event.GetKeyCode();
+    switch ( keycode )
+    {
+        case WXK_NUMPAD0:
+        case WXK_NUMPAD1:
+        case WXK_NUMPAD2:
+        case WXK_NUMPAD3:
+        case WXK_NUMPAD4:
+        case WXK_NUMPAD5:
+        case WXK_NUMPAD6:
+        case WXK_NUMPAD7:
+        case WXK_NUMPAD8:
+        case WXK_NUMPAD9:
+            ch = _T('0') + keycode - WXK_NUMPAD0;
+            break;
  
  
-            Text()->AppendText((wxChar)keycode);
+        case WXK_MULTIPLY:
+        case WXK_NUMPAD_MULTIPLY:
+            ch = _T('*');
+            break;
  
  
-            return;
-        }
+        case WXK_ADD:
+        case WXK_NUMPAD_ADD:
+            ch = _T('+');
+            break;
+
+        case WXK_SUBTRACT:
+        case WXK_NUMPAD_SUBTRACT:
+            ch = _T('-');
+            break;
+
+        case WXK_DECIMAL:
+        case WXK_NUMPAD_DECIMAL:
+            ch = _T('.');
+            break;
+
+        case WXK_DIVIDE:
+        case WXK_NUMPAD_DIVIDE:
+            ch = _T('/');
+            break;
+
+        default:
+            if ( keycode < 256 && keycode >= 0 && isprint(keycode) )
+            {
+                // FIXME this is not going to work for non letters...
+                if ( !event.ShiftDown() )
+                {
+                    keycode = tolower(keycode);
+                }
  
  
+                ch = (wxChar)keycode;
+            }
+            else
+            {
+                ch = _T('\0');
+            }
      }
  
      }
  
-    event.Skip();
+    if ( ch )
+    {
+        Text()->AppendText(ch);
+    }
+    else
+    {
+        event.Skip();
+    }
  }
  
  }
  
-void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
+void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
+                                         WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
  {
  #if defined(__WXMOTIF__) || defined(__WXGTK__)
      // wxMotif needs a little extra help...
  {
  #if defined(__WXMOTIF__) || defined(__WXGTK__)
      // wxMotif needs a little extra help...
-    int pos = Text()->GetInsertionPoint();
+    size_t pos = (size_t)( Text()->GetInsertionPoint() );
      wxString s( Text()->GetValue() );
      s = s.Left(pos) + "\n" + s.Mid(pos);
      Text()->SetValue(s);
      wxString s( Text()->GetValue() );
      s = s.Left(pos) + "\n" + s.Mid(pos);
      Text()->SetValue(s);
@@ -598,6 +743,27 @@ void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
  #endif
  }
  
  #endif
  }
  
+void wxGridCellTextEditor::SetParameters(const wxString& params)
+{
+    if ( !params )
+    {
+        // reset to default
+        m_maxChars = 0;
+    }
+    else
+    {
+        long tmp;
+        if ( !params.ToLong(&tmp) )
+        {
+            wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str());
+        }
+        else
+        {
+            m_maxChars = (size_t)tmp;
+        }
+    }
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellNumberEditor
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellNumberEditor
  // ----------------------------------------------------------------------------
@@ -653,7 +819,8 @@ void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
  
      if ( HasRange() )
      {
  
      if ( HasRange() )
      {
-        Spin()->SetValue(m_valueOld);
+        Spin()->SetValue((int)m_valueOld);
+        Spin()->SetFocus();
      }
      else
      {
      }
      else
      {
@@ -682,7 +849,7 @@ bool wxGridCellNumberEditor::EndEdit(int row, int col,
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
              grid->GetTable()->SetValueAsLong(row, col, value);
          else
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
              grid->GetTable()->SetValueAsLong(row, col, value);
          else
-            grid->GetTable()->SetValue(row, col, wxString::Format("%ld", value));
+            grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%ld"), value));
      }
  
      return changed;
      }
  
      return changed;
@@ -692,7 +859,7 @@ void wxGridCellNumberEditor::Reset()
  {
      if ( HasRange() )
      {
  {
      if ( HasRange() )
      {
-        Spin()->SetValue(m_valueOld);
+        Spin()->SetValue((int)m_valueOld);
      }
      else
      {
      }
      else
      {
@@ -700,11 +867,45 @@ void wxGridCellNumberEditor::Reset()
      }
  }
  
      }
  }
  
+bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
+{
+    if ( wxGridCellEditor::IsAcceptedKey(event) )
+    {
+        int keycode = event.GetKeyCode();
+        switch ( keycode )
+        {
+            case WXK_NUMPAD0:
+            case WXK_NUMPAD1:
+            case WXK_NUMPAD2:
+            case WXK_NUMPAD3:
+            case WXK_NUMPAD4:
+            case WXK_NUMPAD5:
+            case WXK_NUMPAD6:
+            case WXK_NUMPAD7:
+            case WXK_NUMPAD8:
+            case WXK_NUMPAD9:
+            case WXK_ADD:
+            case WXK_NUMPAD_ADD:
+            case WXK_SUBTRACT:
+            case WXK_NUMPAD_SUBTRACT:
+            case WXK_UP:
+            case WXK_DOWN:
+                return TRUE;
+
+            default:
+                if ( (keycode < 128) && isdigit(keycode) )
+                    return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
  void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
  {
      if ( !HasRange() )
      {
  void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
  {
      if ( !HasRange() )
      {
-        long keycode = event.KeyCode();
+        int keycode = (int) event.KeyCode();
          if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
          {
              wxGridCellTextEditor::StartingKey(event);
          if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
          {
              wxGridCellTextEditor::StartingKey(event);
@@ -717,10 +918,44 @@ void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
      event.Skip();
  }
  
      event.Skip();
  }
  
+void wxGridCellNumberEditor::SetParameters(const wxString& params)
+{
+    if ( !params )
+    {
+        // reset to default
+        m_min =
+        m_max = -1;
+    }
+    else
+    {
+        long tmp;
+        if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
+        {
+            m_min = (int)tmp;
+
+            if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
+            {
+                m_max = (int)tmp;
+
+                // skip the error message below
+                return;
+            }
+        }
+
+        wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
+    }
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellFloatEditor
  // ----------------------------------------------------------------------------
  
  // ----------------------------------------------------------------------------
  // wxGridCellFloatEditor
  // ----------------------------------------------------------------------------
  
+wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
+{
+    m_width = width;
+    m_precision = precision;
+}
+
  void wxGridCellFloatEditor::Create(wxWindow* parent,
                                     wxWindowID id,
                                     wxEvtHandler* evtHandler)
  void wxGridCellFloatEditor::Create(wxWindow* parent,
                                     wxWindowID id,
                                     wxEvtHandler* evtHandler)
@@ -762,7 +997,7 @@ bool wxGridCellFloatEditor::EndEdit(int row, int col,
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
              grid->GetTable()->SetValueAsDouble(row, col, value);
          else
          if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
              grid->GetTable()->SetValueAsDouble(row, col, value);
          else
-            grid->GetTable()->SetValue(row, col, wxString::Format("%f", value));
+            grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%f"), value));
  
          return TRUE;
      }
  
          return TRUE;
      }
@@ -779,7 +1014,7 @@ void wxGridCellFloatEditor::Reset()
  
  void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
  {
  
  void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
  {
-    long keycode = event.KeyCode();
+    int keycode = (int)event.KeyCode();
      if ( isdigit(keycode) ||
           keycode == '+' || keycode == '-' || keycode == '.' )
      {
      if ( isdigit(keycode) ||
           keycode == '+' || keycode == '-' || keycode == '.' )
      {
@@ -792,6 +1027,91 @@ void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
      event.Skip();
  }
  
      event.Skip();
  }
  
+void wxGridCellFloatEditor::SetParameters(const wxString& params)
+{
+    if ( !params )
+    {
+        // reset to default
+        m_width =
+        m_precision = -1;
+    }
+    else
+    {
+        long tmp;
+        if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
+        {
+            m_width = (int)tmp;
+
+            if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
+            {
+                m_precision = (int)tmp;
+
+                // skip the error message below
+                return;
+            }
+        }
+
+        wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
+    }
+}
+
+wxString wxGridCellFloatEditor::GetString() const
+{
+    wxString fmt;
+    if ( m_width == -1 )
+    {
+        // default width/precision
+        fmt = _T("%g");
+    }
+    else if ( m_precision == -1 )
+    {
+        // default precision
+        fmt.Printf(_T("%%%d.g"), m_width);
+    }
+    else
+    {
+        fmt.Printf(_T("%%%d.%dg"), m_width, m_precision);
+    }
+
+    return wxString::Format(fmt, m_valueOld);
+}
+
+bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
+{
+    if ( wxGridCellEditor::IsAcceptedKey(event) )
+    {
+        int keycode = event.GetKeyCode();
+        switch ( keycode )
+        {
+            case WXK_NUMPAD0:
+            case WXK_NUMPAD1:
+            case WXK_NUMPAD2:
+            case WXK_NUMPAD3:
+            case WXK_NUMPAD4:
+            case WXK_NUMPAD5:
+            case WXK_NUMPAD6:
+            case WXK_NUMPAD7:
+            case WXK_NUMPAD8:
+            case WXK_NUMPAD9:
+            case WXK_ADD:
+            case WXK_NUMPAD_ADD:
+            case WXK_SUBTRACT:
+            case WXK_NUMPAD_SUBTRACT:
+            case WXK_DECIMAL:
+            case WXK_NUMPAD_DECIMAL:
+                return TRUE;
+
+            default:
+                // additionally accept 'e' as in '1e+6'
+                if ( (keycode < 128) &&
+                     (isdigit(keycode) || tolower(keycode) == 'e') )
+                    return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellBoolEditor
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellBoolEditor
  // ----------------------------------------------------------------------------
@@ -843,8 +1163,8 @@ void wxGridCellBoolEditor::SetSize(const wxRect& r)
      // so shift it to the right
      size.x -= 8;
  #elif defined(__WXMSW__)
      // so shift it to the right
      size.x -= 8;
  #elif defined(__WXMSW__)
-    // here too...
-    size.x -= 6;
+    // here too, but in other way
+    size.x += 1;
      size.y -= 2;
  #endif
  
      size.y -= 2;
  #endif
  
@@ -870,7 +1190,10 @@ void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
      if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
          m_startValue = grid->GetTable()->GetValueAsBool(row, col);
      else
      if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
          m_startValue = grid->GetTable()->GetValueAsBool(row, col);
      else
-        m_startValue = !!grid->GetTable()->GetValue(row, col);
+    {
+        wxString cellval( grid->GetTable()->GetValue(row, col) );
+        m_startValue = !( !cellval || (cellval == "0") );
+    }
      CBox()->SetValue(m_startValue);
      CBox()->SetFocus();
  }
      CBox()->SetValue(m_startValue);
      CBox()->SetFocus();
  }
@@ -910,22 +1233,57 @@ void wxGridCellBoolEditor::StartingClick()
      CBox()->SetValue(!CBox()->GetValue());
  }
  
      CBox()->SetValue(!CBox()->GetValue());
  }
  
+bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
+{
+    if ( wxGridCellEditor::IsAcceptedKey(event) )
+    {
+        int keycode = event.GetKeyCode();
+        switch ( keycode )
+        {
+            case WXK_MULTIPLY:
+            case WXK_NUMPAD_MULTIPLY:
+            case WXK_ADD:
+            case WXK_NUMPAD_ADD:
+            case WXK_SUBTRACT:
+            case WXK_NUMPAD_SUBTRACT:
+            case WXK_SPACE:
+            case '+':
+            case '-':
+                return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellChoiceEditor
  // ----------------------------------------------------------------------------
  
  wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
  // ----------------------------------------------------------------------------
  // wxGridCellChoiceEditor
  // ----------------------------------------------------------------------------
  
  wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
-                                               const wxChar* choices[],
+                                               const wxString choices[],
                                                 bool allowOthers)
                        : m_allowOthers(allowOthers)
  {
                                                 bool allowOthers)
                        : m_allowOthers(allowOthers)
  {
-    m_choices.Alloc(count);
-    for ( size_t n = 0; n < count; n++ )
+    if ( count )
      {
      {
-        m_choices.Add(choices[n]);
+        m_choices.Alloc(count);
+        for ( size_t n = 0; n < count; n++ )
+        {
+            m_choices.Add(choices[n]);
+        }
      }
  }
  
      }
  }
  
+wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
+{
+    wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
+    editor->m_allowOthers = m_allowOthers;
+    editor->m_choices = m_choices;
+
+    return editor;
+}
+
  void wxGridCellChoiceEditor::Create(wxWindow* parent,
                                      wxWindowID id,
                                      wxEvtHandler* evtHandler)
  void wxGridCellChoiceEditor::Create(wxWindow* parent,
                                      wxWindowID id,
                                      wxEvtHandler* evtHandler)
@@ -1001,6 +1359,23 @@ void wxGridCellChoiceEditor::Reset()
      Combo()->SetInsertionPointEnd();
  }
  
      Combo()->SetInsertionPointEnd();
  }
  
+void wxGridCellChoiceEditor::SetParameters(const wxString& params)
+{
+    if ( !params )
+    {
+        // what can we do?
+        return;
+    }
+
+    m_choices.Empty();
+
+    wxStringTokenizer tk(params, _T(','));
+    while ( tk.HasMoreTokens() )
+    {
+        m_choices.Add(tk.GetNextToken());
+    }
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellEditorEvtHandler
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellEditorEvtHandler
  // ----------------------------------------------------------------------------
@@ -1018,6 +1393,7 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
              event.Skip( m_grid->ProcessEvent( event ) );
              break;
  
              event.Skip( m_grid->ProcessEvent( event ) );
              break;
  
+        case WXK_NUMPAD_ENTER:
          case WXK_RETURN:
              if (!m_grid->ProcessEvent(event))
                  m_editor->HandleReturn(event);
          case WXK_RETURN:
              if (!m_grid->ProcessEvent(event))
                  m_editor->HandleReturn(event);
@@ -1036,6 +1412,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:
@@ -1043,6 +1420,20 @@ void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
      }
  }
  
      }
  }
  
+// ----------------------------------------------------------------------------
+// wxGridCellWorker is an (almost) empty common base class for
+// wxGridCellRenderer and wxGridCellEditor managing ref counting
+// ----------------------------------------------------------------------------
+
+void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
+{
+    // nothing to do
+}
+
+wxGridCellWorker::~wxGridCellWorker()
+{
+}
+
  // ============================================================================
  // renderer classes
  // ============================================================================
  // ============================================================================
  // renderer classes
  // ============================================================================
@@ -1055,7 +1446,7 @@ void wxGridCellRenderer::Draw(wxGrid& grid,
                                wxGridCellAttr& attr,
                                wxDC& dc,
                                const wxRect& rect,
                                wxGridCellAttr& attr,
                                wxDC& dc,
                                const wxRect& rect,
-                              int row, int col,
+                              int WXUNUSED(row), int WXUNUSED(col),
                                bool isSelected)
  {
      dc.SetBackgroundMode( wxSOLID );
                                bool isSelected)
  {
      dc.SetBackgroundMode( wxSOLID );
@@ -1073,10 +1464,6 @@ void wxGridCellRenderer::Draw(wxGrid& grid,
      dc.DrawRectangle(rect);
  }
  
      dc.DrawRectangle(rect);
  }
  
-wxGridCellRenderer::~wxGridCellRenderer()
-{
-}
-
  // ----------------------------------------------------------------------------
  // wxGridCellStringRenderer
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellStringRenderer
  // ----------------------------------------------------------------------------
@@ -1108,11 +1495,18 @@ wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
                                                 wxDC& dc,
                                                 const wxString& text)
  {
                                                 wxDC& dc,
                                                 const wxString& text)
  {
-    wxCoord x, y;
+    wxCoord x = 0, y = 0, max_x = 0;
      dc.SetFont(attr.GetFont());
      dc.SetFont(attr.GetFont());
-    dc.GetTextExtent(text, &x, &y);
+    wxStringTokenizer tk(text, _T('\n'));
+    while ( tk.HasMoreTokens() )
+    {
+        dc.GetTextExtent(tk.GetNextToken(), &x, &y);
+        max_x = wxMax(max_x, x);
+    }
  
  
-    return wxSize(x, y);
+    y *= 1 + text.Freq(wxT('\n')); // multiply by the number of lines.
+
+    return wxSize(max_x, y);
  }
  
  wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
  }
  
  wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
@@ -1179,7 +1573,7 @@ void wxGridCellNumberRenderer::Draw(wxGrid& grid,
      // draw the text right aligned by default
      int hAlign, vAlign;
      attr.GetAlignment(&hAlign, &vAlign);
      // draw the text right aligned by default
      int hAlign, vAlign;
      attr.GetAlignment(&hAlign, &vAlign);
-    hAlign = wxRIGHT;
+    hAlign = wxALIGN_RIGHT;
  
      wxRect rect = rectCell;
      rect.Inflate(-1);
  
      wxRect rect = rectCell;
      rect.Inflate(-1);
@@ -1205,23 +1599,57 @@ wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
      SetPrecision(precision);
  }
  
      SetPrecision(precision);
  }
  
+wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
+{
+    wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
+    renderer->m_width = m_width;
+    renderer->m_precision = m_precision;
+    renderer->m_format = m_format;
+
+    return renderer;
+}
+
  wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
  {
      wxGridTableBase *table = grid.GetTable();
  wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
  {
      wxGridTableBase *table = grid.GetTable();
+
+    bool hasDouble;
+    double val;
      wxString text;
      if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
      {
      wxString text;
      if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
      {
-        if ( !m_format )
-        {
-            m_format.Printf(_T("%%%d.%d%%f"), m_width, m_precision);
-        }
-
-        text.Printf(m_format, table->GetValueAsDouble(row, col));
+        val = table->GetValueAsDouble(row, col);
+        hasDouble = TRUE;
      }
      else
      {
          text = table->GetValue(row, col);
      }
      else
      {
          text = table->GetValue(row, col);
+        hasDouble = text.ToDouble(&val);
+    }
+
+    if ( hasDouble )
+    {
+        if ( !m_format )
+        {
+            if ( m_width == -1 )
+            {
+                // default width/precision
+                m_format = _T("%f");
+            }
+            else if ( m_precision == -1 )
+            {
+                // default precision
+                m_format.Printf(_T("%%%d.f"), m_width);
+            }
+            else
+            {
+                m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
+            }
+        }
+
+        text.Printf(m_format, val);
      }
      }
+    //else: text already contains the string
  
      return text;
  }
  
      return text;
  }
@@ -1240,7 +1668,7 @@ void wxGridCellFloatRenderer::Draw(wxGrid& grid,
      // draw the text right aligned by default
      int hAlign, vAlign;
      attr.GetAlignment(&hAlign, &vAlign);
      // draw the text right aligned by default
      int hAlign, vAlign;
      attr.GetAlignment(&hAlign, &vAlign);
-    hAlign = wxRIGHT;
+    hAlign = wxALIGN_RIGHT;
  
      wxRect rect = rectCell;
      rect.Inflate(-1);
  
      wxRect rect = rectCell;
      rect.Inflate(-1);
@@ -1256,6 +1684,53 @@ wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
      return DoGetBestSize(attr, dc, GetString(grid, row, col));
  }
  
      return DoGetBestSize(attr, dc, GetString(grid, row, col));
  }
  
+void wxGridCellFloatRenderer::SetParameters(const wxString& params)
+{
+    bool ok = TRUE;
+
+    if ( !params )
+    {
+        // reset to defaults
+        SetWidth(-1);
+        SetPrecision(-1);
+    }
+    else
+    {
+        wxString tmp = params.BeforeFirst(_T(','));
+        if ( !!tmp )
+        {
+            long width;
+            if ( !tmp.ToLong(&width) )
+            {
+                ok = FALSE;
+            }
+            else
+            {
+                SetWidth((int)width);
+
+                tmp = params.AfterFirst(_T(','));
+                if ( !!tmp )
+                {
+                    long precision;
+                    if ( !tmp.ToLong(&precision) )
+                    {
+                        ok = FALSE;
+                    }
+                    else
+                    {
+                        SetPrecision((int)precision);
+                    }
+                }
+            }
+        }
+
+        if ( !ok )
+        {
+            wxLogDebug(_T("Invalid wxGridCellFloatRenderer parameter string '%s ignored"), params.c_str());
+        }
+    }
+}
+
  // ----------------------------------------------------------------------------
  // wxGridCellBoolRenderer
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // wxGridCellBoolRenderer
  // ----------------------------------------------------------------------------
@@ -1265,11 +1740,7 @@ wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
  // FIXME these checkbox size calculations are really ugly...
  
  // between checkmark and box
  // FIXME these checkbox size calculations are really ugly...
  
  // between checkmark and box
-#ifdef __WXGTK__
-    static const wxCoord wxGRID_CHECKMARK_MARGIN = 4;
-#else
-    static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
-#endif
+static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
  
  wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
                                             wxGridCellAttr& WXUNUSED(attr),
  
  wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
                                             wxGridCellAttr& WXUNUSED(attr),
@@ -1284,7 +1755,7 @@ wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
          wxCoord checkSize = 0;
          wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
          wxSize size = checkbox->GetBestSize();
          wxCoord checkSize = 0;
          wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
          wxSize size = checkbox->GetBestSize();
-        checkSize = size.y + wxGRID_CHECKMARK_MARGIN;
+        checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
  
          // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
  #if defined(__WXGTK__) || defined(__WXMOTIF__)
  
          // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
  #if defined(__WXGTK__) || defined(__WXMOTIF__)
@@ -1320,41 +1791,47 @@ void wxGridCellBoolRenderer::Draw(wxGrid& grid,
      }
  
      // draw a border around checkmark
      }
  
      // draw a border around checkmark
-    wxRect rectMark;
-    rectMark.x = rect.x + rect.width/2 - size.x/2;
-    rectMark.y = rect.y + rect.height/2 - size.y/2;
-    rectMark.width = size.x;
-    rectMark.height = size.y;
-
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
-    dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
-    dc.DrawRectangle(rectMark);
-
-    rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
-
-#ifdef __WXMSW__
-    // looks nicer under MSW
-    rectMark.x++;
-#endif // MSW
+    wxRect rectBorder;
+    rectBorder.x = rect.x + rect.width/2 - size.x/2;
+    rectBorder.y = rect.y + rect.height/2 - size.y/2;
+    rectBorder.width = size.x;
+    rectBorder.height = size.y;
  
      bool value;
      if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
          value = grid.GetTable()->GetValueAsBool(row, col);
      else
  
      bool value;
      if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
          value = grid.GetTable()->GetValueAsBool(row, col);
      else
-        value = !!grid.GetTable()->GetValue(row, col);
+    {
+        wxString cellval( grid.GetTable()->GetValue(row, col) );
+        value = !( !cellval || (cellval == "0") );
+    }
  
      if ( value )
      {
  
      if ( value )
      {
+        wxRect rectMark = rectBorder;
+#ifdef __WXMSW__
+        // MSW DrawCheckMark() is weird (and should probably be changed...)
+        rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
+        rectMark.x++;
+        rectMark.y++;
+#else // !MSW
+        rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
+#endif // MSW/!MSW
+
          dc.SetTextForeground(attr.GetTextColour());
          dc.DrawCheckMark(rectMark);
      }
          dc.SetTextForeground(attr.GetTextColour());
          dc.DrawCheckMark(rectMark);
      }
+
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
+    dc.DrawRectangle(rectBorder);
  }
  
  // ----------------------------------------------------------------------------
  // wxGridCellAttr
  // ----------------------------------------------------------------------------
  
  }
  
  // ----------------------------------------------------------------------------
  // wxGridCellAttr
  // ----------------------------------------------------------------------------
  
-wxGridCellAttr *wxGridCellAttr::Clone()
+wxGridCellAttr *wxGridCellAttr::Clone() const
  {
      wxGridCellAttr *attr = new wxGridCellAttr;
      if ( HasTextColour() )
  {
      wxGridCellAttr *attr = new wxGridCellAttr;
      if ( HasTextColour() )
@@ -1369,12 +1846,12 @@ wxGridCellAttr *wxGridCellAttr::Clone()
      if ( m_renderer )
      {
          attr->SetRenderer(m_renderer);
      if ( m_renderer )
      {
          attr->SetRenderer(m_renderer);
-        m_renderer = NULL;
+        m_renderer->IncRef();
      }
      if ( m_editor )
      {
          attr->SetEditor(m_editor);
      }
      if ( m_editor )
      {
          attr->SetEditor(m_editor);
-        m_editor = NULL;
+        m_editor->IncRef();
      }
  
      if ( IsReadOnly() )
      }
  
      if ( IsReadOnly() )
@@ -1456,38 +1933,58 @@ void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
  
  wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
  {
  
  wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
  {
-    if ((m_defGridAttr != this || grid == NULL) && HasRenderer())
-        return m_renderer;      // use local attribute
-
      wxGridCellRenderer* renderer = NULL;
      wxGridCellRenderer* renderer = NULL;
-    if (grid)                   // get renderer for the data type
-        renderer =  grid->GetDefaultRendererForCell(row, col);
  
  
-    if (! renderer)
+    if ( m_defGridAttr != this || grid == NULL )
+    {
+        renderer = m_renderer;      // use local attribute
+        if ( renderer )
+            renderer->IncRef();
+    }
+
+    if ( !renderer && grid )        // get renderer for the data type
+    {
+        // GetDefaultRendererForCell() will do IncRef() for us
+        renderer = grid->GetDefaultRendererForCell(row, col);
+    }
+
+    if ( !renderer )
+    {
          // if we still don't have one then use the grid default
          // if we still don't have one then use the grid default
+        // (no need for IncRef() here neither)
          renderer = m_defGridAttr->GetRenderer(NULL,0,0);
          renderer = m_defGridAttr->GetRenderer(NULL,0,0);
+    }
  
  
-    if (! renderer)
+    if ( !renderer)
+    {
          wxFAIL_MSG(wxT("Missing default cell attribute"));
          wxFAIL_MSG(wxT("Missing default cell attribute"));
+    }
  
      return renderer;
  }
  
  wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
  {
  
      return renderer;
  }
  
  wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
  {
-    if ((m_defGridAttr != this || grid == NULL) && HasEditor())
-        return m_editor;      // use local attribute
-
      wxGridCellEditor* editor = NULL;
      wxGridCellEditor* editor = NULL;
-    if (grid)                   // get renderer for the data type
-        editor =  grid->GetDefaultEditorForCell(row, col);
  
  
-    if (! editor)
+    if ( m_defGridAttr != this || grid == NULL )
+    {
+        editor = m_editor;      // use local attribute
+        if ( editor )
+            editor->IncRef();
+    }
+
+    if ( !editor && grid )                   // get renderer for the data type
+        editor = grid->GetDefaultEditorForCell(row, col);
+
+    if ( !editor )
          // if we still don't have one then use the grid default
          editor = m_defGridAttr->GetEditor(NULL,0,0);
  
          // if we still don't have one then use the grid default
          editor = m_defGridAttr->GetEditor(NULL,0,0);
  
-    if (! editor)
+    if ( !editor )
+    {
          wxFAIL_MSG(wxT("Missing default cell attribute"));
          wxFAIL_MSG(wxT("Missing default cell attribute"));
+    }
  
      return editor;
  }
  
      return editor;
  }
@@ -1643,8 +2140,8 @@ wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
  
  void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
  {
  
  void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
  {
-    int n = m_rowsOrCols.Index(rowOrCol);
-    if ( n == wxNOT_FOUND )
+    int i = m_rowsOrCols.Index(rowOrCol);
+    if ( i == wxNOT_FOUND )
      {
          // add the attribute
          m_rowsOrCols.Add(rowOrCol);
      {
          // add the attribute
          m_rowsOrCols.Add(rowOrCol);
@@ -1652,17 +2149,19 @@ void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
      }
      else
      {
      }
      else
      {
+        size_t n = (size_t)i;
          if ( attr )
          {
              // change the attribute
          if ( attr )
          {
              // change the attribute
-            m_attrs[(size_t)n] = attr;
+            m_attrs[n]->DecRef();
+            m_attrs[n] = attr;
          }
          else
          {
              // remove this attribute
          }
          else
          {
              // remove this attribute
-            m_attrs[(size_t)n]->DecRef();
-            m_rowsOrCols.RemoveAt((size_t)n);
-            m_attrs.RemoveAt((size_t)n);
+            m_attrs[n]->DecRef();
+            m_rowsOrCols.RemoveAt(n);
+            m_attrs.RemoveAt(n);
          }
      }
  }
          }
      }
  }
@@ -1801,42 +2300,136 @@ void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
                                            wxGridCellRenderer* renderer,
                                            wxGridCellEditor* editor)
  {
                                            wxGridCellRenderer* renderer,
                                            wxGridCellEditor* editor)
  {
-    int loc;
      wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
  
      // is it already registered?
      wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
  
      // is it already registered?
-    if ((loc = FindDataType(typeName)) != -1) {
+    int loc = FindRegisteredDataType(typeName);
+    if ( loc != wxNOT_FOUND )
+    {
          delete m_typeinfo[loc];
          m_typeinfo[loc] = info;
      }
          delete m_typeinfo[loc];
          m_typeinfo[loc] = info;
      }
-    else {
+    else
+    {
          m_typeinfo.Add(info);
      }
  }
  
          m_typeinfo.Add(info);
      }
  }
  
+int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
+{
+    size_t count = m_typeinfo.GetCount();
+    for ( size_t i = 0; i < count; i++ )
+    {
+        if ( typeName == m_typeinfo[i]->m_typeName )
+        {
+            return i;
+        }
+    }
+
+    return wxNOT_FOUND;
+}
+
  int wxGridTypeRegistry::FindDataType(const wxString& typeName)
  {
  int wxGridTypeRegistry::FindDataType(const wxString& typeName)
  {
-    int found = -1;
+    int index = FindRegisteredDataType(typeName);
+    if ( index == wxNOT_FOUND )
+    {
+        // check whether this is one of the standard ones, in which case
+        // register it "on the fly"
+        if ( typeName == wxGRID_VALUE_STRING )
+        {
+            RegisterDataType(wxGRID_VALUE_STRING,
+                             new wxGridCellStringRenderer,
+                             new wxGridCellTextEditor);
+        }
+        else if ( typeName == wxGRID_VALUE_BOOL )
+        {
+            RegisterDataType(wxGRID_VALUE_BOOL,
+                             new wxGridCellBoolRenderer,
+                             new wxGridCellBoolEditor);
+        }
+        else if ( typeName == wxGRID_VALUE_NUMBER )
+        {
+            RegisterDataType(wxGRID_VALUE_NUMBER,
+                             new wxGridCellNumberRenderer,
+                             new wxGridCellNumberEditor);
+        }
+        else if ( typeName == wxGRID_VALUE_FLOAT )
+        {
+            RegisterDataType(wxGRID_VALUE_FLOAT,
+                             new wxGridCellFloatRenderer,
+                             new wxGridCellFloatEditor);
+        }
+        else if ( typeName == wxGRID_VALUE_CHOICE )
+        {
+            RegisterDataType(wxGRID_VALUE_CHOICE,
+                             new wxGridCellStringRenderer,
+                             new wxGridCellChoiceEditor);
+        }
+        else
+        {
+            return wxNOT_FOUND;
+        }
  
  
-    for (size_t i=0; i<m_typeinfo.Count(); i++) {
-        if (typeName == m_typeinfo[i]->m_typeName) {
-            found = i;
-            break;
+        // we get here only if just added the entry for this type, so return
+        // the last index
+        index = m_typeinfo.GetCount() - 1;
+    }
+
+    return index;
+}
+
+int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
+{
+    int index = FindDataType(typeName);
+    if ( index == wxNOT_FOUND )
+    {
+        // the first part of the typename is the "real" type, anything after ':'
+        // are the parameters for the renderer
+        index = FindDataType(typeName.BeforeFirst(_T(':')));
+        if ( index == wxNOT_FOUND )
+        {
+            return wxNOT_FOUND;
          }
          }
+
+        wxGridCellRenderer *renderer = GetRenderer(index);
+        wxGridCellRenderer *rendererOld = renderer;
+        renderer = renderer->Clone();
+        rendererOld->DecRef();
+
+        wxGridCellEditor *editor = GetEditor(index);
+        wxGridCellEditor *editorOld = editor;
+        editor = editor->Clone();
+        editorOld->DecRef();
+
+        // do it even if there are no parameters to reset them to defaults
+        wxString params = typeName.AfterFirst(_T(':'));
+        renderer->SetParameters(params);
+        editor->SetParameters(params);
+
+        // register the new typename
+        RegisterDataType(typeName, renderer, editor);
+
+        // we just registered it, it's the last one
+        index = m_typeinfo.GetCount() - 1;
      }
  
      }
  
-    return found;
+    return index;
  }
  
  wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
  {
      wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
  }
  
  wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
  {
      wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
+       if (renderer)
+               renderer->IncRef();
      return renderer;
  }
  
      return renderer;
  }
  
-wxGridCellEditor*   wxGridTypeRegistry::GetEditor(int index)
+wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
  {
      wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
  {
      wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
+       if (editor)
+               editor->IncRef();
      return editor;
  }
  
      return editor;
  }
  
@@ -1892,7 +2485,7 @@ void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
-        attr->SafeDecRef();
+        wxSafeDecRef(attr);
      }
  }
  
      }
  }
  
@@ -1906,7 +2499,7 @@ void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
-        attr->SafeDecRef();
+        wxSafeDecRef(attr);
      }
  }
  
      }
  }
  
@@ -1920,70 +2513,52 @@ void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
      {
          // as we take ownership of the pointer and don't store it, we must
          // free it now
-        attr->SafeDecRef();
-    }
-}
-
-void wxGridTableBase::UpdateAttrRows( size_t pos, int numRows )
-{
-    if ( m_attrProvider )
-    {
-        m_attrProvider->UpdateAttrRows( pos, numRows );
-    }
-}
-
-void wxGridTableBase::UpdateAttrCols( size_t pos, int numCols )
-{
-    if ( m_attrProvider )
-    {
-        m_attrProvider->UpdateAttrCols( pos, numCols );
+        wxSafeDecRef(attr);
      }
  }
  
      }
  }
  
-bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
+bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
+                                  size_t WXUNUSED(numRows) )
  {
  {
-    wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
-                    "but your derived table class does not override this function") );
+    wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
  
      return FALSE;
  }
  
  
      return FALSE;
  }
  
-bool wxGridTableBase::AppendRows( size_t numRows )
+bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
  {
  {
-    wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
-                    "but your derived table class does not override this function"));
+    wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
  
      return FALSE;
  }
  
  
      return FALSE;
  }
  
-bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
+bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
+                                  size_t WXUNUSED(numRows) )
  {
  {
-    wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
-                    "but your derived table class does not override this function"));
+    wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
  
      return FALSE;
  }
  
  
      return FALSE;
  }
  
-bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
+bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
+                                  size_t WXUNUSED(numCols) )
  {
  {
-    wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
-                  "but your derived table class does not override this function"));
+    wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
  
      return FALSE;
  }
  
  
      return FALSE;
  }
  
-bool wxGridTableBase::AppendCols( size_t numCols )
+bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
  {
  {
-    wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
-                   "but your derived table class does not override this function"));
+    wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
  
      return FALSE;
  }
  
  
      return FALSE;
  }
  
-bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
+bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
+                                  size_t WXUNUSED(numCols) )
  {
  {
-    wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
-                    "but your derived table class does not override this function"));
+    wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
  
      return FALSE;
  }
  
      return FALSE;
  }
@@ -2083,7 +2658,6 @@ void  wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
  {
  }
  
  {
  }
  
-
  //////////////////////////////////////////////////////////////////////
  //
  // Message class for the grid table to send requests and notifications
  //////////////////////////////////////////////////////////////////////
  //
  // Message class for the grid table to send requests and notifications
@@ -2148,12 +2722,12 @@ wxGridStringTable::~wxGridStringTable()
  {
  }
  
  {
  }
  
-long wxGridStringTable::GetNumberRows()
+int wxGridStringTable::GetNumberRows()
  {
      return m_data.GetCount();
  }
  
  {
      return m_data.GetCount();
  }
  
-long wxGridStringTable::GetNumberCols()
+int wxGridStringTable::GetNumberCols()
  {
      if ( m_data.GetCount() > 0 )
          return m_data[0].GetCount();
  {
      if ( m_data.GetCount() > 0 )
          return m_data[0].GetCount();
@@ -2163,26 +2737,28 @@ long wxGridStringTable::GetNumberCols()
  
  wxString wxGridStringTable::GetValue( int row, int col )
  {
  
  wxString wxGridStringTable::GetValue( int row, int col )
  {
-    // TODO: bounds checking
-    //
+    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
+                  _T("invalid row or column index in wxGridStringTable") );
+
      return m_data[row][col];
  }
  
  void wxGridStringTable::SetValue( int row, int col, const wxString& value )
  {
      return m_data[row][col];
  }
  
  void wxGridStringTable::SetValue( int row, int col, const wxString& value )
  {
-    // TODO: bounds checking
-    //
+    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
+                  _T("invalid row or column index in wxGridStringTable") );
+
      m_data[row][col] = value;
  }
  
  bool wxGridStringTable::IsEmptyCell( int row, int col )
  {
      m_data[row][col] = value;
  }
  
  bool wxGridStringTable::IsEmptyCell( int row, int col )
  {
-    // TODO: bounds checking
-    //
+    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
+                  _T("invalid row or column index in wxGridStringTable") );
+
      return (m_data[row][col] == wxEmptyString);
  }
  
      return (m_data[row][col] == wxEmptyString);
  }
  
-
  void wxGridStringTable::Clear()
  {
      int row, col;
  void wxGridStringTable::Clear()
  {
      int row, col;
@@ -2209,7 +2785,8 @@ bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
      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() : 0 );
+    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
+                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      if ( pos >= curNumRows )
      {
  
      if ( pos >= curNumRows )
      {
@@ -2227,7 +2804,6 @@ bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
      {
          m_data.Insert( sa, row );
      }
      {
          m_data.Insert( sa, row );
      }
-    UpdateAttrRows( pos, numRows );
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -2246,7 +2822,8 @@ bool wxGridStringTable::AppendRows( size_t numRows )
      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() : 0 );
+    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
+                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      wxArrayString sa;
      if ( curNumCols > 0 )
  
      wxArrayString sa;
      if ( curNumCols > 0 )
@@ -2284,10 +2861,9 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
      if ( pos >= curNumRows )
      {
          wxString errmsg;
      if ( pos >= curNumRows )
      {
          wxString errmsg;
-        errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
-                      "Pos value is invalid for present table with %d rows",
+        errmsg.Printf(wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
                        pos, numRows, curNumRows );
                        pos, numRows, curNumRows );
-        wxFAIL_MSG( wxT(errmsg) );
+        wxFAIL_MSG( errmsg );
          return FALSE;
      }
  
          return FALSE;
      }
  
@@ -2307,7 +2883,6 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
              m_data.Remove( pos );
          }
      }
              m_data.Remove( pos );
          }
      }
-    UpdateAttrRows( pos, -((int)numRows) );
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -2326,7 +2901,8 @@ 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() : 0 );
+    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
+                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      if ( pos >= curNumCols )
      {
  
      if ( pos >= curNumCols )
      {
@@ -2340,7 +2916,6 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
              m_data[row].Insert( wxEmptyString, col );
          }
      }
              m_data[row].Insert( wxEmptyString, col );
          }
      }
-    UpdateAttrCols( pos, numCols );
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -2359,14 +2934,15 @@ bool wxGridStringTable::AppendCols( size_t numCols )
      size_t row, n;
  
      size_t curNumRows = m_data.GetCount();
      size_t row, n;
  
      size_t curNumRows = m_data.GetCount();
+#if 0
      if ( !curNumRows )
      {
          // TODO: something better than this ?
          //
      if ( !curNumRows )
      {
          // TODO: something better than this ?
          //
-        wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
-                        "Call AppendRows() first") );
+        wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
          return FALSE;
      }
          return FALSE;
      }
+#endif
  
      for ( row = 0;  row < curNumRows;  row++ )
      {
  
      for ( row = 0;  row < curNumRows;  row++ )
      {
@@ -2393,15 +2969,15 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
      size_t row, n;
  
      size_t curNumRows = m_data.GetCount();
      size_t row, n;
  
      size_t curNumRows = m_data.GetCount();
-    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
+    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
+                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );
  
      if ( pos >= curNumCols )
      {
          wxString errmsg;
  
      if ( pos >= curNumCols )
      {
          wxString errmsg;
-        errmsg.Printf( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
-                        "Pos value is invalid for present table with %d cols",
+        errmsg.Printf( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
                          pos, numCols, curNumCols );
                          pos, numCols, curNumCols );
-        wxFAIL_MSG( wxT( errmsg ) );
+        wxFAIL_MSG( errmsg );
          return FALSE;
      }
  
          return FALSE;
      }
  
@@ -2424,7 +3000,6 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
              }
          }
      }
              }
          }
      }
-    UpdateAttrCols( pos, -((int)numCols) );
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
      if ( GetView() )
      {
          wxGridTableMessage msg( this,
@@ -2507,6 +3082,7 @@ BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
      EVT_PAINT( wxGridRowLabelWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
      EVT_PAINT( wxGridRowLabelWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
+    EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
  END_EVENT_TABLE()
  
  wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
  END_EVENT_TABLE()
  
  wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
@@ -2517,7 +3093,7 @@ wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
      m_owner = parent;
  }
  
      m_owner = parent;
  }
  
-void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
+void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
      wxPaintDC dc(this);
  
  {
      wxPaintDC dc(this);
  
@@ -2550,6 +3126,11 @@ void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
+void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
  
  
  //////////////////////////////////////////////////////////////////////
  
  
  //////////////////////////////////////////////////////////////////////
@@ -2560,6 +3141,7 @@ BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
      EVT_PAINT( wxGridColLabelWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
      EVT_PAINT( wxGridColLabelWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
+    EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
  END_EVENT_TABLE()
  
  wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
  END_EVENT_TABLE()
  
  wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
@@ -2570,7 +3152,7 @@ wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
      m_owner = parent;
  }
  
      m_owner = parent;
  }
  
-void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
+void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
      wxPaintDC dc(this);
  
  {
      wxPaintDC dc(this);
  
@@ -2603,6 +3185,11 @@ void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
+void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
  
  
  //////////////////////////////////////////////////////////////////////
  
  
  //////////////////////////////////////////////////////////////////////
@@ -2613,6 +3200,7 @@ BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
      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 )
+    EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
  END_EVENT_TABLE()
  
  wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
  END_EVENT_TABLE()
  
  wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
@@ -2655,6 +3243,11 @@ void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
+void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
  
  
  //////////////////////////////////////////////////////////////////////
  
  
  //////////////////////////////////////////////////////////////////////
@@ -2665,6 +3258,7 @@ BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
      EVT_PAINT( wxGridWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
      EVT_PAINT( wxGridWindow::OnPaint )
      EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
      EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
+    EVT_KEY_UP( wxGridWindow::OnKeyUp )
      EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
  END_EVENT_TABLE()
  
      EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
  END_EVENT_TABLE()
  
@@ -2715,7 +3309,7 @@ void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
  }
  
  
  }
  
  
-// This seems to be required for wxMotif otherwise the mouse
+// 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 )
  // cursor must be in the cell edit control to get key events
  //
  void wxGridWindow::OnKeyDown( wxKeyEvent& event )
@@ -2723,8 +3317,12 @@ void wxGridWindow::OnKeyDown( wxKeyEvent& event )
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
      if ( !m_owner->ProcessEvent( event ) ) event.Skip();
  }
  
+void wxGridWindow::OnKeyUp( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
  
  
-void wxGridWindow::OnEraseBackground(wxEraseEvent& event)
+void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
  {
  }
  
  {
  }
  
@@ -2738,6 +3336,7 @@ BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
      EVT_PAINT( wxGrid::OnPaint )
      EVT_SIZE( wxGrid::OnSize )
      EVT_KEY_DOWN( wxGrid::OnKeyDown )
      EVT_PAINT( wxGrid::OnPaint )
      EVT_SIZE( wxGrid::OnSize )
      EVT_KEY_DOWN( wxGrid::OnKeyDown )
+    EVT_KEY_UP( wxGrid::OnKeyUp )
      EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
  END_EVENT_TABLE()
  
      EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
  END_EVENT_TABLE()
  
@@ -2748,7 +3347,8 @@ wxGrid::wxGrid( wxWindow *parent,
                   long style,
                   const wxString& name )
    : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
                   long style,
                   const wxString& name )
    : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
-    m_colMinWidths(wxKEY_INTEGER, GRID_HASH_SIZE)
+    m_colMinWidths(GRID_HASH_SIZE),
+    m_rowMinHeights(GRID_HASH_SIZE)
  {
      Create();
  }
  {
      Create();
  }
@@ -2757,7 +3357,7 @@ wxGrid::wxGrid( wxWindow *parent,
  wxGrid::~wxGrid()
  {
      ClearAttrCache();
  wxGrid::~wxGrid()
  {
      ClearAttrCache();
-    m_defaultCellAttr->SafeDecRef();
+    wxSafeDecRef(m_defaultCellAttr);
  
  #ifdef DEBUG_ATTR_CACHE
      size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
  
  #ifdef DEBUG_ATTR_CACHE
      size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
@@ -2771,6 +3371,7 @@ wxGrid::~wxGrid()
          delete m_table;
  
      delete m_typeRegistry;
          delete m_table;
  
      delete m_typeRegistry;
+    delete m_selection;
  }
  
  
  }
  
  
@@ -2781,7 +3382,6 @@ wxGrid::~wxGrid()
  void wxGrid::Create()
  {
      m_created = FALSE;    // set to TRUE by CreateGrid
  void wxGrid::Create()
  {
      m_created = FALSE;    // set to TRUE by CreateGrid
-    m_displayed = TRUE; // FALSE;  // set to TRUE by OnPaint
  
      m_table        = (wxGridTableBase *) NULL;
      m_ownTable     = FALSE;
  
      m_table        = (wxGridTableBase *) NULL;
      m_ownTable     = FALSE;
@@ -2793,7 +3393,7 @@ void wxGrid::Create()
  
      // Set default cell attributes
      m_defaultCellAttr->SetFont(GetFont());
  
      // Set default cell attributes
      m_defaultCellAttr->SetFont(GetFont());
-    m_defaultCellAttr->SetAlignment(wxLEFT, wxTOP);
+    m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
      m_defaultCellAttr->SetTextColour(
          wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
      m_defaultCellAttr->SetBackgroundColour(
      m_defaultCellAttr->SetTextColour(
          wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
      m_defaultCellAttr->SetBackgroundColour(
@@ -2809,19 +3409,9 @@ void wxGrid::Create()
      m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
      m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
  
      m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
      m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
  
-    // data type registration: register all standard data types
-    // TODO: may be allow the app to selectively disable some of them?
+    // create the type registry
      m_typeRegistry = new wxGridTypeRegistry;
      m_typeRegistry = new wxGridTypeRegistry;
-    RegisterDataType(wxGRID_VALUE_STRING,
-                     new wxGridCellStringRenderer,
-                     new wxGridCellTextEditor);
-    RegisterDataType(wxGRID_VALUE_BOOL,
-                     new wxGridCellBoolRenderer,
-                     new wxGridCellBoolEditor);
-    RegisterDataType(wxGRID_VALUE_NUMBER,
-                     new wxGridCellNumberRenderer,
-                     new wxGridCellNumberEditor);
-
+    m_selection = 0;
      // subwindow components that make up the wxGrid
      m_cornerLabelWin = new wxGridCornerLabelWindow( this,
                                                      -1,
      // subwindow components that make up the wxGrid
      m_cornerLabelWin = new wxGridCornerLabelWindow( this,
                                                      -1,
@@ -2849,29 +3439,38 @@ void wxGrid::Create()
  }
  
  
  }
  
  
-bool wxGrid::CreateGrid( int numRows, int numCols )
+bool wxGrid::CreateGrid( int numRows, int numCols,
+                         wxGrid::wxGridSelectionModes selmode )
  {
  {
-    if ( m_created )
-    {
-        wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
-        return FALSE;
-    }
-    else
-    {
-        m_numRows = numRows;
-        m_numCols = numCols;
+    wxCHECK_MSG( !m_created,
+                 FALSE,
+                 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
  
  
-        m_table = new wxGridStringTable( m_numRows, m_numCols );
-        m_table->SetView( this );
-        m_ownTable = TRUE;
-        Init();
-        m_created = TRUE;
-    }
+    m_numRows = numRows;
+    m_numCols = numCols;
+
+    m_table = new wxGridStringTable( m_numRows, m_numCols );
+    m_table->SetView( this );
+    m_ownTable = TRUE;
+    m_selection = new wxGridSelection( this, selmode );
+    Init();
+    m_created = TRUE;
  
      return m_created;
  }
  
  
      return m_created;
  }
  
-bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
+void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
+{
+    if ( !m_created )
+    {
+        wxFAIL_MSG( wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
+    }
+    else
+        m_selection->SetSelectionMode( selmode );
+}
+
+bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
+                       wxGrid::wxGridSelectionModes selmode )
  {
      if ( m_created )
      {
  {
      if ( m_created )
      {
@@ -2880,6 +3479,7 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
          // View at runtime.  Is there anything in the implmentation that would
          // prevent this?
  
          // View at runtime.  Is there anything in the implmentation that would
          // prevent this?
  
+        // At least, you now have to cope with m_selection
          wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
          return FALSE;
      }
          wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
          return FALSE;
      }
@@ -2892,6 +3492,7 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
          m_table->SetView( this );
          if (takeOwnership)
              m_ownTable = TRUE;
          m_table->SetView( this );
          if (takeOwnership)
              m_ownTable = TRUE;
+        m_selection = new wxGridSelection( this, selmode );
          Init();
          m_created = TRUE;
      }
          Init();
          m_created = TRUE;
      }
@@ -2902,12 +3503,6 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
  
  void wxGrid::Init()
  {
  
  void wxGrid::Init()
  {
-    if ( m_numRows <= 0 )
-        m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
-
-    if ( m_numCols <= 0 )
-        m_numCols = WXGRID_DEFAULT_NUMBER_COLS;
-
      m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
      m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
  
      m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
      m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
  
@@ -2930,11 +3525,11 @@ void wxGrid::Init()
      m_labelFont = this->GetFont();
      m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
  
      m_labelFont = this->GetFont();
      m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
  
-    m_rowLabelHorizAlign = wxLEFT;
-    m_rowLabelVertAlign  = wxCENTRE;
+    m_rowLabelHorizAlign = wxALIGN_LEFT;
+    m_rowLabelVertAlign  = wxALIGN_CENTRE;
  
  
-    m_colLabelHorizAlign = wxCENTRE;
-    m_colLabelVertAlign  = wxTOP;
+    m_colLabelHorizAlign = wxALIGN_CENTRE;
+    m_colLabelVertAlign  = wxALIGN_TOP;
  
      m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
      m_defaultRowHeight = m_gridWin->GetCharHeight();
  
      m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
      m_defaultRowHeight = m_gridWin->GetCharHeight();
@@ -2947,6 +3542,7 @@ void wxGrid::Init()
  
      m_gridLineColour = wxColour( 128, 128, 255 );
      m_gridLinesEnabled = TRUE;
  
      m_gridLineColour = wxColour( 128, 128, 255 );
      m_gridLinesEnabled = TRUE;
+    m_cellHighlightColour = m_gridLineColour;
  
      m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
      m_winCapture = (wxWindow *)NULL;
  
      m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
      m_winCapture = (wxWindow *)NULL;
@@ -2965,8 +3561,8 @@ void wxGrid::Init()
  
      m_currentCellCoords = wxGridNoCellCoords;
  
  
      m_currentCellCoords = wxGridNoCellCoords;
  
-    m_selectedTopLeft = wxGridNoCellCoords;
-    m_selectedBottomRight = wxGridNoCellCoords;
+    m_selectingTopLeft = wxGridNoCellCoords;
+    m_selectingBottomRight = wxGridNoCellCoords;
      m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
      m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
  
      m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
      m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
  
@@ -3063,10 +3659,10 @@ void wxGrid::CalcDimensions()
      int cw, ch;
      GetClientSize( &cw, &ch );
  
      int cw, ch;
      GetClientSize( &cw, &ch );
  
-    if ( m_numRows > 0  &&  m_numCols > 0 )
+    if ( m_numRows > 0  ||  m_numCols > 0 )
      {
      {
-        int right = GetColRight( m_numCols-1 ) + m_extraWidth;
-        int bottom = GetRowBottom( m_numRows-1 ) + m_extraHeight;
+        int right = m_numCols > 0 ? GetColRight( m_numCols-1 ) + m_extraWidth : 0;
+        int bottom = m_numRows > 0 ? GetRowBottom( m_numRows-1 ) + m_extraHeight : 0;
  
          // TODO: restore the scroll position that we had before sizing
          //
  
          // TODO: restore the scroll position that we had before sizing
          //
@@ -3104,7 +3700,9 @@ void wxGrid::CalcWindowSizes()
  bool wxGrid::Redimension( wxGridTableMessage& msg )
  {
      int i;
  bool wxGrid::Redimension( wxGridTableMessage& msg )
  {
      int i;
+    bool result = FALSE;
  
  
+#if 0
      // if we were using the default widths/heights so far, we must change them
      // now
      if ( m_colWidths.IsEmpty() )
      // if we were using the default widths/heights so far, we must change them
      // now
      if ( m_colWidths.IsEmpty() )
@@ -3116,6 +3714,7 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
      {
          InitRowHeights();
      }
      {
          InitRowHeights();
      }
+#endif
  
      switch ( msg.GetId() )
      {
  
      switch ( msg.GetId() )
      {
@@ -3123,71 +3722,99 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
          {
              size_t pos = msg.GetCommandInt();
              int numRows = msg.GetCommandInt2();
          {
              size_t pos = msg.GetCommandInt();
              int numRows = msg.GetCommandInt2();
-            for ( i = 0;  i < numRows;  i++ )
-            {
-                m_rowHeights.Insert( m_defaultRowHeight, pos );
-                m_rowBottoms.Insert( 0, pos );
-            }
+
              m_numRows += numRows;
  
              m_numRows += numRows;
  
-            int bottom = 0;
-            if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
+            if ( !m_rowHeights.IsEmpty() )
+            {
+                for ( i = 0;  i < numRows;  i++ )
+                {
+                    m_rowHeights.Insert( m_defaultRowHeight, pos );
+                    m_rowBottoms.Insert( 0, pos );
+                }
+
+                int bottom = 0;
+                if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
+
+                for ( i = pos;  i < m_numRows;  i++ )
+                {
+                    bottom += m_rowHeights[i];
+                    m_rowBottoms[i] = bottom;
+                }
+            }
+            if ( m_currentCellCoords == wxGridNoCellCoords )
+            {
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );
+            }
+            m_selection->UpdateRows( pos, numRows );
+            wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
+            if (attrProvider)
+                attrProvider->UpdateAttrRows( pos, numRows );
  
  
-            for ( i = pos;  i < m_numRows;  i++ )
+            if ( !GetBatchCount() )
              {
              {
-                bottom += m_rowHeights[i];
-                m_rowBottoms[i] = bottom;
+                CalcDimensions();
+                m_rowLabelWin->Refresh();
              }
              }
-            CalcDimensions();
          }
          }
-        return TRUE;
+        result = TRUE;
+        break;
  
          case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
          {
              int numRows = msg.GetCommandInt();
  
          case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
          {
              int numRows = msg.GetCommandInt();
-            for ( i = 0;  i < numRows;  i++ )
-            {
-                m_rowHeights.Add( m_defaultRowHeight );
-                m_rowBottoms.Add( 0 );
-            }
-
              int oldNumRows = m_numRows;
              m_numRows += numRows;
  
              int oldNumRows = m_numRows;
              m_numRows += numRows;
  
-            int bottom = 0;
-            if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
+            if ( !m_rowHeights.IsEmpty() )
+            {
+                for ( i = 0;  i < numRows;  i++ )
+                {
+                    m_rowHeights.Add( m_defaultRowHeight );
+                    m_rowBottoms.Add( 0 );
+                }
+
+                int bottom = 0;
+                if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
  
  
-            for ( i = oldNumRows;  i < m_numRows;  i++ )
+                for ( i = oldNumRows;  i < m_numRows;  i++ )
+                {
+                    bottom += m_rowHeights[i];
+                    m_rowBottoms[i] = bottom;
+                }
+            }
+            if ( m_currentCellCoords == wxGridNoCellCoords )
+            {
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );
+            }
+            if ( !GetBatchCount() )
              {
              {
-                bottom += m_rowHeights[i];
-                m_rowBottoms[i] = bottom;
+                CalcDimensions();
+                m_rowLabelWin->Refresh();
              }
              }
-            CalcDimensions();
          }
          }
-        return TRUE;
+        result = TRUE;
+        break;
  
          case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
          {
              size_t pos = msg.GetCommandInt();
              int numRows = msg.GetCommandInt2();
  
          case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
          {
              size_t pos = msg.GetCommandInt();
              int numRows = msg.GetCommandInt2();
-            for ( i = 0;  i < numRows;  i++ )
-            {
-                m_rowHeights.Remove( pos );
-                m_rowBottoms.Remove( pos );
-            }
              m_numRows -= numRows;
  
              m_numRows -= numRows;
  
-            if ( !m_numRows )
-            {
-                m_numCols = 0;
-                m_colWidths.Clear();
-                m_colRights.Clear();
-                m_currentCellCoords = wxGridNoCellCoords;
-            }
-            else
+            if ( !m_rowHeights.IsEmpty() )
              {
              {
-                if ( m_currentCellCoords.GetRow() >= m_numRows )
-                    m_currentCellCoords.Set( 0, 0 );
+                for ( i = 0;  i < numRows;  i++ )
+                {
+                    m_rowHeights.Remove( pos );
+                    m_rowBottoms.Remove( pos );
+                }
  
                  int h = 0;
                  for ( i = 0;  i < m_numRows;  i++ )
  
                  int h = 0;
                  for ( i = 0;  i < m_numRows;  i++ )
@@ -3196,82 +3823,134 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                      m_rowBottoms[i] = h;
                  }
              }
                      m_rowBottoms[i] = h;
                  }
              }
-
-            CalcDimensions();
+            if ( !m_numRows )
+            {
+                m_currentCellCoords = wxGridNoCellCoords;
+            }
+            else
+            {
+                if ( m_currentCellCoords.GetRow() >= m_numRows )
+                    m_currentCellCoords.Set( 0, 0 );
+            }
+            m_selection->UpdateRows( 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
+                // No need to touch column attributes, unless we
+                // removed _all_ rows, in this case, we remove
+                // all column attributes.
+                // I hate to do this here, but the
+                // needed data is not available inside UpdateAttrRows.
+                if ( !GetNumberRows() )
+                    attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
+#endif
+            }
+            if ( !GetBatchCount() )
+            {
+                CalcDimensions();
+                m_rowLabelWin->Refresh();
+            }
          }
          }
-        return TRUE;
+        result = TRUE;
+        break;
  
          case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
          {
              size_t pos = msg.GetCommandInt();
              int numCols = msg.GetCommandInt2();
  
          case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
          {
              size_t pos = msg.GetCommandInt();
              int numCols = msg.GetCommandInt2();
-            for ( i = 0;  i < numCols;  i++ )
-            {
-                m_colWidths.Insert( m_defaultColWidth, pos );
-                m_colRights.Insert( 0, pos );
-            }
              m_numCols += numCols;
  
              m_numCols += numCols;
  
-            int right = 0;
-            if ( pos > 0 ) right = m_colRights[pos-1];
+            if ( !m_colWidths.IsEmpty() )
+            {
+                for ( i = 0;  i < numCols;  i++ )
+                {
+                    m_colWidths.Insert( m_defaultColWidth, pos );
+                    m_colRights.Insert( 0, pos );
+                }
+
+                int right = 0;
+                if ( pos > 0 ) right = m_colRights[pos-1];
  
  
-            for ( i = pos;  i < m_numCols;  i++ )
+                for ( i = pos;  i < m_numCols;  i++ )
+                {
+                    right += m_colWidths[i];
+                    m_colRights[i] = right;
+                }
+            }
+            if ( m_currentCellCoords == wxGridNoCellCoords )
              {
              {
-                right += m_colWidths[i];
-                m_colRights[i] = right;
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );
              }
              }
-            CalcDimensions();
+            m_selection->UpdateCols( pos, numCols );
+            wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
+            if (attrProvider)
+                attrProvider->UpdateAttrCols( pos, numCols );
+            if ( !GetBatchCount() )
+            {
+                CalcDimensions();
+                m_colLabelWin->Refresh();
+            }
+
          }
          }
-        return TRUE;
+        result = TRUE;
+        break;
  
          case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
          {
              int numCols = msg.GetCommandInt();
  
          case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
          {
              int numCols = msg.GetCommandInt();
-            for ( i = 0;  i < numCols;  i++ )
-            {
-                m_colWidths.Add( m_defaultColWidth );
-                m_colRights.Add( 0 );
-            }
-
              int oldNumCols = m_numCols;
              m_numCols += numCols;
              int oldNumCols = m_numCols;
              m_numCols += numCols;
+            if ( !m_colWidths.IsEmpty() )
+            {
+                for ( i = 0;  i < numCols;  i++ )
+                {
+                    m_colWidths.Add( m_defaultColWidth );
+                    m_colRights.Add( 0 );
+                }
  
  
-            int right = 0;
-            if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
+                int right = 0;
+                if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
  
  
-            for ( i = oldNumCols;  i < m_numCols;  i++ )
+                for ( i = oldNumCols;  i < m_numCols;  i++ )
+                {
+                    right += m_colWidths[i];
+                    m_colRights[i] = right;
+                }
+            }
+            if ( m_currentCellCoords == wxGridNoCellCoords )
+            {
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );
+            }
+            if ( !GetBatchCount() )
              {
              {
-                right += m_colWidths[i];
-                m_colRights[i] = right;
+                CalcDimensions();
+                m_colLabelWin->Refresh();
              }
              }
-            CalcDimensions();
          }
          }
-        return TRUE;
+        result = TRUE;
+        break;
  
          case wxGRIDTABLE_NOTIFY_COLS_DELETED:
          {
              size_t pos = msg.GetCommandInt();
              int numCols = msg.GetCommandInt2();
  
          case wxGRIDTABLE_NOTIFY_COLS_DELETED:
          {
              size_t pos = msg.GetCommandInt();
              int numCols = msg.GetCommandInt2();
-            for ( i = 0;  i < numCols;  i++ )
-            {
-                m_colWidths.Remove( pos );
-                m_colRights.Remove( pos );
-            }
              m_numCols -= numCols;
  
              m_numCols -= numCols;
  
-            if ( !m_numCols )
+            if ( !m_colWidths.IsEmpty() )
              {
              {
-#if 0  // leave the row alone here so that AppendCols will work subsequently
-                m_numRows = 0;
-                m_rowHeights.Clear();
-                m_rowBottoms.Clear();
-#endif
-                m_currentCellCoords = wxGridNoCellCoords;
-            }
-            else
-            {
-                if ( m_currentCellCoords.GetCol() >= m_numCols )
-                    m_currentCellCoords.Set( 0, 0 );
+                for ( i = 0;  i < numCols;  i++ )
+                {
+                    m_colWidths.Remove( pos );
+                    m_colRights.Remove( pos );
+                }
  
                  int w = 0;
                  for ( i = 0;  i < m_numCols;  i++ )
  
                  int w = 0;
                  for ( i = 0;  i < m_numCols;  i++ )
@@ -3280,16 +3959,51 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                      m_colRights[i] = w;
                  }
              }
                      m_colRights[i] = w;
                  }
              }
-            CalcDimensions();
+            if ( !m_numCols )
+            {
+                m_currentCellCoords = wxGridNoCellCoords;
+            }
+            else
+            {
+                if ( m_currentCellCoords.GetCol() >= m_numCols )
+                  m_currentCellCoords.Set( 0, 0 );
+            }
+            m_selection->UpdateCols( 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
+                // No need to touch row attributes, unless we
+                // removed _all_ columns, in this case, we remove
+                // all row attributes.
+                // I hate to do this here, but the
+                // needed data is not available inside UpdateAttrCols.
+                if ( !GetNumberCols() )
+                    attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
+#endif
+            }
+            if ( !GetBatchCount() )
+            {
+                CalcDimensions();
+                m_colLabelWin->Refresh();
+            }
+            return TRUE;
          }
          }
-        return TRUE;
+#if 0
+// There is no path to this code !!!!!!
+       result = TRUE;
+        break;
+#endif
      }
  
      }
  
-    return FALSE;
+    if (result && !GetBatchCount() )
+        m_gridWin->Refresh();
+    return result;
  }
  
  
  }
  
  
-void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
+void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  {
      wxRegionIterator iter( reg );
      wxRect r;
@@ -3338,7 +4052,7 @@ void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
  }
  
  
  }
  
  
-void wxGrid::CalcColLabelsExposed( wxRegion& reg )
+void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  {
      wxRegionIterator iter( reg );
      wxRect r;
@@ -3387,7 +4101,7 @@ void wxGrid::CalcColLabelsExposed( wxRegion& reg )
  }
  
  
  }
  
  
-void wxGrid::CalcCellsExposed( wxRegion& reg )
+void wxGrid::CalcCellsExposed( const wxRegion& reg )
  {
      wxRegionIterator iter( reg );
      wxRect r;
  {
      wxRegionIterator iter( reg );
      wxRect r;
@@ -3474,7 +4188,9 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
  
                      wxClientDC dc( m_gridWin );
                      PrepareDC( dc );
  
                      wxClientDC dc( m_gridWin );
                      PrepareDC( dc );
-                    y = wxMax( y, GetRowTop(m_dragRowOrCol) + WXGRID_MIN_ROW_HEIGHT );
+                    y = wxMax( y,
+                               GetRowTop(m_dragRowOrCol) +
+                               GetRowMinimalHeight(m_dragRowOrCol) );
                      dc.SetLogicalFunction(wxINVERT);
                      if ( m_dragLastPos >= 0 )
                      {
                      dc.SetLogicalFunction(wxINVERT);
                      if ( m_dragLastPos >= 0 )
                      {
@@ -3486,10 +4202,13 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                  break;
  
                  case WXGRID_CURSOR_SELECT_ROW:
                  break;
  
                  case WXGRID_CURSOR_SELECT_ROW:
-                    if ( (row = YToRow( y )) >= 0  &&
-                         !IsInSelection( row, 0 ) )
+                    if ( (row = YToRow( y )) >= 0 )
                      {
                      {
-                        SelectRow( row, TRUE );
+                        m_selection->SelectRow( row,
+                                                event.ControlDown(),
+                                                event.ShiftDown(),
+                                                event.AltDown(),
+                                                event.MetaDown() );
                      }
  
                  // default label to suppress warnings about "enumeration value
                      }
  
                  // default label to suppress warnings about "enumeration value
@@ -3526,7 +4245,23 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
              if ( row >= 0  &&
                   !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
              {
              if ( row >= 0  &&
                   !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
              {
-                SelectRow( row, event.ShiftDown() );
+                if ( !event.ShiftDown() && !event.ControlDown() )
+                    ClearSelection();
+                if ( event.ShiftDown() )
+                    m_selection->SelectBlock( m_currentCellCoords.GetRow(),
+                                              0,
+                                              row,
+                                              GetNumberCols() - 1,
+                                              event.ControlDown(),
+                                              event.ShiftDown(),
+                                              event.AltDown(),
+                                              event.MetaDown() );
+                else
+                    m_selection->SelectRow( row,
+                                            event.ControlDown(),
+                                            event.ShiftDown(),
+                                            event.AltDown(),
+                                            event.MetaDown() );
                  ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
              }
          }
                  ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
              }
          }
@@ -3653,10 +4388,13 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                  break;
  
                  case WXGRID_CURSOR_SELECT_COL:
                  break;
  
                  case WXGRID_CURSOR_SELECT_COL:
-                    if ( (col = XToCol( x )) >= 0  &&
-                         !IsInSelection( 0, col ) )
+                    if ( (col = XToCol( x )) >= 0 )
                      {
                      {
-                        SelectCol( col, TRUE );
+                        m_selection->SelectCol( col,
+                                                event.ControlDown(),
+                                                event.ShiftDown(),
+                                                event.AltDown(),
+                                                event.MetaDown() );
                      }
  
                  // default label to suppress warnings about "enumeration value
                      }
  
                  // default label to suppress warnings about "enumeration value
@@ -3693,7 +4431,22 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
              if ( col >= 0  &&
                   !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
              {
              if ( col >= 0  &&
                   !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
              {
-                SelectCol( col, event.ShiftDown() );
+                if ( !event.ShiftDown() && !event.ControlDown() )
+                    ClearSelection();
+                if ( event.ShiftDown() )
+                    m_selection->SelectBlock( 0,
+                                              m_currentCellCoords.GetCol(),
+                                              GetNumberRows() - 1, col,
+                                              event.ControlDown(),
+                                              event.ShiftDown(),
+                                              event.AltDown(),
+                                              event.MetaDown() );
+                else
+                    m_selection->SelectCol( col,
+                                            event.ControlDown(),
+                                            event.ShiftDown(),
+                                            event.AltDown(),
+                                            event.MetaDown() );
                  ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
              }
          }
                  ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
              }
          }
@@ -3914,7 +4667,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
          {
              // 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 ( IsCellEditControlEnabled() )
+            if ( IsCellEditControlShown() )
              {
                  HideCellEditControl();
                  SaveEditControlValue();
              {
                  HideCellEditControl();
                  SaveEditControlValue();
@@ -3929,20 +4682,29 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
  
              if ( coords != wxGridNoCellCoords )
              {
  
              if ( coords != wxGridNoCellCoords )
              {
-                if ( !IsSelection() )
+                if ( event.ControlDown() )
                  {
                  {
-                    SelectBlock( coords, coords );
+                    if ( m_selectingKeyboard == wxGridNoCellCoords)
+                        m_selectingKeyboard = coords;
+                    HighlightBlock ( m_selectingKeyboard, coords );
                  }
                  else
                  {
                  }
                  else
                  {
-                    SelectBlock( m_currentCellCoords, coords );
+                    if ( !IsSelection() )
+                    {
+                        HighlightBlock( coords, coords );
+                    }
+                    else
+                    {
+                        HighlightBlock( m_currentCellCoords, coords );
+                    }
                  }
  
                  if (! IsVisible(coords))
                  {
                      MakeCellVisible(coords);
                      // TODO: need to introduce a delay or something here.  The
                  }
  
                  if (! IsVisible(coords))
                  {
                      MakeCellVisible(coords);
                      // TODO: need to introduce a delay or something here.  The
-                    // scrolling is way to fast, at least on MSW.
+                    // scrolling is way to fast, at least on MSW - also on GTK.
                  }
              }
          }
                  }
              }
          }
@@ -3954,7 +4716,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
  
              wxClientDC dc( m_gridWin );
              PrepareDC( dc );
  
              wxClientDC dc( m_gridWin );
              PrepareDC( dc );
-            y = wxMax( y, GetRowTop(m_dragRowOrCol) + WXGRID_MIN_ROW_HEIGHT );
+            y = wxMax( y, GetRowTop(m_dragRowOrCol) +
+                          GetRowMinimalHeight(m_dragRowOrCol) );
              dc.SetLogicalFunction(wxINVERT);
              if ( m_dragLastPos >= 0 )
              {
              dc.SetLogicalFunction(wxINVERT);
              if ( m_dragLastPos >= 0 )
              {
@@ -4004,17 +4767,26 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
      //
      if ( event.LeftDown() && coords != wxGridNoCellCoords )
      {
      //
      if ( event.LeftDown() && coords != wxGridNoCellCoords )
      {
-        if ( event.ShiftDown() )
-        {
-            SelectBlock( m_currentCellCoords, coords );
-        }
-        else if ( XToEdgeOfCol(x) < 0  &&
-                  YToEdgeOfRow(y) < 0 )
+        if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
+                       coords.GetRow(),
+                       coords.GetCol(),
+                       event ) )
          {
          {
-            if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
-                             coords.GetRow(),
-                             coords.GetCol(),
-                             event ) )
+            if ( !event.ControlDown() )
+                ClearSelection();
+            if ( event.ShiftDown() )
+            {
+                m_selection->SelectBlock( m_currentCellCoords.GetRow(),
+                                          m_currentCellCoords.GetCol(),
+                                          coords.GetRow(),
+                                          coords.GetCol(),
+                                          event.ControlDown(),
+                                          event.ShiftDown(),
+                                          event.AltDown(),
+                                          event.MetaDown() );
+            }
+            else if ( XToEdgeOfCol(x) < 0  &&
+                      YToEdgeOfRow(y) < 0 )
              {
                  DisableCellEditControl();
                  MakeCellVisible( coords );
              {
                  DisableCellEditControl();
                  MakeCellVisible( coords );
@@ -4028,14 +4800,36 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                      EnableCellEditControl();
  
                      wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
                      EnableCellEditControl();
  
                      wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
-                    attr->GetEditor(this, coords.GetRow(), coords.GetCol())->StartingClick();
+                    wxGridCellEditor *editor = attr->GetEditor(this,
+                                                               coords.GetRow(),
+                                                               coords.GetCol());
+                    editor->StartingClick();
+                    editor->DecRef();
                      attr->DecRef();
  
                      m_waitForSlowClick = FALSE;
                  }
                  else
                  {
                      attr->DecRef();
  
                      m_waitForSlowClick = FALSE;
                  }
                  else
                  {
-                    SetCurrentCell( coords );
+                    if ( event.ControlDown() )
+                    {
+                        m_selection->ToggleCellSelection( coords.GetRow(),
+                                                          coords.GetCol(),
+                                                          event.ControlDown(),
+                                                          event.ShiftDown(),
+                                                          event.AltDown(),
+                                                          event.MetaDown() );
+                        m_selectingTopLeft = wxGridNoCellCoords;
+                        m_selectingBottomRight = wxGridNoCellCoords;
+                        m_selectingKeyboard = coords;
+                    }
+                    else
+                    {
+                        SetCurrentCell( coords );
+                        if ( m_selection->GetSelectionMode()
+                             != wxGrid::wxGridSelectCells)
+                            HighlightBlock( coords, coords );
+                    }
                      m_waitForSlowClick = TRUE;
                  }
              }
                      m_waitForSlowClick = TRUE;
                  }
              }
@@ -4065,14 +4859,24 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
      {
          if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
          {
      {
          if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
          {
-            if ( IsSelection() )
+            if ( m_selectingTopLeft != wxGridNoCellCoords &&
+                 m_selectingBottomRight != wxGridNoCellCoords )
              {
                  if (m_winCapture)
                  {
                      m_winCapture->ReleaseMouse();
                      m_winCapture = NULL;
                  }
              {
                  if (m_winCapture)
                  {
                      m_winCapture->ReleaseMouse();
                      m_winCapture = NULL;
                  }
-                SendEvent( wxEVT_GRID_RANGE_SELECT, -1, -1, event );
+                m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
+                                          m_selectingTopLeft.GetCol(),
+                                          m_selectingBottomRight.GetRow(),
+                                          m_selectingBottomRight.GetCol(),
+                                          event.ControlDown(),
+                                          event.ShiftDown(),
+                                          event.AltDown(),
+                                          event.MetaDown() );
+                m_selectingTopLeft = wxGridNoCellCoords;
+                m_selectingBottomRight = wxGridNoCellCoords;
              }
  
              // Show the edit control, if it has been hidden for
              }
  
              // Show the edit control, if it has been hidden for
@@ -4331,40 +5135,12 @@ bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
-        bool ok = m_table->InsertRows( pos, numRows );
+        return m_table->InsertRows( pos, numRows );
  
          // the table will have sent the results of the insert row
          // operation to this view object as a grid table message
  
          // the table will have sent the results of the insert row
          // operation to this view object as a grid table message
-        //
-        if ( ok )
-        {
-            if ( m_numCols == 0 )
-            {
-                m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
-                //
-                // TODO: perhaps instead of appending the default number of cols
-                // we should remember what the last non-zero number of cols was ?
-                //
-            }
-
-            if ( m_currentCellCoords == wxGridNoCellCoords )
-            {
-                // if we have just inserted cols into an empty grid the current
-                // cell will be undefined...
-                //
-                SetCurrentCell( 0, 0 );
-            }
-
-            ClearSelection();
-            if ( !GetBatchCount() ) Refresh();
-        }
-
-        return ok;
-    }
-    else
-    {
-        return FALSE;
      }
      }
+    return FALSE;
  }
  
  
  }
  
  
@@ -4378,27 +5154,9 @@ bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
          return FALSE;
      }
  
          return FALSE;
      }
  
-    if ( m_table && m_table->AppendRows( numRows ) )
-    {
-        if ( m_currentCellCoords == wxGridNoCellCoords )
-        {
-            // if we have just inserted cols into an empty grid the current
-            // cell will be undefined...
-            //
-            SetCurrentCell( 0, 0 );
-        }
-
-        // the table will have sent the results of the append row
-        // operation to this view object as a grid table message
-        //
-        ClearSelection();
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
+    return ( m_table && m_table->AppendRows( numRows ) );
+    // the table will have sent the results of the append row
+    // operation to this view object as a grid table message
  }
  
  
  }
  
  
@@ -4417,16 +5175,9 @@ bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
-        if (m_table->DeleteRows( pos, numRows ))
-        {
-
-            // the table will have sent the results of the delete row
-            // operation to this view object as a grid table message
-            //
-            ClearSelection();
-            if ( !GetBatchCount() ) Refresh();
-            return TRUE;
-        }
+        return (m_table->DeleteRows( pos, numRows ));
+        // the table will have sent the results of the delete row
+        // operation to this view object as a grid table message
      }
      return FALSE;
  }
      }
      return FALSE;
  }
@@ -4447,31 +5198,11 @@ bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
-        bool ok = m_table->InsertCols( pos, numCols );
-
+        return m_table->InsertCols( pos, numCols );
          // the table will have sent the results of the insert col
          // operation to this view object as a grid table message
          // the table will have sent the results of the insert col
          // operation to this view object as a grid table message
-        //
-        if ( ok )
-        {
-            if ( m_currentCellCoords == wxGridNoCellCoords )
-            {
-                // if we have just inserted cols into an empty grid the current
-                // cell will be undefined...
-                //
-                SetCurrentCell( 0, 0 );
-            }
-
-            ClearSelection();
-            if ( !GetBatchCount() ) Refresh();
-        }
-
-        return ok;
-    }
-    else
-    {
-        return FALSE;
      }
      }
+    return FALSE;
  }
  
  
  }
  
  
@@ -4485,27 +5216,9 @@ bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
          return FALSE;
      }
  
          return FALSE;
      }
  
-    if ( m_table && m_table->AppendCols( numCols ) )
-    {
-        // the table will have sent the results of the append col
-        // operation to this view object as a grid table message
-        //
-        if ( m_currentCellCoords == wxGridNoCellCoords )
-        {
-            // if we have just inserted cols into an empty grid the current
-            // cell will be undefined...
-            //
-            SetCurrentCell( 0, 0 );
-        }
-
-        ClearSelection();
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
+    return ( m_table && m_table->AppendCols( numCols ) );
+    // the table will have sent the results of the append col
+    // operation to this view object as a grid table message
  }
  
  
  }
  
  
@@ -4524,15 +5237,9 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
          if (IsCellEditControlEnabled())
              DisableCellEditControl();
  
-        if ( m_table->DeleteCols( pos, numCols ) )
-        {
-            // the table will have sent the results of the delete col
-            // operation to this view object as a grid table message
-            //
-            ClearSelection();
-            if ( !GetBatchCount() ) Refresh();
-            return TRUE;
-        }
+        return ( m_table->DeleteCols( pos, numCols ) );
+        // the table will have sent the results of the delete col
+        // operation to this view object as a grid table message
      }
      return FALSE;
  }
      }
      return FALSE;
  }
@@ -4558,7 +5265,8 @@ bool wxGrid::SendEvent( const wxEventType type,
                                   type,
                                   this,
                                   rowOrCol,
                                   type,
                                   this,
                                   rowOrCol,
-                                 mouseEv.GetX(), mouseEv.GetY(),
+                                 mouseEv.GetX() + GetColLabelSize(),
+                                 mouseEv.GetY() + GetRowLabelSize(),
                                   mouseEv.ControlDown(),
                                   mouseEv.ShiftDown(),
                                   mouseEv.AltDown(),
                                   mouseEv.ControlDown(),
                                   mouseEv.ShiftDown(),
                                   mouseEv.AltDown(),
@@ -4568,11 +5276,13 @@ bool wxGrid::SendEvent( const wxEventType type,
      }
      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(),
                                          type,
                                          this,
          wxGridRangeSelectEvent gridEvt( GetId(),
                                          type,
                                          this,
-                                        m_selectedTopLeft,
-                                        m_selectedBottomRight,
+                                        m_selectingTopLeft,
+                                        m_selectingBottomRight,
+                                        TRUE,
                                          mouseEv.ControlDown(),
                                          mouseEv.ShiftDown(),
                                          mouseEv.AltDown(),
                                          mouseEv.ControlDown(),
                                          mouseEv.ShiftDown(),
                                          mouseEv.AltDown(),
@@ -4586,7 +5296,9 @@ bool wxGrid::SendEvent( const wxEventType type,
                               type,
                               this,
                               row, col,
                               type,
                               this,
                               row, col,
-                             mouseEv.GetX(), mouseEv.GetY(),
+                             mouseEv.GetX() + GetColLabelSize(),
+                             mouseEv.GetY() + GetRowLabelSize(),
+                             FALSE,
                               mouseEv.ControlDown(),
                               mouseEv.ShiftDown(),
                               mouseEv.AltDown(),
                               mouseEv.ControlDown(),
                               mouseEv.ShiftDown(),
                               mouseEv.AltDown(),
@@ -4628,16 +5340,7 @@ bool wxGrid::SendEvent( const wxEventType type,
  
  void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
  
  void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
  {
-    wxPaintDC dc( this );
-
-    if ( m_currentCellCoords == wxGridNoCellCoords  &&
-         m_numRows && m_numCols )
-    {
-        m_currentCellCoords.Set(0, 0);
-        ShowCellEditControl();
-    }
-
-    m_displayed = TRUE;
+    wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
  }
  
  
  }
  
  
@@ -4645,7 +5348,7 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
  // the grid view is resized... then the size event is skipped to allow
  // the box sizers to handle everything
  //
  // the grid view is resized... then the size event is skipped to allow
  // the box sizers to handle everything
  //
-void wxGrid::OnSize( wxSizeEvent& event )
+void wxGrid::OnSize( wxSizeEvent& WXUNUSED(event) )
  {
      CalcWindowSizes();
      CalcDimensions();
  {
      CalcWindowSizes();
      CalcDimensions();
@@ -4672,11 +5375,6 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
      if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
      {
  
      if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
      {
  
-        // TODO:  Should also support Shift-cursor keys for
-        //        extending the selection.  Maybe add a flag to
-        //        MoveCursorXXX() and MoveCursorXXXBlock() and
-        //        just send event.ShiftDown().
-
          // try local handlers
          //
          switch ( event.KeyCode() )
          // try local handlers
          //
          switch ( event.KeyCode() )
@@ -4684,63 +5382,99 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
              case WXK_UP:
                  if ( event.ControlDown() )
                  {
              case WXK_UP:
                  if ( event.ControlDown() )
                  {
-                    MoveCursorUpBlock();
+                    MoveCursorUpBlock( event.ShiftDown() );
                  }
                  else
                  {
                  }
                  else
                  {
-                    MoveCursorUp();
+                    MoveCursorUp( event.ShiftDown() );
                  }
                  break;
  
              case WXK_DOWN:
                  if ( event.ControlDown() )
                  {
                  }
                  break;
  
              case WXK_DOWN:
                  if ( event.ControlDown() )
                  {
-                    MoveCursorDownBlock();
+                    MoveCursorDownBlock( event.ShiftDown() );
                  }
                  else
                  {
                  }
                  else
                  {
-                    MoveCursorDown();
+                    MoveCursorDown( event.ShiftDown() );
                  }
                  break;
  
              case WXK_LEFT:
                  if ( event.ControlDown() )
                  {
                  }
                  break;
  
              case WXK_LEFT:
                  if ( event.ControlDown() )
                  {
-                    MoveCursorLeftBlock();
+                    MoveCursorLeftBlock( event.ShiftDown() );
                  }
                  else
                  {
                  }
                  else
                  {
-                    MoveCursorLeft();
+                    MoveCursorLeft( event.ShiftDown() );
                  }
                  break;
  
              case WXK_RIGHT:
                  if ( event.ControlDown() )
                  {
                  }
                  break;
  
              case WXK_RIGHT:
                  if ( event.ControlDown() )
                  {
-                    MoveCursorRightBlock();
+                    MoveCursorRightBlock( event.ShiftDown() );
                  }
                  else
                  {
                  }
                  else
                  {
-                    MoveCursorRight();
+                    MoveCursorRight( event.ShiftDown() );
                  }
                  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
                  }
                  else
                  {
                  if ( event.ControlDown() )
                  {
                      event.Skip();  // to let the edit control have the return
                  }
                  else
                  {
-                    MoveCursorDown();
+                    if ( GetGridCursorRow() < GetNumberRows()-1 )
+                    {
+                        MoveCursorDown( event.ShiftDown() );
+                    }
+                    else
+                    {
+                        // at the bottom of a column
+                        HideCellEditControl();
+                        SaveEditControlValue();
+                    }
                  }
                  break;
  
                  }
                  break;
  
+            case WXK_ESCAPE:
+                ClearSelection();
+                break;
+
              case WXK_TAB:
                  if (event.ShiftDown())
              case WXK_TAB:
                  if (event.ShiftDown())
-                    MoveCursorLeft();
+                {
+                    if ( GetGridCursorCol() > 0 )
+                    {
+                        MoveCursorLeft( FALSE );
+                    }
+                    else
+                    {
+                        // at left of grid
+                        HideCellEditControl();
+                        SaveEditControlValue();
+                    }
+                }
                  else
                  else
-                    MoveCursorRight();
+                {
+                    if ( GetGridCursorCol() < GetNumberCols()-1 )
+                    {
+                        MoveCursorRight( FALSE );
+                    }
+                    else
+                    {
+                        // at right of grid
+                        HideCellEditControl();
+                        SaveEditControlValue();
+                    }
+                }
                  break;
  
              case WXK_HOME:
                  break;
  
              case WXK_HOME:
@@ -4776,28 +5510,47 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                  break;
  
              case WXK_SPACE:
                  break;
  
              case WXK_SPACE:
+                if ( event.ControlDown() )
+                {
+                    m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
+                                                      m_currentCellCoords.GetCol(),
+                                                      event.ControlDown(),
+                                                      event.ShiftDown(),
+                                                      event.AltDown(),
+                                                      event.MetaDown() );
+                    break;
+                }
                  if ( !IsEditable() )
                  {
                  if ( !IsEditable() )
                  {
-                    MoveCursorRight();
+                    MoveCursorRight( FALSE );
                      break;
                  }
                  // Otherwise fall through to default
  
              default:
                      break;
                  }
                  // Otherwise fall through to default
  
              default:
-                // alphanumeric keys or F2 (special key just for this) enable
-                // the cell edit control
-                if ( !(event.AltDown() ||
-                       event.MetaDown() ||
-                       event.ControlDown()) &&
-                     (isalnum(event.KeyCode()) || event.KeyCode() == WXK_F2) &&
-                     !IsCellEditControlEnabled() &&
-                     CanEnableCellControl() )
+                // is it possible to edit the current cell at all?
+                if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
                  {
                  {
-                    EnableCellEditControl();
+                    // yes, now check whether the cells editor accepts the key
                      int row = m_currentCellCoords.GetRow();
                      int col = m_currentCellCoords.GetCol();
                      wxGridCellAttr* attr = GetCellAttr(row, col);
                      int row = m_currentCellCoords.GetRow();
                      int col = m_currentCellCoords.GetCol();
                      wxGridCellAttr* attr = GetCellAttr(row, col);
-                    attr->GetEditor(this, row, col)->StartingKey(event);
+                    wxGridCellEditor *editor = attr->GetEditor(this, row, col);
+
+                    // <F2> is special and will always start editing, for
+                    // other keys - ask the editor itself
+                    if ( (event.KeyCode() == WXK_F2 && !event.HasModifiers())
+                         || editor->IsAcceptedKey(event) )
+                    {
+                        EnableCellEditControl();
+                        editor->StartingKey(event);
+                    }
+                    else
+                    {
+                        event.Skip();
+                    }
+
+                    editor->DecRef();
                      attr->DecRef();
                  }
                  else
                      attr->DecRef();
                  }
                  else
@@ -4813,6 +5566,27 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
      m_inOnKeyDown = FALSE;
  }
  
      m_inOnKeyDown = FALSE;
  }
  
+void wxGrid::OnKeyUp( wxKeyEvent& event )
+{
+    // try local handlers
+    //
+    if ( event.KeyCode() == WXK_SHIFT )
+    {
+        if ( m_selectingTopLeft != wxGridNoCellCoords &&
+             m_selectingBottomRight != wxGridNoCellCoords )
+            m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
+                                      m_selectingTopLeft.GetCol(),
+                                      m_selectingBottomRight.GetRow(),
+                                      m_selectingBottomRight.GetCol(),
+                                      event.ControlDown(),
+                                      TRUE,
+                                      event.AltDown(),
+                                      event.MetaDown() );
+        m_selectingTopLeft = wxGridNoCellCoords;
+        m_selectingBottomRight = wxGridNoCellCoords;
+        m_selectingKeyboard = wxGridNoCellCoords;
+    }
+}
  
  void wxGrid::OnEraseBackground(wxEraseEvent&)
  {
  
  void wxGrid::OnEraseBackground(wxEraseEvent&)
  {
@@ -4826,131 +5600,269 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
          return;
      }
  
          return;
      }
  
-    if ( m_displayed  &&
-         m_currentCellCoords != wxGridNoCellCoords )
+    wxClientDC dc(m_gridWin);
+    PrepareDC(dc);
+
+    if ( m_currentCellCoords != wxGridNoCellCoords )
      {
          HideCellEditControl();
          DisableCellEditControl();
  
      {
          HideCellEditControl();
          DisableCellEditControl();
  
-        // Clear the old current cell highlight
-        wxRect r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
-
-        // Otherwise refresh redraws the highlight!
-        m_currentCellCoords = coords;
-
-        m_gridWin->Refresh( FALSE, &r );
-    }
-
-    m_currentCellCoords = coords;
+        if ( IsVisible( m_currentCellCoords, FALSE ) )
+        {
+            wxRect r;
+            r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
+            if ( !m_gridLinesEnabled )
+            {
+                r.x--;
+                r.y--;
+                r.width++;
+                r.height++;
+            }
  
  
-    if ( m_displayed )
-    {
-        wxClientDC dc(m_gridWin);
-        PrepareDC(dc);
+            CalcCellsExposed( r );
  
  
-        wxGridCellAttr* attr = GetCellAttr(coords);
-        DrawCellHighlight(dc, attr);
-        attr->DecRef();
+            // Otherwise refresh redraws the highlight!
+            m_currentCellCoords = coords;
  
  
-        if ( IsSelection() )
-        {
-            wxRect r( SelectionToDeviceRect() );
-            ClearSelection();
-            if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
+            DrawGridCellArea(dc);
+            DrawAllGridLines( dc, r );
          }
      }
          }
      }
-}
-
-
-//
-// ------ functions to get/send data (see also public functions)
-//
  
  
-bool wxGrid::GetModelValues()
-{
-    if ( m_table )
-    {
-        // all we need to do is repaint the grid
-        //
-        m_gridWin->Refresh();
-        return TRUE;
-    }
+    m_currentCellCoords = coords;
  
  
-    return FALSE;
+    wxGridCellAttr* attr = GetCellAttr(coords);
+    DrawCellHighlight(dc, attr);
+    attr->DecRef();
  }
  
  
  }
  
  
-bool wxGrid::SetModelValues()
+void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
  {
  {
-    int row, col;
+    int temp;
+    wxGridCellCoords updateTopLeft, updateBottomRight;
  
  
-    if ( m_table )
+    if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
      {
      {
-        for ( row = 0;  row < m_numRows;  row++ )
-        {
-            for ( col = 0;  col < m_numCols;  col++ )
-            {
-                m_table->SetValue( row, col, GetCellValue(row, col) );
-            }
-        }
-
-        return TRUE;
+        leftCol = 0;
+        rightCol = GetNumberCols() - 1;
+    }
+    else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
+    {
+        topRow = 0;
+        bottomRow = GetNumberRows() - 1;
+    }
+    if ( topRow > bottomRow )
+    {
+        temp = topRow;
+        topRow = bottomRow;
+        bottomRow = temp;
      }
  
      }
  
-    return FALSE;
-}
-
-
-
-// Note - this function only draws cells that are in the list of
-// exposed cells (usually set from the update region by
-// CalcExposedCells)
-//
-void wxGrid::DrawGridCellArea( wxDC& dc )
-{
-    if ( !m_numRows || !m_numCols ) return;
-
-    size_t i;
-    size_t numCells = m_cellsExposed.GetCount();
-
-    for ( i = 0;  i < numCells;  i++ )
+    if ( leftCol > rightCol )
      {
      {
-        DrawCell( dc, m_cellsExposed[i] );
+        temp = leftCol;
+        leftCol = rightCol;
+        rightCol = temp;
      }
      }
-}
  
  
+    updateTopLeft = wxGridCellCoords( topRow, leftCol );
+    updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
  
  
-void wxGrid::DrawGridSpace( wxDC& dc )
-{
-    if ( m_numRows  &&  m_numCols )
+    if ( m_selectingTopLeft != updateTopLeft ||
+         m_selectingBottomRight != updateBottomRight )
      {
      {
-        int cw, ch;
-        m_gridWin->GetClientSize( &cw, &ch );
+        // Compute two optimal update rectangles:
+        // Either one rectangle is a real subset of the
+        // other, or they are (almost) disjoint!
+        wxRect  rect[4];
+        bool    need_refresh[4];
+        need_refresh[0] =
+        need_refresh[1] =
+        need_refresh[2] =
+        need_refresh[3] = FALSE;
+        int     i;
  
  
-        int right, bottom;
-        CalcUnscrolledPosition( cw, ch, &right, &bottom );
+        // Store intermediate values
+        wxCoord oldLeft   = m_selectingTopLeft.GetCol();
+        wxCoord oldTop    = m_selectingTopLeft.GetRow();
+        wxCoord oldRight  = m_selectingBottomRight.GetCol();
+        wxCoord oldBottom = m_selectingBottomRight.GetRow();
  
  
-        if ( right > GetColRight(m_numCols-1)  ||
-             bottom > GetRowBottom(m_numRows-1) )
+        // Determine the outer/inner coordinates.
+        if (oldLeft > leftCol)
          {
          {
-            int left, top;
-            CalcUnscrolledPosition( 0, 0, &left, &top );
-
-            dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
-            dc.SetPen( *wxTRANSPARENT_PEN );
-
-            if ( right > GetColRight(m_numCols-1) )
-                dc.DrawRectangle( GetColRight(m_numCols-1), top,
-                                  right - GetColRight(m_numCols-1), ch );
-
-            if ( bottom > GetRowBottom(m_numRows-1) )
-                dc.DrawRectangle( left, GetRowBottom(m_numRows-1),
-                                  cw, bottom - GetRowBottom(m_numRows-1) );
+            temp = oldLeft;
+            oldLeft = leftCol;
+            leftCol = temp;
          }
          }
-    }
-}
-
-
+        if (oldTop > topRow )
+        {
+            temp = oldTop;
+            oldTop = topRow;
+            topRow = temp;
+        }
+        if (oldRight < rightCol )
+        {
+            temp = oldRight;
+            oldRight = rightCol;
+            rightCol = temp;
+        }
+        if (oldBottom < bottomRow)
+        {
+            temp = oldBottom;
+            oldBottom = bottomRow;
+            bottomRow = temp;
+        }
+
+        // Now, either the stuff marked old is the outer
+        // rectangle or we don't have a situation where one
+        // is contained in the other.
+
+        if ( oldLeft < leftCol )
+        {
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            oldLeft ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            leftCol - 1 ) );
+        }
+
+        if ( oldTop  < topRow )
+        {
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            leftCol ),
+                                         wxGridCellCoords ( topRow - 1,
+                                                            rightCol ) );
+        }
+
+        if ( oldRight > rightCol )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            rightCol + 1 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            oldRight ) );
+        }
+
+        if ( oldBottom > bottomRow )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
+                                                            leftCol ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            rightCol ) );
+        }
+
+
+        // Change Selection
+        m_selectingTopLeft = updateTopLeft;
+        m_selectingBottomRight = updateBottomRight;
+
+        // various Refresh() calls
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );
+    }
+
+    // never generate an event as it will be generated from
+    // wxGridSelection::SelectBlock!
+    // (old comment from when this was the body of SelectBlock)
+}
+
+
+//
+// ------ functions to get/send data (see also public functions)
+//
+
+bool wxGrid::GetModelValues()
+{
+    if ( m_table )
+    {
+        // all we need to do is repaint the grid
+        //
+        m_gridWin->Refresh();
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+bool wxGrid::SetModelValues()
+{
+    int row, col;
+
+    if ( m_table )
+    {
+        for ( row = 0;  row < m_numRows;  row++ )
+        {
+            for ( col = 0;  col < m_numCols;  col++ )
+            {
+                m_table->SetValue( row, col, GetCellValue(row, col) );
+            }
+        }
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+
+// Note - this function only draws cells that are in the list of
+// exposed cells (usually set from the update region by
+// CalcExposedCells)
+//
+void wxGrid::DrawGridCellArea( wxDC& dc )
+{
+    if ( !m_numRows || !m_numCols ) return;
+
+    size_t i;
+    size_t numCells = m_cellsExposed.GetCount();
+
+    for ( i = 0;  i < numCells;  i++ )
+    {
+        DrawCell( dc, m_cellsExposed[i] );
+    }
+}
+
+
+void wxGrid::DrawGridSpace( wxDC& dc )
+{
+  int cw, ch;
+  m_gridWin->GetClientSize( &cw, &ch );
+
+  int right, bottom;
+  CalcUnscrolledPosition( cw, ch, &right, &bottom );
+
+  int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
+  int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
+
+  if ( right > rightCol || bottom > bottomRow )
+  {
+      int left, top;
+      CalcUnscrolledPosition( 0, 0, &left, &top );
+
+      dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
+      dc.SetPen( *wxTRANSPARENT_PEN );
+
+      if ( right > rightCol )
+      {
+          dc.DrawRectangle( rightCol, top, right - rightCol, ch);
+      }
+
+      if ( bottom > bottomRow )
+      {
+          dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
+      }
+  }
+}
+
+
  void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
  {
      int row = coords.GetRow();
  void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
  {
      int row = coords.GetRow();
@@ -4969,24 +5881,23 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
  
      bool isCurrent = coords == m_currentCellCoords;
  
  
      bool isCurrent = coords == m_currentCellCoords;
  
-    wxRect rect;
-    rect.x = GetColLeft(col);
-    rect.y = GetRowTop(row);
-    rect.width = GetColWidth(col) - 1;
-    rect.height = GetRowHeight(row) - 1;
+    wxRect rect = CellToRect( row, col );
  
      // if the editor is shown, we should use it and not the renderer
  
      // if the editor is shown, we should use it and not the renderer
-    if ( isCurrent && IsCellEditControlEnabled() )
+    // Note: However, only if it is really _shown_, i.e. not hidden!
+    if ( isCurrent && IsCellEditControlShown() )
      {
      {
-        attr->GetEditor(this, row, col)->PaintBackground(rect, attr);
+        wxGridCellEditor *editor = attr->GetEditor(this, row, col);
+        editor->PaintBackground(rect, attr);
+        editor->DecRef();
      }
      else
      {
          // but all the rest is drawn by the cell renderer and hence may be
          // customized
      }
      else
      {
          // but all the rest is drawn by the cell renderer and hence may be
          // customized
-        attr->GetRenderer(this, row, col)->
-            Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
-
+        wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
+        renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
+        renderer->DecRef();
      }
  
      attr->DecRef();
      }
  
      attr->DecRef();
@@ -5000,16 +5911,12 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
      if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
          return;
  
      if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
          return;
  
-    wxRect rect;
-    rect.x = GetColLeft(col);
-    rect.y = GetRowTop(row);
-    rect.width = GetColWidth(col) - 1;
-    rect.height = GetRowHeight(row) - 1;
+    wxRect rect = CellToRect(row, col);
  
      // 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_gridLineColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
+    dc.SetPen(wxPen(m_cellHighlightColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
      dc.SetBrush(*wxTRANSPARENT_BRUSH);
  
      dc.DrawRectangle(rect);
      dc.SetBrush(*wxTRANSPARENT_BRUSH);
  
      dc.DrawRectangle(rect);
@@ -5059,7 +5966,16 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
  
  void wxGrid::DrawHighlight(wxDC& dc)
  {
  
  void wxGrid::DrawHighlight(wxDC& dc)
  {
-    if ( IsCellEditControlEnabled() )
+    // This if block was previously in wxGrid::OnPaint but that doesn't
+    // seem to get called under wxGTK - MB
+    //
+    if ( m_currentCellCoords == wxGridNoCellCoords  &&
+         m_numRows && m_numCols )
+    {
+        m_currentCellCoords.Set(0, 0);
+    }
+
+    if ( IsCellEditControlShown() )
      {
          // don't show highlight when the edit control is shown
          return;
      {
          // don't show highlight when the edit control is shown
          return;
@@ -5085,7 +6001,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 & reg )
+void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
  {
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
  {
      if ( !m_gridLinesEnabled ||
           !m_numRows ||
@@ -5093,7 +6009,7 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
  
      int top, bottom, left, right;
  
  
      int top, bottom, left, right;
  
-#ifndef __WXGTK__
+#if 0  //#ifndef __WXGTK__
      if (reg.IsEmpty())
      {
        int cw, ch;
      if (reg.IsEmpty())
      {
        int cw, ch;
@@ -5164,7 +6080,7 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
  
  void wxGrid::DrawRowLabels( wxDC& dc )
  {
  
  void wxGrid::DrawRowLabels( wxDC& dc )
  {
-    if ( !m_numRows || !m_numCols ) return;
+    if ( !m_numRows ) return;
  
      size_t i;
      size_t numLabels = m_rowLabelsExposed.GetCount();
  
      size_t i;
      size_t numLabels = m_rowLabelsExposed.GetCount();
@@ -5212,7 +6128,7 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
  
  void wxGrid::DrawColLabels( wxDC& dc )
  {
  
  void wxGrid::DrawColLabels( wxDC& dc )
  {
-    if ( !m_numRows || !m_numCols ) return;
+    if ( !m_numCols ) return;
  
      size_t i;
      size_t numLabels = m_colLabelsExposed.GetCount();
  
      size_t i;
      size_t numLabels = m_colLabelsExposed.GetCount();
@@ -5283,15 +6199,15 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
          float x, y;
          switch ( horizAlign )
          {
          float x, y;
          switch ( horizAlign )
          {
-            case wxRIGHT:
+            case wxALIGN_RIGHT:
                  x = rect.x + (rect.width - textWidth - 1);
                  break;
  
                  x = rect.x + (rect.width - textWidth - 1);
                  break;
  
-            case wxCENTRE:
+            case wxALIGN_CENTRE:
                  x = rect.x + ((rect.width - textWidth)/2);
                  break;
  
                  x = rect.x + ((rect.width - textWidth)/2);
                  break;
  
-            case wxLEFT:
+            case wxALIGN_LEFT:
              default:
                  x = rect.x + 1;
                  break;
              default:
                  x = rect.x + 1;
                  break;
@@ -5299,15 +6215,15 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
  
          switch ( vertAlign )
          {
  
          switch ( vertAlign )
          {
-            case wxBOTTOM:
+            case wxALIGN_BOTTOM:
                  y = rect.y + (rect.height - textHeight - 1);
                  break;
  
                  y = rect.y + (rect.height - textHeight - 1);
                  break;
  
-            case wxCENTRE:
+            case wxALIGN_CENTRE:
                  y = rect.y + ((rect.height - textHeight)/2);
                  break;
  
                  y = rect.y + ((rect.height - textHeight)/2);
                  break;
  
-            case wxTOP:
+            case wxALIGN_TOP:
              default:
                  y = rect.y + 1;
                  break;
              default:
                  y = rect.y + 1;
                  break;
@@ -5315,7 +6231,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
  
          for ( size_t i = 0;  i < lines.GetCount();  i++ )
          {
  
          for ( size_t i = 0;  i < lines.GetCount();  i++ )
          {
-            dc.DrawText( lines[i], (long)x, (long)y );
+            dc.DrawText( lines[i], (int)x, (int)y );
              y += lineHeight;
          }
      }
              y += lineHeight;
          }
      }
@@ -5378,6 +6294,35 @@ void wxGrid::GetTextBoxSize( wxDC& dc,
      *height = h;
  }
  
      *height = h;
  }
  
+//
+// ------ Batch processing.
+//
+void wxGrid::EndBatch()
+{
+    if ( m_batchCount > 0 )
+    {
+        m_batchCount--;
+        if ( !m_batchCount )
+        {
+            CalcDimensions();
+            m_rowLabelWin->Refresh();
+            m_colLabelWin->Refresh();
+            m_cornerLabelWin->Refresh();
+            m_gridWin->Refresh();
+        }
+    }
+}
+
+// Use this, rather than wxWindow::Refresh(), to force an immediate
+// repainting of the grid. Has no effect if you are already inside a
+// BeginBatch / EndBatch block.
+//
+void wxGrid::ForceRefresh()
+{
+    BeginBatch();
+    EndBatch();
+}
+
  
  //
  // ------ Edit control functions
  
  //
  // ------ Edit control functions
@@ -5390,12 +6335,8 @@ void wxGrid::EnableEditing( bool edit )
      //
      if ( edit != m_editable )
      {
      //
      if ( edit != m_editable )
      {
+        if(!edit) EnableCellEditControl(edit);
          m_editable = edit;
          m_editable = edit;
-
-        // FIXME IMHO this won't disable the edit control if edit == FALSE
-        //       because of the check in the beginning of
-        //       EnableCellEditControl() just below (VZ)
-        EnableCellEditControl(m_editable);
      }
  }
  
      }
  }
  
@@ -5457,12 +6398,39 @@ bool wxGrid::IsCellEditControlEnabled() const
      return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
  }
  
      return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
  }
  
+bool wxGrid::IsCellEditControlShown() const
+{
+    bool isShown = FALSE;
+
+    if ( m_cellEditCtrlEnabled )
+    {
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+        wxGridCellAttr* attr = GetCellAttr(row, col);
+        wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
+        attr->DecRef();
+
+        if ( editor )
+        {
+            if ( editor->IsCreated() )
+            {
+                isShown = editor->GetControl()->IsShown();
+            }
+
+            editor->DecRef();
+        }
+    }
+
+    return isShown;
+}
+
  void wxGrid::ShowCellEditControl()
  {
      if ( IsCellEditControlEnabled() )
      {
          if ( !IsVisible( m_currentCellCoords ) )
          {
  void wxGrid::ShowCellEditControl()
  {
      if ( IsCellEditControlEnabled() )
      {
          if ( !IsVisible( m_currentCellCoords ) )
          {
+            m_cellEditCtrlEnabled = FALSE;
              return;
          }
          else
              return;
          }
          else
@@ -5499,10 +6467,12 @@ void wxGrid::ShowCellEditControl()
              }
  
              editor->Show( TRUE, attr );
              }
  
              editor->Show( TRUE, attr );
-            
+
              editor->SetSize( rect );
  
              editor->BeginEdit(row, col, this);
              editor->SetSize( rect );
  
              editor->BeginEdit(row, col, this);
+
+            editor->DecRef();
              attr->DecRef();
           }
      }
              attr->DecRef();
           }
      }
@@ -5517,9 +6487,13 @@ void wxGrid::HideCellEditControl()
          int col = m_currentCellCoords.GetCol();
  
          wxGridCellAttr* attr = GetCellAttr(row, col);
          int col = m_currentCellCoords.GetCol();
  
          wxGridCellAttr* attr = GetCellAttr(row, col);
-        attr->GetEditor(this, row, col)->Show( FALSE );
+        wxGridCellEditor *editor = attr->GetEditor(this, row, col);
+        editor->Show( FALSE );
+        editor->DecRef();
          attr->DecRef();
          m_gridWin->SetFocus();
          attr->DecRef();
          m_gridWin->SetFocus();
+        wxRect rect( CellToRect( row, col ) );
+        m_gridWin->Refresh( FALSE, &rect );
      }
  }
  
      }
  }
  
@@ -5535,6 +6509,7 @@ void wxGrid::SaveEditControlValue()
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
          bool changed = editor->EndEdit(row, col, this);
  
          wxGridCellEditor* editor = attr->GetEditor(this, row, col);
          bool changed = editor->EndEdit(row, col, this);
  
+        editor->DecRef();
          attr->DecRef();
  
          if (changed)
          attr->DecRef();
  
          if (changed)
@@ -5653,6 +6628,11 @@ wxRect wxGrid::CellToRect( int row, int col )
          rect.height = GetRowHeight(row);
      }
  
          rect.height = GetRowHeight(row);
      }
  
+    // if grid lines are enabled, then the area of the cell is a bit smaller
+    if (m_gridLinesEnabled) {
+        rect.width -= 1;
+        rect.height -= 1;
+    }
      return rect;
  }
  
      return rect;
  }
  
@@ -5776,17 +6756,33 @@ void wxGrid::MakeCellVisible( int row, int col )
  // ------ Grid cursor movement functions
  //
  
  // ------ Grid cursor movement functions
  //
  
-bool wxGrid::MoveCursorUp()
+bool wxGrid::MoveCursorUp( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() > 0 )
+         m_currentCellCoords.GetRow() >= 0 )
      {
      {
-        MakeCellVisible( m_currentCellCoords.GetRow() - 1,
-                        m_currentCellCoords.GetCol() );
-
-        SetCurrentCell( m_currentCellCoords.GetRow() - 1,
-                        m_currentCellCoords.GetCol() );
-
+        if ( expandSelection)
+        {
+            if ( m_selectingKeyboard == wxGridNoCellCoords )
+                m_selectingKeyboard = m_currentCellCoords;
+            if ( m_selectingKeyboard.GetRow() > 0 )
+            {
+                m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
+                MakeCellVisible( m_selectingKeyboard.GetRow(),
+                                 m_selectingKeyboard.GetCol() );
+                HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+            }
+        }
+        else if ( m_currentCellCoords.GetRow() > 0 )
+        {
+            ClearSelection();
+            MakeCellVisible( m_currentCellCoords.GetRow() - 1,
+                             m_currentCellCoords.GetCol() );
+            SetCurrentCell( m_currentCellCoords.GetRow() - 1,
+                            m_currentCellCoords.GetCol() );
+        }
+        else
+            return FALSE;
          return TRUE;
      }
  
          return TRUE;
      }
  
@@ -5794,19 +6790,33 @@ bool wxGrid::MoveCursorUp()
  }
  
  
  }
  
  
-bool wxGrid::MoveCursorDown()
+bool wxGrid::MoveCursorDown( bool expandSelection )
  {
  {
-    // TODO: allow for scrolling
-    //
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() < m_numRows-1 )
+         m_currentCellCoords.GetRow() < m_numRows )
      {
      {
-        MakeCellVisible( m_currentCellCoords.GetRow() + 1,
-                        m_currentCellCoords.GetCol() );
-
-        SetCurrentCell( m_currentCellCoords.GetRow() + 1,
-                        m_currentCellCoords.GetCol() );
-
+        if ( expandSelection )
+        {
+            if ( m_selectingKeyboard == wxGridNoCellCoords )
+                m_selectingKeyboard = m_currentCellCoords;
+            if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
+            {
+                m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
+                MakeCellVisible( m_selectingKeyboard.GetRow(),
+                        m_selectingKeyboard.GetCol() );
+                HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+            }
+        }
+        else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
+        {
+            ClearSelection();
+            MakeCellVisible( m_currentCellCoords.GetRow() + 1,
+                             m_currentCellCoords.GetCol() );
+            SetCurrentCell( m_currentCellCoords.GetRow() + 1,
+                            m_currentCellCoords.GetCol() );
+        }
+        else
+            return FALSE;
          return TRUE;
      }
  
          return TRUE;
      }
  
@@ -5814,17 +6824,33 @@ bool wxGrid::MoveCursorDown()
  }
  
  
  }
  
  
-bool wxGrid::MoveCursorLeft()
+bool wxGrid::MoveCursorLeft( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() > 0 )
+         m_currentCellCoords.GetCol() >= 0 )
      {
      {
-        MakeCellVisible( m_currentCellCoords.GetRow(),
-                        m_currentCellCoords.GetCol() - 1 );
-
-        SetCurrentCell( m_currentCellCoords.GetRow(),
-                        m_currentCellCoords.GetCol() - 1 );
-
+        if ( expandSelection )
+        {
+            if ( m_selectingKeyboard == wxGridNoCellCoords )
+                m_selectingKeyboard = m_currentCellCoords;
+            if ( m_selectingKeyboard.GetCol() > 0 )
+            {
+                m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
+                MakeCellVisible( m_selectingKeyboard.GetRow(),
+                        m_selectingKeyboard.GetCol() );
+                HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+            }
+        }
+        else if ( m_currentCellCoords.GetCol() > 0 )
+        {
+            ClearSelection();
+            MakeCellVisible( m_currentCellCoords.GetRow(),
+                             m_currentCellCoords.GetCol() - 1 );
+            SetCurrentCell( m_currentCellCoords.GetRow(),
+                            m_currentCellCoords.GetCol() - 1 );
+        }
+        else
+            return FALSE;
          return TRUE;
      }
  
          return TRUE;
      }
  
@@ -5832,17 +6858,33 @@ bool wxGrid::MoveCursorLeft()
  }
  
  
  }
  
  
-bool wxGrid::MoveCursorRight()
+bool wxGrid::MoveCursorRight( bool expandSelection )
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() < m_numCols - 1 )
+         m_currentCellCoords.GetCol() < m_numCols )
      {
      {
-        MakeCellVisible( m_currentCellCoords.GetRow(),
-                        m_currentCellCoords.GetCol() + 1 );
-
-        SetCurrentCell( m_currentCellCoords.GetRow(),
-                        m_currentCellCoords.GetCol() + 1 );
-
+        if ( expandSelection )
+        {
+            if ( m_selectingKeyboard == wxGridNoCellCoords )
+                m_selectingKeyboard = m_currentCellCoords;
+            if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
+            {
+                m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
+                MakeCellVisible( m_selectingKeyboard.GetRow(),
+                        m_selectingKeyboard.GetCol() );
+                HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+            }
+        }
+        else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
+        {
+            ClearSelection();
+            MakeCellVisible( m_currentCellCoords.GetRow(),
+                             m_currentCellCoords.GetCol() + 1 );
+            SetCurrentCell( m_currentCellCoords.GetRow(),
+                            m_currentCellCoords.GetCol() + 1 );
+        }
+        else
+            return FALSE;
          return TRUE;
      }
  
          return TRUE;
      }
  
@@ -5910,7 +6952,7 @@ bool wxGrid::MovePageDown()
      return FALSE;
  }
  
      return FALSE;
  }
  
-bool wxGrid::MoveCursorUpBlock()
+bool wxGrid::MoveCursorUpBlock( bool expandSelection )
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
@@ -5957,15 +6999,23 @@ bool wxGrid::MoveCursorUpBlock()
          }
  
          MakeCellVisible( row, col );
          }
  
          MakeCellVisible( row, col );
-        SetCurrentCell( row, col );
-
+        if ( expandSelection )
+        {
+            m_selectingKeyboard = wxGridCellCoords( row, col );
+            HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+        }
+        else
+        {
+            ClearSelection();
+            SetCurrentCell( row, col );
+        }
          return TRUE;
      }
  
      return FALSE;
  }
  
          return TRUE;
      }
  
      return FALSE;
  }
  
-bool wxGrid::MoveCursorDownBlock()
+bool wxGrid::MoveCursorDownBlock( bool expandSelection )
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
@@ -6012,7 +7062,16 @@ bool wxGrid::MoveCursorDownBlock()
          }
  
          MakeCellVisible( row, col );
          }
  
          MakeCellVisible( row, col );
-        SetCurrentCell( row, col );
+        if ( expandSelection )
+        {
+            m_selectingKeyboard = wxGridCellCoords( row, col );
+            HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+        }
+        else
+        {
+            ClearSelection();
+            SetCurrentCell( row, col );
+        }
  
          return TRUE;
      }
  
          return TRUE;
      }
@@ -6020,7 +7079,7 @@ bool wxGrid::MoveCursorDownBlock()
      return FALSE;
  }
  
      return FALSE;
  }
  
-bool wxGrid::MoveCursorLeftBlock()
+bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
@@ -6067,15 +7126,24 @@ bool wxGrid::MoveCursorLeftBlock()
          }
  
          MakeCellVisible( row, col );
          }
  
          MakeCellVisible( row, col );
-        SetCurrentCell( row, col );
-
+        if ( expandSelection )
+        {
+            m_selectingKeyboard = wxGridCellCoords( row, col );
+            HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+        }
+        else
+        {
+            ClearSelection();
+            SetCurrentCell( row, col );
+        }
+
          return TRUE;
      }
  
      return FALSE;
  }
  
          return TRUE;
      }
  
      return FALSE;
  }
  
-bool wxGrid::MoveCursorRightBlock()
+bool wxGrid::MoveCursorRightBlock( bool expandSelection )
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
  {
      if ( m_table &&
           m_currentCellCoords != wxGridNoCellCoords  &&
@@ -6122,7 +7190,16 @@ bool wxGrid::MoveCursorRightBlock()
          }
  
          MakeCellVisible( row, col );
          }
  
          MakeCellVisible( row, col );
-        SetCurrentCell( row, col );
+        if ( expandSelection )
+        {
+            m_selectingKeyboard = wxGridCellCoords( row, col );
+            HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
+        }
+        else
+        {
+            ClearSelection();
+            SetCurrentCell( row, col );
+        }
  
          return TRUE;
      }
  
          return TRUE;
      }
@@ -6266,12 +7343,27 @@ void wxGrid::SetLabelFont( const wxFont& font )
  
  void wxGrid::SetRowLabelAlignment( int horiz, int vert )
  {
  
  void wxGrid::SetRowLabelAlignment( int horiz, int vert )
  {
-    if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
+    // allow old (incorrect) defs to be used
+    switch ( horiz )
+    {
+        case wxLEFT:   horiz = wxALIGN_LEFT; 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;
+    }
+
+    if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_rowLabelHorizAlign = horiz;
      }
  
      {
          m_rowLabelHorizAlign = horiz;
      }
  
-    if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
+    if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
      {
          m_rowLabelVertAlign = vert;
      }
      {
          m_rowLabelVertAlign = vert;
      }
@@ -6284,12 +7376,27 @@ void wxGrid::SetRowLabelAlignment( int horiz, int vert )
  
  void wxGrid::SetColLabelAlignment( int horiz, int vert )
  {
  
  void wxGrid::SetColLabelAlignment( int horiz, int vert )
  {
-    if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
+    // allow old (incorrect) defs to be used
+    switch ( horiz )
+    {
+        case wxLEFT:   horiz = wxALIGN_LEFT; 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;
+    }
+
+    if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
      {
          m_colLabelHorizAlign = horiz;
      }
  
      {
          m_colLabelHorizAlign = horiz;
      }
  
-    if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
+    if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
      {
          m_colLabelVertAlign = vert;
      }
      {
          m_colLabelVertAlign = vert;
      }
@@ -6311,7 +7418,7 @@ void wxGrid::SetRowLabelValue( int row, const wxString& s )
              if ( rect.height > 0 )
              {
                  CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
              if ( rect.height > 0 )
              {
                  CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
-                rect.x = m_left;
+                rect.x = 0;
                  rect.width = m_rowLabelWidth;
                  m_rowLabelWin->Refresh( TRUE, &rect );
              }
                  rect.width = m_rowLabelWidth;
                  m_rowLabelWin->Refresh( TRUE, &rect );
              }
@@ -6330,7 +7437,7 @@ void wxGrid::SetColLabelValue( int col, const wxString& s )
              if ( rect.width > 0 )
              {
                  CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
              if ( rect.width > 0 )
              {
                  CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
-                rect.y = m_top;
+                rect.y = 0;
                  rect.height = m_colLabelHeight;
                  m_colLabelWin->Refresh( TRUE, &rect );
              }
                  rect.height = m_colLabelHeight;
                  m_colLabelWin->Refresh( TRUE, &rect );
              }
@@ -6350,6 +7457,21 @@ void wxGrid::SetGridLineColour( const wxColour& colour )
      }
  }
  
      }
  }
  
+
+void wxGrid::SetCellHighlightColour( const wxColour& colour )
+{
+    if ( m_cellHighlightColour != colour )
+    {
+        m_cellHighlightColour = colour;
+
+        wxClientDC dc( m_gridWin );
+        PrepareDC( dc );
+        wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
+        DrawCellHighlight(dc, attr);
+        attr->DecRef();
+    }
+}
+
  void wxGrid::EnableGridLines( bool enable )
  {
      if ( enable != m_gridLinesEnabled )
  void wxGrid::EnableGridLines( bool enable )
  {
      if ( enable != m_gridLinesEnabled )
@@ -6465,7 +7587,7 @@ void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
  
  wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
  {
  
  wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
  {
-    return m_defaultCellAttr->GetRenderer(NULL,0,0);
+    return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
  }
  
  wxGridCellEditor *wxGrid::GetDefaultEditor() const
  }
  
  wxGridCellEditor *wxGrid::GetDefaultEditor() const
@@ -6481,7 +7603,7 @@ wxColour wxGrid::GetCellBackgroundColour(int row, int col)
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxColour colour = attr->GetBackgroundColour();
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxColour colour = attr->GetBackgroundColour();
-    attr->SafeDecRef();
+    attr->DecRef();
      return colour;
  }
  
      return colour;
  }
  
@@ -6489,7 +7611,7 @@ wxColour wxGrid::GetCellTextColour( int row, int col )
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxColour colour = attr->GetTextColour();
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxColour colour = attr->GetTextColour();
-    attr->SafeDecRef();
+    attr->DecRef();
      return colour;
  }
  
      return colour;
  }
  
@@ -6497,7 +7619,7 @@ wxFont wxGrid::GetCellFont( int row, int col )
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxFont font = attr->GetFont();
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      wxFont font = attr->GetFont();
-    attr->SafeDecRef();
+    attr->DecRef();
      return font;
  }
  
      return font;
  }
  
@@ -6505,7 +7627,7 @@ void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      attr->GetAlignment(horiz, vert);
  {
      wxGridCellAttr *attr = GetCellAttr(row, col);
      attr->GetAlignment(horiz, vert);
-    attr->SafeDecRef();
+    attr->DecRef();
  }
  
  wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
  }
  
  wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
@@ -6513,6 +7635,7 @@ wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
      wxGridCellAttr* attr = GetCellAttr(row, col);
      wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
      attr->DecRef();
      wxGridCellAttr* attr = GetCellAttr(row, col);
      wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
      attr->DecRef();
+
      return renderer;
  }
  
      return renderer;
  }
  
@@ -6521,6 +7644,7 @@ wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
      wxGridCellAttr* attr = GetCellAttr(row, col);
      wxGridCellEditor* editor = attr->GetEditor(this, row, col);
      attr->DecRef();
      wxGridCellAttr* attr = GetCellAttr(row, col);
      wxGridCellEditor* editor = attr->GetEditor(this, row, col);
      attr->DecRef();
+
      return editor;
  }
  
      return editor;
  }
  
@@ -6550,7 +7674,7 @@ void wxGrid::ClearAttrCache()
  {
      if ( m_attrCache.row != -1 )
      {
  {
      if ( m_attrCache.row != -1 )
      {
-        m_attrCache.attr->SafeDecRef();
+        wxSafeDecRef(m_attrCache.attr);
          m_attrCache.row = -1;
      }
  }
          m_attrCache.row = -1;
      }
  }
@@ -6563,7 +7687,7 @@ void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
      self->m_attrCache.row = row;
      self->m_attrCache.col = col;
      self->m_attrCache.attr = attr;
      self->m_attrCache.row = row;
      self->m_attrCache.col = col;
      self->m_attrCache.attr = attr;
-    attr->SafeIncRef();
+    wxSafeIncRef(attr);
  }
  
  bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
  }
  
  bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
@@ -6571,7 +7695,7 @@ bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
      if ( row == m_attrCache.row && col == m_attrCache.col )
      {
          *attr = m_attrCache.attr;
      if ( row == m_attrCache.row && col == m_attrCache.col )
      {
          *attr = m_attrCache.attr;
-        (*attr)->SafeIncRef();
+        wxSafeIncRef(m_attrCache.attr);
  
  #ifdef DEBUG_ATTR_CACHE
          gs_nAttrCacheHits++;
  
  #ifdef DEBUG_ATTR_CACHE
          gs_nAttrCacheHits++;
@@ -6615,8 +7739,7 @@ wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
      if ( !LookupAttr(row, col, &attr) || !attr )
      {
          wxASSERT_MSG( m_table,
      if ( !LookupAttr(row, col, &attr) || !attr )
      {
          wxASSERT_MSG( m_table,
-                      _T("we may only be called if CanHaveAttributes() "
-                         "returned TRUE and then m_table should be !NULL") );
+                      _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
  
          attr = m_table->GetAttr(row, col);
          if ( !attr )
  
          attr = m_table->GetAttr(row, col);
          if ( !attr )
@@ -6635,6 +7758,40 @@ wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
      return attr;
  }
  
      return attr;
  }
  
+// ----------------------------------------------------------------------------
+// setting column attributes (wrappers around SetColAttr)
+// ----------------------------------------------------------------------------
+
+void wxGrid::SetColFormatBool(int col)
+{
+    SetColFormatCustom(col, wxGRID_VALUE_BOOL);
+}
+
+void wxGrid::SetColFormatNumber(int col)
+{
+    SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
+}
+
+void wxGrid::SetColFormatFloat(int col, int width, int precision)
+{
+    wxString typeName = wxGRID_VALUE_FLOAT;
+    if ( (width != -1) || (precision != -1) )
+    {
+        typeName << _T(':') << width << _T(',') << precision;
+    }
+
+    SetColFormatCustom(col, typeName);
+}
+
+void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
+{
+    wxGridCellAttr *attr = new wxGridCellAttr;
+    wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
+    attr->SetRenderer(renderer);
+
+    SetColAttr(col, attr);
+}
+
  // ----------------------------------------------------------------------------
  // setting cell attributes: this is forwarded to the table
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // setting cell attributes: this is forwarded to the table
  // ----------------------------------------------------------------------------
@@ -6647,7 +7804,7 @@ void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
      }
      else
      {
      }
      else
      {
-        attr->SafeDecRef();
+        wxSafeDecRef(attr);
      }
  }
  
      }
  }
  
@@ -6659,7 +7816,7 @@ void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
      }
      else
      {
      }
      else
      {
-        attr->SafeDecRef();
+        wxSafeDecRef(attr);
      }
  }
  
      }
  }
  
@@ -6760,24 +7917,28 @@ wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
  wxGridCellEditor*
  wxGrid::GetDefaultEditorForType(const wxString& typeName) const
  {
  wxGridCellEditor*
  wxGrid::GetDefaultEditorForType(const wxString& typeName) const
  {
-    int index = m_typeRegistry->FindDataType(typeName);
-    if (index == -1) {
-        // Should we force the failure here or let it fallback to string handling???
-        // wxFAIL_MSG(wxT("Unknown data type name"));
+    int index = m_typeRegistry->FindOrCloneDataType(typeName);
+    if ( index == wxNOT_FOUND )
+    {
+        wxFAIL_MSG(wxT("Unknown data type name"));
+
          return NULL;
      }
          return NULL;
      }
+
      return m_typeRegistry->GetEditor(index);
  }
  
  wxGridCellRenderer*
  wxGrid::GetDefaultRendererForType(const wxString& typeName) const
  {
      return m_typeRegistry->GetEditor(index);
  }
  
  wxGridCellRenderer*
  wxGrid::GetDefaultRendererForType(const wxString& typeName) const
  {
-    int index = m_typeRegistry->FindDataType(typeName);
-    if (index == -1) {
-        // Should we force the failure here or let it fallback to string handling???
-        // wxFAIL_MSG(wxT("Unknown data type name"));
+    int index = m_typeRegistry->FindOrCloneDataType(typeName);
+    if ( index == wxNOT_FOUND )
+    {
+        wxFAIL_MSG(wxT("Unknown data type name"));
+
          return NULL;
      }
          return NULL;
      }
+
      return m_typeRegistry->GetRenderer(index);
  }
  
      return m_typeRegistry->GetRenderer(index);
  }
  
@@ -6876,64 +8037,113 @@ void wxGrid::SetColSize( int col, int width )
  
  void wxGrid::SetColMinimalWidth( int col, int width )
  {
  
  void wxGrid::SetColMinimalWidth( int col, int width )
  {
-    m_colMinWidths.Put(col, (wxObject *)width);
+    m_colMinWidths.Put(col, width);
+}
+
+void wxGrid::SetRowMinimalHeight( int row, int width )
+{
+    m_rowMinHeights.Put(row, width);
  }
  
  int wxGrid::GetColMinimalWidth(int col) const
  {
  }
  
  int wxGrid::GetColMinimalWidth(int col) const
  {
-    wxObject *obj = m_colMinWidths.Get(m_dragRowOrCol);
-    return obj ? (int)obj : WXGRID_MIN_COL_WIDTH;
+    long value = m_colMinWidths.Get(col);
+    return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
+}
+
+int wxGrid::GetRowMinimalHeight(int row) const
+{
+    long value = m_rowMinHeights.Get(row);
+    return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
  }
  
  // ----------------------------------------------------------------------------
  // auto sizing
  // ----------------------------------------------------------------------------
  
  }
  
  // ----------------------------------------------------------------------------
  // auto sizing
  // ----------------------------------------------------------------------------
  
-void wxGrid::AutoSizeColumn( int col, bool setAsMin )
+void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
  {
      wxClientDC dc(m_gridWin);
  
  {
      wxClientDC dc(m_gridWin);
  
-    wxCoord width, widthMax = 0;
-    for ( int row = 0; row < m_numRows; row++ )
+    // init both of them to avoid compiler warnings, even if weo nly need one
+    int row = -1,
+        col = -1;
+    if ( column )
+        col = colOrRow;
+    else
+        row = colOrRow;
+
+    wxCoord extent, extentMax = 0;
+    int max = column ? m_numRows : m_numCols;
+    for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
      {
      {
+        if ( column )
+            row = rowOrCol;
+        else
+            col = rowOrCol;
+
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
          if ( renderer )
          {
          wxGridCellAttr* attr = GetCellAttr(row, col);
          wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
          if ( renderer )
          {
-            width = renderer->GetBestSize(*this, *attr, dc, row, col).x;
-            if ( width > widthMax )
+            wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
+            extent = column ? size.x : size.y;
+            if ( extent > extentMax )
              {
              {
-                widthMax = width;
+                extentMax = extent;
              }
              }
+
+            renderer->DecRef();
          }
  
          attr->DecRef();
      }
  
          }
  
          attr->DecRef();
      }
  
-    // now also compare with the column label width
+    // now also compare with the column label extent
+    wxCoord w, h;
      dc.SetFont( GetLabelFont() );
      dc.SetFont( GetLabelFont() );
-    dc.GetTextExtent( GetColLabelValue(col), &width, NULL );
-    if ( width > widthMax )
+
+    if ( column )
+        dc.GetTextExtent( GetColLabelValue(col), &w, &h );
+    else
+        dc.GetTextExtent( GetRowLabelValue(col), &w, &h );
+
+    extent = column ? w : h;
+    if ( extent > extentMax )
      {
      {
-        widthMax = width;
+        extentMax = extent;
      }
  
      }
  
-    if ( !widthMax )
+    if ( !extentMax )
      {
      {
-        // empty column - give default width (notice that if widthMax is less
-        // than default width but != 0, it's ok)
-        widthMax = m_defaultColWidth;
+        // empty column - give default extent (notice that if extentMax is less
+        // than default extent but != 0, it's ok)
+        extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
      }
      else
      {
      }
      else
      {
-        // leave some space around text
-        widthMax += 10;
+        if ( column )
+        {
+            // leave some space around text
+            extentMax += 10;
+        }
+        else
+        {
+            extentMax += 6;
+        }
      }
  
      }
  
-    SetColSize(col, widthMax);
+    if ( column )
+        SetColSize(col, extentMax);
+    else
+        SetRowSize(row, extentMax);
+
      if ( setAsMin )
      {
      if ( setAsMin )
      {
-        SetColMinimalWidth(col, widthMax);
+        if ( column )
+            SetColMinimalWidth(col, extentMax);
+        else
+            SetRowMinimalHeight(row, extentMax);
      }
  }
  
      }
  }
  
@@ -6960,7 +8170,10 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
  
      for ( int row = 0; row < m_numRows; row++ )
      {
  
      for ( int row = 0; row < m_numRows; row++ )
      {
-        // if ( !calcOnly ) AutoSizeRow(row, setAsMin) -- TODO
+        if ( !calcOnly )
+        {
+            AutoSizeRow(row, setAsMin);
+        }
  
          height += GetRowHeight(row);
      }
  
          height += GetRowHeight(row);
      }
@@ -6988,6 +8201,12 @@ void wxGrid::Fit()
      AutoSize();
  }
  
      AutoSize();
  }
  
+
+wxPen& wxGrid::GetDividerPen() const
+{
+    return wxNullPen;
+}
+
  // ----------------------------------------------------------------------------
  // cell value accessor functions
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // cell value accessor functions
  // ----------------------------------------------------------------------------
@@ -6996,7 +8215,7 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
  {
      if ( m_table )
      {
  {
      if ( m_table )
      {
-        m_table->SetValue( row, col, s.c_str() );
+        m_table->SetValue( row, col, s );
          if ( !GetBatchCount() )
          {
              wxClientDC dc( m_gridWin );
          if ( !GetBatchCount() )
          {
              wxClientDC dc( m_gridWin );
@@ -7006,7 +8225,10 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
  
          if ( m_currentCellCoords.GetRow() == row &&
               m_currentCellCoords.GetCol() == col &&
  
          if ( m_currentCellCoords.GetRow() == row &&
               m_currentCellCoords.GetCol() == col &&
-             IsCellEditControlEnabled())
+             IsCellEditControlShown())
+             // Note: If we are using IsCellEditControlEnabled,
+             // this interacts badly with calling SetCellValue from
+             // an EVT_GRID_CELL_CHANGE handler.
          {
              HideCellEditControl();
              ShowCellEditControl(); // will reread data from table
          {
              HideCellEditControl();
              ShowCellEditControl(); // will reread data from table
@@ -7021,317 +8243,59 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
  
  void wxGrid::SelectRow( int row, bool addToSelected )
  {
  
  void wxGrid::SelectRow( int row, bool addToSelected )
  {
-    wxRect r;
-
-    if ( IsSelection() && addToSelected )
-    {
-        wxRect  rect[4];
-        bool    need_refresh[4];
-        need_refresh[0] =
-        need_refresh[1] =
-        need_refresh[2] =
-        need_refresh[3] = FALSE;
-
-        int     i;
-
-        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
-        wxCoord oldTop    = m_selectedTopLeft.GetRow();
-        wxCoord oldRight  = m_selectedBottomRight.GetCol();
-        wxCoord oldBottom = m_selectedBottomRight.GetRow();
-
-        if ( oldTop > row )
-        {
-            need_refresh[0] = TRUE;
-            rect[0] = BlockToDeviceRect( wxGridCellCoords ( row, 0 ),
-                                         wxGridCellCoords ( oldTop - 1,
-                                                            m_numCols - 1 ) );
-            m_selectedTopLeft.SetRow( row );
-        }
-
-        if ( oldLeft > 0 )
-        {
-            need_refresh[1] = TRUE;
-            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop, 0 ),
-                                         wxGridCellCoords ( oldBottom,
-                                                            oldLeft - 1 ) );
-
-            m_selectedTopLeft.SetCol( 0 );
-        }
-
-        if ( oldBottom < row )
-        {
-            need_refresh[2] = TRUE;
-            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1, 0 ),
-                                         wxGridCellCoords ( row,
-                                                            m_numCols - 1 ) );
-            m_selectedBottomRight.SetRow( row );
-        }
-
-        if ( oldRight < m_numCols - 1 )
-        {
-            need_refresh[3] = TRUE;
-            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldTop ,
-                                                            oldRight + 1 ),
-                                         wxGridCellCoords ( oldBottom,
-                                                            m_numCols - 1 ) );
-            m_selectedBottomRight.SetCol( m_numCols - 1 );
-        }
-
-        for (i = 0; i < 4; i++ )
-            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
-                m_gridWin->Refresh( FALSE, &(rect[i]) );
-    }
-    else
-    {
-        r = SelectionToDeviceRect();
+    if ( IsSelection() && !addToSelected )
          ClearSelection();
          ClearSelection();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
  
  
-        m_selectedTopLeft.Set( row, 0 );
-        m_selectedBottomRight.Set( row, m_numCols-1 );
-        r = SelectionToDeviceRect();
-        m_gridWin->Refresh( FALSE, &r );
-    }
-
-    wxGridRangeSelectEvent gridEvt( GetId(),
-                                    wxEVT_GRID_RANGE_SELECT,
-                                    this,
-                                    m_selectedTopLeft,
-                                    m_selectedBottomRight );
-
-    GetEventHandler()->ProcessEvent(gridEvt);
+    m_selection->SelectRow( row, FALSE, addToSelected );
  }
  
  
  void wxGrid::SelectCol( int col, bool addToSelected )
  {
  }
  
  
  void wxGrid::SelectCol( int col, bool addToSelected )
  {
-    if ( IsSelection() && addToSelected )
-    {
-        wxRect  rect[4];
-        bool    need_refresh[4];
-        need_refresh[0] =
-        need_refresh[1] =
-        need_refresh[2] =
-        need_refresh[3] = FALSE;
-        int     i;
-
-        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
-        wxCoord oldTop    = m_selectedTopLeft.GetRow();
-        wxCoord oldRight  = m_selectedBottomRight.GetCol();
-        wxCoord oldBottom = m_selectedBottomRight.GetRow();
-
-        if ( oldLeft > col )
-        {
-            need_refresh[0] = TRUE;
-            rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
-                                         wxGridCellCoords ( m_numRows - 1,
-                                                            oldLeft - 1 ) );
-            m_selectedTopLeft.SetCol( col );
-        }
-
-        if ( oldTop  > 0 )
-        {
-            need_refresh[1] = TRUE;
-            rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
-                                         wxGridCellCoords ( oldTop - 1,
-                                                            oldRight ) );
-            m_selectedTopLeft.SetRow( 0 );
-        }
-
-        if ( oldRight < col )
-        {
-            need_refresh[2] = TRUE;
-            rect[2] = BlockToDeviceRect( wxGridCellCoords ( 0, oldRight + 1 ),
-                                         wxGridCellCoords ( m_numRows - 1,
-                                                            col            ) );
-            m_selectedBottomRight.SetCol( col );
-        }
-
-        if ( oldBottom < m_numRows - 1 )
-        {
-            need_refresh[3] = TRUE;
-            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1,
-                                                            oldLeft ),
-                                         wxGridCellCoords ( m_numRows - 1,
-                                                            oldRight ) );
-            m_selectedBottomRight.SetRow( m_numRows - 1 );
-        }
-
-        for (i = 0; i < 4; i++ )
-            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
-                m_gridWin->Refresh( FALSE, &(rect[i]) );
-    }
-    else
-    {
-        wxRect r;
-
-        r = SelectionToDeviceRect();
+    if ( IsSelection() && !addToSelected )
          ClearSelection();
          ClearSelection();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
-
-        m_selectedTopLeft.Set( 0, col );
-        m_selectedBottomRight.Set( m_numRows-1, col );
-        r = SelectionToDeviceRect();
-        m_gridWin->Refresh( FALSE, &r );
-    }
  
  
-    wxGridRangeSelectEvent gridEvt( GetId(),
-                                    wxEVT_GRID_RANGE_SELECT,
-                                    this,
-                                    m_selectedTopLeft,
-                                    m_selectedBottomRight );
-
-    GetEventHandler()->ProcessEvent(gridEvt);
+    m_selection->SelectCol( col, FALSE, 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 )
  {
  {
-    int temp;
-    wxGridCellCoords updateTopLeft, updateBottomRight;
-
-    if ( topRow > bottomRow )
-    {
-        temp = topRow;
-        topRow = bottomRow;
-        bottomRow = temp;
-    }
-
-    if ( leftCol > rightCol )
-    {
-        temp = leftCol;
-        leftCol = rightCol;
-        rightCol = temp;
-    }
-
-    updateTopLeft = wxGridCellCoords( topRow, leftCol );
-    updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
-
-    if ( m_selectedTopLeft != updateTopLeft ||
-         m_selectedBottomRight != updateBottomRight )
-    {
-        // Compute two optimal update rectangles:
-        // Either one rectangle is a real subset of the
-        // other, or they are (almost) disjoint!
-        wxRect  rect[4];
-        bool    need_refresh[4];
-        need_refresh[0] =
-        need_refresh[1] =
-        need_refresh[2] =
-        need_refresh[3] = FALSE;
-        int     i;
-
-        // Store intermediate values
-        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
-        wxCoord oldTop    = m_selectedTopLeft.GetRow();
-        wxCoord oldRight  = m_selectedBottomRight.GetCol();
-        wxCoord oldBottom = m_selectedBottomRight.GetRow();
-
-        // Determine the outer/inner coordinates.
-        if (oldLeft > leftCol)
-        {
-            temp = oldLeft;
-            oldLeft = leftCol;
-            leftCol = temp;
-        }
-        if (oldTop > topRow )
-        {
-            temp = oldTop;
-            oldTop = topRow;
-            topRow = temp;
-        }
-        if (oldRight < rightCol )
-        {
-            temp = oldRight;
-            oldRight = rightCol;
-            rightCol = temp;
-        }
-        if (oldBottom < bottomRow)
-        {
-            temp = oldBottom;
-            oldBottom = bottomRow;
-            bottomRow = temp;
-        }
-
-        // Now, either the stuff marked old is the outer
-        // rectangle or we don't have a situation where one
-        // is contained in the other.
-
-        if ( oldLeft < leftCol )
-        {
-            need_refresh[0] = TRUE;
-            rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
-                                                            oldLeft ),
-                                         wxGridCellCoords ( oldBottom,
-                                                            leftCol - 1 ) );
-        }
-
-        if ( oldTop  < topRow )
-        {
-            need_refresh[1] = TRUE;
-            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
-                                                            leftCol ),
-                                         wxGridCellCoords ( topRow - 1,
-                                                            rightCol ) );
-        }
-
-        if ( oldRight > rightCol )
-        {
-            need_refresh[2] = TRUE;
-            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
-                                                            rightCol + 1 ),
-                                         wxGridCellCoords ( oldBottom,
-                                                            oldRight ) );
-        }
-
-        if ( oldBottom > bottomRow )
-        {
-            need_refresh[3] = TRUE;
-            rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
-                                                            leftCol ),
-                                         wxGridCellCoords ( oldBottom,
-                                                            rightCol ) );
-        }
-
-
-        // Change Selection
-        m_selectedTopLeft = updateTopLeft;
-        m_selectedBottomRight = updateBottomRight;
-
-        // various Refresh() calls
-        for (i = 0; i < 4; i++ )
-            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
-                m_gridWin->Refresh( FALSE, &(rect[i]) );
-    }
-
-    // only generate an event if the block is not being selected by
-    // dragging the mouse (in which case the event will be generated in
-    // the mouse event handler)
-    if ( !m_isDragging )
-    {
-        wxGridRangeSelectEvent gridEvt( GetId(),
-                                        wxEVT_GRID_RANGE_SELECT,
-                                        this,
-                                        m_selectedTopLeft,
-                                        m_selectedBottomRight );
+    if ( IsSelection() && !addToSelected )
+        ClearSelection();
  
  
-        GetEventHandler()->ProcessEvent(gridEvt);
-    }
+    m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
+                              FALSE, addToSelected );
  }
  
  }
  
+
  void wxGrid::SelectAll()
  {
  void wxGrid::SelectAll()
  {
-    m_selectedTopLeft.Set( 0, 0 );
-    m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
+    m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+}
  
  
-    m_gridWin->Refresh();
+bool wxGrid::IsSelection()
+{
+    return ( m_selection->IsSelection() ||
+             ( m_selectingTopLeft != wxGridNoCellCoords &&
+               m_selectingBottomRight != wxGridNoCellCoords ) );
  }
  
  }
  
+bool wxGrid::IsInSelection( int row, int col )
+{
+    return ( m_selection->IsInSelection( row, col ) ||
+             ( row >= m_selectingTopLeft.GetRow() &&
+               col >= m_selectingTopLeft.GetCol() &&
+               row <= m_selectingBottomRight.GetRow() &&
+               col <= m_selectingBottomRight.GetCol() ) );
+}
  
  void wxGrid::ClearSelection()
  {
  
  void wxGrid::ClearSelection()
  {
-    m_selectedTopLeft = wxGridNoCellCoords;
-    m_selectedBottomRight = wxGridNoCellCoords;
+    m_selectingTopLeft = wxGridNoCellCoords;
+    m_selectingBottomRight = wxGridNoCellCoords;
+    m_selection->ClearSelection();
  }
  
  
  }
  
  
@@ -7373,6 +8337,9 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
      int cw, ch;
      m_gridWin->GetClientSize( &cw, &ch );
  
      int cw, ch;
      m_gridWin->GetClientSize( &cw, &ch );
  
+    if (right < 0 || bottom < 0 || left > cw || top > ch)
+        return wxRect( 0, 0, 0, 0);
+
      rect.SetLeft( wxMax(0, left) );
      rect.SetTop( wxMax(0, top) );
      rect.SetRight( wxMin(cw, right) );
      rect.SetLeft( wxMax(0, left) );
      rect.SetTop( wxMax(0, top) );
      rect.SetRight( wxMin(cw, right) );
@@ -7390,7 +8357,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
  IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
  
  wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
  IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
  
  wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
-                          int row, int col, int x, int y,
+                          int row, int col, int x, int y, bool sel,
                            bool control, bool shift, bool alt, bool meta )
          : wxNotifyEvent( type, id )
  {
                            bool control, bool shift, bool alt, bool meta )
          : wxNotifyEvent( type, id )
  {
@@ -7398,6 +8365,7 @@ wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
      m_col = col;
      m_x = x;
      m_y = y;
      m_col = col;
      m_x = x;
      m_y = y;
+    m_selecting = sel;
      m_control = control;
      m_shift = shift;
      m_alt = alt;
      m_control = control;
      m_shift = shift;
      m_alt = alt;
@@ -7431,11 +8399,13 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
  wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                 const wxGridCellCoords& topLeft,
                                                 const wxGridCellCoords& bottomRight,
  wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                 const wxGridCellCoords& topLeft,
                                                 const wxGridCellCoords& bottomRight,
-                                               bool control, bool shift, bool alt, bool meta )
+                                               bool sel, bool control,
+                                               bool shift, bool alt, bool meta )
          : wxNotifyEvent( type, id )
  {
      m_topLeft     = topLeft;
      m_bottomRight = bottomRight;
          : wxNotifyEvent( type, id )
  {
      m_topLeft     = topLeft;
      m_bottomRight = bottomRight;
+    m_selecting   = sel;
      m_control     = control;
      m_shift       = shift;
      m_alt         = alt;
      m_control     = control;
      m_shift       = shift;
      m_alt         = alt;
@@ -7446,4 +8416,3 @@ wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObjec
  
  
  #endif // ifndef wxUSE_NEW_GRID
  
  
  #endif // ifndef wxUSE_NEW_GRID
-