]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/grid.cpp
Made HelpGen compile here.
[wxWidgets.git] / src / generic / grid.cpp
index c931804e3efa805096c5ee1fc3e38c52ded1e00f..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 );
@@ -949,24 +1196,24 @@ void wxGrid::Create()
     m_numRows = 0;
     m_numCols = 0;
     m_currentCellCoords = wxGridNoCellCoords;
-    
-    int colLblH = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
-    int rowLblW = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+
+    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,
@@ -976,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 );
 }
 
 
@@ -1000,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
@@ -1082,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;
@@ -1148,6 +1382,25 @@ void wxGrid::CalcDimensions()
 }
 
 
+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
 //
@@ -1521,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;
@@ -1537,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
@@ -1552,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);
         }
     }
 
@@ -1582,48 +1845,16 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     {
         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
         {
-            m_rowLabelWin->ReleaseMouse();
-
-            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 );
+            DoEndDragResizeRow();
 
-                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( FALSE, &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;
     }
 
 
@@ -1660,15 +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 )
         {
-            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-            if ( m_rowLabelWin->GetCursor() == m_rowResizeCursor )
-                m_rowLabelWin->SetCursor( *wxSTANDARD_CURSOR );
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
         }
     }
 }
@@ -1707,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;
@@ -1723,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
@@ -1738,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);
         }
     }
 
@@ -1768,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();
-
-                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( FALSE, &rect );
-                }
-
-                ShowCellEditControl();
+            DoEndDragResizeCol();
 
-                // 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;
     }
 
@@ -1847,15 +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 )
         {
-            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
-            if ( m_colLabelWin->GetCursor() == m_colResizeCursor )
-                m_colLabelWin->SetCursor( *wxSTANDARD_CURSOR );
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
         }
     }
 }
@@ -1896,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 )
 {
@@ -1927,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;
     }
@@ -1935,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(),
@@ -1959,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 );
+            }
         }
 
 
@@ -1976,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;
         }
@@ -2018,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
 //
@@ -2074,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;
     }
 
@@ -2124,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;
     }
 
@@ -2158,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;
     }
 
@@ -2189,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;
     }
 
@@ -2231,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;
     }
 
@@ -2265,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;
     }
 
@@ -2402,8 +2857,8 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
 //
 void wxGrid::OnSize( wxSizeEvent& event )
 {
+    CalcWindowSizes();
     CalcDimensions();
-    event.Skip();
 }
 
 
@@ -2413,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;
@@ -2473,7 +2928,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                     MoveCursorRight();
                 }
                 break;
-                
+
             case WXK_SPACE:
                 if ( !IsEditable() )
                 {
@@ -2829,14 +3284,14 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
     if ( m_rowHeights[row] <= 0 ) return;
 
     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-1, m_rowBottoms[row]-1 );
-    
+
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
@@ -2876,14 +3331,14 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
     if ( m_colWidths[col] <= 0 ) return;
 
     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( 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 );
@@ -2974,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;
@@ -2991,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;
     }
@@ -3899,150 +4348,46 @@ wxString wxGrid::GetColLabelValue( int col )
 
 void wxGrid::SetRowLabelSize( int width )
 {
-    wxSize sz;
-    
     width = wxMax( width, 0 );
     if ( width != m_rowLabelWidth )
     {
-        // Hiding the row labels (and possible the corner label)
-        //
         if ( width == 0 )
         {
             m_rowLabelWin->Show( FALSE );
-
-            // If the col labels are on display we need to hide the
-            // corner label and remove it from the top sizer
-            //
-            if ( m_colLabelHeight > 0 )
-            {
-                m_cornerLabelWin->Show( FALSE );
-                m_topSizer->Remove( m_cornerLabelWin );
-            }
-            
-            m_middleSizer->Remove( m_rowLabelWin );
+            m_cornerLabelWin->Show( FALSE );
         }
-        else
+        else if ( m_rowLabelWidth == 0 )
         {
-            // Displaying the row labels (and possibly the corner
-            // label) after being hidden
-            //
-            if ( m_rowLabelWidth == 0 )
-            {
-                m_rowLabelWin->Show( TRUE );
-                
-                if ( m_colLabelHeight > 0 )
-                {
-                    m_cornerLabelWin->Show( TRUE );
-                    m_topSizer->Prepend( m_cornerLabelWin, 0 );
-                }
-
-                m_middleSizer->Prepend( m_rowLabelWin, 0, wxEXPAND );
-            }
-
-
-            // set the width of the corner label if it is on display
-            //
-            if ( m_colLabelHeight > 0 )
-            {
-                wxList& childList = m_topSizer->GetChildren();
-                wxNode *node = childList.First();
-                while (node)
-                {
-                    wxSizerItem *item = (wxSizerItem*)node->Data();
-                    if ( item->GetWindow() == m_cornerLabelWin )
-                    {
-                        item->SetInitSize( width, m_colLabelHeight );
-                        break;
-                    }
-                    node = node->Next();
-                }
-            }
-
-            // set the width of the row labels
-            //
-            wxList& childList = m_middleSizer->GetChildren();
-            wxNode *node = childList.First();
-            while (node)
-            {
-                wxSizerItem *item = (wxSizerItem*)node->Data();
-                if ( item->GetWindow() == m_rowLabelWin )
-                {
-                    sz = item->GetWindow()->GetSize();
-                    item->SetInitSize( width, sz.GetHeight() );
-                    break;
-                }
-                node = node->Next();
-            }            
+            m_rowLabelWin->Show( TRUE );
+            if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
         }
-    
+
         m_rowLabelWidth = width;
-        m_mainSizer->Layout();
+        CalcWindowSizes();
+        Refresh( TRUE );
     }
 }
 
 
 void wxGrid::SetColLabelSize( int height )
 {
-    wxSize sz;
-
-    if ( height < 0 ) height = 0;
+    height = wxMax( height, 0 );
     if ( height != m_colLabelHeight )
     {
-        // hiding the column labels
-        //
         if ( height == 0 )
         {
-            m_cornerLabelWin->Show( FALSE );
             m_colLabelWin->Show( FALSE );
-
-            // Note: this call will actually delete the sizer
-            //
-            m_mainSizer->Remove( m_topSizer );
-            m_topSizer = (wxBoxSizer *)NULL;
+            m_cornerLabelWin->Show( FALSE );
         }
-        else
+        else if ( m_colLabelHeight == 0 )
         {
-            // column labels to be displayed after being hidden
-            //
-            if ( m_colLabelHeight == 0 )
-            {
-                // recreate the top sizer
-                //
-                m_topSizer = new wxBoxSizer( wxHORIZONTAL );
-
-                if ( m_rowLabelWidth > 0 )
-                    m_topSizer->Add( m_cornerLabelWin, 0 );
-
-                m_topSizer->Add( m_colLabelWin, 1 );
-                m_mainSizer->Prepend( m_topSizer, 0, wxEXPAND );
-
-                // only show the corner label if the row labels are
-                // also displayed
-                //
-                if ( m_rowLabelWidth > 0 )
-                    m_cornerLabelWin->Show( TRUE );
-                
-                m_colLabelWin->Show( TRUE );
-            }
-            
-            wxList& childList = m_topSizer->GetChildren();
-            wxNode *node = childList.First();
-            while (node)
-            {
-                wxSizerItem *item = (wxSizerItem*)node->Data();
-
-                if ( (item->GetWindow() == m_cornerLabelWin && m_rowLabelWidth > 0) ||
-                     item->GetWindow() == m_colLabelWin )
-                {
-                    sz = item->GetWindow()->GetSize();
-                    item->SetInitSize( sz.GetWidth(), height );
-                }
-                node = node->Next();
-            }
+            m_colLabelWin->Show( TRUE );
+            if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
         }
-    
+
         m_colLabelHeight = height;
-        m_mainSizer->Layout();
+        CalcWindowSizes();
+        Refresh( TRUE );
     }
 }
 
@@ -4204,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()
@@ -4217,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;
 }
 
 
@@ -4257,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 )
@@ -4300,30 +4669,19 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
 void wxGrid::SetRowSize( int row, int height )
 {
+    wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
+
     int i;
 
-    if ( row >= 0  &&  row < m_numRows )
-    {
-        int h = wxMax( 0, height );
-        int diff = h - m_rowHeights[row];
+    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();
-
-        // 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 )
@@ -4346,78 +4704,102 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
 void wxGrid::SetColSize( int col, int width )
 {
-    int i;
+    wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
 
-    if ( col >= 0  &&  col < m_numCols )
-    {
-        int w = wxMax( 0, width );
-        int diff = w - m_colWidths[col];
-        m_colWidths[col] = w;
+    int i;
 
-        for ( i = col;  i < m_numCols;  i++ )
-        {
-            m_colRights[i] += diff;
-        }
-        CalcDimensions();
+    int w = wxMax( 0, width );
+    int diff = w - m_colWidths[col];
+    m_colWidths[col] = w;
 
-        // 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);
+    }
 }
 
 
@@ -4551,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 );
         }
@@ -4560,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 );
         }
@@ -4591,7 +4973,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
     else
     {
         wxRect r;
-    
+
         r = SelectionToDeviceRect();
         ClearSelection();
         if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
@@ -4679,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 ) );
         }
 
@@ -4694,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 ) );
         }
 
@@ -4720,7 +5102,7 @@ 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 )