long -> wxCoord

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

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 2af40dc9c8632c2c7d6d9f4c553a1af2c9e51de1..e856345409280ae21293a40ce3c6fe924a42d079 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////

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


@@ -9,40 +9,50 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-// For compilers that support precompilation, includes "wx/wx.h".
-#include "wx/wxprec.h"
-
-#include "wx/defs.h"
-
-#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID) 
-#include "gridg.cpp"
-#else
-

 #ifdef __GNUG__
     #pragma implementation "grid.h"
 #endif
 
 #ifdef __GNUG__
     #pragma implementation "grid.h"
 #endif
 

+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"

 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 
 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 

+#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
+#include "gridg.cpp"
+#else
+

 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"

+    #include "wx/sizer.h"

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

+#ifndef DRAW_LINES
+#define DRAW_LINES 1
+#endif

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

+// this is a magic incantation which must be done!
+#include "wx/arrimpl.cpp"
+
+WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)

 
 

+// scroll line size
+// TODO: fixed so far - make configurable later (and also different for x/y)
+static const size_t GRID_SCROLL_LINE = 10;

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


@@ -64,55 +74,55 @@ wxGridTableBase::~wxGridTableBase()
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {

-    wxLogWarning( "Called grid table class function InsertRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function",
+    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 );
                   pos, numRows );

-    
+

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

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

                   numRows );
                   numRows );

-    
+

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

-    wxLogWarning( "Called grid table class function DeleteRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function",
+    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 );
                   pos, numRows );

-    
+

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

-    wxLogWarning( "Called grid table class function InsertCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function",
+    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 );
                   pos, numCols );

-    
+

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

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

                   numCols );
                   numCols );

-    
+

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

-    wxLogWarning( "Called grid table class function DeleteCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function",
+    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 );
                   pos, numCols );

-    
+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -135,7 +145,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;
     }


@@ -183,11 +193,7 @@ 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);
+WX_DEFINE_OBJARRAY(wxGridStringArray)

 
 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
 
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
 


@@ -200,7 +206,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;


@@ -209,7 +215,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 );


@@ -259,7 +265,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 )
     {


@@ -282,12 +288,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++ )


@@ -306,7 +312,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 );
     }
 


@@ -319,7 +325,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 )
     {


@@ -329,7 +335,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 );


@@ -340,11 +346,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 )


@@ -352,11 +358,11 @@ 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( "Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d rows",
+        wxLogError( wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
+                    "Pos value is invalid for present table with %d rows"),

                     pos, numRows, curNumRows );
         return FALSE;
     }
                     pos, numRows, curNumRows );
         return FALSE;
     }


@@ -365,7 +371,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


@@ -384,11 +390,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 )


@@ -397,7 +403,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 );


@@ -417,7 +423,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 );
     }
 


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

-        wxLogError( "Unable to append cols to a grid table with no rows.\n"
-                    "Call AppendRows() first" );
+        wxLogError( 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++ )


@@ -451,7 +457,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 );
     }
 


@@ -464,18 +470,18 @@ 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( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
-                   "Pos value is invalid for present table with %d cols",
-                   pos, numCols, curNumCols );
-       return FALSE;
+        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;

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


@@ -499,11 +505,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 )


@@ -570,13 +576,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,


@@ -585,16 +592,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;
 


@@ -602,20 +610,44 @@ void wxGridTextCtrl::OnKeyDown( wxKeyEvent& ev )
         case WXK_DOWN:
         case WXK_LEFT:
         case WXK_RIGHT:
         case WXK_DOWN:
         case WXK_LEFT:
         case WXK_RIGHT:

-        case WXK_RETURN:
+        case WXK_PRIOR:
+        case WXK_NEXT:
+        case WXK_SPACE:

             if ( m_isCellControl )
             {
                 // send the event to the parent grid, skipping the
                 // event if nothing happens
                 //
             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;
 


@@ -626,45 +658,275 @@ 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( wxGridRowLabelWindow, wxWindow )
+
+BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
+    EVT_PAINT( wxGridRowLabelWindow::OnPaint )
+    EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
+    EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
+END_EVENT_TABLE()
+
+wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
+                                            wxWindowID id,
+                                            const wxPoint &pos, const wxSize &size )
+  : wxWindow( parent, id, pos, size )
+{
+    m_owner = parent;
+}
+
+void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
+{
+    wxPaintDC dc(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 y coord  - MB
+    //
+    // m_owner->PrepareDC( dc );
+
+    int x, y;
+    m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
+    dc.SetDeviceOrigin( 0, -y );
+
+    m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawRowLabels( dc );
+}
+
+
+void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
+{
+    m_owner->ProcessRowLabelMouseEvent( event );
+}
+
+
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+
+IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
+
+BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
+    EVT_PAINT( wxGridColLabelWindow::OnPaint )
+    EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
+    EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
+END_EVENT_TABLE()
+
+wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
+                                            wxWindowID id,
+                                            const wxPoint &pos, const wxSize &size )
+  : wxWindow( parent, id, pos, size )
+{
+    m_owner = parent;
+}
+
+void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
+{
+    wxPaintDC dc(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_owner->PrepareDC( dc );
+
+    int x, y;
+    m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
+    dc.SetDeviceOrigin( -x, 0 );
+
+    m_owner->CalcColLabelsExposed( GetUpdateRegion() );
+    m_owner->DrawColLabels( dc );
+}
+
+
+void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
+{
+    m_owner->ProcessColLabelMouseEvent( event );
+}
+
+
+// This seems to be required for wxMotif otherwise the mouse
+// cursor must be in the cell edit control to get key events
+//
+void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
+{
+    if ( !m_owner->ProcessEvent( event ) ) event.Skip();

 }
 
 
 }
 
 

+

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

-IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxPanel )
+IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
+
+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;
+}

 
 

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

     
     

-BEGIN_EVENT_TABLE( wxGrid, wxPanel )
+    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, wxSUNKEN_BORDER, "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 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_PAINT( wxGrid::OnPaint )
     EVT_SIZE( wxGrid::OnSize )

-    EVT_MOUSE_EVENTS( wxGrid::OnMouse )

     EVT_KEY_DOWN( wxGrid::OnKeyDown )
     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)

 END_EVENT_TABLE()
 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()
 {
 
 wxGrid::~wxGrid()
 {


@@ -678,36 +940,77 @@ wxGrid::~wxGrid()
 
 void wxGrid::Create()
 {
 
 void wxGrid::Create()
 {

-    m_table          = (wxGridTableBase *) NULL;
-    m_topEditCtrl    = (wxWindow *) NULL;
-    m_cellEditCtrl   = (wxWindow *) NULL;
-    m_horizScrollBar = (wxScrollBar *) NULL;
-    m_vertScrollBar  = (wxScrollBar *) NULL;
+    int colLblH = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
+    int rowLblW = WXGRID_DEFAULT_ROW_LABEL_WIDTH;

 
 

-    m_numRows = 0;
-    m_numCols = 0;
-    m_created = FALSE;
+    m_rowLabelWin = new wxGridRowLabelWindow( this,
+                                              -1,
+                                              wxDefaultPosition,
+                                              wxSize(rowLblW,-1) );
+
+    m_colLabelWin = new wxGridColLabelWindow( this,
+                                              -1,
+                                              wxDefaultPosition,
+                                              wxSize(-1, colLblH ) );
+
+    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
+                                                    -1,
+                                                    wxDefaultPosition,
+                                                    wxSize(rowLblW, colLblH ) );
+
+    m_gridWin = new wxGridWindow( this,
+                                  m_rowLabelWin,
+                                  m_colLabelWin,
+                                  -1,
+                                  wxDefaultPosition,
+                                  wxDefaultSize );
+
+    SetTargetWindow( m_gridWin );
+
+    m_mainSizer = new wxBoxSizer( wxVERTICAL );
+
+    m_topSizer = new wxBoxSizer( wxHORIZONTAL );
+    m_topSizer->Add( m_cornerLabelWin, 0 );
+    m_topSizer->Add( m_colLabelWin, 1 );
+
+    m_mainSizer->Add( m_topSizer, 0, wxEXPAND );
+
+    m_middleSizer = new wxBoxSizer( wxHORIZONTAL );
+    m_middleSizer->Add( m_rowLabelWin, 0, wxEXPAND );
+    m_middleSizer->Add( m_gridWin, 1, wxEXPAND );
+
+    m_mainSizer->Add( m_middleSizer, 1, wxEXPAND );
+
+    SetAutoLayout( TRUE );
+    SetSizer( m_mainSizer );

 }
 
 }
 

-void wxGrid::Init()
+
+bool wxGrid::CreateGrid( int numRows, int numCols )

 {
 {

-    int i;
+    if ( m_created )
+    {
+        wxLogError( wxT("wxGrid::CreateGrid(numRows, numCols) called more than once") );
+        return FALSE;
+    }
+    else
+    {
+        m_numRows = numRows;
+        m_numCols = numCols;
+
+        m_table = new wxGridStringTable( m_numRows, m_numCols );
+        m_table->SetView( this );
+        Init();
+        m_created = TRUE;
+    }

 
 

-    m_left = 0;
-    m_top  = 0;
+    return m_created;
+}

 
 

-    // 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 );                                      
+
+void wxGrid::Init()
+{
+    int i;

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


@@ -718,71 +1021,65 @@ void wxGrid::Init()
     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 
     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 

-    // default labels are pale grey with black text
-    //
-    m_labelBackgroundColour = wxColour( 192, 192, 192 );
-    m_labelTextColour       = wxColour(   0,   0,   0 );
+    if ( m_rowLabelWin )
+    {
+        m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
+    }
+    else
+    {
+        m_labelBackgroundColour = wxColour( _T("WHITE") );
+    }
+
+    m_labelTextColour = wxColour( _T("BLACK") );

 
     // TODO: something better than this ?
     //
     m_labelFont = this->GetFont();
     m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
 
     // 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_rowLabelHorizAlign = wxLEFT;
     m_rowLabelVertAlign  = wxCENTRE;
 
     m_colLabelHorizAlign = wxCENTRE;
     m_colLabelVertAlign  = wxTOP;
 

-    m_defaultRowHeight = WXGRID_DEFAULT_ROW_HEIGHT;

     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
     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_rowHeights.Alloc( m_numRows );
     m_rowBottoms.Alloc( m_numRows );
 
     m_rowHeights.Alloc( m_numRows );
     m_rowBottoms.Alloc( m_numRows );

+    int rowBottom = 0;

     for ( i = 0;  i < m_numRows;  i++ )
     {
         m_rowHeights.Add( m_defaultRowHeight );
     for ( i = 0;  i < m_numRows;  i++ )
     {
         m_rowHeights.Add( m_defaultRowHeight );

-        m_rowBottoms.Add( 0 );  // set by CalcDimensions()
+        rowBottom += m_defaultRowHeight;
+        m_rowBottoms.Add( rowBottom );

     }
 
     m_colWidths.Alloc( m_numCols );
     }
 
     m_colWidths.Alloc( m_numCols );

-    m_colRights.Alloc( m_numRows );
+    m_colRights.Alloc( m_numCols );
+    int colRight = 0;

     for ( i = 0;  i < m_numCols;  i++ )
     {
         m_colWidths.Add( m_defaultColWidth );
     for ( i = 0;  i < m_numCols;  i++ )
     {
         m_colWidths.Add( m_defaultColWidth );

-        m_colRights.Add( 0 );  // set by CalcDimensions()
+        colRight += m_defaultColWidth;
+        m_colRights.Add( colRight );

     }
 
     // TODO: improve this ?
     //
     m_defaultCellFont = this->GetFont();
     }
 
     // TODO: improve this ?
     //
     m_defaultCellFont = this->GetFont();

-    
-    m_gridLineColour = wxColour(   0,   0, 255 );
+
+    m_gridLineColour = wxColour( 128, 128, 255 );

     m_gridLinesEnabled = TRUE;
     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_cursorMode  = WXGRID_CURSOR_SELECT_CELL;

     m_dragLastPos  = -1;
     m_dragRowOrCol = -1;
     m_isDragging = FALSE;
     m_dragLastPos  = -1;
     m_dragRowOrCol = -1;
     m_isDragging = FALSE;


@@ -791,212 +1088,63 @@ void wxGrid::Init()
     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
 
     m_currentCellCoords = wxGridNoCellCoords;
     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
 
     m_currentCellCoords = wxGridNoCellCoords;

-    m_currentCellHighlighted = FALSE;

 
     m_selectedTopLeft = wxGridNoCellCoords;
     m_selectedBottomRight = wxGridNoCellCoords;
 
     m_selectedTopLeft = wxGridNoCellCoords;
     m_selectedBottomRight = wxGridNoCellCoords;

-    
+

     m_editable = TRUE;  // default for whole grid
 
     m_editable = TRUE;  // default for whole grid
 

+    m_inOnKeyDown = FALSE;
+    m_batchCount = 0;
+

     // TODO: extend this to other types of controls
     //
     // TODO: extend this to other types of controls
     //

-    m_cellEditCtrl = new wxGridTextCtrl( this,
+    m_cellEditCtrl = new wxGridTextCtrl( m_gridWin,
+                                         this,

                                          TRUE,
                                          wxGRID_CELLCTRL,
                                          "",
                                          wxPoint(1,1),
                                          TRUE,
                                          wxGRID_CELLCTRL,
                                          "",
                                          wxPoint(1,1),

-                                         wxSize(1,1),
-                                         wxNO_BORDER
-#ifdef __WXMSW__
-                                         | wxTE_MULTILINE | wxTE_NO_VSCROLL
+                                         wxSize(1,1)
+#if defined(__WXMSW__)
+                                         , wxTE_MULTILINE | wxTE_NO_VSCROLL

 #endif
                                          );
 #endif
                                          );

-                                         
-    m_cellEditCtrl->Show( FALSE );                                            
+
+    m_cellEditCtrl->Show( FALSE );

     m_cellEditCtrlEnabled = TRUE;
     m_cellEditCtrlEnabled = TRUE;

-    m_editCtrlType = wxGRID_TEXTCTRL;    
-    
-    // Not really needed here, it gets called by OnSize()
-    //
-    // CalcDimensions();
+    m_editCtrlType = wxGRID_TEXTCTRL;

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

-    int i;
-
-    if ( IsTopEditControlEnabled() )
-    {
-        int ctrlW, ctrlH;
-        m_topEditCtrl->GetSize( &ctrlW, &ctrlH );
-        
-        m_top = ctrlH + 20;
-    }
-    else
-    {
-        m_top = 0;
-    }
-
-    int bottom =  m_top + m_colLabelHeight;
-    for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-    {
-        bottom += m_rowHeights[i];
-        m_rowBottoms[i] = bottom;
-    }
-
-    int right = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-    {
-        right += m_colWidths[i];
-        m_colRights[i] = right;
-    }    
-
-    // adjust the scroll bars
-    //
-    

     int cw, ch;
     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_numRows > 0  &&
-             m_rowBottoms[m_numRows-1] + horizScrollBarHeight > ch )
-        {
-            vertScrollBarWidth = m_scrollBarWidth;
-
-            m_wholeRowsVisible = 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++ ;
-            }
-        }
-        else  
-        {
-            m_wholeRowsVisible = m_numRows - m_scrollPosY;
-            if ( m_scrollPosY )
-            {
-                vertScrollBarWidth = m_scrollBarWidth;
-            }
-        }
-        
-
-        if ( m_numCols  &&
-             m_colRights[m_numCols-1] + vertScrollBarWidth > cw)
-        {
-            horizScrollBarHeight = m_scrollBarWidth;
-
-            m_wholeColsVisible = 0;
-            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++ ;
-            }
-        }
-        else
-        {
-            // we can see the right-most column
-            //
-            m_wholeColsVisible = m_numCols - m_scrollPosX;
-            if ( m_scrollPosX )
-            {
-                horizScrollBarHeight = m_scrollBarWidth;
-            }
-        }
-    }
+    GetClientSize( &cw, &ch );

 
 

-    
-    if ( m_vertScrollBar )
-    {
-        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);
-        }
-    }
-    
-    if ( m_horizScrollBar )
+    if ( m_numRows > 0  &&  m_numCols > 0 )

     {
     {

-        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_horizScrollBar->SetSize( m_left,
-                                       ch - m_scrollBarWidth,
-                                       cw - m_left - vertScrollBarWidth,
-                                       m_scrollBarWidth );
-        }
-    }
+        int right = m_colRights[ m_numCols-1 ] + 20;
+        int bottom = m_rowBottoms[ m_numRows-1 ] + 20;

 
 

-    m_bottom = m_right = 0;
-    if ( m_numRows > 0 )
-    {
-        m_bottom = wxMin( m_rowBottoms[m_numRows-1],
-                          ch - horizScrollBarHeight );
-    }
-    if ( m_numCols > 0 )
-    {
-        m_right = wxMin( m_colRights[m_numCols-1],
-                         cw - vertScrollBarWidth );
+        // 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()
-{
-    int cw, ch;
-    GetClientSize( &cw, &ch );
-    return ( cw > 10 );
-}
-
-

 // this is called when the grid table sends a message to say that it
 // has been redimensioned
 //
 bool wxGrid::Redimension( wxGridTableMessage& msg )
 {
     int i;
 // this is called when the grid table sends a message to say that it
 // has been redimensioned
 //
 bool wxGrid::Redimension( wxGridTableMessage& msg )
 {
     int i;

-    
+

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


@@ -1009,6 +1157,15 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_rowBottoms.Insert( 0, pos );
             }
             m_numRows += numRows;
                 m_rowBottoms.Insert( 0, pos );
             }
             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;


@@ -1021,7 +1178,18 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_rowHeights.Add( m_defaultRowHeight );
                 m_rowBottoms.Add( 0 );
             }
                 m_rowHeights.Add( m_defaultRowHeight );
                 m_rowBottoms.Add( 0 );
             }

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


@@ -1037,11 +1205,6 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             }
             m_numRows -= numRows;
 
             }
             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;


@@ -1049,10 +1212,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;


@@ -1067,6 +1239,15 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_colRights.Insert( 0, pos );
             }
             m_numCols += numCols;
                 m_colRights.Insert( 0, pos );
             }
             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;


@@ -1079,7 +1260,18 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_colWidths.Add( m_defaultColWidth );
                 m_colRights.Add( 0 );
             }
                 m_colWidths.Add( m_defaultColWidth );
                 m_colRights.Add( 0 );
             }

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


@@ -1094,11 +1286,6 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 m_colRights.Remove( pos );
             }
             m_numCols -= numCols;
                 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 )
             {


@@ -1106,12 +1293,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();
         }


@@ -1122,214 +1317,196 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
 }
 
 
 }
 
 

-//
-// ----- 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 )
+void wxGrid::CalcRowLabelsExposed( wxRegion& reg )

 {
 {

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

 
 

-       wxGridSizeEvent gridEvt( GetId(),
-                                type,
-                                this,
-                                rowOrCol,
-                                mouseEv.GetX(), mouseEv.GetY(),
-                                mouseEv.ControlDown(),
-                                mouseEv.ShiftDown(),
-                                mouseEv.AltDown(),
-                                mouseEv.MetaDown() );
+    m_rowLabelsExposed.Empty();

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
-    }
-    else if ( type == EVT_WXGRID_RANGE_SELECT )
+    int top, bottom;
+    while ( iter )

     {
     {

-       wxGridRangeSelectEvent gridEvt( GetId(),
-                                       type,
-                                       this,
-                                       m_selectedTopLeft,
-                                       m_selectedBottomRight,
-                                       mouseEv.ControlDown(),
-                                       mouseEv.ShiftDown(),
-                                       mouseEv.AltDown(),
-                                       mouseEv.MetaDown() );
+        r = iter.GetRect();

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
-    }
-    else
-    {
-       wxGridEvent gridEvt( GetId(),
-                            type,
-                            this,
-                            row, col,
-                            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
+
+        // logical bounds of update region
+        //
+        int dummy;
+        CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
+        CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
+
+        // 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_WXGRID_ROW_SIZE ||
-        type == EVT_WXGRID_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;
+
+            colLeft = m_colRights[col] - m_colWidths[col];
+            if ( colLeft > right ) break;

 
 

-       return GetEventHandler()->ProcessEvent(gridEvt);
+            m_colLabelsExposed.Add( col );
+        }
+
+        iter++ ;

     }
 }
 
 
     }
 }
 
 

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

 {
 {

-    wxPaintDC dc( this );
+    wxRegionIterator iter( reg );
+    wxRect r;
+
+    m_cellsExposed.Empty();
+    m_rowsExposed.Empty();
+    m_colsExposed.Empty();

 
 

-    if ( !m_batchCount )
+    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;

 
 

-void wxGrid::OnSize( wxSizeEvent& ev )
-{
-    CalcDimensions();
+                colLeft = m_colRights[col] - m_colWidths[col];
+                if ( colLeft > right ) break;
+
+                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 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;
 
                 }
                 break;
 


@@ -1342,1929 +1519,1964 @@ void wxGrid::OnMouse( wxMouseEvent& ev )
                     }
                 }
                 break;
                     }
                 }
                 break;

-
-                case WXGRID_CURSOR_SELECT_COL:
-                {
-                    if ( (col = XToCol( x )) >= 0  &&
-                         !IsInSelection( 0, col ) )
-                    {
-                        SelectCol( col, TRUE );
-                    }
-                }
-                break;

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

-    
-    // ------------------------------------------------------------
-    //
-    // Left mouse button down
+
+
+    // ------------ Left button pressed

     //
     //

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

     {
     {

-        row = -1;
-        col = -1;
-        wxGridCellCoords cellCoords;
-        
-        switch( XYToArea( x, y ) )
+        // 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 )

         {
         {

-            case WXGRID_ROWLABEL:
+            row = YToRow(y);
+            if ( row >= 0  &&
+                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )

             {
             {

-                // 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_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                    {
-                        SelectRow( row, ev.ShiftDown() );
-                        m_cursorMode = WXGRID_CURSOR_SELECT_ROW;
-                    }
-                }
+                SelectRow( row, event.ShiftDown() );
+                m_cursorMode = WXGRID_CURSOR_SELECT_ROW;

             }
             }

-            break;
+        }
+        else
+        {
+            // starting to drag-resize a row
+            //
+            m_rowLabelWin->CaptureMouse();
+        }
+    }
+
+
+    // ------------ Left double click
+    //
+    else if (event.LeftDClick() )
+    {
+        if ( YToEdgeOfRow(y) < 0 )
+        {
+            row = YToRow(y);
+            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
+        }
+    }

 
 

-            case WXGRID_COLLABEL:
+
+    // ------------ Left button released
+    //
+    else if ( event.LeftUp() )
+    {
+        if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
+        {
+            m_rowLabelWin->ReleaseMouse();
+
+            if ( m_dragLastPos >= 0 )

             {
             {

-                // 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
+                // erase the last line and resize the row

                 //
                 //

-                if ( XToEdgeOfCol(x) < 0 )
+                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( y - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
+                if ( !GetBatchCount() )

                 {
                 {

-                    col = XToCol(x);
-                    if ( !SendEvent( EVT_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                    {
-                        SelectCol( col, ev.ShiftDown() );
-                        m_cursorMode = WXGRID_CURSOR_SELECT_COL;
-                    }
+                  // Only needed to get the correct rect.y:
+                  wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
+                  rect.x = 0;
+                  rect.width = m_rowLabelWidth;
+                  rect.height = ch - rect.y;
+                  m_rowLabelWin->Refresh( TRUE, &rect );
+                  rect.width = cw;
+                  m_gridWin->Refresh( TRUE, &rect );

                 }
                 }

-            }
-            break;

 
 

-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
+                ShowCellEditControl();
+
+                // Note: we are ending the event *after* doing
+                // default processing in this case

                 //
                 //

-                if ( !SendEvent( EVT_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
-                {
-                    SelectAll();
-                }
+                SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );

             }
             }

-            break;
+        }

 
 

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

 
 

-            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

         }
     }
         }
     }

-    // ------------------------------------------------------------
+
+
+    // ------------ Right double click

     //
     //

-    // Left mouse button 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
+        }
+    }
+
+
+    // ------------ No buttons down and mouse moving

     //
     //

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

     {
     {

-        row = -1;
-        col = -1;
-        wxGridCellCoords cellCoords;
-        
-        switch( XYToArea( x, y ) )
+        m_dragRowOrCol = YToEdgeOfRow( y );
+        if ( m_dragRowOrCol >= 0 )

         {
         {

-            case WXGRID_ROWLABEL:
+            if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                // 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_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );
-                }
+                m_cursorMode = WXGRID_CURSOR_RESIZE_ROW;
+                m_rowLabelWin->SetCursor( m_rowResizeCursor );

             }
             }

-            break;
+        }
+        else
+        {
+            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+            {
+                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+                m_rowLabelWin->SetCursor( *wxSTANDARD_CURSOR );
+            }
+        }
+    }
+}

 
 

-            case WXGRID_COLLABEL:
+
+void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
+{
+    int x, y, col;
+    wxPoint pos( event.GetPosition() );
+    CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+
+    if ( event.Dragging() )
+    {
+        m_isDragging = TRUE;
+
+        if ( event.LeftIsDown() )
+        {
+            switch( m_cursorMode )

             {
             {

-                // 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 )
+                case WXGRID_CURSOR_RESIZE_COL:

                 {
                 {

-                    col = XToCol(x);
-                    SendEvent(  EVT_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );
+                    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;

                 }
                 }

-            }
-            break;
+                break;

 
 

-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
-                //
-                SendEvent(  EVT_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );                
+                case WXGRID_CURSOR_SELECT_COL:
+                {
+                    if ( (col = XToCol( x )) >= 0  &&
+                         !IsInSelection( 0, col ) )
+                    {
+                        SelectCol( col, TRUE );
+                    }
+                }
+                break;

             }
             }

-            break;
+        }
+        return;
+    }
+
+    m_isDragging = FALSE;
+

 
 

-            case WXGRID_CELL:
+    // ------------ Left button pressed
+    //
+    if ( event.LeftDown() )
+    {
+        // 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 ( col >= 0  &&
+                 !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )

             {
             {

-                XYToCell( x, y, cellCoords );
-                SendEvent( EVT_WXGRID_CELL_LEFT_DCLICK,
-                                 cellCoords.GetRow(),
-                                 cellCoords.GetCol(),
-                                 ev );
+                SelectCol( col, event.ShiftDown() );
+                m_cursorMode = WXGRID_CURSOR_SELECT_COL;

             }
             }

-            break;
-
-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+        }
+        else
+        {
+            // starting to drag-resize a col
+            //
+            m_colLabelWin->CaptureMouse();

         }
     }
         }
     }

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

     //
     //

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

     {
     {

-       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_rowHeights[m_dragRowOrCol] = wxMax( ev.GetY() - top,
-                                                         WXGRID_MIN_ROW_HEIGHT );
-                   CalcDimensions();
-                   ShowCellEditControl();
-                   Refresh();
-
-                   // Note: we are ending the event *after* doing
-                   // default processing in this case
-                   //
-                   SendEvent( EVT_WXGRID_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_colWidths[m_dragRowOrCol] = wxMax( ev.GetX() - left,
-                                                        WXGRID_MIN_COL_WIDTH );
-                   CalcDimensions();
-                   ShowCellEditControl();
-                   Refresh();
-
-                   // Note: we are ending the event *after* doing
-                   // default processing in this case
-                   //
-                   SendEvent( EVT_WXGRID_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_WXGRID_RANGE_SELECT, -1, -1, ev );
-               }
-           }
-           break;
-       }
-
-       m_dragLastPos  = -1;
+        if ( XToEdgeOfCol(x) < 0 )
+        {
+            col = XToCol(x);
+            SendEvent(  EVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
+        }

     }
     }

-    // ------------------------------------------------------------
-    //
-    // Right mouse button down
+
+
+    // ------------ Left button released

     //
     //

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

     {
     {

-       row = -1;
-       col = -1;
-       wxGridCellCoords cellCoords;
-
-       switch( XYToArea( x, y ) )
-       {
-            
-           case WXGRID_ROWLABEL:
-           {
-               row = YToRow(y);
-               if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
-               {
-                    // TODO: default processing ?
-                }
-            }
-            break;
+        if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+        {
+            m_colLabelWin->ReleaseMouse();

 
 

-            case WXGRID_COLLABEL:
+            if ( m_dragLastPos >= 0 )

             {
             {

-                col = XToCol(x);
-               if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
+                // erase the last line and resize the 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 );
+                dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
+                HideCellEditControl();
+
+                int colLeft = m_colRights[m_dragRowOrCol] - m_colWidths[m_dragRowOrCol];
+                SetColSize( m_dragRowOrCol, wxMax( x - colLeft, WXGRID_MIN_COL_WIDTH ) );
+
+                if ( !GetBatchCount() )

                 {
                 {

-                    // TODO: default processing ?
+                  // Only needed to get the correct rect.x:
+                  wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
+                  rect.y = 0;
+                  rect.width = cw - rect.x;
+                  rect.height = m_colLabelHeight;
+                  m_colLabelWin->Refresh( TRUE, &rect );
+                  rect.height = ch;
+                  m_gridWin->Refresh( TRUE, &rect );

                 }
                 }

-            }
-            break;

 
 

-            case WXGRID_CORNERLABEL:
-            {
-                // leave both row and col as -1
+                ShowCellEditControl();
+
+                // Note: we are ending the event *after* doing
+                // default processing in this case

                 //
                 //

-                if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
-                {
-                    // TODO: default processing ?
-                }
+                SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );

             }
             }

-            break;
+        }

 
 

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

 
 

-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                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

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // Right mouse button double click
+
+
+    // ------------ Right double click

     //
     //

-    else if ( ev.RightDClick() )
+    else if ( event.RightDClick() )

     {
     {

-       row = -1;
-       col = -1;
-       wxGridCellCoords cellCoords;
+        col = XToCol(x);
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
+        {
+            // no default action at the moment
+        }
+    }

 
 

-       switch( XYToArea( x, y ) )
-       {
-            
-           case WXGRID_ROWLABEL:
-           {
-               row = YToRow(y);
-               SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
-            }
-            break;

 
 

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

             {
             {

-                col = XToCol(x);
-               SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+                m_cursorMode = WXGRID_CURSOR_RESIZE_COL;
+                m_colLabelWin->SetCursor( m_colResizeCursor );

             }
             }

-            break;
-
-            case WXGRID_CORNERLABEL:
+        }
+        else
+        {
+            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                // leave both row and col as -1
-                //
-                SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+                m_colLabelWin->SetCursor( *wxSTANDARD_CURSOR );

             }
             }

-            break;
+        }
+    }
+}

 
 

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

 
 

-            default:
-#if 0                
-                wxLogMessage( "outside grid area" );
-#endif                
-                break;
+void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
+{
+    if ( event.LeftDown() )
+    {
+        // indicate corner label by having both row and
+        // col args == -1
+        //
+        if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
+        {
+            SelectAll();

         }
     }
         }
     }

-    // ------------------------------------------------------------
-    //
-    // No buttons down and mouse moving
-    //
-    else if ( ev.Moving() )
+
+    else if ( event.LeftDClick() )
+    {
+        SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
+    }
+
+    else if ( event.RightDown() )
+    {
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
+        {
+            // no default action at the moment
+        }
+    }
+
+    else if ( event.RightDClick() )
+    {
+        if ( !SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
+        {
+            // no default action at the moment
+        }
+    }
+}
+
+
+void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
+{
+    int x, y;
+    wxPoint pos( event.GetPosition() );
+    CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+
+    wxGridCellCoords coords;
+    XYToCell( x, y, coords );
+
+    if ( event.Dragging() )

     {
     {

-        switch( XYToArea( x, y ) )
+        m_isDragging = TRUE;
+        if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

         {
         {

-            case WXGRID_ROWLABEL:
+            // Hide the edit control, so it
+            // won't interfer with drag-shrinking.
+            if ( IsCellEditControlEnabled() )
+                HideCellEditControl();
+            if ( coords != wxGridNoCellCoords )

             {
             {

-                m_dragRowOrCol = YToEdgeOfRow( y );
-                if ( m_dragRowOrCol >= 0 )
+                if ( !IsSelection() )

                 {
                 {

-                    if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
-                    {
-                        m_cursorMode = WXGRID_CURSOR_RESIZE_ROW;
-                        SetCursor( m_rowResizeCursor );
-                    }
+                    SelectBlock( coords, coords );

                 }
                 else
                 {
                 }
                 else
                 {

-                    if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-                    {
-                        m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                        SetCursor( *wxSTANDARD_CURSOR );
-                    }
+                    SelectBlock( m_currentCellCoords, coords );

                 }
             }
                 }
             }

-            break;
+        }
+
+        return;
+    }
+
+    m_isDragging = FALSE;

 
 

-            case WXGRID_COLLABEL:
+    if ( coords != wxGridNoCellCoords )
+    {
+        if ( event.LeftDown() )
+        {
+            if ( event.ShiftDown() )

             {
             {

-                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
+                SelectBlock( m_currentCellCoords, coords );
+            }
+            else
+            {
+                if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
+                                 coords.GetRow(),
+                                 coords.GetCol(),
+                                 event ) )

                 {
                 {

-                    if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-                    {
-                        m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                        SetCursor( *wxSTANDARD_CURSOR );
-                    }
+                    MakeCellVisible( coords );
+                    SetCurrentCell( coords );

                 }
             }
                 }
             }

-            break;
+        }

 
 

-            default:
+
+        // ------------ Left double click
+        //
+        else if ( event.LeftDClick() )
+        {
+            SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
+                       coords.GetRow(),
+                       coords.GetCol(),
+                       event );
+        }
+
+
+        // ------------ Left button released
+        //
+        else if ( event.LeftUp() )
+        {
+            if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )

             {
             {

-                if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+                if ( IsSelection() )

                 {
                 {

-                    m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                    SetCursor( *wxSTANDARD_CURSOR );
+                    SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, event );

                 }
             }
                 }
             }

-            break;
-        }        
+
+            // Show the edit control, if it has
+            // been hidden for drag-shrinking.
+            if ( IsCellEditControlEnabled() )
+                ShowCellEditControl();
+
+            m_dragLastPos = -1;
+        }
+
+
+        // ------------ Right button down
+        //
+        else if ( event.RightDown() )
+        {
+            if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
+                             coords.GetRow(),
+                             coords.GetCol(),
+                             event ) )
+            {
+                // no default action at the moment
+            }
+        }
+
+
+        // ------------ Right double click
+        //
+        else if ( event.RightDClick() )
+        {
+            if ( !SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
+                             coords.GetRow(),
+                             coords.GetCol(),
+                             event ) )
+            {
+                // no default action at the moment
+            }
+        }

     }
 }
 
 
     }
 }
 
 

-void wxGrid::OnKeyDown( wxKeyEvent& ev )
+//
+// ------ interaction with data model
+//
+bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )

 {
 {

-    if ( m_inOnKeyDown )
+    switch ( msg.GetId() )

     {
     {

-        // shouldn't be here - we are going round in circles...
-        //
-        wxLogFatalError( "wxGrid::OnKeyDown called while alread active" );
-    }
+        case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
+            return GetModelValues();

 
 

-    m_inOnKeyDown = TRUE;
-        
-    // propagate the event up and see if it gets processed
-    //
-    wxWindow *parent = GetParent();
-    wxKeyEvent keyEvt( ev );
-    keyEvt.SetEventObject( parent );
-    
-    if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
-    {
-        // try local handlers
-        //
-        switch ( ev.KeyCode() )
-        {
-            case WXK_UP:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorUpBlock();
-                }
-                else
-                {
-                    MoveCursorUp();
-                }
-                break;
-                
-            case WXK_DOWN:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorDownBlock();
-                }
-                else
-                {
-                    MoveCursorDown();
-                }
-                break;
+        case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
+            return SetModelValues();

 
 

-            case WXK_LEFT:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorLeftBlock();
-                }
-                else
-                {
-                    MoveCursorLeft();
-                }
-                break;
+        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 );

 
 

-            case WXK_RIGHT:
-                if ( ev.ControlDown() )
-                {
-                    MoveCursorRightBlock();
-                }
-                else
-                {
-                    MoveCursorRight();
-                }
-                break;
+        default:
+            return FALSE;
+    }
+}

 
 

-            case WXK_RETURN:
-                MoveCursorDown();
-                break;

 
 

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

 
 

-            case WXK_NEXT:
-                MovePageDown();
-                break;
-                
-            default:
-                // now try the cell edit control
-                //
-                if ( IsCellEditControlEnabled() )
-                {
-                    ev.SetEventObject( m_cellEditCtrl );
-                    m_cellEditCtrl->GetEventHandler()->ProcessEvent( ev );
-                }
-                break;
-        }
+// 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()
+{
+    if ( m_table )
+    {
+        m_table->Clear();
+        SetEditControlValue();
+        if ( !GetBatchCount() ) m_gridWin->Refresh();

     }
     }

-
-    m_inOnKeyDown = FALSE;

 }
 
 
 }
 
 

-// Text updated in an edit control - either a text control or a
-// combo box
-//
-void wxGrid::OnText( wxKeyEvent& ev )
+bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( !m_inOnText )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-        m_inOnText = TRUE;
-        wxWindow *ctrl = (wxWindow *)ev.GetEventObject();
+        wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
+        return FALSE;
+    }
+
+    if ( m_table )
+    {
+        bool ok = m_table->InsertRows( pos, numRows );

 
 

-        if ( ctrl == m_cellEditCtrl &&
-             IsTopEditControlEnabled() )
+        // the table will have sent the results of the insert row
+        // operation to this view object as a grid table message
+        //
+        if ( ok )

         {
         {

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

             {
             {

-                case wxGRID_TEXTCTRL:
-                    ((wxTextCtrl *)m_topEditCtrl)->
-                        SetValue(((wxTextCtrl *)ctrl)->GetValue());
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    ((wxComboBox *)m_topEditCtrl)->
-                        SetValue(((wxComboBox *)ctrl)->GetValue());
-                    break;
+                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 ?
+                //

             }
             }

-        }
-        else if ( ctrl == m_topEditCtrl &&
-                  IsCellEditControlEnabled() )
-        {
-            switch ( m_editCtrlType )
+
+            if ( m_currentCellCoords == wxGridNoCellCoords )

             {
             {

-                case wxGRID_TEXTCTRL:
-                    ((wxTextCtrl *)m_cellEditCtrl)->
-                        SetValue(((wxTextCtrl *)ctrl)->GetValue());
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    ((wxComboBox *)m_cellEditCtrl)->
-                        SetValue(((wxComboBox *)ctrl)->GetValue());
-                    break;
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );

             }
             }

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

         }
         }

-    }

 
 

-    m_inOnText = FALSE;
+        SetEditControlValue();
+        return ok;
+    }
+    else
+    {
+        return FALSE;
+    }

 }
 
 }
 

-void wxGrid::OnGridScroll( wxScrollEvent& ev )
+
+bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    // propagate the event up and see if it gets processed
-    //
-    wxWindow *parent = GetParent();
-    wxScrollEvent scrollEvt( ev );
-    if (parent->GetEventHandler()->ProcessEvent( scrollEvt )) return;
-    
-    HideCellEditControl();
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )
+    {
+        wxLogError( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
+        return FALSE;
+    }

 
 

-    if ( ev.GetEventObject() == m_horizScrollBar )
+    if ( m_table && m_table->AppendRows( numRows ) )

     {
     {

-        if ( ev.GetPosition() != m_scrollPosX )
+        if ( m_currentCellCoords == wxGridNoCellCoords )

         {
         {

-            SetHorizontalScrollPos( ev.GetPosition() );
+            // if we have just inserted cols into an empty grid the current
+            // cell will be undefined...
+            //
+            SetCurrentCell( 0, 0 );

         }
         }

+
+        // the table will have sent the results of the append row
+        // operation to this view object as a grid table message
+        //
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();
+        return TRUE;

     }
     else
     {
     }
     else
     {

-        if ( ev.GetPosition() != m_scrollPosY )
-        {
-            SetVerticalScrollPos( ev.GetPosition() );
-        }
+        return FALSE;

     }
     }

-
-    ShowCellEditControl();

 }
 
 
 }
 
 

-void wxGrid::SelectCell( const wxGridCellCoords& coords )
+bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )

 {
 {

-    wxClientDC dc( this );
+    // TODO: something with updateLabels flag

 
 

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

     {
     {

-        HideCurrentCellHighlight( dc );
-        HideCellEditControl();
-        SaveEditControlValue();
+        wxLogError( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
+        return FALSE;

     }
 
     }
 

-    m_currentCellCoords = coords;
-
-    SetEditControlValue();
-    if ( IsOnScreen() )
+    if ( m_table && m_table->DeleteRows( pos, numRows ) )

     {
     {

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

 
 

-    if ( IsSelection() )
-    {

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

+        return TRUE;
+    }
+    else
+    {
+        return FALSE;

     }
 }
 
 
     }
 }
 
 

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

 {
 {

-    wxRect rect;
-    
-    if ( IsCellEditControlEnabled() )         
-    {
-        if ( !IsVisible( m_currentCellCoords ) )
-        {
-            return;
-        }
-        else
-        {
-            rect = CellToRect( m_currentCellCoords );
-            
-            m_cellEditCtrl->SetSize( rect );
-            m_cellEditCtrl->Show( TRUE );
+    // TODO: something with updateLabels flag

 
 

-            switch ( m_editCtrlType )
-            {
-                case wxGRID_TEXTCTRL:
-                    ((wxTextCtrl *) m_cellEditCtrl)->SetInsertionPointEnd();
-                    break;
+    if ( !m_created )
+    {
+        wxLogError( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
+        return FALSE;
+    }

 
 

-                case wxGRID_CHECKBOX:
-                    // TODO: anything ???
-                    //
-                    break;
+    if ( m_table )
+    {
+        HideCellEditControl();
+        bool ok = m_table->InsertCols( pos, numCols );

 
 

-                case wxGRID_CHOICE:
-                    // TODO: anything ???
-                    //
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    // TODO: anything ???
-                    //
-                    break;
+        // the table will have sent the results of the insert col
+        // operation to this view object as a grid table message
+        //
+        if ( ok )
+        {
+            if ( m_currentCellCoords == wxGridNoCellCoords )
+            {
+                // if we have just inserted cols into an empty grid the current
+                // cell will be undefined...
+                //
+                SetCurrentCell( 0, 0 );

             }
 
             }
 

-            m_cellEditCtrl->SetFocus();
+            ClearSelection();
+            if ( !GetBatchCount() ) Refresh();

         }
         }

+
+        SetEditControlValue();
+        return ok;
+    }
+    else
+    {
+        return FALSE;

     }
 }
 
 
     }
 }
 
 

-void wxGrid::HideCellEditControl()
+bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( IsCellEditControlEnabled() )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-        m_cellEditCtrl->Show( FALSE );
+        wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
+        return FALSE;

     }
     }

-}

 
 

-void wxGrid::SetEditControlValue( const wxString& value )
-{
-    if ( m_table )
+    if ( m_table && m_table->AppendCols( numCols ) )

     {
     {

-        wxString s;
-        if ( !value )
-            s = GetCellValue(m_currentCellCoords);
-        else
-            s = value;
-
-        if ( IsTopEditControlEnabled() )
+        // 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 )

         {
         {

-            switch ( m_editCtrlType )
-            {
-                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;
-            }
+            // if we have just inserted cols into an empty grid the current
+            // cell will be undefined...
+            //
+            SetCurrentCell( 0, 0 );

         }
 
         }
 

-        if ( IsCellEditControlEnabled() )
-        {
-            switch ( m_editCtrlType )
-            {
-                case wxGRID_TEXTCTRL:
-                    ((wxGridTextCtrl *)m_cellEditCtrl)->SetStartValue(s);
-                    break;
-
-                case wxGRID_CHECKBOX:
-                    // TODO: implement this
-                    //
-                    break;
-
-                case wxGRID_CHOICE:
-                    // TODO: implement this
-                    //
-                    break;
-                
-                case wxGRID_COMBOBOX:
-                    // TODO: implement this
-                    //
-                    break;
-            }
-        }
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;

     }
 }
 
     }
 }
 

-void wxGrid::SaveEditControlValue()
+
+bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )

 {
 {

-    if ( m_table )
+    // TODO: something with updateLabels flag
+
+    if ( !m_created )

     {
     {

-       wxWindow *ctrl = (wxWindow *)NULL;
+        wxLogError( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
+        return FALSE;
+    }

 
 

-        if ( IsCellEditControlEnabled() )
-        {
-            ctrl = m_cellEditCtrl;
-        }
-        else if ( IsTopEditControlEnabled() )
-        {
-            ctrl = m_topEditCtrl;
-        }
+    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

-        {
-            return;
-        }
-        
-        bool valueChanged = FALSE;
-        
-        switch ( m_editCtrlType )
-        {
-            case wxGRID_TEXTCTRL:
-                valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
-                                ((wxGridTextCtrl *)ctrl)->GetStartValue());
-                SetCellValue( m_currentCellCoords,
-                              ((wxTextCtrl *) ctrl)->GetValue() );
-                break;
-
-            case wxGRID_CHECKBOX:
-                // TODO: implement this
-                //
-                break;
+            HideCellEditControl();

 
 

-            case wxGRID_CHOICE:
-                // TODO: implement this
-                //
-                break;
-                
-            case wxGRID_COMBOBOX:
-                // TODO: implement this
-                //
-                break;
-        }
-        
-        if ( valueChanged )
-        {
-            SendEvent( EVT_WXGRID_CELL_CHANGE,
-                       m_currentCellCoords.GetRow(),
-                       m_currentCellCoords.GetCol() );
-        }
+        ClearSelection();
+        if ( !GetBatchCount() ) Refresh();
+        return TRUE;

     }
     }

-}
-
-
-int wxGrid::XYToArea( int x, int y )
-{
-    if ( x > m_left && x < m_right &&
-         y > m_top && y < m_bottom )
+    else

     {
     {

-        if ( y < m_top + m_colLabelHeight )
-        {
-            if ( x > m_left + m_rowLabelWidth )
-            {
-                return WXGRID_COLLABEL;
-            }
-            else
-            {
-                return WXGRID_CORNERLABEL;
-            }
-        }
-        else if ( x <= m_left + m_rowLabelWidth )
-        {
-            return WXGRID_ROWLABEL;
-        }
-        else
-        {
-            return WXGRID_CELL;
-        }
+        return FALSE;

     }
     }

-
-    return WXGRID_NOAREA;

 }
 
 
 }
 
 

-void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
-{
-    coords.SetRow( YToRow(y) );
-    coords.SetCol( XToCol(x) );
-}

 
 

+//
+// ----- event handlers
+//

 
 

-int wxGrid::YToRow( int y )
+// 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 )

 {
 {

-    int i;
-    
-    if ( y > m_top + m_colLabelHeight )
+    if ( type == EVT_GRID_ROW_SIZE ||
+         type == EVT_GRID_COL_SIZE )

     {
     {

-        for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-        {
-            if ( y < m_rowBottoms[i] )
-            {
-                return i;
-            }
-        }
-    }
+        int rowOrCol = (row == -1 ? col : row);

 
 

-    return -1;
-}
+        wxGridSizeEvent gridEvt( GetId(),
+                                 type,
+                                 this,
+                                 rowOrCol,
+                                 mouseEv.GetX(), mouseEv.GetY(),
+                                 mouseEv.ControlDown(),
+                                 mouseEv.ShiftDown(),
+                                 mouseEv.AltDown(),
+                                 mouseEv.MetaDown() );

 
 

-
-int wxGrid::XToCol( int x )
-{
-    int i;
-    
-    if ( x > m_left + m_rowLabelWidth )
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }
+    else if ( type == EVT_GRID_RANGE_SELECT )

     {
     {

-        for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-        {
-            if ( x < m_colRights[i] )
-            {
-                return i;
-            }
-        }
+        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 -1;
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }

 }
 
 
 }
 
 

-// return the row number that that the y coord is near the edge of, or
-// -1 if not near an edge
+// Generate a grid event of specified type and return the result
+// of ProcessEvent().

 //
 //

-int wxGrid::YToEdgeOfRow( int y )
+bool wxGrid::SendEvent( const wxEventType type,
+                        int row, int col )

 {
 {

-    int i, d;
-    
-    if ( y > m_top + m_colLabelHeight )
+    if ( type == EVT_GRID_ROW_SIZE ||
+         type == EVT_GRID_COL_SIZE )

     {
     {

-        for ( i = m_scrollPosY;  i < m_numRows;  i++ )
-        {
-            if ( m_rowHeights[i] > WXGRID_LABEL_EDGE_ZONE )
-            {
-                d = abs( y - m_rowBottoms[i] );
-                {
-                    if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
-                }
-            }
-        }
-    }
-
-    return -1;
-    
-}
+        int rowOrCol = (row == -1 ? col : row);

 
 

+        wxGridSizeEvent gridEvt( GetId(),
+                                 type,
+                                 this,
+                                 rowOrCol );

 
 

-// 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 )
-{
-    int i, d;
-    
-    if ( x > m_left + m_rowLabelWidth )
-    {
-        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;
-                }
-            }
-        }
+        return GetEventHandler()->ProcessEvent(gridEvt);

     }
     }

+    else
+    {
+        wxGridEvent gridEvt( GetId(),
+                             type,
+                             this,
+                             row, col );

 
 

-    return -1;
-    
+        return GetEventHandler()->ProcessEvent(gridEvt);
+    }

 }
 
 
 }
 
 

-wxRect wxGrid::CellToRect( int row, int col )
+void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )

 {
 {

-    wxRect rect( -1, -1, -1, -1 );
+    wxPaintDC dc( this );

 
 

-    if ( row >= m_scrollPosY  &&  col >= m_scrollPosX )
+    if ( m_currentCellCoords == wxGridNoCellCoords  &&
+         m_numRows && m_numCols )

     {
     {

-        rect.x = m_colRights[col] - m_colWidths[col];
-        rect.y = m_rowBottoms[row] - m_rowHeights[row];
-        rect.width = m_colWidths[col];
-        rect.height = m_rowHeights[ row ];
+        m_currentCellCoords.Set(0, 0);
+        SetEditControlValue();
+        ShowCellEditControl();

     }
     }

-
-    return rect;
-}    
+}

 
 
 
 

-bool wxGrid::MoveCursorUp()
+// 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 )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() > 0 )
-    {
-        SelectCell( m_currentCellCoords.GetRow() - 1,
-                      m_currentCellCoords.GetCol() );
+    CalcDimensions();
+    event.Skip();
+}

 
 

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

 
 

-        return TRUE;
+void wxGrid::OnKeyDown( wxKeyEvent& event )
+{
+    if ( m_inOnKeyDown )
+    {
+        // shouldn't be here - we are going round in circles...
+        //
+        wxLogFatalError( wxT("wxGrid::OnKeyDown called while alread active") );

     }
 
     }
 

-    return FALSE;
-}
+    m_inOnKeyDown = TRUE;

 
 

-bool wxGrid::MoveCursorDown()
-{
-    // TODO: allow for scrolling
+    // propagate the event up and see if it gets processed

     //
     //

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() < m_numRows-1 )
+    wxWindow *parent = GetParent();
+    wxKeyEvent keyEvt( event );
+    keyEvt.SetEventObject( parent );
+
+    if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )

     {
     {

-        SelectCell( m_currentCellCoords.GetRow() + 1,
-                      m_currentCellCoords.GetCol() );
+        // try local handlers
+        //
+        switch ( event.KeyCode() )
+        {
+            case WXK_UP:
+                if ( event.ControlDown() )
+                {
+                    MoveCursorUpBlock();
+                }
+                else
+                {
+                    MoveCursorUp();
+                }
+                break;

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-            
-        return TRUE;
+            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;
+        }

     }
 
     }
 

-    return FALSE;
+    m_inOnKeyDown = FALSE;

 }
 
 }
 

-bool wxGrid::MoveCursorLeft()
+
+void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() > 0 )
+    if ( SendEvent( EVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )

     {
     {

-        SelectCell( m_currentCellCoords.GetRow(),
-                      m_currentCellCoords.GetCol() - 1 );
+        // the event has been intercepted - do nothing
+        return;
+    }

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-        
-        return TRUE;
+    wxClientDC dc( m_gridWin );
+    PrepareDC( dc );
+
+    if ( m_currentCellCoords != wxGridNoCellCoords )
+    {
+        HideCellEditControl();
+        SaveEditControlValue();

     }
 
     }
 

-    return FALSE;
+    m_currentCellCoords = coords;
+
+    SetEditControlValue();
+    ShowCellEditControl();
+
+    if ( IsSelection() )
+    {
+        wxRect r( SelectionToDeviceRect() );
+        ClearSelection();
+        if ( !GetBatchCount() ) m_gridWin->Refresh( TRUE, &r );
+    }

 }
 
 }
 

-bool wxGrid::MoveCursorRight()
+
+//
+// ------ functions to get/send data (see also public functions)
+//
+
+bool wxGrid::GetModelValues()

 {
 {

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

     {
     {

-        SelectCell( m_currentCellCoords.GetRow(),
-                      m_currentCellCoords.GetCol() + 1 );
-
-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
-            
+        // all we need to do is repaint the grid
+        //
+        m_gridWin->Refresh();

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

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

 {
 {

-    if ( m_currentCellCoords != wxGridNoCellCoords  &&
-         m_scrollPosY > 0 )
+    int row, col;
+
+    if ( m_table )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
-        while ( row > 0 )
+        for ( row = 0;  row < m_numRows;  row++ )

         {
         {

-            if ( y + m_rowHeights[row-1] > m_bottom ) break;
-            y += m_rowHeights[ --row ];
+            for ( col = 0;  col < m_numCols;  col++ )
+            {
+                m_table->SetValue( row, col, GetCellValue(row, col) );
+            }

         }
         }

-        SetVerticalScrollPos( row );

 
 

-        SelectCell( row, m_currentCellCoords.GetCol() );

         return TRUE;
     }
         return TRUE;
     }

-    
+

     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxGrid::MovePageDown()
+
+
+// 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_currentCellCoords != wxGridNoCellCoords  &&
-         m_scrollPosY + m_wholeRowsVisible < m_numRows )
+    if ( !m_numRows || !m_numCols ) return;
+
+    size_t i;
+    size_t numCells = m_cellsExposed.GetCount();
+
+    for ( i = 0;  i < numCells;  i++ )

     {
     {

-        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
-        //
-        SelectCell( m_scrollPosY, m_currentCellCoords.GetCol() );
-        return TRUE;
+        DrawCell( dc, m_cellsExposed[i] );

     }
     }

-    
-    return FALSE;

 }
 
 }
 

-bool wxGrid::MoveCursorUpBlock()
+
+void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() > 0 )
-    {
-        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 > 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
-            //
-            row--;
-            while ( row > 0 )
-            {
-                row-- ;
-                if ( !(m_table->IsEmptyCell(row, col)) ) break;
-            }
-        }
-        else
-        {
-            // starting within a block: find the top of the block
-            //
-            while ( row > 0 )
-            {
-                row-- ;
-                if ( m_table->IsEmptyCell(row, col) )
-                {
-                    row++ ;
-                    break;
-                }
-            }
-        }
-        
-        SelectCell( row, col );
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
+#if !DRAW_LINES
+    if ( m_gridLinesEnabled )
+        DrawCellBorder( dc, coords );
+#endif

 
 

-        return TRUE;
-    }
+    DrawCellBackground( dc, coords );

 
 

-    return FALSE;
+    // TODO: separate functions here for different kinds of cells ?
+    // e.g. text, image
+    //
+    DrawCellValue( dc, coords );

 }
 
 }
 

-bool wxGrid::MoveCursorDownBlock()
+
+void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetRow() < m_numRows-1 )
-    {
-        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
-        {
-            // starting within a block: find the bottom of the block
-            //
-            while ( row < m_numRows-1 )
-            {
-                row++ ;
-                if ( m_table->IsEmptyCell(row, col) )
-                {
-                    row-- ;
-                    break;
-                }
-            }
-        }
-        
-        SelectCell( row, col );
+    if ( m_colWidths[coords.GetCol()] <=0  ||
+         m_rowHeights[coords.GetRow()] <= 0 ) return;

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
+    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+    int row = coords.GetRow();
+    int col = coords.GetCol();

 
 

-        return TRUE;
-    }
+    // right hand border
+    //
+    dc.DrawLine( m_colRights[col], m_rowBottoms[row] - m_rowHeights[row],
+                 m_colRights[col], m_rowBottoms[row] );

 
 

-    return FALSE;
+    // bottom border
+    //
+    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row],
+                 m_colRights[col], m_rowBottoms[row] );

 }
 
 }
 

-bool wxGrid::MoveCursorLeftBlock()
+
+void wxGrid::DrawCellBackground( wxDC& dc, const wxGridCellCoords& coords )

 {
 {

-    if ( m_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() > 0 )
+    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 ) )

     {
     {

-        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 );
+        // TODO: improve this
+        //
+        dc.SetBrush( *wxBLACK_BRUSH );
+    }
+    else
+    {
+        dc.SetBrush( wxBrush(GetCellBackgroundColour(row, col), wxSOLID) );
+    }

 
 

-        if ( !IsVisible( m_currentCellCoords ) )
-            MakeCellVisible( m_currentCellCoords );
+    dc.SetPen( *wxTRANSPARENT_PEN );

 
 

-        return TRUE;
+    dc.DrawRectangle( m_colRights[col] - m_colWidths[col] + 1,
+                      m_rowBottoms[row] - m_rowHeights[row] + 1,
+                      m_colWidths[col]-1,
+                      m_rowHeights[row]-1 );
+}
+
+
+void wxGrid::DrawCellValue( 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( wxTRANSPARENT );
+
+    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) );

 
 

-    return FALSE;
+    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 );

 }
 
 }
 

-bool wxGrid::MoveCursorRightBlock()
+
+
+// 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_table &&
-         m_currentCellCoords != wxGridNoCellCoords  &&
-         m_currentCellCoords.GetCol() < m_numCols-1 )
+    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 );
+    }
+
+    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+
+    // horizontal grid lines
+    //
+    int i;
+    for ( i = 0; i <= m_numRows; i++ )

     {
     {

-        int row = m_currentCellCoords.GetRow();
-        int col = m_currentCellCoords.GetCol();
-        
-        if ( m_table->IsEmptyCell(row, col) )
+        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;
-            }
-        }
-        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;
-            }
+            break;

         }
         }

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

         {
         {

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

         }
         }

-        
-        SelectCell( row, col );
+    }

 
 

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

 
 

-        return TRUE;
+    // vertical grid lines
+    //
+    for ( i = 0; i <= m_numCols; i++ )
+    {
+        if ( m_colRights[i] > right )
+        {
+            break;
+        }
+        else if ( m_colRights[i] >= left )
+        {
+            dc.DrawLine( m_colRights[i], top, m_colRights[i], bottom );
+        }

     }
     }

-
-    return FALSE;

 }
 
 
 }
 
 

-
-//
-// ----- grid drawing functions
-//
-
-void wxGrid::DrawLabelAreas( wxDC& dc )
+void wxGrid::DrawRowLabels( wxDC& dc )

 {
 {

-    int cw, ch;
-    GetClientSize(&cw, &ch);
+    if ( !m_numRows || !m_numCols ) return;

 
 

-    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 );
+    size_t i;
+    size_t numLabels = m_rowLabelsExposed.GetCount();
+
+    for ( i = 0;  i < numLabels;  i++ )
+    {
+        DrawRowLabel( dc, m_rowLabelsExposed[i] );
+    }

 }
 
 
 }
 
 

-void wxGrid::DrawColLabels( wxDC& dc )
+void wxGrid::DrawRowLabel( wxDC& dc, int row )

 {
 {

-    int cw, ch;
-    GetClientSize(&cw, &ch);
+    if ( m_rowHeights[row] <= 0 ) return;

 
 

-    if (m_colLabelHeight == 0) return;
+    // draw the label's horizontal border (the vertical border is
+    // provided by the cell area window margin)
+    //
+    dc.SetPen( *wxBLACK_PEN );

 
 

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

 
 

-    wxRect rect;
-    rect.y = m_top + 1;
-    rect.height = m_colLabelHeight - 1;
+    dc.SetPen( *wxWHITE_PEN );

 
 

-    int labelLeft = m_left + m_rowLabelWidth;
-    int i;
-    
-    for ( i = m_scrollPosX;  i < m_numCols;  i++ )
-    {
-        if ( labelLeft > cw) break;
+    dc.DrawLine( 0, m_rowBottoms[row]+2,
+                 m_rowLabelWidth, m_rowBottoms[row]+2 );

 
 

-        rect.x = 1 + labelLeft;
-        rect.width = m_colWidths[i];
-        DrawColLabel( dc, rect, i );
-            
-        labelLeft += m_colWidths[i];
-    }
-}
+    dc.SetBackgroundMode( wxTRANSPARENT );
+    dc.SetTextForeground( GetLabelTextColour() );
+    dc.SetFont( GetLabelFont() );

 
 

+    int hAlign, vAlign;
+    GetRowLabelAlignment( &hAlign, &vAlign );

 
 

-void wxGrid::DrawColLabelBorders( wxDC& dc )
-{
-    if ( m_colLabelHeight <= 0 ) return;
+    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 );
+}

 
 

-    int i;
-    int cw, ch;
-    GetClientSize( &cw, &ch );

 
 

-    dc.SetPen( *wxBLACK_PEN );
-  
-    // horizontal lines
-    //
-    dc.DrawLine( m_left, m_top, cw, m_top );
+void wxGrid::DrawColLabels( wxDC& dc )
+{
+    if ( !m_numRows || !m_numCols ) return;

 
 

-    dc.DrawLine( m_left, m_top + m_colLabelHeight,
-                 cw,     m_top + m_colLabelHeight );
+    size_t i;
+    size_t numLabels = m_colLabelsExposed.GetCount();

 
 

-    // vertical lines
-    //
-    int colLeft = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX;  i <= m_numCols;  i++ )
+    for ( i = 0;  i < numLabels;  i++ )

     {
     {

-        if (colLeft > cw) break;
+        DrawColLabel( dc, m_colLabelsExposed[i] );
+    }
+}

 
 

-        dc.DrawLine( colLeft, m_top,
-                     colLeft, m_top + m_colLabelHeight);

 
 

-        if ( i < m_numCols ) colLeft += m_colWidths[i];
-    }
+void wxGrid::DrawColLabel( wxDC& dc, int col )
+{
+    if ( m_colWidths[col] <= 0 ) return;

 
 

-    // Draw white highlights for a 3d effect
+    // draw the label's vertical border (the horizontal border is
+    // provided by the cell area window margin)

     //
     //

-    dc.SetPen( *wxWHITE_PEN );
-
-    colLeft = m_left + m_rowLabelWidth;
-    for ( i = m_scrollPosX; i < m_numCols; i++ )
-    {
-        if (colLeft > cw) break;
+    dc.SetPen( *wxBLACK_PEN );

 
 

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

 
 

-        dc.DrawLine(colLeft + 1, m_top + 1,
-                    colLeft + 1, m_top + m_colLabelHeight);
-        
-        colLeft += m_colWidths[i];
-    }
-}
+    dc.SetPen( *wxWHITE_PEN );

 
 

+    dc.DrawLine( m_colRights[col]+2, 0,
+                 m_colRights[col]+2, m_colLabelHeight );

 
 

-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 i;
-    int cw, ch;
-    GetClientSize( &cw, &ch );
+    // 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;
+        }
+        else if ( pos == 0 )
+        {
+            lines.Add( wxEmptyString );
+        }
+        else
+        {
+            if ( value[startPos+pos-1] == '\r' )
+            {
+                lines.Add( value.Mid(startPos, pos-1) );
+            }
+            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;
+    }

 
 

-        dc.DrawLine( m_left, rowTop,
-                     m_left + m_rowLabelWidth, rowTop );
+    *width = w;
+    *height = h;
+}

 
 

-        if ( i < m_numRows ) rowTop += m_rowHeights[i];
-    }

 
 

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

 
 

-    rowTop = m_top + m_colLabelHeight;
-    for ( i = m_scrollPosY; i < m_numRows; i++ )
-    {
-        if ( rowTop > ch ) break;

 
 

-        dc.DrawLine( m_left + 1, rowTop + 1,
-                     m_left + m_rowLabelWidth, rowTop + 1 );
+void wxGrid::EnableEditing( bool edit )
+{
+    // TODO: improve this ?
+    //
+    if ( edit != m_editable )
+    {
+        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 );
+
+            switch ( m_editCtrlType )
+            {
+                case wxGRID_TEXTCTRL:
+                    ((wxTextCtrl *) m_cellEditCtrl)->SetInsertionPointEnd();
+                    break;

 
 

-    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
+                case wxGRID_CHECKBOX:
+                    // TODO: anything ???
+                    //
+                    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_CHOICE:
+                    // TODO: anything ???
+                    //
+                    break;

 
 

-        dc.DrawLine( m_left + m_rowLabelWidth + 1, rowTop,
-                     m_right, rowTop);
+                case wxGRID_COMBOBOX:
+                    // TODO: anything ???
+                    //
+                    break;
+            }

 
 

-        if ( i < m_numRows ) rowTop += m_rowHeights[i];
+            m_cellEditCtrl->SetFocus();
+        }

     }
     }

+}

 
 
 
 

-    // vertical grid lines
-    //
-    int colLeft = m_left + m_rowLabelWidth + m_colWidths[m_scrollPosX];
-    for ( i = m_scrollPosX + 1; i <= m_numCols; i++ )
+void wxGrid::HideCellEditControl()
+{
+    if ( IsCellEditControlEnabled() )

     {
     {

-        if ( colLeft > cw ) break;
-
-        dc.DrawLine( colLeft, m_top + m_colLabelHeight + 1,
-                     colLeft, m_bottom );
-
-        if ( i < m_numCols ) colLeft += m_colWidths[i];
+        m_cellEditCtrl->Show( FALSE );

     }
 }
 
 
     }
 }
 
 

-void wxGrid::DrawCells( wxDC& dc )
+void wxGrid::SetEditControlValue( const wxString& value )

 {
 {

-    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++ )
+        wxString s;
+        if ( !value )
+            s = GetCellValue(m_currentCellCoords);
+        else
+            s = value;
+
+        if ( IsCellEditControlEnabled() )

         {
         {

-            if ( rect.y > ch ) break;
+            switch ( m_editCtrlType )
+            {
+                case wxGRID_TEXTCTRL:
+                    ((wxGridTextCtrl *)m_cellEditCtrl)->SetStartValue(s);
+                    break;

 
 

-            rect.height = m_rowHeights[ row ];
-            rect.x = m_left + m_rowLabelWidth;
+                case wxGRID_CHECKBOX:
+                    // TODO: implement this
+                    //
+                    break;

 
 

-            for ( col = m_scrollPosX;  col < m_numCols;  col++ )
-            {
-                if ( rect.x > cw ) break;
+                case wxGRID_CHOICE:
+                    // TODO: implement this
+                    //
+                    break;

 
 

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

             }
             }

-            rect.y += rect.height;

         }
     }
 }
 
 
         }
     }
 }
 
 

-void wxGrid::DrawCellBackground( wxDC& dc, const wxRect& rect, int row, int col )
+void wxGrid::SaveEditControlValue()

 {
 {

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

     {
     {

-        dc.SetBrush( wxBrush(GetCellBackgroundColour(row, col), wxSOLID) );
+        wxWindow *ctrl = (wxWindow *)NULL;
+
+        if ( IsCellEditControlEnabled() )
+        {
+            ctrl = m_cellEditCtrl;
+        }
+        else
+        {
+            return;
+        }
+
+        bool valueChanged = FALSE;
+
+        switch ( m_editCtrlType )
+        {
+            case wxGRID_TEXTCTRL:
+                valueChanged = (((wxGridTextCtrl *)ctrl)->GetValue() !=
+                                ((wxGridTextCtrl *)ctrl)->GetStartValue());
+                SetCellValue( m_currentCellCoords,
+                              ((wxTextCtrl *) ctrl)->GetValue() );
+                break;
+
+            case wxGRID_CHECKBOX:
+                // TODO: implement this
+                //
+                break;
+
+            case wxGRID_CHOICE:
+                // TODO: implement this
+                //
+                break;
+
+            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 );

 }
 
 
 }
 
 

-void wxGrid::DrawCellValue( wxDC& dc, const wxRect& rect, int row, int col )
+//
+// ------ 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.
+//
+
+void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )

 {
 {

-    wxRect rect2;
-    rect2 = rect;
-    rect2.x += 3;
-    rect2.y += 2;
-    rect2.width -= 5;
-    rect2.height -= 4;
-    
-    dc.SetBackgroundMode( wxTRANSPARENT );
+    int row = YToRow(y);
+    int col = XToCol(x);

 
 

-    if ( IsInSelection( row, col ) )
+    if ( row == -1  ||  col == -1 )

     {
     {

-        // TODO: improve this
-        //
-        dc.SetTextBackground( wxColour(0, 0, 0) );
-        dc.SetTextForeground( wxColour(255, 255, 255) );
+        coords = wxGridNoCellCoords;

     }
     else
     {
     }
     else
     {

-        dc.SetTextBackground( GetCellBackgroundColour(row, col) );
-        dc.SetTextForeground( GetCellTextColour(row, col) );
+        coords.Set( row, col );

     }
     }

-    dc.SetFont( GetCellFont(row, col) );
-    
-    int hAlign, vAlign;
-    GetCellAlignment( row, col, &hAlign, &vAlign );
-    DrawTextRectangle( dc, GetCellValue( row, col ), rect2, hAlign, vAlign );

 }
 
 
 }
 
 

-void wxGrid::DrawCellHighlight( wxDC& dc, int row, int col )
+int wxGrid::YToRow( int y )

 {
 {

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

 
 

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

     {
     {

-        long x, y;
+        if ( y < m_rowBottoms[i] ) return i;
+    }

 
 

-        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;
+    return -1;
+}

 
 

-        dc.SetLogicalFunction( wxXOR );
-        dc.SetPen( wxPen(GetCellHighlightColour(), 2, wxSOLID) );
-        dc.SetBrush( *wxTRANSPARENT_BRUSH );

 
 

-        dc.DrawRectangle( x, y,
-                          m_colWidths[col] + 2,
-                          m_rowHeights[row] + 2 );
+int wxGrid::XToCol( int x )
+{
+    int i;

 
 

-        dc.SetLogicalFunction( wxCOPY );
+    for ( i = 0;  i < m_numCols;  i++ )
+    {
+        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;
+            }

         }
     }
         }
     }

-}

 
 

-
-// this is just to make other code more obvious
-//
-void wxGrid::HideCurrentCellHighlight( wxDC& dc )
-{
-    if ( m_currentCellHighlighted  &&
-         m_currentCellCoords != wxGridNoCellCoords )
-    {
-        DrawCellHighlight( dc, m_currentCellCoords );
-        m_currentCellHighlighted = FALSE;
-    }
+    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::ShowCurrentCellHighlight( wxDC& dc )
-{
-    if ( !m_currentCellHighlighted  &&
-         m_currentCellCoords != wxGridNoCellCoords )
-    {
-        DrawCellHighlight( dc, m_currentCellCoords );
-        m_currentCellHighlighted = TRUE;
-    }
-}
-
-
-void wxGrid::DrawTextRectangle( wxDC& dc,
-                                const wxString& value,
-                                const wxRect& rect,
-                                int horizAlign,
-                                int vertAlign )
+int wxGrid::XToEdgeOfCol( int x )

 {
 {

-    long textWidth, textHeight;
-    long lineWidth, lineHeight;
-    wxArrayString lines;
-    
-    // see if we are already clipping
-    //
-    wxRect clipRect;
-    dc.GetClippingBox( clipRect );
-
-    bool alreadyClipping = TRUE;
-    wxRect intersectRect;
+    int i, d;

 
 

-    if ( clipRect.x == 0 && clipRect.y == 0 &&
-         clipRect.width == 0 && clipRect.height == 0)
-    {
-        alreadyClipping = FALSE;
-        intersectRect = rect;
-    }
-    else
+    for ( i = 0;  i < m_numCols;  i++ )

     {
     {

-        // Find the intersection of the clipping rectangle and our
-        // rectangle
-        //
-        wxRegion region( rect );
-        region.Intersect( clipRect );
-        if ( region.IsEmpty() )
+        if ( m_colWidths[i] > WXGRID_LABEL_EDGE_ZONE )

         {
         {

-            // nothing to do
-            //
-            return;
+            d = abs( x - m_colRights[i] );
+            {
+                if ( d < WXGRID_LABEL_EDGE_ZONE ) return i;
+            }

         }
         }

-        intersectRect = region.GetBox();

     }
 
     }
 

-    if ( alreadyClipping ) dc.DestroyClippingRegion();
-
-    dc.SetClippingRegion( intersectRect );
+    return -1;
+}

 
 

-    StringToLines( value, lines );
-    if ( lines.GetCount() )
-    {
-        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;

 
 

-            case wxCENTRE:
-                x = rect.x + ((rect.width - textWidth)/2.0);
-                break;
+wxRect wxGrid::CellToRect( int row, int col )
+{
+    wxRect rect( -1, -1, -1, -1 );

 
 

-            case wxLEFT:
-            default:
-                x = rect.x + 1.0;
-                break;
-        }
+    if ( row >= 0  &&  row < m_numRows  &&
+         col >= 0  &&  col < m_numCols )
+    {
+        rect.x = m_colRights[col] - m_colWidths[col];
+        rect.y = m_rowBottoms[row] - m_rowHeights[row];
+        rect.width = m_colWidths[col];
+        rect.height = m_rowHeights[ row ];
+    }

 
 

-        switch ( vertAlign )
-        {
-            case wxBOTTOM:
-                y = rect.y + (rect.height - textHeight - 1);
-                break;
+    return rect;
+}

 
 

-            case wxCENTRE:
-                y = rect.y + ((rect.height - textHeight)/2.0);
-                break;

 
 

-            case wxTOP:
-            default:
-                y = rect.y + 1.0;
-                break;
-        }
+bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
+{
+    // get the cell rectangle in logical coords
+    //
+    wxRect r( CellToRect( row, col ) );

 
 

-        for ( size_t i = 0;  i < lines.GetCount();  i++ )
-        {
-            dc.DrawText( lines[i], (long)x, (long)y );
-            y += lineHeight;
-        }
+    // convert to device coords
+    //
+    int left, top, right, bottom;
+    CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
+    CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
+
+    // check against the client area of the grid window
+    //
+    int cw, ch;
+    m_gridWin->GetClientSize( &cw, &ch );
+
+    if ( wholeCellVisible )
+    {
+        // is the cell wholly visible ?
+        //
+        return ( left >= 0  &&  right <= cw  &&
+                 top >= 0  &&  bottom <= ch );
+    }
+    else
+    {
+        // is the cell partly visible ?
+        //
+        return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
+                 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );

     }
     }

-    
-    dc.DestroyClippingRegion();
-    if (alreadyClipping) dc.SetClippingRegion( clipRect );

 }
 
 
 }
 
 

-// Split multi line text up into an array of strings.  Any existing
-// contents of the string array are preserved.
+// make the specified cell location visible by doing a minimal amount
+// of scrolling

 //
 //

-void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
+void wxGrid::MakeCellVisible( int row, int col )

 {
 {

-    // 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() )
+    int i;
+    int xpos = -1, ypos = -1;
+
+    if ( row >= 0  &&  row < m_numRows  &&
+         col >= 0  &&  col < m_numCols )

     {
     {

-        pos = value.Mid(startPos).Find( '\n' );
-        if ( pos < 0 )
-        {
-            break;
-        }
-        else if ( pos == 0 )
+        // get the cell rectangle in logical coords
+        //
+        wxRect r( CellToRect( row, col ) );
+
+        // convert to device coords
+        //
+        int left, top, right, bottom;
+        CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
+        CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
+
+        int cw, ch;
+        m_gridWin->GetClientSize( &cw, &ch );
+
+        if ( top < 0 )

         {
         {

-            lines.Add( wxEmptyString );
+            ypos = r.GetTop();

         }
         }

-        else
+        else if ( bottom > ch )

         {
         {

-            if ( value[startPos+pos-1] == '\r' )
-            {
-                lines.Add( value.Mid(startPos, pos-1) );
-            }
-            else
+            int h = r.GetHeight();
+            ypos = r.GetTop();
+            for ( i = row-1;  i >= 0;  i-- )

             {
             {

-                lines.Add( value.Mid(startPos, pos) );
+                if ( h + m_rowHeights[i] > ch ) break;
+
+                h += m_rowHeights[i];
+                ypos -= m_rowHeights[i];

             }
             }

+
+            // 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;

         }
         }

-        startPos += pos+1;
-    }
-    if ( startPos < (int)value.Length() )
-    {
-        lines.Add( value.Mid( startPos ) );
-    }
-}

 
 

+        if ( left < 0 )
+        {
+            xpos = r.GetLeft();
+        }
+        else if ( right > cw )
+        {
+            int w = r.GetWidth();
+            xpos = r.GetLeft();
+            for ( i = col-1;  i >= 0;  i-- )
+            {
+                if ( w + m_colWidths[i] > cw ) break;

 
 

-void wxGrid::GetTextBoxSize( wxDC& dc,
-                             wxArrayString& lines,
-                             long *width, long *height )
-{
-    long w = 0;
-    long h = 0;
-    long lineW, lineH;
+                w += m_colWidths[i];
+                xpos -= m_colWidths[i];
+            }

 
 

-    size_t i;
-    for ( i = 0;  i < lines.GetCount();  i++ )
-    {
-        dc.GetTextExtent( lines[i], &lineW, &lineH );
-        w = wxMax( w, lineW );
-        h += lineH;
-    }
+            // see comment for ypos above
+            xpos += GRID_SCROLL_LINE / 2;
+        }

 
 

-    *width = w;
-    *height = h;
+        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;
     }
 


@@ -3272,291 +3484,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( "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( "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 ( !GetBatchCount() ) Refresh();
+            newRow = 0;

         }
         }

-        SetEditControlValue();
-        return ok;
-    }
-    else
-    {
-        return FALSE;
+        else if ( newRow == row )
+        {
+            newRow = row - 1;
+        }
+
+        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 )
-    {
-        wxLogError( "Called wxGrid::AppendRows() before calling CreateGrid()" );
-        return FALSE;
-    }
-    
-    if ( m_table && m_table->AppendRows( numRows ) )
+    if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
+
+    int row = m_currentCellCoords.GetRow();
+    if ( row < m_numRows )

     {
     {

-        // the table will have sent the results of the append row
-        // operation to this view object as a grid table message
-        //
-        if ( !GetBatchCount() ) Refresh();
+        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;
     }
         return TRUE;
     }

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

 }
 
 }
 

-bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
-{
-    // TODO: something with updateLabels flag
+bool wxGrid::MoveCursorUpBlock()
+{
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetRow() > 0 )
+    {
+        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 > 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
+            //
+            row--;
+            while ( row > 0 )
+            {
+                row-- ;
+                if ( !(m_table->IsEmptyCell(row, col)) ) break;
+            }
+        }
+        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 );

 
 

-    if ( !m_created )
-    {
-        wxLogError( "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
-        //
-        if ( m_numRows > 0 )
-            SetEditControlValue();
-        else
-            HideCellEditControl();
-        
-        if ( !GetBatchCount() ) Refresh();

         return TRUE;
     }
         return TRUE;
     }

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

 }
 
 }
 

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

 {
 {

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

     {
     {

-        wxLogError( "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 );
-        if ( ok )
+        if ( m_table->IsEmptyCell(row, col) )

         {
         {

-            // the table will have sent the results of the insert col
-            // operation to this view object as a grid table message
+            // starting in an empty cell: find the next block of
+            // non-empty cells

             //
             //

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

         }
         }

-        SetEditControlValue();
-        return ok;
-    }
-    else
-    {
-        return FALSE;
-    }
-}

 
 

-bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
-{
-    // TODO: something with updateLabels flag
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );

 
 

-    if ( !m_created )
-    {
-       wxLogError( "Called wxGrid::AppendCols() before calling CreateGrid()" );
-       return FALSE;
+        return TRUE;

     }
 
     }
 

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

 }
 
 }
 

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

 {
 {

-    // TODO: something with updateLabels flag
-    
-    if ( !m_created )
-    {
-        wxLogError( "Called wxGrid::DeleteCols() before calling CreateGrid()" );
-        return FALSE;
-    }
-    
-    if ( m_table && m_table->DeleteCols( pos, numCols ) )
-    {
-        // the table will have sent the results of the delete col
-        // operation to this view object as a grid table message
-        //
-        if ( m_numCols > 0 )
-            SetEditControlValue();
-        else
-            HideCellEditControl();
-        
-        if ( !GetBatchCount() ) Refresh();
-        return TRUE;
-    }
-    else
+    if ( m_table &&
+         m_currentCellCoords != wxGridNoCellCoords  &&
+         m_currentCellCoords.GetCol() > 0 )

     {
     {

-        return FALSE;
-    }
-}
-    
-
+        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;
+                }
+            }
+        }

 
 

-// ------ 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 )
-    {
-        HideCellEditControl();
-        SaveEditControlValue();
-        
-        m_cellEditCtrlEnabled = enable;
+        MakeCellVisible( row, col );
+        SetCurrentCell( row, col );

 
 

-        SetEditControlValue();
-        ShowCellEditControl();
+        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 )


@@ -3601,36 +3868,53 @@ 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();
+    // TODO: how to do this with the box sizers ?

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

-    m_colLabelHeight = wxMax( 0, height );
-    CalcDimensions();
-    ShowCellEditControl();
-    if ( !GetBatchCount() ) Refresh();
+    // TODO: how to do this with the box sizers ?

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


@@ -3639,13 +3923,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 )


@@ -3654,13 +3941,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 )


@@ -3668,7 +3958,16 @@ 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 )
+            {
+                rect.x = m_left;
+                rect.width = m_rowLabelWidth;
+                m_rowLabelWin->Refresh( TRUE, &rect );
+            }
+        }

     }
 }
 
     }
 }
 


@@ -3677,16 +3976,29 @@ 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 )
+            {
+                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 );
+    }

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


@@ -3694,7 +4006,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 );
+            }
+            else
+            {
+                m_gridWin->Refresh();
+            }
+        }

     }
 }
 
     }
 }
 


@@ -3732,33 +4057,25 @@ wxColour wxGrid::GetDefaultCellBackgroundColour()
     return wxColour( 255, 255, 255 );
 }
 
     return wxColour( 255, 255, 255 );
 }
 

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

 {
     // TODO: replace this temp test code
     //
 {
     // TODO: replace this temp test code
     //

-    return wxColour( 255, 255, 255 );    
+    return wxColour( 255, 255, 255 );

 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
     // TODO: replace this temp test code
     //
 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
     // TODO: replace this temp test code
     //

-    return wxColour( 0, 0, 0 );    
-}
-
-wxColour wxGrid::GetCellTextColour( int row, int col )
-{
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );    
+    return wxColour( 0, 0, 0 );

 }
 
 }
 

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

 {
     // TODO: replace this temp test code
     //
 {
     // TODO: replace this temp test code
     //

-    return wxColour( 0, 0, 0 );    
+    return wxColour( 0, 0, 0 );

 }
 
 
 }
 
 


@@ -3767,7 +4084,7 @@ wxFont wxGrid::GetDefaultCellFont()
     return m_defaultCellFont;
 }
 
     return m_defaultCellFont;
 }
 

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

 {
     // TODO: replace this temp test code
     //
 {
     // TODO: replace this temp test code
     //


@@ -3782,7 +4099,7 @@ void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
     *vert  = wxTOP;
 }
 
     *vert  = wxTOP;
 }
 

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

 {
     // TODO: replace this temp test code
     //
 {
     // TODO: replace this temp test code
     //


@@ -3796,31 +4113,38 @@ 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;

         }
         CalcDimensions();
         }
         CalcDimensions();

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

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

+    int i;
+

     if ( row >= 0  &&  row < m_numRows )
     {
     if ( row >= 0  &&  row < m_numRows )
     {

-        m_rowHeights[row] = wxMax( 0, height );
+        int h = wxMax( 0, height );
+        int diff = h - m_rowHeights[row];
+
+        m_rowHeights[row] = h;
+        for ( i = row;  i < m_numRows;  i++ )
+        {
+            m_rowBottoms[i] += diff;
+        }

         CalcDimensions();
         CalcDimensions();

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

 
         // Note: we are ending the event *after* doing
         // default processing in this case
         //
 
         // Note: we are ending the event *after* doing
         // default processing in this case
         //

-        SendEvent( EVT_WXGRID_ROW_SIZE,
+        SendEvent( EVT_GRID_ROW_SIZE,

                    row, -1 );
     }
     else
                    row, -1 );
     }
     else


@@ -3835,31 +4159,38 @@ 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;

         }
         CalcDimensions();
         }
         CalcDimensions();

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

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

+    int i;
+

     if ( col >= 0  &&  col < m_numCols )
     {
     if ( col >= 0  &&  col < m_numCols )
     {

-        m_colWidths[col] = wxMax( 0, width );
+        int w = wxMax( 0, width );
+        int diff = w - m_colWidths[col];
+        m_colWidths[col] = w;
+
+        for ( i = col;  i < m_numCols;  i++ )
+        {
+            m_colRights[i] += diff;
+        }

         CalcDimensions();
         CalcDimensions();

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

 
         // Note: we are ending the event *after* doing
         // default processing in this case
         //
 
         // Note: we are ending the event *after* doing
         // default processing in this case
         //

-        SendEvent( EVT_WXGRID_COL_SIZE,
+        SendEvent( EVT_GRID_COL_SIZE,

                    -1, col );
     }
     else
                    -1, col );
     }
     else


@@ -3874,7 +4205,7 @@ void wxGrid::SetDefaultCellBackgroundColour( const wxColour& )
     //
 }
 
     //
 }
 

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

 {
     // TODO: everything !!!
     //
 {
     // TODO: everything !!!
     //


@@ -3886,13 +4217,7 @@ void wxGrid::SetDefaultCellTextColour( const wxColour& )
     //
 }
 
     //
 }
 

-void wxGrid::SetCellTextColour( int row, int col, const wxColour& )
-{
-    // TODO: everything !!!
-    //
-}
-
-void wxGrid::SetCellHighlightColour( const wxColour& )
+void wxGrid::SetCellTextColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )

 {
     // TODO: everything !!!
     //
 {
     // TODO: everything !!!
     //


@@ -3904,25 +4229,26 @@ void wxGrid::SetDefaultCellFont( const wxFont& )
     //
 }
 
     //
 }
 

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

 {
     // TODO: everything !!!
     //
 }
 
 {
     // TODO: everything !!!
     //
 }
 

-void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
+void wxGrid::SetDefaultCellAlignment( int WXUNUSED(horiz), int WXUNUSED(vert) )

 {
     // TODO: everything !!!
     //
 }
 
 {
     // TODO: everything !!!
     //
 }
 

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

 {
     // TODO: everything !!!
     //
 }
 
 
 {
     // TODO: everything !!!
     //
 }
 
 

+

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


@@ -3932,173 +4258,101 @@ 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( TRUE, &(rect[i]) );

     }
     else
     {
     }
     else
     {

+        r = SelectionToDeviceRect();

         ClearSelection();
         ClearSelection();

+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &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( TRUE, &r );

     }
 
     }
 

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

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

-                                    EVT_WXGRID_RANGE_SELECT,
+                                    EVT_GRID_RANGE_SELECT,

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


@@ -4109,33 +4363,74 @@ 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 );

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

 
 

-        m_selectedBottomRight.SetRow( m_numRows - 1 );
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( TRUE, &(rect[i]) );

     }
     else
     {
     }
     else
     {

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

         ClearSelection();
         ClearSelection();

+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &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( TRUE, &r );

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

-                                    EVT_WXGRID_RANGE_SELECT,
+                                    EVT_GRID_RANGE_SELECT,

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


@@ -4147,7 +4442,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;


@@ -4162,26 +4458,113 @@ 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( TRUE, &(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(),

-                                        EVT_WXGRID_RANGE_SELECT,
+                                        EVT_GRID_RANGE_SELECT,

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

-    
+

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


@@ -4191,60 +4574,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
 //


@@ -4264,7 +4652,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);
 }
 


@@ -4283,7 +4671,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);
 }
 


@@ -4291,10 +4679,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;