Check multiple selection :-)

[wxWidgets.git] / src / generic / grid.cpp

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index cbdb0110ac6db378959c237c65d0dc8868225a20..623d484c3bf0d33b6ea0a8fa7d8a629a19a9e9f6 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////

-// Name:        grid.cpp
+// Name:        generic/grid.cpp

 // Purpose:     wxGrid and related classes
 // Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)
 // Modified by:
 // Purpose:     wxGrid and related classes
 // Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)
 // Modified by:


@@ -39,12 +39,14 @@
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"

+    #include "wx/textctrl.h"
+    #include "wx/checkbox.h"

 #endif
 
 // this include needs to be outside precomp for BCC
 #include "wx/textfile.h"
 
 #endif
 
 // this include needs to be outside precomp for BCC
 #include "wx/textfile.h"
 

-#include "wx/generic/grid.h"
+#include "wx/grid.h"

 
 // ----------------------------------------------------------------------------
 // array classes
 
 // ----------------------------------------------------------------------------
 // array classes


@@ -181,6 +183,7 @@ public:
         { }
 
     void OnKeyDown(wxKeyEvent& event);
         { }
 
     void OnKeyDown(wxKeyEvent& event);

+    void OnChar(wxKeyEvent& event);

 
 private:
     wxGrid*             m_grid;
 
 private:
     wxGrid*             m_grid;


@@ -193,6 +196,7 @@ private:
 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )

+    EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 


@@ -207,6 +211,8 @@ class WXDLLEXPORT wxGridCellAttrData
 public:
     void SetAttr(wxGridCellAttr *attr, int row, int col);
     wxGridCellAttr *GetAttr(int row, int col) const;
 public:
     void SetAttr(wxGridCellAttr *attr, int row, int col);
     wxGridCellAttr *GetAttr(int row, int col) const;

+    void UpdateAttrRows( size_t pos, int numRows );
+    void UpdateAttrCols( size_t pos, int numCols );

 
 private:
     // searches for the attr for given cell, returns wxNOT_FOUND if not found
 
 private:
     // searches for the attr for given cell, returns wxNOT_FOUND if not found


@@ -219,10 +225,13 @@ private:
 class WXDLLEXPORT wxGridRowOrColAttrData
 {
 public:
 class WXDLLEXPORT wxGridRowOrColAttrData
 {
 public:

+    // empty ctor to suppress warnings
+    wxGridRowOrColAttrData() { }

     ~wxGridRowOrColAttrData();
 
     void SetAttr(wxGridCellAttr *attr, int rowOrCol);
     wxGridCellAttr *GetAttr(int rowOrCol) const;
     ~wxGridRowOrColAttrData();
 
     void SetAttr(wxGridCellAttr *attr, int rowOrCol);
     wxGridCellAttr *GetAttr(int rowOrCol) const;

+    void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );

 
 private:
     wxArrayInt m_rowsOrCols;
 
 private:
     wxArrayInt m_rowsOrCols;


@@ -257,6 +266,10 @@ public:
     static size_t gs_nAttrCacheMisses = 0;
 #endif // DEBUG_ATTR_CACHE
 
     static size_t gs_nAttrCacheMisses = 0;
 #endif // DEBUG_ATTR_CACHE
 

+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+

 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 


@@ -264,11 +277,14 @@ wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 // TODO: fixed so far - make configurable later (and also different for x/y)
 static const size_t GRID_SCROLL_LINE = 10;
 
 // TODO: fixed so far - make configurable later (and also different for x/y)
 static const size_t GRID_SCROLL_LINE = 10;
 

+// the size of hash tables used a bit everywhere (the max number of elements
+// in these hash tables is the number of rows/columns)
+static const int GRID_HASH_SIZE = 100;
+

 // ============================================================================
 // implementation
 // ============================================================================
 
 // ============================================================================
 // implementation
 // ============================================================================
 

-

 // ----------------------------------------------------------------------------
 // wxGridCellEditor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellEditor
 // ----------------------------------------------------------------------------


@@ -284,20 +300,90 @@ wxGridCellEditor::~wxGridCellEditor()
     Destroy();
 }
 
     Destroy();
 }
 

+void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
+                              wxWindowID WXUNUSED(id),
+                              wxEvtHandler* evtHandler)
+{
+    if ( evtHandler )
+        m_control->PushEventHandler(evtHandler);
+}
+
+void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
+                                       wxGridCellAttr *attr)
+{
+    // erase the background because we might not fill the cell
+    wxClientDC dc(m_control->GetParent());
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
+    dc.DrawRectangle(rectCell);
+
+    // redraw the control we just painted over
+    m_control->Refresh();
+}

 
 void wxGridCellEditor::Destroy()
 {
 
 void wxGridCellEditor::Destroy()
 {

-    if (m_control) {
+    if (m_control)
+    {

         m_control->Destroy();
         m_control = NULL;
     }
 }
 
         m_control->Destroy();
         m_control = NULL;
     }
 }
 

-void wxGridCellEditor::Show(bool show)
+void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)

 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
     m_control->Show(show);
 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
     m_control->Show(show);

+
+    if ( show )
+    {
+        // set the colours/fonts if we have any
+        if ( attr )
+        {
+            if ( attr->HasTextColour() )
+            {
+                m_colFgOld = m_control->GetForegroundColour();
+                m_control->SetForegroundColour(attr->GetTextColour());
+            }
+
+            if ( attr->HasBackgroundColour() )
+            {
+                m_colBgOld = m_control->GetBackgroundColour();
+                m_control->SetBackgroundColour(attr->GetBackgroundColour());
+            }
+
+            if ( attr->HasFont() )
+            {
+                m_fontOld = m_control->GetFont();
+                m_control->SetFont(attr->GetFont());
+            }
+
+            // can't do anything more in the base class version, the other
+            // attributes may only be used by the derived classes
+        }
+    }
+    else
+    {
+        // restore the standard colours fonts
+        if ( m_colFgOld.Ok() )
+        {
+            m_control->SetForegroundColour(m_colFgOld);
+            m_colFgOld = wxNullColour;
+        }
+
+        if ( m_colBgOld.Ok() )
+        {
+            m_control->SetBackgroundColour(m_colBgOld);
+            m_colBgOld = wxNullColour;
+        }
+
+        if ( m_fontOld.Ok() )
+        {
+            m_control->SetFont(m_fontOld);
+            m_fontOld = wxNullFont;
+        }
+    }

 }
 
 void wxGridCellEditor::SetSize(const wxRect& rect)
 }
 
 void wxGridCellEditor::SetSize(const wxRect& rect)


@@ -313,57 +399,72 @@ void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
 }
 
 
 }
 
 

+void wxGridCellEditor::StartingKey(wxKeyEvent& event)
+{
+    event.Skip();
+}
+
+void wxGridCellEditor::StartingClick()
+{
+}
+
+// ----------------------------------------------------------------------------
+// wxGridCellTextEditor
+// ----------------------------------------------------------------------------
+

 wxGridCellTextEditor::wxGridCellTextEditor()
 {
 }
 
 void wxGridCellTextEditor::Create(wxWindow* parent,
                                   wxWindowID id,
 wxGridCellTextEditor::wxGridCellTextEditor()
 {
 }
 
 void wxGridCellTextEditor::Create(wxWindow* parent,
                                   wxWindowID id,

-                                  const wxPoint& pos,
-                                  const wxSize& size,

                                   wxEvtHandler* evtHandler)
 {
                                   wxEvtHandler* evtHandler)
 {

-    m_control = new wxTextCtrl(parent, -1, "", pos, size
+    m_control = new wxTextCtrl(parent, id, wxEmptyString,
+                               wxDefaultPosition, wxDefaultSize

 #if defined(__WXMSW__)
 #if defined(__WXMSW__)

-                           , wxTE_MULTILINE | wxTE_NO_VSCROLL
+                               , wxTE_MULTILINE | wxTE_NO_VSCROLL // necessary ???

 #endif
 #endif

-        );
+                              );

 
 

-    if (evtHandler)
-        m_control->PushEventHandler(evtHandler);
+    wxGridCellEditor::Create(parent, id, evtHandler);

 }
 
 }
 

+void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
+                                           wxGridCellAttr * WXUNUSED(attr))
+{
+    // as we fill the entire client area, don't do anything here to minimize
+    // flicker
+}

 
 

-void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid,
-                           wxGridCellAttr* attr)
+void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)

 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     m_startValue = grid->GetTable()->GetValue(row, col);
 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     m_startValue = grid->GetTable()->GetValue(row, col);

-    ((wxTextCtrl*)m_control)->SetValue(m_startValue);
-    ((wxTextCtrl*)m_control)->SetInsertionPointEnd();
-    ((wxTextCtrl*)m_control)->SetFocus();
-
-    // ???  Should we use attr and try to set colours and font?
+    Text()->SetValue(m_startValue);
+    Text()->SetInsertionPointEnd();
+    Text()->SetFocus();

 }
 
 
 }
 
 

-

 bool wxGridCellTextEditor::EndEdit(int row, int col, bool saveValue,
 bool wxGridCellTextEditor::EndEdit(int row, int col, bool saveValue,

-                                   wxGrid* grid, wxGridCellAttr* attr)
+                                   wxGrid* grid)

 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     bool changed = FALSE;
 {
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     bool changed = FALSE;

-    wxString value = ((wxTextCtrl*)m_control)->GetValue();
+    wxString value = Text()->GetValue();

     if (value != m_startValue)
         changed = TRUE;
 
     if (changed)
         grid->GetTable()->SetValue(row, col, value);
     if (value != m_startValue)
         changed = TRUE;
 
     if (changed)
         grid->GetTable()->SetValue(row, col, value);

-    m_startValue = "";
+
+    m_startValue = wxEmptyString;
+    Text()->SetValue(m_startValue);

 
     return changed;
 }
 
     return changed;
 }


@@ -374,19 +475,43 @@ void wxGridCellTextEditor::Reset()
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 
     wxASSERT_MSG(m_control,
                  wxT("The wxGridCellEditor must be Created first!"));
 

-    ((wxTextCtrl*)m_control)->SetValue(m_startValue);
-    ((wxTextCtrl*)m_control)->SetInsertionPointEnd();
+    Text()->SetValue(m_startValue);
+    Text()->SetInsertionPointEnd();
+}
+
+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);
+            }
+
+            Text()->AppendText((wxChar)keycode);
+
+            return;
+        }
+
+    }
+
+    event.Skip();

 }
 
 void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
 {
 #if defined(__WXMOTIF__) || defined(__WXGTK__)
     // wxMotif needs a little extra help...
 }
 
 void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
 {
 #if defined(__WXMOTIF__) || defined(__WXGTK__)
     // wxMotif needs a little extra help...

-    int pos = ((wxTextCtrl*)m_control)->GetInsertionPoint();
-    wxString s( ((wxTextCtrl*)m_control)->GetValue() );
+    int pos = Text()->GetInsertionPoint();
+    wxString s( Text()->GetValue() );

     s = s.Left(pos) + "\n" + s.Mid(pos);
     s = s.Left(pos) + "\n" + s.Mid(pos);

-    ((wxTextCtrl*)m_control)->SetValue(s);
-    ((wxTextCtrl*)m_control)->SetInsertionPoint( pos );
+    Text()->SetValue(s);
+    Text()->SetInsertionPoint( pos );

 #else
     // the other ports can handle a Return key press
     //
 #else
     // the other ports can handle a Return key press
     //


@@ -394,6 +519,94 @@ void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
 #endif
 }
 
 #endif
 }
 

+// ----------------------------------------------------------------------------
+// wxGridCellBoolEditor
+// ----------------------------------------------------------------------------
+
+void wxGridCellBoolEditor::Create(wxWindow* parent,
+                                  wxWindowID id,
+                                  wxEvtHandler* evtHandler)
+{
+    m_control = new wxCheckBox(parent, id, wxEmptyString,
+                               wxDefaultPosition, wxDefaultSize,
+                               wxNO_BORDER);
+
+    wxGridCellEditor::Create(parent, id, evtHandler);
+}
+
+void wxGridCellBoolEditor::SetSize(const wxRect& r)
+{
+    // position it in the centre of the rectangle (TODO: support alignment?)
+    wxCoord w, h;
+    m_control->GetSize(&w, &h);
+
+    // the checkbox without label still has some space to the right in wxGTK,
+    // so shift it to the right
+#ifdef __WXGTK__
+    w -= 8;
+#endif // GTK
+
+    m_control->Move(r.x + r.width/2 - w/2, r.y + r.height/2 - h/2);
+}
+
+void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
+{
+    wxGridCellEditor::Show(show, attr);
+    if ( show )
+    {
+        // VZ: normally base class already does it, but it doesn't work (FIXME)
+        wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
+        CBox()->SetBackgroundColour(colBg);
+    }
+}
+
+void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
+{
+    wxASSERT_MSG(m_control,
+                 wxT("The wxGridCellEditor must be Created first!"));
+
+    m_startValue = !!grid->GetTable()->GetValue(row, col); // FIXME-DATA
+    CBox()->SetValue(m_startValue);
+    CBox()->SetFocus();
+}
+
+bool wxGridCellBoolEditor::EndEdit(int row, int col,
+                                   bool saveValue,
+                                   wxGrid* grid)
+{
+    wxASSERT_MSG(m_control,
+                 wxT("The wxGridCellEditor must be Created first!"));
+
+    bool changed = FALSE;
+    bool value = CBox()->GetValue();
+    if ( value != m_startValue )
+        changed = TRUE;
+
+    if ( changed )
+    {
+        // FIXME-DATA
+        grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
+    }
+
+    return changed;
+}
+
+void wxGridCellBoolEditor::Reset()
+{
+    wxASSERT_MSG(m_control,
+                 wxT("The wxGridCellEditor must be Created first!"));
+
+    CBox()->SetValue(m_startValue);
+}
+
+void wxGridCellBoolEditor::StartingClick()
+{
+    CBox()->SetValue(!CBox()->GetValue());
+}
+
+// ----------------------------------------------------------------------------
+// wxGridCellEditorEvtHandler
+// ----------------------------------------------------------------------------

 
 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 {
 
 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 {


@@ -401,18 +614,10 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
     {
         case WXK_ESCAPE:
             m_editor->Reset();
     {
         case WXK_ESCAPE:
             m_editor->Reset();

+            m_grid->DisableCellEditControl();

             break;
 
             break;
 

-        case WXK_UP:
-        case WXK_DOWN:
-        case WXK_LEFT:
-        case WXK_RIGHT:
-        case WXK_PRIOR:
-        case WXK_NEXT:
-        case WXK_SPACE:
-            // send the event to the parent grid, skipping the
-            // event if nothing happens
-            //
+        case WXK_TAB:

             event.Skip( m_grid->ProcessEvent( event ) );
             break;
 
             event.Skip( m_grid->ProcessEvent( event ) );
             break;
 


@@ -421,12 +626,19 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
                 m_editor->HandleReturn(event);
             break;
 
                 m_editor->HandleReturn(event);
             break;
 

-        case WXK_HOME:
-        case WXK_END:
-            // send the event to the parent grid, skipping the
-            // event if nothing happens
-            //
-            event.Skip( m_grid->ProcessEvent( event ) );
+
+        default:
+            event.Skip();
+    }
+}
+
+void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
+{
+    switch ( event.KeyCode() )
+    {
+        case WXK_ESCAPE:
+        case WXK_TAB:
+        case WXK_RETURN:

             break;
 
         default:
             break;
 
         default:


@@ -434,6 +646,10 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
     }
 }
 
     }
 }
 

+// ============================================================================
+// renderer classes
+// ============================================================================
+

 // ----------------------------------------------------------------------------
 // wxGridCellRenderer
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellRenderer
 // ----------------------------------------------------------------------------


@@ -457,10 +673,13 @@ void wxGridCellRenderer::Draw(wxGrid& grid,
     }
 
     dc.SetPen( *wxTRANSPARENT_PEN );
     }
 
     dc.SetPen( *wxTRANSPARENT_PEN );

-

     dc.DrawRectangle(rect);
 }
 
     dc.DrawRectangle(rect);
 }
 

+// ----------------------------------------------------------------------------
+// wxGridCellStringRenderer
+// ----------------------------------------------------------------------------
+

 void wxGridCellStringRenderer::Draw(wxGrid& grid,
                                     wxGridCellAttr& attr,
                                     wxDC& dc,
 void wxGridCellStringRenderer::Draw(wxGrid& grid,
                                     wxGridCellAttr& attr,
                                     wxDC& dc,


@@ -473,6 +692,8 @@ void wxGridCellStringRenderer::Draw(wxGrid& grid,
     // now we only have to draw the text
     dc.SetBackgroundMode( wxTRANSPARENT );
 
     // now we only have to draw the text
     dc.SetBackgroundMode( wxTRANSPARENT );
 

+    // TODO some special colours for attr.IsReadOnly() case?
+

     if ( isSelected )
     {
         dc.SetTextBackground( grid.GetSelectionBackground() );
     if ( isSelected )
     {
         dc.SetTextBackground( grid.GetSelectionBackground() );


@@ -498,6 +719,58 @@ void wxGridCellStringRenderer::Draw(wxGrid& grid,
                            rect, hAlign, vAlign);
 }
 
                            rect, hAlign, vAlign);
 }
 

+// ----------------------------------------------------------------------------
+// wxGridCellBoolRenderer
+// ----------------------------------------------------------------------------
+
+void wxGridCellBoolRenderer::Draw(wxGrid& grid,
+                                  wxGridCellAttr& attr,
+                                  wxDC& dc,
+                                  const wxRect& rect,
+                                  int row, int col,
+                                  bool isSelected)
+{
+    wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
+
+    // between checkmark and box
+    static const wxCoord margin = 4;
+
+    // get checkbox size
+    static wxCoord s_checkSize = 0;
+    if ( s_checkSize == 0 )
+    {
+        // compute it only once (no locks for MT safeness in GUI thread...)
+        wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
+        wxSize size = checkbox->GetBestSize();
+        s_checkSize = size.y + margin;
+
+        // FIXME wxGTK::wxCheckBox::GetBestSize() is really weird...
+#ifdef __WXGTK__
+        s_checkSize -= size.y / 2;
+#endif
+
+        delete checkbox;
+    }
+
+    // draw a check mark in the centre (ignoring alignment - TODO)
+    wxRect rectMark;
+    rectMark.x = rect.x + rect.width/2 - s_checkSize/2;
+    rectMark.y = rect.y + rect.height/2 - s_checkSize/2;
+    rectMark.width = rectMark.height = s_checkSize;
+
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
+    dc.DrawRectangle(rectMark);
+
+    rectMark.Inflate(-margin);
+
+    if ( !!grid.GetTable()->GetValue(row, col) ) // FIXME-DATA
+    {
+        dc.SetTextForeground(attr.GetTextColour());
+        dc.DrawCheckMark(rectMark);
+    }
+}
+

 // ----------------------------------------------------------------------------
 // wxGridCellAttr
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellAttr
 // ----------------------------------------------------------------------------


@@ -505,10 +778,15 @@ void wxGridCellStringRenderer::Draw(wxGrid& grid,
 const wxColour& wxGridCellAttr::GetTextColour() const
 {
     if (HasTextColour())
 const wxColour& wxGridCellAttr::GetTextColour() const
 {
     if (HasTextColour())

+    {

         return m_colText;
         return m_colText;

+    }

     else if (m_defGridAttr != this)
     else if (m_defGridAttr != this)

+    {

         return m_defGridAttr->GetTextColour();
         return m_defGridAttr->GetTextColour();

-    else {
+    }
+    else
+    {

         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullColour;
     }
         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullColour;
     }


@@ -521,7 +799,8 @@ const wxColour& wxGridCellAttr::GetBackgroundColour() const
         return m_colBack;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetBackgroundColour();
         return m_colBack;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetBackgroundColour();

-    else {
+    else
+    {

         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullColour;
     }
         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullColour;
     }


@@ -534,7 +813,8 @@ const wxFont& wxGridCellAttr::GetFont() const
         return m_font;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetFont();
         return m_font;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetFont();

-    else {
+    else
+    {

         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullFont;
     }
         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return wxNullFont;
     }


@@ -543,13 +823,15 @@ const wxFont& wxGridCellAttr::GetFont() const
 
 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
 {
 
 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
 {

-    if (HasAlignment()) {
+    if (HasAlignment())
+    {

         if ( hAlign ) *hAlign = m_hAlign;
         if ( vAlign ) *vAlign = m_vAlign;
     }
     else if (m_defGridAttr != this)
         m_defGridAttr->GetAlignment(hAlign, vAlign);
         if ( hAlign ) *hAlign = m_hAlign;
         if ( vAlign ) *vAlign = m_vAlign;
     }
     else if (m_defGridAttr != this)
         m_defGridAttr->GetAlignment(hAlign, vAlign);

-    else {
+    else
+    {

         wxFAIL_MSG(wxT("Missing default cell attribute"));
     }
 }
         wxFAIL_MSG(wxT("Missing default cell attribute"));
     }
 }


@@ -561,7 +843,21 @@ wxGridCellRenderer* wxGridCellAttr::GetRenderer() const
         return m_renderer;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetRenderer();
         return m_renderer;
     else if (m_defGridAttr != this)
         return m_defGridAttr->GetRenderer();

-    else {
+    else
+    {
+        wxFAIL_MSG(wxT("Missing default cell attribute"));
+        return NULL;
+    }
+}
+
+wxGridCellEditor* wxGridCellAttr::GetEditor() const
+{
+    if (HasEditor())
+        return m_editor;
+    else if (m_defGridAttr != this)
+        return m_defGridAttr->GetEditor();
+    else
+    {

         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return NULL;
     }
         wxFAIL_MSG(wxT("Missing default cell attribute"));
         return NULL;
     }


@@ -608,6 +904,72 @@ wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
     return attr;
 }
 
     return attr;
 }
 

+void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
+{
+    size_t count = m_attrs.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        wxGridCellCoords& coords = m_attrs[n].coords;
+        wxCoord row = coords.GetRow();
+        if ((size_t)row >= pos)
+        {
+            if (numRows > 0)
+            {
+                // If rows inserted, include row counter where necessary
+                coords.SetRow(row + numRows);
+            }
+            else if (numRows < 0)
+            {
+                // If rows deleted ...
+                if ((size_t)row >= pos - numRows)
+                {
+                    // ...either decrement row counter (if row still exists)...
+                    coords.SetRow(row + numRows);
+                }
+                else
+                {
+                    // ...or remove the attribute
+                    m_attrs.RemoveAt((size_t)n);
+                    n--; count--;
+                }
+            }
+        }
+    }
+}
+
+void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
+{
+    size_t count = m_attrs.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        wxGridCellCoords& coords = m_attrs[n].coords;
+        wxCoord col = coords.GetCol();
+        if ( (size_t)col >= pos )
+        {
+            if ( numCols > 0 )
+            {
+                // If rows inserted, include row counter where necessary
+                coords.SetCol(col + numCols);
+            }
+            else if (numCols < 0)
+            {
+                // If rows deleted ...
+                if ((size_t)col >= pos - numCols)
+                {
+                    // ...either decrement row counter (if row still exists)...
+                    coords.SetCol(col + numCols);
+                }
+                else
+                {
+                    // ...or remove the attribute
+                    m_attrs.RemoveAt((size_t)n);
+                    n--; count--;
+                }
+            }
+        }
+    }
+}
+

 int wxGridCellAttrData::FindIndex(int row, int col) const
 {
     size_t count = m_attrs.GetCount();
 int wxGridCellAttrData::FindIndex(int row, int col) const
 {
     size_t count = m_attrs.GetCount();


@@ -676,6 +1038,35 @@ void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
     }
 }
 
     }
 }
 

+void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
+{
+    size_t count = m_attrs.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        int & rowOrCol = m_rowsOrCols[n];
+        if ( (size_t)rowOrCol >= pos )
+        {
+            if ( numRowsOrCols > 0 )
+            {
+                // If rows inserted, include row counter where necessary
+                rowOrCol += numRowsOrCols;
+            }
+            else if ( numRowsOrCols < 0)
+            {
+                // If rows deleted, either decrement row counter (if row still exists)
+                if ((size_t)rowOrCol >= pos - numRowsOrCols)
+                    rowOrCol += numRowsOrCols;
+                else
+                {
+                    m_rowsOrCols.RemoveAt((size_t)n);
+                    m_attrs.RemoveAt((size_t)n);
+                    n--; count--;
+                }
+            }
+        }
+    }
+}
+

 // ----------------------------------------------------------------------------
 // wxGridCellAttrProvider
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellAttrProvider
 // ----------------------------------------------------------------------------


@@ -745,6 +1136,26 @@ void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
     m_data->m_colAttrs.SetAttr(attr, col);
 }
 
     m_data->m_colAttrs.SetAttr(attr, col);
 }
 

+void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
+{
+    if ( m_data )
+    {
+        m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
+
+        m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
+    }
+}
+
+void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
+{
+    if ( m_data )
+    {
+        m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
+
+        m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
+    }
+}
+

 // ----------------------------------------------------------------------------
 // wxGridTableBase
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridTableBase
 // ----------------------------------------------------------------------------


@@ -823,6 +1234,22 @@ void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
     }
 }
 
     }
 }
 

+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 );
+    }
+}
+

 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
     wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
     wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"


@@ -1050,7 +1477,7 @@ 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,


@@ -1130,7 +1557,7 @@ 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,


@@ -1163,7 +1590,7 @@ 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,


@@ -1247,7 +1674,7 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
             }
         }
     }
             }
         }
     }

-
+    UpdateAttrCols( pos, -((int)numCols) );

     if ( GetView() )
     {
         wxGridTableMessage msg( this,
     if ( GetView() )
     {
         wxGridTableMessage msg( this,


@@ -1321,116 +1748,7 @@ void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
 
 
 
 
 
 

-

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

-
-IMPLEMENT_DYNAMIC_CLASS( wxGridTextCtrl, wxTextCtrl )
-
-BEGIN_EVENT_TABLE( wxGridTextCtrl, wxTextCtrl )
-    EVT_KEY_DOWN( wxGridTextCtrl::OnKeyDown )
-END_EVENT_TABLE()
-
-
-wxGridTextCtrl::wxGridTextCtrl( wxWindow *par,
-                                wxGrid *grid,
-                                bool isCellControl,
-                                wxWindowID id,
-                                const wxString& value,
-                                const wxPoint& pos,
-                                const wxSize& size,
-                                long style )
-        : wxTextCtrl( par, id, value, pos, size, style )
-{
-    m_grid = grid;
-    m_isCellControl = isCellControl;
-}
-
-
-void wxGridTextCtrl::OnKeyDown( wxKeyEvent& event )
-{
-    switch ( event.KeyCode() )
-    {
-        case WXK_ESCAPE:
-            m_grid->SetEditControlValue( startValue );
-            SetInsertionPointEnd();
-            break;
-
-        case WXK_UP:
-        case WXK_DOWN:
-        case WXK_LEFT:
-        case WXK_RIGHT:
-        case WXK_PRIOR:
-        case WXK_NEXT:
-        case WXK_SPACE:
-            if ( m_isCellControl )
-            {
-                // send the event to the parent grid, skipping the
-                // event if nothing happens
-                //
-                event.Skip( m_grid->ProcessEvent( event ) );
-            }
-            else
-            {
-                // default text control response within the top edit
-                // control
-                //
-                event.Skip();
-            }
-            break;
-
-        case WXK_RETURN:
-            if ( m_isCellControl )
-            {
-                if ( !m_grid->ProcessEvent( event ) )
-                {
-#if defined(__WXMOTIF__) || defined(__WXGTK__)
-                    // wxMotif needs a little extra help...
-                    //
-                    int pos = GetInsertionPoint();
-                    wxString s( GetValue() );
-                    s = s.Left(pos) + "\n" + s.Mid(pos);
-                    SetValue(s);
-                    SetInsertionPoint( pos );
-#else
-                    // the other ports can handle a Return key press
-                    //
-                    event.Skip();
-#endif
-                }
-            }
-            break;
-
-        case WXK_HOME:
-        case WXK_END:
-            if ( m_isCellControl )
-            {
-                // send the event to the parent grid, skipping the
-                // event if nothing happens
-                //
-                event.Skip( m_grid->ProcessEvent( event ) );
-            }
-            else
-            {
-                // default text control response within the top edit
-                // control
-                //
-                event.Skip();
-            }
-            break;
-
-        default:
-            event.Skip();
-    }
-}
-
-void wxGridTextCtrl::SetStartValue( const wxString& s )
-{
-    startValue = s;
-    wxTextCtrl::SetValue(s);
-}
-
-
-

 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )


@@ -1609,7 +1927,6 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
     m_colLabelWin = colLblWin;
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
     m_colLabelWin = colLblWin;

-

     SetBackgroundColour( "WHITE" );
 }
 
     SetBackgroundColour( "WHITE" );
 }
 


@@ -1629,6 +1946,7 @@ void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 #if WXGRID_DRAW_LINES
     m_owner->DrawAllGridLines( dc, reg );
 #endif
 #if WXGRID_DRAW_LINES
     m_owner->DrawAllGridLines( dc, reg );
 #endif

+    m_owner->DrawHighlight( dc );

 }
 
 
 }
 
 


@@ -1654,13 +1972,46 @@ void wxGridWindow::OnKeyDown( wxKeyEvent& event )
     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
 }
 
     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
 }
 

-void wxGridWindow::OnEraseBackground(wxEraseEvent&)
-{ }
-
+// We are trapping erase background events to reduce flicker under MSW
+// and GTK but this can leave junk in the space beyond the last row and
+// col.  So here we paint these spaces if they are visible.
+//
+void wxGridWindow::OnEraseBackground(wxEraseEvent& event)
+{
+    int cw, ch;
+    GetClientSize( &cw, &ch );
+    
+    int right, bottom;
+    m_owner->CalcUnscrolledPosition( cw, ch, &right, &bottom );
+    
+    wxRect rightRect;
+    rightRect = m_owner->CellToRect( 0, m_owner->GetNumberCols()-1 );
+
+    wxRect bottomRect;
+    bottomRect = m_owner->CellToRect( m_owner->GetNumberRows()-1, 0 );
+    
+    if ( right > rightRect.GetRight()  ||  bottom > bottomRect.GetBottom() )
+    {
+        int left, top;
+        m_owner->CalcUnscrolledPosition( 0, 0, &left, &top );
+        
+        wxClientDC dc( this );
+        m_owner->PrepareDC( dc );
+        dc.SetBrush( wxBrush(m_owner->GetDefaultCellBackgroundColour(), wxSOLID) );
+        dc.SetPen( *wxTRANSPARENT_PEN );
+        
+        if ( right > rightRect.GetRight() )
+            dc.DrawRectangle( rightRect.GetRight()+1, top, right - rightRect.GetRight(), ch );
+            
+        if ( bottom > bottomRect.GetBottom() )
+            dc.DrawRectangle( left, bottomRect.GetBottom()+1, cw, bottom - bottomRect.GetBottom() );
+    }
+}

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

+

 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
 
 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
 
 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )


@@ -1676,7 +2027,8 @@ wxGrid::wxGrid( wxWindow *parent,
                  const wxSize& size,
                  long style,
                  const wxString& name )
                  const wxSize& size,
                  long style,
                  const wxString& name )

-  : wxScrolledWindow( parent, id, pos, size, style, name )
+  : wxScrolledWindow( parent, id, pos, size, style, name ),
+    m_colMinWidths(wxKEY_INTEGER, GRID_HASH_SIZE)

 {
     Create();
 }
 {
     Create();
 }


@@ -1707,11 +2059,12 @@ 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 = FALSE;  // set to TRUE by OnPaint
+    m_displayed = TRUE; // FALSE;  // set to TRUE by OnPaint

 
     m_table        = (wxGridTableBase *) NULL;
     m_ownTable     = FALSE;
 
     m_table        = (wxGridTableBase *) NULL;
     m_ownTable     = FALSE;

-    m_cellEditCtrl = (wxWindow *) NULL;
+
+    m_cellEditCtrlEnabled = FALSE;

 
     m_defaultCellAttr = new wxGridCellAttr;
     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
 
     m_defaultCellAttr = new wxGridCellAttr;
     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);


@@ -1777,6 +2130,11 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
 {
     if ( m_created )
     {
 {
     if ( m_created )
     {

+        // RD: Actually, this should probably be allowed.  I think it would be
+        // nice to be able to switch multiple Tables in and out of a single
+        // View at runtime.  Is there anything in the implmentation that would
+        // prevent this?
+

         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;
     }


@@ -1799,8 +2157,6 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
 
 void wxGrid::Init()
 {
 
 void wxGrid::Init()
 {

-    int i;
-

     if ( m_numRows <= 0 )
         m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
 
     if ( m_numRows <= 0 )
         m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
 


@@ -1844,29 +2200,11 @@ void wxGrid::Init()
     m_defaultRowHeight += 4;
 #endif
 
     m_defaultRowHeight += 4;
 #endif
 

-    m_rowHeights.Alloc( m_numRows );
-    m_rowBottoms.Alloc( m_numRows );
-    int rowBottom = 0;
-    for ( i = 0;  i < m_numRows;  i++ )
-    {
-        m_rowHeights.Add( m_defaultRowHeight );
-        rowBottom += m_defaultRowHeight;
-        m_rowBottoms.Add( rowBottom );
-    }
-
-    m_colWidths.Alloc( m_numCols );
-    m_colRights.Alloc( m_numCols );
-    int colRight = 0;
-    for ( i = 0;  i < m_numCols;  i++ )
-    {
-        m_colWidths.Add( m_defaultColWidth );
-        colRight += m_defaultColWidth;
-        m_colRights.Add( colRight );
-    }
-
+    // Set default cell attributes

     m_defaultCellAttr->SetFont(GetFont());
     m_defaultCellAttr->SetAlignment(wxLEFT, wxTOP);
     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
     m_defaultCellAttr->SetFont(GetFont());
     m_defaultCellAttr->SetAlignment(wxLEFT, wxTOP);
     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);

+    m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);

     m_defaultCellAttr->SetTextColour(
         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
     m_defaultCellAttr->SetBackgroundColour(
     m_defaultCellAttr->SetTextColour(
         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
     m_defaultCellAttr->SetBackgroundColour(


@@ -1881,6 +2219,9 @@ void wxGrid::Init()
     m_dragLastPos  = -1;
     m_dragRowOrCol = -1;
     m_isDragging = FALSE;
     m_dragLastPos  = -1;
     m_dragRowOrCol = -1;
     m_isDragging = FALSE;

+    m_startDragPos = wxDefaultPosition;
+
+    m_waitForSlowClick = FALSE;

 
     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
 
     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );


@@ -1896,26 +2237,84 @@ void wxGrid::Init()
 
     m_inOnKeyDown = FALSE;
     m_batchCount = 0;
 
     m_inOnKeyDown = FALSE;
     m_batchCount = 0;

+}

 
 

-    // TODO: extend this to other types of controls
-    //
-    m_cellEditCtrl = new wxGridTextCtrl( m_gridWin,
-                                         this,
-                                         TRUE,
-                                         wxGRID_CELLCTRL,
-                                         "",
-                                         wxPoint(1,1),
-                                         wxSize(1,1)
-#if defined(__WXMSW__)
-                                         , wxTE_MULTILINE | wxTE_NO_VSCROLL
-#endif
-                                         );
+// ----------------------------------------------------------------------------
+// the idea is to call these functions only when necessary because they create
+// quite big arrays which eat memory mostly unnecessary - in particular, if
+// default widths/heights are used for all rows/columns, we may not use these
+// arrays at all
+//
+// with some extra code, it should be possible to only store the
+// widths/heights different from default ones but this will be done later...
+// ----------------------------------------------------------------------------
+
+void wxGrid::InitRowHeights()
+{
+    m_rowHeights.Empty();
+    m_rowBottoms.Empty();
+
+    m_rowHeights.Alloc( m_numRows );
+    m_rowBottoms.Alloc( m_numRows );
+
+    int rowBottom = 0;
+    for ( int i = 0;  i < m_numRows;  i++ )
+    {
+        m_rowHeights.Add( m_defaultRowHeight );
+        rowBottom += m_defaultRowHeight;
+        m_rowBottoms.Add( rowBottom );
+    }
+}
+
+void wxGrid::InitColWidths()
+{
+    m_colWidths.Empty();
+    m_colRights.Empty();
+
+    m_colWidths.Alloc( m_numCols );
+    m_colRights.Alloc( m_numCols );
+    int colRight = 0;
+    for ( int i = 0;  i < m_numCols;  i++ )
+    {
+        m_colWidths.Add( m_defaultColWidth );
+        colRight += m_defaultColWidth;
+        m_colRights.Add( colRight );
+    }
+}
+
+int wxGrid::GetColWidth(int col) const
+{
+    return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
+}
+
+int wxGrid::GetColLeft(int col) const
+{
+    return m_colRights.IsEmpty() ? col * m_defaultColWidth
+                                 : m_colRights[col] - m_colWidths[col];
+}

 
 

-    m_cellEditCtrl->Show( FALSE );
-    m_cellEditCtrlEnabled = TRUE;
-    m_editCtrlType = wxGRID_TEXTCTRL;
+int wxGrid::GetColRight(int col) const
+{
+    return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
+                                 : m_colRights[col];

 }
 
 }
 

+int wxGrid::GetRowHeight(int row) const
+{
+    return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
+}
+
+int wxGrid::GetRowTop(int row) const
+{
+    return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
+                                  : m_rowBottoms[row] - m_rowHeights[row];
+}
+
+int wxGrid::GetRowBottom(int row) const
+{
+    return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
+                                  : m_rowBottoms[row];
+}

 
 void wxGrid::CalcDimensions()
 {
 
 void wxGrid::CalcDimensions()
 {


@@ -1924,8 +2323,8 @@ void wxGrid::CalcDimensions()
 
     if ( m_numRows > 0  &&  m_numCols > 0 )
     {
 
     if ( m_numRows > 0  &&  m_numCols > 0 )
     {

-        int right = m_colRights[ m_numCols-1 ] + 50;
-        int bottom = m_rowBottoms[ m_numRows-1 ] + 50;
+        int right = GetColRight( m_numCols-1 ) + 50;
+        int bottom = GetRowBottom( m_numRows-1 ) + 50;

 
         // TODO: restore the scroll position that we had before sizing
         //
 
         // TODO: restore the scroll position that we had before sizing
         //


@@ -1964,6 +2363,18 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
 {
     int i;
 
 {
     int i;
 

+    // if we were using the default widths/heights so far, we must change them
+    // now
+    if ( m_colWidths.IsEmpty() )
+    {
+        InitColWidths();
+    }
+
+    if ( m_rowHeights.IsEmpty() )
+    {
+        InitRowHeights();
+    }
+

     switch ( msg.GetId() )
     {
         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
     switch ( msg.GetId() )
     {
         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:


@@ -2169,13 +2580,13 @@ void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
         // find the row labels within these bounds
         //
         int row;
         // find the row labels within these bounds
         //
         int row;

-        int rowTop;

         for ( row = 0;  row < m_numRows;  row++ )
         {
         for ( row = 0;  row < m_numRows;  row++ )
         {

-            if ( m_rowBottoms[row] < top ) continue;
+            if ( GetRowBottom(row) < top )
+                continue;

 
 

-            rowTop = m_rowBottoms[row] - m_rowHeights[row];
-            if ( rowTop > bottom ) break;
+            if ( GetRowTop(row) > bottom )
+                break;

 
             m_rowLabelsExposed.Add( row );
         }
 
             m_rowLabelsExposed.Add( row );
         }


@@ -2218,13 +2629,13 @@ void wxGrid::CalcColLabelsExposed( wxRegion& reg )
         // find the cells within these bounds
         //
         int col;
         // find the cells within these bounds
         //
         int col;

-        int colLeft;

         for ( col = 0;  col < m_numCols;  col++ )
         {
         for ( col = 0;  col < m_numCols;  col++ )
         {

-            if ( m_colRights[col] < left ) continue;
+            if ( GetColRight(col) < left )
+                continue;

 
 

-            colLeft = m_colRights[col] - m_colWidths[col];
-            if ( colLeft > right ) break;
+            if ( GetColLeft(col) > right )
+                break;

 
             m_colLabelsExposed.Add( col );
         }
 
             m_colLabelsExposed.Add( col );
         }


@@ -2270,29 +2681,31 @@ void wxGrid::CalcCellsExposed( wxRegion& reg )
         // find the cells within these bounds
         //
         int row, col;
         // find the cells within these bounds
         //
         int row, col;

-        int colLeft, rowTop;

         for ( row = 0;  row < m_numRows;  row++ )
         {
         for ( row = 0;  row < m_numRows;  row++ )
         {

-            if ( m_rowBottoms[row] < top ) continue;
+            if ( GetRowBottom(row) <= top )
+                continue;

 
 

-            rowTop = m_rowBottoms[row] - m_rowHeights[row];
-            if ( rowTop > bottom ) break;
+            if ( GetRowTop(row) > bottom )
+                break;

 
             m_rowsExposed.Add( row );
 
             for ( col = 0;  col < m_numCols;  col++ )
             {
 
             m_rowsExposed.Add( row );
 
             for ( col = 0;  col < m_numCols;  col++ )
             {

-                if ( m_colRights[col] < left ) continue;
+                if ( GetColRight(col) <= left )
+                    continue;

 
 

-                colLeft = m_colRights[col] - m_colWidths[col];
-                if ( colLeft > right ) break;
+                if ( GetColLeft(col) > right )
+                    break;

 
 

-                if ( m_colsExposed.Index( col ) == wxNOT_FOUND ) m_colsExposed.Add( col );
+                if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
+                    m_colsExposed.Add( col );

                 m_cellsExposed.Add( wxGridCellCoords( row, col ) );
             }
         }
 
                 m_cellsExposed.Add( wxGridCellCoords( row, col ) );
             }
         }
 

-        iter++ ;
+        iter++;

     }
 }
 
     }
 }
 


@@ -2319,6 +2732,7 @@ 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 );

                     dc.SetLogicalFunction(wxINVERT);
                     if ( m_dragLastPos >= 0 )
                     {
                     dc.SetLogicalFunction(wxINVERT);
                     if ( m_dragLastPos >= 0 )
                     {


@@ -2368,7 +2782,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
         {
             row = YToRow(y);
             if ( row >= 0  &&
         {
             row = YToRow(y);
             if ( row >= 0  &&

-                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
+                 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )

             {
                 SelectRow( row, event.ShiftDown() );
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
             {
                 SelectRow( row, event.ShiftDown() );
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);


@@ -2390,7 +2804,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
         if ( YToEdgeOfRow(y) < 0 )
         {
             row = YToRow(y);
         if ( YToEdgeOfRow(y) < 0 )
         {
             row = YToRow(y);

-            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
+            SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );

         }
     }
 
         }
     }
 


@@ -2406,7 +2820,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
             // Note: we are ending the event *after* doing
             // default processing in this case
             //
             // Note: we are ending the event *after* doing
             // default processing in this case
             //

-            SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+            SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );

         }
 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
         }
 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);


@@ -2419,7 +2833,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     else if ( event.RightDown() )
     {
         row = YToRow(y);
     else if ( event.RightDown() )
     {
         row = YToRow(y);

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2431,7 +2845,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     else if ( event.RightDClick() )
     {
         row = YToRow(y);
     else if ( event.RightDClick() )
     {
         row = YToRow(y);

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2481,6 +2895,9 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
 
                     wxClientDC dc( m_gridWin );
                     PrepareDC( dc );
 
                     wxClientDC dc( m_gridWin );
                     PrepareDC( dc );

+
+                    x = wxMax( x, GetColLeft(m_dragRowOrCol) +
+                                  GetColMinimalWidth(m_dragRowOrCol));

                     dc.SetLogicalFunction(wxINVERT);
                     if ( m_dragLastPos >= 0 )
                     {
                     dc.SetLogicalFunction(wxINVERT);
                     if ( m_dragLastPos >= 0 )
                     {


@@ -2530,7 +2947,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         {
             col = XToCol(x);
             if ( col >= 0  &&
         {
             col = XToCol(x);
             if ( col >= 0  &&

-                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
+                 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )

             {
                 SelectCol( col, event.ShiftDown() );
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
             {
                 SelectCol( col, event.ShiftDown() );
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);


@@ -2552,7 +2969,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         if ( XToEdgeOfCol(x) < 0 )
         {
             col = XToCol(x);
         if ( XToEdgeOfCol(x) < 0 )
         {
             col = XToCol(x);

-            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
+            SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );

         }
     }
 
         }
     }
 


@@ -2568,7 +2985,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
             // Note: we are ending the event *after* doing
             // default processing in this case
             //
             // Note: we are ending the event *after* doing
             // default processing in this case
             //

-            SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
+            SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );

         }
 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
         }
 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);


@@ -2581,7 +2998,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
     else if ( event.RightDown() )
     {
         col = XToCol(x);
     else if ( event.RightDown() )
     {
         col = XToCol(x);

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2593,7 +3010,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
     else if ( event.RightDClick() )
     {
         col = XToCol(x);
     else if ( event.RightDClick() )
     {
         col = XToCol(x);

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2628,7 +3045,7 @@ void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
         // indicate corner label by having both row and
         // col args == -1
         //
         // indicate corner label by having both row and
         // col args == -1
         //

-        if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )

         {
             SelectAll();
         }
         {
             SelectAll();
         }


@@ -2636,12 +3053,12 @@ void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
 
     else if ( event.LeftDClick() )
     {
 
     else if ( event.LeftDClick() )
     {

-        SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
+        SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );

     }
 
     else if ( event.RightDown() )
     {
     }
 
     else if ( event.RightDown() )
     {

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2649,7 +3066,7 @@ void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
 
     else if ( event.RightDClick() )
     {
 
     else if ( event.RightDClick() )
     {

-        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
+        if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )

         {
             // no default action at the moment
         }
         {
             // no default action at the moment
         }


@@ -2731,6 +3148,21 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
 
     if ( event.Dragging() )
     {
 
     if ( event.Dragging() )
     {

+        //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
+
+        // Don't start doing anything until the mouse has been drug at
+        // least 3 pixels in any direction...
+        if (! m_isDragging)
+        {
+            if (m_startDragPos == wxDefaultPosition)
+            {
+                m_startDragPos = pos;
+                return;
+            }
+            if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
+                return;
+        }
+

         m_isDragging = TRUE;
         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {
         m_isDragging = TRUE;
         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {


@@ -2738,6 +3170,14 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
             // won't interfer with drag-shrinking.
             if ( IsCellEditControlEnabled() )
                 HideCellEditControl();
             // won't interfer with drag-shrinking.
             if ( IsCellEditControlEnabled() )
                 HideCellEditControl();

+
+            // Have we captured the mouse yet?
+            if (! m_winCapture)
+            {
+                m_winCapture = m_gridWin;
+                m_winCapture->CaptureMouse();
+            }
+

             if ( coords != wxGridNoCellCoords )
             {
                 if ( !IsSelection() )
             if ( coords != wxGridNoCellCoords )
             {
                 if ( !IsSelection() )


@@ -2748,6 +3188,13 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 {
                     SelectBlock( m_currentCellCoords, coords );
                 }
                 {
                     SelectBlock( m_currentCellCoords, coords );
                 }

+
+                if (! IsVisible(coords))
+                {
+                    MakeCellVisible(coords);
+                    // TODO: need to introduce a delay or something here.  The
+                    // scrolling is way to fast, at least on MSW.
+                }

             }
         }
         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
             }
         }
         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )


@@ -2758,6 +3205,7 @@ 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 );

             dc.SetLogicalFunction(wxINVERT);
             if ( m_dragLastPos >= 0 )
             {
             dc.SetLogicalFunction(wxINVERT);
             if ( m_dragLastPos >= 0 )
             {


@@ -2774,6 +3222,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
 
             wxClientDC dc( m_gridWin );
             PrepareDC( dc );
 
             wxClientDC dc( m_gridWin );
             PrepareDC( dc );

+            x = wxMax( x, GetColLeft(m_dragRowOrCol) +
+                          GetColMinimalWidth(m_dragRowOrCol) );

             dc.SetLogicalFunction(wxINVERT);
             if ( m_dragLastPos >= 0 )
             {
             dc.SetLogicalFunction(wxINVERT);
             if ( m_dragLastPos >= 0 )
             {


@@ -2787,6 +3237,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
     }
 
     m_isDragging = FALSE;
     }
 
     m_isDragging = FALSE;

+    m_startDragPos = wxDefaultPosition;
+

 
     if ( coords != wxGridNoCellCoords )
     {
 
     if ( coords != wxGridNoCellCoords )
     {


@@ -2806,6 +3258,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         if ( event.LeftDown() )
         {
         //
         if ( event.LeftDown() )
         {

+            DisableCellEditControl();

             if ( event.ShiftDown() )
             {
                 SelectBlock( m_currentCellCoords, coords );
             if ( event.ShiftDown() )
             {
                 SelectBlock( m_currentCellCoords, coords );


@@ -2813,13 +3266,32 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
             else if ( XToEdgeOfCol(x) < 0  &&
                       YToEdgeOfRow(y) < 0 )
             {
             else if ( XToEdgeOfCol(x) < 0  &&
                       YToEdgeOfRow(y) < 0 )
             {

-                if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
+                if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,

                                  coords.GetRow(),
                                  coords.GetCol(),
                                  event ) )
                 {
                     MakeCellVisible( coords );
                                  coords.GetRow(),
                                  coords.GetCol(),
                                  event ) )
                 {
                     MakeCellVisible( coords );

-                    SetCurrentCell( coords );
+
+                    // if this is the second click on this cell then start
+                    // the edit control
+                    if ( m_waitForSlowClick &&
+                         (coords == m_currentCellCoords) &&
+                         CanEnableCellControl())
+                    {
+                        EnableCellEditControl();
+
+                        wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
+                        attr->GetEditor()->StartingClick();
+                        attr->DecRef();
+
+                        m_waitForSlowClick = FALSE;
+                    }
+                    else
+                    {
+                        SetCurrentCell( coords );
+                        m_waitForSlowClick = TRUE;
+                    }

                 }
             }
         }
                 }
             }
         }


@@ -2829,9 +3301,10 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         else if ( event.LeftDClick() )
         {
         //
         else if ( event.LeftDClick() )
         {

+            DisableCellEditControl();

             if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
             {
             if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
             {

-                SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
+                SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,

                            coords.GetRow(),
                            coords.GetCol(),
                            event );
                            coords.GetRow(),
                            coords.GetCol(),
                            event );


@@ -2847,13 +3320,17 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
             {
                 if ( IsSelection() )
                 {
             {
                 if ( IsSelection() )
                 {

-                    SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, event );
+                    if (m_winCapture)
+                    {
+                        m_winCapture->ReleaseMouse();
+                        m_winCapture = NULL;
+                    }
+                    SendEvent( wxEVT_GRID_RANGE_SELECT, -1, -1, event );

                 }
 
                 }
 

-                // Show the edit control, if it has
-                // been hidden for drag-shrinking.
-                if ( IsCellEditControlEnabled() )
-                    ShowCellEditControl();
+                // Show the edit control, if it has been hidden for
+                // drag-shrinking.
+                ShowCellEditControl();

             }
             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
             {
             }
             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
             {


@@ -2863,7 +3340,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 // Note: we are ending the event *after* doing
                 // default processing in this case
                 //
                 // Note: we are ending the event *after* doing
                 // default processing in this case
                 //

-                SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+                SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );

             }
             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
             {
             }
             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
             {


@@ -2873,7 +3350,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 // Note: we are ending the event *after* doing
                 // default processing in this case
                 //
                 // Note: we are ending the event *after* doing
                 // default processing in this case
                 //

-                SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
+                SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );

             }
 
             m_dragLastPos = -1;
             }
 
             m_dragLastPos = -1;


@@ -2884,7 +3361,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         else if ( event.RightDown() )
         {
         //
         else if ( event.RightDown() )
         {

-            if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
+            DisableCellEditControl();
+            if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,

                              coords.GetRow(),
                              coords.GetCol(),
                              event ) )
                              coords.GetRow(),
                              coords.GetCol(),
                              event ) )


@@ -2898,7 +3376,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         else if ( event.RightDClick() )
         {
         //
         else if ( event.RightDClick() )
         {

-            if ( !SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
+            DisableCellEditControl();
+            if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,

                              coords.GetRow(),
                              coords.GetCol(),
                              event ) )
                              coords.GetRow(),
                              coords.GetCol(),
                              event ) )


@@ -2974,7 +3453,7 @@ void wxGrid::DoEndDragResizeRow()
         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
         HideCellEditControl();
 
         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
         HideCellEditControl();
 

-        int rowTop = m_rowBottoms[m_dragRowOrCol] - m_rowHeights[m_dragRowOrCol];
+        int rowTop = GetRowTop(m_dragRowOrCol);

         SetRowSize( m_dragRowOrCol,
                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
 
         SetRowSize( m_dragRowOrCol,
                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
 


@@ -3012,9 +3491,10 @@ void wxGrid::DoEndDragResizeCol()
         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
         HideCellEditControl();
 
         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
         HideCellEditControl();
 

-        int colLeft = m_colRights[m_dragRowOrCol] - m_colWidths[m_dragRowOrCol];
+        int colLeft = GetColLeft(m_dragRowOrCol);

         SetColSize( m_dragRowOrCol,
         SetColSize( m_dragRowOrCol,

-                    wxMax( m_dragLastPos - colLeft, WXGRID_MIN_COL_WIDTH ) );
+                    wxMax( m_dragLastPos - colLeft,
+                           GetColMinimalWidth(m_dragRowOrCol) ) );

 
         if ( !GetBatchCount() )
         {
 
         if ( !GetBatchCount() )
         {


@@ -3091,6 +3571,9 @@ bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
 
     if ( m_table )
     {
 
     if ( m_table )
     {

+        if (IsCellEditControlEnabled())
+            DisableCellEditControl();
+

         bool ok = m_table->InsertRows( pos, numRows );
 
         // the table will have sent the results of the insert row
         bool ok = m_table->InsertRows( pos, numRows );
 
         // the table will have sent the results of the insert row


@@ -3173,24 +3656,23 @@ bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
         return FALSE;
     }
 
         return FALSE;
     }
 

-    if ( m_table && m_table->DeleteRows( pos, numRows ) )
+    if ( m_table )

     {
     {

-        // the table will have sent the results of the delete row
-        // operation to this view object as a grid table message
-        //
-        if ( m_numRows > 0 )
-            SetEditControlValue();
-        else
-            HideCellEditControl();
+        if (IsCellEditControlEnabled())
+            DisableCellEditControl();

 
 

-        ClearSelection();
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
+        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 FALSE;

 }
 
 
 }
 
 


@@ -3206,7 +3688,9 @@ bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( m_table )
     {
 
     if ( m_table )
     {

-        HideCellEditControl();
+        if (IsCellEditControlEnabled())
+            DisableCellEditControl();
+

         bool ok = m_table->InsertCols( pos, numCols );
 
         // the table will have sent the results of the insert col
         bool ok = m_table->InsertCols( pos, numCols );
 
         // the table will have sent the results of the insert col


@@ -3276,28 +3760,26 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {

-        wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
-        return FALSE;
-    }
-
-    if ( m_table && 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
-        //
-        if ( m_numCols > 0 )
-            SetEditControlValue();
-        else
-            HideCellEditControl();
-
-        ClearSelection();
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
-    {
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );

         return FALSE;
     }
         return FALSE;
     }

+
+    if ( m_table )
+    {
+        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 FALSE;

 }
 
 
 }
 
 


@@ -3313,8 +3795,7 @@ bool wxGrid::SendEvent( const wxEventType type,
                         int row, int col,
                         wxMouseEvent& mouseEv )
 {
                         int row, int col,
                         wxMouseEvent& mouseEv )
 {

-    if ( type == EVT_GRID_ROW_SIZE ||
-         type == EVT_GRID_COL_SIZE )
+    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )

     {
         int rowOrCol = (row == -1 ? col : row);
 
     {
         int rowOrCol = (row == -1 ? col : row);
 


@@ -3330,7 +3811,7 @@ bool wxGrid::SendEvent( const wxEventType type,
 
         return GetEventHandler()->ProcessEvent(gridEvt);
     }
 
         return GetEventHandler()->ProcessEvent(gridEvt);
     }

-    else if ( type == EVT_GRID_RANGE_SELECT )
+    else if ( type == wxEVT_GRID_RANGE_SELECT )

     {
         wxGridRangeSelectEvent gridEvt( GetId(),
                                         type,
     {
         wxGridRangeSelectEvent gridEvt( GetId(),
                                         type,


@@ -3367,8 +3848,7 @@ bool wxGrid::SendEvent( const wxEventType type,
 bool wxGrid::SendEvent( const wxEventType type,
                         int row, int col )
 {
 bool wxGrid::SendEvent( const wxEventType type,
                         int row, int col )
 {

-    if ( type == EVT_GRID_ROW_SIZE ||
-         type == EVT_GRID_COL_SIZE )
+    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )

     {
         int rowOrCol = (row == -1 ? col : row);
 
     {
         int rowOrCol = (row == -1 ? col : row);
 


@@ -3424,7 +3904,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
     {
         // shouldn't be here - we are going round in circles...
         //
     {
         // shouldn't be here - we are going round in circles...
         //

-        wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while alread active") );
+        wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );

     }
 
     m_inOnKeyDown = TRUE;
     }
 
     m_inOnKeyDown = TRUE;


@@ -3437,6 +3917,12 @@ 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() )


@@ -3485,17 +3971,6 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 }
                 break;
 
                 }
                 break;
 

-            case WXK_SPACE:
-                if ( !IsEditable() )
-                {
-                    MoveCursorRight();
-                }
-                else
-                {
-                    event.Skip();
-                }
-                break;
-

             case WXK_RETURN:
                 if ( event.ControlDown() )
                 {
             case WXK_RETURN:
                 if ( event.ControlDown() )
                 {


@@ -3507,6 +3982,13 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 }
                 break;
 
                 }
                 break;
 

+            case WXK_TAB:
+                if (event.ShiftDown())
+                    MoveCursorLeft();
+                else
+                    MoveCursorRight();
+                break;
+

             case WXK_HOME:
                 if ( event.ControlDown() )
                 {
             case WXK_HOME:
                 if ( event.ControlDown() )
                 {


@@ -3539,13 +4021,36 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 MovePageDown();
                 break;
 
                 MovePageDown();
                 break;
 

+            // We don't want these keys to trigger the edit control, any others?
+            case WXK_SHIFT:
+            case WXK_ALT:
+            case WXK_CONTROL:
+            case WXK_CAPITAL:
+                event.Skip();
+                break;
+
+            case WXK_SPACE:
+                if ( !IsEditable() )
+                {
+                    MoveCursorRight();
+                    break;
+                }
+                // Otherwise fall through to default
+

             default:
                 // now try the cell edit control
                 //
             default:
                 // now try the cell edit control
                 //

-                if ( IsCellEditControlEnabled() )
+                if ( !IsCellEditControlEnabled() && CanEnableCellControl() )

                 {
                 {

-                    event.SetEventObject( m_cellEditCtrl );
-                    m_cellEditCtrl->GetEventHandler()->ProcessEvent( event );
+                    EnableCellEditControl();
+                    wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
+                    attr->GetEditor()->StartingKey(event);
+                    attr->DecRef();
+                }
+                else
+                {
+                    // let others process char events for readonly cells
+                    event.Skip();

                 }
                 break;
         }
                 }
                 break;
         }


@@ -3554,12 +4059,14 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
     m_inOnKeyDown = FALSE;
 }
 
     m_inOnKeyDown = FALSE;
 }
 

+

 void wxGrid::OnEraseBackground(wxEraseEvent&)
 void wxGrid::OnEraseBackground(wxEraseEvent&)

-{ }
+{
+}

 
 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
 {
 
 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
 {

-    if ( SendEvent( EVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
+    if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )

     {
         // the event has been intercepted - do nothing
         return;
     {
         // the event has been intercepted - do nothing
         return;


@@ -3570,6 +4077,15 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
     {
         HideCellEditControl();
         SaveEditControlValue();
     {
         HideCellEditControl();
         SaveEditControlValue();

+        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;
     }
 
     m_currentCellCoords = coords;


@@ -3578,7 +4094,12 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
 
     if ( m_displayed )
     {
 
     if ( m_displayed )
     {

-        ShowCellEditControl();
+        wxClientDC dc(m_gridWin);
+        PrepareDC(dc);
+
+        wxGridCellAttr* attr = GetCellAttr(coords);
+        DrawCellHighlight(dc, attr);
+        attr->DecRef();

 
         if ( IsSelection() )
         {
 
         if ( IsSelection() )
         {


@@ -3653,7 +4174,7 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
     int row = coords.GetRow();
     int col = coords.GetCol();
 
     int row = coords.GetRow();
     int col = coords.GetCol();
 

-    if ( m_colWidths[col] <= 0 || m_rowHeights[row] <= 0 )
+    if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )

         return;
 
     // we draw the cell border ourselves
         return;
 
     // we draw the cell border ourselves


@@ -3662,39 +4183,112 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
         DrawCellBorder( dc, coords );
 #endif
 
         DrawCellBorder( dc, coords );
 #endif
 

-    // but all the rest is drawn by the cell renderer and hence may be
-    // customized
+    wxGridCellAttr* attr = GetCellAttr(row, col);
+
+    bool isCurrent = coords == m_currentCellCoords;
+

     wxRect rect;
     wxRect rect;

-    rect.x = m_colRights[col] - m_colWidths[col] + 1;
-    rect.y = m_rowBottoms[row] - m_rowHeights[row] + 1;
-    rect.width = m_colWidths[col] - 1;
-    rect.height = m_rowHeights[row] - 1;
+    rect.x = GetColLeft(col);
+    rect.y = GetRowTop(row);
+    rect.width = GetColWidth(col) - 1;
+    rect.height = GetRowHeight(row) - 1;
+
+    // if the editor is shown, we should use it and not the renderer
+    if ( isCurrent && IsCellEditControlEnabled() )
+    {
+        attr->GetEditor()->PaintBackground(rect, attr);
+    }
+    else
+    {
+        // but all the rest is drawn by the cell renderer and hence may be
+        // customized
+        attr->GetRenderer()->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
+    }

 
 

-    wxGridCellAttr* attr = GetCellAttr(row, col);
-    attr->GetRenderer()->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));

     attr->DecRef();
 }
 
     attr->DecRef();
 }
 

-void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
+void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )

 {
 {

-    if ( m_colWidths[coords.GetCol()] <=0  ||
-         m_rowHeights[coords.GetRow()] <= 0 ) return;
+    int row = m_currentCellCoords.GetRow();
+    int col = m_currentCellCoords.GetCol();

 
 

-    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+    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;
+
+    // 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.SetBrush(*wxTRANSPARENT_BRUSH);
+
+    dc.DrawRectangle(rect);
+
+#if 0
+        // VZ: my experiments with 3d borders...
+
+        // how to properly set colours for arbitrary bg?
+        wxCoord x1 = rect.x,
+                y1 = rect.y,
+                x2 = rect.x + rect.width -1,
+                y2 = rect.y + rect.height -1;
+
+        dc.SetPen(*wxWHITE_PEN);
+        dc.DrawLine(x1, y1, x2, y1);
+        dc.DrawLine(x1, y1, x1, y2);
+
+        dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
+        dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
+
+        dc.SetPen(*wxBLACK_PEN);
+        dc.DrawLine(x1, y2, x2, y2);
+        dc.DrawLine(x2, y1, x2, y2+1);
+#endif // 0
+}
+
+void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
+{

     int row = coords.GetRow();
     int col = coords.GetCol();
     int row = coords.GetRow();
     int col = coords.GetCol();

+    if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+        return;
+
+    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );

 
     // right hand border
     //
 
     // right hand border
     //

-    dc.DrawLine( m_colRights[col], m_rowBottoms[row] - m_rowHeights[row],
-                 m_colRights[col], m_rowBottoms[row] );
+    dc.DrawLine( GetColRight(col), GetRowTop(row),
+                 GetColRight(col), GetRowBottom(row) );

 
     // bottom border
     //
 
     // bottom border
     //

-    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row],
-                 m_colRights[col], m_rowBottoms[row] );
+    dc.DrawLine( GetColLeft(col), GetRowBottom(row),
+                 GetColRight(col), GetRowBottom(row) );

 }
 
 }
 

+void wxGrid::DrawHighlight(wxDC& dc)
+{
+    // if the active cell was repainted, repaint its highlight too because it
+    // might have been damaged by the grid lines
+    size_t count = m_cellsExposed.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        if ( m_cellsExposed[n] == m_currentCellCoords )
+        {
+            wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
+            DrawCellHighlight(dc, attr);
+            attr->DecRef();
+
+            break;
+        }
+    }
+}

 
 // TODO: remove this ???
 // This is used to redraw all grid lines e.g. when the grid line colour
 
 // TODO: remove this ???
 // This is used to redraw all grid lines e.g. when the grid line colour


@@ -3708,7 +4302,8 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
 
     int top, bottom, left, right;
 
 
     int top, bottom, left, right;
 

-    if (reg.IsEmpty()){
+    if (reg.IsEmpty())
+    {

       int cw, ch;
       m_gridWin->GetClientSize(&cw, &ch);
 
       int cw, ch;
       m_gridWin->GetClientSize(&cw, &ch);
 


@@ -3717,7 +4312,8 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
       CalcUnscrolledPosition( 0, 0, &left, &top );
       CalcUnscrolledPosition( cw, ch, &right, &bottom );
     }
       CalcUnscrolledPosition( 0, 0, &left, &top );
       CalcUnscrolledPosition( cw, ch, &right, &bottom );
     }

-    else{
+    else
+    {

       wxCoord x, y, w, h;
       reg.GetBox(x, y, w, h);
       CalcUnscrolledPosition( x, y, &left, &top );
       wxCoord x, y, w, h;
       reg.GetBox(x, y, w, h);
       CalcUnscrolledPosition( x, y, &left, &top );


@@ -3726,8 +4322,8 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
 
     // avoid drawing grid lines past the last row and col
     //
 
     // avoid drawing grid lines past the last row and col
     //

-    right = wxMin( right, m_colRights[m_numCols-1] );
-    bottom = wxMin( bottom, m_rowBottoms[m_numRows-1] );
+    right = wxMin( right, GetColRight(m_numCols - 1) );
+    bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );

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


@@ -3736,13 +4332,16 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
     int i;
     for ( i = 0; i < m_numRows; i++ )
     {
     int i;
     for ( i = 0; i < m_numRows; i++ )
     {

-        if ( m_rowBottoms[i] > bottom )
+        int bot = GetRowBottom(i) - 1;
+
+        if ( bot > bottom )

         {
             break;
         }
         {
             break;
         }

-        else if ( m_rowBottoms[i] >= top )
+
+        if ( bot >= top )

         {
         {

-            dc.DrawLine( left, m_rowBottoms[i], right, m_rowBottoms[i] );
+            dc.DrawLine( left, bot, right, bot );

         }
     }
 
         }
     }
 


@@ -3751,13 +4350,15 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
     //
     for ( i = 0; i < m_numCols; i++ )
     {
     //
     for ( i = 0; i < m_numCols; i++ )
     {

-        if ( m_colRights[i] > right )
+        int colRight = GetColRight(i) - 1;
+        if ( colRight > right )

         {
             break;
         }
         {
             break;
         }

-        else if ( m_colRights[i] >= left )
+
+        if ( colRight >= left )

         {
         {

-            dc.DrawLine( m_colRights[i], top, m_colRights[i], bottom );
+            dc.DrawLine( colRight, top, colRight, bottom );

         }
     }
 }
         }
     }
 }


@@ -3779,19 +4380,20 @@ void wxGrid::DrawRowLabels( wxDC& dc )
 
 void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {
 
 void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {

-    if ( m_rowHeights[row] <= 0 ) return;
+    if ( GetRowHeight(row) <= 0 )
+        return;

 
 

-    int rowTop = m_rowBottoms[row] - m_rowHeights[row];
+    int rowTop = GetRowTop(row),
+        rowBottom = GetRowBottom(row) - 1;

 
     dc.SetPen( *wxBLACK_PEN );
     dc.DrawLine( m_rowLabelWidth-1, rowTop,
 
     dc.SetPen( *wxBLACK_PEN );
     dc.DrawLine( m_rowLabelWidth-1, rowTop,

-                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+                 m_rowLabelWidth-1, rowBottom );

 
 

-    dc.DrawLine( 0, m_rowBottoms[row]-1,
-                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+    dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );

 
     dc.SetPen( *wxWHITE_PEN );
 
     dc.SetPen( *wxWHITE_PEN );

-    dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
+    dc.DrawLine( 0, rowTop, 0, rowBottom );

     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
 
     dc.SetBackgroundMode( wxTRANSPARENT );


@@ -3803,9 +4405,9 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
 
     wxRect rect;
     rect.SetX( 2 );
 
     wxRect rect;
     rect.SetX( 2 );

-    rect.SetY( m_rowBottoms[row] - m_rowHeights[row] + 2 );
+    rect.SetY( GetRowTop(row) + 2 );

     rect.SetWidth( m_rowLabelWidth - 4 );
     rect.SetWidth( m_rowLabelWidth - 4 );

-    rect.SetHeight( m_rowHeights[row] - 4 );
+    rect.SetHeight( GetRowHeight(row) - 4 );

     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
 }
 
     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
 }
 


@@ -3826,20 +4428,22 @@ void wxGrid::DrawColLabels( wxDC& dc )
 
 void wxGrid::DrawColLabel( wxDC& dc, int col )
 {
 
 void wxGrid::DrawColLabel( wxDC& dc, int col )
 {

-    if ( m_colWidths[col] <= 0 ) return;
+    if ( GetColWidth(col) <= 0 )
+        return;

 
 

-    int colLeft = m_colRights[col] - m_colWidths[col];
+    int colLeft = GetColLeft(col),
+        colRight = GetColRight(col) - 1;

 
     dc.SetPen( *wxBLACK_PEN );
 
     dc.SetPen( *wxBLACK_PEN );

-    dc.DrawLine( m_colRights[col]-1, 0,
-                 m_colRights[col]-1, m_colLabelHeight-1 );
+    dc.DrawLine( colRight, 0,
+                 colRight, m_colLabelHeight-1 );

 
     dc.DrawLine( colLeft, m_colLabelHeight-1,
 
     dc.DrawLine( colLeft, m_colLabelHeight-1,

-                 m_colRights[col]-1, m_colLabelHeight-1 );
+                 colRight, m_colLabelHeight-1 );

 
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
 
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );

-    dc.DrawLine( colLeft, 0, m_colRights[col]-1, 0 );
+    dc.DrawLine( colLeft, 0, colRight, 0 );

 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );


@@ -3853,9 +4457,9 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
     GetColLabelAlignment( &hAlign, &vAlign );
 
     wxRect rect;
     GetColLabelAlignment( &hAlign, &vAlign );
 
     wxRect rect;

-    rect.SetX( m_colRights[col] - m_colWidths[col] + 2 );
+    rect.SetX( colLeft + 2 );

     rect.SetY( 2 );
     rect.SetY( 2 );

-    rect.SetWidth( m_colWidths[col] - 4 );
+    rect.SetWidth( GetColWidth(col) - 4 );

     rect.SetHeight( m_colLabelHeight - 4 );
     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
 }
     rect.SetHeight( m_colLabelHeight - 4 );
     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
 }


@@ -3990,26 +4594,36 @@ void wxGrid::EnableEditing( bool edit )
     {
         m_editable = edit;
 
     {
         m_editable = edit;
 

-        // TODO: extend this for other edit control types
-        //
-        if ( m_editCtrlType == wxGRID_TEXTCTRL )
-        {
-            ((wxTextCtrl *)m_cellEditCtrl)->SetEditable( m_editable );
-        }
+        // 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);

     }
 }
 
 
     }
 }
 
 

-#if 0  // disabled for the moment - the cell control is always active

 void wxGrid::EnableCellEditControl( bool enable )
 {
 void wxGrid::EnableCellEditControl( bool enable )
 {

-    if ( m_cellEditCtrl &&
-         enable != m_cellEditCtrlEnabled )
+    if (! m_editable)
+        return;
+
+    if ( m_currentCellCoords == wxGridNoCellCoords )
+        SetCurrentCell( 0, 0 );
+
+    if ( enable != m_cellEditCtrlEnabled )

     {
     {

-        m_cellEditCtrlEnabled = enable;
+        // TODO allow the app to Veto() this event?
+        SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);

 
 

-        if ( m_cellEditCtrlEnabled )
+        if ( enable )

         {
         {

+            // this should be checked by the caller!
+            wxASSERT_MSG( CanEnableCellControl(),
+                          _T("can't enable editing for this cell!") );
+
+            // do it before ShowCellEditControl()
+            m_cellEditCtrlEnabled = enable;
+

             SetEditControlValue();
             ShowCellEditControl();
         }
             SetEditControlValue();
             ShowCellEditControl();
         }


@@ -4017,16 +4631,42 @@ void wxGrid::EnableCellEditControl( bool enable )
         {
             HideCellEditControl();
             SaveEditControlValue();
         {
             HideCellEditControl();
             SaveEditControlValue();

+
+            // do it after HideCellEditControl()
+            m_cellEditCtrlEnabled = enable;

         }
     }
 }
         }
     }
 }

-#endif

 
 

+bool wxGrid::IsCurrentCellReadOnly() const
+{
+    // const_cast
+    wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
+    bool readonly = attr->IsReadOnly();
+    attr->DecRef();
+
+    return readonly;
+}

 
 

-void wxGrid::ShowCellEditControl()
+bool wxGrid::CanEnableCellControl() const

 {
 {

-    wxRect rect;
+    return m_editable && !IsCurrentCellReadOnly();
+}
+
+bool wxGrid::IsCellEditControlEnabled() const
+{
+    // the cell edit control might be disable for all cells or just for the
+    // current one if it's read only
+    return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
+}

 
 

+wxWindow *wxGrid::GetGridWindow() const
+{
+    return m_gridWin;
+}
+
+void wxGrid::ShowCellEditControl()
+{

     if ( IsCellEditControlEnabled() )
     {
         if ( !IsVisible( m_currentCellCoords ) )
     if ( IsCellEditControlEnabled() )
     {
         if ( !IsVisible( m_currentCellCoords ) )


@@ -4035,7 +4675,9 @@ void wxGrid::ShowCellEditControl()
         }
         else
         {
         }
         else
         {

-            rect = CellToRect( m_currentCellCoords );
+            wxRect rect = CellToRect( m_currentCellCoords );
+            int row = m_currentCellCoords.GetRow();
+            int col = m_currentCellCoords.GetCol();

 
             // convert to scrolled coords
             //
 
             // convert to scrolled coords
             //


@@ -4043,16 +4685,21 @@ void wxGrid::ShowCellEditControl()
             CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
             CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
 
             CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
             CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
 

-            int cw, ch;
-            m_gridWin->GetClientSize( &cw, &ch );
+            // cell is shifted by one pixel
+            left--;
+            top--;
+            right--;
+            bottom--;

 
 

-            // Make the edit control large enough to allow for internal margins
-            // TODO: remove this if the text ctrl sizing is improved esp. for unix
+            // Make the edit control large enough to allow for internal
+            // margins
+            //
+            // TODO: remove this if the text ctrl sizing is improved esp. for
+            // unix

             //
             int extra;
 #if defined(__WXMOTIF__)
             //
             int extra;
 #if defined(__WXMOTIF__)

-            if ( m_currentCellCoords.GetRow() == 0  ||
-                 m_currentCellCoords.GetCol() == 0 )
+            if ( row == 0  || col == 0 )

             {
                 extra = 2;
             }
             {
                 extra = 2;
             }


@@ -4061,8 +4708,7 @@ void wxGrid::ShowCellEditControl()
                 extra = 4;
             }
 #else
                 extra = 4;
             }
 #else

-            if ( m_currentCellCoords.GetRow() == 0  ||
-                 m_currentCellCoords.GetCol() == 0 )
+            if ( row == 0  || col == 0 )

             {
                 extra = 1;
             }
             {
                 extra = 1;
             }


@@ -4088,33 +4734,19 @@ void wxGrid::ShowCellEditControl()
             rect.SetBottom( rect.GetBottom() + 2*extra );
 #endif
 
             rect.SetBottom( rect.GetBottom() + 2*extra );
 #endif
 

-            m_cellEditCtrl->SetSize( rect );
-            m_cellEditCtrl->Show( TRUE );
-
-            switch ( m_editCtrlType )
+            wxGridCellAttr* attr = GetCellAttr(row, col);
+            wxGridCellEditor* editor = attr->GetEditor();
+            if ( !editor->IsCreated() )

             {
             {

-                case wxGRID_TEXTCTRL:
-                    ((wxTextCtrl *) m_cellEditCtrl)->SetInsertionPointEnd();
-                    break;
-
-                case wxGRID_CHECKBOX:
-                    // TODO: anything ???
-                    //
-                    break;
-
-                case wxGRID_CHOICE:
-                    // TODO: anything ???
-                    //
-                    break;
-
-                case wxGRID_COMBOBOX:
-                    // TODO: anything ???
-                    //
-                    break;
+                editor->Create(m_gridWin, -1,
+                               new wxGridCellEditorEvtHandler(this, editor));

             }
 
             }
 

-            m_cellEditCtrl->SetFocus();
-        }
+            editor->SetSize( rect );
+            editor->Show( TRUE, attr );
+            editor->BeginEdit(row, col, this);
+            attr->DecRef();
+         }

     }
 }
 
     }
 }
 


@@ -4123,94 +4755,39 @@ void wxGrid::HideCellEditControl()
 {
     if ( IsCellEditControlEnabled() )
     {
 {
     if ( IsCellEditControlEnabled() )
     {

-        m_cellEditCtrl->Show( FALSE );
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+
+        wxGridCellAttr* attr = GetCellAttr(row, col);
+        attr->GetEditor()->Show( FALSE );
+        attr->DecRef();
+        m_gridWin->SetFocus();

     }
 }
 
 
 void wxGrid::SetEditControlValue( const wxString& value )
 {
     }
 }
 
 
 void wxGrid::SetEditControlValue( const wxString& value )
 {

-    if ( m_table )
-    {
-        wxString s;
-        if ( !value )
-            s = GetCellValue(m_currentCellCoords);
-        else
-            s = value;
-
-        if ( IsCellEditControlEnabled() )
-        {
-            switch ( m_editCtrlType )
-            {
-                case wxGRID_TEXTCTRL:
-                    ((wxGridTextCtrl *)m_cellEditCtrl)->SetStartValue(s);
-                    break;
-
-                case wxGRID_CHECKBOX:
-                    // TODO: implement this
-                    //
-                    break;
-
-                case wxGRID_CHOICE:
-                    // TODO: implement this
-                    //
-                    break;
-
-                case wxGRID_COMBOBOX:
-                    // TODO: implement this
-                    //
-                    break;
-            }
-        }
-    }
+    // RD: The new Editors get the value from the table themselves now.  This
+    // method can probably be removed...

 }
 
 
 void wxGrid::SaveEditControlValue()
 {
 }
 
 
 void wxGrid::SaveEditControlValue()
 {

-    if ( m_table )
+    if ( IsCellEditControlEnabled() )

     {
     {

-        wxWindow *ctrl = (wxWindow *)NULL;
-
-        if ( IsCellEditControlEnabled() )
-        {
-            ctrl = m_cellEditCtrl;
-        }
-        else
-        {
-            return;
-        }
-
-        bool valueChanged = FALSE;
-
-        switch ( m_editCtrlType )
-        {
-            case wxGRID_TEXTCTRL:
-                valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
-                                ((wxGridTextCtrl *)ctrl)->GetStartValue());
-                SetCellValue( m_currentCellCoords,
-                              ((wxTextCtrl *) ctrl)->GetValue() );
-                break;
-
-            case wxGRID_CHECKBOX:
-                // TODO: implement this
-                //
-                break;
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();

 
 

-            case wxGRID_CHOICE:
-                // TODO: implement this
-                //
-                break;
+        wxGridCellAttr* attr = GetCellAttr(row, col);
+        bool changed = attr->GetEditor()->EndEdit(row, col, TRUE, this);

 
 

-            case wxGRID_COMBOBOX:
-                // TODO: implement this
-                //
-                break;
-        }
+        attr->DecRef();

 
 

-        if ( valueChanged )
+        if (changed)

         {
         {

-            SendEvent( EVT_GRID_CELL_CHANGE,
+            SendEvent( wxEVT_GRID_CELL_CHANGE,

                        m_currentCellCoords.GetRow(),
                        m_currentCellCoords.GetCol() );
         }
                        m_currentCellCoords.GetRow(),
                        m_currentCellCoords.GetCol() );
         }


@@ -4247,10 +4824,11 @@ int wxGrid::YToRow( int y )
 
     for ( i = 0;  i < m_numRows;  i++ )
     {
 
     for ( i = 0;  i < m_numRows;  i++ )
     {

-        if ( y < m_rowBottoms[i] ) return i;
+        if ( y < GetRowBottom(i) )
+            return i;

     }
 
     }
 

-    return -1;
+    return m_numRows; //-1;

 }
 
 
 }
 
 


@@ -4260,10 +4838,11 @@ int wxGrid::XToCol( int x )
 
     for ( i = 0;  i < m_numCols;  i++ )
     {
 
     for ( i = 0;  i < m_numCols;  i++ )
     {

-        if ( x < m_colRights[i] ) return i;
+        if ( x < GetColRight(i) )
+            return i;

     }
 
     }
 

-    return -1;
+    return m_numCols; //-1;

 }
 
 
 }
 
 


@@ -4276,12 +4855,11 @@ int wxGrid::YToEdgeOfRow( int y )
 
     for ( i = 0;  i < m_numRows;  i++ )
     {
 
     for ( i = 0;  i < m_numRows;  i++ )
     {

-        if ( m_rowHeights[i] > WXGRID_LABEL_EDGE_ZONE )
+        if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )

         {
         {

-            d = abs( y - m_rowBottoms[i] );
-            {
-                if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
-            }
+            d = abs( y - GetRowBottom(i) );
+            if ( d < WXGRID_LABEL_EDGE_ZONE )
+                return i;

         }
     }
 
         }
     }
 


@@ -4298,12 +4876,11 @@ int wxGrid::XToEdgeOfCol( int x )
 
     for ( i = 0;  i < m_numCols;  i++ )
     {
 
     for ( i = 0;  i < m_numCols;  i++ )
     {

-        if ( m_colWidths[i] > WXGRID_LABEL_EDGE_ZONE )
+        if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )

         {
         {

-            d = abs( x - m_colRights[i] );
-            {
-                if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
-            }
+            d = abs( x - GetColRight(i) );
+            if ( d < WXGRID_LABEL_EDGE_ZONE )
+                return i;

         }
     }
 
         }
     }
 


@@ -4318,10 +4895,10 @@ wxRect wxGrid::CellToRect( int row, int col )
     if ( row >= 0  &&  row < m_numRows  &&
          col >= 0  &&  col < m_numCols )
     {
     if ( row >= 0  &&  row < m_numRows  &&
          col >= 0  &&  col < m_numCols )
     {

-        rect.x = m_colRights[col] - m_colWidths[col];
-        rect.y = m_rowBottoms[row] - m_rowHeights[row];
-        rect.width = m_colWidths[col];
-        rect.height = m_rowHeights[ row ];
+        rect.x = GetColLeft(col);
+        rect.y = GetRowTop(row);
+        rect.width = GetColWidth(col);
+        rect.height = GetRowHeight(row);

     }
 
     return rect;
     }
 
     return rect;


@@ -4396,10 +4973,12 @@ void wxGrid::MakeCellVisible( int row, int col )
             ypos = r.GetTop();
             for ( i = row-1;  i >= 0;  i-- )
             {
             ypos = r.GetTop();
             for ( i = row-1;  i >= 0;  i-- )
             {

-                if ( h + m_rowHeights[i] > ch ) break;
+                int rowHeight = GetRowHeight(i);
+                if ( h + rowHeight > ch )
+                    break;

 
 

-                h += m_rowHeights[i];
-                ypos -= m_rowHeights[i];
+                h += rowHeight;
+                ypos -= rowHeight;

             }
 
             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
             }
 
             // we divide it later by GRID_SCROLL_LINE, make sure that we don't


@@ -4418,10 +4997,12 @@ void wxGrid::MakeCellVisible( int row, int col )
             xpos = r.GetLeft();
             for ( i = col-1;  i >= 0;  i-- )
             {
             xpos = r.GetLeft();
             for ( i = col-1;  i >= 0;  i-- )
             {

-                if ( w + m_colWidths[i] > cw ) break;
+                int colWidth = GetColWidth(i);
+                if ( w + colWidth > cw )
+                    break;

 
 

-                w += m_colWidths[i];
-                xpos -= m_colWidths[i];
+                w += colWidth;
+                xpos -= colWidth;

             }
 
             // see comment for ypos above
             }
 
             // see comment for ypos above


@@ -4527,7 +5108,7 @@ bool wxGrid::MovePageUp()
         int cw, ch;
         m_gridWin->GetClientSize( &cw, &ch );
 
         int cw, ch;
         m_gridWin->GetClientSize( &cw, &ch );
 

-        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+        int y = GetRowTop(row);

         int newRow = YToRow( y - ch + 1 );
         if ( newRow == -1 )
         {
         int newRow = YToRow( y - ch + 1 );
         if ( newRow == -1 )
         {


@@ -4557,7 +5138,7 @@ bool wxGrid::MovePageDown()
         int cw, ch;
         m_gridWin->GetClientSize( &cw, &ch );
 
         int cw, ch;
         m_gridWin->GetClientSize( &cw, &ch );
 

-        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+        int y = GetRowTop(row);

         int newRow = YToRow( y + ch );
         if ( newRow == -1 )
         {
         int newRow = YToRow( y + ch );
         if ( newRow == -1 )
         {


@@ -5049,7 +5630,7 @@ int wxGrid::GetRowSize( int row )
 {
     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
 
 {
     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
 

-    return m_rowHeights[row];
+    return GetRowHeight(row);

 }
 
 int wxGrid::GetDefaultColSize()
 }
 
 int wxGrid::GetDefaultColSize()


@@ -5061,7 +5642,7 @@ int wxGrid::GetColSize( int col )
 {
     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
 
 {
     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
 

-    return m_colWidths[col];
+    return GetColWidth(col);

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -5076,6 +5657,9 @@ int wxGrid::GetColSize( int col )
 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
 {
     m_defaultCellAttr->SetBackgroundColour(col);
 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
 {
     m_defaultCellAttr->SetBackgroundColour(col);

+#ifdef __WXGTK__
+    m_gridWin->SetBackgroundColour(col);
+#endif

 }
 
 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
 }
 
 void wxGrid::SetDefaultCellTextColour( const wxColour& col )


@@ -5098,6 +5682,11 @@ void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
     m_defaultCellAttr->SetRenderer(renderer);
 }
 
     m_defaultCellAttr->SetRenderer(renderer);
 }
 

+void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
+{
+    m_defaultCellAttr->SetEditor(editor);
+}
+

 // ----------------------------------------------------------------------------
 // access to the default attrbiutes
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // access to the default attrbiutes
 // ----------------------------------------------------------------------------


@@ -5127,6 +5716,11 @@ wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
     return m_defaultCellAttr->GetRenderer();
 }
 
     return m_defaultCellAttr->GetRenderer();
 }
 

+wxGridCellEditor *wxGrid::GetDefaultEditor() const
+{
+    return m_defaultCellAttr->GetEditor();
+}
+

 // ----------------------------------------------------------------------------
 // access to cell attributes
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // access to cell attributes
 // ----------------------------------------------------------------------------


@@ -5170,6 +5764,22 @@ wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
     return renderer;
 }
 
     return renderer;
 }
 

+wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
+{
+    wxGridCellAttr* attr = GetCellAttr(row, col);
+    wxGridCellEditor* editor = attr->GetEditor();
+    attr->DecRef();
+    return editor;
+}
+
+bool wxGrid::IsReadOnly(int row, int col) const
+{
+    wxGridCellAttr* attr = GetCellAttr(row, col);
+    bool isReadOnly = attr->IsReadOnly();
+    attr->DecRef();
+    return isReadOnly;
+}
+

 // ----------------------------------------------------------------------------
 // attribute support: cache, automatic provider creation, ...
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // attribute support: cache, automatic provider creation, ...
 // ----------------------------------------------------------------------------


@@ -5246,9 +5856,12 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
         attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
         CacheAttr(row, col, attr);
     }
         attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
         CacheAttr(row, col, attr);
     }

-    if (attr) {
+    if (attr)
+    {

         attr->SetDefAttr(m_defaultCellAttr);
         attr->SetDefAttr(m_defaultCellAttr);

-    } else {
+    }
+    else
+    {

         attr = m_defaultCellAttr;
         attr->IncRef();
     }
         attr = m_defaultCellAttr;
         attr->IncRef();
     }


@@ -5360,6 +5973,26 @@ void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
     }
 }
 
     }
 }
 

+void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
+{
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
+        attr->SetEditor(editor);
+        attr->DecRef();
+    }
+}
+
+void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
+{
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
+        attr->SetReadOnly(isReadOnly);
+        attr->DecRef();
+    }
+}
+

 // ----------------------------------------------------------------------------
 // row/col size
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // row/col size
 // ----------------------------------------------------------------------------


@@ -5370,14 +6003,8 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
     if ( resizeExistingRows )
     {
 
     if ( resizeExistingRows )
     {

-        int row;
-        int bottom = 0;
-        for ( row = 0;  row < m_numRows;  row++ )
-        {
-            m_rowHeights[row] = m_defaultRowHeight;
-            bottom += m_defaultRowHeight;
-            m_rowBottoms[row] = bottom;
-        }
+        InitRowHeights();
+

         CalcDimensions();
     }
 }
         CalcDimensions();
     }
 }


@@ -5386,12 +6013,17 @@ void wxGrid::SetRowSize( int row, int height )
 {
     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
 
 {
     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
 

-    int i;
+    if ( m_rowHeights.IsEmpty() )
+    {
+        // need to really create the array
+        InitRowHeights();
+    }

 
     int h = wxMax( 0, height );
     int diff = h - m_rowHeights[row];
 
     m_rowHeights[row] = h;
 
     int h = wxMax( 0, height );
     int diff = h - m_rowHeights[row];
 
     m_rowHeights[row] = h;

+    int i;

     for ( i = row;  i < m_numRows;  i++ )
     {
         m_rowBottoms[i] += diff;
     for ( i = row;  i < m_numRows;  i++ )
     {
         m_rowBottoms[i] += diff;


@@ -5405,14 +6037,8 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
     if ( resizeExistingCols )
     {
 
     if ( resizeExistingCols )
     {

-        int col;
-        int right = 0;
-        for ( col = 0;  col < m_numCols;  col++ )
-        {
-            m_colWidths[col] = m_defaultColWidth;
-            right += m_defaultColWidth;
-            m_colRights[col] = right;
-        }
+        InitColWidths();
+

         CalcDimensions();
     }
 }
         CalcDimensions();
     }
 }


@@ -5421,12 +6047,19 @@ void wxGrid::SetColSize( int col, int width )
 {
     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
 
 {
     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
 

-    int i;
+    // should we check that it's bigger than GetColMinimalWidth(col) here?
+
+    if ( m_colWidths.IsEmpty() )
+    {
+        // need to really create the array
+        InitColWidths();
+    }

 
     int w = wxMax( 0, width );
     int diff = w - m_colWidths[col];
     m_colWidths[col] = w;
 
 
     int w = wxMax( 0, width );
     int diff = w - m_colWidths[col];
     m_colWidths[col] = w;
 

+    int i;

     for ( i = col;  i < m_numCols;  i++ )
     {
         m_colRights[i] += diff;
     for ( i = col;  i < m_numCols;  i++ )
     {
         m_colRights[i] += diff;


@@ -5435,6 +6068,17 @@ void wxGrid::SetColSize( int col, int width )
 }
 
 
 }
 
 

+void wxGrid::SetColMinimalWidth( int col, int width )
+{
+    m_colMinWidths.Put(col, (wxObject *)width);
+}
+
+int wxGrid::GetColMinimalWidth(int col) const
+{
+    wxObject *obj = m_colMinWidths.Get(m_dragRowOrCol);
+    return obj ? (int)obj : WXGRID_MIN_COL_WIDTH;
+}
+

 //
 // ------ cell value accessor functions
 //
 //
 // ------ cell value accessor functions
 //


@@ -5475,7 +6119,12 @@ void wxGrid::SelectRow( int row, bool addToSelected )
     if ( IsSelection() && addToSelected )
     {
         wxRect  rect[4];
     if ( IsSelection() && addToSelected )
     {
         wxRect  rect[4];

-        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        bool    need_refresh[4];
+        need_refresh[0] =
+        need_refresh[1] =
+        need_refresh[2] =
+        need_refresh[3] = FALSE;
+

         int     i;
 
         wxCoord oldLeft   = m_selectedTopLeft.GetCol();
         int     i;
 
         wxCoord oldLeft   = m_selectedTopLeft.GetCol();


@@ -5538,7 +6187,7 @@ void wxGrid::SelectRow( int row, bool addToSelected )
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),

-                                    EVT_GRID_RANGE_SELECT,
+                                    wxEVT_GRID_RANGE_SELECT,

                                     this,
                                     m_selectedTopLeft,
                                     m_selectedBottomRight );
                                     this,
                                     m_selectedTopLeft,
                                     m_selectedBottomRight );


@@ -5552,7 +6201,11 @@ void wxGrid::SelectCol( int col, bool addToSelected )
     if ( IsSelection() && addToSelected )
     {
         wxRect  rect[4];
     if ( IsSelection() && addToSelected )
     {
         wxRect  rect[4];

-        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        bool    need_refresh[4];
+        need_refresh[0] =
+        need_refresh[1] =
+        need_refresh[2] =
+        need_refresh[3] = FALSE;

         int     i;
 
         wxCoord oldLeft   = m_selectedTopLeft.GetCol();
         int     i;
 
         wxCoord oldLeft   = m_selectedTopLeft.GetCol();


@@ -5616,7 +6269,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),

-                                    EVT_GRID_RANGE_SELECT,
+                                    wxEVT_GRID_RANGE_SELECT,

                                     this,
                                     m_selectedTopLeft,
                                     m_selectedBottomRight );
                                     this,
                                     m_selectedTopLeft,
                                     m_selectedBottomRight );


@@ -5654,7 +6307,11 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
         // Either one rectangle is a real subset of the
         // other, or they are (almost) disjoint!
         wxRect  rect[4];
         // Either one rectangle is a real subset of the
         // other, or they are (almost) disjoint!
         wxRect  rect[4];

-        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        bool    need_refresh[4];
+        need_refresh[0] =
+        need_refresh[1] =
+        need_refresh[2] =
+        need_refresh[3] = FALSE;

         int     i;
 
         // Store intermediate values
         int     i;
 
         // Store intermediate values


@@ -5746,7 +6403,7 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
     if ( !m_isDragging )
     {
         wxGridRangeSelectEvent gridEvt( GetId(),
     if ( !m_isDragging )
     {
         wxGridRangeSelectEvent gridEvt( GetId(),

-                                        EVT_GRID_RANGE_SELECT,
+                                        wxEVT_GRID_RANGE_SELECT,

                                         this,
                                         m_selectedTopLeft,
                                         m_selectedBottomRight );
                                         this,
                                         m_selectedTopLeft,
                                         m_selectedBottomRight );