Made HelpGen compile here.

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

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 2f85221fd1638bf40c1b9ffb59ca3075299e1269..af3daea9cfca0ec62c57875182a7e21badf67c16 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -22,7 +22,7 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID) 
+#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)

 #include "gridg.cpp"
 #else
 
 #include "gridg.cpp"
 #else
 


@@ -33,15 +33,247 @@
     #include "wx/log.h"
 #endif
 
     #include "wx/log.h"
 #endif
 

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

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

+// ----------------------------------------------------------------------------
+// array classes instantiation
+// ----------------------------------------------------------------------------
+
+struct wxGridCellWithAttr
+{
+    wxGridCellWithAttr(int row, int col, const wxGridCellAttr *pAttr)
+        : coords(row, col), attr(*pAttr)
+    {
+    }
+
+    wxGridCellCoords coords;
+    wxGridCellAttr   attr;
+};
+
+WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
+
+#include "wx/arrimpl.cpp"
+
+WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
+WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
+{
+public:
+    wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent& event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
+{
+public:
+    wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
+{
+public:
+    wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
+                             const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid *m_owner;
+
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+    void OnPaint( wxPaintEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+class WXDLLEXPORT wxGridWindow : public wxPanel
+{
+public:
+    wxGridWindow()
+    {
+        m_owner = (wxGrid *)NULL;
+        m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
+        m_colLabelWin = (wxGridColLabelWindow *)NULL;
+    }
+
+    wxGridWindow( wxGrid *parent,
+                  wxGridRowLabelWindow *rowLblWin,
+                  wxGridColLabelWindow *colLblWin,
+                  wxWindowID id, const wxPoint &pos, const wxSize &size );
+    ~wxGridWindow();
+
+    void ScrollWindow( int dx, int dy, const wxRect *rect );
+
+private:
+    wxGrid                   *m_owner;
+    wxGridRowLabelWindow     *m_rowLabelWin;
+    wxGridColLabelWindow     *m_colLabelWin;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& );
+
+    DECLARE_DYNAMIC_CLASS(wxGridWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+// the internal data representation used by wxGridCellAttrProvider
+//
+// TODO make it more efficient
+class WXDLLEXPORT wxGridCellAttrProviderData
+{
+public:
+    void SetAttr(const wxGridCellAttr *attr, int row, int col);
+    wxGridCellAttr *GetAttr(int row, int col) const;
+
+private:
+    // searches for the attr for given cell, returns wxNOT_FOUND if not found
+    int FindIndex(int row, int col) const;
+
+    wxGridCellWithAttrArray m_attrs;
+};
+
+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
+#ifndef WXGRID_DRAW_LINES
+#define WXGRID_DRAW_LINES 1
+#endif

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

+// scroll line size
+// TODO: fixed so far - make configurable later (and also different for x/y)
+static const size_t GRID_SCROLL_LINE = 10;
+
+// ----------------------------------------------------------------------------
+// wxGridCellAttrProviderData
+// ----------------------------------------------------------------------------
+
+void wxGridCellAttrProviderData::SetAttr(const wxGridCellAttr *attr,
+                                         int row, int col)
+{
+    int n = FindIndex(row, col);
+    if ( n == wxNOT_FOUND )
+    {
+        // add the attribute
+        m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
+    }
+    else
+    {
+        if ( attr )
+        {
+            // change the attribute
+            m_attrs[(size_t)n].attr = *attr;
+        }
+        else
+        {
+            // remove this attribute
+            m_attrs.RemoveAt((size_t)n);
+        }
+    }
+
+    delete attr;
+}
+
+wxGridCellAttr *wxGridCellAttrProviderData::GetAttr(int row, int col) const
+{
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
+
+    int n = FindIndex(row, col);
+    if ( n != wxNOT_FOUND )
+    {
+        attr = new wxGridCellAttr(m_attrs[(size_t)n].attr);
+    }
+
+    return attr;
+}
+
+int wxGridCellAttrProviderData::FindIndex(int row, int col) const
+{
+    size_t count = m_attrs.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        const wxGridCellCoords& coords = m_attrs[n].coords;
+        if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
+        {
+            return n;
+        }
+    }
+
+    return wxNOT_FOUND;
+}
+
+// ----------------------------------------------------------------------------
+// wxGridCellAttrProvider
+// ----------------------------------------------------------------------------
+
+wxGridCellAttrProvider::wxGridCellAttrProvider()
+{
+    m_data = (wxGridCellAttrProviderData *)NULL;
+}
+
+wxGridCellAttrProvider::~wxGridCellAttrProvider()
+{
+    delete m_data;
+}
+
+void wxGridCellAttrProvider::InitData()
+{
+    m_data = new wxGridCellAttrProviderData;
+}
+
+wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
+{
+    return m_data ? m_data->GetAttr(row, col) : (wxGridCellAttr *)NULL;
+}
+
+void wxGridCellAttrProvider::SetAttr(const wxGridCellAttr *attr,
+                                     int row, int col)
+{
+    if ( !m_data )
+        InitData();

 
 

+    m_data->SetAttr(attr, row, col);
+}

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


@@ -51,67 +283,89 @@ IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
 
 
 wxGridTableBase::wxGridTableBase()
 
 
 wxGridTableBase::wxGridTableBase()

-        : wxObject()

 {
     m_view = (wxGrid *) NULL;
 {
     m_view = (wxGrid *) NULL;

+    m_attrProvider = (wxGridCellAttrProvider *) NULL;

 }
 
 wxGridTableBase::~wxGridTableBase()
 {
 }
 
 wxGridTableBase::~wxGridTableBase()
 {

+    delete m_attrProvider;
+}
+
+void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
+{
+    delete m_attrProvider;
+    m_attrProvider = attrProvider;
+}
+
+wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
+{
+    if ( m_attrProvider )
+        return m_attrProvider->GetAttr(row, col);
+    else
+        return (wxGridCellAttr *)NULL;

 }
 
 }
 

+void wxGridTableBase::SetAttr(const wxGridCellAttr *attr, int row, int col )
+{
+    if ( m_attrProvider )
+    {
+        m_attrProvider->SetAttr(attr, row, col);
+    }
+    else
+    {
+        // as we take ownership of the pointer and don't store it, we must
+        // free it now
+        delete attr;
+    }
+}

 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {

-    wxLogWarning( wxT("Called grid table class function InsertRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
-    
+    wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
+                    "but your derived table class does not override this function") );
+

     return FALSE;
 }
 
 bool wxGridTableBase::AppendRows( size_t numRows )
 {
     return FALSE;
 }
 
 bool wxGridTableBase::AppendRows( size_t numRows )
 {

-    wxLogWarning( wxT("Called grid table class function AppendRows(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numRows );
-    
+    wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
+                    "but your derived table class does not override this function"));
+

     return FALSE;
 }
 
 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
 {
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
 {

-    wxLogWarning( wxT("Called grid table class function DeleteRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
-    
+    wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
+                    "but your derived table class does not override this function"));
+

     return FALSE;
 }
 
 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
 {
     return FALSE;
 }
 
 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
 {

-    wxLogWarning( wxT("Called grid table class function InsertCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
-    
+    wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
+                  "but your derived table class does not override this function"));
+

     return FALSE;
 }
 
 bool wxGridTableBase::AppendCols( size_t numCols )
 {
     return FALSE;
 }
 
 bool wxGridTableBase::AppendCols( size_t numCols )
 {

-    wxLogWarning( wxT("Called grid table class function AppendCols(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numCols );
-    
+    wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
+                   "but your derived table class does not override this function"));
+

     return FALSE;
 }
 
 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
 {
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
 {

-    wxLogWarning( wxT("Called grid table class function DeleteCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
-    
+    wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
+                    "but your derived table class does not override this function"));
+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -134,7 +388,7 @@ wxString wxGridTableBase::GetColLabelValue( int col )
     unsigned int i, n;
     for ( n = 1; ; n++ )
     {
     unsigned int i, n;
     for ( n = 1; ; n++ )
     {

-        s += ('A' + (char)( col%26 ));
+        s += (_T('A') + (wxChar)( col%26 ));

         col = col/26 - 1;
         if ( col < 0 ) break;
     }
         col = col/26 - 1;
         if ( col < 0 ) break;
     }


@@ -182,10 +436,6 @@ wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
 // created by wxGrid if you don't specify an alternative table class.
 //
 
 // created by wxGrid if you don't specify an alternative table class.
 //
 

-
-// this is a magic incantation which must be done!
-#include <wx/arrimpl.cpp>
-

 WX_DEFINE_OBJARRAY(wxGridStringArray)
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
 WX_DEFINE_OBJARRAY(wxGridStringArray)
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )


@@ -199,7 +449,7 @@ wxGridStringTable::wxGridStringTable( int numRows, int numCols )
         : wxGridTableBase()
 {
     int row, col;
         : wxGridTableBase()
 {
     int row, col;

-    
+

     m_data.Alloc( numRows );
 
     wxArrayString sa;
     m_data.Alloc( numRows );
 
     wxArrayString sa;


@@ -208,7 +458,7 @@ wxGridStringTable::wxGridStringTable( int numRows, int numCols )
     {
         sa.Add( wxEmptyString );
     }
     {
         sa.Add( wxEmptyString );
     }

-    
+

     for ( row = 0;  row < numRows;  row++ )
     {
         m_data.Add( sa );
     for ( row = 0;  row < numRows;  row++ )
     {
         m_data.Add( sa );


@@ -258,7 +508,7 @@ void wxGridStringTable::Clear()
 {
     int row, col;
     int numRows, numCols;
 {
     int row, col;
     int numRows, numCols;

-    
+

     numRows = m_data.GetCount();
     if ( numRows > 0 )
     {
     numRows = m_data.GetCount();
     if ( numRows > 0 )
     {


@@ -281,12 +531,12 @@ bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );

-    
+

     if ( pos >= curNumRows )
     {
         return AppendRows( numRows );
     }
     if ( pos >= curNumRows )
     {
         return AppendRows( numRows );
     }

-    
+

     wxArrayString sa;
     sa.Alloc( curNumCols );
     for ( col = 0;  col < curNumCols;  col++ )
     wxArrayString sa;
     sa.Alloc( curNumCols );
     for ( col = 0;  col < curNumCols;  col++ )


@@ -305,7 +555,7 @@ bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
                                 pos,
                                 numRows );
                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
                                 pos,
                                 numRows );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 


@@ -318,7 +568,7 @@ bool wxGridStringTable::AppendRows( size_t numRows )
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );

-    
+

     wxArrayString sa;
     if ( curNumCols > 0 )
     {
     wxArrayString sa;
     if ( curNumCols > 0 )
     {


@@ -328,7 +578,7 @@ bool wxGridStringTable::AppendRows( size_t numRows )
             sa.Add( wxEmptyString );
         }
     }
             sa.Add( wxEmptyString );
         }
     }

-    
+

     for ( row = 0;  row < numRows;  row++ )
     {
         m_data.Add( sa );
     for ( row = 0;  row < numRows;  row++ )
     {
         m_data.Add( sa );


@@ -339,11 +589,11 @@ bool wxGridStringTable::AppendRows( size_t numRows )
         wxGridTableMessage msg( this,
                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
                                 numRows );
         wxGridTableMessage msg( this,
                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
                                 numRows );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 

-    return TRUE;    
+    return TRUE;

 }
 
 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
 }
 
 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )


@@ -351,12 +601,14 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
     size_t n;
 
     size_t curNumRows = m_data.GetCount();
     size_t n;
 
     size_t curNumRows = m_data.GetCount();

-    
+

     if ( pos >= curNumRows )
     {
     if ( pos >= curNumRows )
     {

-        wxLogError( wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d rows"),
-                    pos, numRows, curNumRows );
+        wxString errmsg;
+        errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
+                      "Pos value is invalid for present table with %d rows",
+                      pos, numRows, curNumRows );
+        wxFAIL_MSG( wxT(errmsg) );

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -364,7 +616,7 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
     {
         numRows = curNumRows - pos;
     }
     {
         numRows = curNumRows - pos;
     }

-    
+

     if ( numRows >= curNumRows )
     {
         m_data.Empty();  // don't release memory just yet
     if ( numRows >= curNumRows )
     {
         m_data.Empty();  // don't release memory just yet


@@ -383,11 +635,11 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
                                 pos,
                                 numRows );
                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
                                 pos,
                                 numRows );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 

-    return TRUE;    
+    return TRUE;

 }
 
 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
 }
 
 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )


@@ -396,7 +648,7 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );

-    
+

     if ( pos >= curNumCols )
     {
         return AppendCols( numCols );
     if ( pos >= curNumCols )
     {
         return AppendCols( numCols );


@@ -416,7 +668,7 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
                                 pos,
                                 numCols );
                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
                                 pos,
                                 numCols );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 


@@ -432,11 +684,11 @@ bool wxGridStringTable::AppendCols( size_t numCols )
     {
         // TODO: something better than this ?
         //
     {
         // TODO: something better than this ?
         //

-        wxLogError( wxT("Unable to append cols to a grid table with no rows.\n"
-                    "Call AppendRows() first") );
+        wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
+                        "Call AppendRows() first") );

         return FALSE;
     }
         return FALSE;
     }

-    
+

     for ( row = 0;  row < curNumRows;  row++ )
     {
         for ( n = 0;  n < numCols;  n++ )
     for ( row = 0;  row < curNumRows;  row++ )
     {
         for ( n = 0;  n < numCols;  n++ )


@@ -450,7 +702,7 @@ bool wxGridStringTable::AppendCols( size_t numCols )
         wxGridTableMessage msg( this,
                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
                                 numCols );
         wxGridTableMessage msg( this,
                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
                                 numCols );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 


@@ -463,18 +715,20 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
 
     size_t curNumRows = m_data.GetCount();
     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );

-    
+

     if ( pos >= curNumCols )
     {
     if ( pos >= curNumCols )
     {

-       wxLogError( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
-                   "Pos value is invalid for present table with %d cols"),
-                   pos, numCols, curNumCols );
-       return FALSE;
+        wxString errmsg;
+        errmsg.Printf( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
+                        "Pos value is invalid for present table with %d cols",
+                        pos, numCols, curNumCols );
+        wxFAIL_MSG( wxT( errmsg ) );
+        return FALSE;

     }
 
     if ( numCols > curNumCols - pos )
     {
     }
 
     if ( numCols > curNumCols - pos )
     {

-       numCols = curNumCols - pos;
+        numCols = curNumCols - pos;

     }
 
     for ( row = 0;  row < curNumRows;  row++ )
     }
 
     for ( row = 0;  row < curNumRows;  row++ )


@@ -498,11 +752,11 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
                                 pos,
                                 numCols );
                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
                                 pos,
                                 numCols );

-        
+

         GetView()->ProcessTableMessage( msg );
     }
 
         GetView()->ProcessTableMessage( msg );
     }
 

-    return TRUE;    
+    return TRUE;

 }
 
 wxString wxGridStringTable::GetRowLabelValue( int row )
 }
 
 wxString wxGridStringTable::GetRowLabelValue( int row )


@@ -569,13 +823,14 @@ void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridTextCtrl, wxTextCtrl )
 //////////////////////////////////////////////////////////////////////
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridTextCtrl, wxTextCtrl )

-    
+

 BEGIN_EVENT_TABLE( wxGridTextCtrl, wxTextCtrl )
     EVT_KEY_DOWN( wxGridTextCtrl::OnKeyDown )
 END_EVENT_TABLE()
 
 
 wxGridTextCtrl::wxGridTextCtrl( wxWindow *par,
 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,
                                 bool isCellControl,
                                 wxWindowID id,
                                 const wxString& value,


@@ -584,16 +839,17 @@ wxGridTextCtrl::wxGridTextCtrl( wxWindow *par,
                                 long style )
         : wxTextCtrl( par, id, value, pos, size, style )
 {
                                 long style )
         : wxTextCtrl( par, id, value, pos, size, style )
 {

+    m_grid = grid;

     m_isCellControl = isCellControl;
 }
 
 
     m_isCellControl = isCellControl;
 }
 
 

-void wxGridTextCtrl::OnKeyDown( wxKeyEvent& ev )
+void wxGridTextCtrl::OnKeyDown( wxKeyEvent& event )

 {
 {

-    switch ( ev.KeyCode() )
+    switch ( event.KeyCode() )

     {
         case WXK_ESCAPE:
     {
         case WXK_ESCAPE:

-            ((wxGrid *)GetParent())->SetEditControlValue( startValue );
+            m_grid->SetEditControlValue( startValue );

             SetInsertionPointEnd();
             break;
 
             SetInsertionPointEnd();
             break;
 


@@ -603,20 +859,42 @@ void wxGridTextCtrl::OnKeyDown( wxKeyEvent& ev )
         case WXK_RIGHT:
         case WXK_PRIOR:
         case WXK_NEXT:
         case WXK_RIGHT:
         case WXK_PRIOR:
         case WXK_NEXT:

-        case WXK_RETURN:
+        case WXK_SPACE:

             if ( m_isCellControl )
             {
                 // send the event to the parent grid, skipping the
                 // event if nothing happens
                 //
             if ( m_isCellControl )
             {
                 // send the event to the parent grid, skipping the
                 // event if nothing happens
                 //

-                ev.Skip( !GetParent()->ProcessEvent( ev ) );
+                event.Skip( m_grid->ProcessEvent( event ) );

             }
             else
             {
                 // default text control response within the top edit
                 // control
                 //
             }
             else
             {
                 // default text control response within the top edit
                 // control
                 //

-                ev.Skip();
+                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;
 
             }
             break;
 


@@ -627,388 +905,499 @@ void wxGridTextCtrl::OnKeyDown( wxKeyEvent& ev )
                 // send the event to the parent grid, skipping the
                 // event if nothing happens
                 //
                 // send the event to the parent grid, skipping the
                 // event if nothing happens
                 //

-                ev.Skip( !GetParent()->ProcessEvent( ev ) );
+                event.Skip( m_grid->ProcessEvent( event ) );

             }
             else
             {
                 // default text control response within the top edit
                 // control
                 //
             }
             else
             {
                 // default text control response within the top edit
                 // control
                 //

-                ev.Skip();
+                event.Skip();

             }
             break;
             }
             break;

-            
+

         default:
         default:

-            ev.Skip();
+            event.Skip();

     }
 }
 
 void wxGridTextCtrl::SetStartValue( const wxString& s )
 {
     startValue = s;
     }
 }
 
 void wxGridTextCtrl::SetStartValue( const wxString& s )
 {
     startValue = s;

-    wxTextCtrl::SetValue( s.c_str() );
+    wxTextCtrl::SetValue(s);

 }
 
 
 }
 
 

+

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

-IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxPanel )
+IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )

 
 

-    
-BEGIN_EVENT_TABLE( wxGrid, wxPanel )
-    EVT_PAINT( wxGrid::OnPaint )
-    EVT_SIZE( wxGrid::OnSize )
-    EVT_MOUSE_EVENTS( wxGrid::OnMouse )
-    EVT_KEY_DOWN( wxGrid::OnKeyDown )
-    EVT_TEXT( wxGRID_CELLCTRL, wxGrid::OnText )
-    EVT_TEXT( wxGRID_TOPCTRL, wxGrid::OnText )
-    EVT_COMMAND_SCROLL( wxGRID_HORIZSCROLL, wxGrid::OnGridScroll)
-    EVT_COMMAND_SCROLL( wxGRID_VERTSCROLL, wxGrid::OnGridScroll)
+BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
+    EVT_PAINT( wxGridRowLabelWindow::OnPaint )
+    EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
+    EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )

 END_EVENT_TABLE()
 END_EVENT_TABLE()

-    

 
 

-wxGrid::~wxGrid()
+wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
+                                            wxWindowID id,
+                                            const wxPoint &pos, const wxSize &size )
+  : wxWindow( parent, id, pos, size )

 {
 {

-    delete m_table;
+    m_owner = parent;

 }
 
 }
 

+void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
+{
+    wxPaintDC dc(this);

 
 

-//
-// ----- internal init and update functions
-//
+    // NO - don't do this because it will set both the x and y origin
+    // coords to match the parent scrolled window and we just want to
+    // set the y coord  - MB
+    //
+    // m_owner->PrepareDC( dc );

 
 

-void wxGrid::Create()
-{
-    m_table          = (wxGridTableBase *) NULL;
-    m_topEditCtrl    = (wxWindow *) NULL;
-    m_cellEditCtrl   = (wxWindow *) NULL;
-    m_horizScrollBar = (wxScrollBar *) NULL;
-    m_vertScrollBar  = (wxScrollBar *) NULL;
+    int x, y;
+    m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
+    dc.SetDeviceOrigin( 0, -y );

 
 

-    m_numRows = 0;
-    m_numCols = 0;
-    m_created = FALSE;
+    m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawRowLabels( dc );

 }
 
 }
 

-void wxGrid::Init()
+
+void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )

 {
 {

-    int i;
+    m_owner->ProcessRowLabelMouseEvent( event );
+}

 
 

-    m_left = 0;
-    m_top  = 0;

 
 

-    // TODO: perhaps have a style flag for control panel
-    //
-    m_topEditCtrlEnabled = FALSE;
-    m_topEditCtrl = new wxGridTextCtrl( this,
-                                       FALSE,
-                                       wxGRID_TOPCTRL,
-                                       "",
-                                       wxPoint(10, 10),
-                                       wxSize(WXGRID_DEFAULT_TOPEDIT_WIDTH,
-                                               WXGRID_DEFAULT_TOPEDIT_HEIGHT),
-                                       wxTE_MULTILINE );
-    m_topEditCtrl->Show( FALSE );                                      
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}

 
 

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

 
 

-    if ( m_numCols <= 0 )
-        m_numCols = WXGRID_DEFAULT_NUMBER_COLS;

 
 

-    m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
-    m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
+//////////////////////////////////////////////////////////////////////

 
 

-    // default labels are pale grey with black text
-    //
-    m_labelBackgroundColour = wxColour( 192, 192, 192 );
-    m_labelTextColour       = wxColour(   0,   0,   0 );
+IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )

 
 

-    // TODO: something better than this ?
-    //
-    m_labelFont = this->GetFont();
-    m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
-    
-    m_rowLabelHorizAlign = wxLEFT;
-    m_rowLabelVertAlign  = wxCENTRE;
+BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
+    EVT_PAINT( wxGridColLabelWindow::OnPaint )
+    EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
+    EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
+END_EVENT_TABLE()

 
 

-    m_colLabelHorizAlign = wxCENTRE;
-    m_colLabelVertAlign  = wxTOP;
+wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
+                                            wxWindowID id,
+                                            const wxPoint &pos, const wxSize &size )
+  : wxWindow( parent, id, pos, size )
+{
+    m_owner = parent;
+}

 
 

-    m_defaultRowHeight = WXGRID_DEFAULT_ROW_HEIGHT;
-    m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
+void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
+{
+    wxPaintDC dc(this);

 
 

-    m_rowHeights.Alloc( m_numRows );
-    m_rowBottoms.Alloc( m_numRows );
-    m_sumRowHeights = 0;
-    for ( i = 0;  i < m_numRows;  i++ )
-    {
-        m_rowHeights.Add( m_defaultRowHeight );
-        m_rowBottoms.Add( 0 );  // set by CalcDimensions()
-    }
-    m_sumRowHeights = m_defaultRowHeight * m_numRows;
-        
-    m_colWidths.Alloc( m_numCols );
-    m_colRights.Alloc( m_numRows );
-    m_sumColWidths = 0;
-    for ( i = 0;  i < m_numCols;  i++ )
-    {
-        m_colWidths.Add( m_defaultColWidth );
-        m_colRights.Add( 0 );  // set by CalcDimensions()
-    }
-    m_sumColWidths = m_defaultColWidth * m_numCols;
-        
-    // TODO: improve this ?
+    // NO - don't do this because it will set both the x and y origin
+    // coords to match the parent scrolled window and we just want to
+    // set the x coord  - MB

     //
     //

-    m_defaultCellFont = this->GetFont();
-    
-    m_gridLineColour = wxColour(   0,   0, 255 );
-    m_gridLinesEnabled = TRUE;
-    
-    m_scrollBarWidth = WXGRID_DEFAULT_SCROLLBAR_WIDTH;
-
-    m_horizScrollBar = new wxScrollBar( this,
-                                        wxGRID_HORIZSCROLL,
-                                        wxPoint(0, 0),
-                                        wxSize(10, 10),
-                                        wxHORIZONTAL);
-    
-    m_vertScrollBar = new wxScrollBar( this,
-                                       wxGRID_VERTSCROLL,
-                                       wxPoint(0, 0),
-                                       wxSize(10, 10),
-                                       wxVERTICAL);
-    m_scrollPosX = 0;
-    m_scrollPosY = 0;
-    m_wholeColsVisible = 0;
-    m_wholeRowsVisible = 0;    
-
-    m_firstPaint = TRUE;
-    m_inOnKeyDown = FALSE;
-    m_batchCount = 0;
-    
-    m_cursorMode  = WXGRID_CURSOR_DEFAULT;
-    m_dragLastPos  = -1;
-    m_dragRowOrCol = -1;
-    m_isDragging = FALSE;
+    // m_owner->PrepareDC( dc );

 
 

-    m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
-    m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
+    int x, y;
+    m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
+    dc.SetDeviceOrigin( -x, 0 );

 
 

-    m_currentCellCoords = wxGridNoCellCoords;
-    m_currentCellHighlighted = FALSE;
+    m_owner->CalcColLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawColLabels( dc );
+}

 
 

-    m_selectedTopLeft = wxGridNoCellCoords;
-    m_selectedBottomRight = wxGridNoCellCoords;
-    
-    m_editable = TRUE;  // default for whole grid

 
 

-    // TODO: extend this to other types of controls
-    //
-    m_cellEditCtrl = new wxGridTextCtrl( this,
-                                         TRUE,
-                                         wxGRID_CELLCTRL,
-                                         "",
-                                         wxPoint(1,1),
-                                         wxSize(1,1)
-#ifdef __WXMSW__
-                                         , wxTE_MULTILINE | wxTE_NO_VSCROLL
-#endif
-                                         );
-                                         
-    m_cellEditCtrl->Show( FALSE );                                            
-    m_cellEditCtrlEnabled = TRUE;
-    m_editCtrlType = wxGRID_TEXTCTRL;    
-    
-    // This is here in case OnSize does not get called when the grid is
-    // displayed
-    //
-    CalcDimensions();
+void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
+{
+    m_owner->ProcessColLabelMouseEvent( event );

 }
 
 
 }
 
 

-void wxGrid::CalcDimensions()
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )

 {
 {

-    int i;
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}

 
 

-    if ( IsTopEditControlEnabled() )
-    {
-        int ctrlW, ctrlH;
-        m_topEditCtrl->GetSize( &ctrlW, &ctrlH );
-        
-        m_top = ctrlH + 20;
-    }
-    else
-    {
-        m_top = 0;
-    }

 
 

-    // check to see if either of the scroll bars are required
-    //
-    int cw, ch;
-    GetClientSize(&cw, &ch);

 
 

-    // begin by assuming that we don't need either scroll bar
-    //
-    int vertScrollBarWidth = 0;
-    int horizScrollBarHeight = 0;
+//////////////////////////////////////////////////////////////////////

 
 

-    // Each scroll bar needs to eventually know if the other one is
-    // required in deciding whether or not it is also required - hence
-    // this loop. A bit inelegant but simple and it works.
-    //
-    int check;
-    for ( check = 0;  check < 2;  check++ )
-    {
-        if ( m_top + m_colLabelHeight + m_sumRowHeights + horizScrollBarHeight > ch )
-        {
-            vertScrollBarWidth = m_scrollBarWidth;
-        }
+IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )

 
 

-        if ( m_left + m_rowLabelWidth + m_sumColWidths + vertScrollBarWidth > cw)
-        {
-            horizScrollBarHeight = m_scrollBarWidth;
-        }
-    }
+BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
+    EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
+    EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
+    EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
+END_EVENT_TABLE()

 
 

+wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
+                                                  wxWindowID id,
+                                                  const wxPoint &pos, const wxSize &size )
+  : wxWindow( parent, id, pos, size )
+{
+    m_owner = parent;
+}

 
 

-    // if the window has been resized while scrolled then the scroll
-    // position might need to be adjusted...
-    //
-    bool adjustScrollPos = FALSE;
-    if ( !vertScrollBarWidth )
+void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
+{
+    wxPaintDC dc(this);
+
+    int client_height = 0;
+    int client_width = 0;
+    GetClientSize( &client_width, &client_height );
+
+    dc.SetPen( *wxBLACK_PEN );
+    dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
+    dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
+
+    dc.SetPen( *wxWHITE_PEN );
+    dc.DrawLine( 0, 0, client_width, 0 );
+    dc.DrawLine( 0, 0, 0, client_height );
+}
+
+
+void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
+{
+    m_owner->ProcessCornerLabelMouseEvent( event );
+}
+
+
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
+
+BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
+    EVT_PAINT( wxGridWindow::OnPaint )
+    EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
+    EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
+END_EVENT_TABLE()
+
+wxGridWindow::wxGridWindow( wxGrid *parent,
+                            wxGridRowLabelWindow *rowLblWin,
+                            wxGridColLabelWindow *colLblWin,
+                            wxWindowID id, const wxPoint &pos, const wxSize &size )
+        : wxPanel( parent, id, pos, size, 0, "grid window" )
+{
+    m_owner = parent;
+    m_rowLabelWin = rowLblWin;
+    m_colLabelWin = colLblWin;
+
+    SetBackgroundColour( "WHITE" );
+}
+
+
+wxGridWindow::~wxGridWindow()
+{
+}
+
+
+void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
+{
+    wxPaintDC dc( this );
+    m_owner->PrepareDC( dc );
+    wxRegion reg = GetUpdateRegion();
+    m_owner->CalcCellsExposed( reg );
+    m_owner->DrawGridCellArea( dc );
+#if WXGRID_DRAW_LINES
+    m_owner->DrawAllGridLines( dc, reg );
+#endif
+}
+
+
+void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
+{
+    wxPanel::ScrollWindow( dx, dy, rect );
+    m_rowLabelWin->ScrollWindow( 0, dy, rect );
+    m_colLabelWin->ScrollWindow( dx, 0, rect );
+}
+
+
+void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
+{
+    m_owner->ProcessGridCellMouseEvent( event );
+}
+
+
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridWindow::OnKeyDown( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
+
+BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
+    EVT_PAINT( wxGrid::OnPaint )
+    EVT_SIZE( wxGrid::OnSize )
+    EVT_KEY_DOWN( wxGrid::OnKeyDown )
+END_EVENT_TABLE()
+
+wxGrid::wxGrid( wxWindow *parent,
+                 wxWindowID id,
+                 const wxPoint& pos,
+                 const wxSize& size,
+                 long style,
+                 const wxString& name )
+  : wxScrolledWindow( parent, id, pos, size, style, name )
+{
+    Create();
+}
+
+
+wxGrid::~wxGrid()
+{
+    delete m_table;
+}
+
+
+//
+// ----- internal init and update functions
+//
+
+void wxGrid::Create()
+{
+    m_created = FALSE;    // set to TRUE by CreateGrid
+    m_displayed = FALSE;  // set to TRUE by OnPaint
+
+    m_table        = (wxGridTableBase *) NULL;
+    m_cellEditCtrl = (wxWindow *) NULL;
+
+    m_numRows = 0;
+    m_numCols = 0;
+    m_currentCellCoords = wxGridNoCellCoords;
+
+    m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
+
+    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
+                                                    -1,
+                                                    wxDefaultPosition,
+                                                    wxDefaultSize );
+
+    m_rowLabelWin = new wxGridRowLabelWindow( this,
+                                              -1,
+                                              wxDefaultPosition,
+                                              wxDefaultSize );
+
+    m_colLabelWin = new wxGridColLabelWindow( this,
+                                              -1,
+                                              wxDefaultPosition,
+                                              wxDefaultSize );
+
+    m_gridWin = new wxGridWindow( this,
+                                  m_rowLabelWin,
+                                  m_colLabelWin,
+                                  -1,
+                                  wxDefaultPosition,
+                                  wxDefaultSize );
+
+    SetTargetWindow( m_gridWin );
+}
+
+
+bool wxGrid::CreateGrid( int numRows, int numCols )
+{
+    if ( m_created )

     {
     {

-        if ( m_scrollPosY )
-        {
-            adjustScrollPos = TRUE;
-            m_scrollPosY = 0;
-        }
+        wxFAIL_MSG( wxT("wxGrid::CreateGrid called more than once") );
+        return FALSE;

     }
     }

-    if ( !horizScrollBarHeight )
+    else

     {
     {

-        if ( m_scrollPosX )
-        {
-            adjustScrollPos = TRUE;
-            m_scrollPosX = 0;
-        }
-    }
+        m_numRows = numRows;
+        m_numCols = numCols;

 
 

-    
-    // calculate the coords of row bottom edges and col right edges
-    //
-    int bottom =  m_top + m_colLabelHeight;
-    for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-    {
-        bottom += m_rowHeights[i];
-        m_rowBottoms[i] = bottom;
+        m_table = new wxGridStringTable( m_numRows, m_numCols );
+        m_table->SetView( this );
+        Init();
+        m_created = TRUE;

     }
 
     }
 

-    int right = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-    {
-        right += m_colWidths[i];
-        m_colRights[i] = right;
-    }    
+    return m_created;
+}

 
 

-    
-    // check how many rows and cols are visible
-    //
-    m_wholeRowsVisible = 0;
-    if ( m_numRows > 0 )
-    {
-        for ( i = m_scrollPosY; i < m_numRows; i++ )
-        {
-            // A partial row doesn't count, we still have to scroll to
-            // see the rest of it
-            if ( m_rowBottoms[i] + horizScrollBarHeight > ch ) break;

 
 

-            m_wholeRowsVisible++ ;
-        }
-    }
+void wxGrid::Init()
+{
+    int i;
+
+    if ( m_numRows <= 0 )
+        m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
+
+    if ( m_numCols <= 0 )
+        m_numCols = WXGRID_DEFAULT_NUMBER_COLS;
+
+    m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;

 
 

-    m_wholeColsVisible = 0;
-    if ( m_numCols )
+    if ( m_rowLabelWin )

     {
     {

-        for ( i = m_scrollPosX; i < m_numCols; i++ )
-        {
-            // A partial col doesn't count, we still have to scroll to
-            // see the rest of it
-            if ( m_colRights[i] + vertScrollBarWidth > cw ) break;
-                
-            m_wholeColsVisible++ ;
-        }
+        m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();

     }
     }

-    
-    if ( m_vertScrollBar )
+    else

     {
     {

-        if ( !vertScrollBarWidth )
-        {
-            m_vertScrollBar->Show(FALSE);
-        }
-        else
-        {
-            m_vertScrollBar->Show(TRUE);
-            m_vertScrollBar->SetScrollbar(
-                m_scrollPosY,
-                wxMax(m_wholeRowsVisible, 1),
-                (m_wholeRowsVisible == 0 ? 1 : m_numRows),
-                wxMax(m_wholeRowsVisible, 1) );
-                                       
-            m_vertScrollBar->SetSize( cw - m_scrollBarWidth,
-                                      m_top,
-                                      m_scrollBarWidth,
-                                      ch - m_top - horizScrollBarHeight);
-        }
+        m_labelBackgroundColour = wxColour( _T("WHITE") );

     }
     }

-    
-    if ( m_horizScrollBar )
-    {
-        if ( !horizScrollBarHeight )
-        {
-            m_horizScrollBar->Show(FALSE);
-        }
-        else
-        {
-            m_horizScrollBar->Show(TRUE);

 
 

-            m_horizScrollBar->SetScrollbar(
-                m_scrollPosX,
-                wxMax(m_wholeColsVisible, 1),
-                (m_wholeColsVisible == 0) ? 1 : m_numCols,
-                wxMax(m_wholeColsVisible, 1) );
+    m_labelTextColour = wxColour( _T("BLACK") );

 
 

-            m_horizScrollBar->SetSize( m_left,
-                                       ch - m_scrollBarWidth,
-                                       cw - m_left - vertScrollBarWidth,
-                                       m_scrollBarWidth );
-        }
-    }
+    // TODO: something better than this ?
+    //
+    m_labelFont = this->GetFont();
+    m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
+
+    m_rowLabelHorizAlign = wxLEFT;
+    m_rowLabelVertAlign  = wxCENTRE;
+
+    m_colLabelHorizAlign = wxCENTRE;
+    m_colLabelVertAlign  = wxTOP;
+
+    m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
+    m_defaultRowHeight = m_gridWin->GetCharHeight();
+
+#if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
+    m_defaultRowHeight += 8;
+#else
+    m_defaultRowHeight += 4;
+#endif

 
 

-    m_bottom = m_right = 0;
-    if ( m_numRows > 0 )
+    m_rowHeights.Alloc( m_numRows );
+    m_rowBottoms.Alloc( m_numRows );
+    int rowBottom = 0;
+    for ( i = 0;  i < m_numRows;  i++ )

     {
     {

-        m_bottom = wxMin( m_rowBottoms[m_numRows-1],
-                          ch - horizScrollBarHeight );
+        m_rowHeights.Add( m_defaultRowHeight );
+        rowBottom += m_defaultRowHeight;
+        m_rowBottoms.Add( rowBottom );

     }
     }

-    if ( m_numCols > 0 )
+
+    m_colWidths.Alloc( m_numCols );
+    m_colRights.Alloc( m_numCols );
+    int colRight = 0;
+    for ( i = 0;  i < m_numCols;  i++ )

     {
     {

-        m_right = wxMin( m_colRights[m_numCols-1],
-                         cw - vertScrollBarWidth );
+        m_colWidths.Add( m_defaultColWidth );
+        colRight += m_defaultColWidth;
+        m_colRights.Add( colRight );

     }
 
     }
 

-    // if the scroll position was adjusted (due to a window resize)
-    // ensure that the cell highlight and edit control are displayed
-    // correctly
+    // TODO: improve this by using wxSystemSettings?
+    //
+    m_defaultCellFont = GetFont();
+
+    m_defaultCellHAlign = wxLEFT;
+    m_defaultCellVAlign = wxTOP;
+
+    m_gridLineColour = wxColour( 128, 128, 255 );
+    m_gridLinesEnabled = TRUE;
+
+    m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
+    m_winCapture = (wxWindow *)NULL;
+    m_dragLastPos  = -1;
+    m_dragRowOrCol = -1;
+    m_isDragging = FALSE;
+
+    m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
+    m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
+
+    m_currentCellCoords = wxGridNoCellCoords;
+
+    m_selectedTopLeft = wxGridNoCellCoords;
+    m_selectedBottomRight = wxGridNoCellCoords;
+
+    m_editable = TRUE;  // default for whole grid
+
+    m_inOnKeyDown = FALSE;
+    m_batchCount = 0;
+
+    // TODO: extend this to other types of controls

     //
     //

-    if ( adjustScrollPos ) SelectCell( m_currentCellCoords );
+    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
+                                         );
+
+    m_cellEditCtrl->Show( FALSE );
+    m_cellEditCtrlEnabled = TRUE;
+    m_editCtrlType = wxGRID_TEXTCTRL;
+}
+
+
+void wxGrid::CalcDimensions()
+{
+    int cw, ch;
+    GetClientSize( &cw, &ch );
+
+    if ( m_numRows > 0  &&  m_numCols > 0 )
+    {
+        int right = m_colRights[ m_numCols-1 ] + 50;
+        int bottom = m_rowBottoms[ m_numRows-1 ] + 50;
+
+        // TODO: restore the scroll position that we had before sizing
+        //
+        int x, y;
+        GetViewStart( &x, &y );
+        SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
+                       right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
+                       x, y );
+    }

 }
 
 
 }
 
 

-bool wxGrid::IsOnScreen()
+void wxGrid::CalcWindowSizes()

 {
     int cw, ch;
     GetClientSize( &cw, &ch );
 {
     int cw, ch;
     GetClientSize( &cw, &ch );

-    return ( cw > 10 );
+
+    if ( m_cornerLabelWin->IsShown() )
+        m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
+
+    if ( m_colLabelWin->IsShown() )
+        m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
+
+    if ( m_rowLabelWin->IsShown() )
+        m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
+
+    if ( m_gridWin->IsShown() )
+        m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);

 }
 
 
 }
 
 


@@ -1018,7 +1407,7 @@ bool wxGrid::IsOnScreen()
 bool wxGrid::Redimension( wxGridTableMessage& msg )
 {
     int i;
 bool wxGrid::Redimension( wxGridTableMessage& msg )
 {
     int i;

-    
+

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


@@ -1029,9 +1418,17 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 m_rowHeights.Insert( m_defaultRowHeight, pos );
                 m_rowBottoms.Insert( 0, pos );
             {
                 m_rowHeights.Insert( m_defaultRowHeight, pos );
                 m_rowBottoms.Insert( 0, pos );

-                m_sumRowHeights += m_defaultRowHeight;

             }
             m_numRows += numRows;
             }
             m_numRows += numRows;

+
+            int bottom = 0;
+            if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
+
+            for ( i = pos;  i < m_numRows;  i++ )
+            {
+                bottom += m_rowHeights[i];
+                m_rowBottoms[i] = bottom;
+            }

             CalcDimensions();
         }
         return TRUE;
             CalcDimensions();
         }
         return TRUE;


@@ -1043,9 +1440,19 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 m_rowHeights.Add( m_defaultRowHeight );
                 m_rowBottoms.Add( 0 );
             {
                 m_rowHeights.Add( m_defaultRowHeight );
                 m_rowBottoms.Add( 0 );

-                m_sumRowHeights += m_defaultRowHeight;

             }
             }

+
+            int oldNumRows = m_numRows;

             m_numRows += numRows;
             m_numRows += numRows;

+
+            int bottom = 0;
+            if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
+
+            for ( i = oldNumRows;  i < m_numRows;  i++ )
+            {
+                bottom += m_rowHeights[i];
+                m_rowBottoms[i] = bottom;
+            }

             CalcDimensions();
         }
         return TRUE;
             CalcDimensions();
         }
         return TRUE;


@@ -1056,17 +1463,11 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             int numRows = msg.GetCommandInt2();
             for ( i = 0;  i < numRows;  i++ )
             {
             int numRows = msg.GetCommandInt2();
             for ( i = 0;  i < numRows;  i++ )
             {

-                m_sumRowHeights -= m_rowHeights[ pos ];

                 m_rowHeights.Remove( pos );
                 m_rowBottoms.Remove( pos );
             }
             m_numRows -= numRows;
 
                 m_rowHeights.Remove( pos );
                 m_rowBottoms.Remove( pos );
             }
             m_numRows -= numRows;
 

-            // TODO: improve these adjustments...
-            //
-            if ( m_scrollPosY >= m_numRows )
-                m_scrollPosY = 0;
-

             if ( !m_numRows )
             {
                 m_numCols = 0;
             if ( !m_numRows )
             {
                 m_numCols = 0;


@@ -1074,10 +1475,19 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_colRights.Clear();
                 m_currentCellCoords = wxGridNoCellCoords;
             }
                 m_colRights.Clear();
                 m_currentCellCoords = wxGridNoCellCoords;
             }

-            else if ( m_currentCellCoords.GetRow() >= m_numRows )
+            else

             {
             {

-                m_currentCellCoords.Set( 0, 0 );
+                if ( m_currentCellCoords.GetRow() >= m_numRows )
+                    m_currentCellCoords.Set( 0, 0 );
+
+                int h = 0;
+                for ( i = 0;  i < m_numRows;  i++ )
+                {
+                    h += m_rowHeights[i];
+                    m_rowBottoms[i] = h;
+                }

             }
             }

+

             CalcDimensions();
         }
         return TRUE;
             CalcDimensions();
         }
         return TRUE;


@@ -1090,9 +1500,17 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 m_colWidths.Insert( m_defaultColWidth, pos );
                 m_colRights.Insert( 0, pos );
             {
                 m_colWidths.Insert( m_defaultColWidth, pos );
                 m_colRights.Insert( 0, pos );

-                m_sumColWidths += m_defaultColWidth;

             }
             m_numCols += numCols;
             }
             m_numCols += numCols;

+
+            int right = 0;
+            if ( pos > 0 ) right = m_colRights[pos-1];
+
+            for ( i = pos;  i < m_numCols;  i++ )
+            {
+                right += m_colWidths[i];
+                m_colRights[i] = right;
+            }

             CalcDimensions();
         }
         return TRUE;
             CalcDimensions();
         }
         return TRUE;


@@ -1104,9 +1522,19 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 m_colWidths.Add( m_defaultColWidth );
                 m_colRights.Add( 0 );
             {
                 m_colWidths.Add( m_defaultColWidth );
                 m_colRights.Add( 0 );

-                m_sumColWidths += m_defaultColWidth;

             }
             }

+
+            int oldNumCols = m_numCols;

             m_numCols += numCols;
             m_numCols += numCols;

+
+            int right = 0;
+            if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
+
+            for ( i = oldNumCols;  i < m_numCols;  i++ )
+            {
+                right += m_colWidths[i];
+                m_colRights[i] = right;
+            }

             CalcDimensions();
         }
         return TRUE;
             CalcDimensions();
         }
         return TRUE;


@@ -1117,16 +1545,10 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             int numCols = msg.GetCommandInt2();
             for ( i = 0;  i < numCols;  i++ )
             {
             int numCols = msg.GetCommandInt2();
             for ( i = 0;  i < numCols;  i++ )
             {

-                m_sumColWidths -= m_colWidths[ pos ];

                 m_colWidths.Remove( pos );
                 m_colRights.Remove( pos );
             }
             m_numCols -= numCols;
                 m_colWidths.Remove( pos );
                 m_colRights.Remove( pos );
             }
             m_numCols -= numCols;

-            //
-            // TODO: improve these adjustments...
-            //
-            if ( m_scrollPosX >= m_numCols )
-                m_scrollPosX = 0;

 
             if ( !m_numCols )
             {
 
             if ( !m_numCols )
             {


@@ -1134,12 +1556,20 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_numRows = 0;
                 m_rowHeights.Clear();
                 m_rowBottoms.Clear();
                 m_numRows = 0;
                 m_rowHeights.Clear();
                 m_rowBottoms.Clear();

-#endif                
+#endif

                 m_currentCellCoords = wxGridNoCellCoords;
             }
                 m_currentCellCoords = wxGridNoCellCoords;
             }

-            else if ( m_currentCellCoords.GetCol() >= m_numCols )
+            else

             {
             {

-                m_currentCellCoords.Set( 0, 0 );
+                if ( m_currentCellCoords.GetCol() >= m_numCols )
+                    m_currentCellCoords.Set( 0, 0 );
+
+                int w = 0;
+                for ( i = 0;  i < m_numCols;  i++ )
+                {
+                    w += m_colWidths[i];
+                    m_colRights[i] = w;
+                }

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


@@ -1150,1464 +1580,1489 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
 }
 
 
 }
 
 

-//
-// ----- event handlers
-//
+void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
+{
+    wxRegionIterator iter( reg );
+    wxRect r;

 
 

-// Generate a grid event based on a mouse event and 
-// return the result of ProcessEvent()
-//
-bool wxGrid::SendEvent( const wxEventType type,
-                       int row, int col,
-                       wxMouseEvent& mouseEv )
-{
-    if ( type == EVT_GRID_ROW_SIZE ||
-        type == EVT_GRID_COL_SIZE )
+    m_rowLabelsExposed.Empty();
+
+    int top, bottom;
+    while ( iter )

     {
     {

-       int rowOrCol = (row == -1 ? col : row);
+        r = iter.GetRect();

 
 

-       wxGridSizeEvent gridEvt( GetId(),
-                                type,
-                                this,
-                                rowOrCol,
-                                mouseEv.GetX(), mouseEv.GetY(),
-                                mouseEv.ControlDown(),
-                                mouseEv.ShiftDown(),
-                                mouseEv.AltDown(),
-                                mouseEv.MetaDown() );
+        // TODO: remove this when we can...
+        // There is a bug in wxMotif that gives garbage update
+        // rectangles if you jump-scroll a long way by clicking the
+        // scrollbar with middle button.  This is a work-around
+        //
+#if defined(__WXMOTIF__)
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );
+        if ( r.GetTop() > ch ) r.SetTop( 0 );
+        r.SetBottom( wxMin( r.GetBottom(), ch ) );
+#endif

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
-    }
-    else if ( type == EVT_GRID_RANGE_SELECT )
-    {
-       wxGridRangeSelectEvent gridEvt( GetId(),
-                                       type,
-                                       this,
-                                       m_selectedTopLeft,
-                                       m_selectedBottomRight,
-                                       mouseEv.ControlDown(),
-                                       mouseEv.ShiftDown(),
-                                       mouseEv.AltDown(),
-                                       mouseEv.MetaDown() );
+        // logical bounds of update region
+        //
+        int dummy;
+        CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
+        CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
-    }
-    else
-    {
-       wxGridEvent gridEvt( GetId(),
-                            type,
-                            this,
-                            row, col,
-                            mouseEv.GetX(), mouseEv.GetY(),
-                            mouseEv.ControlDown(),
-                            mouseEv.ShiftDown(),
-                            mouseEv.AltDown(),
-                            mouseEv.MetaDown() );
+        // find the row labels within these bounds
+        //
+        int row;
+        int rowTop;
+        for ( row = 0;  row < m_numRows;  row++ )
+        {
+            if ( m_rowBottoms[row] < top ) continue;
+
+            rowTop = m_rowBottoms[row] - m_rowHeights[row];
+            if ( rowTop > bottom ) break;
+
+            m_rowLabelsExposed.Add( row );
+        }

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
+        iter++ ;

     }
 }
 
 
     }
 }
 
 

-// Generate a grid event of specified type and return the result
-// of ProcessEvent().
-//
-bool wxGrid::SendEvent( const wxEventType type,
-                       int row, int col )
+void wxGrid::CalcColLabelsExposed( wxRegion& reg )

 {
 {

-    if ( type == EVT_GRID_ROW_SIZE ||
-        type == EVT_GRID_COL_SIZE )
-    {
-       int rowOrCol = (row == -1 ? col : row);
+    wxRegionIterator iter( reg );
+    wxRect r;

 
 

-       wxGridSizeEvent gridEvt( GetId(),
-                                type,
-                                this,
-                                rowOrCol );
+    m_colLabelsExposed.Empty();

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
-    }
-    else
+    int left, right;
+    while ( iter )

     {
     {

-       wxGridEvent gridEvt( GetId(),
-                            type,
-                            this,
-                            row, col );
+        r = iter.GetRect();
+
+        // TODO: remove this when we can...
+        // There is a bug in wxMotif that gives garbage update
+        // rectangles if you jump-scroll a long way by clicking the
+        // scrollbar with middle button.  This is a work-around
+        //
+#if defined(__WXMOTIF__)
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );
+        if ( r.GetLeft() > cw ) r.SetLeft( 0 );
+        r.SetRight( wxMin( r.GetRight(), cw ) );
+#endif
+
+        // logical bounds of update region
+        //
+        int dummy;
+        CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
+        CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
+
+        // find the cells within these bounds
+        //
+        int col;
+        int colLeft;
+        for ( col = 0;  col < m_numCols;  col++ )
+        {
+            if ( m_colRights[col] < left ) continue;

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
+            colLeft = m_colRights[col] - m_colWidths[col];
+            if ( colLeft > right ) break;
+
+            m_colLabelsExposed.Add( col );
+        }
+
+        iter++ ;

     }
 }
 
 
     }
 }
 
 

-void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(ev) )
+void wxGrid::CalcCellsExposed( wxRegion& reg )

 {
 {

-    wxPaintDC dc( this );
+    wxRegionIterator iter( reg );
+    wxRect r;

 
 

-    if ( !m_batchCount )
+    m_cellsExposed.Empty();
+    m_rowsExposed.Empty();
+    m_colsExposed.Empty();
+
+    int left, top, right, bottom;
+    while ( iter )

     {
     {

-        // define a clipping region to avoid painting over the scroll bars
+        r = iter.GetRect();
+
+        // TODO: remove this when we can...
+        // There is a bug in wxMotif that gives garbage update
+        // rectangles if you jump-scroll a long way by clicking the
+        // scrollbar with middle button.  This is a work-around

         //
         //

-        int vs = 0;
-        if ( m_vertScrollBar && m_vertScrollBar->IsShown() )
-            vs = m_scrollBarWidth;
+#if defined(__WXMOTIF__)
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );
+        if ( r.GetTop() > ch ) r.SetTop( 0 );
+        if ( r.GetLeft() > cw ) r.SetLeft( 0 );
+        r.SetRight( wxMin( r.GetRight(), cw ) );
+        r.SetBottom( wxMin( r.GetBottom(), ch ) );
+#endif

 
 

-        int hs = 0;
-        if ( m_horizScrollBar && m_horizScrollBar->IsShown() )
-            hs = m_scrollBarWidth;
+        // logical bounds of update region
+        //
+        CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
+        CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );

 
 

-        int cw, ch;
-        GetClientSize( &cw, &ch );
-        dc.SetClippingRegion( 0, 0, cw - vs, ch - hs );
-            
-        HideCurrentCellHighlight( dc );
-        
-        DrawLabelAreas( dc );
-        DrawColLabels( dc );
-        DrawRowLabels( dc );
-        DrawCellArea( dc );
-        DrawGridLines( dc );
-        DrawCells( dc );
-
-        // TODO: something more elegant than this...
+        // find the cells within these bounds

         //
         //

-        if ( m_firstPaint )
+        int row, col;
+        int colLeft, rowTop;
+        for ( row = 0;  row < m_numRows;  row++ )

         {
         {

-            if ( m_currentCellCoords == wxGridNoCellCoords )
-                m_currentCellCoords.Set(0, 0);
-        
-            SetEditControlValue();
-            ShowCellEditControl();
-            m_firstPaint = FALSE;
-        }
+            if ( m_rowBottoms[row] < top ) continue;

 
 

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

 
 

-        dc.DestroyClippingRegion();
-    }
-}
+            m_rowsExposed.Add( row );
+
+            for ( col = 0;  col < m_numCols;  col++ )
+            {
+                if ( m_colRights[col] < left ) continue;

 
 

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

 
 

-void wxGrid::OnSize( wxSizeEvent& WXUNUSED(ev) )
-{
-    if ( m_created ) CalcDimensions();
+                if ( m_colsExposed.Index( col ) == wxNOT_FOUND ) m_colsExposed.Add( col );
+                m_cellsExposed.Add( wxGridCellCoords( row, col ) );
+            }
+        }
+
+        iter++ ;
+    }

 }
 
 
 }
 
 

-void wxGrid::OnMouse( wxMouseEvent& ev )
+void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )

 {
 {

-    int x = ev.GetX();
-    int y = ev.GetY();
-    int row, col;
-    
-    // ------------------------------------------------------------
-    //
-    // Mouse dragging
-    //
-    if ( ev.Dragging() )
+    int x, y, row;
+    wxPoint pos( event.GetPosition() );
+    CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+
+    if ( event.Dragging() )

     {
         m_isDragging = TRUE;
     {
         m_isDragging = TRUE;

-        
-        if ( ev.LeftIsDown() )
+
+        if ( event.LeftIsDown() )

         {
             switch( m_cursorMode )
             {
         {
             switch( m_cursorMode )
             {

-                case WXGRID_CURSOR_SELECT_CELL:
-                {
-                    wxGridCellCoords cellCoords;
-                    XYToCell( x, y, cellCoords );
-                    if ( cellCoords != wxGridNoCellCoords )
-                    {
-                        if ( !IsSelection() )
-                        {
-                           SelectBlock( cellCoords, cellCoords );
-                       }
-                       else 
-                       {
-                            // check for the mouse being outside the cell area
-                            // (we still want to let the user grow the selected block)
-                            //
-                            if ( cellCoords.GetCol() == -1 )
-                            {
-                                if ( x >= m_right )
-                                    cellCoords.SetCol( m_numCols-1 );
-                                else
-                                    cellCoords.SetCol( m_scrollPosX );
-                            }
-                            
-                            if ( cellCoords.GetRow() == -1 )
-                            {
-                                if ( y >= m_bottom )
-                                    cellCoords.SetRow( m_numRows-1 );
-                                else
-                                    cellCoords.SetRow( m_scrollPosY );
-                            }
-                            
-                            if ( !IsInSelection( cellCoords ) )
-                               SelectBlock( m_currentCellCoords, cellCoords );
-                       }
-                    }
-                }
-                break;
-

                 case WXGRID_CURSOR_RESIZE_ROW:
                 {
                 case WXGRID_CURSOR_RESIZE_ROW:
                 {

-                    wxClientDC dc(this);
-                    dc.SetLogicalFunction(wxXOR);
-                    if ( m_dragLastPos >= 0 )
-                    {
-                        dc.DrawLine( m_left, m_dragLastPos,
-                                     m_right, m_dragLastPos );
-                    }
-                    dc.DrawLine( m_left, ev.GetY(),
-                                 m_right, ev.GetY());
-                
-                    m_dragLastPos = ev.GetY();
-                }
-                break;
-                
-                case WXGRID_CURSOR_RESIZE_COL:
-                {
-                    wxClientDC dc(this);
+                    int cw, ch, left, dummy;
+                    m_gridWin->GetClientSize( &cw, &ch );
+                    CalcUnscrolledPosition( 0, 0, &left, &dummy );
+
+                    wxClientDC dc( m_gridWin );
+                    PrepareDC( dc );

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

-                        dc.DrawLine( m_dragLastPos, m_top,
-                                     m_dragLastPos, m_bottom );
+                        dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );

                     }
                     }

-                    dc.DrawLine( ev.GetX(), m_top,
-                                 ev.GetX(), m_bottom );
-                    
-                    m_dragLastPos = ev.GetX();
+                    dc.DrawLine( left, y, left+cw, y );
+                    m_dragLastPos = y;

                 }
                 break;
 
                 case WXGRID_CURSOR_SELECT_ROW:
                 }
                 break;
 
                 case WXGRID_CURSOR_SELECT_ROW:

-                {

                     if ( (row = YToRow( y )) >= 0  &&
                          !IsInSelection( row, 0 ) )
                     {
                         SelectRow( row, TRUE );
                     }
                     if ( (row = YToRow( y )) >= 0  &&
                          !IsInSelection( row, 0 ) )
                     {
                         SelectRow( row, TRUE );
                     }

-                }
-                break;

 
 

-                case WXGRID_CURSOR_SELECT_COL:
-                {
-                    if ( (col = XToCol( x )) >= 0  &&
-                         !IsInSelection( 0, col ) )
-                    {
-                        SelectCol( col, TRUE );
-                    }
-                }
-                break;
+                // default label to suppress warnings about "enumeration value
+                // 'xxx' not handled in switch
+                default:
+                    break;

             }
         }
         return;
     }
 
     m_isDragging = FALSE;
             }
         }
         return;
     }
 
     m_isDragging = FALSE;

-    
-    // ------------------------------------------------------------
-    //
-    // Left mouse button down
+
+
+    // ------------ Entering or leaving the window

     //
     //

-    if ( ev.LeftDown() )
+    if ( event.Entering() || event.Leaving() )

     {
     {

-        row = -1;
-        col = -1;
-        wxGridCellCoords cellCoords;
-        
-        switch( XYToArea( x, y ) )
-        {
-            case WXGRID_ROWLABEL:
-            {
-                // don't send a label click event for a hit on the
-                // edge of the row label - this is probably the user
-                // wanting to resize the row
-                //
-                if ( YToEdgeOfRow(y) < 0 )
-                {
-                    row = YToRow(y);
-                    if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                    {
-                        SelectRow( row, ev.ShiftDown() );
-                        m_cursorMode = WXGRID_CURSOR_SELECT_ROW;
-                    }
-                }
-            }
-            break;
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
+    }

 
 

-            case WXGRID_COLLABEL:
-            {
-                // don't send a label click event for a hit on the
-                // edge of the col label - this is probably the user
-                // wanting to resize the col
-                //
-                if ( XToEdgeOfCol(x) < 0 )
-                {
-                    col = XToCol(x);
-                    if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                    {
-                        SelectCol( col, ev.ShiftDown() );
-                        m_cursorMode = WXGRID_CURSOR_SELECT_COL;
-                    }
-                }
-            }
-            break;

 
 

-            case WXGRID_CORNERLABEL:
+    // ------------ Left button pressed
+    //
+    else if ( event.LeftDown() )
+    {
+        // don't send a label click event for a hit on the
+        // edge of the row label - this is probably the user
+        // wanting to resize the row
+        //
+        if ( YToEdgeOfRow(y) < 0 )
+        {
+            row = YToRow(y);
+            if ( row >= 0  &&
+                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )

             {
             {

-                // leave both row and col as -1
-                //
-                if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                {
-                    SelectAll();
-                }
+                SelectRow( row, event.ShiftDown() );
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);

             }
             }

-            break;
+        }
+        else
+        {
+            // starting to drag-resize a row
+            //
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
+        }
+    }

 
 

-            case WXGRID_CELL:
-            {
-                XYToCell( x, y, cellCoords );
-                if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
-                                 cellCoords.GetRow(),
-                                 cellCoords.GetCol(),
-                                 ev ) )
-                {
-                    MakeCellVisible( cellCoords );
-                    SelectCell( cellCoords );
-                }
-            }
-            break;

 
 

-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+    // ------------ Left double click
+    //
+    else if (event.LeftDClick() )
+    {
+        if ( YToEdgeOfRow(y) < 0 )
+        {
+            row = YToRow(y);
+            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // Left mouse button double click
+
+
+    // ------------ Left button released

     //
     //

-    else if ( ev.LeftDClick() )
+    else if ( event.LeftUp() )

     {
     {

-        row = -1;
-        col = -1;
-        wxGridCellCoords cellCoords;
-        
-        switch( XYToArea( x, y ) )
+        if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )

         {
         {

-            case WXGRID_ROWLABEL:
-            {
-                // don't send a label click event for a hit on the
-                // edge of the row label - this is probably the user
-                // wanting to resize the row
-                //
-                if ( YToEdgeOfRow(y) < 0 )
-                {
-                    row = YToRow(y);
-                    SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
-                }
-            }
-            break;
+            DoEndDragResizeRow();

 
 

-            case WXGRID_COLLABEL:
-            {
-                // don't send a label click event for a hit on the
-                // edge of the col label - this is probably the user
-                // wanting to resize the col
-                //
-                if ( XToEdgeOfCol(x) < 0 )
-                {
-                    col = XToCol(x);
-                    SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
-                }
-            }
-            break;
+            // Note: we are ending the event *after* doing
+            // default processing in this case
+            //
+            SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+        }

 
 

-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
-                //
-                SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );                
-            }
-            break;
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
+        m_dragLastPos = -1;
+    }

 
 

-            case WXGRID_CELL:
-            {
-                XYToCell( x, y, cellCoords );
-                SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
-                                 cellCoords.GetRow(),
-                                 cellCoords.GetCol(),
-                                 ev );
-            }
-            break;

 
 

-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+    // ------------ Right button down
+    //
+    else if ( event.RightDown() )
+    {
+        row = YToRow(y);
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
+        {
+            // no default action at the moment

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // Left mouse button released
-    //
-    else if ( ev.LeftUp() )
-    {
-       switch ( m_cursorMode )
-       {
-           case WXGRID_CURSOR_RESIZE_ROW:
-           {
-               if ( m_dragLastPos >= 0 )
-               {
-                   // erase the last line and resize the row
-                   //
-                   wxClientDC dc( this );
-                   dc.SetLogicalFunction( wxINVERT );
-                   dc.DrawLine( m_left, m_dragLastPos,
-                                m_right, m_dragLastPos );
-                   HideCellEditControl();
-                   int top = m_top + m_colLabelHeight;
-                   if ( m_dragRowOrCol > 0 )
-                       top = m_rowBottoms[m_dragRowOrCol-1];
-
-                    m_sumRowHeights -= m_rowHeights[ m_dragRowOrCol ];
-                   m_rowHeights[m_dragRowOrCol] = wxMax( ev.GetY() - top,
-                                                         WXGRID_MIN_ROW_HEIGHT );
-                    m_sumRowHeights += m_rowHeights[ m_dragRowOrCol ];
-                   CalcDimensions();
-                   ShowCellEditControl();
-                   Refresh();
-
-                   // Note: we are ending the event *after* doing
-                   // default processing in this case
-                   //
-                   SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, ev );
-               }
-           }
-           break;
-
-           case WXGRID_CURSOR_RESIZE_COL:
-           {
-               if ( m_dragLastPos >= 0 )
-               {
-                   // erase the last line and resize the col
-                   //
-                   wxClientDC dc( this );
-                   dc.SetLogicalFunction( wxINVERT );
-                   dc.DrawLine( m_left, m_dragLastPos,
-                                m_right, m_dragLastPos );
-                   HideCellEditControl();
-                   int left = m_left + m_rowLabelWidth;
-                   if ( m_dragRowOrCol > 0 )
-                       left = m_colRights[m_dragRowOrCol-1];
-
-                    m_sumColWidths -= m_colWidths[m_dragRowOrCol];
-                   m_colWidths[m_dragRowOrCol] = wxMax( ev.GetX() - left,
-                                                        WXGRID_MIN_COL_WIDTH );
-                    m_sumColWidths += m_colWidths[m_dragRowOrCol];
-
-                   CalcDimensions();
-                   ShowCellEditControl();
-                   Refresh();
-
-                   // Note: we are ending the event *after* doing
-                   // default processing in this case
-                   //
-                   SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, ev );
-               }
-           }
-           break;
-
-           case WXGRID_CURSOR_SELECT_CELL:
-           {
-               if ( IsSelection() )
-               {
-                   // Note: we are ending the event *after* doing
-                   // default processing in this case
-                   //
-                   SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, ev );
-               }
-           }
-           break;
-       }
-
-       m_dragLastPos  = -1;
-    }
-    // ------------------------------------------------------------
-    //
-    // Right mouse button down
-    //
-    else if ( ev.RightDown() )
-    {
-       row = -1;
-       col = -1;
-       wxGridCellCoords cellCoords;
-
-       switch( XYToArea( x, y ) )
-       {
-            
-           case WXGRID_ROWLABEL:
-           {
-               row = YToRow(y);
-               if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
-               {
-                    // TODO: default processing ?
-                }
-            }
-            break;
-
-            case WXGRID_COLLABEL:
-            {
-                col = XToCol(x);
-               if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
-                {
-                    // TODO: default processing ?
-                }
-            }
-            break;
-
-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
-                //
-                if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
-                {
-                    // TODO: default processing ?
-                }
-            }
-            break;

 
 

-            case WXGRID_CELL:
-            {
-                XYToCell( x, y, cellCoords );
-                if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
-                                cellCoords.GetRow(),
-                                cellCoords.GetCol(),
-                                ev ) )
-                {
-                    // TODO: default processing ?
-                }
-            }
-            break;

 
 

-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+    // ------------ Right double click
+    //
+    else if ( event.RightDClick() )
+    {
+        row = YToRow(y);
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
+        {
+            // no default action at the moment

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // Right mouse button double click
-    //
-    else if ( ev.RightDClick() )
-    {
-       row = -1;
-       col = -1;
-       wxGridCellCoords cellCoords;
-
-       switch( XYToArea( x, y ) )
-       {
-            
-           case WXGRID_ROWLABEL:
-           {
-               row = YToRow(y);
-               SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
-            }
-            break;
-
-            case WXGRID_COLLABEL:
-            {
-                col = XToCol(x);
-               SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
-            }
-            break;

 
 

-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
-                //
-                SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
-            }
-            break;

 
 

-            case WXGRID_CELL:
+    // ------------ No buttons down and mouse moving
+    //
+    else if ( event.Moving() )
+    {
+        m_dragRowOrCol = YToEdgeOfRow( y );
+        if ( m_dragRowOrCol >= 0 )
+        {
+            if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                XYToCell( x, y, cellCoords );
-                SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
-                           cellCoords.GetRow(),
-                           cellCoords.GetCol(),
-                           ev );
+                // don't capture the mouse yet
+                ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);

             }
             }

-            break;
-
-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+        }
+        else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+        {
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // No buttons down and mouse moving
-    //
-    else if ( ev.Moving() )
+}
+
+
+void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
+{
+    int x, y, col;
+    wxPoint pos( event.GetPosition() );
+    CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+
+    if ( event.Dragging() )

     {
     {

-        switch( XYToArea( x, y ) )
+        m_isDragging = TRUE;
+
+        if ( event.LeftIsDown() )

         {
         {

-            case WXGRID_ROWLABEL:
+            switch( m_cursorMode )

             {
             {

-                m_dragRowOrCol = YToEdgeOfRow( y );
-                if ( m_dragRowOrCol >= 0 )
+                case WXGRID_CURSOR_RESIZE_COL:

                 {
                 {

-                    if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+                    int cw, ch, dummy, top;
+                    m_gridWin->GetClientSize( &cw, &ch );
+                    CalcUnscrolledPosition( 0, 0, &dummy, &top );
+
+                    wxClientDC dc( m_gridWin );
+                    PrepareDC( dc );
+                    dc.SetLogicalFunction(wxINVERT);
+                    if ( m_dragLastPos >= 0 )

                     {
                     {

-                        m_cursorMode = WXGRID_CURSOR_RESIZE_ROW;
-                        SetCursor( m_rowResizeCursor );
+                        dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );

                     }
                     }

+                    dc.DrawLine( x, top, x, top+ch );
+                    m_dragLastPos = x;

                 }
                 }

-                else
-                {
-                    if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+                break;
+
+                case WXGRID_CURSOR_SELECT_COL:
+                    if ( (col = XToCol( x )) >= 0  &&
+                         !IsInSelection( 0, col ) )

                     {
                     {

-                        m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                        SetCursor( *wxSTANDARD_CURSOR );
+                        SelectCol( col, TRUE );

                     }
                     }

-                }
+
+                // default label to suppress warnings about "enumeration value
+                // 'xxx' not handled in switch
+                default:
+                    break;

             }
             }

-            break;
+        }
+        return;
+    }

 
 

-            case WXGRID_COLLABEL:
-            {
-                m_dragRowOrCol = XToEdgeOfCol( x );
-                if ( m_dragRowOrCol >= 0 )
-                {
-                    if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
-                    {
-                        m_cursorMode = WXGRID_CURSOR_RESIZE_COL;
-                        SetCursor( m_colResizeCursor );
-                    }
-                }
-                else
-                {
-                    if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-                    {
-                        m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                        SetCursor( *wxSTANDARD_CURSOR );
-                    }
-                }
-            }
-            break;
+    m_isDragging = FALSE;

 
 

-            default:
-            {
-                if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-                {
-                    m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                    SetCursor( *wxSTANDARD_CURSOR );
-                }
-            }
-            break;
-        }        
+
+    // ------------ Entering or leaving the window
+    //
+    if ( event.Entering() || event.Leaving() )
+    {
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);

     }
     }

-}

 
 
 
 

-void wxGrid::OnKeyDown( wxKeyEvent& ev )
-{
-    if ( m_inOnKeyDown )
+    // ------------ Left button pressed
+    //
+    else if ( event.LeftDown() )

     {
     {

-        // shouldn't be here - we are going round in circles...
+        // don't send a label click event for a hit on the
+        // edge of the col label - this is probably the user
+        // wanting to resize the col

         //
         //

-        wxLogFatalError( wxT("wxGrid::OnKeyDown called while alread active") );
+        if ( XToEdgeOfCol(x) < 0 )
+        {
+            col = XToCol(x);
+            if ( col >= 0  &&
+                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
+            {
+                SelectCol( col, event.ShiftDown() );
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
+            }
+        }
+        else
+        {
+            // starting to drag-resize a col
+            //
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
+        }

     }
 
     }
 

-    m_inOnKeyDown = TRUE;
-        
-    // propagate the event up and see if it gets processed
+
+    // ------------ Left double click

     //
     //

-    wxWindow *parent = GetParent();
-    wxKeyEvent keyEvt( ev );
-    keyEvt.SetEventObject( parent );
-    
-    if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
+    if ( event.LeftDClick() )

     {
     {

-        // try local handlers
-        //
-        switch ( ev.KeyCode() )
+        if ( XToEdgeOfCol(x) < 0 )

         {
         {

-            case WXK_UP:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorUpBlock();
-                }
-                else
-                {
-                    MoveCursorUp();
-                }
-                break;
-                
-            case WXK_DOWN:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorDownBlock();
-                }
-                else
-                {
-                    MoveCursorDown();
-                }
-                break;
+            col = XToCol(x);
+            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
+        }
+    }

 
 

-            case WXK_LEFT:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorLeftBlock();
-                }
-                else
-                {
-                    MoveCursorLeft();
-                }
-                break;

 
 

-            case WXK_RIGHT:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorRightBlock();
-                }
-                else
-                {
-                    MoveCursorRight();
-                }
-                break;
+    // ------------ Left button released
+    //
+    else if ( event.LeftUp() )
+    {
+        if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+        {
+            DoEndDragResizeCol();

 
 

-            case WXK_RETURN:
-                MoveCursorDown();
-                break;
+            // Note: we are ending the event *after* doing
+            // default processing in this case
+            //
+            SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
+        }

 
 

-            case WXK_HOME:
-                if ( ev.ControlDown() )
-                {
-                    MakeCellVisible( 0, 0 );
-                    SelectCell( 0, 0 );
-                }
-                else
-                {
-                    ev.Skip();
-                }
-                break;
-                
-            case WXK_END:
-                if ( ev.ControlDown() )
-                {
-                    MakeCellVisible( m_numRows-1, m_numCols-1 );
-                    SelectCell( m_numRows-1, m_numCols-1 );
-                }
-                else
-                {
-                    ev.Skip();
-                }
-                break;
-                
-            case WXK_PRIOR:
-                MovePageUp();
-                break;
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
+        m_dragLastPos  = -1;
+    }

 
 

-            case WXK_NEXT:
-                MovePageDown();
-                break;
-                
-            default:
-                // now try the cell edit control
-                //
-                if ( IsCellEditControlEnabled() )
-                {
-                    ev.SetEventObject( m_cellEditCtrl );
-                    m_cellEditCtrl->GetEventHandler()->ProcessEvent( ev );
-                }
-                break;
+
+    // ------------ Right button down
+    //
+    else if ( event.RightDown() )
+    {
+        col = XToCol(x);
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
+        {
+            // no default action at the moment

         }
     }
 
         }
     }
 

-    m_inOnKeyDown = FALSE;
-}
-

 
 

-// Text updated in an edit control - either a text control or a
-// combo box
-//
-void wxGrid::OnText( wxKeyEvent& ev )
-{
-    if ( !m_inOnText )
+    // ------------ Right double click
+    //
+    else if ( event.RightDClick() )

     {
     {

-        m_inOnText = TRUE;
-        wxWindow *ctrl = (wxWindow *)ev.GetEventObject();
+        col = XToCol(x);
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
+        {
+            // no default action at the moment
+        }
+    }

 
 

-        if ( ctrl == m_cellEditCtrl &&
-             IsTopEditControlEnabled() )
+
+    // ------------ No buttons down and mouse moving
+    //
+    else if ( event.Moving() )
+    {
+        m_dragRowOrCol = XToEdgeOfCol( x );
+        if ( m_dragRowOrCol >= 0 )

         {
         {

-            // set the value of the top edit control
-            //
-            switch ( m_editCtrlType )
+            if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                case wxGRID_TEXTCTRL:
-                    ((wxTextCtrl *)m_topEditCtrl)->
-                        SetValue(((wxTextCtrl *)ctrl)->GetValue());
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    ((wxComboBox *)m_topEditCtrl)->
-                        SetValue(((wxComboBox *)ctrl)->GetValue());
-                    break;
+                // don't capture the cursor yet
+                ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);

             }
         }
             }
         }

-        else if ( ctrl == m_topEditCtrl )
+        else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )

         {
         {

-            if ( IsCellEditControlEnabled() )
-            {
-                switch ( m_editCtrlType )
-                {
-                    case wxGRID_TEXTCTRL:
-                        ((wxTextCtrl *)m_cellEditCtrl)->
-                            SetValue(((wxTextCtrl *)ctrl)->GetValue());
-                        break;
-                    
-                    case wxGRID_COMBOBOX:
-                        ((wxComboBox *)m_cellEditCtrl)->
-                            SetValue(((wxComboBox *)ctrl)->GetValue());
-                        break;
-                }
-            }
-            else
-            {
-                // in the case when in-place editing is turned off we just want to 
-                // echo the text changes in the cell but not yet update the grid table
-                //
-                switch ( m_editCtrlType )
-                {
-                    case wxGRID_TEXTCTRL:
-                        DrawCellValue( m_currentCellCoords, ((wxTextCtrl *)ctrl)->GetValue() );
-                        break;
-                    
-                    case wxGRID_COMBOBOX:
-                        DrawCellValue( m_currentCellCoords, ((wxComboBox *)ctrl)->GetValue() );
-                        break;
-                }
-            }
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);

         }
     }
         }
     }

-
-    m_inOnText = FALSE;

 }
 
 }
 

-void wxGrid::OnGridScroll( wxScrollEvent& ev )
-{
-    // propagate the event up and see if it gets processed
-    //
-    wxWindow *parent = GetParent();
-    wxScrollEvent scrollEvt( ev );
-    if (parent->GetEventHandler()->ProcessEvent( scrollEvt )) return;
-    
-    HideCellEditControl();

 
 

-    if ( ev.GetEventObject() == m_horizScrollBar )
+void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
+{
+    if ( event.LeftDown() )

     {
     {

-        if ( ev.GetPosition() != m_scrollPosX )
+        // indicate corner label by having both row and
+        // col args == -1
+        //
+        if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )

         {
         {

-            SetHorizontalScrollPos( ev.GetPosition() );
+            SelectAll();

         }
     }
         }
     }

-    else
+
+    else if ( event.LeftDClick() )
+    {
+        SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
+    }
+
+    else if ( event.RightDown() )

     {
     {

-        if ( ev.GetPosition() != m_scrollPosY )
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )

         {
         {

-            SetVerticalScrollPos( ev.GetPosition() );
+            // no default action at the moment

         }
     }
 
         }
     }
 

-    ShowCellEditControl();
+    else if ( event.RightDClick() )
+    {
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
+        {
+            // no default action at the moment
+        }
+    }

 }
 
 }
 

-
-void wxGrid::SelectCell( const wxGridCellCoords& coords )
+void wxGrid::ChangeCursorMode(CursorMode mode,
+                              wxWindow *win,
+                              bool captureMouse)

 {
 {

-    if ( SendEvent( EVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
+#ifdef __WXDEBUG__
+    static const wxChar *cursorModes[] =

     {
     {

-        // the event has been intercepted - do nothing
+        _T("SELECT_CELL"),
+        _T("RESIZE_ROW"),
+        _T("RESIZE_COL"),
+        _T("SELECT_ROW"),
+        _T("SELECT_COL")
+    };
+
+    wxLogTrace(_T("grid"),
+               _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
+               win == m_colLabelWin ? _T("colLabelWin")
+                                    : win ? _T("rowLabelWin")
+                                          : _T("gridWin"),
+               cursorModes[m_cursorMode], cursorModes[mode]);
+#endif // __WXDEBUG__
+
+    if ( mode == m_cursorMode )

         return;
         return;

-    }

 
 

-    wxClientDC dc( this );
+    if ( !win )
+    {
+        // by default use the grid itself
+        win = m_gridWin;
+    }

 
 

-    if ( m_currentCellCoords != wxGridNoCellCoords )
+    if ( m_winCapture )

     {
     {

-        HideCurrentCellHighlight( dc );
-        HideCellEditControl();
-        SaveEditControlValue();
+        m_winCapture->ReleaseMouse();
+        m_winCapture = (wxWindow *)NULL;

     }
 
     }
 

-    m_currentCellCoords = coords;
+    m_cursorMode = mode;

 
 

-    SetEditControlValue();
-    if ( IsOnScreen() )
+    switch ( m_cursorMode )

     {
     {

-        ShowCellEditControl();
-        ShowCurrentCellHighlight( dc );
+        case WXGRID_CURSOR_RESIZE_ROW:
+            win->SetCursor( m_rowResizeCursor );
+            break;
+
+        case WXGRID_CURSOR_RESIZE_COL:
+            win->SetCursor( m_colResizeCursor );
+            break;
+
+        default:
+            win->SetCursor( *wxSTANDARD_CURSOR );

     }
 
     }
 

-    if ( IsSelection() )
+    // we need to capture mouse when resizing
+    bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
+                  m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
+
+    if ( captureMouse && resize )

     {
     {

-        ClearSelection();
-        if ( !GetBatchCount() ) Refresh();
+        win->CaptureMouse();
+        m_winCapture = win;

     }
 }
 
     }
 }
 

-
-void wxGrid::ShowCellEditControl()
+void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )

 {
 {

-    wxRect rect;
-    
-    if ( IsCellEditControlEnabled() )         
+    int x, y;
+    wxPoint pos( event.GetPosition() );
+    CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+
+    wxGridCellCoords coords;
+    XYToCell( x, y, coords );
+
+    if ( event.Dragging() )

     {
     {

-        if ( !IsVisible( m_currentCellCoords ) )
+        m_isDragging = TRUE;
+        if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

         {
         {

-            return;
+            // Hide the edit control, so it
+            // won't interfer with drag-shrinking.
+            if ( IsCellEditControlEnabled() )
+                HideCellEditControl();
+            if ( coords != wxGridNoCellCoords )
+            {
+                if ( !IsSelection() )
+                {
+                    SelectBlock( coords, coords );
+                }
+                else
+                {
+                    SelectBlock( m_currentCellCoords, coords );
+                }
+            }

         }
         }

-        else
+        else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )

         {
         {

-            rect = CellToRect( m_currentCellCoords );
-            
-            m_cellEditCtrl->SetSize( rect );
-            m_cellEditCtrl->Show( TRUE );
-
-            switch ( m_editCtrlType )
+            int cw, ch, left, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            CalcUnscrolledPosition( 0, 0, &left, &dummy );
+
+            wxClientDC dc( m_gridWin );
+            PrepareDC( dc );
+            dc.SetLogicalFunction(wxINVERT);
+            if ( m_dragLastPos >= 0 )

             {
             {

-                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;
+                dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );

             }
             }

-
-            m_cellEditCtrl->SetFocus();
+            dc.DrawLine( left, y, left+cw, y );
+            m_dragLastPos = y;
+        }
+        else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+        {
+            int cw, ch, dummy, top;
+            m_gridWin->GetClientSize( &cw, &ch );
+            CalcUnscrolledPosition( 0, 0, &dummy, &top );
+
+            wxClientDC dc( m_gridWin );
+            PrepareDC( dc );
+            dc.SetLogicalFunction(wxINVERT);
+            if ( m_dragLastPos >= 0 )
+            {
+                dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
+            }
+            dc.DrawLine( x, top, x, top+ch );
+            m_dragLastPos = x;

         }
         }

-    }
-}
-

 
 

-void wxGrid::HideCellEditControl()
-{
-    if ( IsCellEditControlEnabled() )
-    {
-        m_cellEditCtrl->Show( FALSE );
+        return;

     }
     }

-}

 
 

-void wxGrid::SetEditControlValue( const wxString& value )
-{
-    if ( m_table )
+    m_isDragging = FALSE;
+
+    if ( coords != wxGridNoCellCoords )

     {
     {

-        wxString s;
-        if ( !value )
-            s = GetCellValue(m_currentCellCoords);
+        // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
+        //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
+        //     wxGTK
+#if 0
+        if ( event.Entering() || event.Leaving() )
+        {
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+            m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
+        }

         else
         else

-            s = value;
+#endif // 0

 
 

-        if ( IsTopEditControlEnabled() )
+        // ------------ Left button pressed
+        //
+        if ( event.LeftDown() )

         {
         {

-            switch ( m_editCtrlType )
+            if ( event.ShiftDown() )

             {
             {

-                case wxGRID_TEXTCTRL:
-                    ((wxGridTextCtrl *)m_topEditCtrl)->SetStartValue(s);
-                    break;
-
-                case wxGRID_CHECKBOX:
-                    // TODO: implement this
-                    //
-                    break;
-
-                case wxGRID_CHOICE:
-                    // TODO: implement this
-                    //
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    // TODO: implement this
-                    //
-                    break;
+                SelectBlock( m_currentCellCoords, coords );
+            }
+            else if ( XToEdgeOfCol(x) < 0  &&
+                      YToEdgeOfRow(y) < 0 )
+            {
+                if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
+                                 coords.GetRow(),
+                                 coords.GetCol(),
+                                 event ) )
+                {
+                    MakeCellVisible( coords );
+                    SetCurrentCell( coords );
+                }

             }
         }
 
             }
         }
 

-        if ( IsCellEditControlEnabled() )
+
+        // ------------ Left double click
+        //
+        else if ( event.LeftDClick() )

         {
         {

-            switch ( m_editCtrlType )
+            if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )

             {
             {

-                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;
+                SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
+                           coords.GetRow(),
+                           coords.GetCol(),
+                           event );

             }
         }
             }
         }

-    }
-}

 
 

-void wxGrid::SaveEditControlValue()
-{
-    if ( m_table )
-    {
-       wxWindow *ctrl = (wxWindow *)NULL;

 
 

-        if ( IsCellEditControlEnabled() )
-        {
-            ctrl = m_cellEditCtrl;
-        }
-        else if ( IsTopEditControlEnabled() )
-        {
-            ctrl = m_topEditCtrl;
-        }
-        else
-        {
-            return;
-        }
-        
-        bool valueChanged = FALSE;
-        
-        switch ( m_editCtrlType )
+        // ------------ Left button released
+        //
+        else if ( event.LeftUp() )

         {
         {

-            case wxGRID_TEXTCTRL:
-                valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
-                                ((wxGridTextCtrl *)ctrl)->GetStartValue());
-                SetCellValue( m_currentCellCoords,
-                              ((wxTextCtrl *) ctrl)->GetValue() );
-                break;
+            if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+            {
+                if ( IsSelection() )
+                {
+                    SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, event );
+                }

 
 

-            case wxGRID_CHECKBOX:
-                // TODO: implement this
-                //
-                break;
+                // Show the edit control, if it has
+                // been hidden for drag-shrinking.
+                if ( IsCellEditControlEnabled() )
+                    ShowCellEditControl();
+            }
+            else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                DoEndDragResizeRow();

 
 

-            case wxGRID_CHOICE:
-                // TODO: implement this
+                // Note: we are ending the event *after* doing
+                // default processing in this case

                 //
                 //

-                break;
-                
-            case wxGRID_COMBOBOX:
-                // TODO: implement this
+                SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+            }
+            else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                DoEndDragResizeCol();
+
+                // Note: we are ending the event *after* doing
+                // default processing in this case

                 //
                 //

-                break;
-        }
-        
-        if ( valueChanged )
-        {
-            SendEvent( EVT_GRID_CELL_CHANGE,
-                       m_currentCellCoords.GetRow(),
-                       m_currentCellCoords.GetCol() );
+                SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
+            }
+
+            m_dragLastPos = -1;

         }
         }

-    }
-}

 
 
 
 

-int wxGrid::XYToArea( int x, int y )
-{
-    if ( x > m_left && x < m_right &&
-         y > m_top && y < m_bottom )
-    {
-        if ( y < m_top + m_colLabelHeight )
+        // ------------ Right button down
+        //
+        else if ( event.RightDown() )

         {
         {

-            if ( x > m_left + m_rowLabelWidth )
-            {
-                return WXGRID_COLLABEL;
-            }
-            else
+            if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
+                             coords.GetRow(),
+                             coords.GetCol(),
+                             event ) )

             {
             {

-                return WXGRID_CORNERLABEL;
+                // no default action at the moment

             }
         }
             }
         }

-        else if ( x <= m_left + m_rowLabelWidth )
+
+
+        // ------------ Right double click
+        //
+        else if ( event.RightDClick() )

         {
         {

-            return WXGRID_ROWLABEL;
+            if ( !SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
+                             coords.GetRow(),
+                             coords.GetCol(),
+                             event ) )
+            {
+                // no default action at the moment
+            }

         }
         }

-        else
+
+        // ------------ Moving and no button action
+        //
+        else if ( event.Moving() && !event.IsButton() )

         {
         {

-            return WXGRID_CELL;
-        }
-    }
+            int dragRow = YToEdgeOfRow( y );
+            int dragCol = XToEdgeOfCol( x );

 
 

-    return WXGRID_NOAREA;
-}
+            // Dragging on the corner of a cell to resize in both
+            // directions is not implemented yet...
+            //
+            if ( dragRow >= 0  &&  dragCol >= 0 )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                return;
+            }

 
 

+            if ( dragRow >= 0 )
+            {
+                m_dragRowOrCol = dragRow;

 
 

-void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
-{
-    coords.SetRow( YToRow(y) );
-    coords.SetCol( XToCol(x) );
-}
+                if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+                {
+                    ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
+                }

 
 

+                return;
+            }

 
 

-int wxGrid::YToRow( int y )
-{
-    int i;
-    
-    if ( y > m_top + m_colLabelHeight )
-    {
-        for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-        {
-            if ( y < m_rowBottoms[i] )
+            if ( dragCol >= 0 )

             {
             {

-                return i;
-            }
-        }
-    }
+                m_dragRowOrCol = dragCol;

 
 

-    return -1;
-}
+                if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+                {
+                    ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
+                }

 
 

+                return;
+            }

 
 

-int wxGrid::XToCol( int x )
-{
-    int i;
-    
-    if ( x > m_left + m_rowLabelWidth )
-    {
-        for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-        {
-            if ( x < m_colRights[i] )
+            // Neither on a row or col edge
+            //
+            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                return i;
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);

             }
         }
     }
             }
         }
     }

-
-    return -1;

 }
 
 
 }
 
 

-// return the row number that that the y coord is near the edge of, or
-// -1 if not near an edge
-//
-int wxGrid::YToEdgeOfRow( int y )
+void wxGrid::DoEndDragResizeRow()

 {
 {

-    int i, d;
-    
-    if ( y > m_top + m_colLabelHeight )
+    if ( m_dragLastPos >= 0 )

     {
     {

-        for ( i = m_scrollPosY;  i < m_numRows;  i++ )
+        // erase the last line and resize the row
+        //
+        int cw, ch, left, dummy;
+        m_gridWin->GetClientSize( &cw, &ch );
+        CalcUnscrolledPosition( 0, 0, &left, &dummy );
+
+        wxClientDC dc( m_gridWin );
+        PrepareDC( dc );
+        dc.SetLogicalFunction( wxINVERT );
+        dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
+        HideCellEditControl();
+
+        int rowTop = m_rowBottoms[m_dragRowOrCol] - m_rowHeights[m_dragRowOrCol];
+        SetRowSize( m_dragRowOrCol,
+                    wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
+
+        if ( !GetBatchCount() )

         {
         {

-            if ( m_rowHeights[i] > WXGRID_LABEL_EDGE_ZONE )
-            {
-                d = abs( y - m_rowBottoms[i] );
-                {
-                    if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
-                }
-            }
+            // Only needed to get the correct rect.y:
+            wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
+            rect.x = 0;
+            CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
+            rect.width = m_rowLabelWidth;
+            rect.height = ch - rect.y;
+            m_rowLabelWin->Refresh( TRUE, &rect );
+            rect.width = cw;
+            m_gridWin->Refresh( FALSE, &rect );

         }
         }

-    }

 
 

-    return -1;
-    
+        ShowCellEditControl();
+    }

 }
 
 
 }
 
 

-// return the col number that that the x coord is near the edge of, or
-// -1 if not near an edge
-//
-int wxGrid::XToEdgeOfCol( int x )
+void wxGrid::DoEndDragResizeCol()

 {
 {

-    int i, d;
-    
-    if ( x > m_left + m_rowLabelWidth )
+    if ( m_dragLastPos >= 0 )

     {
     {

-        for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-        {
-            if ( m_colWidths[i] > WXGRID_LABEL_EDGE_ZONE )
-            {
-                d = abs( x - m_colRights[i] );
-                {
-                    if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
-                }
-            }
-        }
-    }
+        // erase the last line and resize the col
+        //
+        int cw, ch, dummy, top;
+        m_gridWin->GetClientSize( &cw, &ch );
+        CalcUnscrolledPosition( 0, 0, &dummy, &top );

 
 

-    return -1;
-    
-}
+        wxClientDC dc( m_gridWin );
+        PrepareDC( dc );
+        dc.SetLogicalFunction( wxINVERT );
+        dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
+        HideCellEditControl();

 
 

+        int colLeft = m_colRights[m_dragRowOrCol] - m_colWidths[m_dragRowOrCol];
+        SetColSize( m_dragRowOrCol,
+                    wxMax( m_dragLastPos - colLeft, WXGRID_MIN_COL_WIDTH ) );

 
 

-wxRect wxGrid::CellToRect( int row, int col )
-{
-    wxRect rect( -1, -1, -1, -1 );
+        if ( !GetBatchCount() )
+        {
+            // Only needed to get the correct rect.x:
+            wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
+            rect.y = 0;
+            CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
+            rect.width = cw - rect.x;
+            rect.height = m_colLabelHeight;
+            m_colLabelWin->Refresh( TRUE, &rect );
+            rect.height = ch;
+            m_gridWin->Refresh( FALSE, &rect );
+        }

 
 

-    if ( row >= m_scrollPosY  &&  col >= m_scrollPosX )
-    {
-        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 ];
+        ShowCellEditControl();

     }
     }

+}

 
 

-    return rect;
-}    

 
 
 
 

-bool wxGrid::MoveCursorUp()
+//
+// ------ interaction with data model
+//
+bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() > 0 )
+    switch ( msg.GetId() )

     {
     {

-        SelectCell( m_currentCellCoords.GetRow() - 1,
-                      m_currentCellCoords.GetCol() );
+        case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
+            return GetModelValues();

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
+        case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
+            return SetModelValues();

 
 

-        return TRUE;
-    }
+        case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
+        case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
+        case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
+        case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
+        case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
+        case wxGRIDTABLE_NOTIFY_COLS_DELETED:
+            return Redimension( msg );

 
 

-    return FALSE;
+        default:
+            return FALSE;
+    }

 }
 
 }
 

-bool wxGrid::MoveCursorDown()
+
+
+// The behaviour of this function depends on the grid table class
+// Clear() function.  For the default wxGridStringTable class the
+// behavious is to replace all cell contents with wxEmptyString but
+// not to change the number of rows or cols.
+//
+void wxGrid::ClearGrid()

 {
 {

-    // TODO: allow for scrolling
-    //
-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() < m_numRows-1 )
+    if ( m_table )

     {
     {

-        SelectCell( m_currentCellCoords.GetRow() + 1,
-                      m_currentCellCoords.GetCol() );
-
-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-            
-        return TRUE;
+        m_table->Clear();
+        SetEditControlValue();
+        if ( !GetBatchCount() ) m_gridWin->Refresh();

     }
     }

-
-    return FALSE;

 }
 
 }
 

-bool wxGrid::MoveCursorLeft()
+
+bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() > 0 )
-    {
-        SelectCell( m_currentCellCoords.GetRow(),
-                      m_currentCellCoords.GetCol() - 1 );
+    // TODO: something with updateLabels flag

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-        
-        return TRUE;
+    if ( !m_created )
+    {
+        wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
+        return FALSE;

     }
 
     }
 

-    return FALSE;
-}
+    if ( m_table )
+    {
+        bool ok = m_table->InsertRows( pos, numRows );

 
 

-bool wxGrid::MoveCursorRight()
-{
-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() < m_numCols - 1 )
-    {
-        SelectCell( m_currentCellCoords.GetRow(),
-                      m_currentCellCoords.GetCol() + 1 );
+        // the table will have sent the results of the insert row
+        // operation to this view object as a grid table message
+        //
+        if ( ok )
+        {
+            if ( m_numCols == 0 )
+            {
+                m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
+                //
+                // TODO: perhaps instead of appending the default number of cols
+                // we should remember what the last non-zero number of cols was ?
+                //
+            }

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-            
-        return TRUE;
-    }
+            if ( m_currentCellCoords == wxGridNoCellCoords )
+            {
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );
+            }

 
 

-    return FALSE;
+            ClearSelection();
+            if ( !GetBatchCount() ) Refresh();
+        }
+
+        SetEditControlValue();
+        return ok;
+    }
+    else
+    {
+        return FALSE;
+    }

 }
 
 }
 

-bool wxGrid::MovePageUp()
+
+bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_scrollPosY > 0 )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
-        while ( row > 0 )
+        wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
+        return FALSE;
+    }
+
+    if ( m_table && m_table->AppendRows( numRows ) )
+    {
+        if ( m_currentCellCoords == wxGridNoCellCoords )

         {
         {

-            if ( y + m_rowHeights[row-1] > m_bottom ) break;
-            y += m_rowHeights[ --row ];
+            // if we have just inserted cols into an empty grid the current
+            // cell will be undefined...
+            //
+            SetCurrentCell( 0, 0 );

         }
         }

-        SetVerticalScrollPos( row );

 
 

-        SelectCell( row, m_currentCellCoords.GetCol() );
+        // the table will have sent the results of the append row
+        // operation to this view object as a grid table message
+        //
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();

         return TRUE;
     }
         return TRUE;
     }

-    
-    return FALSE;
+    else
+    {
+        return FALSE;
+    }

 }
 
 }
 

-bool wxGrid::MovePageDown()
+
+bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_scrollPosY + m_wholeRowsVisible < m_numRows )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-        if ( m_wholeRowsVisible > 0 )
-        {
-            SetVerticalScrollPos( m_scrollPosY + m_wholeRowsVisible );
-        }
-        else if ( m_scrollPosY < m_numRows - 1 )
-        {
-            SetVerticalScrollPos( m_scrollPosY + 1 );
-        }
-        else
-        {
-            return FALSE;
-        }
-        
-        // m_scrollPosY will have been updated
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
+        return FALSE;
+    }
+
+    if ( m_table && 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

         //
         //

-        SelectCell( m_scrollPosY, m_currentCellCoords.GetCol() );
+        if ( m_numRows > 0 )
+            SetEditControlValue();
+        else
+            HideCellEditControl();
+
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();

         return TRUE;
     }
         return TRUE;
     }

-    
-    return FALSE;
+    else
+    {
+        return FALSE;
+    }

 }
 
 }
 

-bool wxGrid::MoveCursorUpBlock()
+
+bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() > 0 )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int col = m_currentCellCoords.GetCol();
-        
-        if ( m_table->IsEmptyCell(row, col) )
+        wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
+        return FALSE;
+    }
+
+    if ( m_table )
+    {
+        HideCellEditControl();
+        bool ok = m_table->InsertCols( pos, numCols );
+
+        // the table will have sent the results of the insert col
+        // operation to this view object as a grid table message
+        //
+        if ( ok )

         {
         {

-            // starting in an empty cell: find the next block of
-            // non-empty cells
-            //
-            while ( row > 0 )
+            if ( m_currentCellCoords == wxGridNoCellCoords )

             {
             {

-                row-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );

             }
             }

+
+            ClearSelection();
+            if ( !GetBatchCount() ) Refresh();

         }
         }

-        else if ( m_table->IsEmptyCell(row-1, col) )
+
+        SetEditControlValue();
+        return ok;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+
+bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
+{
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )
+    {
+        wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
+        return FALSE;
+    }
+
+    if ( m_table && m_table->AppendCols( numCols ) )
+    {
+        // the table will have sent the results of the append col
+        // operation to this view object as a grid table message
+        //
+        if ( m_currentCellCoords == wxGridNoCellCoords )

         {
         {

-            // starting at the top of a block: find the next block
+            // if we have just inserted cols into an empty grid the current
+            // cell will be undefined...

             //
             //

-            row--;
-            while ( row > 0 )
-            {
-                row-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
+            SetCurrentCell( 0, 0 );

         }
         }

+
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+
+bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
+{
+    // TODO: something with updateLabels flag
+
+    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
         else

+            HideCellEditControl();
+
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+
+
+//
+// ----- event handlers
+//
+
+// Generate a grid event based on a mouse event and
+// return the result of ProcessEvent()
+//
+bool wxGrid::SendEvent( const wxEventType type,
+                        int row, int col,
+                        wxMouseEvent& mouseEv )
+{
+    if ( type == EVT_GRID_ROW_SIZE ||
+         type == EVT_GRID_COL_SIZE )
+    {
+        int rowOrCol = (row == -1 ? col : row);
+
+        wxGridSizeEvent gridEvt( GetId(),
+                                 type,
+                                 this,
+                                 rowOrCol,
+                                 mouseEv.GetX(), mouseEv.GetY(),
+                                 mouseEv.ControlDown(),
+                                 mouseEv.ShiftDown(),
+                                 mouseEv.AltDown(),
+                                 mouseEv.MetaDown() );
+
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+    else if ( type == EVT_GRID_RANGE_SELECT )
+    {
+        wxGridRangeSelectEvent gridEvt( GetId(),
+                                        type,
+                                        this,
+                                        m_selectedTopLeft,
+                                        m_selectedBottomRight,
+                                        mouseEv.ControlDown(),
+                                        mouseEv.ShiftDown(),
+                                        mouseEv.AltDown(),
+                                        mouseEv.MetaDown() );
+
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+    else
+    {
+        wxGridEvent gridEvt( GetId(),
+                             type,
+                             this,
+                             row, col,
+                             mouseEv.GetX(), mouseEv.GetY(),
+                             mouseEv.ControlDown(),
+                             mouseEv.ShiftDown(),
+                             mouseEv.AltDown(),
+                             mouseEv.MetaDown() );
+
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+}
+
+
+// Generate a grid event of specified type and return the result
+// of ProcessEvent().
+//
+bool wxGrid::SendEvent( const wxEventType type,
+                        int row, int col )
+{
+    if ( type == EVT_GRID_ROW_SIZE ||
+         type == EVT_GRID_COL_SIZE )
+    {
+        int rowOrCol = (row == -1 ? col : row);
+
+        wxGridSizeEvent gridEvt( GetId(),
+                                 type,
+                                 this,
+                                 rowOrCol );
+
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+    else
+    {
+        wxGridEvent gridEvt( GetId(),
+                             type,
+                             this,
+                             row, col );
+
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+}
+
+
+void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
+{
+    wxPaintDC dc( this );
+
+    if ( m_currentCellCoords == wxGridNoCellCoords  &&
+         m_numRows && m_numCols )
+    {
+        m_currentCellCoords.Set(0, 0);
+        SetEditControlValue();
+        ShowCellEditControl();
+    }
+
+    m_displayed = TRUE;
+}
+
+
+// This is just here to make sure that CalcDimensions gets called when
+// the grid view is resized... then the size event is skipped to allow
+// the box sizers to handle everything
+//
+void wxGrid::OnSize( wxSizeEvent& event )
+{
+    CalcWindowSizes();
+    CalcDimensions();
+}
+
+
+void wxGrid::OnKeyDown( wxKeyEvent& event )
+{
+    if ( m_inOnKeyDown )
+    {
+        // shouldn't be here - we are going round in circles...
+        //
+        wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while alread active") );
+    }
+
+    m_inOnKeyDown = TRUE;
+
+    // propagate the event up and see if it gets processed
+    //
+    wxWindow *parent = GetParent();
+    wxKeyEvent keyEvt( event );
+    keyEvt.SetEventObject( parent );
+
+    if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
+    {
+        // try local handlers
+        //
+        switch ( event.KeyCode() )

         {
         {

-            // starting within a block: find the top of the block
-            //
-            while ( row > 0 )
-            {
-                row-- ;
-                if ( m_table->IsEmptyCell(row, col) )
+            case WXK_UP:
+                if ( event.ControlDown() )

                 {
                 {

-                    row++ ;
-                    break;
+                    MoveCursorUpBlock();

                 }
                 }

-            }
+                else
+                {
+                    MoveCursorUp();
+                }
+                break;
+
+            case WXK_DOWN:
+                if ( event.ControlDown() )
+                {
+                    MoveCursorDownBlock();
+                }
+                else
+                {
+                    MoveCursorDown();
+                }
+                break;
+
+            case WXK_LEFT:
+                if ( event.ControlDown() )
+                {
+                    MoveCursorLeftBlock();
+                }
+                else
+                {
+                    MoveCursorLeft();
+                }
+                break;
+
+            case WXK_RIGHT:
+                if ( event.ControlDown() )
+                {
+                    MoveCursorRightBlock();
+                }
+                else
+                {
+                    MoveCursorRight();
+                }
+                break;
+
+            case WXK_SPACE:
+                if ( !IsEditable() )
+                {
+                    MoveCursorRight();
+                }
+                else
+                {
+                    event.Skip();
+                }
+                break;
+
+            case WXK_RETURN:
+                if ( event.ControlDown() )
+                {
+                    event.Skip();  // to let the edit control have the return
+                }
+                else
+                {
+                    MoveCursorDown();
+                }
+                break;
+
+            case WXK_HOME:
+                if ( event.ControlDown() )
+                {
+                    MakeCellVisible( 0, 0 );
+                    SetCurrentCell( 0, 0 );
+                }
+                else
+                {
+                    event.Skip();
+                }
+                break;
+
+            case WXK_END:
+                if ( event.ControlDown() )
+                {
+                    MakeCellVisible( m_numRows-1, m_numCols-1 );
+                    SetCurrentCell( m_numRows-1, m_numCols-1 );
+                }
+                else
+                {
+                    event.Skip();
+                }
+                break;
+
+            case WXK_PRIOR:
+                MovePageUp();
+                break;
+
+            case WXK_NEXT:
+                MovePageDown();
+                break;
+
+            default:
+                // now try the cell edit control
+                //
+                if ( IsCellEditControlEnabled() )
+                {
+                    event.SetEventObject( m_cellEditCtrl );
+                    m_cellEditCtrl->GetEventHandler()->ProcessEvent( event );
+                }
+                break;

         }
         }

-        
-        SelectCell( row, col );
+    }

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
+    m_inOnKeyDown = FALSE;
+}
+
+
+void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
+{
+    if ( SendEvent( EVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
+    {
+        // the event has been intercepted - do nothing
+        return;
+    }

 
 

+    if ( m_displayed  &&
+         m_currentCellCoords != wxGridNoCellCoords )
+    {
+        HideCellEditControl();
+        SaveEditControlValue();
+    }
+
+    m_currentCellCoords = coords;
+
+    SetEditControlValue();
+
+    if ( m_displayed )
+    {
+        ShowCellEditControl();
+
+        if ( IsSelection() )
+        {
+            wxRect r( SelectionToDeviceRect() );
+            ClearSelection();
+            if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
+        }
+    }
+}
+
+
+//
+// ------ functions to get/send data (see also public functions)
+//
+
+bool wxGrid::GetModelValues()
+{
+    if ( m_table )
+    {
+        // all we need to do is repaint the grid
+        //
+        m_gridWin->Refresh();

         return TRUE;
     }
 
     return FALSE;
 }
 
         return TRUE;
     }
 
     return FALSE;
 }
 

-bool wxGrid::MoveCursorDownBlock()
+
+bool wxGrid::SetModelValues()

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() < m_numRows-1 )
+    int row, col;
+
+    if ( m_table )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int col = m_currentCellCoords.GetCol();
-        
-        if ( m_table->IsEmptyCell(row, col) )
-        {
-            // starting in an empty cell: find the next block of
-            // non-empty cells
-            //
-            while ( row < m_numRows-1 )
-            {
-                row++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
-        }
-        else if ( m_table->IsEmptyCell(row+1, col) )
-        {
-            // starting at the bottom of a block: find the next block
-            //
-            row++;
-            while ( row < m_numRows-1 )
-            {
-                row++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
-        }
-        else
+        for ( row = 0;  row < m_numRows;  row++ )

         {
         {

-            // starting within a block: find the bottom of the block
-            //
-            while ( row < m_numRows-1 )
+            for ( col = 0;  col < m_numCols;  col++ )

             {
             {

-                row++ ;
-                if ( m_table->IsEmptyCell(row, col) )
-                {
-                    row-- ;
-                    break;
-                }
+                m_table->SetValue( row, col, GetCellValue(row, col) );

             }
         }
             }
         }

-        
-        SelectCell( row, col );
-
-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );

 
         return TRUE;
     }
 
         return TRUE;
     }


@@ -2615,769 +3070,892 @@ bool wxGrid::MoveCursorDownBlock()
     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxGrid::MoveCursorLeftBlock()
+
+
+// Note - this function only draws cells that are in the list of
+// exposed cells (usually set from the update region by
+// CalcExposedCells)
+//
+void wxGrid::DrawGridCellArea( wxDC& dc )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() > 0 )
+    if ( !m_numRows || !m_numCols ) return;
+
+    size_t i;
+    size_t numCells = m_cellsExposed.GetCount();
+
+    for ( i = 0;  i < numCells;  i++ )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int col = m_currentCellCoords.GetCol();
-        
-        if ( m_table->IsEmptyCell(row, col) )
-        {
-            // starting in an empty cell: find the next block of
-            // non-empty cells
-            //
-            while ( col > 0 )
-            {
-                col-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
-        }
-        else if ( m_table->IsEmptyCell(row, col-1) )
-        {
-            // starting at the left of a block: find the next block
-            //
-            col--;
-            while ( col > 0 )
-            {
-                col-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
-        }
-        else
-        {
-            // starting within a block: find the left of the block
-            //
-            while ( col > 0 )
-            {
-                col-- ;
-                if ( m_table->IsEmptyCell(row, col) )
-                {
-                    col++ ;
-                    break;
-                }
-            }
-        }
-        
-        SelectCell( row, col );
+        DrawCell( dc, m_cellsExposed[i] );
+    }
+}

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );

 
 

-        return TRUE;
+void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
+{
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;
+
+#if !WXGRID_DRAW_LINES
+    if ( m_gridLinesEnabled )
+        DrawCellBorder( dc, coords );
+#endif
+
+    DrawCellBackground( dc, coords );
+
+    // TODO: separate functions here for different kinds of cells ?
+    // e.g. text, image
+    //
+    DrawCellValue( dc, coords );
+}
+
+
+void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
+{
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;
+
+    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+    int row = coords.GetRow();
+    int col = coords.GetCol();
+
+    // right hand border
+    //
+    dc.DrawLine( m_colRights[col], m_rowBottoms[row] - m_rowHeights[row],
+                 m_colRights[col], m_rowBottoms[row] );
+
+    // bottom border
+    //
+    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row],
+                 m_colRights[col], m_rowBottoms[row] );
+}
+
+
+void wxGrid::DrawCellBackground( wxDC& dc, const wxGridCellCoords& coords )
+{
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;
+
+    int row = coords.GetRow();
+    int col = coords.GetCol();
+
+    dc.SetBackgroundMode( wxSOLID );
+
+    if ( IsInSelection( coords ) )
+    {
+        // TODO: improve this
+        //
+        dc.SetBrush( *wxBLACK_BRUSH );
+    }
+    else
+    {
+        dc.SetBrush( wxBrush(GetCellBackgroundColour(row, col), wxSOLID) );

     }
 
     }
 

-    return FALSE;
+    dc.SetPen( *wxTRANSPARENT_PEN );
+
+    dc.DrawRectangle( m_colRights[col] - m_colWidths[col] + 1,
+                      m_rowBottoms[row] - m_rowHeights[row] + 1,
+                      m_colWidths[col]-1,
+                      m_rowHeights[row]-1 );

 }
 
 }
 

-bool wxGrid::MoveCursorRightBlock()
+
+void wxGrid::DrawCellValue( wxDC& dc, const wxGridCellCoords& coords )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() < m_numCols-1 )
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;
+
+    int row = coords.GetRow();
+    int col = coords.GetCol();
+
+    dc.SetBackgroundMode( wxTRANSPARENT );
+
+    if ( IsInSelection( row, col ) )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int col = m_currentCellCoords.GetCol();
-        
-        if ( m_table->IsEmptyCell(row, col) )
+        // TODO: improve this
+        //
+        dc.SetTextBackground( wxColour(0, 0, 0) );
+        dc.SetTextForeground( wxColour(255, 255, 255) );
+    }
+    else
+    {
+        dc.SetTextBackground( GetCellBackgroundColour(row, col) );
+        dc.SetTextForeground( GetCellTextColour(row, col) );
+    }
+    dc.SetFont( GetCellFont(row, col) );
+
+    int hAlign, vAlign;
+    GetCellAlignment( row, col, &hAlign, &vAlign );
+
+    wxRect rect;
+    rect.SetX( m_colRights[col] - m_colWidths[col] + 2 );
+    rect.SetY( m_rowBottoms[row] - m_rowHeights[row] + 2 );
+    rect.SetWidth( m_colWidths[col] - 4 );
+    rect.SetHeight( m_rowHeights[row] - 4 );
+
+    DrawTextRectangle( dc, GetCellValue( row, col ), rect, hAlign, vAlign );
+}
+
+
+
+// TODO: remove this ???
+// This is used to redraw all grid lines e.g. when the grid line colour
+// has been changed
+//
+void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
+{
+    if ( !m_gridLinesEnabled ||
+         !m_numRows ||
+         !m_numCols ) return;
+
+    int top, bottom, left, right;
+
+    if (reg.IsEmpty()){
+      int cw, ch;
+      m_gridWin->GetClientSize(&cw, &ch);
+
+      // virtual coords of visible area
+      //
+      CalcUnscrolledPosition( 0, 0, &left, &top );
+      CalcUnscrolledPosition( cw, ch, &right, &bottom );
+    }
+    else{
+      wxCoord x, y, w, h;
+      reg.GetBox(x, y, w, h);
+      CalcUnscrolledPosition( x, y, &left, &top );
+      CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
+    }
+
+    // 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] );
+
+    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+
+    // horizontal grid lines
+    //
+    int i;
+    for ( i = 0; i < m_numRows; i++ )
+    {
+        if ( m_rowBottoms[i] > bottom )

         {
         {

-            // starting in an empty cell: find the next block of
-            // non-empty cells
-            //
-            while ( col < m_numCols-1 )
-            {
-                col++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
+            break;

         }
         }

-        else if ( m_table->IsEmptyCell(row, col+1) )
+        else if ( m_rowBottoms[i] >= top )

         {
         {

-            // starting at the right of a block: find the next block
-            //
-            col++;
-            while ( col < m_numCols-1 )
-            {
-                col++ ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
+            dc.DrawLine( left, m_rowBottoms[i], right, m_rowBottoms[i] );

         }
         }

-        else
+    }
+
+
+    // vertical grid lines
+    //
+    for ( i = 0; i < m_numCols; i++ )
+    {
+        if ( m_colRights[i] > right )

         {
         {

-            // starting within a block: find the right of the block
-            //
-            while ( col < m_numCols-1 )
-            {
-                col++ ;
-                if ( m_table->IsEmptyCell(row, col) )
-                {
-                    col-- ;
-                    break;
-                }
-            }
+            break;
+        }
+        else if ( m_colRights[i] >= left )
+        {
+            dc.DrawLine( m_colRights[i], top, m_colRights[i], bottom );

         }
         }

-        
-        SelectCell( row, col );
+    }
+}

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );

 
 

-        return TRUE;
-    }
+void wxGrid::DrawRowLabels( wxDC& dc )
+{
+    if ( !m_numRows || !m_numCols ) return;

 
 

-    return FALSE;
+    size_t i;
+    size_t numLabels = m_rowLabelsExposed.GetCount();
+
+    for ( i = 0;  i < numLabels;  i++ )
+    {
+        DrawRowLabel( dc, m_rowLabelsExposed[i] );
+    }

 }
 
 
 }
 
 

+void wxGrid::DrawRowLabel( wxDC& dc, int row )
+{
+    if ( m_rowHeights[row] <= 0 ) return;

 
 

-//
-// ----- grid drawing functions
-//
+    int rowTop = m_rowBottoms[row] - m_rowHeights[row];

 
 

-void wxGrid::DrawLabelAreas( wxDC& dc )
-{
-    int cw, ch;
-    GetClientSize(&cw, &ch);
+    dc.SetPen( *wxBLACK_PEN );
+    dc.DrawLine( m_rowLabelWidth-1, rowTop,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+
+    dc.DrawLine( 0, m_rowBottoms[row]-1,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+
+    dc.SetPen( *wxWHITE_PEN );
+    dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
+    dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
+
+    dc.SetBackgroundMode( wxTRANSPARENT );
+    dc.SetTextForeground( GetLabelTextColour() );
+    dc.SetFont( GetLabelFont() );
+
+    int hAlign, vAlign;
+    GetRowLabelAlignment( &hAlign, &vAlign );

 
 

-    dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.SetBrush( wxBrush(GetLabelBackgroundColour(), wxSOLID) );
-    
-    dc.DrawRectangle( m_left, m_top,
-                      cw - m_left, m_colLabelHeight );
-    
-    dc.DrawRectangle( m_left, m_top,
-                      m_rowLabelWidth, ch - m_top );
+    wxRect rect;
+    rect.SetX( 2 );
+    rect.SetY( m_rowBottoms[row] - m_rowHeights[row] + 2 );
+    rect.SetWidth( m_rowLabelWidth - 4 );
+    rect.SetHeight( m_rowHeights[row] - 4 );
+    DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );

 }
 
 
 void wxGrid::DrawColLabels( wxDC& dc )
 {
 }
 
 
 void wxGrid::DrawColLabels( wxDC& dc )
 {

-    int cw, ch;
-    GetClientSize(&cw, &ch);
-
-    if (m_colLabelHeight == 0) return;
-
-    DrawColLabelBorders( dc );
+    if ( !m_numRows || !m_numCols ) return;

 
 

-    wxRect rect;
-    rect.y = m_top + 1;
-    rect.height = m_colLabelHeight - 1;
+    size_t i;
+    size_t numLabels = m_colLabelsExposed.GetCount();

 
 

-    int labelLeft = m_left + m_rowLabelWidth;
-    int i;
-    
-    for ( i = m_scrollPosX;  i < m_numCols;  i++ )
+    for ( i = 0;  i < numLabels;  i++ )

     {
     {

-        if ( labelLeft > cw) break;
-
-        rect.x = 1 + labelLeft;
-        rect.width = m_colWidths[i];
-        DrawColLabel( dc, rect, i );
-            
-        labelLeft += m_colWidths[i];
+        DrawColLabel( dc, m_colLabelsExposed[i] );

     }
 }
 
 
     }
 }
 
 

-void wxGrid::DrawColLabelBorders( wxDC& dc )
+void wxGrid::DrawColLabel( wxDC& dc, int col )

 {
 {

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

 
 

-    int i;
-    int cw, ch;
-    GetClientSize( &cw, &ch );
+    int colLeft = m_colRights[col] - m_colWidths[col];

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

-  
-    // horizontal lines
-    //
-    dc.DrawLine( m_left, m_top, cw, m_top );
-
-    dc.DrawLine( m_left, m_top + m_colLabelHeight,
-                 cw,     m_top + m_colLabelHeight );
-
-    // vertical lines
-    //
-    int colLeft = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX;  i <= m_numCols;  i++ )
-    {
-        if (colLeft > cw) break;
-
-        dc.DrawLine( colLeft, m_top,
-                     colLeft, m_top + m_colLabelHeight);
+    dc.DrawLine( m_colRights[col]-1, 0,
+                 m_colRights[col]-1, m_colLabelHeight-1 );

 
 

-        if ( i < m_numCols ) colLeft += m_colWidths[i];
-    }
+    dc.DrawLine( colLeft, m_colLabelHeight-1,
+                 m_colRights[col]-1, m_colLabelHeight-1 );

 
 

-    // Draw white highlights for a 3d effect
-    //

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

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

 
 

-    colLeft = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX; i < m_numCols; i++ )
-    {
-        if (colLeft > cw) break;
-
-        dc.DrawLine(colLeft + 1, m_top + 1,
-                    colLeft + m_colWidths[i], m_top + 1);
-
-        dc.DrawLine(colLeft + 1, m_top + 1,
-                    colLeft + 1, m_top + m_colLabelHeight);
-        
-        colLeft += m_colWidths[i];
-    }
-}
-
+    dc.SetBackgroundMode( wxTRANSPARENT );
+    dc.SetTextForeground( GetLabelTextColour() );
+    dc.SetFont( GetLabelFont() );

 
 

-void wxGrid::DrawColLabel( wxDC& dc, const wxRect& rect, int col )
-{
-    wxRect rect2;
-    rect2 = rect;
-    rect2.x += 3;
-    rect2.y += 2;
-    rect2.width -= 5;
-    rect2.height -= 4;
-    

     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetBackgroundMode( wxTRANSPARENT );

-    dc.SetTextBackground( GetLabelBackgroundColour() );

     dc.SetTextForeground( GetLabelTextColour() );
     dc.SetFont( GetLabelFont() );
     dc.SetTextForeground( GetLabelTextColour() );
     dc.SetFont( GetLabelFont() );

-    
+

     int hAlign, vAlign;
     GetColLabelAlignment( &hAlign, &vAlign );
     int hAlign, vAlign;
     GetColLabelAlignment( &hAlign, &vAlign );

-    DrawTextRectangle( dc, GetColLabelValue( col ), rect2, hAlign, vAlign );
+
+    wxRect rect;
+    rect.SetX( m_colRights[col] - m_colWidths[col] + 2 );
+    rect.SetY( 2 );
+    rect.SetWidth( m_colWidths[col] - 4 );
+    rect.SetHeight( m_colLabelHeight - 4 );
+    DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );

 }
 
 
 }
 
 

-void wxGrid::DrawRowLabels( wxDC& dc )
+void wxGrid::DrawTextRectangle( wxDC& dc,
+                                const wxString& value,
+                                const wxRect& rect,
+                                int horizAlign,
+                                int vertAlign )

 {
 {

-    int cw, ch;
-    GetClientSize(&cw, &ch);
+    long textWidth, textHeight;
+    long lineWidth, lineHeight;
+    wxArrayString lines;
+
+    dc.SetClippingRegion( rect );
+    StringToLines( value, lines );
+    if ( lines.GetCount() )
+    {
+        GetTextBoxSize( dc, lines, &textWidth, &textHeight );
+        dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );

 
 

-    if (m_rowLabelWidth == 0) return;
+        float x, y;
+        switch ( horizAlign )
+        {
+            case wxRIGHT:
+                x = rect.x + (rect.width - textWidth - 1);
+                break;

 
 

-    DrawRowLabelBorders( dc );
+            case wxCENTRE:
+                x = rect.x + ((rect.width - textWidth)/2);
+                break;

 
 

-    wxRect rect;
-    rect.x = m_left + 1;
-    rect.width = m_rowLabelWidth - 1;
+            case wxLEFT:
+            default:
+                x = rect.x + 1;
+                break;
+        }

 
 

-    int labelTop = m_top + m_colLabelHeight;
-    int i;
-    
-    for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-    {
-        if ( labelTop > ch ) break;
+        switch ( vertAlign )
+        {
+            case wxBOTTOM:
+                y = rect.y + (rect.height - textHeight - 1);
+                break;
+
+            case wxCENTRE:
+                y = rect.y + ((rect.height - textHeight)/2);
+                break;
+
+            case wxTOP:
+            default:
+                y = rect.y + 1;
+                break;
+        }

 
 

-        rect.y = 1 + labelTop;
-        rect.height = m_rowHeights[i];
-        DrawRowLabel( dc, rect, i );
-            
-        labelTop += m_rowHeights[i];
+        for ( size_t i = 0;  i < lines.GetCount();  i++ )
+        {
+            dc.DrawText( lines[i], (long)x, (long)y );
+            y += lineHeight;
+        }

     }
     }

+
+    dc.DestroyClippingRegion();

 }
 
 
 }
 
 

-void wxGrid::DrawRowLabelBorders( wxDC& dc )
+// Split multi line text up into an array of strings.  Any existing
+// contents of the string array are preserved.
+//
+void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )

 {
 {

-    if ( m_rowLabelWidth <= 0 ) return;
+    int startPos = 0;
+    int pos;
+    wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
+    wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );

 
 

-    int i;
-    int cw, ch;
-    GetClientSize( &cw, &ch );
+    while ( startPos < (int)tVal.Length() )
+    {
+        pos = tVal.Mid(startPos).Find( eol );
+        if ( pos < 0 )
+        {
+            break;
+        }
+        else if ( pos == 0 )
+        {
+            lines.Add( wxEmptyString );
+        }
+        else
+        {
+            lines.Add( value.Mid(startPos, pos) );
+        }
+        startPos += pos+1;
+    }
+    if ( startPos < (int)value.Length() )
+    {
+        lines.Add( value.Mid( startPos ) );
+    }
+}

 
 

-    dc.SetPen( *wxBLACK_PEN );
-  
-    // vertical lines
-    //
-    dc.DrawLine( m_left, m_top, m_left, ch );

 
 

-    dc.DrawLine( m_left + m_rowLabelWidth, m_top,
-                 m_left + m_rowLabelWidth, ch );
+void wxGrid::GetTextBoxSize( wxDC& dc,
+                             wxArrayString& lines,
+                             long *width, long *height )
+{
+    long w = 0;
+    long h = 0;
+    long lineW, lineH;

 
 

-    // horizontal lines
-    //
-    int rowTop = m_top + m_colLabelHeight;
-    for ( i = m_scrollPosY;  i <= m_numRows;  i++ )
+    size_t i;
+    for ( i = 0;  i < lines.GetCount();  i++ )

     {
     {

-        if ( rowTop > ch ) break;
+        dc.GetTextExtent( lines[i], &lineW, &lineH );
+        w = wxMax( w, lineW );
+        h += lineH;
+    }
+
+    *width = w;
+    *height = h;
+}

 
 

-        dc.DrawLine( m_left, rowTop,
-                     m_left + m_rowLabelWidth, rowTop );

 
 

-        if ( i < m_numRows ) rowTop += m_rowHeights[i];
-    }
+//
+// ------ Edit control functions
+//

 
 

-    // Draw white highlights for a 3d effect
-    //
-    dc.SetPen( *wxWHITE_PEN );

 
 

-    rowTop = m_top + m_colLabelHeight;
-    for ( i = m_scrollPosY; i < m_numRows; i++ )
+void wxGrid::EnableEditing( bool edit )
+{
+    // TODO: improve this ?
+    //
+    if ( edit != m_editable )

     {
     {

-        if ( rowTop > ch ) break;
-
-        dc.DrawLine( m_left + 1, rowTop + 1,
-                     m_left + m_rowLabelWidth, rowTop + 1 );
+        m_editable = edit;

 
 

-        dc.DrawLine( m_left + 1, rowTop + 1,
-                     m_left + 1, rowTop + m_rowHeights[i] );
-        
-        rowTop += m_rowHeights[i];
+        // TODO: extend this for other edit control types
+        //
+        if ( m_editCtrlType == wxGRID_TEXTCTRL )
+        {
+            ((wxTextCtrl *)m_cellEditCtrl)->SetEditable( m_editable );
+        }

     }
 }
 
 
     }
 }
 
 

-void wxGrid::DrawRowLabel( wxDC& dc, const wxRect& rect, int row )
+#if 0  // disabled for the moment - the cell control is always active
+void wxGrid::EnableCellEditControl( bool enable )

 {
 {

-    wxRect rect2;
-    rect2 = rect;
-    rect2.x += 3;
-    rect2.y += 2;
-    rect2.width -= 5;
-    rect2.height -= 4;
-    
-    dc.SetBackgroundMode( wxTRANSPARENT );
-    dc.SetTextBackground( GetLabelBackgroundColour() );
-    dc.SetTextForeground( GetLabelTextColour() );
-    dc.SetFont( GetLabelFont() );
-    
-    int hAlign, vAlign;
-    GetRowLabelAlignment( &hAlign, &vAlign );
-    DrawTextRectangle( dc, GetRowLabelValue( row ), rect2, hAlign, vAlign );
+    if ( m_cellEditCtrl &&
+         enable != m_cellEditCtrlEnabled )
+    {
+        m_cellEditCtrlEnabled = enable;
+
+        if ( m_cellEditCtrlEnabled )
+        {
+            SetEditControlValue();
+            ShowCellEditControl();
+        }
+        else
+        {
+            HideCellEditControl();
+            SaveEditControlValue();
+        }
+    }

 }
 }

+#endif

 
 
 
 

-void wxGrid::DrawCellArea( wxDC& dc )
+void wxGrid::ShowCellEditControl()

 {
 {

-  int cw, ch;
-  GetClientSize(&cw, &ch);
+    wxRect rect;
+
+    if ( IsCellEditControlEnabled() )
+    {
+        if ( !IsVisible( m_currentCellCoords ) )
+        {
+            return;
+        }
+        else
+        {
+            rect = CellToRect( m_currentCellCoords );

 
 

-  dc.SetPen( *wxTRANSPARENT_PEN );
-  dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
+            // convert to scrolled coords
+            //
+            int left, top, right, bottom;
+            CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
+            CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );

 
 

-  int left = m_left + m_rowLabelWidth + 1;
-  int top  = m_top + m_colLabelHeight + 1;
+            int cw, ch;
+            m_gridWin->GetClientSize( &cw, &ch );

 
 

-  dc.DrawRectangle( left, top, cw - left, ch - top );
-}
+            // 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__)
+            if ( m_currentCellCoords.GetRow() == 0  ||
+                 m_currentCellCoords.GetCol() == 0 )
+            {
+                extra = 2;
+            }
+            else
+            {
+                extra = 4;
+            }
+#else
+            if ( m_currentCellCoords.GetRow() == 0  ||
+                 m_currentCellCoords.GetCol() == 0 )
+            {
+                extra = 1;
+            }
+            else
+            {
+                extra = 2;
+            }
+#endif

 
 

+#if defined(__WXGTK__)
+            int top_diff = 0;
+            int left_diff = 0;
+            if (left != 0) left_diff++;
+            if (top != 0) top_diff++;
+            rect.SetLeft( left + left_diff );
+            rect.SetTop( top + top_diff );
+            rect.SetRight( rect.GetRight() - left_diff );
+            rect.SetBottom( rect.GetBottom() - top_diff );
+#else
+            rect.SetLeft( wxMax(0, left - extra) );
+            rect.SetTop( wxMax(0, top - extra) );
+            rect.SetRight( rect.GetRight() + 2*extra );
+            rect.SetBottom( rect.GetBottom() + 2*extra );
+#endif

 
 

-void wxGrid::DrawGridLines( wxDC& dc )
-{
-    if ( !m_gridLinesEnabled || !m_numRows || !m_numCols ) return;
-    
-    int i;
-    int cw, ch;
-    GetClientSize(&cw, &ch);
+            m_cellEditCtrl->SetSize( rect );
+            m_cellEditCtrl->Show( TRUE );

 
 

-    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+            switch ( m_editCtrlType )
+            {
+                case wxGRID_TEXTCTRL:
+                    ((wxTextCtrl *) m_cellEditCtrl)->SetInsertionPointEnd();
+                    break;

 
 

-    // horizontal grid lines
-    //
-    int rowTop = m_top + m_colLabelHeight + m_rowHeights[m_scrollPosY];
-    for ( i = m_scrollPosY + 1; i <= m_numRows; i++ )
-    {
-        if ( rowTop > ch ) break;
+                case wxGRID_CHECKBOX:
+                    // TODO: anything ???
+                    //
+                    break;
+
+                case wxGRID_CHOICE:
+                    // TODO: anything ???
+                    //
+                    break;
+
+                case wxGRID_COMBOBOX:
+                    // TODO: anything ???
+                    //
+                    break;
+            }
+
+            m_cellEditCtrl->SetFocus();
+        }
+    }
+}

 
 

-        dc.DrawLine( m_left + m_rowLabelWidth + 1, rowTop,
-                     m_right, rowTop);

 
 

-        if ( i < m_numRows ) rowTop += m_rowHeights[i];
+void wxGrid::HideCellEditControl()
+{
+    if ( IsCellEditControlEnabled() )
+    {
+        m_cellEditCtrl->Show( FALSE );

     }
     }

+}

 
 
 
 

-    // vertical grid lines
-    //
-    int colLeft = m_left + m_rowLabelWidth + m_colWidths[m_scrollPosX];
-    for ( i = m_scrollPosX + 1; i <= m_numCols; i++ )
+void wxGrid::SetEditControlValue( const wxString& value )
+{
+    if ( m_table )

     {
     {

-        if ( colLeft > cw ) break;
+        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;

 
 

-        dc.DrawLine( colLeft, m_top + m_colLabelHeight + 1,
-                     colLeft, m_bottom );
+                case wxGRID_CHOICE:
+                    // TODO: implement this
+                    //
+                    break;

 
 

-        if ( i < m_numCols ) colLeft += m_colWidths[i];
+                case wxGRID_COMBOBOX:
+                    // TODO: implement this
+                    //
+                    break;
+            }
+        }

     }
 }
 
 
     }
 }
 
 

-void wxGrid::DrawCells( wxDC& dc )
+void wxGrid::SaveEditControlValue()

 {
 {

-    if ( !m_numRows || !m_numCols ) return;
-    
-    int row, col;
-        
-    int cw, ch;
-    GetClientSize( &cw, &ch );
-    
-    wxRect rect;
-

     if ( m_table )
     {
     if ( m_table )
     {

-        rect.y = m_top + m_colLabelHeight;
-        for ( row = m_scrollPosY;  row < m_numRows;  row++ )
+        wxWindow *ctrl = (wxWindow *)NULL;
+
+        if ( IsCellEditControlEnabled() )
+        {
+            ctrl = m_cellEditCtrl;
+        }
+        else

         {
         {

-            if ( rect.y > ch ) break;
+            return;
+        }

 
 

-            rect.height = m_rowHeights[ row ];
-            rect.x = m_left + m_rowLabelWidth;
+        bool valueChanged = FALSE;

 
 

-            for ( col = m_scrollPosX;  col < m_numCols;  col++ )
-            {
-                if ( rect.x > cw ) break;
+        switch ( m_editCtrlType )
+        {
+            case wxGRID_TEXTCTRL:
+                valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
+                                ((wxGridTextCtrl *)ctrl)->GetStartValue());
+                SetCellValue( m_currentCellCoords,
+                              ((wxTextCtrl *) ctrl)->GetValue() );
+                break;

 
 

-                rect.width = m_colWidths[col];
-                DrawCellBackground( dc, rect, row, col );
-                DrawCellValue( dc, rect, row, col );
-                rect.x += rect.width;
-            }
-            rect.y += rect.height;
-        }
-    }
-}
+            case wxGRID_CHECKBOX:
+                // TODO: implement this
+                //
+                break;

 
 

+            case wxGRID_CHOICE:
+                // TODO: implement this
+                //
+                break;

 
 

-void wxGrid::DrawCellBackground( wxDC& dc, const wxRect& rect, int row, int col )
-{
-    wxRect rect2;
-    rect2 = rect;
-    rect2.x += 1;
-    rect2.y += 1;
-    rect2.width -= 2;
-    rect2.height -= 2;
-    
-    dc.SetBackgroundMode( wxSOLID );
-    
-    if ( IsInSelection( row, col ) )
-    {
-        // TODO: improve this
-        //
-        dc.SetBrush( *wxBLACK_BRUSH );
-    }
-    else
-    {
-        dc.SetBrush( wxBrush(GetCellBackgroundColour(row, col), wxSOLID) );
+            case wxGRID_COMBOBOX:
+                // TODO: implement this
+                //
+                break;
+        }
+
+        if ( valueChanged )
+        {
+            SendEvent( EVT_GRID_CELL_CHANGE,
+                       m_currentCellCoords.GetRow(),
+                       m_currentCellCoords.GetCol() );
+        }

     }
     }

-    dc.SetPen( *wxTRANSPARENT_PEN );
-    dc.DrawRectangle( rect2 );

 }
 
 
 }
 
 

-// This draws a text value in the given cell.  If useValueArg is FALSE
-// (the default) then the grid table value will be used

 //
 //

-void wxGrid::DrawCellValue( wxDC& dc, const wxRect& rect, int row, int col,
-                            const wxString& value, bool useValueArg )
-{
-    wxRect rect2;
-    rect2 = rect;
-    rect2.x += 3;
-    rect2.y += 2;
-    rect2.width -= 5;
-    rect2.height -= 4;
-    
-    dc.SetBackgroundMode( wxTRANSPARENT );
+// ------ Grid location functions
+//  Note that all of these functions work with the logical coordinates of
+//  grid cells and labels so you will need to convert from device
+//  coordinates for mouse events etc.
+//

 
 

-    if ( IsInSelection( row, col ) )
-    {
-        // TODO: improve this
-        //
-        dc.SetTextBackground( wxColour(0, 0, 0) );
-        dc.SetTextForeground( wxColour(255, 255, 255) );
-    }
-    else
-    {
-        dc.SetTextBackground( GetCellBackgroundColour(row, col) );
-        dc.SetTextForeground( GetCellTextColour(row, col) );
-    }
-    dc.SetFont( GetCellFont(row, col) );
-    
-    int hAlign, vAlign;
-    GetCellAlignment( row, col, &hAlign, &vAlign );
-    
-    if ( useValueArg )
+void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
+{
+    int row = YToRow(y);
+    int col = XToCol(x);
+
+    if ( row == -1  ||  col == -1 )

     {
     {

-        DrawTextRectangle( dc, value, rect2, hAlign, vAlign );
+        coords = wxGridNoCellCoords;

     }
     else
     {
     }
     else
     {

-        DrawTextRectangle( dc, GetCellValue( row, col ), rect2, hAlign, vAlign );
+        coords.Set( row, col );

     }
 }
 
 
     }
 }
 
 

-// this is used to echo text being entered into the top edit control when 
-// in-place editing is turned off
-//
-void wxGrid::DrawCellValue( const wxGridCellCoords& coords, const wxString& value )
+int wxGrid::YToRow( int y )

 {
 {

-    if ( IsVisible( coords ) )
-    {
-        int row = coords.GetRow();
-        int col = coords.GetCol();
-        wxRect rect;
-        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 ];
+    int i;

 
 

-        wxClientDC dc( this );
-        DrawCellBackground( dc, rect, row, col );
-        DrawCellValue( dc, rect, row, col, value, TRUE );
+    for ( i = 0;  i < m_numRows;  i++ )
+    {
+        if ( y < m_rowBottoms[i] ) return i;

     }
     }

+
+    return -1;

 }
 
 
 }
 
 

-void wxGrid::DrawCellHighlight( wxDC& dc, int row, int col )
+int wxGrid::XToCol( int x )

 {
 {

-    // TODO: bounds checking on row, col ?
-    //
+    int i;

 
 

-    if ( row >= m_scrollPosY  &&  col >= m_scrollPosX )
+    for ( i = 0;  i < m_numCols;  i++ )

     {
     {

-        long x, y;
-
-        int cw, ch;
-        GetClientSize( &cw, &ch );
-    
-        x = m_colRights[col] - m_colWidths[col];
-        if ( x >= cw ) return;
-        
-        y = m_rowBottoms[row] - m_rowHeights[row];
-        if ( y >= ch ) return;
-
-        dc.SetLogicalFunction( wxINVERT );
-        dc.SetPen( wxPen(GetCellHighlightColour(), 2, wxSOLID) );
-        dc.SetBrush( *wxTRANSPARENT_BRUSH );
-
-        dc.DrawRectangle( x-2, y-2,
-                          m_colWidths[col] + 6,
-                          m_rowHeights[row] + 6 );
-
-        dc.SetLogicalFunction( wxCOPY );
+        if ( x < m_colRights[i] ) return i;

     }
     }

+
+    return -1;

 }
 
 
 }
 
 

-// This function is handy when you just want to update one or a few
-// cells.  For example, it is used by SetCellValue()
+// return the row number that that the y coord is near the edge of, or
+// -1 if not near an edge

 //
 //

-void wxGrid::DrawCell( int row, int col )
+int wxGrid::YToEdgeOfRow( int y )

 {
 {

-    if ( !GetBatchCount() )
-    {
-        if ( !IsVisible( wxGridCellCoords(row, col) ) ) return;
-    
-        int cw, ch;
-        GetClientSize( &cw, &ch );
-    
-        wxRect rect( CellToRect( row, col ) );
+    int i, d;

 
 

-        if ( m_table )
+    for ( i = 0;  i < m_numRows;  i++ )
+    {
+        if ( m_rowHeights[i] > WXGRID_LABEL_EDGE_ZONE )

         {
         {

-            wxClientDC dc( this );
-            DrawCellBackground( dc, rect, row, col );
-            DrawCellValue( dc, rect, row, col );
+            d = abs( y - m_rowBottoms[i] );
+            {
+                if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
+            }

         }
     }
         }
     }

+
+    return -1;

 }
 
 
 }
 
 

-// this is just to make other code more obvious
+// return the col number that that the x coord is near the edge of, or
+// -1 if not near an edge

 //
 //

-void wxGrid::HideCurrentCellHighlight( wxDC& dc )
+int wxGrid::XToEdgeOfCol( int x )

 {
 {

-    if ( m_currentCellHighlighted  &&
-         m_currentCellCoords != wxGridNoCellCoords )
+    int i, d;
+
+    for ( i = 0;  i < m_numCols;  i++ )

     {
     {

-        DrawCellHighlight( dc, m_currentCellCoords );
-        m_currentCellHighlighted = FALSE;
+        if ( m_colWidths[i] > WXGRID_LABEL_EDGE_ZONE )
+        {
+            d = abs( x - m_colRights[i] );
+            {
+                if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
+            }
+        }

     }
     }

+
+    return -1;

 }
 
 
 }
 
 

-// this is just to make other code more obvious
-//
-void wxGrid::ShowCurrentCellHighlight( wxDC& dc )
+wxRect wxGrid::CellToRect( int row, int col )

 {
 {

-    if ( !m_currentCellHighlighted  &&
-         m_currentCellCoords != wxGridNoCellCoords )
+    wxRect rect( -1, -1, -1, -1 );
+
+    if ( row >= 0  &&  row < m_numRows  &&
+         col >= 0  &&  col < m_numCols )

     {
     {

-        DrawCellHighlight( dc, m_currentCellCoords );
-        m_currentCellHighlighted = TRUE;
+        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 ];

     }
     }

+
+    return rect;

 }
 
 
 }
 
 

-void wxGrid::DrawTextRectangle( wxDC& dc,
-                                const wxString& value,
-                                const wxRect& rect,
-                                int horizAlign,
-                                int vertAlign )
+bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )

 {
 {

-    long textWidth, textHeight;
-    long lineWidth, lineHeight;
-    wxArrayString lines;
-    
-    // see if we are already clipping
+    // get the cell rectangle in logical coords
+    //
+    wxRect r( CellToRect( row, col ) );
+
+    // convert to device coords

     //
     //

-    wxRect clipRect;
-    dc.GetClippingBox( clipRect );
+    int left, top, right, bottom;
+    CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
+    CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );

 
 

-    bool alreadyClipping = TRUE;
-    wxRect intersectRect;
+    // check against the client area of the grid window
+    //
+    int cw, ch;
+    m_gridWin->GetClientSize( &cw, &ch );

 
 

-    if ( clipRect.x == 0 && clipRect.y == 0 &&
-         clipRect.width == 0 && clipRect.height == 0)
+    if ( wholeCellVisible )

     {
     {

-        alreadyClipping = FALSE;
-        intersectRect = rect;
+        // is the cell wholly visible ?
+        //
+        return ( left >= 0  &&  right <= cw  &&
+                 top >= 0  &&  bottom <= ch );

     }
     else
     {
     }
     else
     {

-        // Find the intersection of the clipping rectangle and our
-        // rectangle
+        // is the cell partly visible ?

         //
         //

-        wxRegion region( rect );
-        region.Intersect( clipRect );
-        if ( region.IsEmpty() )
-        {
-            // nothing to do
-            //
-            return;
-        }
-        intersectRect = region.GetBox();
+        return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
+                 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );

     }
     }

+}

 
 

-    if ( alreadyClipping ) dc.DestroyClippingRegion();

 
 

-    dc.SetClippingRegion( intersectRect );
+// make the specified cell location visible by doing a minimal amount
+// of scrolling
+//
+void wxGrid::MakeCellVisible( int row, int col )
+{
+    int i;
+    int xpos = -1, ypos = -1;

 
 

-    StringToLines( value, lines );
-    if ( lines.GetCount() )
+    if ( row >= 0  &&  row < m_numRows  &&
+         col >= 0  &&  col < m_numCols )

     {
     {

-        GetTextBoxSize( dc, lines, &textWidth, &textHeight );
-        dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
-        
-        float x, y;
-        switch ( horizAlign )
-        {
-            case wxRIGHT:
-                x = rect.x + (rect.width - textWidth - 1.0);
-                break;
+        // get the cell rectangle in logical coords
+        //
+        wxRect r( CellToRect( row, col ) );

 
 

-            case wxCENTRE:
-                x = rect.x + ((rect.width - textWidth)/2.0);
-                break;
+        // convert to device coords
+        //
+        int left, top, right, bottom;
+        CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
+        CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );

 
 

-            case wxLEFT:
-            default:
-                x = rect.x + 1.0;
-                break;
-        }
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );

 
 

-        switch ( vertAlign )
+        if ( top < 0 )

         {
         {

-            case wxBOTTOM:
-                y = rect.y + (rect.height - textHeight - 1);
-                break;
-
-            case wxCENTRE:
-                y = rect.y + ((rect.height - textHeight)/2.0);
-                break;
-
-            case wxTOP:
-            default:
-                y = rect.y + 1.0;
-                break;
+            ypos = r.GetTop();

         }
         }

-
-        for ( size_t i = 0;  i < lines.GetCount();  i++ )
+        else if ( bottom > ch )

         {
         {

-            dc.DrawText( lines[i], (long)x, (long)y );
-            y += lineHeight;
-        }
-    }
-    
-    dc.DestroyClippingRegion();
-    if (alreadyClipping) dc.SetClippingRegion( clipRect );
-}
+            int h = r.GetHeight();
+            ypos = r.GetTop();
+            for ( i = row-1;  i >= 0;  i-- )
+            {
+                if ( h + m_rowHeights[i] > ch ) break;

 
 

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

 
 

-// Split multi line text up into an array of strings.  Any existing
-// contents of the string array are preserved.
-//
-void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
-{
-    // TODO: this won't work for WXMAC ? (lines end with '\r')
-    //       => use wxTextFile functions then (VZ)
-    int startPos = 0;
-    int pos;
-    while ( startPos < (int)value.Length() )
-    {
-        pos = value.Mid(startPos).Find( '\n' );
-        if ( pos < 0 )
-        {
-            break;
+            // we divide it later by GRID_SCROLL_LINE, make sure that we don't
+            // have rounding errors (this is important, because if we do, we
+            // might not scroll at all and some cells won't be redrawn)
+            ypos += GRID_SCROLL_LINE / 2;

         }
         }

-        else if ( pos == 0 )
+
+        if ( left < 0 )

         {
         {

-            lines.Add( wxEmptyString );
+            xpos = r.GetLeft();

         }
         }

-        else
+        else if ( right > cw )

         {
         {

-            if ( value[startPos+pos-1] == '\r' )
-            {
-                lines.Add( value.Mid(startPos, pos-1) );
-            }
-            else
+            int w = r.GetWidth();
+            xpos = r.GetLeft();
+            for ( i = col-1;  i >= 0;  i-- )

             {
             {

-                lines.Add( value.Mid(startPos, pos) );
-            }
-        }
-        startPos += pos+1;
-    }
-    if ( startPos < (int)value.Length() )
-    {
-        lines.Add( value.Mid( startPos ) );
-    }
-}
-
-
-void wxGrid::GetTextBoxSize( wxDC& dc,
-                             wxArrayString& lines,
-                             long *width, long *height )
-{
-    long w = 0;
-    long h = 0;
-    long lineW, lineH;
+                if ( w + m_colWidths[i] > cw ) break;

 
 

-    size_t i;
-    for ( i = 0;  i < lines.GetCount();  i++ )
-    {
-        dc.GetTextExtent( lines[i], &lineW, &lineH );
-        w = wxMax( w, lineW );
-        h += lineH;
-    }
+                w += m_colWidths[i];
+                xpos -= m_colWidths[i];
+            }

 
 

-    *width = w;
-    *height = h;
+            // see comment for ypos above
+            xpos += GRID_SCROLL_LINE / 2;
+        }
+
+        if ( xpos != -1  ||  ypos != -1 )
+        {
+            if ( xpos != -1 ) xpos /= GRID_SCROLL_LINE;
+            if ( ypos != -1 ) ypos /= GRID_SCROLL_LINE;
+            Scroll( xpos, ypos );
+            AdjustScrollbars();
+        }
+    }

 }
 
 
 //
 }
 
 
 //

-// ------ functions to get/send data (see also public functions)
+// ------ Grid cursor movement functions

 //
 
 //
 

-bool wxGrid::GetModelValues()
+bool wxGrid::MoveCursorUp()

 {
 {

-    if ( m_table )
+    if ( m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetRow() > 0 )

     {
     {

-        // all we need to do is repaint the grid
-        //
-        Refresh();
+        MakeCellVisible( m_currentCellCoords.GetRow() - 1,
+                        m_currentCellCoords.GetCol() );
+
+        SetCurrentCell( m_currentCellCoords.GetRow() - 1,
+                        m_currentCellCoords.GetCol() );
+

         return TRUE;
     }
 
         return TRUE;
     }
 


@@ -3385,338 +3963,346 @@ bool wxGrid::GetModelValues()
 }
 
 
 }
 
 

-bool wxGrid::SetModelValues()
+bool wxGrid::MoveCursorDown()

 {
 {

-    int row, col;
-    
-    if ( m_table )
+    // TODO: allow for scrolling
+    //
+    if ( m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetRow() < m_numRows-1 )

     {
     {

-        for ( row = m_scrollPosY;  row < m_numRows;  row++ )
-        {
-            for ( col = m_scrollPosX;  col < m_numCols;  col++ )
-            {
-                m_table->SetValue( row, col, GetCellValue(row, col) );
-            }
-        }
+        MakeCellVisible( m_currentCellCoords.GetRow() + 1,
+                        m_currentCellCoords.GetCol() );
+
+        SetCurrentCell( m_currentCellCoords.GetRow() + 1,
+                        m_currentCellCoords.GetCol() );

 
         return TRUE;
     }
 
         return TRUE;
     }

-    
+

     return FALSE;
 }
 
 
     return FALSE;
 }
 
 

-//
-// ------ public functions
-//
-
-bool wxGrid::CreateGrid( int numRows, int numCols )
+bool wxGrid::MoveCursorLeft()

 {
 {

-    if ( m_created )
-    {
-        wxLogError( wxT("wxGrid::CreateGrid(numRows, numCols) called more than once") );
-        return FALSE;
-    }
-    else
+    if ( m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetCol() > 0 )

     {
     {

-        m_numRows = numRows;
-        m_numCols = numCols;
-        
-        m_table = new wxGridStringTable( m_numRows, m_numCols );
-        m_table->SetView( this );
-        Init();
-        m_created = TRUE;
+        MakeCellVisible( m_currentCellCoords.GetRow(),
+                        m_currentCellCoords.GetCol() - 1 );
+
+        SetCurrentCell( m_currentCellCoords.GetRow(),
+                        m_currentCellCoords.GetCol() - 1 );
+
+        return TRUE;

     }
     }

-    
-    return m_created;
+
+    return FALSE;

 }
 
 
 }
 
 

-// The behaviour of this function depends on the grid table class
-// Clear() function.  For the default wxGridStringTable class the
-// behavious is to replace all cell contents with wxEmptyString but
-// not to change the number of rows or cols.
-//
-void wxGrid::ClearGrid()
+bool wxGrid::MoveCursorRight()

 {
 {

-    if ( m_table )
+    if ( m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetCol() < m_numCols - 1 )

     {
     {

-        m_table->Clear();
-        SetEditControlValue();
-        if ( !GetBatchCount() ) Refresh();
+        MakeCellVisible( m_currentCellCoords.GetRow(),
+                        m_currentCellCoords.GetCol() + 1 );
+
+        SetCurrentCell( m_currentCellCoords.GetRow(),
+                        m_currentCellCoords.GetCol() + 1 );
+
+        return TRUE;

     }
     }

+
+    return FALSE;

 }
 
 
 }
 
 

-bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
+bool wxGrid::MovePageUp()

 {
 {

-    // TODO: something with updateLabels flag
+    if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;

 
 

-    if ( !m_created )
-    {
-        wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
-        return FALSE;
-    }
-    
-    if ( m_table )
+    int row = m_currentCellCoords.GetRow();
+    if ( row > 0 )

     {
     {

-        bool ok = m_table->InsertRows( pos, numRows );
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );

 
 

-        // the table will have sent the results of the insert row
-        // operation to this view object as a grid table message
-        //
-        if ( ok )
+        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+        int newRow = YToRow( y - ch + 1 );
+        if ( newRow == -1 )

         {
         {

-            if ( m_numCols == 0 ) 
-            {
-                m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
-                //
-                // TODO: perhaps instead of appending the default number of cols
-                // we should remember what the last non-zero number of cols was ?
-                //
-            }
-            
-            if ( m_currentCellCoords == wxGridNoCellCoords )
-            {
-                // if we have just inserted cols into an empty grid the current
-                // cell will be undefined...
-                //
-                SelectCell( 0, 0 );  
-            }
-            
-            if ( !GetBatchCount() ) Refresh();
+            newRow = 0;
+        }
+        else if ( newRow == row )
+        {
+            newRow = row - 1;

         }
 
         }
 

-        SetEditControlValue();
-        return ok;
-    }
-    else
-    {
-        return FALSE;
+        MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
+        SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
+
+        return TRUE;

     }
     }

+
+    return FALSE;

 }
 
 }
 

-bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
+bool wxGrid::MovePageDown()

 {
 {

-    // TODO: something with updateLabels flag
-    
-    if ( !m_created )
+    if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
+
+    int row = m_currentCellCoords.GetRow();
+    if ( row < m_numRows )

     {
     {

-        wxLogError( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
-        return FALSE;
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );
+
+        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+        int newRow = YToRow( y + ch );
+        if ( newRow == -1 )
+        {
+            newRow = m_numRows - 1;
+        }
+        else if ( newRow == row )
+        {
+            newRow = row + 1;
+        }
+
+        MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
+        SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
+
+        return TRUE;

     }
     }

-    
-    if ( m_table && m_table->AppendRows( numRows ) )
+
+    return FALSE;
+}
+
+bool wxGrid::MoveCursorUpBlock()
+{
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetRow() > 0 )

     {
     {

-        if ( m_currentCellCoords == wxGridNoCellCoords )
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+
+        if ( m_table->IsEmptyCell(row, col) )

         {
         {

-            // if we have just inserted cols into an empty grid the current
-            // cell will be undefined...
+            // starting in an empty cell: find the next block of
+            // non-empty cells
+            //
+            while ( row > 0 )
+            {
+                row-- ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }
+        else if ( m_table->IsEmptyCell(row-1, col) )
+        {
+            // starting at the top of a block: find the next block

             //
             //

-            SelectCell( 0, 0 );  
+            row--;
+            while ( row > 0 )
+            {
+                row-- ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }

         }
         }

-        
-        // the table will have sent the results of the append row
-        // operation to this view object as a grid table message
-        //
-        if ( !GetBatchCount() ) Refresh();
+        else
+        {
+            // starting within a block: find the top of the block
+            //
+            while ( row > 0 )
+            {
+                row-- ;
+                if ( m_table->IsEmptyCell(row, col) )
+                {
+                    row++ ;
+                    break;
+                }
+            }
+        }
+
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );
+

         return TRUE;
     }
         return TRUE;
     }

-    else
-    {
-        return FALSE;
-    }
+
+    return FALSE;

 }
 
 }
 

-bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
+bool wxGrid::MoveCursorDownBlock()

 {
 {

-    // TODO: something with updateLabels flag
-
-    if ( !m_created )
-    {
-        wxLogError( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
-        return FALSE;
-    }
-    
-    if ( m_table && m_table->DeleteRows( pos, numRows ) )
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetRow() < m_numRows-1 )

     {
     {

-        // 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();
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+
+        if ( m_table->IsEmptyCell(row, col) )
+        {
+            // starting in an empty cell: find the next block of
+            // non-empty cells
+            //
+            while ( row < m_numRows-1 )
+            {
+                row++ ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }
+        else if ( m_table->IsEmptyCell(row+1, col) )
+        {
+            // starting at the bottom of a block: find the next block
+            //
+            row++;
+            while ( row < m_numRows-1 )
+            {
+                row++ ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }

         else
         else

-            HideCellEditControl();
-        
-        if ( !GetBatchCount() ) Refresh();
+        {
+            // starting within a block: find the bottom of the block
+            //
+            while ( row < m_numRows-1 )
+            {
+                row++ ;
+                if ( m_table->IsEmptyCell(row, col) )
+                {
+                    row-- ;
+                    break;
+                }
+            }
+        }
+
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );
+

         return TRUE;
     }
         return TRUE;
     }

-    else
-    {
-        return FALSE;
-    }
+
+    return FALSE;

 }
 
 }
 

-bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
+bool wxGrid::MoveCursorLeftBlock()

 {
 {

-    // TODO: something with updateLabels flag
-    
-    if ( !m_created )
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetCol() > 0 )

     {
     {

-        wxLogError( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
-        return FALSE;
-    }
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();

 
 

-    if ( m_table )
-    {
-        HideCellEditControl();
-        bool ok = m_table->InsertCols( pos, numCols );
-            
-        // the table will have sent the results of the insert col
-        // operation to this view object as a grid table message
-        //
-        if ( ok )
+        if ( m_table->IsEmptyCell(row, col) )

         {
         {

-            if ( m_currentCellCoords == wxGridNoCellCoords )
+            // starting in an empty cell: find the next block of
+            // non-empty cells
+            //
+            while ( col > 0 )

             {
             {

-                // if we have just inserted cols into an empty grid the current
-                // cell will be undefined...
-                //
-                SelectCell( 0, 0 );  
+                col-- ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;

             }
             }

-
-            if ( !GetBatchCount() ) Refresh();

         }
         }

-        
-        SetEditControlValue();
-        return ok;
-    }
-    else
-    {
-        return FALSE;
-    }
-}
-
-bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
-{
-    // TODO: something with updateLabels flag
-
-    if ( !m_created )
-    {
-       wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
-       return FALSE;
-    }
-
-    if ( m_table && m_table->AppendCols( numCols ) )
-    {
-       // the table will have sent the results of the append col
-       // operation to this view object as a grid table message
-       //
-        if ( m_currentCellCoords == wxGridNoCellCoords )
+        else if ( m_table->IsEmptyCell(row, col-1) )

         {
         {

-            // if we have just inserted cols into an empty grid the current
-            // cell will be undefined...
+            // starting at the left of a block: find the next block

             //
             //

-            SelectCell( 0, 0 );  
+            col--;
+            while ( col > 0 )
+            {
+                col-- ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }

         }
         }

-       if ( !GetBatchCount() ) Refresh();
-       return TRUE;
-    }
-    else
-    {
-       return FALSE;
-    }
-}
-
-bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
-{
-    // TODO: something with updateLabels flag
-    
-    if ( !m_created )
-    {
-        wxLogError( 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
         else

-            HideCellEditControl();
-        
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
-}
-    
-
-
+        {
+            // starting within a block: find the left of the block
+            //
+            while ( col > 0 )
+            {
+                col-- ;
+                if ( m_table->IsEmptyCell(row, col) )
+                {
+                    col++ ;
+                    break;
+                }
+            }
+        }

 
 

-// ------ control panel and cell edit control
-//
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );

 
 

-void wxGrid::EnableEditing( bool edit )
-{
-    // TODO: improve this ?
-    //
-    if ( edit != m_editable )
-    {
-        m_editable = edit;
-        if ( !m_editable ) HideCellEditControl();
-        m_topEditCtrlEnabled = m_editable;
-        m_cellEditCtrlEnabled = m_editable;
-        if ( !m_editable ) ShowCellEditControl();            
+        return TRUE;

     }
     }

-}

 
 

+    return FALSE;
+}

 
 

-void wxGrid::EnableTopEditControl( bool enable )
+bool wxGrid::MoveCursorRightBlock()

 {
 {

-    if ( enable != m_topEditCtrlEnabled )
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetCol() < m_numCols-1 )

     {
     {

-        HideCellEditControl();
-        m_topEditCtrlEnabled = enable;
-        CalcDimensions();
-        m_topEditCtrl->Show( enable );
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();

 
 

-        if ( m_currentCellCoords != wxGridNoCellCoords )
-          SetEditControlValue();
-          
-        ShowCellEditControl();
-        if ( !GetBatchCount() ) Refresh();
-    }
-}
+        if ( m_table->IsEmptyCell(row, col) )
+        {
+            // starting in an empty cell: find the next block of
+            // non-empty cells
+            //
+            while ( col < m_numCols-1 )
+            {
+                col++ ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }
+        else if ( m_table->IsEmptyCell(row, col+1) )
+        {
+            // starting at the right of a block: find the next block
+            //
+            col++;
+            while ( col < m_numCols-1 )
+            {
+                col++ ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }
+        else
+        {
+            // starting within a block: find the right of the block
+            //
+            while ( col < m_numCols-1 )
+            {
+                col++ ;
+                if ( m_table->IsEmptyCell(row, col) )
+                {
+                    col-- ;
+                    break;
+                }
+            }
+        }

 
 

-void wxGrid::EnableCellEditControl( bool enable )
-{
-    if ( m_cellEditCtrl &&
-         enable != m_cellEditCtrlEnabled )
-    {
-        wxClientDC dc( this );
-        
-        HideCurrentCellHighlight( dc );
-        HideCellEditControl();
-        SaveEditControlValue();
-        
-        m_cellEditCtrlEnabled = enable;
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );

 
 

-        SetEditControlValue();
-        ShowCellEditControl();
-        ShowCurrentCellHighlight( dc );
+        return TRUE;

     }
     }

+
+    return FALSE;

 }
 
 
 }
 
 

+

 //
 //

-// ------ grid formatting functions
+// ------ Label values and formatting

 //
 
 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
 //
 
 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )


@@ -3759,38 +4345,92 @@ wxString wxGrid::GetColLabelValue( int col )
     }
 }
 
     }
 }
 

+

 void wxGrid::SetRowLabelSize( int width )
 {
 void wxGrid::SetRowLabelSize( int width )
 {

-    m_rowLabelWidth = wxMax( 0, width );
-    CalcDimensions();
-    ShowCellEditControl();
-    if ( !GetBatchCount() ) Refresh();
+    width = wxMax( width, 0 );
+    if ( width != m_rowLabelWidth )
+    {
+        if ( width == 0 )
+        {
+            m_rowLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_rowLabelWidth == 0 )
+        {
+            m_rowLabelWin->Show( TRUE );
+            if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+
+        m_rowLabelWidth = width;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }

 }
 
 }
 

+

 void wxGrid::SetColLabelSize( int height )
 {
 void wxGrid::SetColLabelSize( int height )
 {

-    m_colLabelHeight = wxMax( 0, height );
-    CalcDimensions();
-    ShowCellEditControl();
-    if ( !GetBatchCount() ) Refresh();
+    height = wxMax( height, 0 );
+    if ( height != m_colLabelHeight )
+    {
+        if ( height == 0 )
+        {
+            m_colLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_colLabelHeight == 0 )
+        {
+            m_colLabelWin->Show( TRUE );
+            if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+
+        m_colLabelHeight = height;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }

 }
 
 }
 

+

 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
 {
 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
 {

-    m_labelBackgroundColour = colour;
-    if ( !GetBatchCount() ) Refresh();
+    if ( m_labelBackgroundColour != colour )
+    {
+        m_labelBackgroundColour = colour;
+        m_rowLabelWin->SetBackgroundColour( colour );
+        m_colLabelWin->SetBackgroundColour( colour );
+        m_cornerLabelWin->SetBackgroundColour( colour );
+
+        if ( !GetBatchCount() )
+        {
+            m_rowLabelWin->Refresh();
+            m_colLabelWin->Refresh();
+            m_cornerLabelWin->Refresh();
+        }
+    }

 }
 
 void wxGrid::SetLabelTextColour( const wxColour& colour )
 {
 }
 
 void wxGrid::SetLabelTextColour( const wxColour& colour )
 {

-    m_labelTextColour = colour;
-    if ( !GetBatchCount() ) Refresh();
+    if ( m_labelTextColour != colour )
+    {
+        m_labelTextColour = colour;
+        if ( !GetBatchCount() )
+        {
+            m_rowLabelWin->Refresh();
+            m_colLabelWin->Refresh();
+        }
+    }

 }
 
 void wxGrid::SetLabelFont( const wxFont& font )
 {
     m_labelFont = font;
 }
 
 void wxGrid::SetLabelFont( const wxFont& font )
 {
     m_labelFont = font;

-    if ( !GetBatchCount() ) Refresh();
+    if ( !GetBatchCount() )
+    {
+        m_rowLabelWin->Refresh();
+        m_colLabelWin->Refresh();
+    }

 }
 
 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
 }
 
 void wxGrid::SetRowLabelAlignment( int horiz, int vert )


@@ -3799,13 +4439,16 @@ void wxGrid::SetRowLabelAlignment( int horiz, int vert )
     {
         m_rowLabelHorizAlign = horiz;
     }
     {
         m_rowLabelHorizAlign = horiz;
     }

-    
+

     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
     {
         m_rowLabelVertAlign = vert;
     }
 
     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
     {
         m_rowLabelVertAlign = vert;
     }
 

-    if ( !GetBatchCount() ) Refresh();
+    if ( !GetBatchCount() )
+    {
+        m_rowLabelWin->Refresh();
+    }

 }
 
 void wxGrid::SetColLabelAlignment( int horiz, int vert )
 }
 
 void wxGrid::SetColLabelAlignment( int horiz, int vert )


@@ -3814,13 +4457,16 @@ void wxGrid::SetColLabelAlignment( int horiz, int vert )
     {
         m_colLabelHorizAlign = horiz;
     }
     {
         m_colLabelHorizAlign = horiz;
     }

-    
+

     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
     {
         m_colLabelVertAlign = vert;
     }
 
     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
     {
         m_colLabelVertAlign = vert;
     }
 

-    if ( !GetBatchCount() ) Refresh();
+    if ( !GetBatchCount() )
+    {
+        m_colLabelWin->Refresh();
+    }

 }
 
 void wxGrid::SetRowLabelValue( int row, const wxString& s )
 }
 
 void wxGrid::SetRowLabelValue( int row, const wxString& s )


@@ -3828,7 +4474,17 @@ void wxGrid::SetRowLabelValue( int row, const wxString& s )
     if ( m_table )
     {
         m_table->SetRowLabelValue( row, s );
     if ( m_table )
     {
         m_table->SetRowLabelValue( row, s );

-        if ( !GetBatchCount() ) Refresh();
+        if ( !GetBatchCount() )
+        {
+            wxRect rect = CellToRect( row, 0);
+            if ( rect.height > 0 )
+            {
+                CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
+                rect.x = m_left;
+                rect.width = m_rowLabelWidth;
+                m_rowLabelWin->Refresh( TRUE, &rect );
+            }
+        }

     }
 }
 
     }
 }
 


@@ -3837,16 +4493,30 @@ void wxGrid::SetColLabelValue( int col, const wxString& s )
     if ( m_table )
     {
         m_table->SetColLabelValue( col, s );
     if ( m_table )
     {
         m_table->SetColLabelValue( col, s );

-        if ( !GetBatchCount() ) Refresh();
+        if ( !GetBatchCount() )
+        {
+            wxRect rect = CellToRect( 0, col );
+            if ( rect.width > 0 )
+            {
+                CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
+                rect.y = m_top;
+                rect.height = m_colLabelHeight;
+                m_colLabelWin->Refresh( TRUE, &rect );
+            }
+        }

     }
 }
 
 void wxGrid::SetGridLineColour( const wxColour& colour )
 {
     }
 }
 
 void wxGrid::SetGridLineColour( const wxColour& colour )
 {

-    m_gridLineColour = colour;
-    
-    wxClientDC dc( this );
-    DrawGridLines( dc );
+    if ( m_gridLineColour != colour )
+    {
+        m_gridLineColour = colour;
+
+        wxClientDC dc( m_gridWin );
+        PrepareDC( dc );
+        DrawAllGridLines( dc, wxRegion() );
+    }

 }
 
 void wxGrid::EnableGridLines( bool enable )
 }
 
 void wxGrid::EnableGridLines( bool enable )


@@ -3854,7 +4524,20 @@ void wxGrid::EnableGridLines( bool enable )
     if ( enable != m_gridLinesEnabled )
     {
         m_gridLinesEnabled = enable;
     if ( enable != m_gridLinesEnabled )
     {
         m_gridLinesEnabled = enable;

-        if ( !GetBatchCount() ) Refresh();
+
+        if ( !GetBatchCount() )
+        {
+            if ( enable )
+            {
+                wxClientDC dc( m_gridWin );
+                PrepareDC( dc );
+                DrawAllGridLines( dc, wxRegion() );
+            }
+            else
+            {
+                m_gridWin->Refresh();
+            }
+        }

     }
 }
 
     }
 }
 


@@ -3866,10 +4549,9 @@ int wxGrid::GetDefaultRowSize()
 
 int wxGrid::GetRowSize( int row )
 {
 
 int wxGrid::GetRowSize( int row )
 {

-    if ( row >= 0  &&  row < m_numRows )
-        return m_rowHeights[row];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
+
+    return m_rowHeights[row];

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


@@ -3879,46 +4561,51 @@ int wxGrid::GetDefaultColSize()
 
 int wxGrid::GetColSize( int col )
 {
 
 int wxGrid::GetColSize( int col )
 {

-    if ( col >= 0  &&  col < m_numCols )
-        return m_colWidths[col];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
+
+    return m_colWidths[col];

 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {
 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {

-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );
+    return m_gridWin->GetBackgroundColour();

 }
 
 }
 

-wxColour wxGrid::GetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col) )
+// TODO VZ: this must be optimized to allow only retrieveing attr once!
+
+wxColour wxGrid::GetCellBackgroundColour(int row, int col)

 {
 {

-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );    
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxColour colour;
+    if ( attr && attr->HasBackgroundColour() )
+        colour = attr->GetBackgroundColour();
+    else
+        colour = GetDefaultCellBackgroundColour();
+
+    delete attr;
+
+    return colour;

 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {

-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );    
+    return m_gridWin->GetForegroundColour();

 }
 
 }
 

-wxColour wxGrid::GetCellTextColour( int WXUNUSED(row), int WXUNUSED(col) )
+wxColour wxGrid::GetCellTextColour( int row, int col )

 {
 {

-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );    
-}
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;

 
 

+    wxColour colour;
+    if ( attr && attr->HasTextColour() )
+        colour = attr->GetTextColour();
+    else
+        colour = GetDefaultCellTextColour();

 
 

-wxColour wxGrid::GetCellHighlightColour()
-{
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );    
+    delete attr;
+
+    return colour;

 }
 
 
 }
 
 


@@ -3927,27 +4614,39 @@ wxFont wxGrid::GetDefaultCellFont()
     return m_defaultCellFont;
 }
 
     return m_defaultCellFont;
 }
 

-wxFont wxGrid::GetCellFont( int WXUNUSED(row), int WXUNUSED(col) )
+wxFont wxGrid::GetCellFont( int row, int col )

 {
 {

-    // TODO: replace this temp test code
-    //
-    return m_defaultCellFont;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxFont font;
+    if ( attr && attr->HasFont() )
+        font = attr->GetFont();
+    else
+        font = GetDefaultCellFont();
+
+    delete attr;
+
+    return font;

 }
 
 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
 {
 }
 
 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
 {

-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    if ( horiz )
+        *horiz = m_defaultCellHAlign;
+    if ( vert )
+        *vert = m_defaultCellVAlign;

 }
 
 }
 

-void wxGrid::GetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int *horiz, int *vert )
+void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )

 {
 {

-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    if ( attr && attr->HasAlignment() )
+        attr->GetAlignment(horiz, vert);
+    else
+        GetDefaultCellAlignment(horiz, vert);
+
+    delete attr;

 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )


@@ -3956,40 +4655,33 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
     if ( resizeExistingRows )
     {
 
     if ( resizeExistingRows )
     {

-        // TODO: what do we do about events here ?
-        // Generate an event for each resize ?
-        //

         int row;
         int row;

+        int bottom = 0;

         for ( row = 0;  row < m_numRows;  row++ )
         {
             m_rowHeights[row] = m_defaultRowHeight;
         for ( row = 0;  row < m_numRows;  row++ )
         {
             m_rowHeights[row] = m_defaultRowHeight;

+            bottom += m_defaultRowHeight;
+            m_rowBottoms[row] = bottom;

         }
         }

-        m_sumRowHeights = m_defaultRowHeight * m_numRows;

         CalcDimensions();
         CalcDimensions();

-        if ( !GetBatchCount() ) Refresh();

     }
 }
 
 void wxGrid::SetRowSize( int row, int height )
 {
     }
 }
 
 void wxGrid::SetRowSize( int row, int height )
 {

-    if ( row >= 0  &&  row < m_numRows )
-    {
-        m_sumRowHeights -= m_rowHeights[row];
-        m_rowHeights[row] = wxMax( 0, height );
-        m_sumRowHeights += m_rowHeights[row];
-        CalcDimensions();
-        if ( !GetBatchCount() ) Refresh();
+    wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );

 
 

-        // Note: we are ending the event *after* doing
-        // default processing in this case
-        //
-        SendEvent( EVT_GRID_ROW_SIZE,
-                   row, -1 );
-    }
-    else
+    int i;
+
+    int h = wxMax( 0, height );
+    int diff = h - m_rowHeights[row];
+
+    m_rowHeights[row] = h;
+    for ( i = row;  i < m_numRows;  i++ )

     {
     {

-        // TODO: log an error here
+        m_rowBottoms[i] += diff;

     }
     }

+    CalcDimensions();

 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )


@@ -3998,97 +4690,120 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
     if ( resizeExistingCols )
     {
 
     if ( resizeExistingCols )
     {

-        // TODO: what do we do about events here ?
-        // Generate an event for each resize ?
-        //

         int col;
         int col;

+        int right = 0;

         for ( col = 0;  col < m_numCols;  col++ )
         {
             m_colWidths[col] = m_defaultColWidth;
         for ( col = 0;  col < m_numCols;  col++ )
         {
             m_colWidths[col] = m_defaultColWidth;

+            right += m_defaultColWidth;
+            m_colRights[col] = right;

         }
         }

-        m_sumColWidths = m_defaultColWidth * m_numCols;

         CalcDimensions();
         CalcDimensions();

-        if ( !GetBatchCount() ) Refresh();

     }
 }
 
 void wxGrid::SetColSize( int col, int width )
 {
     }
 }
 
 void wxGrid::SetColSize( int col, int width )
 {

-    if ( col >= 0  &&  col < m_numCols )
-    {
-        m_sumColWidths -= m_colWidths[col];
-        m_colWidths[col] = wxMax( 0, width );
-        m_sumColWidths += m_colWidths[col];
-        CalcDimensions();
-        if ( !GetBatchCount() ) Refresh();
+    wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );

 
 

-        // Note: we are ending the event *after* doing
-        // default processing in this case
-        //
-        SendEvent( EVT_GRID_COL_SIZE,
-                   -1, col );
-    }
-    else
+    int i;
+
+    int w = wxMax( 0, width );
+    int diff = w - m_colWidths[col];
+    m_colWidths[col] = w;
+
+    for ( i = col;  i < m_numCols;  i++ )

     {
     {

-        // TODO: log an error here
+        m_colRights[i] += diff;

     }
     }

+    CalcDimensions();

 }
 
 }
 

-void wxGrid::SetDefaultCellBackgroundColour( const wxColour& )
+void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )

 {
 {

-    // TODO: everything !!!
-    //
+    m_gridWin->SetBackgroundColour(col);

 }
 
 }
 

-void wxGrid::SetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+void wxGrid::SetDefaultCellTextColour( const wxColour& col )

 {
 {

-    // TODO: everything !!!
-    //
+    m_gridWin->SetForegroundColour(col);

 }
 
 }
 

-void wxGrid::SetDefaultCellTextColour( const wxColour& )
+void wxGrid::SetDefaultCellAlignment( int horiz, int vert )

 {
 {

-    // TODO: everything !!!
-    //
+    m_defaultCellHAlign = horiz;
+    m_defaultCellVAlign = vert;

 }
 
 }
 

-void wxGrid::SetCellTextColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+bool wxGrid::CanHaveAttributes()

 {
 {

-    // TODO: everything !!!
-    //
+    if ( !m_table )
+    {
+        return FALSE;
+    }
+
+    if ( !m_table->GetAttrProvider() )
+    {
+        // use the default attr provider by default
+        // (another choice would be to just return FALSE thus forcing the user
+        // to it himself)
+        m_table->SetAttrProvider(new wxGridCellAttrProvider);
+    }
+
+    return TRUE;

 }
 
 }
 

-void wxGrid::SetCellHighlightColour( const wxColour& )
+void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )

 {
 {

-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetBackgroundColour(colour);
+
+        m_table->SetAttr(attr, row, col);
+    }

 }
 
 }
 

-void wxGrid::SetDefaultCellFont( const wxFont& )
+void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )

 {
 {

-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetTextColour(colour);
+
+        m_table->SetAttr(attr, row, col);
+    }

 }
 
 }
 

-void wxGrid::SetCellFont( int WXUNUSED(row), int WXUNUSED(col), const wxFont& )
+void wxGrid::SetDefaultCellFont( const wxFont& font )

 {
 {

-    // TODO: everything !!!
-    //
+    m_defaultCellFont = font;

 }
 
 }
 

-void wxGrid::SetDefaultCellAlignment( int WXUNUSED(horiz), int WXUNUSED(vert) )
+void wxGrid::SetCellFont( int row, int col, const wxFont& font )

 {
 {

-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetFont(font);
+
+        m_table->SetAttr(attr, row, col);
+    }

 }
 
 }
 

-void wxGrid::SetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int WXUNUSED(horiz), int WXUNUSED(vert) )
+void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )

 {
 {

-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetAlignment(horiz, vert);
+
+        m_table->SetAttr(attr, row, col);
+    }

 }
 
 
 }
 
 

+

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


@@ -4098,171 +4813,99 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
     if ( m_table )
     {
         m_table->SetValue( row, col, s.c_str() );
     if ( m_table )
     {
         m_table->SetValue( row, col, s.c_str() );

-        DrawCell( row, col );
+        if ( !GetBatchCount() )
+        {
+            wxClientDC dc( m_gridWin );
+            PrepareDC( dc );
+            DrawCell( dc, wxGridCellCoords(row, col) );
+        }
+
+#if 0  // TODO: edit in place
+

         if ( m_currentCellCoords.GetRow() == row &&
              m_currentCellCoords.GetCol() == col )
         {
             SetEditControlValue( s );
         }
         if ( m_currentCellCoords.GetRow() == row &&
              m_currentCellCoords.GetCol() == col )
         {
             SetEditControlValue( s );
         }

-    }
-}    
-
-
-
-//
-// ------ interaction with data model
-//
-bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
-{
-    switch ( msg.GetId() )
-    {
-        case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
-            return GetModelValues();
-
-        case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
-            return SetModelValues();
-
-        case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
-        case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
-        case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
-        case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
-        case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
-        case wxGRIDTABLE_NOTIFY_COLS_DELETED:
-            return Redimension( msg );
+#endif

 
 

-        default:
-            return FALSE;

     }
 }
 
 
 //
     }
 }
 
 
 //

-// ------ Grid location functions
+// ------ Block, row and col selection

 //
 //

-//  (see also inline functions in grid.h)
-

 
 

-// check to see if a cell location is wholly visible
-//
-bool wxGrid::IsVisible( const wxGridCellCoords& coords )
+void wxGrid::SelectRow( int row, bool addToSelected )

 {
 {

-    return ( coords.GetRow() >= m_scrollPosY  &&
-             coords.GetRow() < m_scrollPosY + m_wholeRowsVisible  &&
-             coords.GetCol() >= m_scrollPosX  &&
-             coords.GetCol() < m_scrollPosX + m_wholeColsVisible );
-}
-
+    wxRect r;

 
 

-// make the specified cell location visible by doing a minimal amount
-// of scrolling
-//
-void wxGrid::MakeCellVisible( int row, int col )
-{
-    int lastX = m_scrollPosX;
-    int lastY = m_scrollPosY;
-    
-    if ( row >= 0  &&  row < m_numRows  &&
-         col >= 0  &&  col < m_numCols )
+    if ( IsSelection() && addToSelected )

     {
     {

-        if ( row < m_scrollPosY )
-        {
-            SetVerticalScrollPos( row );
-        }
-        else if ( row >= m_scrollPosY + m_wholeRowsVisible )
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        if ( oldTop > row )

         {
         {

-            int i;
-            int h = m_rowBottoms[row];
-            for ( i = m_scrollPosY; i < m_numRows && h > m_bottom; i++ )
-            {
-                h -= m_rowHeights[i];
-            }
-            SetVerticalScrollPos( i );
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( row, 0 ),
+                                         wxGridCellCoords ( oldTop - 1,
+                                                            m_numCols - 1 ) );
+            m_selectedTopLeft.SetRow( row );

         }
 
         }
 

-        if ( col < m_scrollPosX )
+        if ( oldLeft > 0 )

         {
         {

-            SetHorizontalScrollPos( col );
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop, 0 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            oldLeft - 1 ) );
+
+            m_selectedTopLeft.SetCol( 0 );

         }
         }

-        else if ( col >= m_scrollPosX + m_wholeColsVisible )
+
+        if ( oldBottom < row )

         {
         {

-            int i;
-            int w = m_colRights[col];
-            for ( i = m_scrollPosX; i < m_numCols && w > m_right; i++ )
-            {
-                w -= m_colWidths[i];
-            }
-            SetHorizontalScrollPos( i );
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1, 0 ),
+                                         wxGridCellCoords ( row,
+                                                            m_numCols - 1 ) );
+            m_selectedBottomRight.SetRow( row );

         }
 
         }
 

-        if ( m_scrollPosX != lastX  ||  m_scrollPosY != lastY )
+        if ( oldRight < m_numCols - 1 )

         {
         {

-            // The cell was not visible before but not it is
-            //
-            ShowCellEditControl();
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldTop ,
+                                                            oldRight + 1 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            m_numCols - 1 ) );
+            m_selectedBottomRight.SetCol( m_numCols - 1 );

         }
         }

-    }
-    else
-    {
-        // TODO: log an error
-    }
-}
-
-
-void wxGrid::SetVerticalScrollPos( int topMostRow )
-{
-    if ( m_vertScrollBar && topMostRow != m_scrollPosY )
-    {
-        m_scrollPosY = topMostRow;
-
-        CalcDimensions();
-        Refresh();
-    }
-}
-
-
-void wxGrid::SetHorizontalScrollPos( int leftMostCol )
-{
-    if ( m_horizScrollBar && leftMostCol != m_scrollPosX )
-    {
-        m_scrollPosX = leftMostCol;
-
-        CalcDimensions();
-        Refresh();
-    }
-}
-
-
-//
-// ------ block, row and col selection
-//

 
 

-void wxGrid::SelectRow( int row, bool addToSelected )
-{
-    if ( IsSelection() && addToSelected )
-    {
-        if ( m_selectedTopLeft.GetRow() > row )
-            m_selectedTopLeft.SetRow( row );
-        
-        m_selectedTopLeft.SetCol( 0 );
-        
-        if ( m_selectedBottomRight.GetRow() < row )
-            m_selectedBottomRight.SetRow( row );
-        
-        m_selectedBottomRight.SetCol( m_numCols - 1 );
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
     else
     {
     }
     else
     {

+        r = SelectionToDeviceRect();

         ClearSelection();
         ClearSelection();

+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
+

         m_selectedTopLeft.Set( row, 0 );
         m_selectedBottomRight.Set( row, m_numCols-1 );
         m_selectedTopLeft.Set( row, 0 );
         m_selectedBottomRight.Set( row, m_numCols-1 );

+        r = SelectionToDeviceRect();
+        m_gridWin->Refresh( FALSE, &r );

     }
 
     }
 

-    if ( !GetBatchCount() )
-    {
-        wxRect rect( SelectionToRect() );
-        if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
-    }
-    

     wxGridRangeSelectEvent gridEvt( GetId(),
                                     EVT_GRID_RANGE_SELECT,
                                     this,
     wxGridRangeSelectEvent gridEvt( GetId(),
                                     EVT_GRID_RANGE_SELECT,
                                     this,


@@ -4275,29 +4918,70 @@ void wxGrid::SelectRow( int row, bool addToSelected )
 
 void wxGrid::SelectCol( int col, bool addToSelected )
 {
 
 void wxGrid::SelectCol( int col, bool addToSelected )
 {

-    if ( addToSelected && m_selectedTopLeft != wxGridNoCellCoords )
+    if ( IsSelection() && addToSelected )

     {
     {

-        if ( m_selectedTopLeft.GetCol() > col )
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        if ( oldLeft > col )
+        {
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
+                                         wxGridCellCoords ( m_numRows - 1,
+                                                            oldLeft - 1 ) );

             m_selectedTopLeft.SetCol( col );
             m_selectedTopLeft.SetCol( col );

+        }

 
 

-        m_selectedTopLeft.SetRow( 0 );
+        if ( oldTop  > 0 )
+        {
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
+                                         wxGridCellCoords ( oldTop - 1,
+                                                            oldRight ) );
+            m_selectedTopLeft.SetRow( 0 );
+        }

 
 

-        if ( m_selectedBottomRight.GetCol() < col )
+        if ( oldRight < col )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( 0, oldRight + 1 ),
+                                         wxGridCellCoords ( m_numRows - 1,
+                                                            col            ) );

             m_selectedBottomRight.SetCol( col );
             m_selectedBottomRight.SetCol( col );

+        }

 
 

-        m_selectedBottomRight.SetRow( m_numRows - 1 );
+        if ( oldBottom < m_numRows - 1 )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1,
+                                                            oldLeft ),
+                                         wxGridCellCoords ( m_numRows - 1,
+                                                            oldRight ) );
+            m_selectedBottomRight.SetRow( m_numRows - 1 );
+        }
+
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
     else
     {
     }
     else
     {

+        wxRect r;
+
+        r = SelectionToDeviceRect();

         ClearSelection();
         ClearSelection();

+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
+

         m_selectedTopLeft.Set( 0, col );
         m_selectedBottomRight.Set( m_numRows-1, col );
         m_selectedTopLeft.Set( 0, col );
         m_selectedBottomRight.Set( m_numRows-1, col );

-    }
-
-    if ( !GetBatchCount() )
-    {
-        wxRect rect( SelectionToRect() );
-        if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
+        r = SelectionToDeviceRect();
+        m_gridWin->Refresh( FALSE, &r );

     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),


@@ -4313,7 +4997,8 @@ void wxGrid::SelectCol( int col, bool addToSelected )
 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
 {
     int temp;
 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
 {
     int temp;

-    
+    wxGridCellCoords updateTopLeft, updateBottomRight;
+

     if ( topRow > bottomRow )
     {
         temp = topRow;
     if ( topRow > bottomRow )
     {
         temp = topRow;


@@ -4328,18 +5013,105 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
         rightCol = temp;
     }
 
         rightCol = temp;
     }
 

-    m_selectedTopLeft.Set( topRow, leftCol );
-    m_selectedBottomRight.Set( bottomRow, rightCol );
+    updateTopLeft = wxGridCellCoords( topRow, leftCol );
+    updateBottomRight = wxGridCellCoords( bottomRow, rightCol );

 
 

-    if ( !GetBatchCount() )
+    if ( m_selectedTopLeft != updateTopLeft ||
+         m_selectedBottomRight != updateBottomRight )

     {
     {

-        wxRect rect( SelectionToRect() );
-        if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
+        // Compute two optimal update rectangles:
+        // Either one rectangle is a real subset of the
+        // other, or they are (almost) disjoint!
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        // Store intermediate values
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        // Determine the outer/inner coordinates.
+        if (oldLeft > leftCol)
+        {
+            temp = oldLeft;
+            oldLeft = leftCol;
+            leftCol = temp;
+        }
+        if (oldTop > topRow )
+        {
+            temp = oldTop;
+            oldTop = topRow;
+            topRow = temp;
+        }
+        if (oldRight < rightCol )
+        {
+            temp = oldRight;
+            oldRight = rightCol;
+            rightCol = temp;
+        }
+        if (oldBottom < bottomRow)
+        {
+            temp = oldBottom;
+            oldBottom = bottomRow;
+            bottomRow = temp;
+        }
+
+        // Now, either the stuff marked old is the outer
+        // rectangle or we don't have a situation where one
+        // is contained in the other.
+
+        if ( oldLeft < leftCol )
+        {
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            oldLeft ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            leftCol - 1 ) );
+        }
+
+        if ( oldTop  < topRow )
+        {
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            leftCol ),
+                                         wxGridCellCoords ( topRow - 1,
+                                                            rightCol ) );
+        }
+
+        if ( oldRight > rightCol )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            rightCol + 1 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            oldRight ) );
+        }
+
+        if ( oldBottom > bottomRow )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
+                                                            leftCol ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            rightCol ) );
+        }
+
+
+        // Change Selection
+        m_selectedTopLeft = updateTopLeft;
+        m_selectedBottomRight = updateBottomRight;
+
+        // various Refresh() calls
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
 
     // only generate an event if the block is not being selected by
     // dragging the mouse (in which case the event will be generated in
     }
 
     // only generate an event if the block is not being selected by
     // dragging the mouse (in which case the event will be generated in

-    // OnMouse) }
+    // the mouse event handler)

     if ( !m_isDragging )
     {
         wxGridRangeSelectEvent gridEvt( GetId(),
     if ( !m_isDragging )
     {
         wxGridRangeSelectEvent gridEvt( GetId(),


@@ -4347,7 +5119,7 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
                                         this,
                                         m_selectedTopLeft,
                                         m_selectedBottomRight );
                                         this,
                                         m_selectedTopLeft,
                                         m_selectedBottomRight );

-    
+

         GetEventHandler()->ProcessEvent(gridEvt);
     }
 }
         GetEventHandler()->ProcessEvent(gridEvt);
     }
 }


@@ -4357,60 +5129,65 @@ void wxGrid::SelectAll()
     m_selectedTopLeft.Set( 0, 0 );
     m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
 
     m_selectedTopLeft.Set( 0, 0 );
     m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
 

-    if ( !GetBatchCount() ) Refresh();
+    m_gridWin->Refresh();

 }
 
 
 void wxGrid::ClearSelection()
 {
 }
 
 
 void wxGrid::ClearSelection()
 {

-    if ( IsSelection() )
-    {
-        wxRect rect( SelectionToRect() );
-        if ( rect != wxGridNoCellRect )
-        {
-            Refresh( TRUE, &rect );
-        }
-
-        m_selectedTopLeft = wxGridNoCellCoords;
-        m_selectedBottomRight = wxGridNoCellCoords;
-    }
-}    
+    m_selectedTopLeft = wxGridNoCellCoords;
+    m_selectedBottomRight = wxGridNoCellCoords;
+}

 
 
 
 

-wxRect wxGrid::SelectionToRect()
+// This function returns the rectangle that encloses the given block
+// in device coords clipped to the client size of the grid window.
+//
+wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
+                                  const wxGridCellCoords &bottomRight )

 {
 {

-    wxRect rect;
+    wxRect rect( wxGridNoCellRect );

     wxRect cellRect;
 
     wxRect cellRect;
 

-    if ( IsSelection() )
+    cellRect = CellToRect( topLeft );
+    if ( cellRect != wxGridNoCellRect )

     {
     {

-        cellRect = CellToRect( m_selectedTopLeft );
-        if ( cellRect != wxGridNoCellRect )
-        {
-            rect = cellRect;
-        }
-        else
-        {
-            rect = wxRect( m_left, m_top, 0, 0 );
-        }
-        
-        cellRect = CellToRect( m_selectedBottomRight );
-        if ( cellRect != wxGridNoCellRect )
-        {
-            rect += cellRect;
-        }
-        else
-        {
-            return wxGridNoCellRect;
-        }
+        rect = cellRect;
+    }
+    else
+    {
+        rect = wxRect( 0, 0, 0, 0 );
+    }
+
+    cellRect = CellToRect( bottomRight );
+    if ( cellRect != wxGridNoCellRect )
+    {
+        rect += cellRect;

     }
     }

+    else
+    {
+        return wxGridNoCellRect;
+    }
+
+    // convert to scrolled coords
+    //
+    int left, top, right, bottom;
+    CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
+    CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
+
+    int cw, ch;
+    m_gridWin->GetClientSize( &cw, &ch );
+
+    rect.SetLeft( wxMax(0, left) );
+    rect.SetTop( wxMax(0, top) );
+    rect.SetRight( wxMin(cw, right) );
+    rect.SetBottom( wxMin(ch, bottom) );

 
     return rect;
 }
 
 
 
 
     return rect;
 }
 
 
 

-

 //
 // ------ Grid event classes
 //
 //
 // ------ Grid event classes
 //


@@ -4430,7 +5207,7 @@ wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
     m_shift = shift;
     m_alt = alt;
     m_meta = meta;
     m_shift = shift;
     m_alt = alt;
     m_meta = meta;

-    
+

     SetEventObject(obj);
 }
 
     SetEventObject(obj);
 }
 


@@ -4449,7 +5226,7 @@ wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
     m_shift = shift;
     m_alt = alt;
     m_meta = meta;
     m_shift = shift;
     m_alt = alt;
     m_meta = meta;

-    
+

     SetEventObject(obj);
 }
 
     SetEventObject(obj);
 }
 


@@ -4457,10 +5234,10 @@ wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
 
 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
 
 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,

-                                              const wxGridCellCoords& topLeft,
-                                              const wxGridCellCoords& bottomRight,
-                                              bool control, bool shift, bool alt, bool meta )
-       : wxNotifyEvent( type, id )
+                                               const wxGridCellCoords& topLeft,
+                                               const wxGridCellCoords& bottomRight,
+                                               bool control, bool shift, bool alt, bool meta )
+        : wxNotifyEvent( type, id )

 {
     m_topLeft     = topLeft;
     m_bottomRight = bottomRight;
 {
     m_topLeft     = topLeft;
     m_bottomRight = bottomRight;