Return to just using the official API for setting

[wxWidgets.git] / src / generic / datavgen.cpp

diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp
index 4f5a5220eb14f4de3a8d38b423b975d404931418..771dab7a474a134ba1116c31b775d4cac50796be 100644 (file)
--- a/src/generic/datavgen.cpp
+++ b/src/generic/datavgen.cpp
@@ -10,6 +10,10 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+

 #if wxUSE_DATAVIEWCTRL
 
 #include "wx/dataview.h"
 #if wxUSE_DATAVIEWCTRL
 
 #include "wx/dataview.h"


@@ -17,21 +21,23 @@
 #ifdef wxUSE_GENERICDATAVIEWCTRL
 
 #ifndef WX_PRECOMP
 #ifdef wxUSE_GENERICDATAVIEWCTRL
 
 #ifndef WX_PRECOMP

+    #ifdef __WXMSW__
+        #include "wx/msw/wrapwin.h"
+    #endif

     #include "wx/sizer.h"
     #include "wx/log.h"
     #include "wx/sizer.h"
     #include "wx/log.h"

+    #include "wx/dcclient.h"
+    #include "wx/timer.h"
+    #include "wx/settings.h"
+    #include "wx/msgdlg.h"

 #endif
 
 #include "wx/stockitem.h"
 #endif
 
 #include "wx/stockitem.h"

-#include "wx/dcclient.h"

 #include "wx/calctrl.h"
 #include "wx/popupwin.h"
 #include "wx/renderer.h"
 #include "wx/calctrl.h"
 #include "wx/popupwin.h"
 #include "wx/renderer.h"

-#include "wx/timer.h"
-#include "wx/settings.h"
-
-#ifdef __WXMSW__
-    #include "wx/msw/wrapwin.h"
-#endif
+#include "wx/dcbuffer.h"
+#include "wx/icon.h"

 
 //-----------------------------------------------------------------------------
 // classes
 
 //-----------------------------------------------------------------------------
 // classes


@@ -51,7 +57,7 @@ public:
                             const wxPoint &pos = wxDefaultPosition,
                             const wxSize &size = wxDefaultSize,
                             const wxString &name = wxT("wxdataviewctrlheaderwindow") );
                             const wxPoint &pos = wxDefaultPosition,
                             const wxSize &size = wxDefaultSize,
                             const wxString &name = wxT("wxdataviewctrlheaderwindow") );

-    ~wxDataViewHeaderWindow();
+    virtual ~wxDataViewHeaderWindow();

 
     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
     wxDataViewCtrl *GetOwner() { return m_owner; }
 
     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
     wxDataViewCtrl *GetOwner() { return m_owner; }


@@ -94,7 +100,7 @@ public:
     wxDataViewTextCtrlWrapper( wxDataViewMainWindow *owner,
                                wxTextCtrl *text,
                                wxDataViewListModel *model,
     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; }
                                wxRect cellLabel );
 
     wxTextCtrl *GetText() const { return m_text; }


@@ -114,8 +120,8 @@ private:
     wxTextCtrl             *m_text;
     wxString                m_startValue;
     wxDataViewListModel    *m_model;
     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;
 
     bool                    m_finished;
     bool                    m_aboutToFinish;
 


@@ -126,7 +132,7 @@ private:
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 
 // 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
 {
 
 class wxDataViewMainWindow: public wxWindow
 {


@@ -136,23 +142,23 @@ public:
                             const wxPoint &pos = wxDefaultPosition,
                             const wxSize &size = wxDefaultSize,
                             const wxString &name = wxT("wxdataviewctrlmainwindow") );
                             const wxPoint &pos = wxDefaultPosition,
                             const wxSize &size = wxDefaultSize,
                             const wxString &name = wxT("wxdataviewctrlmainwindow") );

-    ~wxDataViewMainWindow();
+    virtual ~wxDataViewMainWindow();

 
     // notifications from wxDataViewListModel
     bool RowAppended();
     bool RowPrepended();
 
     // 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 );
     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 );
     void OnChar( wxKeyEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );


@@ -166,42 +172,51 @@ public:
     void FinishEditing( wxTextCtrl *text );
 
     void ScrollWindow( int dx, int dy, const wxRect *rect );
     void FinishEditing( wxTextCtrl *text );
 
     void ScrollWindow( int dx, int dy, const wxRect *rect );

-    
-    bool HasCurrentRow() { return m_currentRow != (size_t)-1; }
-    
+
+    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; }
     bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); };
     bool IsEmpty() { return GetRowCount() == 0; }

-    
+

     int GetCountPerPage();
     int GetCountPerPage();

-    int GetRowCount();
-    
+    int GetEndOfLastCol();
+    unsigned int GetFirstVisibleRow();
+    unsigned int GetLastVisibleRow();
+    unsigned int GetRowCount();
+

     void SelectAllRows( bool on );
     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 RefreshRow( size_t row );
-    void RefreshRows( size_t from, size_t to );
-    void RefreshRowsAfter( size_t firstRow );
-    
+    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( unsigned int row );
+    void RefreshRows( unsigned int from, unsigned int to );
+    void RefreshRowsAfter( unsigned int firstRow );
+

 private:
     wxDataViewCtrl             *m_owner;
     int                         m_lineHeight;
     bool                        m_dirty;
 private:
     wxDataViewCtrl             *m_owner;
     int                         m_lineHeight;
     bool                        m_dirty;

-    
+

     wxDataViewColumn           *m_currentCol;
     wxDataViewColumn           *m_currentCol;

-    size_t                      m_currentRow;
+    unsigned int                      m_currentRow;

     wxDataViewSelection         m_selection;
     wxDataViewSelection         m_selection;

-    
+

     wxDataViewRenameTimer      *m_renameTimer;
     wxDataViewTextCtrlWrapper  *m_textctrlWrapper;
     bool                        m_lastOnSame;
 
     wxDataViewRenameTimer      *m_renameTimer;
     wxDataViewTextCtrlWrapper  *m_textctrlWrapper;
     bool                        m_lastOnSame;
 

-    wxBrush                    *m_highlightBrush,
-                               *m_highlightUnfocusedBrush;

     bool                        m_hasFocus;
 
     bool                        m_hasFocus;
 

+    int                         m_dragCount;
+    wxPoint                     m_dragStart;
+
+    // for double click logic
+    unsigned int m_lineLastClicked,
+           m_lineBeforeLastClicked,
+           m_lineSelectSingleOnUp;

 
 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)


@@ -222,15 +237,15 @@ public:
         { return m_mainWindow->RowAppended(); }
     virtual bool RowPrepended()
         { return m_mainWindow->RowPrepended(); }
         { 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 ); }
         { return m_mainWindow->RowInserted( before ); }

-    virtual bool RowDeleted( size_t row )
+    virtual bool RowDeleted( unsigned int row )

         { return m_mainWindow->RowDeleted( row ); }
         { return m_mainWindow->RowDeleted( row ); }

-    virtual bool RowChanged( size_t row )
+    virtual bool RowChanged( unsigned int row )

         { return m_mainWindow->RowChanged( 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 ); }
         { 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(); }
         { return m_mainWindow->RowsReordered( new_order ); }
     virtual bool Cleared()
         { return m_mainWindow->Cleared(); }


@@ -239,24 +254,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;
 }
 
 {
     m_dc = NULL;
 }
 

-wxDataViewCell::~wxDataViewCell()
+wxDataViewRenderer::~wxDataViewRenderer()

 {
     if (m_dc)
         delete m_dc;
 }
 
 {
     if (m_dc)
         delete m_dc;
 }
 

-wxDC *wxDataViewCell::GetDC()
+wxDC *wxDataViewRenderer::GetDC()

 {
     if (m_dc == NULL)
     {
 {
     if (m_dc == NULL)
     {


@@ -271,78 +286,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 ) :
                           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;
 }
 
 {
     m_text = value.GetString();
 
     return true;
 }
 

-bool wxDataViewTextCell::GetValue( wxVariant& WXUNUSED(value) )
+bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) )

 {
     return false;
 }
 
 {
     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;
 }
 
 {
     dc->DrawText( m_text, cell.x, cell.y );
 
     return true;
 }
 

-wxSize wxDataViewTextCell::GetSize()
+wxSize wxDataViewTextRenderer::GetSize()

 {
     return wxSize(80,20);
 }
 
 // ---------------------------------------------------------
 {
     return wxSize(80,20);
 }
 
 // ---------------------------------------------------------

-// wxDataViewToggleCell
+// wxDataViewBitmapRenderer

 // ---------------------------------------------------------
 
 // ---------------------------------------------------------
 

-IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
+IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewCustomRenderer)
+
+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 );

 
 

-wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
+    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 ) :
                         wxDataViewCellMode mode ) :

-    wxDataViewCustomCell( varianttype, mode )
+    wxDataViewCustomRenderer( varianttype, mode )

 {
     m_toggle = false;
 }
 
 {
     m_toggle = false;
 }
 

-bool wxDataViewToggleCell::SetValue( const wxVariant &value )
+bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )

 {
     m_toggle = value.GetBool();
 
 {
     m_toggle = value.GetBool();
 

-    return true;;
+    return true;

 }
 
 }
 

-bool wxDataViewToggleCell::GetValue( wxVariant &WXUNUSED(value) )
+bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) )

 {
     return false;
 }
 
 {
     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
 
 {
     // User wxRenderer here
 


@@ -351,14 +412,14 @@ bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
     rect.width = 20;
     rect.y = cell.y + cell.height/2 - 10;
     rect.height = 20;
     rect.width = 20;
     rect.y = cell.y + cell.height/2 - 10;
     rect.height = 20;

-    
+

     int flags = 0;
     if (m_toggle)
         flags |= wxCONTROL_CHECKED;
     if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE)
         flags |= wxCONTROL_DISABLED;
 
     int flags = 0;
     if (m_toggle)
         flags |= wxCONTROL_CHECKED;
     if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE)
         flags |= wxCONTROL_DISABLED;
 

-    wxRendererNative::Get().DrawCheckButton(
+    wxRendererNative::Get().DrawCheckBox(

             GetOwner()->GetOwner(),
             *dc,
             rect,
             GetOwner()->GetOwner(),
             *dc,
             rect,


@@ -367,7 +428,7 @@ bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
     return true;
 }
 
     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;
 {
     bool value = !m_toggle;
     wxVariant variant = value;


@@ -376,30 +437,30 @@ bool wxDataViewToggleCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel
     return true;
 }
 
     return true;
 }
 

-wxSize wxDataViewToggleCell::GetSize()
+wxSize wxDataViewToggleRenderer::GetSize()

 {
     return wxSize(20,20);
 }
 
 // ---------------------------------------------------------
 {
     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 ) :
     const wxString &varianttype, wxDataViewCellMode mode ) :

-    wxDataViewCustomCell( varianttype, mode )
+    wxDataViewCustomRenderer( varianttype, mode )

 {
     m_label = label;
     m_value = 0;
 }
 
 {
     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;
 
 {
     m_value = (long) value;
 


@@ -409,7 +470,7 @@ bool wxDataViewProgressCell::SetValue( const wxVariant &value )
     return true;
 }
 
     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;
 {
     double pct = (double)m_value / 100.0;
     wxRect bar = cell;


@@ -425,20 +486,22 @@ bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state)
     return true;
 }
 
     return true;
 }
 

-wxSize wxDataViewProgressCell::GetSize()
+wxSize wxDataViewProgressRenderer::GetSize()

 {
     return wxSize(40,12);
 }
 
 // ---------------------------------------------------------
 {
     return wxSize(40,12);
 }
 
 // ---------------------------------------------------------

-// wxDataViewDateCell
+// wxDataViewDateRenderer

 // ---------------------------------------------------------
 
 // ---------------------------------------------------------
 

-class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
+#if wxUSE_CALENDARCTRL
+
+class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow

 {
 public:
 {
 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;
         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
     {
         m_model = model;


@@ -451,26 +514,27 @@ public:
         sizer->Fit( this );
     }
 
         sizer->Fit( this );
     }
 

-    virtual void OnDismiss()
-    {
-    }
-

     void OnCalendar( wxCalendarEvent &event );
 
     wxCalendarCtrl      *m_cal;
     wxDataViewListModel *m_model;
     void OnCalendar( wxCalendarEvent &event );
 
     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()
+    {
+    }

 
 private:
     DECLARE_EVENT_TABLE()
 };
 
 
 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()
 
 END_EVENT_TABLE()
 

-void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
+void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )

 {
     wxDateTime date = event.GetDate();
     wxVariant value = date;
 {
     wxDateTime date = event.GetDate();
     wxVariant value = date;


@@ -479,22 +543,24 @@ void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
     DismissAndNotify();
 }
 
     DismissAndNotify();
 }
 

-IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
+#endif // wxUSE_CALENDARCTRL
+
+IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)

 
 

-wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
+wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,

                         wxDataViewCellMode mode ) :
                         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;
 }
 
 {
     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();
 {
     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
     wxString tmp = m_date.FormatDate();


@@ -503,7 +569,7 @@ bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
     return true;
 }
 
     return true;
 }
 

-wxSize wxDataViewDateCell::GetSize()
+wxSize wxDataViewDateRenderer::GetSize()

 {
     wxDataViewCtrl* view = GetOwner()->GetOwner();
     wxString tmp = m_date.FormatDate();
 {
     wxDataViewCtrl* view = GetOwner()->GetOwner();
     wxString tmp = m_date.FormatDate();


@@ -512,19 +578,22 @@ wxSize wxDataViewDateCell::GetSize()
     return wxSize(x,y+d);
 }
 
     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();
 
 {
     wxVariant variant;
     model->GetValue( variant, col, row );
     wxDateTime value = variant.GetDateTime();
 

-    wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
+#if wxUSE_CALENDARCTRL
+    wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(

         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
     wxPoint pos = wxGetMousePosition();
     popup->Move( pos );
     popup->Layout();
     popup->Popup( popup->m_cal );
         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
     wxPoint pos = wxGetMousePosition();
     popup->Move( pos );
     popup->Layout();
     popup->Popup( popup->m_cal );

-
+#else
+    wxMessageBox(value.Format());
+#endif

     return true;
 }
 
     return true;
 }
 


@@ -534,16 +603,52 @@ bool wxDataViewDateCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *m
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 
 
 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_width = width;
+    if (m_width < 0)
+        m_width = 80;
+}
+
+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;
+}
+
+void wxDataViewColumn::SetAlignment( wxAlignment WXUNUSED(align) )
+{
+    // TODO
+}
+
+void wxDataViewColumn::SetSortable( bool WXUNUSED(sortable) )
+{
+    // TODO
+}
+
+bool wxDataViewColumn::GetSortable()
+{
+    // TODO
+    return false;
+}
+
+void wxDataViewColumn::SetSortOrder( bool WXUNUSED(ascending) )

 {
 {

-    m_sizing = sizing;
-    
-    m_width = fixed_width;
-    m_fixedWidth = fixed_width;
+    // TODO

 }
 
 }
 

+bool wxDataViewColumn::IsSortOrderAscending()
+{
+    // TODO
+    return true;
+}
+
+

 wxDataViewColumn::~wxDataViewColumn()
 {
 }
 wxDataViewColumn::~wxDataViewColumn()
 {
 }


@@ -554,25 +659,15 @@ void wxDataViewColumn::SetTitle( const wxString &title )
 
 }
 
 
 }
 

-int wxDataViewColumn::GetWidth()
+void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )

 {
 {

-    return m_width;
-}
+    wxDataViewColumnBase::SetBitmap( bitmap );

 
 

-void wxDataViewColumn::SetFixedWidth( int width )
-{
-    m_fixedWidth = width;
-    
-    if (m_sizing == wxDATAVIEW_COL_WIDTH_FIXED)
-    {
-        m_width = width;
-        // Set dirty
-    }

 }
 
 }
 

-int wxDataViewColumn::GetFixedWidth()
+int wxDataViewColumn::GetWidth()

 {
 {

-    return m_fixedWidth;
+    return m_width;

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -596,6 +691,7 @@ wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindow
     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
 
     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
 
     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();

+    SetBackgroundStyle( wxBG_STYLE_CUSTOM );

     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );
     if (!m_hasFont)
     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );
     if (!m_hasFont)


@@ -612,7 +708,10 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
     int w, h;
     GetClientSize( &w, &h );
 
     int w, h;
     GetClientSize( &w, &h );
 

-    wxPaintDC dc( this );
+    wxAutoBufferedPaintDC dc( this );
+
+    dc.SetBackground(GetBackgroundColour());
+    dc.Clear();

 
     int xpix;
     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
 
     int xpix;
     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );


@@ -625,29 +724,22 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
     dc.SetFont( GetFont() );
 
 
     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++)
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         int width = col->GetWidth();
 
     int xpos = 0;
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         int width = col->GetWidth();
 

-        // the width of the rect to draw: make it smaller to fit entirely
-        // inside the column rect
-#ifdef __WXMAC__

         int cw = width;
         int ch = h;
         int cw = width;
         int ch = h;

-#else
-        int cw = width - 2;
-        int ch = h - 2;
-#endif

 
         wxRendererNative::Get().DrawHeaderButton
                                 (
                                     this,
                                     dc,
 
         wxRendererNative::Get().DrawHeaderButton
                                 (
                                     this,
                                     dc,

-                                    wxRect(xpos+1, 1, cw-1, ch-1),
+                                    wxRect(xpos, 0, cw, ch-1),

                                     m_parent->IsEnabled() ? 0
                                                           : (int)wxCONTROL_DISABLED
                                 );
                                     m_parent->IsEnabled() ? 0
                                                           : (int)wxCONTROL_DISABLED
                                 );


@@ -696,22 +788,22 @@ wxDataViewTextCtrlWrapper::wxDataViewTextCtrlWrapper(
                         wxDataViewMainWindow *owner,
                         wxTextCtrl *text,
                         wxDataViewListModel *model,
                         wxDataViewMainWindow *owner,
                         wxTextCtrl *text,
                         wxDataViewListModel *model,

-                        size_t col, size_t row,
+                        unsigned int col, unsigned int row,

                         wxRect rectLabel )
 {
     m_owner = owner;
     m_model = model;
     m_row = row;
     m_col = col;
                         wxRect rectLabel )
 {
     m_owner = owner;
     m_model = model;
     m_row = row;
     m_col = col;

-    m_text = text; 
-    
+    m_text = text;
+

     m_finished = false;
     m_aboutToFinish = false;
     m_finished = false;
     m_aboutToFinish = false;

-    
+

     wxVariant value;
     model->GetValue( value, col, row );
     m_startValue = value.GetString();
     wxVariant value;
     model->GetValue( value, col, row );
     m_startValue = value.GetString();

-    
+

     m_owner->GetOwner()->CalcScrolledPosition(
         rectLabel.x, rectLabel.y, &rectLabel.x, &rectLabel.y );
 
     m_owner->GetOwner()->CalcScrolledPosition(
         rectLabel.x, rectLabel.y, &rectLabel.x, &rectLabel.y );
 


@@ -719,7 +811,7 @@ wxDataViewTextCtrlWrapper::wxDataViewTextCtrlWrapper(
                     wxPoint(rectLabel.x-2,rectLabel.y-2),
                     wxSize(rectLabel.width+7,rectLabel.height+4) );
     m_text->SetFocus();
                     wxPoint(rectLabel.x-2,rectLabel.y-2),
                     wxSize(rectLabel.width+7,rectLabel.height+4) );
     m_text->SetFocus();

-                       
+

     m_text->PushEventHandler(this);
 }
 
     m_text->PushEventHandler(this);
 }
 


@@ -782,7 +874,7 @@ void wxDataViewTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
         AcceptChanges();
         //if ( !AcceptChanges() )
         //    m_owner->OnRenameCancelled( m_itemEdited );
         AcceptChanges();
         //if ( !AcceptChanges() )
         //    m_owner->OnRenameCancelled( m_itemEdited );

-        
+

         Finish();
     }
 
         Finish();
     }
 


@@ -829,7 +921,7 @@ void wxDataViewTextCtrlWrapper::Finish()
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 
 // 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;
 {
     if (row1 > row2) return 1;
     if (row1 == row2) return 0;


@@ -849,51 +941,40 @@ END_EVENT_TABLE()
 
 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
     const wxPoint &pos, const wxSize &size, const wxString &name ) :
 
 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
     const wxPoint &pos, const wxSize &size, const wxString &name ) :

-    wxWindow( parent, id, pos, size, 0, name ),
+    wxWindow( parent, id, pos, size, wxWANTS_CHARS, name ),

     m_selection( wxDataViewSelectionCmp )
     m_selection( wxDataViewSelectionCmp )

-    
+

 {
     SetOwner( parent );
 
     m_lastOnSame = false;
     m_renameTimer = new wxDataViewRenameTimer( this );
     m_textctrlWrapper = NULL;
 {
     SetOwner( parent );
 
     m_lastOnSame = false;
     m_renameTimer = new wxDataViewRenameTimer( this );
     m_textctrlWrapper = NULL;

-    
+

     // TODO: user better initial values/nothing selected
     m_currentCol = NULL;
     m_currentRow = 0;
 
     // TODO: we need to calculate this smartly
     m_lineHeight = 20;
     // TODO: user better initial values/nothing selected
     m_currentCol = NULL;
     m_currentRow = 0;
 
     // TODO: we need to calculate this smartly
     m_lineHeight = 20;

-    
-    m_highlightBrush = new wxBrush
-                           (
-                            wxSystemSettings::GetColour
-                            (
-                                wxSYS_COLOUR_HIGHLIGHT
-                            ),
-                            wxSOLID
-                           );
-
-    m_highlightUnfocusedBrush = new wxBrush
-                                    (
-                                       wxSystemSettings::GetColour
-                                       (
-                                           wxSYS_COLOUR_BTNSHADOW
-                                       ),
-                                       wxSOLID
-                                    );
-    
+
+    m_dragCount = 0;
+    m_dragStart = wxPoint(0,0);
+    m_lineLastClicked = (unsigned int) -1;
+    m_lineBeforeLastClicked = (unsigned int) -1;
+    m_lineSelectSingleOnUp = (unsigned int) -1;
+

     m_hasFocus = false;
 
     m_hasFocus = false;
 

+    SetBackgroundStyle( wxBG_STYLE_CUSTOM );
+    SetBackgroundColour( *wxWHITE );
+

     UpdateDisplay();
 }
 
 wxDataViewMainWindow::~wxDataViewMainWindow()
 {
     delete m_renameTimer;
     UpdateDisplay();
 }
 
 wxDataViewMainWindow::~wxDataViewMainWindow()
 {
     delete m_renameTimer;

-    delete m_highlightBrush;
-    delete m_highlightUnfocusedBrush;

 }
 
 void wxDataViewMainWindow::OnRenameTimer()
 }
 
 void wxDataViewMainWindow::OnRenameTimer()


@@ -905,8 +986,8 @@ void wxDataViewMainWindow::OnRenameTimer()
 
 
     int xpos = 0;
 
 
     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 );
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *c = GetOwner()->GetColumn( i );


@@ -919,7 +1000,7 @@ void wxDataViewMainWindow::OnRenameTimer()
     wxClassInfo *textControlClass = CLASSINFO(wxTextCtrl);
 
     wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
     wxClassInfo *textControlClass = CLASSINFO(wxTextCtrl);
 
     wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();

-    m_textctrlWrapper = new wxDataViewTextCtrlWrapper(this, text, GetOwner()->GetModel(), 
+    m_textctrlWrapper = new wxDataViewTextCtrlWrapper(this, text, GetOwner()->GetModel(),

         m_currentCol->GetModelColumn(), m_currentRow, labelRect );
 }
 
         m_currentCol->GetModelColumn(), m_currentRow, labelRect );
 }
 


@@ -941,22 +1022,22 @@ bool wxDataViewMainWindow::RowPrepended()
     return false;
 }
 
     return false;
 }
 

-bool wxDataViewMainWindow::RowInserted( size_t WXUNUSED(before) )
+bool wxDataViewMainWindow::RowInserted( unsigned int WXUNUSED(before) )

 {
     return false;
 }
 
 {
     return false;
 }
 

-bool wxDataViewMainWindow::RowDeleted( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowDeleted( unsigned int WXUNUSED(row) )

 {
     return false;
 }
 
 {
     return false;
 }
 

-bool wxDataViewMainWindow::RowChanged( size_t WXUNUSED(row) )
+bool wxDataViewMainWindow::RowChanged( unsigned int WXUNUSED(row) )

 {
     return false;
 }
 
 {
     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 );
 {
     wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );


@@ -965,10 +1046,10 @@ bool wxDataViewMainWindow::ValueChanged( size_t WXUNUSED(col), size_t row )
     return true;
 }
 
     return true;
 }
 

-bool wxDataViewMainWindow::RowsReordered( size_t *WXUNUSED(new_order) )
+bool wxDataViewMainWindow::RowsReordered( unsigned int *WXUNUSED(new_order) )

 {
     Refresh();
 {
     Refresh();

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -1003,8 +1084,8 @@ void wxDataViewMainWindow::RecalculateDisplay()
     }
 
     int width = 0;
     }
 
     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 );
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );


@@ -1027,7 +1108,10 @@ void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
 
 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 {
 
 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 {

-    wxPaintDC dc( this );
+    wxAutoBufferedPaintDC dc( this );
+
+    dc.SetBackground(GetBackgroundColour());
+    dc.Clear();

 
     GetOwner()->PrepareDC( dc );
 
 
     GetOwner()->PrepareDC( dc );
 


@@ -1038,44 +1122,60 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
     wxDataViewListModel *model = GetOwner()->GetModel();
 
 
     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) );
 
 
                                (int)(model->GetNumberOfRows()-item_start) );
 
 

-    if (m_hasFocus)
-        dc.SetBrush( *m_highlightBrush );
-    else
-        dc.SetBrush( *m_highlightUnfocusedBrush );
-    dc.SetPen( *wxTRANSPARENT_PEN );
-            
-    size_t item;
+
+    unsigned int item;

     for (item = item_start; item < item_start+item_count; item++)
     {
         if (m_selection.Index( item ) != wxNOT_FOUND)
         {
     for (item = item_start; item < item_start+item_count; item++)
     {
         if (m_selection.Index( item ) != wxNOT_FOUND)
         {

-            wxRect rect( 0, item*m_lineHeight+1, 10000, m_lineHeight-2 );
-            dc.DrawRectangle( rect );
+            int flags = wxCONTROL_SELECTED;
+            if (item == m_currentRow)
+                flags |= wxCONTROL_CURRENT;
+            if (m_hasFocus)
+                flags |= wxCONTROL_FOCUSED;
+            wxRect rect( 0, item*m_lineHeight+1, GetEndOfLastCol(), m_lineHeight-2 );
+            wxRendererNative::Get().DrawItemSelectionRect
+                                (
+                                    this,
+                                    dc,
+                                    rect,
+                                    flags
+                                );
+        }
+        else
+        {
+            if (item == m_currentRow)
+            {
+                int flags = wxCONTROL_CURRENT;
+                if (m_hasFocus)
+                    flags |= wxCONTROL_FOCUSED;  // should have no effect
+                wxRect rect( 0, item*m_lineHeight+1, GetEndOfLastCol(), m_lineHeight-2 );
+                wxRendererNative::Get().DrawItemSelectionRect
+                                (
+                                    this,
+                                    dc,
+                                    rect,
+                                    flags
+                                );
+
+            }

         }
     }
         }
     }

-    
-    dc.SetBrush( *wxTRANSPARENT_BRUSH );
-    dc.SetPen( *wxBLACK_PEN );
-    if (HasCurrentRow())
-    {
-        wxRect rect( 0, m_currentRow*m_lineHeight+1, 10000, m_lineHeight-2 );
-        dc.DrawRectangle( rect );
-    }

 
     wxRect cell_rect;
     cell_rect.x = 0;
     cell_rect.height = m_lineHeight;
 
     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 );
     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++)
         cell_rect.width = col->GetWidth();
 
         for (item = item_start; item < item_start+item_count; item++)


@@ -1109,24 +1209,75 @@ int wxDataViewMainWindow::GetCountPerPage()
     return size.y / m_lineHeight;
 }
 
     return size.y / m_lineHeight;
 }
 

-int wxDataViewMainWindow::GetRowCount()
+int wxDataViewMainWindow::GetEndOfLastCol()
+{
+    int width = 0;
+    unsigned int i;
+    for (i = 0; i < GetOwner()->GetNumberOfColumns(); i++)
+    {
+        wxDataViewColumn *c = GetOwner()->GetColumn( i );
+        width += c->GetWidth();
+    }
+    return width;
+}
+
+unsigned int wxDataViewMainWindow::GetFirstVisibleRow()
+{
+    int x = 0;
+    int y = 0;
+    m_owner->CalcUnscrolledPosition( x, y, &x, &y );
+
+    return y / m_lineHeight;
+}
+
+unsigned int wxDataViewMainWindow::GetLastVisibleRow()
+{
+    wxSize client_size = GetClientSize();
+    m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, &client_size.x, &client_size.y );
+
+    return wxMin( GetRowCount()-1, ((unsigned)client_size.y/m_lineHeight)+1 );
+}
+
+unsigned int wxDataViewMainWindow::GetRowCount()

 {
     return GetOwner()->GetModel()->GetNumberOfRows();
 }
 
 {
     return GetOwner()->GetModel()->GetNumberOfRows();
 }
 

+void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
+{
+    m_currentRow = row;
+
+    // send event
+}
+

 void wxDataViewMainWindow::SelectAllRows( bool on )
 {
 void wxDataViewMainWindow::SelectAllRows( bool on )
 {

-    m_selection.Clear();
+    if (IsEmpty())
+        return;
+

     if (on)
     {
     if (on)
     {

-        size_t i;
-        for (i = 0; i < m_selection.GetCount(); i++)
+        m_selection.Clear();
+        for (unsigned int i = 0; i < GetRowCount(); i++)

             m_selection.Add( i );
             m_selection.Add( i );

+        Refresh();
+    }
+    else
+    {
+        unsigned int first_visible = GetFirstVisibleRow();
+        unsigned int last_visible = GetLastVisibleRow();
+        unsigned int i;
+        for (i = 0; i < m_selection.GetCount(); i++)
+        {
+            unsigned int row = m_selection[i];
+            if ((row >= first_visible) && (row <= last_visible))
+                RefreshRow( row );
+        }
+        m_selection.Clear();

     }
     }

-    Refresh();

 }
 
 }
 

-void wxDataViewMainWindow::SelectRow( size_t row, bool on )
+void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )

 {
     if (m_selection.Index( row ) == wxNOT_FOUND)
     {
 {
     if (m_selection.Index( row ) == wxNOT_FOUND)
     {


@@ -1146,16 +1297,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)
     {
 {
     if (from > to)
     {

-        size_t tmp = from;
+        unsigned int tmp = from;

         from = to;
         to = tmp;
     }
 
         from = to;
         to = tmp;
     }
 

-    size_t i;
+    unsigned int i;

     for (i = from; i <= to; i++)
     {
         if (m_selection.Index( i ) == wxNOT_FOUND)
     for (i = from; i <= to; i++)
     {
         if (m_selection.Index( i ) == wxNOT_FOUND)


@@ -1172,25 +1323,25 @@ void wxDataViewMainWindow::SelectRows( size_t from, size_t to, bool on )
     RefreshRows( from, to );
 }
 
     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 );
     else
         m_selection.Remove( row );
 {
     if (m_selection.Index( row ) == wxNOT_FOUND)
         m_selection.Add( row );
     else
         m_selection.Remove( row );

-    Refresh( row );
+    RefreshRow( row );

 }
 
 }
 

-bool wxDataViewMainWindow::IsRowSelected( size_t row )
+bool wxDataViewMainWindow::IsRowSelected( unsigned int row )

 {
     return (m_selection.Index( row ) != wxNOT_FOUND);
 }
 
 {
     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, 10000, m_lineHeight );
+    wxRect rect( 0, row*m_lineHeight, GetEndOfLastCol(), m_lineHeight );

     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );

-    
+

     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );
     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );


@@ -1198,18 +1349,18 @@ void wxDataViewMainWindow::RefreshRow( size_t row )
         Refresh( true, &intersect_rect );
 }
 
         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)
     {
 {
     if (from > to)
     {

-        size_t tmp = to;
+        unsigned int tmp = to;

         to = from;
         from = tmp;
     }
 
         to = from;
         from = tmp;
     }
 

-    wxRect rect( 0, from*m_lineHeight, 10000, (to-from+1) * m_lineHeight );
+    wxRect rect( 0, from*m_lineHeight, GetEndOfLastCol(), (to-from+1) * m_lineHeight );

     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );

-    
+

     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );
     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );


@@ -1217,14 +1368,15 @@ void wxDataViewMainWindow::RefreshRows( size_t from, size_t to )
         Refresh( true, &intersect_rect );
 }
 
         Refresh( true, &intersect_rect );
 }
 

-void wxDataViewMainWindow::RefreshRowsAfter( size_t firstRow )
+void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )

 {
 {

-    size_t count = GetRowCount();
-    if (firstRow > count) return;
-    
-    wxRect rect( 0, firstRow*m_lineHeight, 10000, count * m_lineHeight );
+    unsigned int count = GetRowCount();
+    if (firstRow > count)
+        return;
+
+    wxRect rect( 0, firstRow*m_lineHeight, GetEndOfLastCol(), count * m_lineHeight );

     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );

-    
+

     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );
     wxSize client_size = GetClientSize();
     wxRect client_rect( 0, 0, client_size.x, client_size.y );
     wxRect intersect_rect = client_rect.Intersect( rect );


@@ -1232,24 +1384,24 @@ void wxDataViewMainWindow::RefreshRowsAfter( size_t firstRow )
         Refresh( true, &intersect_rect );
 }
 
         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 < (size_t)GetRowCount(),
+    wxCHECK_RET( newCurrent < GetRowCount(),

                  _T("invalid item index in OnArrowChar()") );
 
     // if there is no selection, we cannot move it anywhere
     if (!HasCurrentRow())
         return;
 
                  _T("invalid item index in OnArrowChar()") );
 
     // if there is no selection, we cannot move it anywhere
     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
 
     // in single selection we just ignore Shift as we can't select several
     // items anyhow

-    if ( event.ShiftDown() /* && !IsSingleSel() */ )
+    if ( event.ShiftDown() && !IsSingleSel() )

     {
         RefreshRow( oldCurrent );
     {
         RefreshRow( oldCurrent );

-    
-        m_currentRow = newCurrent;
+
+        ChangeCurrentRow( newCurrent );

 
         // select all the items between the old and the new one
         if ( oldCurrent > newCurrent )
 
         // select all the items between the old and the new one
         if ( oldCurrent > newCurrent )


@@ -1262,16 +1414,18 @@ void wxDataViewMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& even
     }
     else // !shift
     {
     }
     else // !shift
     {

-        Refresh( oldCurrent );
-    
+        RefreshRow( oldCurrent );
+

         // all previously selected items are unselected unless ctrl is held
         if ( !event.ControlDown() )
             SelectAllRows(false);
 
         // all previously selected items are unselected unless ctrl is held
         if ( !event.ControlDown() )
             SelectAllRows(false);
 

-        m_currentRow = newCurrent;
+        ChangeCurrentRow( newCurrent );

 
         if ( !event.ControlDown() )
             SelectRow( m_currentRow, true );
 
         if ( !event.ControlDown() )
             SelectRow( m_currentRow, true );

+        else
+            RefreshRow( m_currentRow );

     }
 
     // MoveToFocus();
     }
 
     // MoveToFocus();


@@ -1296,7 +1450,7 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
         event.Skip();
         return;
     }
         event.Skip();
         return;
     }

-    
+

     // don't use m_linesPerPage directly as it might not be computed yet
     const int pageSize = GetCountPerPage();
     wxCHECK_RET( pageSize, _T("should have non zero page size") );
     // don't use m_linesPerPage directly as it might not be computed yet
     const int pageSize = GetCountPerPage();
     wxCHECK_RET( pageSize, _T("should have non zero page size") );


@@ -1309,7 +1463,7 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
             break;
 
         case WXK_DOWN:
             break;
 
         case WXK_DOWN:

-            if ( m_currentRow < (size_t)GetRowCount() - 1 )
+            if ( m_currentRow < GetRowCount() - 1 )

                 OnArrowChar( m_currentRow + 1, event );
             break;
 
                 OnArrowChar( m_currentRow + 1, event );
             break;
 


@@ -1337,8 +1491,8 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
         case WXK_PAGEDOWN:
             {
                 int steps = pageSize - 1;
         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;
 
                 if ( index >= count )
                     index = count - 1;
 


@@ -1353,6 +1507,13 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
 
 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 {
 
 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 {

+    if (event.GetEventType() == wxEVT_MOUSEWHEEL)
+    {
+        // let the base handle mouse wheel events.
+        event.Skip();
+        return;
+    }
+

     int x = event.GetX();
     int y = event.GetY();
     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
     int x = event.GetX();
     int y = event.GetY();
     m_owner->CalcUnscrolledPosition( x, y, &x, &y );


@@ -1360,8 +1521,8 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
     wxDataViewColumn *col = NULL;
 
     int xpos = 0;
     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 );
     for (i = 0; i < cols; i++)
     {
         wxDataViewColumn *c = GetOwner()->GetColumn( i );


@@ -1374,12 +1535,46 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
     }
     if (!col)
         return;
     }
     if (!col)
         return;

-    wxDataViewCell *cell = col->GetCell();
+    wxDataViewRenderer *cell = col->GetRenderer();
+
+    unsigned int current = y / m_lineHeight;

 
 

-    size_t row = y / m_lineHeight;
+    if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
+    {
+        // Unselect all if below the last row ?
+        return;
+    }

 
     wxDataViewListModel *model = GetOwner()->GetModel();
 
 
     wxDataViewListModel *model = GetOwner()->GetModel();
 

+    if (event.Dragging())
+    {
+        if (m_dragCount == 0)
+        {
+            // we have to report the raw, physical coords as we want to be
+            // able to call HitTest(event.m_pointDrag) from the user code to
+            // get the item being dragged
+            m_dragStart = event.GetPosition();
+        }
+
+        m_dragCount++;
+
+        if (m_dragCount != 3)
+            return;
+
+        if (event.LeftIsDown())
+        {
+            // Notify cell about drag
+        }
+        return;
+    }
+    else
+    {
+        m_dragCount = 0;
+    }
+
+    bool forceClick = false;
+

     if (event.ButtonDClick())
     {
         m_renameTimer->Stop();
     if (event.ButtonDClick())
     {
         m_renameTimer->Stop();


@@ -1388,22 +1583,38 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 
     if (event.LeftDClick())
     {
 
     if (event.LeftDClick())
     {

-        if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
+        if ( current == m_lineLastClicked )

         {
         {

-            wxVariant value;
-            model->GetValue( value, col->GetModelColumn(), row );
-            cell->SetValue( value );
-            wxRect cell_rect( xpos, row * m_lineHeight, col->GetWidth(), m_lineHeight );
-            cell->Activate( cell_rect, model, col->GetModelColumn(), row );
+            if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
+            {
+                wxVariant value;
+                model->GetValue( value, col->GetModelColumn(), current );
+                cell->SetValue( value );
+                wxRect cell_rect( xpos, current * m_lineHeight, col->GetWidth(), m_lineHeight );
+                cell->Activate( cell_rect, model, col->GetModelColumn(), current );
+            }
+            return;
+        }
+        else
+        {
+            // The first click was on another item, so don't interpret this as
+            // a double click, but as a simple click instead
+            forceClick = true;

         }
         }

+    }

 
 

-        return;
-    } else

     if (event.LeftUp())
     {
     if (event.LeftUp())
     {

+        if (m_lineSelectSingleOnUp != (unsigned int)-1)
+        {
+            // select single line
+            SelectAllRows( false );
+            SelectRow( m_lineSelectSingleOnUp, true );
+        }
+

         if (m_lastOnSame)
         {
         if (m_lastOnSame)
         {

-            if ((col == m_currentCol) & (row == m_currentRow) &&
+            if ((col == m_currentCol) && (current == m_currentRow) &&

                 (cell->GetMode() == wxDATAVIEW_CELL_EDITABLE) )
             {
                 m_renameTimer->Start( 100, true );
                 (cell->GetMode() == wxDATAVIEW_CELL_EDITABLE) )
             {
                 m_renameTimer->Start( 100, true );


@@ -1411,43 +1622,130 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         }
 
         m_lastOnSame = false;
         }
 
         m_lastOnSame = false;

-    } else
-    if (event.LeftDown())
+        m_lineSelectSingleOnUp = (unsigned int)-1;
+    }
+    else

     {
     {

+        // This is necessary, because after a DnD operation in
+        // 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 = (unsigned int)-1;
+    }
+
+    if (event.RightDown())
+    {
+        m_lineBeforeLastClicked = m_lineLastClicked;
+        m_lineLastClicked = current;
+
+        // If the item is already selected, do not update the selection.
+        // Multi-selections should not be cleared if a selected item is clicked.
+        if (!IsRowSelected(current))
+        {
+            SelectAllRows(false);
+            ChangeCurrentRow(current);
+            SelectRow(m_currentRow,true);
+        }
+
+        // notify cell about right click
+        // cell->...
+
+        // Allow generation of context menu event
+        event.Skip();
+    }
+    else if (event.MiddleDown())
+    {
+        // notify cell about middle click
+        // cell->...
+    }
+    if (event.LeftDown() || forceClick)
+    {
+#ifdef __WXMSW__
+        SetFocus();
+#endif
+
+        m_lineBeforeLastClicked = m_lineLastClicked;
+        m_lineLastClicked = current;
+
+        unsigned int oldCurrentRow = m_currentRow;
+        bool oldWasSelected = IsRowSelected(m_currentRow);
+
+        bool cmdModifierDown = event.CmdDown();
+        if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
+        {
+            if ( IsSingleSel() || !IsRowSelected(current) )
+            {
+                SelectAllRows( false );
+
+                ChangeCurrentRow(current);
+
+                SelectRow(m_currentRow,true);
+            }
+            else // multi sel & current is highlighted & no mod keys
+            {
+                m_lineSelectSingleOnUp = current;
+                ChangeCurrentRow(current); // change focus
+            }
+        }
+        else // multi sel & either ctrl or shift is down
+        {
+            if (cmdModifierDown)
+            {
+                ChangeCurrentRow(current);
+
+                ReverseRowSelection(m_currentRow);
+            }
+            else if (event.ShiftDown())
+            {
+                ChangeCurrentRow(current);
+
+                unsigned int lineFrom = oldCurrentRow,
+                       lineTo = current;
+
+                if ( lineTo < lineFrom )
+                {
+                    lineTo = lineFrom;
+                    lineFrom = m_currentRow;
+                }
+
+                SelectRows(lineFrom, lineTo, true);
+            }
+            else // !ctrl, !shift
+            {
+                // test in the enclosing if should make it impossible
+                wxFAIL_MSG( _T("how did we get here?") );
+            }
+        }
+
+        if (m_currentRow != oldCurrentRow)
+            RefreshRow( oldCurrentRow );
+

         wxDataViewColumn *oldCurrentCol = m_currentCol;
         wxDataViewColumn *oldCurrentCol = m_currentCol;

-        size_t oldCurrentRow = m_currentRow;
-        
+

         // Update selection here...
         m_currentCol = col;
         // Update selection here...
         m_currentCol = col;

-        m_currentRow = row;
-        RefreshRow( oldCurrentRow );
-        RefreshRow( m_currentRow );
-    
-        m_lastOnSame = (col == oldCurrentCol) && (row == oldCurrentRow);
-        
-        return;
-    }

 
 

-    event.Skip();
+        m_lastOnSame = !forceClick && ((col == oldCurrentCol) && (current == oldCurrentRow)) && oldWasSelected;
+    }

 }
 
 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
 {
     m_hasFocus = true;
 }
 
 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
 {
     m_hasFocus = true;

-    
+

     if (HasCurrentRow())
         Refresh();
     if (HasCurrentRow())
         Refresh();

-        
+

     event.Skip();
 }
 
 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
 {
     m_hasFocus = false;
     event.Skip();
 }
 
 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
 {
     m_hasFocus = false;

-    
+

     if (HasCurrentRow())
         Refresh();
     if (HasCurrentRow())
         Refresh();

-        
+

     event.Skip();
 }
 
     event.Skip();
 }
 


@@ -1486,7 +1784,11 @@ bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
 #endif
 
     m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
 #endif
 
     m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );

+#ifdef __WXMSW__
+    m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,22) );
+#else

     m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,25) );
     m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,25) );

+#endif

 
     SetTargetWindow( m_clientArea );
 
 
     SetTargetWindow( m_clientArea );
 


@@ -1555,9 +1857,49 @@ bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
     return true;
 }
 
     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
 
 #endif
     // wxUSE_DATAVIEWCTRL
 #endif
     // !wxUSE_GENERICDATAVIEWCTRL
 
 #endif
     // wxUSE_DATAVIEWCTRL

-