cell attributes added (doesn't quite work, work in progress, beware, don't use, &c &c)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5933 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/generic/grid.h

@@ -50,9 +50,100 @@
 #define WXGRID_MIN_COL_WIDTH                  15
 #define WXGRID_DEFAULT_SCROLLBAR_WIDTH        16
 
+// ----------------------------------------------------------------------------
+// forward declarations
+// ----------------------------------------------------------------------------
 
+class WXDLLEXPORT wxGridCellAttrProviderData;
+class WXDLLEXPORT wxGridRowLabelWindow;
+class WXDLLEXPORT wxGridColLabelWindow;
+class WXDLLEXPORT wxGridCornerLabelWindow;
+class WXDLLEXPORT wxGridWindow;
 class WXDLLEXPORT wxGrid;
 
+// ----------------------------------------------------------------------------
+// wxGridCellAttr: this class can be used to alter the cells appearance in
+// the grid by changing their colour/font/... from default. An object of this
+// class may be returned by wxGridTable::GetAttr().
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGridCellAttr
+{
+public:
+    // ctors
+    wxGridCellAttr()
+    {
+        SetAlignment(0, 0);
+    }
+
+    wxGridCellAttr(const wxColour& colText,
+                   const wxColour& colBack,
+                   const wxFont& font,
+                   int hAlign,
+                   int vAlign)
+        : m_colText(colText), m_colBack(colBack), m_font(font)
+    {
+        SetAlignment(hAlign, vAlign);
+    }
+
+    // default copy ctor ok
+
+    // setters
+    void SetTextColour(const wxColour& colText) { m_colText = colText; }
+    void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
+    void SetFont(const wxFont& font) { m_font = font; }
+    void SetAlignment(int hAlign, int vAlign)
+    {
+        m_hAlign = hAlign;
+        m_vAlign = vAlign;
+    }
+
+    // accessors
+    bool HasTextColour() const { return m_colText.Ok(); }
+    bool HasBackgroundColour() const { return m_colBack.Ok(); }
+    bool HasFont() const { return m_font.Ok(); }
+    bool HasAlignment() const { return m_hAlign || m_vAlign; }
+
+    const wxColour& GetTextColour() const { return m_colText; }
+    const wxColour& GetBackgroundColour() const { return m_colBack; }
+    const wxFont& GetFont() const { return m_font; }
+    void GetAlignment(int *hAlign, int *vAlign)
+    {
+        if ( hAlign ) *hAlign = m_hAlign;
+        if ( vAlign ) *vAlign = m_vAlign;
+    }
+
+private:
+    wxColour m_colText,
+             m_colBack;
+    wxFont   m_font;
+    int      m_hAlign,
+             m_vAlign;
+};
+
+// ----------------------------------------------------------------------------
+// wxGridCellAttrProvider: class used by wxGridTableBase to retrieve/store the
+// cell attributes.
+// ----------------------------------------------------------------------------
+
+// implementation note: we separate it from wxGridTableBase because we wish to
+// avoid deriving a new table class if possible, and sometimes it will be
+// enough to just derive another wxGridCellAttrProvider instead
+
+class WXDLLEXPORT wxGridCellAttrProvider
+{
+public:
+    wxGridCellAttrProvider();
+    virtual ~wxGridCellAttrProvider();
+
+    virtual wxGridCellAttr *GetAttr(int row, int col) const;
+    virtual void SetAttr(const wxGridCellAttr *attr, int row, int col);
+
+private:
+    void InitData();
+
+    wxGridCellAttrProviderData *m_data;
+};
 
 //////////////////////////////////////////////////////////////////////
 //
@@ -93,13 +184,33 @@ public:
     virtual void SetRowLabelValue( int WXUNUSED(row), const wxString& ) {}
     virtual void SetColLabelValue( int WXUNUSED(col), const wxString& ) {}
 
+    // Attribute handling
+    //
+
+    // give us the attr provider to use - we take ownership of the pointer
+    void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
+
+    // get the currently used attr provider (may be NULL)
+    wxGridCellAttrProvider *GetAttrProvider() const { return m_attrProvider; }
+
+    // by default forwarded to wxGridCellAttrProvider if any. May be
+    // overridden to handle attributes directly in this class.
+    virtual wxGridCellAttr *GetAttr( int row, int col );
+
+    // takes ownership of the pointer
+    virtual void SetAttr(const wxGridCellAttr *attr, int row, int col );
+
 private:
     wxGrid * m_view;
+    wxGridCellAttrProvider *m_attrProvider;
 
     DECLARE_ABSTRACT_CLASS( wxGridTableBase );
 };
 
 
+// ----------------------------------------------------------------------------
+// wxGridTableMessage
+// ----------------------------------------------------------------------------
 
 // IDs for messages sent from grid table to view
 //
@@ -296,97 +407,9 @@ private:
     DECLARE_EVENT_TABLE()
 };
 
-
+// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
+// wxGrid
-{
+// ----------------------------------------------------------------------------
-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()
-};
-
-
 
 class WXDLLEXPORT wxGrid : public wxScrolledWindow
 {
@@ -684,16 +707,16 @@ public:
     //  to the client size of the grid window.
     //
     wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
-			      const wxGridCellCoords & bottomRight );
+                              const wxGridCellCoords & bottomRight );
 
     // This function returns the rectangle that encloses the selected cells
     // in device coords and clipped to the client size of the grid window.
     //
     wxRect SelectionToDeviceRect()
         {
-	    return BlockToDeviceRect( m_selectedTopLeft,
+            return BlockToDeviceRect( m_selectedTopLeft,
-				      m_selectedBottomRight );
+                                      m_selectedBottomRight );
-	}
+        }
 
 
     // ------ For compatibility with previous wxGrid only...
@@ -907,7 +930,13 @@ protected:
     wxColour   m_gridLineColour;
     bool       m_gridLinesEnabled;
 
+    // default cell attributes
     wxFont     m_defaultCellFont;
+    int        m_defaultCellHAlign,
+               m_defaultCellVAlign;
+
+    // do we have some place to store attributes in?
+    bool CanHaveAttributes();
 
     wxGridCellCoordsArray  m_cellsExposed;
     wxArrayInt             m_rowsExposed;

samples/newgrid/griddemo.cpp

@@ -163,6 +163,12 @@ GridFrame::GridFrame()
     grid->SetRowSize( 99, 60 );
     grid->SetCellValue( 99, 99, "Ctrl+End\nwill go to\nthis cell" );
 
+    grid->SetCellValue(2, 2, "red");
+    grid->SetCellTextColour(2, 2, *wxRED);
+    grid->SetCellValue(3, 3, "green on white");
+    grid->SetCellTextColour(3, 3, *wxGREEN);
+    grid->SetCellBackgroundColour(3, 3, *wxWHITE);
+
     wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
     topSizer->Add( grid,
                    1,

samples/newgrid/griddemo.h

@@ -12,6 +12,9 @@
 #ifndef griddemo_h
 #define griddemo_h
 
+#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
+    #error "This sample requires the new wxGrid class."
+#endif
 
 class wxGrid;
 

src/generic/grid.cpp

@@ -37,6 +37,139 @@
 
 #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
@@ -46,15 +179,101 @@
 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)
@@ -63,15 +282,46 @@ 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;
+    }
+}
+
+// FIXME VZ: these should be wxFAIL_MSG(), not wxLogWarning, they're for the
+//           programmer, not the user!
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
@@ -1066,9 +1316,12 @@ 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;
@@ -4104,10 +4357,9 @@ int wxGrid::GetDefaultRowSize()
 
 int wxGrid::GetRowSize( int row )
 {
-    if ( row >= 0  &&  row < m_numRows )
+    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
-        return m_rowHeights[row];
+
-    else
+    return m_rowHeights[row];
-        return 0;  // TODO: log an error here
 }
 
 int wxGrid::GetDefaultColSize()
@@ -4117,38 +4369,51 @@ int wxGrid::GetDefaultColSize()
 
 int wxGrid::GetColSize( int col )
 {
-    if ( col >= 0  &&  col < m_numCols )
+    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
-        return m_colWidths[col];
+
-    else
+    return m_colWidths[col];
-        return 0;  // TODO: log an error here
 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {
-    // TODO: replace this temp test code
+    return GetBackgroundColour();
-    //
-    return wxColour( 255, 255, 255 );
 }
 
-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
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
-    //
+
-    return wxColour( 255, 255, 255 );
+    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 GetForegroundColour();
-    //
-    return wxColour( 0, 0, 0 );
 }
 
-wxColour wxGrid::GetCellTextColour( int WXUNUSED(row), int WXUNUSED(col) )
+wxColour wxGrid::GetCellTextColour( int row, int col )
 {
-    // TODO: replace this temp test code
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
-    //
+
-    return wxColour( 0, 0, 0 );
+    wxColour colour;
+    if ( attr && attr->HasTextColour() )
+        colour = attr->GetTextColour();
+    else
+        colour = GetDefaultCellTextColour();
+
+    delete attr;
+
+    return colour;
 }
 
 
@@ -4157,27 +4422,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
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
-    //
+
-    return m_defaultCellFont;
+    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
+    if ( horiz )
-    //
+        *horiz = m_defaultCellHAlign;
-    *horiz = wxLEFT;
+    if ( vert )
-    *vert  = wxTOP;
+        *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
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
-    //
+
-    *horiz = wxLEFT;
+    if ( attr && attr->HasAlignment() )
-    *vert  = wxTOP;
+        attr->GetAlignment(horiz, vert);
+    else
+        GetDefaultCellAlignment(horiz, vert);
+
+    delete attr;
 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
@@ -4200,30 +4477,25 @@ 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;
+    m_rowHeights[row] = h;
-        for ( i = row;  i < m_numRows;  i++ )
+    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
     {
-        // TODO: log an error here
+        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 );
 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
@@ -4246,78 +4518,108 @@ 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;
+
+    for ( i = col;  i < m_numCols;  i++ )
     {
-        int w = wxMax( 0, width );
+        m_colRights[i] += diff;
-        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
+    CalcDimensions();
+
+    // Note: we are ending the event *after* doing
+    // default processing in this case
+    //
+    SendEvent( EVT_GRID_COL_SIZE,
+               -1, col );
+}
+
+void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
+{
+    SetBackgroundColour(col);
+}
+
+void wxGrid::SetDefaultCellTextColour( const wxColour& col )
+{
+    SetForegroundColour(col);
+}
+
+void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
+{
+    m_defaultCellHAlign = horiz;
+    m_defaultCellVAlign = vert;
+}
+
+bool wxGrid::CanHaveAttributes()
+{
+    if ( !m_table )
     {
-        // TODO: log an error here
+        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::SetCellBackgroundColour( int row, int col, const wxColour& colour )
+{
+    if ( CanHaveAttributes() )
+    {
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetBackgroundColour(colour);
+
+        m_table->SetAttr(attr, row, col);
     }
 }
 
-void wxGrid::SetDefaultCellBackgroundColour( const wxColour& )
+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::SetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+void wxGrid::SetDefaultCellFont( const wxFont& font )
 {
-    // TODO: everything !!!
+    m_defaultCellFont = font;
-    //
 }
 
-void wxGrid::SetDefaultCellTextColour( const wxColour& )
+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::SetCellTextColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
+void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
 {
-    // TODO: everything !!!
+    if ( CanHaveAttributes() )
-    //
+    {
-}
+        wxGridCellAttr *attr = new wxGridCellAttr;
+        attr->SetAlignment(horiz, vert);
 
-void wxGrid::SetDefaultCellFont( const wxFont& )
+        m_table->SetAttr(attr, row, col);
-{
+    }
-    // TODO: everything !!!
-    //
-}
-
-void wxGrid::SetCellFont( int WXUNUSED(row), int WXUNUSED(col), const wxFont& )
-{
-    // TODO: everything !!!
-    //
-}
-
-void wxGrid::SetDefaultCellAlignment( int WXUNUSED(horiz), int WXUNUSED(vert) )
-{
-    // TODO: everything !!!
-    //
-}
-
-void wxGrid::SetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int WXUNUSED(horiz), int WXUNUSED(vert) )
-{
-    // TODO: everything !!!
-    //
 }