really fix warning about implicitly converting 0 and 1 to size_t -- use explicit...

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

diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp
index 6866fa7203e08db60775ff5fa5a392e7ced82f53..2ad27c525e20ed2271fbdd13fde6cff0ae656cc1 100644 (file)
--- a/src/generic/datavgen.cpp
+++ b/src/generic/datavgen.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        datavgen.cpp
+// Name:        src/generic/datavgen.cpp

 // Purpose:     wxDataViewCtrl generic implementation
 // Author:      Robert Roebling
 // Id:          $Id$
 // Purpose:     wxDataViewCtrl generic implementation
 // Author:      Robert Roebling
 // Id:          $Id$


@@ -10,25 +10,26 @@
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

-#include "wx/defs.h"
-

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

+#ifndef WX_PRECOMP
+    #include "wx/sizer.h"
+    #include "wx/log.h"
+#endif
+

 #include "wx/stockitem.h"
 #include "wx/dcclient.h"
 #include "wx/calctrl.h"
 #include "wx/popupwin.h"
 #include "wx/stockitem.h"
 #include "wx/dcclient.h"
 #include "wx/calctrl.h"
 #include "wx/popupwin.h"

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

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

+#include "wx/timer.h"

 
 #ifdef __WXMSW__
 
 #ifdef __WXMSW__

-    #include <windows.h> // for DLGC_WANTARROWS
-    #include "wx/msw/winundef.h"
+    #include "wx/msw/wrapwin.h"

 #endif
 
 //-----------------------------------------------------------------------------
 #endif
 
 //-----------------------------------------------------------------------------


@@ -57,16 +58,69 @@ public:
     void OnPaint( wxPaintEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );
     void OnPaint( wxPaintEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );

-    
+

 private:
     wxDataViewCtrl      *m_owner;
     wxCursor            *m_resizeCursor;
 private:
     wxDataViewCtrl      *m_owner;
     wxCursor            *m_resizeCursor;

-    
+

 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
     DECLARE_EVENT_TABLE()
 };
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
     DECLARE_EVENT_TABLE()
 };
 

+//-----------------------------------------------------------------------------
+// wxDataViewRenameTimer
+//-----------------------------------------------------------------------------
+
+class wxDataViewRenameTimer: public wxTimer
+{
+private:
+    wxDataViewMainWindow *m_owner;
+
+public:
+    wxDataViewRenameTimer( wxDataViewMainWindow *owner );
+    void Notify();
+};
+
+//-----------------------------------------------------------------------------
+// wxDataViewTextCtrlWrapper: wraps a wxTextCtrl for inline editing
+//-----------------------------------------------------------------------------
+
+class wxDataViewTextCtrlWrapper : public wxEvtHandler
+{
+public:
+    // NB: text must be a valid object but not Create()d yet
+    wxDataViewTextCtrlWrapper( wxDataViewMainWindow *owner,
+                               wxTextCtrl *text,
+                               wxDataViewListModel *model,
+                               size_t col, size_t row,
+                               wxRect cellLabel );
+
+    wxTextCtrl *GetText() const { return m_text; }
+
+    void AcceptChangesAndFinish();
+
+protected:
+    void OnChar( wxKeyEvent &event );
+    void OnKeyUp( wxKeyEvent &event );
+    void OnKillFocus( wxFocusEvent &event );
+
+    bool AcceptChanges();
+    void Finish();
+
+private:
+    wxDataViewMainWindow   *m_owner;
+    wxTextCtrl             *m_text;
+    wxString                m_startValue;
+    wxDataViewListModel    *m_model;
+    size_t                  m_col; 
+    size_t                  m_row;
+    bool                    m_finished;
+    bool                    m_aboutToFinish;
+
+    DECLARE_EVENT_TABLE()
+};
+

 //-----------------------------------------------------------------------------
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------


@@ -97,32 +151,42 @@ public:
     void OnPaint( wxPaintEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );
     void OnPaint( wxPaintEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnSetFocus( wxFocusEvent &event );

-    
+

     void UpdateDisplay();
     void RecalculateDisplay();
     void OnInternalIdle();
     void UpdateDisplay();
     void RecalculateDisplay();
     void OnInternalIdle();

-    
+
+    void OnRenameTimer();
+    void FinishEditing( wxTextCtrl *text );
+

     void ScrollWindow( int dx, int dy, const wxRect *rect );
 private:
     void ScrollWindow( int dx, int dy, const wxRect *rect );
 private:

-    wxDataViewCtrl      *m_owner;
-    int                  m_lineHeight;
-    bool                 m_dirty;
+    wxDataViewCtrl             *m_owner;
+    int                         m_lineHeight;
+    bool                        m_dirty;

     
     

+    wxDataViewColumn           *m_currentCol;
+    size_t                      m_currentRow;
+    
+    wxDataViewRenameTimer      *m_renameTimer;
+    wxDataViewTextCtrlWrapper  *m_textctrlWrapper;
+    bool                        m_lastOnSame;
+

 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
     DECLARE_EVENT_TABLE()
 };
 
 private:
     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
     DECLARE_EVENT_TABLE()
 };
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxGenericDataViewListModelNotifier
 // wxGenericDataViewListModelNotifier

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
 {
 public:
     wxGenericDataViewListModelNotifier( wxDataViewMainWindow *mainWindow )
         { m_mainWindow = mainWindow; }
 
 class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
 {
 public:
     wxGenericDataViewListModelNotifier( wxDataViewMainWindow *mainWindow )
         { m_mainWindow = mainWindow; }

-        
+

     virtual bool RowAppended()
         { return m_mainWindow->RowAppended(); }
     virtual bool RowPrepended()
     virtual bool RowAppended()
         { return m_mainWindow->RowAppended(); }
     virtual bool RowPrepended()


@@ -139,13 +203,13 @@ public:
         { 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(); }

-    
+

     wxDataViewMainWindow    *m_mainWindow;
 };
 
     wxDataViewMainWindow    *m_mainWindow;
 };
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewCell
 // wxDataViewCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
 


@@ -171,26 +235,25 @@ wxDC *wxDataViewCell::GetDC()
             return NULL;
         m_dc = new wxClientDC( GetOwner()->GetOwner() );
     }
             return NULL;
         m_dc = new wxClientDC( GetOwner()->GetOwner() );
     }

-        
+

     return m_dc;
 }
 
     return m_dc;
 }
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewCustomCell
 // wxDataViewCustomCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
 

-wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype, 
+wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,

                           wxDataViewCellMode mode ) :
     wxDataViewCell( varianttype, mode )
 {
 }
 
                           wxDataViewCellMode mode ) :
     wxDataViewCell( varianttype, mode )
 {
 }
 

-    
-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewTextCell
 // wxDataViewTextCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCustomCell)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCustomCell)
 


@@ -202,16 +265,16 @@ wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewC
 bool wxDataViewTextCell::SetValue( const wxVariant &value )
 {
     m_text = value.GetString();
 bool wxDataViewTextCell::SetValue( const wxVariant &value )
 {
     m_text = value.GetString();

-    
+

     return true;
 }
 
     return true;
 }
 

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

 {
     return false;
 }
 
 {
     return false;
 }
 

-bool wxDataViewTextCell::Render( wxRect cell, wxDC *dc, int state )
+bool wxDataViewTextCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )

 {
     dc->DrawText( m_text, cell.x, cell.y );
 
 {
     dc->DrawText( m_text, cell.x, cell.y );
 


@@ -223,13 +286,13 @@ wxSize wxDataViewTextCell::GetSize()
     return wxSize(80,20);
 }
 
     return wxSize(80,20);
 }
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewToggleCell
 // wxDataViewToggleCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
 

-wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype, 
+wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,

                         wxDataViewCellMode mode ) :
     wxDataViewCustomCell( varianttype, mode )
 {
                         wxDataViewCellMode mode ) :
     wxDataViewCustomCell( varianttype, mode )
 {


@@ -239,20 +302,23 @@ wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
 bool wxDataViewToggleCell::SetValue( const wxVariant &value )
 {
     m_toggle = value.GetBool();
 bool wxDataViewToggleCell::SetValue( const wxVariant &value )
 {
     m_toggle = value.GetBool();

-    
+

     return true;;
 }
 
     return true;;
 }
 

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

 {
     return false;
 }
 {
     return false;
 }

-    
-bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int state )
+
+bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )

 {
     // User wxRenderer here
 {
     // User wxRenderer here

-    
-    dc->SetPen( *wxBLACK_PEN );
+
+    if (GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
+        dc->SetPen( *wxBLACK_PEN );
+    else
+        dc->SetPen( *wxGREY_PEN );

     dc->SetBrush( *wxTRANSPARENT_BRUSH );
     wxRect rect;
     rect.x = cell.x + cell.width/2 - 10;
     dc->SetBrush( *wxTRANSPARENT_BRUSH );
     wxRect rect;
     rect.x = cell.x + cell.width/2 - 10;


@@ -269,7 +335,16 @@ bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int state )
         dc->DrawLine( rect.x, rect.y, rect.x+rect.width, rect.y+rect.height );
         dc->DrawLine( rect.x+rect.width, rect.y, rect.x, rect.y+rect.height );
     }
         dc->DrawLine( rect.x, rect.y, rect.x+rect.width, rect.y+rect.height );
         dc->DrawLine( rect.x+rect.width, rect.y, rect.x, rect.y+rect.height );
     }

-    
+
+    return true;
+}
+
+bool wxDataViewToggleCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t row )
+{
+    bool value = !m_toggle;
+    wxVariant variant = value;
+    model->SetValue( variant, col, row );
+    model->ValueChanged( col, row );

     return true;
 }
 
     return true;
 }
 


@@ -278,15 +353,15 @@ wxSize wxDataViewToggleCell::GetSize()
     return wxSize(20,20);
 }
 
     return wxSize(20,20);
 }
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewProgressCell
 // wxDataViewProgressCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
 

-wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label, 
+wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,

     const wxString &varianttype, wxDataViewCellMode mode ) :
     const wxString &varianttype, wxDataViewCellMode mode ) :

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

 {
     m_label = label;
     m_value = 0;
 {
     m_label = label;
     m_value = 0;


@@ -299,14 +374,14 @@ wxDataViewProgressCell::~wxDataViewProgressCell()
 bool wxDataViewProgressCell::SetValue( const wxVariant &value )
 {
     m_value = (long) value;
 bool wxDataViewProgressCell::SetValue( const wxVariant &value )
 {
     m_value = (long) value;

-    
+

     if (m_value < 0) m_value = 0;
     if (m_value > 100) m_value = 100;
     if (m_value < 0) m_value = 0;
     if (m_value > 100) m_value = 100;

-    
+

     return true;
 }
     return true;
 }

-    
-bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
+
+bool wxDataViewProgressCell::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;


@@ -318,7 +393,7 @@ bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
     dc->SetBrush( *wxTRANSPARENT_BRUSH );
     dc->SetPen( *wxBLACK_PEN );
     dc->DrawRectangle( cell );
     dc->SetBrush( *wxTRANSPARENT_BRUSH );
     dc->SetPen( *wxBLACK_PEN );
     dc->DrawRectangle( cell );

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -326,14 +401,14 @@ wxSize wxDataViewProgressCell::GetSize()
 {
     return wxSize(40,12);
 }
 {
     return wxSize(40,12);
 }

-    
-// --------------------------------------------------------- 
+
+// ---------------------------------------------------------

 // wxDataViewDateCell
 // wxDataViewDateCell

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
 {
 
 class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
 {

-public: 
+public:

     wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
         wxDataViewListModel *model, size_t col, size_t row ) :
         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
     wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
         wxDataViewListModel *model, size_t col, size_t row ) :
         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )


@@ -341,30 +416,30 @@ public:
         m_model = model;
         m_col = col;
         m_row = row;
         m_model = model;
         m_col = col;
         m_row = row;

-        m_cal = new wxCalendarCtrl( this, -1, *value );
+        m_cal = new wxCalendarCtrl( this, wxID_ANY, *value );

         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
         sizer->Add( m_cal, 1, wxGROW );
         SetSizer( sizer );
         sizer->Fit( this );
     }
         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
         sizer->Add( m_cal, 1, wxGROW );
         SetSizer( sizer );
         sizer->Fit( this );
     }

-    
+

     virtual void OnDismiss()
     {
     }
     virtual void OnDismiss()
     {
     }

-    
+

     void OnCalendar( wxCalendarEvent &event );
     void OnCalendar( wxCalendarEvent &event );

-    
+

     wxCalendarCtrl      *m_cal;
     wxCalendarCtrl      *m_cal;

-    wxDataViewListModel *m_model; 
+    wxDataViewListModel *m_model;

     size_t               m_col;
     size_t               m_row;
     size_t               m_col;
     size_t               m_row;

-    
+

 private:
     DECLARE_EVENT_TABLE()
 };
 
 BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
 private:
     DECLARE_EVENT_TABLE()
 };
 
 BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)

-    EVT_CALENDAR( -1, wxDataViewDateCellPopupTransient::OnCalendar )
+    EVT_CALENDAR( wxID_ANY, wxDataViewDateCellPopupTransient::OnCalendar )

 END_EVENT_TABLE()
 
 void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
 END_EVENT_TABLE()
 
 void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )


@@ -383,15 +458,15 @@ wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
     wxDataViewCustomCell( varianttype, mode )
 {
 }
     wxDataViewCustomCell( varianttype, mode )
 {
 }

-    
+

 bool wxDataViewDateCell::SetValue( const wxVariant &value )
 {
     m_date = value.GetDateTime();
 bool wxDataViewDateCell::SetValue( const wxVariant &value )
 {
     m_date = value.GetDateTime();

-    
+

     return true;
 }
 
     return true;
 }
 

-bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int state )
+bool wxDataViewDateCell::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();


@@ -409,13 +484,13 @@ wxSize wxDataViewDateCell::GetSize()
     return wxSize(x,y+d);
 }
 
     return wxSize(x,y+d);
 }
 

-bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
+bool wxDataViewDateCell::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, size_t col, size_t 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( 
+    wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(

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


@@ -425,13 +500,13 @@ bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size
     return true;
 }
 
     return true;
 }
 

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 // wxDataViewColumn
 // wxDataViewColumn

-// --------------------------------------------------------- 
+// ---------------------------------------------------------

 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 

-wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell, 
+wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell,

     size_t model_column, int flags ) :
     wxDataViewColumnBase( title, cell, model_column, flags )
 {
     size_t model_column, int flags ) :
     wxDataViewColumnBase( title, cell, model_column, flags )
 {


@@ -445,7 +520,7 @@ wxDataViewColumn::~wxDataViewColumn()
 void wxDataViewColumn::SetTitle( const wxString &title )
 {
     wxDataViewColumnBase::SetTitle( title );
 void wxDataViewColumn::SetTitle( const wxString &title )
 {
     wxDataViewColumnBase::SetTitle( title );

-    
+

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


@@ -467,7 +542,7 @@ wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindow
     SetOwner( parent );
 
     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
     SetOwner( parent );
 
     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );

-    
+

     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );
     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );


@@ -480,13 +555,13 @@ wxDataViewHeaderWindow::~wxDataViewHeaderWindow()
     delete m_resizeCursor;
 }
 
     delete m_resizeCursor;
 }
 

-void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
+void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )

 {
     int w, h;
     GetClientSize( &w, &h );
 
     wxPaintDC dc( this );
 {
     int w, h;
     GetClientSize( &w, &h );
 
     wxPaintDC dc( this );

-    
+

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


@@ -495,9 +570,9 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
 
     // account for the horz scrollbar offset
     dc.SetDeviceOrigin( -x * xpix, 0 );
 
     // account for the horz scrollbar offset
     dc.SetDeviceOrigin( -x * xpix, 0 );

-    
+

     dc.SetFont( GetFont() );
     dc.SetFont( GetFont() );

-    
+

     size_t cols = GetOwner()->GetNumberOfColumns();
     size_t i;
     int xpos = 0;
     size_t cols = GetOwner()->GetNumberOfColumns();
     size_t i;
     int xpos = 0;


@@ -505,7 +580,7 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
     {
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         int width = col->GetWidth();
     {
         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__
         // the width of the rect to draw: make it smaller to fit entirely
         // inside the column rect
 #ifdef __WXMAC__


@@ -525,13 +600,13 @@ void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
                                                           : (int)wxCONTROL_DISABLED
                                 );
 
                                                           : (int)wxCONTROL_DISABLED
                                 );
 

-        dc.DrawText( col->GetTitle(), xpos+3, 3 );   
-                                
+        dc.DrawText( col->GetTitle(), xpos+3, 3 );
+

         xpos += width;
     }
 }
 
         xpos += width;
     }
 }
 

-void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &event )
+void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &WXUNUSED(event) )

 {
 }
 
 {
 }
 


@@ -540,6 +615,163 @@ void wxDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
     event.Skip();
 }
 
     event.Skip();
 }
 

+//-----------------------------------------------------------------------------
+// wxDataViewRenameTimer
+//-----------------------------------------------------------------------------
+
+wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner )
+{
+    m_owner = owner;
+}
+
+void wxDataViewRenameTimer::Notify()
+{
+    m_owner->OnRenameTimer();
+}
+
+//-----------------------------------------------------------------------------
+// wxDataViewTextCtrlWrapper: wraps a wxTextCtrl for inline editing
+//-----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(wxDataViewTextCtrlWrapper, wxEvtHandler)
+    EVT_CHAR           (wxDataViewTextCtrlWrapper::OnChar)
+    EVT_KEY_UP         (wxDataViewTextCtrlWrapper::OnKeyUp)
+    EVT_KILL_FOCUS     (wxDataViewTextCtrlWrapper::OnKillFocus)
+END_EVENT_TABLE()
+
+wxDataViewTextCtrlWrapper::wxDataViewTextCtrlWrapper(
+                        wxDataViewMainWindow *owner,
+                        wxTextCtrl *text,
+                        wxDataViewListModel *model,
+                        size_t col, size_t row,
+                        wxRect rectLabel )
+{
+    m_owner = owner;
+    m_model = model;
+    m_row = row;
+    m_col = col;
+    m_text = text; 
+    
+    m_finished = false;
+    m_aboutToFinish = false;
+    
+    wxVariant value;
+    model->GetValue( value, col, row );
+    m_startValue = value.GetString();
+    
+    m_owner->GetOwner()->CalcScrolledPosition(
+        rectLabel.x, rectLabel.y, &rectLabel.x, &rectLabel.y );
+
+    m_text->Create( owner, wxID_ANY, m_startValue,
+                    wxPoint(rectLabel.x-2,rectLabel.y-2),
+                    wxSize(rectLabel.width+7,rectLabel.height+4) );
+    m_text->SetFocus();
+                       
+    m_text->PushEventHandler(this);
+}
+
+void wxDataViewTextCtrlWrapper::AcceptChangesAndFinish()
+{
+    m_aboutToFinish = true;
+
+    // Notify the owner about the changes
+    AcceptChanges();
+
+    // Even if vetoed, close the control (consistent with MSW)
+    Finish();
+}
+
+void wxDataViewTextCtrlWrapper::OnChar( wxKeyEvent &event )
+{
+    switch ( event.m_keyCode )
+    {
+        case WXK_RETURN:
+            AcceptChangesAndFinish();
+            break;
+
+        case WXK_ESCAPE:
+            // m_owner->OnRenameCancelled( m_itemEdited );
+            Finish();
+            break;
+
+        default:
+            event.Skip();
+    }
+}
+
+void wxDataViewTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
+{
+    if (m_finished)
+    {
+        event.Skip();
+        return;
+    }
+
+    // auto-grow the textctrl
+    wxSize parentSize = m_owner->GetSize();
+    wxPoint myPos = m_text->GetPosition();
+    wxSize mySize = m_text->GetSize();
+    int sx, sy;
+    m_text->GetTextExtent(m_text->GetValue() + _T("MM"), &sx, &sy);
+    if (myPos.x + sx > parentSize.x)
+        sx = parentSize.x - myPos.x;
+    if (mySize.x > sx)
+        sx = mySize.x;
+    m_text->SetSize(sx, wxDefaultCoord);
+
+    event.Skip();
+}
+
+void wxDataViewTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
+{
+    if ( !m_finished && !m_aboutToFinish )
+    {
+        AcceptChanges();
+        //if ( !AcceptChanges() )
+        //    m_owner->OnRenameCancelled( m_itemEdited );
+        
+        Finish();
+    }
+
+    // We must let the native text control handle focus
+    event.Skip();
+}
+
+bool wxDataViewTextCtrlWrapper::AcceptChanges()
+{
+    const wxString value = m_text->GetValue();
+
+    if ( value == m_startValue )
+        // nothing changed, always accept
+        return true;
+
+//    if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
+        // vetoed by the user
+//        return false;
+
+    // accepted, do rename the item
+    wxVariant variant;
+    variant = value;
+    m_model->SetValue( variant, m_col, m_row );
+    m_model->ValueChanged( m_col, m_row );
+
+    return true;
+}
+
+void wxDataViewTextCtrlWrapper::Finish()
+{
+    if ( !m_finished )
+    {
+        m_finished = true;
+
+        m_text->RemoveEventHandler(this);
+        m_owner->FinishEditing(m_text);
+
+        // delete later
+        wxPendingDelete.Append( this );
+    }
+}
+

 //-----------------------------------------------------------------------------
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxDataViewMainWindow
 //-----------------------------------------------------------------------------


@@ -557,15 +789,59 @@ wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID i
     wxWindow( parent, id, pos, size, 0, name )
 {
     SetOwner( parent );
     wxWindow( parent, id, pos, size, 0, name )
 {
     SetOwner( parent );

+
+    m_lastOnSame = false;
+    m_renameTimer = new wxDataViewRenameTimer( this );
+    m_textctrlWrapper = NULL;

     
     

-    // We need to calculate this smartly..
+    // TODO: user better initial values/nothing selected
+    m_currentCol = NULL;
+    m_currentRow = 0;
+
+    // TODO: we need to calculate this smartly

     m_lineHeight = 20;
     m_lineHeight = 20;

-    
+

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

+    delete m_renameTimer;
+}
+
+void wxDataViewMainWindow::OnRenameTimer()
+{
+    // We have to call this here because changes may just have
+    // been made and no screen update taken place.
+    if ( m_dirty )
+        wxSafeYield();
+
+
+    int xpos = 0;
+    size_t cols = GetOwner()->GetNumberOfColumns();
+    size_t i;
+    for (i = 0; i < cols; i++)
+    {
+        wxDataViewColumn *c = GetOwner()->GetColumn( i );
+        if (c == m_currentCol)
+            break;
+        xpos += c->GetWidth();
+    }
+    wxRect labelRect( xpos, m_currentRow * m_lineHeight, m_currentCol->GetWidth(), m_lineHeight );
+
+    wxClassInfo *textControlClass = CLASSINFO(wxTextCtrl);
+
+    wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
+    m_textctrlWrapper = new wxDataViewTextCtrlWrapper(this, text, GetOwner()->GetModel(), 
+        m_currentCol->GetModelColumn(), m_currentRow, labelRect );
+}
+
+void wxDataViewMainWindow::FinishEditing( wxTextCtrl *text )
+{
+    delete text;
+    m_textctrlWrapper = NULL;
+    SetFocus();
+  //  SetFocusIgnoringChildren();

 }
 
 bool wxDataViewMainWindow::RowAppended()
 }
 
 bool wxDataViewMainWindow::RowAppended()


@@ -578,29 +854,35 @@ bool wxDataViewMainWindow::RowPrepended()
     return false;
 }
 
     return false;
 }
 

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

 {
     return false;
 }
 
 {
     return false;
 }
 

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

 {
     return false;
 }
 
 {
     return false;
 }
 

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

 {
     return false;
 }
 
 {
     return false;
 }
 

-bool wxDataViewMainWindow::ValueChanged( size_t col, size_t row )
+bool wxDataViewMainWindow::ValueChanged( size_t WXUNUSED(col), size_t row )

 {
 {

-    return false;
+    wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
+    m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+    Refresh( true, &rect );
+
+    return true;

 }
 
 }
 

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

 {
 {

-    return false;
+    Refresh();
+    
+    return true;

 }
 
 bool wxDataViewMainWindow::Cleared()
 }
 
 bool wxDataViewMainWindow::Cleared()


@@ -616,7 +898,7 @@ void wxDataViewMainWindow::UpdateDisplay()
 void wxDataViewMainWindow::OnInternalIdle()
 {
     wxWindow::OnInternalIdle();
 void wxDataViewMainWindow::OnInternalIdle()
 {
     wxWindow::OnInternalIdle();

-    
+

     if (m_dirty)
     {
         RecalculateDisplay();
     if (m_dirty)
     {
         RecalculateDisplay();


@@ -632,7 +914,7 @@ void wxDataViewMainWindow::RecalculateDisplay()
         Refresh();
         return;
     }
         Refresh();
         return;
     }

-    
+

     int width = 0;
     size_t cols = GetOwner()->GetNumberOfColumns();
     size_t i;
     int width = 0;
     size_t cols = GetOwner()->GetNumberOfColumns();
     size_t i;


@@ -641,12 +923,12 @@ void wxDataViewMainWindow::RecalculateDisplay()
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         width += col->GetWidth();
     }
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         width += col->GetWidth();
     }

-    
+

     int height = model->GetNumberOfRows() * m_lineHeight;
 
     SetVirtualSize( width, height );
     GetOwner()->SetScrollRate( 10, m_lineHeight );
     int height = model->GetNumberOfRows() * m_lineHeight;
 
     SetVirtualSize( width, height );
     GetOwner()->SetScrollRate( 10, m_lineHeight );

-    
+

     Refresh();
 }
 
     Refresh();
 }
 


@@ -656,7 +938,7 @@ void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
     GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
 }
 
     GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
 }
 

-void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
+void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )

 {
     wxPaintDC dc( this );
 
 {
     wxPaintDC dc( this );
 


@@ -666,11 +948,12 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
 
     wxRect update = GetUpdateRegion().GetBox();
     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
 
     wxRect update = GetUpdateRegion().GetBox();
     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );

-    
+

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

-    
-    size_t item_start = update.y / m_lineHeight;
-    size_t item_count = (update.height / m_lineHeight) + 1;
+
+    size_t item_start = wxMax( 0, update.y / m_lineHeight );
+    size_t item_count = wxMin( (update.height / m_lineHeight) + 1, 
+                                (int)(model->GetNumberOfRows()-item_start) );

 
     wxRect cell_rect;
     cell_rect.x = 0;
 
     wxRect cell_rect;
     cell_rect.x = 0;


@@ -682,23 +965,108 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         wxDataViewCell *cell = col->GetCell();
         cell_rect.width = col->GetWidth();
         wxDataViewColumn *col = GetOwner()->GetColumn( i );
         wxDataViewCell *cell = col->GetCell();
         cell_rect.width = col->GetWidth();

-        
+

         size_t item;
         size_t item;

-        for (item = item_start; item <= item_start+item_count; item++)
+        for (item = item_start; item < item_start+item_count; item++)

         {
             cell_rect.y = item*m_lineHeight;
             wxVariant value;
             model->GetValue( value, col->GetModelColumn(), item );
             cell->SetValue( value );
         {
             cell_rect.y = item*m_lineHeight;
             wxVariant value;
             model->GetValue( value, col->GetModelColumn(), item );
             cell->SetValue( value );

-            cell->Render( cell_rect, &dc, 0 );
+            wxSize size = cell->GetSize();
+            // cannot be bigger than allocated space
+            size.x = wxMin( size.x, cell_rect.width );
+            size.y = wxMin( size.y, cell_rect.height );
+            // TODO: check for left/right/centre alignment here
+            wxRect item_rect;
+            // for now: centre
+            item_rect.x = cell_rect.x + (cell_rect.width / 2) - (size.x / 2);
+            item_rect.y = cell_rect.y + (cell_rect.height / 2) - (size.y / 2);
+
+            item_rect.width = size.x;
+            item_rect.height= size.y;
+            cell->Render( item_rect, &dc, 0 );

         }
         }

-        
+

         cell_rect.x += cell_rect.width;
     }
 }
 
 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 {
         cell_rect.x += cell_rect.width;
     }
 }
 
 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 {

+    int x = event.GetX();
+    int y = event.GetY();
+    m_owner->CalcUnscrolledPosition( x, y, &x, &y );
+
+    wxDataViewColumn *col = NULL;
+
+    int xpos = 0;
+    size_t cols = GetOwner()->GetNumberOfColumns();
+    size_t i;
+    for (i = 0; i < cols; i++)
+    {
+        wxDataViewColumn *c = GetOwner()->GetColumn( i );
+        if (x < xpos + c->GetWidth())
+        {
+            col = c;
+            break;
+        }
+        xpos += c->GetWidth();
+    }
+    if (!col)
+        return;
+    wxDataViewCell *cell = col->GetCell();
+
+    size_t row = y / m_lineHeight;
+
+    wxDataViewListModel *model = GetOwner()->GetModel();
+
+    if (event.ButtonDClick())
+    {
+        m_renameTimer->Stop();
+        m_lastOnSame = false;
+    }
+
+    if (event.LeftDClick())
+    {
+        if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
+        {
+            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 );
+        }
+
+        return;
+    } else
+    if (event.LeftUp())
+    {
+        if (m_lastOnSame)
+        {
+            if ((col == m_currentCol) & (row == m_currentRow) &&
+                (cell->GetMode() == wxDATAVIEW_CELL_EDITABLE) )
+            {
+                m_renameTimer->Start( 100, true );
+            }
+        }
+
+        m_lastOnSame = false;
+    } else
+    if (event.LeftDown())
+    {
+        wxDataViewColumn *oldCurrentCol = m_currentCol;
+        size_t oldCurrentRow = m_currentRow;
+        
+        // Update selection here...
+        m_currentCol = col;
+        m_currentRow = row;
+    
+        m_lastOnSame = (col == oldCurrentCol) && (row == oldCurrentRow);
+        
+        return;
+    }
+

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


@@ -729,23 +1097,23 @@ void wxDataViewCtrl::Init()
 }
 
 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
 }
 
 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,

-           const wxPoint& pos, const wxSize& size, 
+           const wxPoint& pos, const wxSize& size,

            long style, const wxValidator& validator )
 {
     if (!wxControl::Create( parent, id, pos, size, style | wxScrolledWindowStyle|wxSUNKEN_BORDER, validator))
         return false;
 
     Init();
            long style, const wxValidator& validator )
 {
     if (!wxControl::Create( parent, id, pos, size, style | wxScrolledWindowStyle|wxSUNKEN_BORDER, validator))
         return false;
 
     Init();

-    
+

 #ifdef __WXMAC__
     MacSetClipChildren( true ) ;
 #endif
 
 #ifdef __WXMAC__
     MacSetClipChildren( true ) ;
 #endif
 

-    m_clientArea = new wxDataViewMainWindow( this, -1 );
-    m_headerArea = new wxDataViewHeaderWindow( this, -1, wxDefaultPosition, wxSize(-1,25) );
-    
+    m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
+    m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,25) );
+

     SetTargetWindow( m_clientArea );
     SetTargetWindow( m_clientArea );

-    
+

     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
     sizer->Add( m_headerArea, 0, wxGROW );
     sizer->Add( m_clientArea, 1, wxGROW );
     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
     sizer->Add( m_headerArea, 0, wxGROW );
     sizer->Add( m_clientArea, 1, wxGROW );


@@ -759,7 +1127,7 @@ WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
                                        WXWPARAM wParam,
                                        WXLPARAM lParam)
 {
                                        WXWPARAM wParam,
                                        WXLPARAM lParam)
 {

-    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
+    WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam);

 
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
 
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling


@@ -773,7 +1141,7 @@ WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
 }
 #endif
 
 }
 #endif
 

-void wxDataViewCtrl::OnSize( wxSizeEvent &event )
+void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )

 {
     // We need to override OnSize so that our scrolled
     // window a) does call Layout() to use sizers for
 {
     // We need to override OnSize so that our scrolled
     // window a) does call Layout() to use sizers for


@@ -794,10 +1162,10 @@ bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
 
     m_notifier = new wxGenericDataViewListModelNotifier( m_clientArea );
 
 
     m_notifier = new wxGenericDataViewListModelNotifier( m_clientArea );
 

-    model->AddNotifier( m_notifier );    
+    model->AddNotifier( m_notifier );

 
     m_clientArea->UpdateDisplay();
 
     m_clientArea->UpdateDisplay();

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -805,15 +1173,15 @@ bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
 {
     if (!wxDataViewCtrlBase::AppendColumn(col))
         return false;
 {
     if (!wxDataViewCtrlBase::AppendColumn(col))
         return false;

-    
+

     m_clientArea->UpdateDisplay();
     m_clientArea->UpdateDisplay();

-    
+

     return true;
 }
 
     return true;
 }
 

-#endif 
+#endif

     // !wxUSE_GENERICDATAVIEWCTRL
 
     // !wxUSE_GENERICDATAVIEWCTRL
 

-#endif 
+#endif

     // wxUSE_DATAVIEWCTRL
 
     // wxUSE_DATAVIEWCTRL