]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/grid.cpp
Added an OS/2 section to the sql defines
[wxWidgets.git] / src / generic / grid.cpp
index bcf0c8d7b50ffe0a44ba1500e72af868b0b58456..dd097a54f59e34a444ecfca5b9e6ea0ba76fe610 100644 (file)
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"
     #include "wx/dcclient.h"
     #include "wx/settings.h"
     #include "wx/log.h"
-    #include "wx/sizer.h"
-    #include "wx/layout.h"
 #endif
 
 #endif
 
+#include "wx/textfile.h"
 #include "wx/generic/grid.h"
 
 #include "wx/generic/grid.h"
 
+// ----------------------------------------------------------------------------
+// array classes instantiation
+// ----------------------------------------------------------------------------
+
+struct wxGridCellWithAttr
+{
+    wxGridCellWithAttr(int row, int col, const wxGridCellAttr *pAttr)
+        : coords(row, col), attr(*pAttr)
+    {
+    }
+
+    wxGridCellCoords coords;
+    wxGridCellAttr   attr;
+};
+
+WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
+
+#include "wx/arrimpl.cpp"
+
+WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
+WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
+{
+public:
+    wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent& event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
+{
+public:
+    wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
+                          const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid   *m_owner;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+
+class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
+{
+public:
+    wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
+                             const wxPoint &pos, const wxSize &size );
+
+private:
+    wxGrid *m_owner;
+
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+    void OnPaint( wxPaintEvent& event );
+
+    DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+class WXDLLEXPORT wxGridWindow : public wxPanel
+{
+public:
+    wxGridWindow()
+    {
+        m_owner = (wxGrid *)NULL;
+        m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
+        m_colLabelWin = (wxGridColLabelWindow *)NULL;
+    }
+
+    wxGridWindow( wxGrid *parent,
+                  wxGridRowLabelWindow *rowLblWin,
+                  wxGridColLabelWindow *colLblWin,
+                  wxWindowID id, const wxPoint &pos, const wxSize &size );
+    ~wxGridWindow();
+
+    void ScrollWindow( int dx, int dy, const wxRect *rect );
+
+private:
+    wxGrid                   *m_owner;
+    wxGridRowLabelWindow     *m_rowLabelWin;
+    wxGridColLabelWindow     *m_colLabelWin;
+
+    void OnPaint( wxPaintEvent &event );
+    void OnMouseEvent( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& );
+
+    DECLARE_DYNAMIC_CLASS(wxGridWindow)
+    DECLARE_EVENT_TABLE()
+};
+
+// the internal data representation used by wxGridCellAttrProvider
+//
+// TODO make it more efficient
+class WXDLLEXPORT wxGridCellAttrProviderData
+{
+public:
+    void SetAttr(const wxGridCellAttr *attr, int row, int col);
+    wxGridCellAttr *GetAttr(int row, int col) const;
+
+private:
+    // searches for the attr for given cell, returns wxNOT_FOUND if not found
+    int FindIndex(int row, int col) const;
+
+    wxGridCellWithAttrArray m_attrs;
+};
+
+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
 #ifndef WXGRID_DRAW_LINES
 #define WXGRID_DRAW_LINES 1
 #endif
 #ifndef WXGRID_DRAW_LINES
 #define WXGRID_DRAW_LINES 1
 #endif
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
-// 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;
 
 // 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)
 //////////////////////////////////////////////////////////////////////
 //
 // Abstract base class for grid data (the model)
@@ -63,66 +281,88 @@ IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
 
 
 wxGridTableBase::wxGridTableBase()
 
 
 wxGridTableBase::wxGridTableBase()
-        : wxObject()
 {
     m_view = (wxGrid *) NULL;
 {
     m_view = (wxGrid *) NULL;
+    m_attrProvider = (wxGridCellAttrProvider *) NULL;
 }
 
 wxGridTableBase::~wxGridTableBase()
 {
 }
 
 wxGridTableBase::~wxGridTableBase()
 {
+    delete m_attrProvider;
+}
+
+void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
+{
+    delete m_attrProvider;
+    m_attrProvider = attrProvider;
 }
 
 }
 
+wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
+{
+    if ( m_attrProvider )
+        return m_attrProvider->GetAttr(row, col);
+    else
+        return (wxGridCellAttr *)NULL;
+}
+
+void wxGridTableBase::SetAttr(const wxGridCellAttr *attr, int row, int col )
+{
+    if ( m_attrProvider )
+    {
+        m_attrProvider->SetAttr(attr, row, col);
+    }
+    else
+    {
+        // as we take ownership of the pointer and don't store it, we must
+        // free it now
+        delete attr;
+    }
+}
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
 
 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function InsertRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
+    wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
+                    "but your derived table class does not override this function") );
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendRows( size_t numRows )
 {
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendRows( size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function AppendRows(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numRows );
+    wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
 {
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
 {
-    wxLogWarning( wxT("Called grid table class function DeleteRows(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numRows );
+    wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
 {
 
     return FALSE;
 }
 
 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function InsertCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
+    wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
+                  "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendCols( size_t numCols )
 {
 
     return FALSE;
 }
 
 bool wxGridTableBase::AppendCols( size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function AppendCols(N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  numCols );
+    wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
+                   "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
 {
 
     return FALSE;
 }
 
 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
 {
-    wxLogWarning( wxT("Called grid table class function DeleteCols(pos=%d, N=%d)\n"
-                  "but your derived table class does not override this function"),
-                  pos, numCols );
+    wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
+                    "but your derived table class does not override this function"));
 
     return FALSE;
 }
 
     return FALSE;
 }
@@ -362,9 +602,11 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
 
     if ( pos >= curNumRows )
     {
 
     if ( pos >= curNumRows )
     {
-        wxLogError( wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d rows"),
-                    pos, numRows, curNumRows );
+        wxString errmsg;
+        errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
+                      "Pos value is invalid for present table with %d rows",
+                      pos, numRows, curNumRows );
+        wxFAIL_MSG( wxT(errmsg) );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -440,8 +682,8 @@ bool wxGridStringTable::AppendCols( size_t numCols )
     {
         // TODO: something better than this ?
         //
     {
         // TODO: something better than this ?
         //
-        wxLogError( wxT("Unable to append cols to a grid table with no rows.\n"
-                    "Call AppendRows() first") );
+        wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
+                        "Call AppendRows() first") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -474,9 +716,11 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
 
     if ( pos >= curNumCols )
     {
 
     if ( pos >= curNumCols )
     {
-        wxLogError( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
-                    "Pos value is invalid for present table with %d cols"),
-                    pos, numCols, curNumCols );
+        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;
     }
 
         return FALSE;
     }
 
@@ -810,15 +1054,15 @@ wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);
 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);
-    
+
     int client_height = 0;
     int client_width = 0;
     GetClientSize( &client_width, &client_height );
     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( *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 );
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( 0, 0, client_width, 0 );
     dc.DrawLine( 0, 0, 0, client_height );
@@ -950,7 +1194,7 @@ void wxGrid::Create()
     m_numRows = 0;
     m_numCols = 0;
     m_currentCellCoords = wxGridNoCellCoords;
     m_numRows = 0;
     m_numCols = 0;
     m_currentCellCoords = wxGridNoCellCoords;
-    
+
     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 
     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 
@@ -984,7 +1228,7 @@ bool wxGrid::CreateGrid( int numRows, int numCols )
 {
     if ( m_created )
     {
 {
     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
         return FALSE;
     }
     else
@@ -1066,9 +1310,12 @@ void wxGrid::Init()
         m_colRights.Add( colRight );
     }
 
         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_gridLineColour = wxColour( 128, 128, 255 );
     m_gridLinesEnabled = TRUE;
@@ -1136,7 +1383,7 @@ void wxGrid::CalcWindowSizes()
 {
     int cw, ch;
     GetClientSize( &cw, &ch );
 {
     int cw, ch;
     GetClientSize( &cw, &ch );
-    
+
     if ( m_cornerLabelWin->IsShown() )
         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
 
     if ( m_cornerLabelWin->IsShown() )
         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
 
@@ -2077,7 +2324,7 @@ bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2127,7 +2374,7 @@ bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2161,7 +2408,7 @@ bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2192,7 +2439,7 @@ bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2234,7 +2481,7 @@ bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2268,7 +2515,7 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 
     if ( !m_created )
     {
 
     if ( !m_created )
     {
-        wxLogError( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
+        wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
         return FALSE;
     }
 
         return FALSE;
     }
 
@@ -2416,7 +2663,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
     {
         // shouldn't be here - we are going round in circles...
         //
     {
         // 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;
     }
 
     m_inOnKeyDown = TRUE;
@@ -2476,7 +2723,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                     MoveCursorRight();
                 }
                 break;
                     MoveCursorRight();
                 }
                 break;
-                
+
             case WXK_SPACE:
                 if ( !IsEditable() )
                 {
             case WXK_SPACE:
                 if ( !IsEditable() )
                 {
@@ -2668,13 +2915,13 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
 
     // right hand border
     //
 
     // right hand border
     //
-    dc.DrawLine( m_colRights[col]-1, m_rowBottoms[row] - m_rowHeights[row],
-                 m_colRights[col]-1, m_rowBottoms[row]-1 );
+    dc.DrawLine( m_colRights[col], m_rowBottoms[row] - m_rowHeights[row],
+                 m_colRights[col], m_rowBottoms[row] );
 
     // bottom border
     //
 
     // bottom border
     //
-    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row]-1,
-                 m_colRights[col]-1, m_rowBottoms[row]-1 );
+    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row],
+                 m_colRights[col], m_rowBottoms[row] );
 }
 
 
 }
 
 
@@ -2786,13 +3033,13 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
     int i;
     for ( i = 0; i < m_numRows; i++ )
     {
     int i;
     for ( i = 0; i < m_numRows; i++ )
     {
-        if ( m_rowBottoms[i]-1 > bottom )
+        if ( m_rowBottoms[i] > bottom )
         {
             break;
         }
         {
             break;
         }
-        else if ( m_rowBottoms[i]-1 >= top )
+        else if ( m_rowBottoms[i] >= top )
         {
         {
-            dc.DrawLine( left, m_rowBottoms[i]-1, right, m_rowBottoms[i]-1 );
+            dc.DrawLine( left, m_rowBottoms[i], right, m_rowBottoms[i] );
         }
     }
 
         }
     }
 
@@ -2801,13 +3048,13 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
     //
     for ( i = 0; i < m_numCols; i++ )
     {
     //
     for ( i = 0; i < m_numCols; i++ )
     {
-        if ( m_colRights[i]-1 > right )
+        if ( m_colRights[i] > right )
         {
             break;
         }
         {
             break;
         }
-        else if ( m_colRights[i]-1 >= left )
+        else if ( m_colRights[i] >= left )
         {
         {
-            dc.DrawLine( m_colRights[i]-1, top, m_colRights[i]-1, bottom );
+            dc.DrawLine( m_colRights[i], top, m_colRights[i], bottom );
         }
     }
 }
         }
     }
 }
@@ -2832,14 +3079,14 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
     if ( m_rowHeights[row] <= 0 ) return;
 
     int rowTop = m_rowBottoms[row] - m_rowHeights[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.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.DrawLine( 0, m_rowBottoms[row]-1,
                  m_rowLabelWidth-1, m_rowBottoms[row]-1 );
-    
+
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
     dc.SetPen( *wxWHITE_PEN );
     dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
@@ -2879,14 +3126,14 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
     if ( m_colWidths[col] <= 0 ) return;
 
     int colLeft = m_colRights[col] - m_colWidths[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.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.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.SetPen( *wxWHITE_PEN );
     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
     dc.DrawLine( colLeft, 0, m_colRights[col]-1, 0 );
@@ -2977,13 +3224,15 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
 //
 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
 {
 //
 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;
     int startPos = 0;
     int pos;
-    while ( startPos < (int)value.Length() )
+    wxTextFile tf;
+    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;
         if ( pos < 0 )
         {
             break;
@@ -2994,14 +3243,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
         }
         else
         {
         }
         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;
     }
         }
         startPos += pos+1;
     }
@@ -3915,7 +4157,7 @@ void wxGrid::SetRowLabelSize( int width )
             m_rowLabelWin->Show( TRUE );
             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
         }
             m_rowLabelWin->Show( TRUE );
             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
         }
-        
+
         m_rowLabelWidth = width;
         CalcWindowSizes();
         Refresh( TRUE );
         m_rowLabelWidth = width;
         CalcWindowSizes();
         Refresh( TRUE );
@@ -4103,10 +4345,9 @@ int wxGrid::GetDefaultRowSize()
 
 int wxGrid::GetRowSize( int row )
 {
 
 int wxGrid::GetRowSize( int row )
 {
-    if ( row >= 0  &&  row < m_numRows )
-        return m_rowHeights[row];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
+
+    return m_rowHeights[row];
 }
 
 int wxGrid::GetDefaultColSize()
 }
 
 int wxGrid::GetDefaultColSize()
@@ -4116,38 +4357,51 @@ int wxGrid::GetDefaultColSize()
 
 int wxGrid::GetColSize( int col )
 {
 
 int wxGrid::GetColSize( int col )
 {
-    if ( col >= 0  &&  col < m_numCols )
-        return m_colWidths[col];
-    else
-        return 0;  // TODO: log an error here
+    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
+
+    return m_colWidths[col];
 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {
 }
 
 wxColour wxGrid::GetDefaultCellBackgroundColour()
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );
+    return m_gridWin->GetBackgroundColour();
 }
 
 }
 
-wxColour wxGrid::GetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col) )
+// TODO VZ: this must be optimized to allow only retrieveing attr once!
+
+wxColour wxGrid::GetCellBackgroundColour(int row, int col)
 {
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 255, 255, 255 );
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxColour colour;
+    if ( attr && attr->HasBackgroundColour() )
+        colour = attr->GetBackgroundColour();
+    else
+        colour = GetDefaultCellBackgroundColour();
+
+    delete attr;
+
+    return colour;
 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
 }
 
 wxColour wxGrid::GetDefaultCellTextColour()
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );
+    return m_gridWin->GetForegroundColour();
 }
 
 }
 
-wxColour wxGrid::GetCellTextColour( int WXUNUSED(row), int WXUNUSED(col) )
+wxColour wxGrid::GetCellTextColour( int row, int col )
 {
 {
-    // TODO: replace this temp test code
-    //
-    return wxColour( 0, 0, 0 );
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxColour colour;
+    if ( attr && attr->HasTextColour() )
+        colour = attr->GetTextColour();
+    else
+        colour = GetDefaultCellTextColour();
+
+    delete attr;
+
+    return colour;
 }
 
 
 }
 
 
@@ -4156,27 +4410,39 @@ wxFont wxGrid::GetDefaultCellFont()
     return m_defaultCellFont;
 }
 
     return m_defaultCellFont;
 }
 
-wxFont wxGrid::GetCellFont( int WXUNUSED(row), int WXUNUSED(col) )
+wxFont wxGrid::GetCellFont( int row, int col )
 {
 {
-    // TODO: replace this temp test code
-    //
-    return m_defaultCellFont;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    wxFont font;
+    if ( attr && attr->HasFont() )
+        font = attr->GetFont();
+    else
+        font = GetDefaultCellFont();
+
+    delete attr;
+
+    return font;
 }
 
 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
 {
 }
 
 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
 {
-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    if ( horiz )
+        *horiz = m_defaultCellHAlign;
+    if ( vert )
+        *vert = m_defaultCellVAlign;
 }
 
 }
 
-void wxGrid::GetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int *horiz, int *vert )
+void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
 {
 {
-    // TODO: replace this temp test code
-    //
-    *horiz = wxLEFT;
-    *vert  = wxTOP;
+    wxGridCellAttr *attr = m_table ? m_table->GetAttr(row, col) : NULL;
+
+    if ( attr && attr->HasAlignment() )
+        attr->GetAlignment(horiz, vert);
+    else
+        GetDefaultCellAlignment(horiz, vert);
+
+    delete attr;
 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 }
 
 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
@@ -4199,30 +4465,25 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
 void wxGrid::SetRowSize( int row, int height )
 {
 
 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();
+
+    // 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 )
 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
@@ -4245,78 +4506,108 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
 void wxGrid::SetColSize( int col, int width )
 {
 
 void wxGrid::SetColSize( int col, int width )
 {
+    wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
+
     int i;
 
     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();
+
+    // 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& )
+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);
+    }
 }
 
 
 }
 
 
@@ -4450,7 +4741,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
         {
             need_refresh[0] = TRUE;
             rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
         {
             need_refresh[0] = TRUE;
             rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
-                                         wxGridCellCoords ( m_numRows - 1, 
+                                         wxGridCellCoords ( m_numRows - 1,
                                                             oldLeft - 1 ) );
             m_selectedTopLeft.SetCol( col );
         }
                                                             oldLeft - 1 ) );
             m_selectedTopLeft.SetCol( col );
         }
@@ -4459,7 +4750,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
         {
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
         {
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
-                                         wxGridCellCoords ( oldTop - 1, 
+                                         wxGridCellCoords ( oldTop - 1,
                                                             oldRight ) );
             m_selectedTopLeft.SetRow( 0 );
         }
                                                             oldRight ) );
             m_selectedTopLeft.SetRow( 0 );
         }
@@ -4490,7 +4781,7 @@ void wxGrid::SelectCol( int col, bool addToSelected )
     else
     {
         wxRect r;
     else
     {
         wxRect r;
-    
+
         r = SelectionToDeviceRect();
         ClearSelection();
         if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
         r = SelectionToDeviceRect();
         ClearSelection();
         if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
@@ -4578,13 +4869,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.
         // 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 ),
         if ( oldLeft < leftCol )
         {
             need_refresh[0] = TRUE;
             rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
                                                             oldLeft ),
-                                         wxGridCellCoords ( oldBottom, 
+                                         wxGridCellCoords ( oldBottom,
                                                             leftCol - 1 ) );
         }
 
                                                             leftCol - 1 ) );
         }
 
@@ -4593,7 +4884,7 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
                                                             leftCol ),
             need_refresh[1] = TRUE;
             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
                                                             leftCol ),
-                                         wxGridCellCoords ( topRow - 1, 
+                                         wxGridCellCoords ( topRow - 1,
                                                             rightCol ) );
         }
 
                                                             rightCol ) );
         }
 
@@ -4619,7 +4910,7 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
         // Change Selection
         m_selectedTopLeft = updateTopLeft;
         m_selectedBottomRight = updateBottomRight;
         // Change Selection
         m_selectedTopLeft = updateTopLeft;
         m_selectedBottomRight = updateBottomRight;
-        
+
         // various Refresh() calls
         for (i = 0; i < 4; i++ )
             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
         // various Refresh() calls
         for (i = 0; i < 4; i++ )
             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )