X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/57bd4c6031d438f11af0ec540136f49a928b923c..b9e5acc5400f99a5da9dc46adb83d421a0408a92:/src/generic/datavgen.cpp

diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp
index 7d404f3e72..e3886ffcf4 100644
--- a/src/generic/datavgen.cpp
+++ b/src/generic/datavgen.cpp
@@ -35,6 +35,7 @@
 #include "wx/calctrl.h"
 #include "wx/popupwin.h"
 #include "wx/renderer.h"
+#include "wx/icon.h"
 
 //-----------------------------------------------------------------------------
 // classes
@@ -97,7 +98,7 @@ public:
     wxDataViewTextCtrlWrapper( wxDataViewMainWindow *owner,
                                wxTextCtrl *text,
                                wxDataViewListModel *model,
-                               size_t col, size_t row,
+                               unsigned int col, unsigned int row,
                                wxRect cellLabel );
 
     wxTextCtrl *GetText() const { return m_text; }
@@ -117,8 +118,8 @@ private:
     wxTextCtrl             *m_text;
     wxString                m_startValue;
     wxDataViewListModel    *m_model;
-    size_t                  m_col;
-    size_t                  m_row;
+    unsigned int                  m_col;
+    unsigned int                  m_row;
     bool                    m_finished;
     bool                    m_aboutToFinish;
 
@@ -129,7 +130,7 @@ private:
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 
-WX_DEFINE_SORTED_ARRAY_SIZE_T( size_t, wxDataViewSelection );
+WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection, WXDLLIMPEXP_ADV);
 
 class wxDataViewMainWindow: public wxWindow
 {
@@ -144,18 +145,18 @@ public:
     // notifications from wxDataViewListModel
     bool RowAppended();
     bool RowPrepended();
-    bool RowInserted( size_t before );
-    bool RowDeleted( size_t row );
-    bool RowChanged( size_t row );
-    bool ValueChanged( size_t col, size_t row );
-    bool RowsReordered( size_t *new_order );
+    bool RowInserted( unsigned int before );
+    bool RowDeleted( unsigned int row );
+    bool RowChanged( unsigned int row );
+    bool ValueChanged( unsigned int col, unsigned int row );
+    bool RowsReordered( unsigned int *new_order );
     bool Cleared();
 
     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
     wxDataViewCtrl *GetOwner() { return m_owner; }
 
     void OnPaint( wxPaintEvent &event );
-    void OnArrowChar(size_t newCurrent, const wxKeyEvent& event);
+    void OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event);
     void OnChar( wxKeyEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );
@@ -170,27 +171,27 @@ public:
 
     void ScrollWindow( int dx, int dy, const wxRect *rect );
 
-    bool HasCurrentRow() { return m_currentRow != (size_t)-1; }
-    void ChangeCurrentRow( size_t row );
+    bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; }
+    void ChangeCurrentRow( unsigned int row );
 
     bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); };
     bool IsEmpty() { return GetRowCount() == 0; }
 
     int GetCountPerPage();
     int GetEndOfLastCol();
-    size_t GetFirstVisibleRow();
-    size_t GetLastVisibleRow();
-    size_t GetRowCount();
+    unsigned int GetFirstVisibleRow();
+    unsigned int GetLastVisibleRow();
+    unsigned int GetRowCount();
 
     void SelectAllRows( bool on );
-    void SelectRow( size_t row, bool on );
-    void SelectRows( size_t from, size_t to, bool on );
-    void ReverseRowSelection( size_t row );
-    bool IsRowSelected( size_t row );
+    void SelectRow( unsigned int row, bool on );
+    void SelectRows( unsigned int from, unsigned int to, bool on );
+    void ReverseRowSelection( unsigned int row );
+    bool IsRowSelected( unsigned int row );
 
-    void RefreshRow( size_t row );
-    void RefreshRows( size_t from, size_t to );
-    void RefreshRowsAfter( size_t firstRow );
+    void RefreshRow( unsigned int row );
+    void RefreshRows( unsigned int from, unsigned int to );
+    void RefreshRowsAfter( unsigned int firstRow );
 
 private:
     wxDataViewCtrl             *m_owner;
@@ -198,7 +199,7 @@ private:
     bool                        m_dirty;
 
     wxDataViewColumn           *m_currentCol;
-    size_t                      m_currentRow;
+    unsigned int                      m_currentRow;
     wxDataViewSelection         m_selection;
 
     wxDataViewRenameTimer      *m_renameTimer;
@@ -211,7 +212,7 @@ private:
     wxPoint                     m_dragStart;
 
     // for double click logic
-    size_t m_lineLastClicked,
+    unsigned int m_lineLastClicked,
            m_lineBeforeLastClicked,
            m_lineSelectSingleOnUp;
 
@@ -234,15 +235,15 @@ public:
         { return m_mainWindow->RowAppended(); }
     virtual bool RowPrepended()
         { return m_mainWindow->RowPrepended(); }
-    virtual bool RowInserted( size_t before )
+    virtual bool RowInserted( unsigned int before )
         { return m_mainWindow->RowInserted( before ); }
-    virtual bool RowDeleted( size_t row )
+    virtual bool RowDeleted( unsigned int row )
         { return m_mainWindow->RowDeleted( row ); }
-    virtual bool RowChanged( size_t row )
+    virtual bool RowChanged( unsigned int row )
         { return m_mainWindow->RowChanged( row ); }
-    virtual bool ValueChanged( size_t col, size_t row )
+    virtual bool ValueChanged( unsigned int col, unsigned int row )
         { return m_mainWindow->ValueChanged( col, row ); }
-    virtual bool RowsReordered( size_t *new_order )
+    virtual bool RowsReordered( unsigned int *new_order )
         { return m_mainWindow->RowsReordered( new_order ); }
     virtual bool Cleared()
         { return m_mainWindow->Cleared(); }
@@ -251,24 +252,24 @@ public:
 };
 
 // ---------------------------------------------------------
-// wxDataViewCell
+// wxDataViewRenderer
 // ---------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
 
-wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
-    wxDataViewCellBase( varianttype, mode )
+wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+    wxDataViewRendererBase( varianttype, mode )
 {
     m_dc = NULL;
 }
 
-wxDataViewCell::~wxDataViewCell()
+wxDataViewRenderer::~wxDataViewRenderer()
 {
     if (m_dc)
         delete m_dc;
 }
 
-wxDC *wxDataViewCell::GetDC()
+wxDC *wxDataViewRenderer::GetDC()
 {
     if (m_dc == NULL)
     {
@@ -283,78 +284,124 @@ wxDC *wxDataViewCell::GetDC()
 }
 
 // ---------------------------------------------------------
-// wxDataViewCustomCell
+// wxDataViewCustomRenderer
 // ---------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
 
-wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
+wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
                           wxDataViewCellMode mode ) :
-    wxDataViewCell( varianttype, mode )
+    wxDataViewRenderer( varianttype, mode )
 {
 }
 
 // ---------------------------------------------------------
-// wxDataViewTextCell
+// wxDataViewTextRenderer
 // ---------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCustomCell)
+IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewCustomRenderer)
 
-wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
-    wxDataViewCustomCell( varianttype, mode )
+wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+    wxDataViewCustomRenderer( varianttype, mode )
 {
 }
 
-bool wxDataViewTextCell::SetValue( const wxVariant &value )
+bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
 {
     m_text = value.GetString();
 
     return true;
 }
 
-bool wxDataViewTextCell::GetValue( wxVariant& WXUNUSED(value) )
+bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) )
 {
     return false;
 }
 
-bool wxDataViewTextCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewTextRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {
     dc->DrawText( m_text, cell.x, cell.y );
 
     return true;
 }
 
-wxSize wxDataViewTextCell::GetSize()
+wxSize wxDataViewTextRenderer::GetSize()
 {
     return wxSize(80,20);
 }
 
 // ---------------------------------------------------------
-// wxDataViewToggleCell
+// wxDataViewBitmapRenderer
 // ---------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
+IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewCustomRenderer)
 
-wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
+wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
+    wxDataViewCustomRenderer( varianttype, mode )
+{
+}
+
+bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
+{
+    if (value.GetType() == wxT("wxBitmap"))
+        m_bitmap << value;
+    if (value.GetType() == wxT("wxIcon"))
+        m_icon << value;
+
+    return true;
+}
+
+bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) )
+{
+    return false;
+}
+
+bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+{
+    if (m_bitmap.Ok())
+        dc->DrawBitmap( m_bitmap, cell.x, cell.y );
+    else if (m_icon.Ok())
+        dc->DrawIcon( m_icon, cell.x, cell.y );
+
+    return true;
+}
+
+wxSize wxDataViewBitmapRenderer::GetSize()
+{
+    if (m_bitmap.Ok())
+        return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
+    else if (m_icon.Ok())
+        return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
+
+    return wxSize(16,16);
+}
+
+// ---------------------------------------------------------
+// wxDataViewToggleRenderer
+// ---------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewCustomRenderer)
+
+wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
                         wxDataViewCellMode mode ) :
-    wxDataViewCustomCell( varianttype, mode )
+    wxDataViewCustomRenderer( varianttype, mode )
 {
     m_toggle = false;
 }
 
-bool wxDataViewToggleCell::SetValue( const wxVariant &value )
+bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
 {
     m_toggle = value.GetBool();
 
     return true;
 }
 
-bool wxDataViewToggleCell::GetValue( wxVariant &WXUNUSED(value) )
+bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) )
 {
     return false;
 }
 
-bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {
     // User wxRenderer here
 
@@ -379,7 +426,7 @@ bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
     return true;
 }
 
-bool wxDataViewToggleCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t row )
+bool wxDataViewToggleRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
 {
     bool value = !m_toggle;
     wxVariant variant = value;
@@ -388,30 +435,30 @@ bool wxDataViewToggleCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel
     return true;
 }
 
-wxSize wxDataViewToggleCell::GetSize()
+wxSize wxDataViewToggleRenderer::GetSize()
 {
     return wxSize(20,20);
 }
 
 // ---------------------------------------------------------
-// wxDataViewProgressCell
+// wxDataViewProgressRenderer
 // ---------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
 
-wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
+wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
     const wxString &varianttype, wxDataViewCellMode mode ) :
-    wxDataViewCustomCell( varianttype, mode )
+    wxDataViewCustomRenderer( varianttype, mode )
 {
     m_label = label;
     m_value = 0;
 }
 
-wxDataViewProgressCell::~wxDataViewProgressCell()
+wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
 {
 }
 
-bool wxDataViewProgressCell::SetValue( const wxVariant &value )
+bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
 {
     m_value = (long) value;
 
@@ -421,7 +468,7 @@ bool wxDataViewProgressCell::SetValue( const wxVariant &value )
     return true;
 }
 
-bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {
     double pct = (double)m_value / 100.0;
     wxRect bar = cell;
@@ -437,20 +484,20 @@ bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state)
     return true;
 }
 
-wxSize wxDataViewProgressCell::GetSize()
+wxSize wxDataViewProgressRenderer::GetSize()
 {
     return wxSize(40,12);
 }
 
 // ---------------------------------------------------------
-// wxDataViewDateCell
+// wxDataViewDateRenderer
 // ---------------------------------------------------------
 
-class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
+class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
 {
 public:
-    wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
-        wxDataViewListModel *model, size_t col, size_t row ) :
+    wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
+        wxDataViewListModel *model, unsigned int col, unsigned int row ) :
         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
     {
         m_model = model;
@@ -467,8 +514,8 @@ public:
 
     wxCalendarCtrl      *m_cal;
     wxDataViewListModel *m_model;
-    size_t               m_col;
-    size_t               m_row;
+    unsigned int               m_col;
+    unsigned int               m_row;
 
 protected:
     virtual void OnDismiss()
@@ -479,11 +526,11 @@ private:
     DECLARE_EVENT_TABLE()
 };
 
-BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
-    EVT_CALENDAR( wxID_ANY, wxDataViewDateCellPopupTransient::OnCalendar )
+BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
+    EVT_CALENDAR( wxID_ANY, wxDataViewDateRendererPopupTransient::OnCalendar )
 END_EVENT_TABLE()
 
-void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
+void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
 {
     wxDateTime date = event.GetDate();
     wxVariant value = date;
@@ -492,22 +539,22 @@ void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
     DismissAndNotify();
 }
 
-IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
 
-wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
+wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
                         wxDataViewCellMode mode ) :
-    wxDataViewCustomCell( varianttype, mode )
+    wxDataViewCustomRenderer( varianttype, mode )
 {
 }
 
-bool wxDataViewDateCell::SetValue( const wxVariant &value )
+bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
 {
     m_date = value.GetDateTime();
 
     return true;
 }
 
-bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
+bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {
     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
     wxString tmp = m_date.FormatDate();
@@ -516,7 +563,7 @@ bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
     return true;
 }
 
-wxSize wxDataViewDateCell::GetSize()
+wxSize wxDataViewDateRenderer::GetSize()
 {
     wxDataViewCtrl* view = GetOwner()->GetOwner();
     wxString tmp = m_date.FormatDate();
@@ -525,13 +572,13 @@ wxSize wxDataViewDateCell::GetSize()
     return wxSize(x,y+d);
 }
 
-bool wxDataViewDateCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t row )
+bool wxDataViewDateRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
 {
     wxVariant variant;
     model->GetValue( variant, col, row );
     wxDateTime value = variant.GetDateTime();
 
-    wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
+    wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
     wxPoint pos = wxGetMousePosition();
     popup->Move( pos );
@@ -547,45 +594,71 @@ bool wxDataViewDateCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *m
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 
-wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell, size_t model_column,
-        int fixed_width, wxDataViewColumnSizing sizing, int flags ) :
-    wxDataViewColumnBase( title, cell, model_column, flags )
+wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell, unsigned int model_column,
+        int width, int flags ) :
+    wxDataViewColumnBase( title, cell, model_column, width, flags )
 {
-    m_sizing = sizing;
+    m_width = width;
+    if (m_width < 0)
+        m_width = 80;
+}
 
-    m_width = fixed_width;
-    m_fixedWidth = fixed_width;
+wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell, unsigned int model_column,
+        int width, int flags ) :
+    wxDataViewColumnBase( bitmap, cell, model_column, width, flags )
+{
+    m_width = width;
+    if (m_width < 0)
+        m_width = 30;
 }
 
-wxDataViewColumn::~wxDataViewColumn()
+void wxDataViewColumn::SetAlignment( wxAlignment WXUNUSED(align) )
 {
+    // TODO
 }
 
-void wxDataViewColumn::SetTitle( const wxString &title )
+void wxDataViewColumn::SetSortable( bool WXUNUSED(sortable) )
 {
-    wxDataViewColumnBase::SetTitle( title );
+    // TODO
+}
 
+bool wxDataViewColumn::GetSortable()
+{   
+    // TODO
+    return false;
 }
 
-int wxDataViewColumn::GetWidth()
+void wxDataViewColumn::SetSortOrder( bool WXUNUSED(ascending) )
 {
-    return m_width;
+    // TODO
 }
 
-void wxDataViewColumn::SetFixedWidth( int width )
+bool wxDataViewColumn::IsSortOrderAscending()
 {
-    m_fixedWidth = width;
+    // TODO
+    return true;
+}
+
+
+wxDataViewColumn::~wxDataViewColumn()
+{
+}
+
+void wxDataViewColumn::SetTitle( const wxString &title )
+{
+    wxDataViewColumnBase::SetTitle( title );
+
+}
+
+void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
+{
+    wxDataViewColumnBase::SetBitmap( bitmap );
 
-    if (m_sizing == wxDATAVIEW_COL_WIDTH_FIXED)
-    {
-        m_width = width;
-        // Set dirty
-    }
 }
 
-int wxDataViewColumn::GetFixedWidth()
+int wxDataViewColumn::GetWidth()
 {
-    return m_fixedWidth;
+    return m_width;
 }
 
 //-----------------------------------------------------------------------------
@@ -638,8 +711,8 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
     dc.SetFont( GetFont() );
 
-    size_t cols = GetOwner()->GetNumberOfColumns();
-    size_t i;
+    unsigned int cols = GetOwner()->GetNumberOfColumns();
+    unsigned int i;
     int xpos = 0;
     for (i = 0; i < cols; i++)
     {
@@ -702,7 +775,7 @@ wxDataViewTextCtrlWrapper::wxDataViewTextCtrlWrapper(
                         wxDataViewMainWindow *owner,
                         wxTextCtrl *text,
                         wxDataViewListModel *model,
-                        size_t col, size_t row,
+                        unsigned int col, unsigned int row,
                         wxRect rectLabel )
 {
     m_owner = owner;
@@ -835,7 +908,7 @@ void wxDataViewTextCtrlWrapper::Finish()
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 
-int LINKAGEMODE wxDataViewSelectionCmp( size_t row1, size_t row2 )
+int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
 {
     if (row1 > row2) return 1;
     if (row1 == row2) return 0;
@@ -874,9 +947,9 @@ wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID i
 
     m_dragCount = 0;
     m_dragStart = wxPoint(0,0);
-    m_lineLastClicked = (size_t) -1;
-    m_lineBeforeLastClicked = (size_t) -1;
-    m_lineSelectSingleOnUp = (size_t) -1;
+    m_lineLastClicked = (unsigned int) -1;
+    m_lineBeforeLastClicked = (unsigned int) -1;
+    m_lineSelectSingleOnUp = (unsigned int) -1;
 
     m_hasFocus = false;
 
@@ -899,8 +972,8 @@ void wxDataViewMainWindow::OnRenameTimer()
 
 
     int xpos = 0;
-    size_t cols = GetOwner()->GetNumberOfColumns();
-    size_t i;
+    unsigned int cols = GetOwner()->GetNumberOfColumns();
+    unsigned int i;
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *c = GetOwner()->GetColumn( i );
@@ -935,22 +1008,22 @@ bool wxDataViewMainWindow::RowPrepended()
     return false;
 }
 
-bool wxDataViewMainWindow::RowInserted( size_t WXUNUSED(before) )
+bool wxDataViewMainWindow::RowInserted( unsigned int WXUNUSED(before) )
 {
     return false;
 }
 
-bool wxDataViewMainWindow::RowDeleted( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowDeleted( unsigned int WXUNUSED(row) )
 {
     return false;
 }
 
-bool wxDataViewMainWindow::RowChanged( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowChanged( unsigned int WXUNUSED(row) )
 {
     return false;
 }
 
-bool wxDataViewMainWindow::ValueChanged( size_t WXUNUSED(col), size_t row )
+bool wxDataViewMainWindow::ValueChanged( unsigned int WXUNUSED(col), unsigned int row )
 {
     wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
@@ -959,7 +1032,7 @@ bool wxDataViewMainWindow::ValueChanged( size_t WXUNUSED(col), size_t row )
     return true;
 }
 
-bool wxDataViewMainWindow::RowsReordered( size_t *WXUNUSED(new_order) )
+bool wxDataViewMainWindow::RowsReordered( unsigned int *WXUNUSED(new_order) )
 {
     Refresh();
 
@@ -997,8 +1070,8 @@ void wxDataViewMainWindow::RecalculateDisplay()
     }
 
     int width = 0;
-    size_t cols = GetOwner()->GetNumberOfColumns();
-    size_t i;
+    unsigned int cols = GetOwner()->GetNumberOfColumns();
+    unsigned int i;
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
@@ -1032,13 +1105,13 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
     wxDataViewListModel *model = GetOwner()->GetModel();
 
-    size_t item_start = wxMax( 0, (update.y / m_lineHeight) );
-    size_t item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1),
+    unsigned int item_start = wxMax( 0, (update.y / m_lineHeight) );
+    unsigned int item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1),
                                (int)(model->GetNumberOfRows()-item_start) );
 
 
 
-    size_t item;
+    unsigned int item;
     for (item = item_start; item < item_start+item_count; item++)
     {
         if (m_selection.Index( item ) != wxNOT_FOUND)
@@ -1080,12 +1153,12 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
     wxRect cell_rect;
     cell_rect.x = 0;
     cell_rect.height = m_lineHeight;
-    size_t cols = GetOwner()->GetNumberOfColumns();
-    size_t i;
+    unsigned int cols = GetOwner()->GetNumberOfColumns();
+    unsigned int i;
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
-        wxDataViewCell *cell = col->GetCell();
+        wxDataViewRenderer *cell = col->GetRenderer();
         cell_rect.width = col->GetWidth();
 
         for (item = item_start; item < item_start+item_count; item++)
@@ -1122,7 +1195,7 @@ int wxDataViewMainWindow::GetCountPerPage()
 int wxDataViewMainWindow::GetEndOfLastCol()
 {
     int width = 0;
-    size_t i;
+    unsigned int i;
     for (i = 0; i < GetOwner()->GetNumberOfColumns(); i++)
     {
         wxDataViewColumn *c = GetOwner()->GetColumn( i );
@@ -1131,7 +1204,7 @@ int wxDataViewMainWindow::GetEndOfLastCol()
     return width;
 }
 
-size_t wxDataViewMainWindow::GetFirstVisibleRow()
+unsigned int wxDataViewMainWindow::GetFirstVisibleRow()
 {
     int x = 0;
     int y = 0;
@@ -1140,7 +1213,7 @@ size_t wxDataViewMainWindow::GetFirstVisibleRow()
     return y / m_lineHeight;
 }
 
-size_t wxDataViewMainWindow::GetLastVisibleRow()
+unsigned int wxDataViewMainWindow::GetLastVisibleRow()
 {
     wxSize client_size = GetClientSize();
     m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, &client_size.x, &client_size.y );
@@ -1148,12 +1221,12 @@ size_t wxDataViewMainWindow::GetLastVisibleRow()
     return wxMin( GetRowCount()-1, ((unsigned)client_size.y/m_lineHeight)+1 );
 }
 
-size_t wxDataViewMainWindow::GetRowCount()
+unsigned int wxDataViewMainWindow::GetRowCount()
 {
     return GetOwner()->GetModel()->GetNumberOfRows();
 }
 
-void wxDataViewMainWindow::ChangeCurrentRow( size_t row )
+void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
 {
     m_currentRow = row;
 
@@ -1168,18 +1241,18 @@ void wxDataViewMainWindow::SelectAllRows( bool on )
     if (on)
     {
         m_selection.Clear();
-        for (size_t i = 0; i < GetRowCount(); i++)
+        for (unsigned int i = 0; i < GetRowCount(); i++)
             m_selection.Add( i );
         Refresh();
     }
     else
     {
-        size_t first_visible = GetFirstVisibleRow();
-        size_t last_visible = GetLastVisibleRow();
-        size_t i;
+        unsigned int first_visible = GetFirstVisibleRow();
+        unsigned int last_visible = GetLastVisibleRow();
+        unsigned int i;
         for (i = 0; i < m_selection.GetCount(); i++)
         {
-            size_t row = m_selection[i];
+            unsigned int row = m_selection[i];
             if ((row >= first_visible) && (row <= last_visible))
                 RefreshRow( row );
         }
@@ -1187,7 +1260,7 @@ void wxDataViewMainWindow::SelectAllRows( bool on )
     }
 }
 
-void wxDataViewMainWindow::SelectRow( size_t row, bool on )
+void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
 {
     if (m_selection.Index( row ) == wxNOT_FOUND)
     {
@@ -1207,16 +1280,16 @@ void wxDataViewMainWindow::SelectRow( size_t row, bool on )
     }
 }
 
-void wxDataViewMainWindow::SelectRows( size_t from, size_t to, bool on )
+void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
 {
     if (from > to)
     {
-        size_t tmp = from;
+        unsigned int tmp = from;
         from = to;
         to = tmp;
     }
 
-    size_t i;
+    unsigned int i;
     for (i = from; i <= to; i++)
     {
         if (m_selection.Index( i ) == wxNOT_FOUND)
@@ -1233,7 +1306,7 @@ void wxDataViewMainWindow::SelectRows( size_t from, size_t to, bool on )
     RefreshRows( from, to );
 }
 
-void wxDataViewMainWindow::ReverseRowSelection( size_t row )
+void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
 {
     if (m_selection.Index( row ) == wxNOT_FOUND)
         m_selection.Add( row );
@@ -1242,12 +1315,12 @@ void wxDataViewMainWindow::ReverseRowSelection( size_t row )
     RefreshRow( row );
 }
 
-bool wxDataViewMainWindow::IsRowSelected( size_t row )
+bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
 {
     return (m_selection.Index( row ) != wxNOT_FOUND);
 }
 
-void wxDataViewMainWindow::RefreshRow( size_t row )
+void wxDataViewMainWindow::RefreshRow( unsigned int row )
 {
     wxRect rect( 0, row*m_lineHeight, GetEndOfLastCol(), m_lineHeight );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
@@ -1259,11 +1332,11 @@ void wxDataViewMainWindow::RefreshRow( size_t row )
         Refresh( true, &intersect_rect );
 }
 
-void wxDataViewMainWindow::RefreshRows( size_t from, size_t to )
+void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
 {
     if (from > to)
     {
-        size_t tmp = to;
+        unsigned int tmp = to;
         to = from;
         from = tmp;
     }
@@ -1278,9 +1351,9 @@ void wxDataViewMainWindow::RefreshRows( size_t from, size_t to )
         Refresh( true, &intersect_rect );
 }
 
-void wxDataViewMainWindow::RefreshRowsAfter( size_t firstRow )
+void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
 {
-    size_t count = GetRowCount();
+    unsigned int count = GetRowCount();
     if (firstRow > count)
         return;
 
@@ -1294,7 +1367,7 @@ void wxDataViewMainWindow::RefreshRowsAfter( size_t firstRow )
         Refresh( true, &intersect_rect );
 }
 
-void wxDataViewMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& event)
+void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event)
 {
     wxCHECK_RET( newCurrent < GetRowCount(),
                  _T("invalid item index in OnArrowChar()") );
@@ -1303,7 +1376,7 @@ void wxDataViewMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& even
     if (!HasCurrentRow())
         return;
 
-    size_t oldCurrent = m_currentRow;
+    unsigned int oldCurrent = m_currentRow;
 
     // in single selection we just ignore Shift as we can't select several
     // items anyhow
@@ -1401,8 +1474,8 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
         case WXK_PAGEDOWN:
             {
                 int steps = pageSize - 1;
-                size_t index = m_currentRow + steps;
-                size_t count = GetRowCount();
+                unsigned int index = m_currentRow + steps;
+                unsigned int count = GetRowCount();
                 if ( index >= count )
                     index = count - 1;
 
@@ -1431,8 +1504,8 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
     wxDataViewColumn *col = NULL;
 
     int xpos = 0;
-    size_t cols = GetOwner()->GetNumberOfColumns();
-    size_t i;
+    unsigned int cols = GetOwner()->GetNumberOfColumns();
+    unsigned int i;
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *c = GetOwner()->GetColumn( i );
@@ -1445,9 +1518,9 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
     }
     if (!col)
         return;
-    wxDataViewCell *cell = col->GetCell();
+    wxDataViewRenderer *cell = col->GetRenderer();
 
-    size_t current = y / m_lineHeight;
+    unsigned int current = y / m_lineHeight;
 
     if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
     {
@@ -1515,7 +1588,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 
     if (event.LeftUp())
     {
-        if (m_lineSelectSingleOnUp != (size_t)-1)
+        if (m_lineSelectSingleOnUp != (unsigned int)-1)
         {
             // select single line
             SelectAllRows( false );
@@ -1532,7 +1605,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         }
 
         m_lastOnSame = false;
-        m_lineSelectSingleOnUp = (size_t)-1;
+        m_lineSelectSingleOnUp = (unsigned int)-1;
     }
     else
     {
@@ -1540,7 +1613,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         // from and to ourself, the up event is swallowed by the
         // DnD code. So on next non-up event (which means here and
         // now) m_lineSelectSingleOnUp should be reset.
-        m_lineSelectSingleOnUp = (size_t)-1;
+        m_lineSelectSingleOnUp = (unsigned int)-1;
     }
 
     if (event.RightDown())
@@ -1577,7 +1650,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         m_lineBeforeLastClicked = m_lineLastClicked;
         m_lineLastClicked = current;
 
-        size_t oldCurrentRow = m_currentRow;
+        unsigned int oldCurrentRow = m_currentRow;
         bool oldWasSelected = IsRowSelected(m_currentRow);
 
         bool cmdModifierDown = event.CmdDown();
@@ -1609,7 +1682,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
             {
                 ChangeCurrentRow(current);
 
-                size_t lineFrom = oldCurrentRow,
+                unsigned int lineFrom = oldCurrentRow,
                        lineTo = current;
 
                 if ( lineTo < lineFrom )
@@ -1767,6 +1840,47 @@ bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
     return true;
 }
 
+void wxDataViewCtrl::SetSelection( int WXUNUSED(row) )
+{
+    // FIXME - TODO
+}
+
+void wxDataViewCtrl::SetSelectionRange( unsigned int WXUNUSED(from), unsigned int WXUNUSED(to) )
+{
+    // FIXME - TODO
+}
+
+void wxDataViewCtrl::SetSelections( const wxArrayInt& WXUNUSED(aSelections) )
+{
+    // FIXME - TODO
+}
+
+void wxDataViewCtrl::Unselect( unsigned int WXUNUSED(row) )
+{
+    // FIXME - TODO
+}
+
+bool wxDataViewCtrl::IsSelected( unsigned int WXUNUSED(row) ) const
+{
+    // FIXME - TODO
+
+    return false;
+}
+
+int wxDataViewCtrl::GetSelection() const
+{
+    // FIXME - TODO
+
+    return -1;
+}
+
+int wxDataViewCtrl::GetSelections(wxArrayInt& WXUNUSED(aSelections) ) const
+{
+    // FIXME - TODO
+
+    return 0;
+}
+
 #endif
     // !wxUSE_GENERICDATAVIEWCTRL