Rework the GTK WebKit backend history to remove the need for the map between wxWebHis...

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

diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp
index 02555daa57a1c07c7c21871b9841af495bcb6ccd..bdc389ad666390c374662c5c18d328f1bc55b2cc 100644 (file)
--- a/src/generic/datavgen.cpp
+++ b/src/generic/datavgen.cpp
@@ -48,6 +48,7 @@
 #include "wx/imaglist.h"
 #include "wx/headerctrl.h"
 #include "wx/dnd.h"
 #include "wx/imaglist.h"
 #include "wx/headerctrl.h"
 #include "wx/dnd.h"

+#include "wx/stopwatch.h"

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


@@ -144,7 +145,6 @@ protected:
         return *(GetOwner()->GetColumn(idx));
     }
 
         return *(GetOwner()->GetColumn(idx));
     }
 

-    // FIXME: currently unused

     virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
     {
         wxDataViewCtrl * const owner = GetOwner();
     virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
     {
         wxDataViewCtrl * const owner = GetOwner();


@@ -214,6 +214,8 @@ private:
             model->Resort();
 
         owner->OnColumnChange(idx);
             model->Resort();
 
         owner->OnColumnChange(idx);

+
+        SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, idx);

     }
 
     void OnRClick(wxHeaderCtrlEvent& event)
     }
 
     void OnRClick(wxHeaderCtrlEvent& event)


@@ -434,7 +436,7 @@ public:
     bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
     bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
     bool ItemChanged( const wxDataViewItem &item );
     bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
     bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
     bool ItemChanged( const wxDataViewItem &item );

-    bool ValueChanged( const wxDataViewItem &item, unsigned int col );
+    bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );

     bool Cleared();
     void Resort()
     {
     bool Cleared();
     void Resort()
     {


@@ -532,6 +534,8 @@ public:
     int GetLineHeight( unsigned int row ) const; // m_lineHeight in fixed mode
     int GetLineAt( unsigned int y ) const;       // y / m_lineHeight in fixed mode
 
     int GetLineHeight( unsigned int row ) const; // m_lineHeight in fixed mode
     int GetLineAt( unsigned int y ) const;       // y / m_lineHeight in fixed mode
 

+    void SetRowHeight( int lineHeight ) { m_lineHeight = lineHeight; }
+

     // Some useful functions for row and item mapping
     wxDataViewItem GetItemByRow( unsigned int row ) const;
     int GetRowByItem( const wxDataViewItem & item ) const;
     // Some useful functions for row and item mapping
     wxDataViewItem GetItemByRow( unsigned int row ) const;
     int GetRowByItem( const wxDataViewItem & item ) const;


@@ -732,7 +736,7 @@ bool wxDataViewTextRenderer::HasEditorCtrl() const
     return true;
 }
 
     return true;
 }
 

-wxControl* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent,
+wxWindow* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent,

         wxRect labelRect, const wxVariant &value )
 {
     wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, value,
         wxRect labelRect, const wxVariant &value )
 {
     wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, value,


@@ -746,7 +750,7 @@ wxControl* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent,
     return ctrl;
 }
 
     return ctrl;
 }
 

-bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxControl *editor, wxVariant &value )
+bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant &value )

 {
     wxTextCtrl *text = (wxTextCtrl*) editor;
     value = text->GetValue();
 {
     wxTextCtrl *text = (wxTextCtrl*) editor;
     value = text->GetValue();


@@ -796,9 +800,9 @@ bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
 
 bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {
 
 bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 {

-    if (m_bitmap.Ok())
+    if (m_bitmap.IsOk())

         dc->DrawBitmap( m_bitmap, cell.x, cell.y );
         dc->DrawBitmap( m_bitmap, cell.x, cell.y );

-    else if (m_icon.Ok())
+    else if (m_icon.IsOk())

         dc->DrawIcon( m_icon, cell.x, cell.y );
 
     return true;
         dc->DrawIcon( m_icon, cell.x, cell.y );
 
     return true;


@@ -806,9 +810,9 @@ bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state
 
 wxSize wxDataViewBitmapRenderer::GetSize() const
 {
 
 wxSize wxDataViewBitmapRenderer::GetSize() const
 {

-    if (m_bitmap.Ok())
+    if (m_bitmap.IsOk())

         return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
         return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );

-    else if (m_icon.Ok())
+    else if (m_icon.IsOk())

         return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
 
     return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE);
         return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
 
     return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE);


@@ -844,7 +848,8 @@ bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state
     int flags = 0;
     if (m_toggle)
         flags |= wxCONTROL_CHECKED;
     int flags = 0;
     if (m_toggle)
         flags |= wxCONTROL_CHECKED;

-    if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE)
+    if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE ||
+        GetEnabled() == false)

         flags |= wxCONTROL_DISABLED;
 
     // check boxes we draw must always have the same, standard size (if it's
         flags |= wxCONTROL_DISABLED;
 
     // check boxes we draw must always have the same, standard size (if it's


@@ -862,12 +867,23 @@ bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state
     return true;
 }
 
     return true;
 }
 

-void wxDataViewToggleRenderer::WXOnActivate(wxDataViewModel *model,
-                                            const wxVariant& valueOld,
-                                            const wxDataViewItem & item,
-                                            unsigned int col)
+bool wxDataViewToggleRenderer::WXOnLeftClick(const wxPoint& cursor,
+                                             const wxRect& WXUNUSED(cell),
+                                             wxDataViewModel *model,
+                                             const wxDataViewItem& item,
+                                             unsigned int col)

 {
 {

-    model->ChangeValue(!valueOld.GetBool(), item, col);
+    // only react to clicks directly on the checkbox, not elsewhere in the same cell:
+    if (!wxRect(GetSize()).Contains(cursor))
+        return false;
+
+    if (model->IsEnabled(item, col))
+    {
+        model->ChangeValue(!m_toggle, item, col);
+        return true;
+    }
+
+    return false;

 }
 
 wxSize wxDataViewToggleRenderer::GetSize() const
 }
 
 wxSize wxDataViewToggleRenderer::GetSize() const


@@ -1019,12 +1035,12 @@ wxSize wxDataViewDateRenderer::GetSize() const
     return GetTextExtent(m_date.FormatDate());
 }
 
     return GetTextExtent(m_date.FormatDate());
 }
 

-void wxDataViewDateRenderer::WXOnActivate(wxDataViewModel *model,
-                                          const wxVariant& valueOld,
-                                          const wxDataViewItem & item,
-                                          unsigned int col )
+bool wxDataViewDateRenderer::WXOnActivate(const wxRect& WXUNUSED(cell),
+                                          wxDataViewModel *model,
+                                          const wxDataViewItem& item,
+                                          unsigned int col)

 {
 {

-    wxDateTime dtOld = valueOld.GetDateTime();
+    wxDateTime dtOld = m_date;

 
 #if wxUSE_DATE_RENDERER_POPUP
     wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
 
 #if wxUSE_DATE_RENDERER_POPUP
     wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(


@@ -1036,6 +1052,8 @@ void wxDataViewDateRenderer::WXOnActivate(wxDataViewModel *model,
 #else // !wxUSE_DATE_RENDERER_POPUP
     wxMessageBox(dtOld.Format());
 #endif // wxUSE_DATE_RENDERER_POPUP/!wxUSE_DATE_RENDERER_POPUP
 #else // !wxUSE_DATE_RENDERER_POPUP
     wxMessageBox(dtOld.Format());
 #endif // wxUSE_DATE_RENDERER_POPUP/!wxUSE_DATE_RENDERER_POPUP

+
+    return true;

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


@@ -1092,7 +1110,7 @@ wxSize wxDataViewIconTextRenderer::GetSize() const
     return wxSize(80,20);
 }
 
     return wxSize(80,20);
 }
 

-wxControl* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value)
+wxWindow* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value)

 {
     wxDataViewIconText iconText;
     iconText << value;
 {
     wxDataViewIconText iconText;
     iconText << value;


@@ -1118,7 +1136,7 @@ wxControl* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect
     return ctrl;
 }
 
     return ctrl;
 }
 

-bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxControl *editor, wxVariant& value )
+bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant& value )

 {
     wxTextCtrl *text = (wxTextCtrl*) editor;
 
 {
     wxTextCtrl *text = (wxTextCtrl*) editor;
 


@@ -1272,7 +1290,7 @@ void wxDataViewRenameTimer::Notify()
 //-----------------------------------------------------------------------------
 
 // The tree building helper, declared firstly
 //-----------------------------------------------------------------------------
 
 // The tree building helper, declared firstly

-static void BuildTreeHelper( wxDataViewModel * model,  wxDataViewItem & item,
+static void BuildTreeHelper( const wxDataViewModel * model,  const wxDataViewItem & item,

                              wxDataViewTreeNode * node);
 
 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
                              wxDataViewTreeNode * node);
 
 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )


@@ -1583,6 +1601,12 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
     dc.DrawRectangle(GetClientSize());
 #endif
 
     dc.DrawRectangle(GetClientSize());
 #endif
 

+    if ( IsEmpty() )
+    {
+        // No items to draw.
+        return;
+    }
+

     // prepare the DC
     GetOwner()->PrepareDC( dc );
     dc.SetFont( GetFont() );
     // prepare the DC
     GetOwner()->PrepareDC( dc );
     dc.SetFont( GetFont() );


@@ -1596,10 +1620,11 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
         wxMin( (int)(  GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1),
             (int)(GetRowCount( ) - item_start));
     unsigned int item_last = item_start + item_count;
         wxMin( (int)(  GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1),
             (int)(GetRowCount( ) - item_start));
     unsigned int item_last = item_start + item_count;

-    // Get the parent of DataViewCtrl
-    wxWindow *parent = GetParent()->GetParent();
+
+    // Send the event to wxDataViewCtrl itself.
+    wxWindow * const parent = GetParent();

     wxDataViewEvent cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT, parent->GetId());
     wxDataViewEvent cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT, parent->GetId());

-    cache_event.SetEventObject(GetParent());
+    cache_event.SetEventObject(parent);

     cache_event.SetCache(item_start, item_last - 1);
     parent->ProcessWindowEvent(cache_event);
 
     cache_event.SetCache(item_start, item_last - 1);
     parent->ProcessWindowEvent(cache_event);
 


@@ -1660,22 +1685,23 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
         dc.SetPen(m_penRule);
         dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
         dc.SetPen(m_penRule);
         dc.SetBrush(*wxTRANSPARENT_BRUSH);
 

-        int x = x_start;
+        // NB: Vertical rules are drawn in the last pixel of a column so that
+        //     they align perfectly with native MSW wxHeaderCtrl as well as for
+        //     consistency with MSW native list control. There's no vertical
+        //     rule at the most-left side of the control.
+
+        int x = x_start - 1;

         for (unsigned int i = col_start; i < col_last; i++)
         {
             wxDataViewColumn *col = GetOwner()->GetColumnAt(i);
             if (col->IsHidden())
                 continue;       // skip it
 
         for (unsigned int i = col_start; i < col_last; i++)
         {
             wxDataViewColumn *col = GetOwner()->GetColumnAt(i);
             if (col->IsHidden())
                 continue;       // skip it
 

+            x += col->GetWidth();
+

             dc.DrawLine(x, GetLineStart( item_start ),
                         x, GetLineStart( item_last ) );
             dc.DrawLine(x, GetLineStart( item_start ),
                         x, GetLineStart( item_last ) );

-
-            x += col->GetWidth();

         }
         }

-
-        // Draw last vertical rule
-        dc.DrawLine(x, GetLineStart( item_start ),
-                    x, GetLineStart( item_last ) );

     }
 
     // redraw the background for the items which are selected/current
     }
 
     // redraw the background for the items which are selected/current


@@ -1747,8 +1773,11 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 
                 dataitem = node->GetItem();
 
 
                 dataitem = node->GetItem();
 

-                if ((i > 0) && model->IsContainer(dataitem) &&
-                    !model->HasContainerColumns(dataitem))
+                // Skip all columns of "container" rows except the expander
+                // column itself unless HasContainerColumns() overrides this.
+                if ( col != GetOwner()->GetExpanderColumn() &&
+                        model->IsContainer(dataitem) &&
+                            !model->HasContainerColumns(dataitem) )

                     continue;
             }
             else
                     continue;
             }
             else


@@ -1892,8 +1921,8 @@ bool Walker( wxDataViewTreeNode * node, DoJob & func )
             ;
     }
 
             ;
     }
 

-    wxDataViewTreeNodes nodes = node->GetNodes();
-    wxDataViewTreeLeaves leaves = node->GetChildren();
+    const wxDataViewTreeNodes& nodes = node->GetNodes();
+    const wxDataViewTreeLeaves& leaves = node->GetChildren();

 
     int len_nodes = nodes.GetCount();
     int len = leaves.GetCount();
 
     int len_nodes = nodes.GetCount();
     int len = leaves.GetCount();


@@ -2068,9 +2097,23 @@ bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item)
     return true;
 }
 
     return true;
 }
 

-bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int col )
+bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int model_column )

 {
 {

-    GetOwner()->InvalidateColBestWidth(col);
+    int view_column = -1;
+    unsigned int n_col = m_owner->GetColumnCount();
+    for (unsigned i = 0; i < n_col; i++)
+    {
+        wxDataViewColumn *column = m_owner->GetColumn( i );
+        if (column->GetModelColumn() == model_column)
+        {
+            view_column = (int) i;
+            break;
+        }
+    }
+    if (view_column == -1)
+        return false;
+
+    GetOwner()->InvalidateColBestWidth(view_column);

 
     // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
 /*#define MAX_VIRTUAL_WIDTH       100000
 
     // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
 /*#define MAX_VIRTUAL_WIDTH       100000


@@ -2090,8 +2133,8 @@ bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned i
     le.SetEventObject(parent);
     le.SetModel(GetOwner()->GetModel());
     le.SetItem(item);
     le.SetEventObject(parent);
     le.SetModel(GetOwner()->GetModel());
     le.SetItem(item);

-    le.SetColumn(col);
-    le.SetDataViewColumn(GetOwner()->GetColumn(col));
+    le.SetColumn(view_column);
+    le.SetDataViewColumn(GetOwner()->GetColumn(view_column));

     parent->GetEventHandler()->ProcessEvent(le);
 
     return true;
     parent->GetEventHandler()->ProcessEvent(le);
 
     return true;


@@ -2149,6 +2192,8 @@ void wxDataViewMainWindow::RecalculateDisplay()
 
 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
 {
 
 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
 {

+    m_underMouse = NULL;
+

     wxWindow::ScrollWindow( dx, dy, rect );
 
     if (GetOwner()->m_headerArea)
     wxWindow::ScrollWindow( dx, dy, rect );
 
     if (GetOwner()->m_headerArea)


@@ -2157,6 +2202,8 @@ void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
 
 void wxDataViewMainWindow::ScrollTo( int rows, int column )
 {
 
 void wxDataViewMainWindow::ScrollTo( int rows, int column )
 {

+    m_underMouse = NULL;
+

     int x, y;
     m_owner->GetScrollPixelsPerUnit( &x, &y );
     int sy = GetLineStart( rows )/y;
     int x, y;
     m_owner->GetScrollPixelsPerUnit( &x, &y );
     int sy = GetLineStart( rows )/y;


@@ -2968,28 +3015,26 @@ void wxDataViewMainWindow::Collapse(unsigned int row)
 
 wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item )
 {
 
 wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item )
 {

-    wxDataViewModel * model = GetOwner()->GetModel();
+    const wxDataViewModel * model = GetOwner()->GetModel();

     if( model == NULL )
         return NULL;
 
     if (!item.IsOk())
         return m_root;
 
     if( model == NULL )
         return NULL;
 
     if (!item.IsOk())
         return m_root;
 

-    // Compose the a parent-chain of the finding item
-    ItemList list;
-    list.DeleteContents( true );
+    // Compose the parent-chain for the item we are looking for
+    wxVector<wxDataViewItem> parentChain;

     wxDataViewItem it( item );
     while( it.IsOk() )
     {
     wxDataViewItem it( item );
     while( it.IsOk() )
     {

-        wxDataViewItem * pItem = new wxDataViewItem( it );
-        list.Insert( pItem );
-        it = model->GetParent( it );
+        parentChain.push_back(it);
+        it = model->GetParent(it);

     }
 
     // Find the item along the parent-chain.
     // This algorithm is designed to speed up the node-finding method
     }
 
     // Find the item along the parent-chain.
     // This algorithm is designed to speed up the node-finding method

-    wxDataViewTreeNode * node = m_root;
-    for( ItemList::const_iterator iter = list.begin(); iter !=list.end(); iter++ )
+    wxDataViewTreeNode* node = m_root;
+    for( unsigned iter = parentChain.size()-1; ; --iter )

     {
         if( node->HasChildren() )
         {
     {
         if( node->HasChildren() )
         {


@@ -2999,18 +3044,18 @@ wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item
                 ::BuildTreeHelper(model, node->GetItem(), node);
             }
 
                 ::BuildTreeHelper(model, node->GetItem(), node);
             }
 

-            wxDataViewTreeNodes nodes = node->GetNodes();
-            unsigned int i;
+            const wxDataViewTreeNodes& nodes = node->GetNodes();

             bool found = false;
 
             bool found = false;
 

-            for (i = 0; i < nodes.GetCount(); i ++)
+            for (unsigned i = 0; i < nodes.GetCount(); ++i)

             {
             {

-                if (nodes[i]->GetItem() == (**iter))
+                wxDataViewTreeNode* currentNode = nodes[i];
+                if (currentNode->GetItem() == parentChain[iter])

                 {
                 {

-                    if (nodes[i]->GetItem() == item)
-                    return nodes[i];
+                    if (currentNode->GetItem() == item)
+                        return currentNode;

 
 

-                    node = nodes[i];
+                    node = currentNode;

                     found = true;
                     break;
                 }
                     found = true;
                     break;
                 }


@@ -3020,6 +3065,9 @@ wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item
         }
         else
             return NULL;
         }
         else
             return NULL;

+
+        if ( !iter )
+            break;

     }
     return NULL;
 }
     }
     return NULL;
 }


@@ -3130,7 +3178,7 @@ int wxDataViewMainWindow::RecalculateCount()
 class ItemToRowJob : public DoJob
 {
 public:
 class ItemToRowJob : public DoJob
 {
 public:

-    ItemToRowJob(const wxDataViewItem& item_, ItemList::const_iterator iter)
+    ItemToRowJob(const wxDataViewItem& item_, wxVector<wxDataViewItem>::reverse_iterator iter)

         : m_iter(iter),
         item(item_)
     {
         : m_iter(iter),
         item(item_)
     {


@@ -3146,7 +3194,7 @@ public:
             return DoJob::OK;
         }
 
             return DoJob::OK;
         }
 

-        if( node->GetItem() == **m_iter )
+        if( node->GetItem() == *m_iter )

         {
             m_iter++;
             return DoJob::CONT;
         {
             m_iter++;
             return DoJob::CONT;


@@ -3172,7 +3220,7 @@ public:
         { return ret -1; }
 
 private:
         { return ret -1; }
 
 private:

-    ItemList::const_iterator  m_iter;
+    wxVector<wxDataViewItem>::reverse_iterator m_iter;

     wxDataViewItem item;
     int ret;
 
     wxDataViewItem item;
     int ret;
 


@@ -3193,27 +3241,27 @@ int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const
         if( !item.IsOk() )
             return -1;
 
         if( !item.IsOk() )
             return -1;
 

-        // Compose the a parent-chain of the finding item
-        ItemList list;
-        wxDataViewItem * pItem;
-        list.DeleteContents( true );
+        // Compose the parent-chain of the item we are looking for
+        wxVector<wxDataViewItem> parentChain;

         wxDataViewItem it( item );
         while( it.IsOk() )
         {
         wxDataViewItem it( item );
         while( it.IsOk() )
         {

-            pItem = new wxDataViewItem( it );
-            list.Insert( pItem );
-            it = model->GetParent( it );
+            parentChain.push_back(it);
+            it = model->GetParent(it);

         }
         }

-        pItem = new wxDataViewItem( );
-        list.Insert( pItem );

 
 

-        ItemToRowJob job( item, list.begin() );
-        Walker(m_root , job );
+        // add an 'invalid' item to represent our 'invisible' root node
+        parentChain.push_back(wxDataViewItem());
+
+        // the parent chain was created by adding the deepest parent first.
+        // so if we want to start at the root node, we have to iterate backwards through the vector
+        ItemToRowJob job( item, parentChain.rbegin() );
+        Walker( m_root, job );

         return job.GetResult();
     }
 }
 
         return job.GetResult();
     }
 }
 

-static void BuildTreeHelper( wxDataViewModel * model,  wxDataViewItem & item,
+static void BuildTreeHelper( const wxDataViewModel * model,  const wxDataViewItem & item,

                              wxDataViewTreeNode * node)
 {
     if( !model->IsContainer( item ) )
                              wxDataViewTreeNode * node)
 {
     if( !model->IsContainer( item ) )


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

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

                 OnArrowChar( m_currentRow + 1, event );
             break;
         // Add the process for tree expanding/collapsing
                 OnArrowChar( m_currentRow + 1, event );
             break;
         // Add the process for tree expanding/collapsing


@@ -3470,13 +3518,17 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         xpos += c->GetWidth();
     }
     if (!col)
         xpos += c->GetWidth();
     }
     if (!col)

+    {
+        event.Skip();

         return;
         return;

+    }

 
     wxDataViewRenderer *cell = col->GetRenderer();
     unsigned int current = GetLineAt( y );
     if ((current >= GetRowCount()) || (x > GetEndOfLastCol()))
     {
         // Unselect all if below the last row ?
 
     wxDataViewRenderer *cell = col->GetRenderer();
     unsigned int current = GetLineAt( y );
     if ((current >= GetRowCount()) || (x > GetEndOfLastCol()))
     {
         // Unselect all if below the last row ?

+        event.Skip();

         return;
     }
 
         return;
     }
 


@@ -3605,25 +3657,19 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
             {
                 const unsigned colIdx = col->GetModelColumn();
 
             {
                 const unsigned colIdx = col->GetModelColumn();
 

-                wxVariant value;
-                model->GetValue( value, item, colIdx );
+                cell->PrepareForItem(model, item, colIdx);

 
 

-                cell->WXOnActivate(model, value, item, colIdx);
-
-                if ( wxDataViewCustomRenderer *custom = cell->WXGetAsCustom() )
-                {
-                    cell->SetValue( value );
-
-                    wxRect cell_rect( xpos, GetLineStart( current ),
-                                    col->GetWidth(), GetLineHeight( current ) );
-                    custom->Activate( cell_rect, model, item, colIdx );
-                }
+                wxRect cell_rect( xpos, GetLineStart( current ),
+                                col->GetWidth(), GetLineHeight( current ) );
+                cell->WXOnActivate( cell_rect, model, item, colIdx );

             }
             else
             {
                 wxWindow *parent = GetParent();
                 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
                 le.SetItem( item );
             }
             else
             {
                 wxWindow *parent = GetParent();
                 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
                 le.SetItem( item );

+                le.SetColumn( col->GetModelColumn() );
+                le.SetDataViewColumn( col );

                 le.SetEventObject(parent);
                 le.SetModel(GetOwner()->GetModel());
 
                 le.SetEventObject(parent);
                 le.SetModel(GetOwner()->GetModel());
 


@@ -3682,8 +3728,10 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         if (!IsRowSelected(current))
         {
             SelectAllRows(false);
         if (!IsRowSelected(current))
         {
             SelectAllRows(false);

+            const unsigned oldCurrent = m_currentRow;

             ChangeCurrentRow(current);
             SelectRow(m_currentRow,true);
             ChangeCurrentRow(current);
             SelectRow(m_currentRow,true);

+            RefreshRow(oldCurrent);

             SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
         }
     }
             SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
         }
     }


@@ -3694,6 +3742,8 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         wxWindow *parent = GetParent();
         wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId());
         le.SetItem( item );
         wxWindow *parent = GetParent();
         wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId());
         le.SetItem( item );

+        le.SetColumn( col->GetModelColumn() );
+        le.SetDataViewColumn( col );

         le.SetEventObject(parent);
         le.SetModel(GetOwner()->GetModel());
         le.SetValue(value);
         le.SetEventObject(parent);
         le.SetModel(GetOwner()->GetModel());
         le.SetValue(value);


@@ -3784,53 +3834,50 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
         // Call LeftClick after everything else as under GTK+
         if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE)
         {
         // Call LeftClick after everything else as under GTK+
         if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE)
         {

-            if ( wxDataViewCustomRenderer *custom = cell->WXGetAsCustom() )
-            {
-                // notify cell about click
-                custom->PrepareForItem(model, item, col->GetModelColumn());
+            // notify cell about click
+            cell->PrepareForItem(model, item, col->GetModelColumn());

 
 

-                wxRect cell_rect( xpos, GetLineStart( current ),
-                                  col->GetWidth(), GetLineHeight( current ) );
+            wxRect cell_rect( xpos, GetLineStart( current ),
+                              col->GetWidth(), GetLineHeight( current ) );

 
 

-                // Report position relative to the cell's custom area, i.e.
-                // no the entire space as given by the control but the one
-                // used by the renderer after calculation of alignment etc.
+            // Report position relative to the cell's custom area, i.e.
+            // no the entire space as given by the control but the one
+            // used by the renderer after calculation of alignment etc.

 
 

-                // adjust the rectangle ourselves to account for the alignment
-                wxRect rectItem = cell_rect;
-                const int align = custom->GetAlignment();
-                if ( align != wxDVR_DEFAULT_ALIGNMENT )
-                {
-                    const wxSize size = custom->GetSize();
+            // adjust the rectangle ourselves to account for the alignment
+            wxRect rectItem = cell_rect;
+            const int align = cell->GetAlignment();
+            if ( align != wxDVR_DEFAULT_ALIGNMENT )
+            {
+                const wxSize size = cell->GetSize();

 
 

-                    if ( size.x >= 0 && size.x < cell_rect.width )
-                    {
-                        if ( align & wxALIGN_CENTER_HORIZONTAL )
-                            rectItem.x += (cell_rect.width - size.x)/2;
-                        else if ( align & wxALIGN_RIGHT )
-                            rectItem.x += cell_rect.width - size.x;
-                        // else: wxALIGN_LEFT is the default
-                    }
+                if ( size.x >= 0 && size.x < cell_rect.width )
+                {
+                    if ( align & wxALIGN_CENTER_HORIZONTAL )
+                        rectItem.x += (cell_rect.width - size.x)/2;
+                    else if ( align & wxALIGN_RIGHT )
+                        rectItem.x += cell_rect.width - size.x;
+                    // else: wxALIGN_LEFT is the default
+                }

 
 

-                    if ( size.y >= 0 && size.y < cell_rect.height )
-                    {
-                        if ( align & wxALIGN_CENTER_VERTICAL )
-                            rectItem.y += (cell_rect.height - size.y)/2;
-                        else if ( align & wxALIGN_BOTTOM )
-                            rectItem.y += cell_rect.height - size.y;
-                        // else: wxALIGN_TOP is the default
-                    }
+                if ( size.y >= 0 && size.y < cell_rect.height )
+                {
+                    if ( align & wxALIGN_CENTER_VERTICAL )
+                        rectItem.y += (cell_rect.height - size.y)/2;
+                    else if ( align & wxALIGN_BOTTOM )
+                        rectItem.y += cell_rect.height - size.y;
+                    // else: wxALIGN_TOP is the default

                 }
                 }

+            }

 
 

-                wxPoint pos( event.GetPosition() );
-                pos.x -= rectItem.x;
-                pos.y -= rectItem.y;
+            wxPoint pos( event.GetPosition() );
+            pos.x -= rectItem.x;
+            pos.y -= rectItem.y;

 
 

-                m_owner->CalcUnscrolledPosition( pos.x, pos.y, &pos.x, &pos.y );
+            m_owner->CalcUnscrolledPosition( pos.x, pos.y, &pos.x, &pos.y );

 
 

-                 /* ignore ret */ custom->LeftClick( pos, cell_rect,
-                                  model, item, col->GetModelColumn());
-            }
+             /* ignore ret */ cell->WXOnLeftClick( pos, cell_rect,
+                              model, item, col->GetModelColumn());

         }
     }
 }
         }
     }
 }


@@ -3985,6 +4032,16 @@ void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
     Layout();
 
     AdjustScrollbars();
     Layout();
 
     AdjustScrollbars();

+
+    // We must redraw the headers if their height changed. Normally this
+    // shouldn't happen as the control shouldn't let itself be resized beneath
+    // its minimal height but avoid the display artefacts that appear if it
+    // does happen, e.g. because there is really not enough vertical space.
+    if ( !HasFlag(wxDV_NO_HEADER) && m_headerArea &&
+            m_headerArea->GetSize().y <= m_headerArea->GetBestSize(). y )
+    {
+        m_headerArea->Refresh();
+    }

 }
 
 void wxDataViewCtrl::SetFocus()
 }
 
 void wxDataViewCtrl::SetFocus()


@@ -4089,6 +4146,16 @@ unsigned int wxDataViewCtrl::GetColumnCount() const
     return m_cols.GetCount();
 }
 
     return m_cols.GetCount();
 }
 

+bool wxDataViewCtrl::SetRowHeight( int lineHeight )
+{
+    if ( !m_clientArea )
+        return false;
+
+    m_clientArea->SetRowHeight(lineHeight);
+
+    return true;
+}
+

 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int idx ) const
 {
     return m_cols[idx];
 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int idx ) const
 {
     return m_cols[idx];


@@ -4121,30 +4188,129 @@ unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const
     if ( m_colsBestWidths[idx] != 0 )
         return m_colsBestWidths[idx];
 
     if ( m_colsBestWidths[idx] != 0 )
         return m_colsBestWidths[idx];
 

-    const unsigned count = m_clientArea->GetRowCount();
+    const int count = m_clientArea->GetRowCount();

     wxDataViewColumn *column = GetColumn(idx);
     wxDataViewRenderer *renderer =
         const_cast<wxDataViewRenderer*>(column->GetRenderer());
 
     wxDataViewColumn *column = GetColumn(idx);
     wxDataViewRenderer *renderer =
         const_cast<wxDataViewRenderer*>(column->GetRenderer());
 

-    int max_width = 0;
+    class MaxWidthCalculator
+    {
+    public:
+        MaxWidthCalculator(wxDataViewMainWindow *clientArea,
+                           wxDataViewRenderer *renderer,
+                           const wxDataViewModel *model,
+                           unsigned column)
+            : m_width(0),
+              m_clientArea(clientArea),
+              m_renderer(renderer),
+              m_model(model),
+              m_column(column)
+        {
+        }
+
+        void UpdateWithWidth(int width)
+        {
+            m_width = wxMax(m_width, width);
+        }
+
+        void UpdateWithRow(int row)
+        {
+            wxDataViewItem item = m_clientArea->GetItemByRow(row);
+            m_renderer->PrepareForItem(m_model, item, m_column);
+            m_width = wxMax(m_width, m_renderer->GetSize().x);
+        }
+
+        int GetMaxWidth() const { return m_width; }
+
+    private:
+        int m_width;
+        wxDataViewMainWindow *m_clientArea;
+        wxDataViewRenderer *m_renderer;
+        const wxDataViewModel *m_model;
+        unsigned m_column;
+    };
+
+    MaxWidthCalculator calculator(m_clientArea, renderer,
+                                  GetModel(), column->GetModelColumn());

 
     if ( m_headerArea )
     {
 
     if ( m_headerArea )
     {

-        max_width = m_headerArea->GetTextExtent(column->GetTitle()).x;
-
+        int header_width = m_headerArea->GetTextExtent(column->GetTitle()).x;

         // Labels on native MSW header are indented on both sides
         // Labels on native MSW header are indented on both sides

-        max_width += wxRendererNative::Get().GetHeaderButtonMargin(m_headerArea);
+        header_width +=
+            wxRendererNative::Get().GetHeaderButtonMargin(m_headerArea);
+        calculator.UpdateWithWidth(header_width);
+    }
+
+    // The code below deserves some explanation. For very large controls, we
+    // simply can't afford to calculate sizes for all items, it takes too
+    // long. So the best we can do is to check the first and the last N/2
+    // items in the control for some sufficiently large N and calculate best
+    // sizes from that. That can result in the calculated best width being too
+    // small for some outliers, but it's better to get slightly imperfect
+    // result than to wait several seconds after every update. To avoid highly
+    // visible miscalculations, we also include all currently visible items
+    // no matter what.  Finally, the value of N is determined dynamically by
+    // measuring how much time we spent on the determining item widths so far.
+
+#if wxUSE_STOPWATCH
+    int top_part_end = count;
+    static const long CALC_TIMEOUT = 20/*ms*/;
+    // don't call wxStopWatch::Time() too often
+    static const unsigned CALC_CHECK_FREQ = 100;
+    wxStopWatch timer;
+#else
+    // use some hard-coded limit, that's the best we can do without timer
+    int top_part_end = wxMin(500, count);
+#endif // wxUSE_STOPWATCH/!wxUSE_STOPWATCH
+
+    int row = 0;
+
+    for ( row = 0; row < top_part_end; row++ )
+    {
+#if wxUSE_STOPWATCH
+        if ( row % CALC_CHECK_FREQ == CALC_CHECK_FREQ-1 &&
+             timer.Time() > CALC_TIMEOUT )
+            break;
+#endif // wxUSE_STOPWATCH
+        calculator.UpdateWithRow(row);

     }
 
     }
 

-    for ( unsigned row = 0; row < count; row++ )
+    // row is the first unmeasured item now; that's our value of N/2
+
+    if ( row < count )

     {
     {

-        wxDataViewItem item = m_clientArea->GetItemByRow(row);
+        top_part_end = row;

 
 

-        renderer->PrepareForItem(GetModel(), item, column->GetModelColumn());
+        // add bottom N/2 items now:
+        const int bottom_part_start = wxMax(row, count - row);
+        for ( row = bottom_part_start; row < count; row++ )
+        {
+            calculator.UpdateWithRow(row);
+        }
+
+        // finally, include currently visible items in the calculation:
+        const wxPoint origin = CalcUnscrolledPosition(wxPoint(0, 0));
+        int first_visible = m_clientArea->GetLineAt(origin.y);
+        int last_visible = m_clientArea->GetLineAt(origin.y + GetClientSize().y);
+
+        first_visible = wxMax(first_visible, top_part_end);
+        last_visible = wxMin(bottom_part_start, last_visible);
+
+        for ( row = first_visible; row < last_visible; row++ )
+        {
+            calculator.UpdateWithRow(row);
+        }

 
 

-        max_width = (unsigned)wxMax((int)max_width, renderer->GetSize().x);
+        wxLogTrace("dataview",
+                   "determined best size from %d top, %d bottom plus %d more visible items out of %d total",
+                   top_part_end,
+                   count - bottom_part_start,
+                   wxMax(0, last_visible - first_visible),
+                   count);

     }
 
     }
 

+    int max_width = calculator.GetMaxWidth();

     if ( max_width > 0 )
         max_width += 2 * PADDING_RIGHTLEFT;
 
     if ( max_width > 0 )
         max_width += 2 * PADDING_RIGHTLEFT;
 


@@ -4197,8 +4363,9 @@ void wxDataViewCtrl::InvalidateColBestWidths()
 
     if ( m_headerArea )
     {
 
     if ( m_headerArea )
     {

-        // this updates visual appearance of columns 0 and up, not just 0
-        m_headerArea->UpdateColumn(0);
+        const unsigned cols = m_headerArea->GetColumnCount();
+        for ( unsigned i = 0; i < cols; i++ )
+            m_headerArea->UpdateColumn(i);

     }
 }
 
     }
 }
 


@@ -4504,7 +4671,8 @@ void wxDataViewCtrl::StartEditor( const wxDataViewItem & item, unsigned int colu
 
     wxRect itemRect = GetItemRect(item, col);
     wxDataViewRenderer* renderer = col->GetRenderer();
 
     wxRect itemRect = GetItemRect(item, col);
     wxDataViewRenderer* renderer = col->GetRenderer();

-    renderer->StartEditing(item, itemRect);
+    if (renderer->GetMode() == wxDATAVIEW_CELL_EDITABLE)
+        renderer->StartEditing(item, itemRect);

 }
 
 #endif // !wxUSE_GENERICDATAVIEWCTRL
 }
 
 #endif // !wxUSE_GENERICDATAVIEWCTRL