]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/grid.cpp
Made HelpGen compile here.
[wxWidgets.git] / src / generic / grid.cpp
index 48e9a6b61ab8dddf2285124cefc4746f24d3d974..af3daea9cfca0ec62c57875182a7e21badf67c16 100644 (file)
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"
-    #include "wx/sizer.h"
 #endif
 
+// this include needs to be outside precomp for BCC
+#include "wx/textfile.h"
+
 #include "wx/generic/grid.h"
 
+// ----------------------------------------------------------------------------
+// array classes instantiation
+// ----------------------------------------------------------------------------
+
+struct wxGridCellWithAttr
+{
+    wxGridCellWithAttr(int row, int col, const wxGridCellAttr *pAttr)
+        : coords(row, col), attr(*pAttr)
+    {
+    }
+
+    wxGridCellCoords coords;
+    wxGridCellAttr   attr;
+};
+
+WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
+
+#include "wx/arrimpl.cpp"
+
+WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
+WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
+{
+public:
+    wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent& event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
+{
+public:
+    wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
+{
+public:
+    wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
+                             const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid *m_owner;
+
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+    void OnPaint( wxPaintEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+class WXDLLEXPORT wxGridWindow : public wxPanel
+{
+public:
+    wxGridWindow()
+    {
+        m_owner = (wxGrid *)NULL;
+        m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
+        m_colLabelWin = (wxGridColLabelWindow *)NULL;
+    }
+
+    wxGridWindow( wxGrid *parent,
+                  wxGridRowLabelWindow *rowLblWin,
+                  wxGridColLabelWindow *colLblWin,
+                  wxWindowID id, const wxPoint &pos, const wxSize &size );
+    ~wxGridWindow();
+
+    void ScrollWindow( int dx, int dy, const wxRect *rect );
+
+private:
+    wxGrid                   *m_owner;
+    wxGridRowLabelWindow     *m_rowLabelWin;
+    wxGridColLabelWindow     *m_colLabelWin;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& );
+
+    DECLARE_DYNAMIC_CLASS(wxGridWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+// the internal data representation used by wxGridCellAttrProvider
+//
+// TODO make it more efficient
+class WXDLLEXPORT wxGridCellAttrProviderData
+{
+public:
+    void SetAttr(const wxGridCellAttr *attr, int row, int col);
+    wxGridCellAttr *GetAttr(int row, int col) const;
+
+private:
+    // searches for the attr for given cell, returns wxNOT_FOUND if not found
+    int FindIndex(int row, int col) const;
+
+    wxGridCellWithAttrArray m_attrs;
+};
+
+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
 #ifndef WXGRID_DRAW_LINES
 #define WXGRID_DRAW_LINES 1
 #endif
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
-// 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;
 
+// ----------------------------------------------------------------------------
+// wxGridCellAttrProviderData
+// ----------------------------------------------------------------------------
+
+void wxGridCellAttrProviderData::SetAttr(const wxGridCellAttr *attr,
+                                         int row, int col)
+{
+    int n = FindIndex(row, col);
+    if ( n == wxNOT_FOUND )
+    {
+        // add the attribute
+        m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
+    }
+    else
+    {
+        if ( attr )
+        {
+            // change the attribute
+            m_attrs[(size_t)n].attr = *attr;
+        }
+        else
+        {
+            // remove this attribute
+            m_attrs.RemoveAt((size_t)n);
+        }
+    }
+
+    delete attr;
+}
+
+wxGridCellAttr *wxGridCellAttrProviderData::GetAttr(int row, int col) const
+{
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
+
+    int n = FindIndex(row, col);
+    if ( n != wxNOT_FOUND )
+    {
+        attr = new wxGridCellAttr(m_attrs[(size_t)n].attr);
+    }
+
+    return attr;
+}
+
+int wxGridCellAttrProviderData::FindIndex(int row, int col) const
+{
+    size_t count = m_attrs.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        const wxGridCellCoords& coords = m_attrs[n].coords;
+        if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
+        {
+            return n;
+        }
+    }
+
+    return wxNOT_FOUND;
+}
+
+// ----------------------------------------------------------------------------
+// wxGridCellAttrProvider
+// ----------------------------------------------------------------------------
+
+wxGridCellAttrProvider::wxGridCellAttrProvider()
+{
+    m_data = (wxGridCellAttrProviderData *)NULL;
+}
+
+wxGridCellAttrProvider::~wxGridCellAttrProvider()
+{
+    delete m_data;
+}
+
+void wxGridCellAttrProvider::InitData()
+{
+    m_data = new wxGridCellAttrProviderData;
+}
+
+wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
+{
+    return m_data ? m_data->GetAttr(row, col) : (wxGridCellAttr *)NULL;
+}
+
+void wxGridCellAttrProvider::SetAttr(const wxGridCellAttr *attr,
+                                     int row, int col)
+{
+    if ( !m_data )
+        InitData();
+
+    m_data->SetAttr(attr, row, col);
+}
+
 //////////////////////////////////////////////////////////////////////
 //
 // Abstract base class for grid data (the model)
@@ -62,66 +283,88 @@ IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
 
 
 wxGridTableBase::wxGridTableBase()
-        : wxObject()
 {
     m_view = (wxGrid *) NULL;
+    m_attrProvider = (wxGridCellAttrProvider *) NULL;
 }
 
 wxGridTableBase::~wxGridTableBase()
 {
+    delete m_attrProvider;
 }
 
+void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
+{
+    delete m_attrProvider;
+    m_attrProvider = attrProvider;
+}
+
+wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
+{
+    if ( m_attrProvider )
+        return m_attrProvider->GetAttr(row, col);
+    else
+        return (wxGridCellAttr *)NULL;
+}
+
+void wxGridTableBase::SetAttr(const wxGridCellAttr *attr, int row, int col )
+{
+    if ( m_attrProvider )
+    {
+        m_attrProvider->SetAttr(attr, row, col);
+    }
+    else
+    {
+        // as we take ownership of the pointer and don't store it, we must
+        // free it now
+        delete attr;
+    }
+}
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function InsertRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
+    wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
+                    "but your derived table class does not override this function") );
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendRows( size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function AppendRows(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numRows );
+    wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function DeleteRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
+    wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function InsertCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
+    wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
+                  "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendCols( size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function AppendCols(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numCols );
+    wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
+                   "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function DeleteCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
+    wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
@@ -361,9 +604,11 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
 
     if ( pos >= curNumRows )
     {
-        wxLogError( wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d rows"),
-                    pos, numRows, curNumRows );
+        wxString errmsg;
+        errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
+                      "Pos value is invalid for present table with %d rows",
+                      pos, numRows, curNumRows );
+        wxFAIL_MSG( wxT(errmsg) );
         return FALSE;
     }
 
@@ -439,8 +684,8 @@ bool wxGridStringTable::AppendCols( size_t numCols )
     {
         // TODO: something better than this ?
         //
-        wxLogError( wxT("Unable to append cols to a grid table with no rows.\n"
-                    "Call AppendRows() first") );
+        wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
+                        "Call AppendRows() first") );
         return FALSE;
     }
 
@@ -473,9 +718,11 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
 
     if ( pos >= curNumCols )
     {
-        wxLogError( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d cols"),
-                    pos, numCols, curNumCols );
+        wxString errmsg;
+        errmsg.Printf( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
+                        "Pos value is invalid for present table with %d cols",
+                        pos, numCols, curNumCols );
+        wxFAIL_MSG( wxT( errmsg ) );
         return FALSE;
     }
 
@@ -809,15 +1056,15 @@ wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *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 );
-    
+
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( 0, 0, client_width, 0 );
     dc.DrawLine( 0, 0, 0, client_height );
@@ -854,7 +1101,7 @@ 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" )
+        : wxPanel( parent, id, pos, size, 0, "grid window" )
 {
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
@@ -940,23 +1187,33 @@ wxGrid::~wxGrid()
 
 void wxGrid::Create()
 {
-    int colLblH = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
-    int rowLblW = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_created = FALSE;    // set to TRUE by CreateGrid
+    m_displayed = FALSE;  // set to TRUE by OnPaint
+
+    m_table        = (wxGridTableBase *) NULL;
+    m_cellEditCtrl = (wxWindow *) NULL;
+
+    m_numRows = 0;
+    m_numCols = 0;
+    m_currentCellCoords = wxGridNoCellCoords;
+
+    m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
+
+    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
+                                                    -1,
+                                                    wxDefaultPosition,
+                                                    wxDefaultSize );
 
     m_rowLabelWin = new wxGridRowLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,
-                                              wxSize(rowLblW,-1) );
+                                              wxDefaultSize );
 
     m_colLabelWin = new wxGridColLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,
-                                              wxSize(-1, colLblH ) );
-
-    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
-                                                    -1,
-                                                    wxDefaultPosition,
-                                                    wxSize(rowLblW, colLblH ) );
+                                              wxDefaultSize );
 
     m_gridWin = new wxGridWindow( this,
                                   m_rowLabelWin,
@@ -966,23 +1223,6 @@ void wxGrid::Create()
                                   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 );
 }
 
 
@@ -990,7 +1230,7 @@ bool wxGrid::CreateGrid( int numRows, int numCols )
 {
     if ( m_created )
     {
-        wxLogError( wxT("wxGrid::CreateGrid(numRows, numCols) called more than once") );
+        wxFAIL_MSG( wxT("wxGrid::CreateGrid called more than once") );
         return FALSE;
     }
     else
@@ -1072,14 +1312,18 @@ void wxGrid::Init()
         m_colRights.Add( colRight );
     }
 
-    // TODO: improve this ?
+    // TODO: improve this by using wxSystemSettings?
     //
-    m_defaultCellFont = this->GetFont();
+    m_defaultCellFont = GetFont();
+
+    m_defaultCellHAlign = wxLEFT;
+    m_defaultCellVAlign = wxTOP;
 
     m_gridLineColour = wxColour( 128, 128, 255 );
     m_gridLinesEnabled = TRUE;
 
     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
+    m_winCapture = (wxWindow *)NULL;
     m_dragLastPos  = -1;
     m_dragRowOrCol = -1;
     m_isDragging = FALSE;
@@ -1124,8 +1368,8 @@ void wxGrid::CalcDimensions()
 
     if ( m_numRows > 0  &&  m_numCols > 0 )
     {
-        int right = m_colRights[ m_numCols-1 ] + 20;
-        int bottom = m_rowBottoms[ m_numRows-1 ] + 20;
+        int right = m_colRights[ m_numCols-1 ] + 50;
+        int bottom = m_rowBottoms[ m_numRows-1 ] + 50;
 
         // TODO: restore the scroll position that we had before sizing
         //
@@ -1133,11 +1377,30 @@ void wxGrid::CalcDimensions()
         GetViewStart( &x, &y );
         SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
                        right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
-                       x, y, TRUE );
+                       x, y );
     }
 }
 
 
+void wxGrid::CalcWindowSizes()
+{
+    int cw, ch;
+    GetClientSize( &cw, &ch );
+
+    if ( m_cornerLabelWin->IsShown() )
+        m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
+
+    if ( m_colLabelWin->IsShown() )
+        m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
+
+    if ( m_rowLabelWin->IsShown() )
+        m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
+
+    if ( m_gridWin->IsShown() )
+        m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
+}
+
+
 // this is called when the grid table sends a message to say that it
 // has been redimensioned
 //
@@ -1511,14 +1774,16 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                 break;
 
                 case WXGRID_CURSOR_SELECT_ROW:
-                {
                     if ( (row = YToRow( y )) >= 0  &&
                          !IsInSelection( row, 0 ) )
                     {
                         SelectRow( row, TRUE );
                     }
-                }
-                break;
+
+                // default label to suppress warnings about "enumeration value
+                // 'xxx' not handled in switch
+                default:
+                    break;
             }
         }
         return;
@@ -1527,9 +1792,17 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     m_isDragging = FALSE;
 
 
+    // ------------ Entering or leaving the window
+    //
+    if ( event.Entering() || event.Leaving() )
+    {
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
+    }
+
+
     // ------------ Left button pressed
     //
-    if ( event.LeftDown() )
+    else if ( event.LeftDown() )
     {
         // don't send a label click event for a hit on the
         // edge of the row label - this is probably the user
@@ -1542,14 +1815,14 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                  !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
             {
                 SelectRow( row, event.ShiftDown() );
-                m_cursorMode = WXGRID_CURSOR_SELECT_ROW;
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
             }
         }
         else
         {
             // starting to drag-resize a row
             //
-            m_rowLabelWin->CaptureMouse();
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
         }
     }
 
@@ -1572,48 +1845,16 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     {
         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
         {
-            m_rowLabelWin->ReleaseMouse();
+            DoEndDragResizeRow();
 
-            if ( m_dragLastPos >= 0 )
-            {
-                // erase the last line and resize the row
-                //
-                int cw, ch, left, dummy;
-                m_gridWin->GetClientSize( &cw, &ch );
-                CalcUnscrolledPosition( 0, 0, &left, &dummy );
-
-                wxClientDC dc( m_gridWin );
-                PrepareDC( dc );
-                dc.SetLogicalFunction( wxINVERT );
-                dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
-                HideCellEditControl();
-
-                int rowTop = m_rowBottoms[m_dragRowOrCol] - m_rowHeights[m_dragRowOrCol];
-                SetRowSize( m_dragRowOrCol, wxMax( y - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
-                if ( !GetBatchCount() )
-                {
-                  // Only needed to get the correct rect.y:
-                  wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
-                  rect.x = 0;
-                  CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
-                  rect.width = m_rowLabelWidth;
-                  rect.height = ch - rect.y;
-                  m_rowLabelWin->Refresh( TRUE, &rect );
-                  rect.width = cw;
-                  m_gridWin->Refresh( TRUE, &rect );
-                }
-
-                ShowCellEditControl();
-
-                // Note: we are ending the event *after* doing
-                // default processing in this case
-                //
-                SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
-            }
+            // Note: we are ending the event *after* doing
+            // default processing in this case
+            //
+            SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
         }
 
-        m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
-        m_dragLastPos  = -1;
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
+        m_dragLastPos = -1;
     }
 
 
@@ -1650,17 +1891,13 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {
-                m_cursorMode = WXGRID_CURSOR_RESIZE_ROW;
-                m_rowLabelWin->SetCursor( m_rowResizeCursor );
+                // don't capture the mouse yet
+                ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
             }
         }
-        else
+        else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
         {
-            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-            {
-                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                m_rowLabelWin->SetCursor( *wxSTANDARD_CURSOR );
-            }
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
         }
     }
 }
@@ -1699,14 +1936,16 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                 break;
 
                 case WXGRID_CURSOR_SELECT_COL:
-                {
                     if ( (col = XToCol( x )) >= 0  &&
                          !IsInSelection( 0, col ) )
                     {
                         SelectCol( col, TRUE );
                     }
-                }
-                break;
+
+                // default label to suppress warnings about "enumeration value
+                // 'xxx' not handled in switch
+                default:
+                    break;
             }
         }
         return;
@@ -1715,9 +1954,17 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
     m_isDragging = FALSE;
 
 
+    // ------------ Entering or leaving the window
+    //
+    if ( event.Entering() || event.Leaving() )
+    {
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
+    }
+
+
     // ------------ Left button pressed
     //
-    if ( event.LeftDown() )
+    else 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
@@ -1730,14 +1977,14 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                  !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
             {
                 SelectCol( col, event.ShiftDown() );
-                m_cursorMode = WXGRID_CURSOR_SELECT_COL;
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
             }
         }
         else
         {
             // starting to drag-resize a col
             //
-            m_colLabelWin->CaptureMouse();
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
         }
     }
 
@@ -1760,48 +2007,15 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
     {
         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
         {
-            m_colLabelWin->ReleaseMouse();
-
-            if ( m_dragLastPos >= 0 )
-            {
-                // 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();
+            DoEndDragResizeCol();
 
-                int colLeft = m_colRights[m_dragRowOrCol] - m_colWidths[m_dragRowOrCol];
-                SetColSize( m_dragRowOrCol, wxMax( x - colLeft, WXGRID_MIN_COL_WIDTH ) );
-
-                if ( !GetBatchCount() )
-                {
-                  // Only needed to get the correct rect.x:
-                  wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
-                  rect.y = 0;
-                  CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
-                  rect.width = cw - rect.x;
-                  rect.height = m_colLabelHeight;
-                  m_colLabelWin->Refresh( TRUE, &rect );
-                  rect.height = ch;
-                  m_gridWin->Refresh( TRUE, &rect );
-                }
-
-                ShowCellEditControl();
-
-                // Note: we are ending the event *after* doing
-                // default processing in this case
-                //
-                SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
-            }
+            // Note: we are ending the event *after* doing
+            // default processing in this case
+            //
+            SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
         }
 
-        m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
+        ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
         m_dragLastPos  = -1;
     }
 
@@ -1839,17 +2053,13 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {
-                m_cursorMode = WXGRID_CURSOR_RESIZE_COL;
-                m_colLabelWin->SetCursor( m_colResizeCursor );
+                // don't capture the cursor yet
+                ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
             }
         }
-        else
+        else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
         {
-            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-            {
-                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-                m_colLabelWin->SetCursor( *wxSTANDARD_CURSOR );
-            }
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
         }
     }
 }
@@ -1890,6 +2100,69 @@ void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
     }
 }
 
+void wxGrid::ChangeCursorMode(CursorMode mode,
+                              wxWindow *win,
+                              bool captureMouse)
+{
+#ifdef __WXDEBUG__
+    static const wxChar *cursorModes[] =
+    {
+        _T("SELECT_CELL"),
+        _T("RESIZE_ROW"),
+        _T("RESIZE_COL"),
+        _T("SELECT_ROW"),
+        _T("SELECT_COL")
+    };
+
+    wxLogTrace(_T("grid"),
+               _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
+               win == m_colLabelWin ? _T("colLabelWin")
+                                    : win ? _T("rowLabelWin")
+                                          : _T("gridWin"),
+               cursorModes[m_cursorMode], cursorModes[mode]);
+#endif // __WXDEBUG__
+
+    if ( mode == m_cursorMode )
+        return;
+
+    if ( !win )
+    {
+        // by default use the grid itself
+        win = m_gridWin;
+    }
+
+    if ( m_winCapture )
+    {
+        m_winCapture->ReleaseMouse();
+        m_winCapture = (wxWindow *)NULL;
+    }
+
+    m_cursorMode = mode;
+
+    switch ( m_cursorMode )
+    {
+        case WXGRID_CURSOR_RESIZE_ROW:
+            win->SetCursor( m_rowResizeCursor );
+            break;
+
+        case WXGRID_CURSOR_RESIZE_COL:
+            win->SetCursor( m_colResizeCursor );
+            break;
+
+        default:
+            win->SetCursor( *wxSTANDARD_CURSOR );
+    }
+
+    // we need to capture mouse when resizing
+    bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
+                  m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
+
+    if ( captureMouse && resize )
+    {
+        win->CaptureMouse();
+        m_winCapture = win;
+    }
+}
 
 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
 {
@@ -1921,6 +2194,38 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 }
             }
         }
+        else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
+        {
+            int cw, ch, left, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            CalcUnscrolledPosition( 0, 0, &left, &dummy );
+
+            wxClientDC dc( m_gridWin );
+            PrepareDC( dc );
+            dc.SetLogicalFunction(wxINVERT);
+            if ( m_dragLastPos >= 0 )
+            {
+                dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
+            }
+            dc.DrawLine( left, y, left+cw, y );
+            m_dragLastPos = y;
+        }
+        else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+        {
+            int cw, ch, dummy, top;
+            m_gridWin->GetClientSize( &cw, &ch );
+            CalcUnscrolledPosition( 0, 0, &dummy, &top );
+
+            wxClientDC dc( m_gridWin );
+            PrepareDC( dc );
+            dc.SetLogicalFunction(wxINVERT);
+            if ( m_dragLastPos >= 0 )
+            {
+                dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
+            }
+            dc.DrawLine( x, top, x, top+ch );
+            m_dragLastPos = x;
+        }
 
         return;
     }
@@ -1929,13 +2234,28 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
 
     if ( coords != wxGridNoCellCoords )
     {
+        // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
+        //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
+        //     wxGTK
+#if 0
+        if ( event.Entering() || event.Leaving() )
+        {
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+            m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
+        }
+        else
+#endif // 0
+
+        // ------------ Left button pressed
+        //
         if ( event.LeftDown() )
         {
             if ( event.ShiftDown() )
             {
                 SelectBlock( m_currentCellCoords, coords );
             }
-            else
+            else if ( XToEdgeOfCol(x) < 0  &&
+                      YToEdgeOfRow(y) < 0 )
             {
                 if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
                                  coords.GetRow(),
@@ -1953,10 +2273,13 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         else if ( event.LeftDClick() )
         {
-            SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
-                       coords.GetRow(),
-                       coords.GetCol(),
-                       event );
+            if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
+            {
+                SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
+                           coords.GetRow(),
+                           coords.GetCol(),
+                           event );
+            }
         }
 
 
@@ -1970,12 +2293,32 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 {
                     SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, event );
                 }
+
+                // Show the edit control, if it has
+                // been hidden for drag-shrinking.
+                if ( IsCellEditControlEnabled() )
+                    ShowCellEditControl();
             }
+            else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                DoEndDragResizeRow();
 
-            // Show the edit control, if it has
-            // been hidden for drag-shrinking.
-            if ( IsCellEditControlEnabled() )
-                ShowCellEditControl();
+                // Note: we are ending the event *after* doing
+                // default processing in this case
+                //
+                SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+            }
+            else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                DoEndDragResizeCol();
+
+                // Note: we are ending the event *after* doing
+                // default processing in this case
+                //
+                SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
+            }
 
             m_dragLastPos = -1;
         }
@@ -2012,12 +2355,130 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         //
         else if ( event.Moving() && !event.IsButton() )
         {
-            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+            int dragRow = YToEdgeOfRow( y );
+            int dragCol = XToEdgeOfCol( x );
+
+            // Dragging on the corner of a cell to resize in both
+            // directions is not implemented yet...
+            //
+            if ( dragRow >= 0  &&  dragCol >= 0 )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+                return;
+            }
+
+            if ( dragRow >= 0 )
+            {
+                m_dragRowOrCol = dragRow;
+
+                if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+                {
+                    ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
+                }
+
+                return;
+            }
+
+            if ( dragCol >= 0 )
+            {
+                m_dragRowOrCol = dragCol;
+
+                if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
+                {
+                    ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
+                }
+
+                return;
+            }
+
+            // Neither on a row or col edge
+            //
+            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+            }
+        }
+    }
+}
+
+
+void wxGrid::DoEndDragResizeRow()
+{
+    if ( m_dragLastPos >= 0 )
+    {
+        // erase the last line and resize the row
+        //
+        int cw, ch, left, dummy;
+        m_gridWin->GetClientSize( &cw, &ch );
+        CalcUnscrolledPosition( 0, 0, &left, &dummy );
+
+        wxClientDC dc( m_gridWin );
+        PrepareDC( dc );
+        dc.SetLogicalFunction( wxINVERT );
+        dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
+        HideCellEditControl();
+
+        int rowTop = m_rowBottoms[m_dragRowOrCol] - m_rowHeights[m_dragRowOrCol];
+        SetRowSize( m_dragRowOrCol,
+                    wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
+
+        if ( !GetBatchCount() )
+        {
+            // Only needed to get the correct rect.y:
+            wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
+            rect.x = 0;
+            CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
+            rect.width = m_rowLabelWidth;
+            rect.height = ch - rect.y;
+            m_rowLabelWin->Refresh( TRUE, &rect );
+            rect.width = cw;
+            m_gridWin->Refresh( FALSE, &rect );
         }
+
+        ShowCellEditControl();
     }
 }
 
 
+void wxGrid::DoEndDragResizeCol()
+{
+    if ( m_dragLastPos >= 0 )
+    {
+        // 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( m_dragLastPos - colLeft, WXGRID_MIN_COL_WIDTH ) );
+
+        if ( !GetBatchCount() )
+        {
+            // Only needed to get the correct rect.x:
+            wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
+            rect.y = 0;
+            CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
+            rect.width = cw - rect.x;
+            rect.height = m_colLabelHeight;
+            m_colLabelWin->Refresh( TRUE, &rect );
+            rect.height = ch;
+            m_gridWin->Refresh( FALSE, &rect );
+        }
+
+        ShowCellEditControl();
+    }
+}
+
+
+
 //
 // ------ interaction with data model
 //
@@ -2068,7 +2529,7 @@ bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2118,7 +2579,7 @@ bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2152,7 +2613,7 @@ bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2183,7 +2644,7 @@ bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2225,7 +2686,7 @@ bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2259,7 +2720,7 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
         return FALSE;
     }
 
@@ -2385,6 +2846,8 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
         SetEditControlValue();
         ShowCellEditControl();
     }
+
+    m_displayed = TRUE;
 }
 
 
@@ -2394,8 +2857,8 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
 //
 void wxGrid::OnSize( wxSizeEvent& event )
 {
+    CalcWindowSizes();
     CalcDimensions();
-    event.Skip();
 }
 
 
@@ -2405,7 +2868,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
     {
         // shouldn't be here - we are going round in circles...
         //
-        wxLogFatalError( wxT("wxGrid::OnKeyDown called while alread active") );
+        wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while alread active") );
     }
 
     m_inOnKeyDown = TRUE;
@@ -2465,7 +2928,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                     MoveCursorRight();
                 }
                 break;
-                
+
             case WXK_SPACE:
                 if ( !IsEditable() )
                 {
@@ -2544,10 +3007,8 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         return;
     }
 
-    wxClientDC dc( m_gridWin );
-    PrepareDC( dc );
-
-    if ( m_currentCellCoords != wxGridNoCellCoords )
+    if ( m_displayed  &&
+         m_currentCellCoords != wxGridNoCellCoords )
     {
         HideCellEditControl();
         SaveEditControlValue();
@@ -2556,13 +3017,17 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
     m_currentCellCoords = coords;
 
     SetEditControlValue();
-    ShowCellEditControl();
 
-    if ( IsSelection() )
+    if ( m_displayed )
     {
-        wxRect r( SelectionToDeviceRect() );
-        ClearSelection();
-        if ( !GetBatchCount() ) m_gridWin->Refresh( TRUE, &r );
+        ShowCellEditControl();
+
+        if ( IsSelection() )
+        {
+            wxRect r( SelectionToDeviceRect() );
+            ClearSelection();
+            if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
+        }
     }
 }
 
@@ -2818,18 +3283,18 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {
     if ( m_rowHeights[row] <= 0 ) return;
 
-    // draw the label's horizontal border (the vertical border is
-    // provided by the cell area window margin)
-    //
+    int rowTop = m_rowBottoms[row] - m_rowHeights[row];
+
     dc.SetPen( *wxBLACK_PEN );
+    dc.DrawLine( m_rowLabelWidth-1, rowTop,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
 
-    dc.DrawLine( 0, m_rowBottoms[row]+1,
-                 m_rowLabelWidth, m_rowBottoms[row]+1 );
+    dc.DrawLine( 0, m_rowBottoms[row]-1,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
 
     dc.SetPen( *wxWHITE_PEN );
-
-    dc.DrawLine( 0, m_rowBottoms[row]+2,
-                 m_rowLabelWidth, m_rowBottoms[row]+2 );
+    dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
+    dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );
@@ -2865,18 +3330,22 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
 {
     if ( m_colWidths[col] <= 0 ) return;
 
-    // draw the label's vertical border (the horizontal border is
-    // provided by the cell area window margin)
-    //
+    int colLeft = m_colRights[col] - m_colWidths[col];
+
     dc.SetPen( *wxBLACK_PEN );
+    dc.DrawLine( m_colRights[col]-1, 0,
+                 m_colRights[col]-1, m_colLabelHeight-1 );
 
-    dc.DrawLine( m_colRights[col]+1, 0,
-                 m_colRights[col]+1, m_colLabelHeight );
+    dc.DrawLine( colLeft, m_colLabelHeight-1,
+                 m_colRights[col]-1, m_colLabelHeight-1 );
 
     dc.SetPen( *wxWHITE_PEN );
+    dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
+    dc.DrawLine( colLeft, 0, m_colRights[col]-1, 0 );
 
-    dc.DrawLine( m_colRights[col]+2, 0,
-                 m_colRights[col]+2, m_colLabelHeight );
+    dc.SetBackgroundMode( wxTRANSPARENT );
+    dc.SetTextForeground( GetLabelTextColour() );
+    dc.SetFont( GetLabelFont() );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );
@@ -2960,13 +3429,14 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
 //
 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
 {
-    // TODO: this won't work for WXMAC ? (lines end with '\r')
-    //       => use wxTextFile functions then (VZ)
     int startPos = 0;
     int pos;
-    while ( startPos < (int)value.Length() )
+    wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
+    wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
+
+    while ( startPos < (int)tVal.Length() )
     {
-        pos = value.Mid(startPos).Find( '\n' );
+        pos = tVal.Mid(startPos).Find( eol );
         if ( pos < 0 )
         {
             break;
@@ -2977,14 +3447,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
         }
         else
         {
-            if ( value[startPos+pos-1] == '\r' )
-            {
-                lines.Add( value.Mid(startPos, pos-1) );
-            }
-            else
-            {
-                lines.Add( value.Mid(startPos, pos) );
-            }
+            lines.Add( value.Mid(startPos, pos) );
         }
         startPos += pos+1;
     }
@@ -3882,16 +4345,53 @@ wxString wxGrid::GetColLabelValue( int col )
     }
 }
 
+
 void wxGrid::SetRowLabelSize( int width )
 {
-    // TODO: how to do this with the box sizers ?
+    width = wxMax( width, 0 );
+    if ( width != m_rowLabelWidth )
+    {
+        if ( width == 0 )
+        {
+            m_rowLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_rowLabelWidth == 0 )
+        {
+            m_rowLabelWin->Show( TRUE );
+            if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+
+        m_rowLabelWidth = width;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }
 }
 
+
 void wxGrid::SetColLabelSize( int height )
 {
-    // TODO: how to do this with the box sizers ?
+    height = wxMax( height, 0 );
+    if ( height != m_colLabelHeight )
+    {
+        if ( height == 0 )
+        {
+            m_colLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_colLabelHeight == 0 )
+        {
+            m_colLabelWin->Show( TRUE );
+            if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+
+        m_colLabelHeight = height;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }
 }
 
+
 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
 {
     if ( m_labelBackgroundColour != colour )
@@ -4015,7 +4515,7 @@ void wxGrid::SetGridLineColour( const wxColour& colour )
 
         wxClientDC dc( m_gridWin );
         PrepareDC( dc );
-        DrawAllGridLines( dc );
+        DrawAllGridLines( dc, wxRegion() );
     }
 }
 
@@ -4031,7 +4531,7 @@ void wxGrid::EnableGridLines( bool enable )
             {
                 wxClientDC dc( m_gridWin );
                 PrepareDC( dc );
-                DrawAllGridLines( dc );
+                DrawAllGridLines( dc, wxRegion() );
             }
             else
             {
@@ -4049,10 +4549,9 @@ int wxGrid::GetDefaultRowSize()
 
 int wxGrid::GetRowSize( int row )
 {
-    if ( row >= 0  &&  row < m_numRows )
-        return m_rowHeights[row];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
+
+    return m_rowHeights[row];
 }
 
 int wxGrid::GetDefaultColSize()
@@ -4062,38 +4561,51 @@ int wxGrid::GetDefaultColSize()
 
 int wxGrid::GetColSize( int col )
 {
-    if ( col >= 0  &&  col < m_numCols )
-        return m_colWidths[col];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
+
+    return m_colWidths[col];
 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );
+    return m_gridWin->GetBackgroundColour();
 }
 
-wxColour wxGrid::GetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col) )
+// TODO VZ: this must be optimized to allow only retrieveing attr once!
+
+wxColour wxGrid::GetCellBackgroundColour(int row, int col)
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxColour colour;
+    if ( attr && attr->HasBackgroundColour() )
+        colour = attr->GetBackgroundColour();
+    else
+        colour = GetDefaultCellBackgroundColour();
+
+    delete attr;
+
+    return colour;
 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );
+    return m_gridWin->GetForegroundColour();
 }
 
-wxColour wxGrid::GetCellTextColour( int WXUNUSED(row), int WXUNUSED(col) )
+wxColour wxGrid::GetCellTextColour( int row, int col )
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxColour colour;
+    if ( attr && attr->HasTextColour() )
+        colour = attr->GetTextColour();
+    else
+        colour = GetDefaultCellTextColour();
+
+    delete attr;
+
+    return colour;
 }
 
 
@@ -4102,27 +4614,39 @@ wxFont wxGrid::GetDefaultCellFont()
     return m_defaultCellFont;
 }
 
-wxFont wxGrid::GetCellFont( int WXUNUSED(row), int WXUNUSED(col) )
+wxFont wxGrid::GetCellFont( int row, int col )
 {
-    // TODO: replace this temp test code
-    //
-    return m_defaultCellFont;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxFont font;
+    if ( attr && attr->HasFont() )
+        font = attr->GetFont();
+    else
+        font = GetDefaultCellFont();
+
+    delete attr;
+
+    return font;
 }
 
 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
 {
-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    if ( horiz )
+        *horiz = m_defaultCellHAlign;
+    if ( vert )
+        *vert = m_defaultCellVAlign;
 }
 
-void wxGrid::GetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int *horiz, int *vert )
+void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
 {
-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    if ( attr && attr->HasAlignment() )
+        attr->GetAlignment(horiz, vert);
+    else
+        GetDefaultCellAlignment(horiz, vert);
+
+    delete attr;
 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
@@ -4145,30 +4669,19 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
 void wxGrid::SetRowSize( int row, int height )
 {
-    int i;
+    wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
 
-    if ( row >= 0  &&  row < m_numRows )
-    {
-        int h = wxMax( 0, height );
-        int diff = h - m_rowHeights[row];
+    int i;
 
-        m_rowHeights[row] = h;
-        for ( i = row;  i < m_numRows;  i++ )
-        {
-            m_rowBottoms[i] += diff;
-        }
-        CalcDimensions();
+    int h = wxMax( 0, height );
+    int diff = h - m_rowHeights[row];
 
-        // Note: we are ending the event *after* doing
-        // default processing in this case
-        //
-        SendEvent( EVT_GRID_ROW_SIZE,
-                   row, -1 );
-    }
-    else
+    m_rowHeights[row] = h;
+    for ( i = row;  i < m_numRows;  i++ )
     {
-        // TODO: log an error here
+        m_rowBottoms[i] += diff;
     }
+    CalcDimensions();
 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
@@ -4191,78 +4704,102 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
 void wxGrid::SetColSize( int col, int width )
 {
+    wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
+
     int i;
 
-    if ( col >= 0  &&  col < m_numCols )
-    {
-        int w = wxMax( 0, width );
-        int diff = w - m_colWidths[col];
-        m_colWidths[col] = w;
+    int w = wxMax( 0, width );
+    int diff = w - m_colWidths[col];
+    m_colWidths[col] = w;
 
-        for ( i = col;  i < m_numCols;  i++ )
-        {
-            m_colRights[i] += diff;
-        }
-        CalcDimensions();
-
-        // Note: we are ending the event *after* doing
-        // default processing in this case
-        //
-        SendEvent( EVT_GRID_COL_SIZE,
-                   -1, col );
-    }
-    else
+    for ( i = col;  i < m_numCols;  i++ )
     {
-        // TODO: log an error here
+        m_colRights[i] += diff;
     }
+    CalcDimensions();
 }
 
-void wxGrid::SetDefaultCellBackgroundColour( const wxColour& )
+void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
 {
-    // TODO: everything !!!
-    //
+    m_gridWin->SetBackgroundColour(col);
 }
 
-void wxGrid::SetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+void wxGrid::SetDefaultCellTextColour( const wxColour& col )
 {
-    // TODO: everything !!!
-    //
+    m_gridWin->SetForegroundColour(col);
 }
 
-void wxGrid::SetDefaultCellTextColour( const wxColour& )
+void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
 {
-    // TODO: everything !!!
-    //
+    m_defaultCellHAlign = horiz;
+    m_defaultCellVAlign = vert;
 }
 
-void wxGrid::SetCellTextColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+bool wxGrid::CanHaveAttributes()
 {
-    // TODO: everything !!!
-    //
+    if ( !m_table )
+    {
+        return FALSE;
+    }
+
+    if ( !m_table->GetAttrProvider() )
+    {
+        // use the default attr provider by default
+        // (another choice would be to just return FALSE thus forcing the user
+        // to it himself)
+        m_table->SetAttrProvider(new wxGridCellAttrProvider);
+    }
+
+    return TRUE;
 }
 
-void wxGrid::SetDefaultCellFont( const wxFont& )
+void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
 {
-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetBackgroundColour(colour);
+
+        m_table->SetAttr(attr, row, col);
+    }
 }
 
-void wxGrid::SetCellFont( int WXUNUSED(row), int WXUNUSED(col), const wxFont& )
+void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
 {
-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetTextColour(colour);
+
+        m_table->SetAttr(attr, row, col);
+    }
 }
 
-void wxGrid::SetDefaultCellAlignment( int WXUNUSED(horiz), int WXUNUSED(vert) )
+void wxGrid::SetDefaultCellFont( const wxFont& font )
 {
-    // TODO: everything !!!
-    //
+    m_defaultCellFont = font;
 }
 
-void wxGrid::SetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int WXUNUSED(horiz), int WXUNUSED(vert) )
+void wxGrid::SetCellFont( int row, int col, const wxFont& font )
 {
-    // TODO: everything !!!
-    //
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetFont(font);
+
+        m_table->SetAttr(attr, row, col);
+    }
+}
+
+void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
+{
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetAlignment(horiz, vert);
+
+        m_table->SetAttr(attr, row, col);
+    }
 }
 
 
@@ -4355,18 +4892,18 @@ void wxGrid::SelectRow( int row, bool addToSelected )
 
         for (i = 0; i < 4; i++ )
             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
-                m_gridWin->Refresh( TRUE, &(rect[i]) );
+                m_gridWin->Refresh( FALSE, &(rect[i]) );
     }
     else
     {
         r = SelectionToDeviceRect();
         ClearSelection();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
 
         m_selectedTopLeft.Set( row, 0 );
         m_selectedBottomRight.Set( row, m_numCols-1 );
         r = SelectionToDeviceRect();
-        m_gridWin->Refresh( TRUE, &r );
+        m_gridWin->Refresh( FALSE, &r );
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
@@ -4396,7 +4933,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
         {
             need_refresh[0] = TRUE;
             rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
-                                         wxGridCellCoords ( m_numRows - 1, 
+                                         wxGridCellCoords ( m_numRows - 1,
                                                             oldLeft - 1 ) );
             m_selectedTopLeft.SetCol( col );
         }
@@ -4405,7 +4942,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
         {
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
-                                         wxGridCellCoords ( oldTop - 1, 
+                                         wxGridCellCoords ( oldTop - 1,
                                                             oldRight ) );
             m_selectedTopLeft.SetRow( 0 );
         }
@@ -4431,20 +4968,20 @@ void wxGrid::SelectCol( int col, bool addToSelected )
 
         for (i = 0; i < 4; i++ )
             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
-                m_gridWin->Refresh( TRUE, &(rect[i]) );
+                m_gridWin->Refresh( FALSE, &(rect[i]) );
     }
     else
     {
         wxRect r;
-    
+
         r = SelectionToDeviceRect();
         ClearSelection();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
 
         m_selectedTopLeft.Set( 0, col );
         m_selectedBottomRight.Set( m_numRows-1, col );
         r = SelectionToDeviceRect();
-        m_gridWin->Refresh( TRUE, &r );
+        m_gridWin->Refresh( FALSE, &r );
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
@@ -4524,13 +5061,13 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
         // 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, 
+                                         wxGridCellCoords ( oldBottom,
                                                             leftCol - 1 ) );
         }
 
@@ -4539,7 +5076,7 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
                                                             leftCol ),
-                                         wxGridCellCoords ( topRow - 1, 
+                                         wxGridCellCoords ( topRow - 1,
                                                             rightCol ) );
         }
 
@@ -4565,11 +5102,11 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int 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]) );
+                m_gridWin->Refresh( FALSE, &(rect[i]) );
     }
 
     // only generate an event if the block is not being selected by