X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/fce2dc61c3fca054138702cad59077d8f7221360..4b263e5ef358411a345dee9ffef3ba69c19be40e:/src/generic/datavgen.cpp diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp index cf63855f78..d36e86116b 100644 --- a/src/generic/datavgen.cpp +++ b/src/generic/datavgen.cpp @@ -3,7 +3,6 @@ // Purpose: wxDataViewCtrl generic implementation // Author: Robert Roebling // Modified by: Francesco Montorsi, Guru Kathiresan, Bo Yang -// Id: $Id$ // Copyright: (c) 1998 Robert Roebling // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -38,7 +37,6 @@ #endif #include "wx/stockitem.h" -#include "wx/calctrl.h" #include "wx/popupwin.h" #include "wx/renderer.h" #include "wx/dcbuffer.h" @@ -49,6 +47,7 @@ #include "wx/headerctrl.h" #include "wx/dnd.h" #include "wx/stopwatch.h" +#include "wx/weakref.h" //----------------------------------------------------------------------------- // classes @@ -80,9 +79,48 @@ static const int EXPANDER_OFFSET = 1; // For the generic implementation, both the leaf nodes and the nodes are sorted for // fast search when needed static wxDataViewModel* g_model; -static int g_column = -2; + +// The column is either the index of the column to be used for sorting or one +// of the special values in this enum: +enum +{ + // Sort when we're thawed later. + SortColumn_OnThaw = -3, + + // Don't sort at all. + SortColumn_None = -2, + + // Sort using the model default sort order. + SortColumn_Default = -1 +}; + +static int g_column = SortColumn_None; static bool g_asending = true; +// ---------------------------------------------------------------------------- +// helper functions +// ---------------------------------------------------------------------------- + +namespace +{ + +// Return the expander column or, if it is not set, the first column and also +// set it as the expander one for the future. +wxDataViewColumn* GetExpanderColumnOrFirstOne(wxDataViewCtrl* dataview) +{ + wxDataViewColumn* expander = dataview->GetExpanderColumn(); + if (!expander) + { + // TODO-RTL: last column for RTL support + expander = dataview->GetColumnAt( 0 ); + dataview->SetExpanderColumn(expander); + } + + return expander; +} + +} // anonymous namespace + //----------------------------------------------------------------------------- // wxDataViewColumn //----------------------------------------------------------------------------- @@ -122,6 +160,40 @@ void wxDataViewColumn::UpdateDisplay() } } +void wxDataViewColumn::UnsetAsSortKey() +{ + m_sort = false; + + if ( m_owner ) + m_owner->SetSortingColumnIndex(wxNOT_FOUND); + + UpdateDisplay(); +} + +void wxDataViewColumn::SetSortOrder(bool ascending) +{ + if ( !m_owner ) + return; + + // First unset the old sort column if any. + int oldSortKey = m_owner->GetSortingColumnIndex(); + if ( oldSortKey != wxNOT_FOUND ) + { + m_owner->GetColumn(oldSortKey)->UnsetAsSortKey(); + } + + // Now set this one as the new sort column. + const int idx = m_owner->GetColumnIndex(this); + m_owner->SetSortingColumnIndex(idx); + + m_sort = true; + m_sortAscending = ascending; + + // Call this directly instead of using UpdateDisplay() as we already have + // the column index, no need to look it up again. + m_owner->OnColumnChange(idx); +} + //----------------------------------------------------------------------------- // wxDataViewHeaderWindow //----------------------------------------------------------------------------- @@ -169,14 +241,14 @@ private: // for events created by wxDataViewHeaderWindow the // row / value fields are not valid - return owner->GetEventHandler()->ProcessEvent(event); + return owner->ProcessWindowEvent(event); } void OnClick(wxHeaderCtrlEvent& event) { const unsigned idx = event.GetColumn(); - if ( SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, idx) ) + if ( SendEvent(wxEVT_DATAVIEW_COLUMN_HEADER_CLICK, idx) ) return; // default handling for the column click is to sort by this column or @@ -197,16 +269,7 @@ private: } else // not using this column for sorting yet { - // first unset the old sort column if any - int oldSortKey = owner->GetSortingColumnIndex(); - if ( oldSortKey != wxNOT_FOUND ) - { - owner->GetColumn(oldSortKey)->UnsetAsSortKey(); - owner->OnColumnChange(oldSortKey); - } - - owner->SetSortingColumnIndex(idx); - col->SetAsSortKey(); + col->SetSortOrder(true); } wxDataViewModel * const model = owner->GetModel(); @@ -214,11 +277,13 @@ private: model->Resort(); owner->OnColumnChange(idx); + + SendEvent(wxEVT_DATAVIEW_COLUMN_SORTED, idx); } void OnRClick(wxHeaderCtrlEvent& event) { - if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, + if ( !SendEvent(wxEVT_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, event.GetColumn()) ) event.Skip(); } @@ -273,57 +338,89 @@ public: class wxDataViewTreeNode; WX_DEFINE_ARRAY( wxDataViewTreeNode *, wxDataViewTreeNodes ); -WX_DEFINE_ARRAY( void* , wxDataViewTreeLeaves); int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, wxDataViewTreeNode ** node2); -int LINKAGEMODE wxGenericTreeModelItemCmp( void ** id1, void ** id2); class wxDataViewTreeNode { public: - wxDataViewTreeNode( wxDataViewTreeNode * parent = NULL ) + wxDataViewTreeNode(wxDataViewTreeNode *parent, const wxDataViewItem& item) + : m_parent(parent), + m_item(item), + m_branchData(NULL) { - m_parent = parent; - if (!parent) - m_open = true; - else - m_open = false; - m_hasChildren = false; - m_subTreeCount = 0; } ~wxDataViewTreeNode() { + if ( m_branchData ) + { + wxDataViewTreeNodes& nodes = m_branchData->children; + for ( wxDataViewTreeNodes::iterator i = nodes.begin(); + i != nodes.end(); + ++i ) + { + delete *i; + } + + delete m_branchData; + } + } + + static wxDataViewTreeNode* CreateRootNode() + { + wxDataViewTreeNode *n = new wxDataViewTreeNode(NULL, wxDataViewItem()); + n->m_branchData = new BranchNodeData; + n->m_branchData->open = true; + return n; } wxDataViewTreeNode * GetParent() const { return m_parent; } - void SetParent( wxDataViewTreeNode * parent ) { m_parent = parent; } - wxDataViewTreeNodes & GetNodes() { return m_nodes; } - wxDataViewTreeLeaves & GetChildren() { return m_leaves; } - void AddNode( wxDataViewTreeNode * node ) + const wxDataViewTreeNodes& GetChildNodes() const { - m_leaves.Add( node->GetItem().GetID() ); - if (g_column >= -1) - m_leaves.Sort( &wxGenericTreeModelItemCmp ); - m_nodes.Add( node ); - if (g_column >= -1) - m_nodes.Sort( &wxGenericTreeModelNodeCmp ); + wxASSERT( m_branchData != NULL ); + return m_branchData->children; } - void AddLeaf( void * leaf ) + + void InsertChild(wxDataViewTreeNode *node, unsigned index) { - m_leaves.Add( leaf ); + if ( !m_branchData ) + m_branchData = new BranchNodeData; + + m_branchData->children.Insert(node, index); + + // TODO: insert into sorted array directly in O(log n) instead of resorting in O(n log n) if (g_column >= -1) - m_leaves.Sort( &wxGenericTreeModelItemCmp ); + m_branchData->children.Sort( &wxGenericTreeModelNodeCmp ); + } + + void RemoveChild(wxDataViewTreeNode *node) + { + wxCHECK_RET( m_branchData != NULL, "leaf node doesn't have children" ); + m_branchData->children.Remove(node); + } + + // returns position of child node for given item in children list or wxNOT_FOUND + int FindChildByItem(const wxDataViewItem& item) const + { + if ( !m_branchData ) + return wxNOT_FOUND; + + const wxDataViewTreeNodes& nodes = m_branchData->children; + const int len = nodes.size(); + for ( int i = 0; i < len; i++ ) + { + if ( nodes[i]->m_item == item ) + return i; + } + return wxNOT_FOUND; } - wxDataViewItem & GetItem() { return m_item; } const wxDataViewItem & GetItem() const { return m_item; } void SetItem( const wxDataViewItem & item ) { m_item = item; } - unsigned int GetChildrenNumber() const { return m_leaves.GetCount(); } - unsigned int GetNodeNumber() const { return m_nodes.GetCount(); } int GetIndentLevel() const { int ret = 0; @@ -338,84 +435,146 @@ public: bool IsOpen() const { - return m_open; + return m_branchData && m_branchData->open; } void ToggleOpen() { - int len = m_nodes.GetCount(); + // We do not allow the (invisible) root node to be collapsed because + // there is no way to expand it again. + if ( !m_parent ) + return; + + wxCHECK_RET( m_branchData != NULL, "can't open leaf node" ); + int sum = 0; + + const wxDataViewTreeNodes& nodes = m_branchData->children; + const int len = nodes.GetCount(); for ( int i = 0;i < len; i ++) - sum += m_nodes[i]->GetSubTreeCount(); + sum += 1 + nodes[i]->GetSubTreeCount(); - sum += m_leaves.GetCount(); - if (m_open) + if (m_branchData->open) { ChangeSubTreeCount(-sum); - m_open = !m_open; + m_branchData->open = !m_branchData->open; } else { - m_open = !m_open; - ChangeSubTreeCount(sum); + m_branchData->open = !m_branchData->open; + ChangeSubTreeCount(+sum); + } + } + + // "HasChildren" property corresponds to model's IsContainer(). Note that it may be true + // even if GetChildNodes() is empty; see below. + bool HasChildren() const + { + return m_branchData != NULL; + } + + void SetHasChildren(bool has) + { + // The invisible root item always has children, so ignore any attempts + // to change this. + if ( !m_parent ) + return; + + if ( !has ) + { + wxDELETE(m_branchData); } + else if ( m_branchData == NULL ) + { + m_branchData = new BranchNodeData; + } + } + + int GetSubTreeCount() const + { + return m_branchData ? m_branchData->subTreeCount : 0; } - bool HasChildren() const { return m_hasChildren; } - void SetHasChildren( bool has ){ m_hasChildren = has; } - void SetSubTreeCount( int num ) { m_subTreeCount = num; } - int GetSubTreeCount() const { return m_subTreeCount; } void ChangeSubTreeCount( int num ) { - if( !m_open ) + wxASSERT( m_branchData != NULL ); + + if( !m_branchData->open ) return; - m_subTreeCount += num; + + m_branchData->subTreeCount += num; + wxASSERT( m_branchData->subTreeCount >= 0 ); + if( m_parent ) m_parent->ChangeSubTreeCount(num); } void Resort() { + if ( !m_branchData ) + return; + if (g_column >= -1) { - m_nodes.Sort( &wxGenericTreeModelNodeCmp ); - int len = m_nodes.GetCount(); + wxDataViewTreeNodes& nodes = m_branchData->children; + + nodes.Sort( &wxGenericTreeModelNodeCmp ); + int len = nodes.GetCount(); for (int i = 0; i < len; i ++) - m_nodes[i]->Resort(); - m_leaves.Sort( &wxGenericTreeModelItemCmp ); + { + if ( nodes[i]->HasChildren() ) + nodes[i]->Resort(); + } } } + private: wxDataViewTreeNode *m_parent; - wxDataViewTreeNodes m_nodes; - wxDataViewTreeLeaves m_leaves; + + // Corresponding model item. wxDataViewItem m_item; - bool m_open; - bool m_hasChildren; - int m_subTreeCount; + + // Data specific to non-leaf (branch, inner) nodes. They are kept in a + // separate struct in order to conserve memory. + struct BranchNodeData + { + BranchNodeData() + : open(false), + subTreeCount(0) + { + } + + // Child nodes. Note that this may be empty even if m_hasChildren in + // case this branch of the tree wasn't expanded and realized yet. + wxDataViewTreeNodes children; + + // Is the branch node currently open (expanded)? + bool open; + + // Total count of expanded (i.e. visible with the help of some + // scrolling) items in the subtree, but excluding this node. I.e. it is + // 0 for leaves and is the number of rows the subtree occupies for + // branch nodes. + int subTreeCount; + }; + + BranchNodeData *m_branchData; }; + int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, wxDataViewTreeNode ** node2) { return g_model->Compare( (*node1)->GetItem(), (*node2)->GetItem(), g_column, g_asending ); } -int LINKAGEMODE wxGenericTreeModelItemCmp( void ** id1, void ** id2) -{ - return g_model->Compare( *id1, *id2, g_column, g_asending ); -} - //----------------------------------------------------------------------------- // wxDataViewMainWindow //----------------------------------------------------------------------------- -WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection, - WXDLLIMPEXP_ADV); -WX_DECLARE_LIST(wxDataViewItem, ItemList); -WX_DEFINE_LIST(ItemList) +WX_DEFINE_SORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection); class wxDataViewMainWindow: public wxWindow { @@ -427,7 +586,7 @@ public: const wxString &name = wxT("wxdataviewctrlmainwindow") ); virtual ~wxDataViewMainWindow(); - bool IsList() const { return GetOwner()->GetModel()->IsListModel(); } + bool IsList() const { return GetModel()->IsListModel(); } bool IsVirtualList() const { return m_root == NULL; } // notifications from wxDataViewModel @@ -446,20 +605,50 @@ public: UpdateDisplay(); } + // Override the base class method to resort if needed, i.e. if + // SortPrepare() was called -- and ignored -- while we were frozen. + virtual void DoThaw() + { + if ( g_column == SortColumn_OnThaw ) + { + Resort(); + g_column = SortColumn_None; + } + + wxWindow::DoThaw(); + } + void SortPrepare() { - g_model = GetOwner()->GetModel(); + g_model = GetModel(); + wxDataViewColumn* col = GetOwner()->GetSortingColumn(); if( !col ) { if (g_model->HasDefaultCompare()) - g_column = -1; + { + // See below for the explanation of IsFrozen() test. + if ( IsFrozen() ) + g_column = SortColumn_OnThaw; + else + g_column = SortColumn_Default; + } else - g_column = -2; + g_column = SortColumn_None; g_asending = true; return; } + + // Avoid sorting while the window is frozen, this allows to quickly add + // many items without resorting after each addition and only resort + // them all at once when the window is finally thawed, see above. + if ( IsFrozen() ) + { + g_column = SortColumn_OnThaw; + return; + } + g_column = col->GetModelColumn(); g_asending = col->IsSortOrderAscending(); } @@ -468,12 +657,18 @@ public: wxDataViewCtrl *GetOwner() { return m_owner; } const wxDataViewCtrl *GetOwner() const { return m_owner; } + wxDataViewModel* GetModel() { return GetOwner()->GetModel(); } + const wxDataViewModel* GetModel() const { return GetOwner()->GetModel(); } + #if wxUSE_DRAG_AND_DROP wxBitmap CreateItemBitmap( unsigned int row, int &indent ); #endif // wxUSE_DRAG_AND_DROP void OnPaint( wxPaintEvent &event ); - void OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event); + void OnCharHook( wxKeyEvent &event ); void OnChar( wxKeyEvent &event ); + void OnVerticalNavigation(int delta, const wxKeyEvent& event); + void OnLeftKey(); + void OnRightKey(); void OnMouse( wxMouseEvent &event ); void OnSetFocus( wxFocusEvent &event ); void OnKillFocus( wxFocusEvent &event ); @@ -490,6 +685,10 @@ public: unsigned GetCurrentRow() const { return m_currentRow; } bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; } void ChangeCurrentRow( unsigned int row ); + bool TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward); + + wxDataViewColumn *GetCurrentColumn() const { return m_currentCol; } + void ClearCurrentColumn() { m_currentCol = NULL; } bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); } bool IsEmpty() { return GetRowCount() == 0; } @@ -502,10 +701,9 @@ public: // the displaying number of the tree are changing along with the // expanding/collapsing of the tree nodes unsigned int GetLastVisibleRow(); - unsigned int GetRowCount(); + unsigned int GetRowCount() const; - wxDataViewItem GetSelection() const; - wxDataViewSelection GetSelections(){ return m_selection; } + const wxDataViewSelection& GetSelections() const { return m_selection; } void SetSelections( const wxDataViewSelection & sel ) { m_selection = sel; UpdateDisplay(); } void Select( const wxArrayInt& aSelections ); @@ -532,10 +730,18 @@ public: 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; } + int GetRowHeight() const { return m_lineHeight; } + int GetDefaultRowHeight() const; + // Some useful functions for row and item mapping wxDataViewItem GetItemByRow( unsigned int row ) const; int GetRowByItem( const wxDataViewItem & item ) const; + wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ) const; + // We did not need this temporarily + // wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item ); + // Methods for building the mapping tree void BuildTree( wxDataViewModel * model ); void DestroyTree(); @@ -558,17 +764,26 @@ public: void OnLeave(); #endif // wxUSE_DRAG_AND_DROP -private: - wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ) const; - // We did not need this temporarily - // wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item ); + void OnColumnsCountChanged(); + + // Called by wxDataViewCtrl and our own OnRenameTimer() to start edit the + // specified item in the given column. + void StartEditing(const wxDataViewItem& item, const wxDataViewColumn* col); - int RecalculateCount(); +private: + int RecalculateCount() const; - wxDataViewEvent SendExpanderEvent( wxEventType type, const wxDataViewItem & item ); + // Return false only if the event was vetoed by its handler. + bool SendExpanderEvent(wxEventType type, const wxDataViewItem& item); wxDataViewTreeNode * FindNode( const wxDataViewItem & item ); + wxDataViewColumn *FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode); + + bool IsCellEditableInMode(const wxDataViewItem& item, const wxDataViewColumn *col, wxDataViewCellMode mode) const; + + void DrawCellBackground( wxDataViewRenderer* cell, wxDC& dc, const wxRect& rect ); + private: wxDataViewCtrl *m_owner; int m_lineHeight; @@ -582,6 +797,8 @@ private: bool m_lastOnSame; bool m_hasFocus; + bool m_useCellFocus; + bool m_currentColSetByKeyboard; #if wxUSE_DRAG_AND_DROP int m_dragCount; @@ -614,6 +831,12 @@ private: // This is the tree node under the cursor wxDataViewTreeNode * m_underMouse; + // The control used for editing or NULL. + wxWeakRef m_editorCtrl; + + // Id m_editorCtrl is non-NULL, pointer to the associated renderer. + wxDataViewRenderer* m_editorRenderer; + private: DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow) DECLARE_EVENT_TABLE() @@ -732,12 +955,13 @@ bool wxDataViewTextRenderer::HasEditorCtrl() const 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, wxPoint(labelRect.x,labelRect.y), - wxSize(labelRect.width,labelRect.height) ); + wxSize(labelRect.width,labelRect.height), + wxTE_PROCESS_ENTER ); // select the text in the control an place the cursor at the end ctrl->SetInsertionPointEnd(); @@ -746,7 +970,7 @@ wxControl* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent, return ctrl; } -bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxControl *editor, wxVariant &value ) +bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant &value ) { wxTextCtrl *text = (wxTextCtrl*) editor; value = text->GetValue(); @@ -796,9 +1020,9 @@ bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) ) const 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()) + if (m_bitmap.IsOk()) + dc->DrawBitmap( m_bitmap, cell.x, cell.y, true /* use mask */ ); + else if (m_icon.IsOk()) dc->DrawIcon( m_icon, cell.x, cell.y ); return true; @@ -806,9 +1030,9 @@ bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state wxSize wxDataViewBitmapRenderer::GetSize() const { - if (m_bitmap.Ok()) + if (m_bitmap.IsOk()) 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); @@ -848,11 +1072,13 @@ bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state GetEnabled() == false) flags |= wxCONTROL_DISABLED; - // check boxes we draw must always have the same, standard size (if it's - // bigger than the cell size the checkbox will be truncated because the - // caller had set the clipping rectangle to prevent us from drawing outside - // the cell) - cell.SetSize(GetSize()); + // Ensure that the check boxes always have at least the minimal required + // size, otherwise DrawCheckBox() doesn't really work well. If this size is + // greater than the cell size, the checkbox will be truncated but this is a + // lesser evil. + wxSize size = cell.GetSize(); + size.IncTo(GetSize()); + cell.SetSize(size); wxRendererNative::Get().DrawCheckBox( GetOwner()->GetOwner(), @@ -863,23 +1089,22 @@ bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state return true; } -bool wxDataViewToggleRenderer::WXOnLeftClick(const wxPoint& cursor, - const wxRect& WXUNUSED(cell), - wxDataViewModel *model, - const wxDataViewItem& item, - unsigned int col) +bool wxDataViewToggleRenderer::WXActivateCell(const wxRect& WXUNUSED(cellRect), + wxDataViewModel *model, + const wxDataViewItem& item, + unsigned int col, + const wxMouseEvent *mouseEvent) { - // 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)) + if ( mouseEvent ) { - model->ChangeValue(!m_toggle, item, col); - return true; + // Only react to clicks directly on the checkbox, not elsewhere in the + // same cell. + if ( !wxRect(GetSize()).Contains(mouseEvent->GetPosition()) ) + return false; } - return false; + model->ChangeValue(!m_toggle, item, col); + return true; } wxSize wxDataViewToggleRenderer::GetSize() const @@ -945,113 +1170,6 @@ wxSize wxDataViewProgressRenderer::GetSize() const return wxSize(40,12); } -// --------------------------------------------------------- -// wxDataViewDateRenderer -// --------------------------------------------------------- - -#define wxUSE_DATE_RENDERER_POPUP (wxUSE_CALENDARCTRL && wxUSE_POPUPWIN) - -#if wxUSE_DATE_RENDERER_POPUP - -class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow -{ -public: - wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value, - wxDataViewModel *model, const wxDataViewItem & item, unsigned int col) : - wxPopupTransientWindow( parent, wxBORDER_SIMPLE ), - m_item( item ) - { - m_model = model; - m_col = col; - m_cal = new wxCalendarCtrl( this, wxID_ANY, *value ); - wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL ); - sizer->Add( m_cal, 1, wxGROW ); - SetSizer( sizer ); - sizer->Fit( this ); - } - - void OnCalendar( wxCalendarEvent &event ); - - wxCalendarCtrl *m_cal; - wxDataViewModel *m_model; - unsigned int m_col; - const wxDataViewItem & m_item; - -protected: - virtual void OnDismiss() - { - } - -private: - DECLARE_EVENT_TABLE() -}; - -BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow) - EVT_CALENDAR( wxID_ANY, wxDataViewDateRendererPopupTransient::OnCalendar ) -END_EVENT_TABLE() - -void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event ) -{ - m_model->ChangeValue( event.GetDate(), m_item, m_col ); - DismissAndNotify(); -} - -#endif // wxUSE_DATE_RENDERER_POPUP - -IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewRenderer) - -wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype, - wxDataViewCellMode mode, int align ) : - wxDataViewRenderer( varianttype, mode, align ) -{ -} - -bool wxDataViewDateRenderer::SetValue( const wxVariant &value ) -{ - m_date = value.GetDateTime(); - - return true; -} - -bool wxDataViewDateRenderer::GetValue( wxVariant &value ) const -{ - value = m_date; - return true; -} - -bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int state ) -{ - wxString tmp = m_date.FormatDate(); - RenderText( tmp, 0, cell, dc, state ); - return true; -} - -wxSize wxDataViewDateRenderer::GetSize() const -{ - return GetTextExtent(m_date.FormatDate()); -} - -bool wxDataViewDateRenderer::WXOnActivate(const wxRect& WXUNUSED(cell), - wxDataViewModel *model, - const wxDataViewItem& item, - unsigned int col) -{ - wxDateTime dtOld = m_date; - -#if wxUSE_DATE_RENDERER_POPUP - wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient( - GetOwner()->GetOwner()->GetParent(), &dtOld, model, item, col); - wxPoint pos = wxGetMousePosition(); - popup->Move( pos ); - popup->Layout(); - popup->Popup( popup->m_cal ); -#else // !wxUSE_DATE_RENDERER_POPUP - wxMessageBox(dtOld.Format()); -#endif // wxUSE_DATE_RENDERER_POPUP/!wxUSE_DATE_RENDERER_POPUP - - return true; -} - // --------------------------------------------------------- // wxDataViewIconTextRenderer // --------------------------------------------------------- @@ -1106,7 +1224,7 @@ wxSize wxDataViewIconTextRenderer::GetSize() const 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; @@ -1123,7 +1241,8 @@ wxControl* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, text, wxPoint(labelRect.x,labelRect.y), - wxSize(labelRect.width,labelRect.height) ); + wxSize(labelRect.width,labelRect.height), + wxTE_PROCESS_ENTER ); // select the text in the control an place the cursor at the end ctrl->SetInsertionPointEnd(); @@ -1132,11 +1251,21 @@ wxControl* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect return ctrl; } -bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxControl *editor, wxVariant& value ) +bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant& value ) { wxTextCtrl *text = (wxTextCtrl*) editor; - wxDataViewIconText iconText(text->GetValue(), m_value.GetIcon()); + // The icon can't be edited so get its old value and reuse it. + wxVariant valueOld; + wxDataViewColumn* const col = GetOwner(); + GetView()->GetModel()->GetValue(valueOld, m_item, col->GetModelColumn()); + + wxDataViewIconText iconText; + iconText << valueOld; + + // But replace the text with the value entered by user. + iconText.SetText(text->GetValue()); + value << iconText; return true; } @@ -1303,6 +1432,7 @@ BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow) EVT_MOUSE_EVENTS (wxDataViewMainWindow::OnMouse) EVT_SET_FOCUS (wxDataViewMainWindow::OnSetFocus) EVT_KILL_FOCUS (wxDataViewMainWindow::OnKillFocus) + EVT_CHAR_HOOK (wxDataViewMainWindow::OnCharHook) EVT_CHAR (wxDataViewMainWindow::OnChar) END_EVENT_TABLE() @@ -1314,14 +1444,17 @@ wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID i { SetOwner( parent ); + m_editorRenderer = NULL; + m_lastOnSame = false; m_renameTimer = new wxDataViewRenameTimer( this ); // TODO: user better initial values/nothing selected m_currentCol = NULL; - m_currentRow = 0; - - m_lineHeight = wxMax( 17, GetCharHeight() + 2 ); // 17 = mini icon height + 1 + m_currentColSetByKeyboard = false; + m_useCellFocus = false; + m_currentRow = (unsigned)-1; + m_lineHeight = GetDefaultRowHeight(); #if wxUSE_DRAG_AND_DROP m_dragCount = 0; @@ -1349,8 +1482,7 @@ wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID i // TODO: maybe there is something system colour to use m_penExpander = wxPen(wxColour(0,0,0)); - m_root = new wxDataViewTreeNode( NULL ); - m_root->SetHasChildren(true); + m_root = wxDataViewTreeNode::CreateRootNode(); // Make m_count = -1 will cause the class recaculate the real displaying number of rows. m_count = -1; @@ -1365,6 +1497,20 @@ wxDataViewMainWindow::~wxDataViewMainWindow() } +int wxDataViewMainWindow::GetDefaultRowHeight() const +{ +#ifdef __WXMSW__ + // We would like to use the same line height that Explorer uses. This is + // different from standard ListView control since Vista. + if ( wxGetWinVersion() >= wxWinVersion_Vista ) + return wxMax(16, GetCharHeight()) + 6; // 16 = mini icon height + else +#endif // __WXMSW__ + return wxMax(16, GetCharHeight()) + 1; // 16 = mini icon height +} + + + #if wxUSE_DRAG_AND_DROP bool wxDataViewMainWindow::EnableDragSource( const wxDataFormat &format ) { @@ -1411,13 +1557,14 @@ wxDragResult wxDataViewMainWindow::OnDragOver( wxDataFormat format, wxCoord x, wxDataViewItem item = GetItemByRow( row ); - wxDataViewModel *model = GetOwner()->GetModel(); + wxDataViewModel *model = GetModel(); - wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); + wxDataViewEvent event( wxEVT_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); event.SetEventObject( m_owner ); event.SetItem( item ); event.SetModel( model ); event.SetDataFormat( format ); + event.SetDropEffect( def ); if (!m_owner->HandleWindowEvent( event )) { RemoveDropHint(); @@ -1454,9 +1601,9 @@ bool wxDataViewMainWindow::OnDrop( wxDataFormat format, wxCoord x, wxCoord y ) wxDataViewItem item = GetItemByRow( row ); - wxDataViewModel *model = GetOwner()->GetModel(); + wxDataViewModel *model = GetModel(); - wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); + wxDataViewEvent event( wxEVT_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); event.SetEventObject( m_owner ); event.SetItem( item ); event.SetModel( model ); @@ -1483,17 +1630,18 @@ wxDragResult wxDataViewMainWindow::OnData( wxDataFormat format, wxCoord x, wxCoo wxDataViewItem item = GetItemByRow( row ); - wxDataViewModel *model = GetOwner()->GetModel(); + wxDataViewModel *model = GetModel(); wxCustomDataObject *obj = (wxCustomDataObject *) GetDropTarget()->GetDataObject(); - wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() ); + wxDataViewEvent event( wxEVT_DATAVIEW_ITEM_DROP, m_owner->GetId() ); event.SetEventObject( m_owner ); event.SetItem( item ); event.SetModel( model ); event.SetDataFormat( format ); event.SetDataSize( obj->GetSize() ); event.SetDataBuffer( obj->GetData() ); + event.SetDropEffect( def ); if (!m_owner->HandleWindowEvent( event )) return wxDragNone; @@ -1529,9 +1677,6 @@ wxBitmap wxDataViewMainWindow::CreateItemBitmap( unsigned int row, int &indent ) indent = GetOwner()->GetIndent() * node->GetIndentLevel(); indent = indent + m_lineHeight; // try to use the m_lineHeight as the expander space - - if(!node->HasChildren()) - delete node; } width -= indent; @@ -1544,14 +1689,8 @@ wxBitmap wxDataViewMainWindow::CreateItemBitmap( unsigned int row, int &indent ) wxDataViewModel *model = m_owner->GetModel(); - wxDataViewColumn *expander = GetOwner()->GetExpanderColumn(); - if (!expander) - { - // TODO-RTL: last column for RTL support - expander = GetOwner()->GetColumnAt( 0 ); - GetOwner()->SetExpanderColumn(expander); - } - + wxDataViewColumn * const + expander = GetExpanderColumnOrFirstOne(GetOwner()); int x = 0; for (col = 0; col < cols; col++) @@ -1586,16 +1725,57 @@ wxBitmap wxDataViewMainWindow::CreateItemBitmap( unsigned int row, int &indent ) #endif // wxUSE_DRAG_AND_DROP +// Draw focus rect for individual cell. Unlike native focus rect, we render +// this in foreground text color (typically white) to enhance contrast and +// make it visible. +static void DrawSelectedCellFocusRect(wxDC& dc, const wxRect& rect) +{ + // (This code is based on wxRendererGeneric::DrawFocusRect and modified.) + + // draw the pixels manually because the "dots" in wxPen with wxDOT style + // may be short traits and not really dots + // + // note that to behave in the same manner as DrawRect(), we must exclude + // the bottom and right borders from the rectangle + wxCoord x1 = rect.GetLeft(), + y1 = rect.GetTop(), + x2 = rect.GetRight(), + y2 = rect.GetBottom(); + + wxDCPenChanger pen(dc, wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT)); + + wxCoord z; + for ( z = x1 + 1; z < x2; z += 2 ) + dc.DrawPoint(z, rect.GetTop()); + + wxCoord shift = z == x2 ? 0 : 1; + for ( z = y1 + shift; z < y2; z += 2 ) + dc.DrawPoint(x2, z); + + shift = z == y2 ? 0 : 1; + for ( z = x2 - shift; z > x1; z -= 2 ) + dc.DrawPoint(z, y2); + + shift = z == x1 ? 0 : 1; + for ( z = y2 - shift; z > y1; z -= 2 ) + dc.DrawPoint(x1, z); +} + + void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) { - wxDataViewModel *model = GetOwner()->GetModel(); + wxDataViewModel *model = GetModel(); wxAutoBufferedPaintDC dc( this ); -#ifdef __WXMSW__ dc.SetBrush(GetOwner()->GetBackgroundColour()); dc.SetPen( *wxTRANSPARENT_PEN ); dc.DrawRectangle(GetClientSize()); -#endif + + if ( IsEmpty() ) + { + // No items to draw. + return; + } // prepare the DC GetOwner()->PrepareDC( dc ); @@ -1613,7 +1793,7 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) // Send the event to wxDataViewCtrl itself. wxWindow * const parent = GetParent(); - wxDataViewEvent cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT, parent->GetId()); + wxDataViewEvent cache_event(wxEVT_DATAVIEW_CACHE_HINT, parent->GetId()); cache_event.SetEventObject(parent); cache_event.SetCache(item_start, item_last - 1); parent->ProcessWindowEvent(cache_event); @@ -1656,6 +1836,37 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) x_last += col->GetWidth(); } + // Draw background of alternate rows specially if required + if ( m_owner->HasFlag(wxDV_ROW_LINES) ) + { + wxColour altRowColour = m_owner->m_alternateRowColour; + if ( !altRowColour.IsOk() ) + { + // Determine the alternate rows colour automatically from the + // background colour. + const wxColour bgColour = m_owner->GetBackgroundColour(); + + // Depending on the background, alternate row color + // will be 3% more dark or 50% brighter. + int alpha = bgColour.GetRGB() > 0x808080 ? 97 : 150; + altRowColour = bgColour.ChangeLightness(alpha); + } + + dc.SetPen(*wxTRANSPARENT_PEN); + dc.SetBrush(wxBrush(altRowColour)); + + for (unsigned int item = item_start; item < item_last; item++) + { + if ( item % 2 ) + { + dc.DrawRectangle(x_start, + GetLineStart(item), + GetClientSize().GetWidth(), + GetLineHeight(item)); + } + } + } + // Draw horizontal rules if required if ( m_owner->HasFlag(wxDV_HORIZ_RULES) ) { @@ -1698,44 +1909,113 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) for (unsigned int item = item_start; item < item_last; item++) { bool selected = m_selection.Index( item ) != wxNOT_FOUND; + if (selected || item == m_currentRow) { - int flags = selected ? (int)wxCONTROL_SELECTED : 0; - if (item == m_currentRow) - flags |= wxCONTROL_CURRENT; - if (m_hasFocus) - flags |= wxCONTROL_FOCUSED; - wxRect rect( x_start, GetLineStart( item ), x_last - x_start, GetLineHeight( item ) ); - wxRendererNative::Get().DrawItemSelectionRect - ( - this, - dc, - rect, - flags - ); - } - } -#if wxUSE_DRAG_AND_DROP - if (m_dropHint) - { - wxRect rect( x_start, GetLineStart( m_dropHintLine ), - x_last - x_start, GetLineHeight( m_dropHintLine ) ); - dc.SetPen( *wxBLACK_PEN ); - dc.SetBrush( *wxTRANSPARENT_BRUSH ); - dc.DrawRectangle( rect ); - } -#endif // wxUSE_DRAG_AND_DROP + // draw selection and whole-item focus: + if ( selected ) + { + int flags = wxCONTROL_SELECTED; + if (m_hasFocus) + flags |= wxCONTROL_FOCUSED; + + wxRendererNative::Get().DrawItemSelectionRect + ( + this, + dc, + rect, + flags + ); + } - wxDataViewColumn *expander = GetOwner()->GetExpanderColumn(); - if (!expander) + // draw keyboard focus rect if applicable + if ( item == m_currentRow && m_hasFocus ) + { + bool renderColumnFocus = false; + + if ( m_useCellFocus && m_currentCol && m_currentColSetByKeyboard ) + { + renderColumnFocus = true; + + // If this is container node without columns, render full-row focus: + if ( !IsList() ) + { + wxDataViewTreeNode *node = GetTreeNodeByRow(item); + if ( node->HasChildren() && !model->HasContainerColumns(node->GetItem()) ) + renderColumnFocus = false; + } + } + + if ( renderColumnFocus ) + { + for ( unsigned int i = col_start; i < col_last; i++ ) + { + wxDataViewColumn *col = GetOwner()->GetColumnAt(i); + if ( col->IsHidden() ) + continue; + + rect.width = col->GetWidth(); + + if ( col == m_currentCol ) + { + // make the rect more visible by adding a small + // margin around it: + rect.Deflate(1, 1); + + if ( selected ) + { + // DrawFocusRect() uses XOR and is all but + // invisible against dark-blue background. Use + // the same color used for selected text. + DrawSelectedCellFocusRect(dc, rect); + } + else + { + wxRendererNative::Get().DrawFocusRect + ( + this, + dc, + rect, + 0 + ); + } + break; + } + + rect.x += rect.width; + } + } + else + { + // render focus rectangle for the whole row + wxRendererNative::Get().DrawFocusRect + ( + this, + dc, + rect, + selected ? (int)wxCONTROL_SELECTED : 0 + ); + } + } + } + } + +#if wxUSE_DRAG_AND_DROP + if (m_dropHint) { - // TODO-RTL: last column for RTL support - expander = GetOwner()->GetColumnAt( 0 ); - GetOwner()->SetExpanderColumn(expander); + wxRect rect( x_start, GetLineStart( m_dropHintLine ), + x_last - x_start, GetLineHeight( m_dropHintLine ) ); + dc.SetPen( *wxBLACK_PEN ); + dc.SetBrush( *wxTRANSPARENT_BRUSH ); + dc.DrawRectangle( rect ); } +#endif // wxUSE_DRAG_AND_DROP + + wxDataViewColumn * const + expander = GetExpanderColumnOrFirstOne(GetOwner()); // redraw all cells for all rows which must be repainted and all columns wxRect cell_rect; @@ -1763,8 +2043,11 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) 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 != expander && + model->IsContainer(dataitem) && + !model->HasContainerColumns(dataitem) ) continue; } else @@ -1778,6 +2061,11 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) cell_rect.y = GetLineStart( item ); cell_rect.height = GetLineHeight( item ); + // draw the background + bool selected = m_selection.Index( item ) != wxNOT_FOUND; + if ( !selected ) + DrawCellBackground( cell, dc, cell_rect ); + // deal with the expander int indent = 0; if ((!IsList()) && (col == expander)) @@ -1819,12 +2107,6 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) // force the expander column to left-center align cell->SetAlignment( wxALIGN_CENTER_VERTICAL ); } - if (node && !node->HasChildren()) - { - // Yes, if the node does not have any child, it must be a leaf which - // mean that it is a temporarily created by GetTreeNodeByRow - wxDELETE(node); - } wxRect item_rect = cell_rect; item_rect.Deflate(PADDING_RIGHTLEFT, 0); @@ -1837,7 +2119,7 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) continue; int state = 0; - if (m_hasFocus && (m_selection.Index(item) != wxNOT_FOUND)) + if (m_hasFocus && selected) state |= wxDATAVIEW_CELL_SELECTED; // TODO: it would be much more efficient to create a clipping @@ -1856,6 +2138,28 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) } } + +void wxDataViewMainWindow::DrawCellBackground( wxDataViewRenderer* cell, wxDC& dc, const wxRect& rect ) +{ + wxRect rectBg( rect ); + + // don't overlap the horizontal rules + if ( m_owner->HasFlag(wxDV_HORIZ_RULES) ) + { + rectBg.x++; + rectBg.width--; + } + + // don't overlap the vertical rules + if ( m_owner->HasFlag(wxDV_VERT_RULES) ) + { + rectBg.y++; + rectBg.height--; + } + + cell->RenderBackground(&dc, rectBg); +} + void wxDataViewMainWindow::OnRenameTimer() { // We have to call this here because changes may just have @@ -1869,9 +2173,25 @@ void wxDataViewMainWindow::OnRenameTimer() wxDataViewItem item = GetItemByRow( m_currentRow ); - wxRect labelRect = GetItemRect(item, m_currentCol); + StartEditing( item, m_currentCol ); +} + +void +wxDataViewMainWindow::StartEditing(const wxDataViewItem& item, + const wxDataViewColumn* col) +{ + wxDataViewRenderer* renderer = col->GetRenderer(); + if ( !IsCellEditableInMode(item, col, wxDATAVIEW_CELL_EDITABLE) ) + return; - m_currentCol->GetRenderer()->StartEditing( item, labelRect ); + const wxRect itemRect = GetItemRect(item, col); + if ( renderer->StartEditing(item, itemRect) ) + { + // Save the renderer to be able to finish/cancel editing it later and + // save the control to be able to detect if we're still editing it. + m_editorRenderer = renderer; + m_editorCtrl = renderer->GetEditorCtrl(); + } } //----------------------------------------------------------------------------- @@ -1884,183 +2204,266 @@ public: virtual ~DoJob() { } // The return value control how the tree-walker tranverse the tree - // 0: Job done, stop tranverse and return - // 1: Ignore the current node's subtree and continue - // 2: Job not done, continue - enum { OK = 0 , IGR = 1, CONT = 2 }; + enum + { + DONE, // Job done, stop traversing and return + SKIP_SUBTREE, // Ignore the current node's subtree and continue + CONTINUE // Job not done, continue + }; + virtual int operator() ( wxDataViewTreeNode * node ) = 0; - virtual int operator() ( void * n ) = 0; }; bool Walker( wxDataViewTreeNode * node, DoJob & func ) { - if( node==NULL ) - return false; + wxCHECK_MSG( node, false, "can't walk NULL node" ); switch( func( node ) ) { - case DoJob::OK : + case DoJob::DONE: return true; - case DoJob::IGR: + case DoJob::SKIP_SUBTREE: return false; - case DoJob::CONT: - default: - ; + case DoJob::CONTINUE: + break; } - const wxDataViewTreeNodes& nodes = node->GetNodes(); - const wxDataViewTreeLeaves& leaves = node->GetChildren(); - - int len_nodes = nodes.GetCount(); - int len = leaves.GetCount(); - int i = 0, nodes_i = 0; - - for(; i < len; i ++ ) + if ( node->HasChildren() ) { - void * n = leaves[i]; - if( nodes_i < len_nodes && n == nodes[nodes_i]->GetItem().GetID() ) - { - wxDataViewTreeNode * nd = nodes[nodes_i]; - nodes_i++; + const wxDataViewTreeNodes& nodes = node->GetChildNodes(); - if( Walker( nd , func ) ) + for ( wxDataViewTreeNodes::const_iterator i = nodes.begin(); + i != nodes.end(); + ++i ) + { + if ( Walker(*i, func) ) return true; - } - else - switch( func( n ) ) - { - case DoJob::OK : - return true; - case DoJob::IGR: - continue; - case DoJob::CONT: - default: - ; - } } + return false; } bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item) { - GetOwner()->InvalidateColBestWidths(); - if (IsVirtualList()) { wxDataViewVirtualListModel *list_model = - (wxDataViewVirtualListModel*) GetOwner()->GetModel(); + (wxDataViewVirtualListModel*) GetModel(); m_count = list_model->GetCount(); - UpdateDisplay(); - return true; } + else + { + SortPrepare(); - SortPrepare(); + wxDataViewTreeNode *parentNode = FindNode(parent); - wxDataViewTreeNode * node; - node = FindNode(parent); + if ( !parentNode ) + return false; - if( node == NULL ) - return false; + wxDataViewItemArray modelSiblings; + GetModel()->GetChildren(parent, modelSiblings); + const int modelSiblingsSize = modelSiblings.size(); - node->SetHasChildren( true ); + int posInModel = modelSiblings.Index(item, /*fromEnd=*/true); + wxCHECK_MSG( posInModel != wxNOT_FOUND, false, "adding non-existent item?" ); - if( g_model->IsContainer( item ) ) - { - wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node ); - newnode->SetItem(item); - newnode->SetHasChildren( true ); - node->AddNode( newnode); - } - else - node->AddLeaf( item.GetID() ); + wxDataViewTreeNode *itemNode = new wxDataViewTreeNode(parentNode, item); + itemNode->SetHasChildren(GetModel()->IsContainer(item)); - node->ChangeSubTreeCount(1); + parentNode->SetHasChildren(true); - m_count = -1; + const wxDataViewTreeNodes& nodeSiblings = parentNode->GetChildNodes(); + const int nodeSiblingsSize = nodeSiblings.size(); + + int nodePos = 0; + + if ( posInModel == modelSiblingsSize - 1 ) + { + nodePos = nodeSiblingsSize; + } + else if ( modelSiblingsSize == nodeSiblingsSize + 1 ) + { + // This is the simple case when our node tree already matches the + // model and only this one item is missing. + nodePos = posInModel; + } + else + { + // It's possible that a larger discrepancy between the model and + // our realization exists. This can happen e.g. when adding a bunch + // of items to the model and then calling ItemsAdded() just once + // afterwards. In this case, we must find the right position by + // looking at sibling items. + + // append to the end if we won't find a better position: + nodePos = nodeSiblingsSize; + + for ( int nextItemPos = posInModel + 1; + nextItemPos < modelSiblingsSize; + nextItemPos++ ) + { + int nextNodePos = parentNode->FindChildByItem(modelSiblings[nextItemPos]); + if ( nextNodePos != wxNOT_FOUND ) + { + nodePos = nextNodePos; + break; + } + } + } + + parentNode->ChangeSubTreeCount(+1); + parentNode->InsertChild(itemNode, nodePos); + + m_count = -1; + } + + GetOwner()->InvalidateColBestWidths(); UpdateDisplay(); return true; } -static void DestroyTreeHelper( wxDataViewTreeNode * node); - bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent, const wxDataViewItem& item) { - GetOwner()->InvalidateColBestWidths(); - if (IsVirtualList()) { wxDataViewVirtualListModel *list_model = - (wxDataViewVirtualListModel*) GetOwner()->GetModel(); + (wxDataViewVirtualListModel*) GetModel(); m_count = list_model->GetCount(); - if( m_currentRow > GetRowCount() ) - m_currentRow = m_count - 1; + if ( !m_selection.empty() ) + { + const int row = GetRowByItem(item); - // TODO: why empty the entire selection? - m_selection.Empty(); + int rowIndexInSelection = wxNOT_FOUND; - UpdateDisplay(); + const size_t selCount = m_selection.size(); + for ( size_t i = 0; i < selCount; i++ ) + { + if ( m_selection[i] == (unsigned)row ) + rowIndexInSelection = i; + else if ( m_selection[i] > (unsigned)row ) + m_selection[i]--; + } + + if ( rowIndexInSelection != wxNOT_FOUND ) + m_selection.RemoveAt(rowIndexInSelection); + } - return true; } + else // general case + { + wxDataViewTreeNode *parentNode = FindNode(parent); - wxDataViewTreeNode * node = FindNode(parent); + // Notice that it is possible that the item being deleted is not in the + // tree at all, for example we could be deleting a never shown (because + // collapsed) item in a tree model. So it's not an error if we don't know + // about this item, just return without doing anything then. + if ( !parentNode ) + return true; - // Notice that it is possible that the item being deleted is not in the - // tree at all, for example we could be deleting a never shown (because - // collapsed) item in a tree model. So it's not an error if we don't know - // about this item, just return without doing anything then. - if ( !node || node->GetChildren().Index(item.GetID()) == wxNOT_FOUND ) - return false; + wxCHECK_MSG( parentNode->HasChildren(), false, "parent node doesn't have children?" ); + const wxDataViewTreeNodes& parentsChildren = parentNode->GetChildNodes(); + + // We can't use FindNode() to find 'item', because it was already + // removed from the model by the time ItemDeleted() is called, so we + // have to do it manually. We keep track of its position as well for + // later use. + int itemPosInNode = 0; + wxDataViewTreeNode *itemNode = NULL; + for ( wxDataViewTreeNodes::const_iterator i = parentsChildren.begin(); + i != parentsChildren.end(); + ++i, ++itemPosInNode ) + { + if( (*i)->GetItem() == item ) + { + itemNode = *i; + break; + } + } - int sub = -1; - node->GetChildren().Remove( item.GetID() ); - // Manipolate selection - if( m_selection.GetCount() > 1 ) - { - m_selection.Empty(); - } - bool isContainer = false; - wxDataViewTreeNodes nds = node->GetNodes(); - for (size_t i = 0; i < nds.GetCount(); i ++) - { - if (nds[i]->GetItem() == item) + // If the parent wasn't expanded, it's possible that we didn't have a + // node corresponding to 'item' and so there's nothing left to do. + if ( !itemNode ) { - isContainer = true; - break; + // If this was the last child to be removed, it's possible the parent + // node became a leaf. Let's ask the model about it. + if ( parentNode->GetChildNodes().empty() ) + parentNode->SetHasChildren(GetModel()->IsContainer(parent)); + + return true; } - } - if( isContainer ) - { - wxDataViewTreeNode * n = NULL; - wxDataViewTreeNodes nodes = node->GetNodes(); - int len = nodes.GetCount(); - for( int i = 0; i < len; i ++) + + // Delete the item from wxDataViewTreeNode representation: + const int itemsDeleted = 1 + itemNode->GetSubTreeCount(); + + parentNode->RemoveChild(itemNode); + delete itemNode; + parentNode->ChangeSubTreeCount(-itemsDeleted); + + // Make the row number invalid and get a new valid one when user call GetRowCount + m_count = -1; + + // If this was the last child to be removed, it's possible the parent + // node became a leaf. Let's ask the model about it. + if ( parentNode->GetChildNodes().empty() ) { - if( nodes[i]->GetItem() == item ) + bool isContainer = GetModel()->IsContainer(parent); + parentNode->SetHasChildren(isContainer); + if ( isContainer ) { - n = nodes[i]; - break; + // If it's still a container, make sure we show "+" icon for it + // and not "-" one as there is nothing to collapse any more. + if ( parentNode->IsOpen() ) + parentNode->ToggleOpen(); } } - wxCHECK_MSG( n != NULL, false, "item not found" ); + // Update selection by removing 'item' and its entire children tree from the selection. + if ( !m_selection.empty() ) + { + // we can't call GetRowByItem() on 'item', as it's already deleted, so compute it from + // the parent ('parentNode') and position in its list of children + int itemRow; + if ( itemPosInNode == 0 ) + { + // 1st child, row number is that of the parent parentNode + 1 + itemRow = GetRowByItem(parentNode->GetItem()) + 1; + } + else + { + // row number is that of the sibling above 'item' + its subtree if any + 1 + const wxDataViewTreeNode *siblingNode = parentNode->GetChildNodes()[itemPosInNode - 1]; + + itemRow = GetRowByItem(siblingNode->GetItem()) + + siblingNode->GetSubTreeCount() + + 1; + } + + wxDataViewSelection newsel(wxDataViewSelectionCmp); - node->GetNodes().Remove( n ); - sub -= n->GetSubTreeCount(); - ::DestroyTreeHelper(n); + const size_t numSelections = m_selection.size(); + for ( size_t i = 0; i < numSelections; ++i ) + { + const int s = m_selection[i]; + if ( s < itemRow ) + newsel.push_back(s); + else if ( s >= itemRow + itemsDeleted ) + newsel.push_back(s - itemsDeleted); + // else: deleted item, remove from selection + } + + m_selection = newsel; + } } - // Make the row number invalid and get a new valid one when user call GetRowCount - m_count = -1; - node->ChangeSubTreeCount(sub); // Change the current row to the last row if the current exceed the max row number - if( m_currentRow > GetRowCount() ) - m_currentRow = m_count - 1; + if ( m_currentRow >= GetRowCount() ) + ChangeCurrentRow(m_count - 1); + GetOwner()->InvalidateColBestWidths(); UpdateDisplay(); return true; @@ -2068,40 +2471,28 @@ bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent, bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item) { - GetOwner()->InvalidateColBestWidths(); - SortPrepare(); g_model->Resort(); + GetOwner()->InvalidateColBestWidths(); + // Send event wxWindow *parent = GetParent(); - wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); + wxDataViewEvent le(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); + le.SetModel(GetModel()); le.SetItem(item); - parent->GetEventHandler()->ProcessEvent(le); + parent->ProcessWindowEvent(le); return true; } bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int model_column ) { - 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) + int view_column = m_owner->GetModelColumnIndex(model_column); + if ( view_column == wxNOT_FOUND ) return false; - GetOwner()->InvalidateColBestWidth(view_column); - // NOTE: to be valid, we cannot use e.g. INT_MAX - 1 /*#define MAX_VIRTUAL_WIDTH 100000 @@ -2114,29 +2505,38 @@ bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned i SortPrepare(); g_model->Resort(); + GetOwner()->InvalidateColBestWidth(view_column); + // Send event wxWindow *parent = GetParent(); - wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); + wxDataViewEvent le(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); + le.SetModel(GetModel()); le.SetItem(item); le.SetColumn(view_column); le.SetDataViewColumn(GetOwner()->GetColumn(view_column)); - parent->GetEventHandler()->ProcessEvent(le); + parent->ProcessWindowEvent(le); return true; } bool wxDataViewMainWindow::Cleared() { - GetOwner()->InvalidateColBestWidths(); - DestroyTree(); m_selection.Clear(); + m_currentRow = (unsigned)-1; - SortPrepare(); - BuildTree( GetOwner()->GetModel() ); + if (GetModel()) + { + SortPrepare(); + BuildTree( GetModel() ); + } + else + { + m_count = 0; + } + GetOwner()->InvalidateColBestWidths(); UpdateDisplay(); return true; @@ -2161,7 +2561,7 @@ void wxDataViewMainWindow::OnInternalIdle() void wxDataViewMainWindow::RecalculateDisplay() { - wxDataViewModel *model = GetOwner()->GetModel(); + wxDataViewModel *model = GetModel(); if (!model) { Refresh(); @@ -2194,7 +2594,7 @@ void wxDataViewMainWindow::ScrollTo( int rows, int column ) int x, y; m_owner->GetScrollPixelsPerUnit( &x, &y ); int sy = GetLineStart( rows )/y; - int sx = 0; + int sx = -1; if( column != -1 ) { wxRect rect = GetClientRect(); @@ -2268,12 +2668,14 @@ unsigned int wxDataViewMainWindow::GetLastVisibleRow() return wxMin( GetRowCount()-1, row ); } -unsigned int wxDataViewMainWindow::GetRowCount() +unsigned int wxDataViewMainWindow::GetRowCount() const { if ( m_count == -1 ) { - m_count = RecalculateCount(); - UpdateDisplay(); + wxDataViewMainWindow* const + self = const_cast(this); + self->m_count = RecalculateCount(); + self->UpdateDisplay(); } return m_count; } @@ -2386,13 +2788,13 @@ bool wxDataViewMainWindow::IsRowSelected( unsigned int row ) void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem& item) { wxWindow *parent = GetParent(); - wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, parent->GetId()); + wxDataViewEvent le(wxEVT_DATAVIEW_SELECTION_CHANGED, parent->GetId()); le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); + le.SetModel(GetModel()); le.SetItem( item ); - parent->GetEventHandler()->ProcessEvent(le); + parent->ProcessWindowEvent(le); } void wxDataViewMainWindow::RefreshRow( unsigned int row ) @@ -2438,58 +2840,6 @@ void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow ) Refresh( true, &rect ); } -void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event) -{ - wxCHECK_RET( newCurrent < GetRowCount(), - wxT("invalid item index in OnArrowChar()") ); - - // if there is no selection, we cannot move it anywhere - if (!HasCurrentRow()) - return; - - unsigned int oldCurrent = m_currentRow; - - // in single selection we just ignore Shift as we can't select several - // items anyhow - if ( event.ShiftDown() && !IsSingleSel() ) - { - RefreshRow( oldCurrent ); - - ChangeCurrentRow( newCurrent ); - - // select all the items between the old and the new one - if ( oldCurrent > newCurrent ) - { - newCurrent = oldCurrent; - oldCurrent = m_currentRow; - } - - SelectRows( oldCurrent, newCurrent, true ); - if (oldCurrent!=newCurrent) - SendSelectionChangedEvent(GetItemByRow(m_selection[0])); - } - else // !shift - { - RefreshRow( oldCurrent ); - - // all previously selected items are unselected unless ctrl is held - if ( !event.ControlDown() ) - SelectAllRows(false); - - ChangeCurrentRow( newCurrent ); - - if ( !event.ControlDown() ) - { - SelectRow( m_currentRow, true ); - SendSelectionChangedEvent(GetItemByRow(m_currentRow)); - } - else - RefreshRow( m_currentRow ); - } - - GetOwner()->EnsureVisible( m_currentRow, -1 ); -} - wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const { wxRect rect; @@ -2503,7 +2853,7 @@ wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const int wxDataViewMainWindow::GetLineStart( unsigned int row ) const { - const wxDataViewModel *model = GetOwner()->GetModel(); + const wxDataViewModel *model = GetModel(); if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) { @@ -2519,13 +2869,6 @@ int wxDataViewMainWindow::GetLineStart( unsigned int row ) const wxDataViewItem item = node->GetItem(); - if (node && !node->HasChildren()) - { - // Yes, if the node does not have any child, it must be a leaf which - // mean that it is a temporarily created by GetTreeNodeByRow - wxDELETE(node); - } - unsigned int cols = GetOwner()->GetColumnCount(); unsigned int col; int height = m_lineHeight; @@ -2560,7 +2903,7 @@ int wxDataViewMainWindow::GetLineStart( unsigned int row ) const int wxDataViewMainWindow::GetLineAt( unsigned int y ) const { - const wxDataViewModel *model = GetOwner()->GetModel(); + const wxDataViewModel *model = GetModel(); // check for the easy case first if ( !GetOwner()->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) ) @@ -2580,13 +2923,6 @@ int wxDataViewMainWindow::GetLineAt( unsigned int y ) const wxDataViewItem item = node->GetItem(); - if (node && !node->HasChildren()) - { - // Yes, if the node does not have any child, it must be a leaf which - // mean that it is a temporarily created by GetTreeNodeByRow - wxDELETE(node); - } - unsigned int cols = GetOwner()->GetColumnCount(); unsigned int col; int height = m_lineHeight; @@ -2618,7 +2954,7 @@ int wxDataViewMainWindow::GetLineAt( unsigned int y ) const int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const { - const wxDataViewModel *model = GetOwner()->GetModel(); + const wxDataViewModel *model = GetModel(); if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) { @@ -2630,13 +2966,6 @@ int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const wxDataViewItem item = node->GetItem(); - if (node && !node->HasChildren()) - { - // Yes, if the node does not have any child, it must be a leaf which - // mean that it is a temporarily created by GetTreeNodeByRow - wxDELETE(node); - } - int height = m_lineHeight; unsigned int cols = GetOwner()->GetColumnCount(); @@ -2667,169 +2996,103 @@ int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const } } -class RowToItemJob: public DoJob + +class RowToTreeNodeJob: public DoJob { public: - RowToItemJob( unsigned int row , int current ) - { this->row = row; this->current = current; } - virtual ~RowToItemJob() {} + RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node ) + { + this->row = row; + this->current = current; + ret = NULL; + parent = node; + } virtual int operator() ( wxDataViewTreeNode * node ) { current ++; if( current == static_cast(row)) { - ret = node->GetItem(); - return DoJob::OK; + ret = node; + return DoJob::DONE; } if( node->GetSubTreeCount() + current < static_cast(row) ) { current += node->GetSubTreeCount(); - return DoJob::IGR; + return DoJob::SKIP_SUBTREE; } else { - // If the current has no child node, we can find the desired item of the row - // number directly. - // This if can speed up finding in some case, and will has a very good effect - // when it comes to list view - if( node->GetNodes().GetCount() == 0) + parent = node; + + // If the current node has only leaf children, we can find the + // desired node directly. This can speed up finding the node + // in some cases, and will have a very good effect for list views. + if ( node->HasChildren() && + (int)node->GetChildNodes().size() == node->GetSubTreeCount() ) { - int index = static_cast(row) - current - 1; - ret = node->GetChildren().Item( index ); - return DoJob::OK; + const int index = static_cast(row) - current - 1; + ret = node->GetChildNodes()[index]; + return DoJob::DONE; } - return DoJob::CONT; - } - } - virtual int operator() ( void * n ) - { - current ++; - if( current == static_cast(row)) - { - ret = wxDataViewItem( n ); - return DoJob::OK; + return DoJob::CONTINUE; } - return DoJob::CONT; } - wxDataViewItem GetResult() const + wxDataViewTreeNode * GetResult() const { return ret; } private: unsigned int row; int current; - wxDataViewItem ret; + wxDataViewTreeNode * ret; + wxDataViewTreeNode * parent; }; -wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const +wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const { - if (IsVirtualList()) - { - return wxDataViewItem( wxUIntToPtr(row+1) ); - } - else - { - RowToItemJob job( row, -2 ); - Walker( m_root , job ); - return job.GetResult(); - } + wxASSERT( !IsVirtualList() ); + + if ( row == (unsigned)-1 ) + return NULL; + + RowToTreeNodeJob job( row , -2, m_root ); + Walker( m_root , job ); + return job.GetResult(); } -class RowToTreeNodeJob: public DoJob +wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const { -public: - RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node ) - { - this->row = row; - this->current = current; - ret = NULL; - parent = node; - } - virtual ~RowToTreeNodeJob(){ } - - virtual int operator() ( wxDataViewTreeNode * node ) + wxDataViewItem item; + if (IsVirtualList()) { - current ++; - if( current == static_cast(row)) - { - ret = node; - return DoJob::OK; - } - - if( node->GetSubTreeCount() + current < static_cast(row) ) - { - current += node->GetSubTreeCount(); - return DoJob::IGR; - } - else - { - parent = node; - - // If the current node has no children, we can find the desired item of the - // row number directly. - // This if can speed up finding in some case, and will have a very good - // effect for list views. - if( node->GetNodes().GetCount() == 0) - { - int index = static_cast(row) - current - 1; - void * n = node->GetChildren().Item( index ); - ret = new wxDataViewTreeNode( parent ); - ret->SetItem( wxDataViewItem( n )); - ret->SetHasChildren(false); - return DoJob::OK; - } - return DoJob::CONT; - } + if ( row < GetRowCount() ) + item = wxDataViewItem(wxUIntToPtr(row+1)); } - - virtual int operator() ( void * n ) + else { - current ++; - if( current == static_cast(row)) - { - ret = new wxDataViewTreeNode( parent ); - ret->SetItem( wxDataViewItem( n )); - ret->SetHasChildren(false); - return DoJob::OK; - } - - return DoJob::CONT; + wxDataViewTreeNode *node = GetTreeNodeByRow(row); + if ( node ) + item = node->GetItem(); } - wxDataViewTreeNode * GetResult() const - { return ret; } - -private: - unsigned int row; - int current; - wxDataViewTreeNode * ret; - wxDataViewTreeNode * parent; -}; - -wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const -{ - wxASSERT( !IsVirtualList() ); - - RowToTreeNodeJob job( row , -2, m_root ); - Walker( m_root , job ); - return job.GetResult(); + return item; } -wxDataViewEvent wxDataViewMainWindow::SendExpanderEvent( wxEventType type, - const wxDataViewItem & item ) +bool +wxDataViewMainWindow::SendExpanderEvent(wxEventType type, + const wxDataViewItem& item) { wxWindow *parent = GetParent(); wxDataViewEvent le(type, parent->GetId()); le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); + le.SetModel(GetModel()); le.SetItem( item ); - parent->GetEventHandler()->ProcessEvent(le); - return le; + return !parent->ProcessWindowEvent(le) || le.IsAllowed(); } bool wxDataViewMainWindow::IsExpanded( unsigned int row ) const @@ -2842,10 +3105,7 @@ bool wxDataViewMainWindow::IsExpanded( unsigned int row ) const return false; if (!node->HasChildren()) - { - delete node; return false; - } return node->IsOpen(); } @@ -2860,10 +3120,7 @@ bool wxDataViewMainWindow::HasChildren( unsigned int row ) const return false; if (!node->HasChildren()) - { - delete node; return false; - } return true; } @@ -2878,50 +3135,46 @@ void wxDataViewMainWindow::Expand( unsigned int row ) return; if (!node->HasChildren()) - { - delete node; return; - } - if (!node->IsOpen()) - { - wxDataViewEvent e = - SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, node->GetItem()); - - // Check if the user prevent expanding - if( e.GetSkipped() ) - return; + if (!node->IsOpen()) + { + if ( !SendExpanderEvent(wxEVT_DATAVIEW_ITEM_EXPANDING, node->GetItem()) ) + { + // Vetoed by the event handler. + return; + } - node->ToggleOpen(); + node->ToggleOpen(); - // build the children of current node - if( node->GetChildrenNumber() == 0 ) - { - SortPrepare(); - ::BuildTreeHelper(GetOwner()->GetModel(), node->GetItem(), node); - } + // build the children of current node + if( node->GetChildNodes().empty() ) + { + SortPrepare(); + ::BuildTreeHelper(GetModel(), node->GetItem(), node); + } - // By expanding the node all row indices that are currently in the selection list - // and are greater than our node have become invalid. So we have to correct that now. - const unsigned rowAdjustment = node->GetSubTreeCount(); - for(unsigned i=0; iGetSubTreeCount(); + for(unsigned i=0; i row) - ChangeCurrentRow(m_currentRow + rowAdjustment); + if(m_currentRow > row) + ChangeCurrentRow(m_currentRow + rowAdjustment); - m_count = -1; - UpdateDisplay(); - // Send the expanded event - SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem()); - } + m_count = -1; + UpdateDisplay(); + // Send the expanded event + SendExpanderEvent(wxEVT_DATAVIEW_ITEM_EXPANDED,node->GetItem()); + } } void wxDataViewMainWindow::Collapse(unsigned int row) @@ -2934,17 +3187,15 @@ void wxDataViewMainWindow::Collapse(unsigned int row) return; if (!node->HasChildren()) - { - delete node; return; - } if (node->IsOpen()) { - wxDataViewEvent e = - SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem()); - if( e.GetSkipped() ) + if ( !SendExpanderEvent(wxEVT_DATAVIEW_ITEM_COLLAPSING,node->GetItem()) ) + { + // Vetoed by the event handler. return; + } // Find out if there are selected items below the current node. bool selectCollapsingRow = false; @@ -2996,13 +3247,13 @@ void wxDataViewMainWindow::Collapse(unsigned int row) m_count = -1; UpdateDisplay(); - SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,node->GetItem()); + SendExpanderEvent(wxEVT_DATAVIEW_ITEM_COLLAPSED,node->GetItem()); } } wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item ) { - const wxDataViewModel * model = GetOwner()->GetModel(); + const wxDataViewModel * model = GetModel(); if( model == NULL ) return NULL; @@ -3021,17 +3272,20 @@ wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item // Find the item along the parent-chain. // This algorithm is designed to speed up the node-finding method wxDataViewTreeNode* node = m_root; - for( unsigned iter = parentChain.size()-1; iter>=0; --iter ) + for( unsigned iter = parentChain.size()-1; ; --iter ) { if( node->HasChildren() ) { - if( node->GetChildrenNumber() == 0 ) + if( node->GetChildNodes().empty() ) { + // Even though the item is a container, it doesn't have any + // child nodes in the control's representation yet. We have + // to realize its subtree now. SortPrepare(); ::BuildTreeHelper(model, node->GetItem(), node); } - const wxDataViewTreeNodes& nodes = node->GetNodes(); + const wxDataViewTreeNodes& nodes = node->GetChildNodes(); bool found = false; for (unsigned i = 0; i < nodes.GetCount(); ++i) @@ -3052,6 +3306,9 @@ wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item } else return NULL; + + if ( !iter ) + break; } return NULL; } @@ -3123,14 +3380,12 @@ wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, // to get the correct x position where the actual text is int indent = 0; int row = GetRowByItem(item); - if (!IsList() && (column == 0 || GetOwner()->GetExpanderColumn() == column) ) + if (!IsList() && + (column == 0 || GetExpanderColumnOrFirstOne(GetOwner()) == column) ) { wxDataViewTreeNode* node = GetTreeNodeByRow(row); indent = GetOwner()->GetIndent() * node->GetIndentLevel(); indent = indent + m_lineHeight; // use m_lineHeight as the width of the expander - - if(!node->HasChildren()) - delete node; } wxRect itemRect( xpos + indent, @@ -3144,12 +3399,12 @@ wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, return itemRect; } -int wxDataViewMainWindow::RecalculateCount() +int wxDataViewMainWindow::RecalculateCount() const { if (IsVirtualList()) { wxDataViewVirtualListModel *list_model = - (wxDataViewVirtualListModel*) GetOwner()->GetModel(); + (wxDataViewVirtualListModel*) GetModel(); return list_model->GetCount(); } @@ -3175,30 +3430,22 @@ public: ret ++; if( node->GetItem() == item ) { - return DoJob::OK; + return DoJob::DONE; } if( node->GetItem() == *m_iter ) { m_iter++; - return DoJob::CONT; + return DoJob::CONTINUE; } else { ret += node->GetSubTreeCount(); - return DoJob::IGR; + return DoJob::SKIP_SUBTREE; } } - virtual int operator() ( void * n ) - { - ret ++; - if( n == item.GetID() ) - return DoJob::OK; - return DoJob::CONT; - } - // the row number is begin from zero int GetResult() const { return ret -1; } @@ -3212,7 +3459,7 @@ private: int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const { - const wxDataViewModel * model = GetOwner()->GetModel(); + const wxDataViewModel * model = GetModel(); if( model == NULL ) return -1; @@ -3254,41 +3501,31 @@ static void BuildTreeHelper( const wxDataViewModel * model, const wxDataViewIte wxDataViewItemArray children; unsigned int num = model->GetChildren( item, children); - unsigned int index = 0; - while( index < num ) + for ( unsigned int index = 0; index < num; index++ ) { - if( model->IsContainer( children[index] ) ) - { - wxDataViewTreeNode * n = new wxDataViewTreeNode( node ); - n->SetItem(children[index]); + wxDataViewTreeNode *n = new wxDataViewTreeNode(node, children[index]); + + if( model->IsContainer(children[index]) ) n->SetHasChildren( true ); - node->AddNode( n ); - } - else - { - node->AddLeaf( children[index].GetID() ); - } - index ++; + + node->InsertChild(n, index); } - node->SetSubTreeCount( num ); - wxDataViewTreeNode * n = node->GetParent(); - if( n != NULL) - n->ChangeSubTreeCount(num); + wxASSERT( node->IsOpen() ); + node->ChangeSubTreeCount(+num); } void wxDataViewMainWindow::BuildTree(wxDataViewModel * model) { DestroyTree(); - if (GetOwner()->GetModel()->IsVirtualListModel()) + if (GetModel()->IsVirtualListModel()) { m_count = -1; return; } - m_root = new wxDataViewTreeNode( NULL ); - m_root->SetHasChildren(true); + m_root = wxDataViewTreeNode::CreateRootNode(); // First we define a invalid item to fetch the top-level elements wxDataViewItem item; @@ -3297,26 +3534,110 @@ void wxDataViewMainWindow::BuildTree(wxDataViewModel * model) m_count = -1; } -static void DestroyTreeHelper( wxDataViewTreeNode * node ) +void wxDataViewMainWindow::DestroyTree() { - if( node->GetNodeNumber() != 0 ) + if (!IsVirtualList()) { - int len = node->GetNodeNumber(); - wxDataViewTreeNodes& nodes = node->GetNodes(); - for (int i = 0; i < len; i++) - DestroyTreeHelper(nodes[i]); + wxDELETE(m_root); + m_count = 0; } - delete node; } -void wxDataViewMainWindow::DestroyTree() +wxDataViewColumn* +wxDataViewMainWindow::FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode) { - if (!IsVirtualList()) + // Edit the current column editable in 'mode'. If no column is focused + // (typically because the user has full row selected), try to find the + // first editable column (this would typically be a checkbox for + // wxDATAVIEW_CELL_ACTIVATABLE and we don't want to force the user to set + // focus on the checkbox column; or on the only editable text column). + + wxDataViewColumn *candidate = m_currentCol; + + if ( candidate && + !IsCellEditableInMode(item, candidate, mode) && + !m_currentColSetByKeyboard ) + { + // If current column was set by mouse to something not editable (in + // 'mode') and the user pressed Space/F2 to edit it, treat the + // situation as if there was whole-row focus, because that's what is + // visually indicated and the mouse click could very well be targeted + // on the row rather than on an individual cell. + // + // But if it was done by keyboard, respect that even if the column + // isn't editable, because focus is visually on that column and editing + // something else would be surprising. + candidate = NULL; + } + + if ( !candidate ) + { + const unsigned cols = GetOwner()->GetColumnCount(); + for ( unsigned i = 0; i < cols; i++ ) + { + wxDataViewColumn *c = GetOwner()->GetColumnAt(i); + if ( c->IsHidden() ) + continue; + + if ( IsCellEditableInMode(item, c, mode) ) + { + candidate = c; + break; + } + } + } + + // If on container item without columns, only the expander column + // may be directly editable: + if ( candidate && + GetOwner()->GetExpanderColumn() != candidate && + GetModel()->IsContainer(item) && + !GetModel()->HasContainerColumns(item) ) { - ::DestroyTreeHelper(m_root); - m_count = 0; - m_root = NULL; + candidate = GetOwner()->GetExpanderColumn(); } + + if ( !candidate ) + return NULL; + + if ( !IsCellEditableInMode(item, candidate, mode) ) + return NULL; + + return candidate; +} + +bool wxDataViewMainWindow::IsCellEditableInMode(const wxDataViewItem& item, + const wxDataViewColumn *col, + wxDataViewCellMode mode) const +{ + if ( col->GetRenderer()->GetMode() != mode ) + return false; + + if ( !GetModel()->IsEnabled(item, col->GetModelColumn()) ) + return false; + + return true; +} + +void wxDataViewMainWindow::OnCharHook(wxKeyEvent& event) +{ + if ( m_editorCtrl ) + { + // Handle any keys special for the in-place editor and return without + // calling Skip() below. + switch ( event.GetKeyCode() ) + { + case WXK_ESCAPE: + m_editorRenderer->CancelEditing(); + return; + + case WXK_RETURN: + m_editorRenderer->FinishEditing(); + return; + } + } + + event.Skip(); } void wxDataViewMainWindow::OnChar( wxKeyEvent &event ) @@ -3346,69 +3667,260 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event ) switch ( event.GetKeyCode() ) { case WXK_RETURN: + if ( event.HasModifiers() ) { - wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, + event.Skip(); + break; + } + else + { + // Enter activates the item, i.e. sends wxEVT_DATAVIEW_ITEM_ACTIVATED to + // it. Only if that event is not handled do we activate column renderer (which + // is normally done by Space) or even inline editing. + + const wxDataViewItem item = GetItemByRow(m_currentRow); + + wxDataViewEvent le(wxEVT_DATAVIEW_ITEM_ACTIVATED, parent->GetId()); - le.SetItem( GetItemByRow(m_currentRow) ); + le.SetItem(item); le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); + le.SetModel(GetModel()); + + if ( parent->ProcessWindowEvent(le) ) + break; + // else: fall through to WXK_SPACE handling + } - parent->GetEventHandler()->ProcessEvent(le); + case WXK_SPACE: + if ( event.HasModifiers() ) + { + event.Skip(); + break; + } + else + { + // Space toggles activatable items or -- if not activatable -- + // starts inline editing (this is normally done using F2 on + // Windows, but Space is common everywhere else, so use it too + // for greater cross-platform compatibility). + + const wxDataViewItem item = GetItemByRow(m_currentRow); + + // Activate the current activatable column. If not column is focused (typically + // because the user has full row selected), try to find the first activatable + // column (this would typically be a checkbox and we don't want to force the user + // to set focus on the checkbox column). + wxDataViewColumn *activatableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_ACTIVATABLE); + + if ( activatableCol ) + { + const unsigned colIdx = activatableCol->GetModelColumn(); + const wxRect cell_rect = GetOwner()->GetItemRect(item, activatableCol); + + wxDataViewRenderer *cell = activatableCol->GetRenderer(); + cell->PrepareForItem(GetModel(), item, colIdx); + cell->WXActivateCell(cell_rect, GetModel(), item, colIdx, NULL); + + break; + } + // else: fall through to WXK_F2 handling + } + + case WXK_F2: + if ( event.HasModifiers() ) + { + event.Skip(); + break; + } + else + { + if( !m_selection.empty() ) + { + // Mimic Windows 7 behavior: edit the item that has focus + // if it is selected and the first selected item if focus + // is out of selection. + int sel; + if ( m_selection.Index(m_currentRow) != wxNOT_FOUND ) + sel = m_currentRow; + else + sel = m_selection[0]; + + + const wxDataViewItem item = GetItemByRow(sel); + + // Edit the current column. If no column is focused + // (typically because the user has full row selected), try + // to find the first editable column. + wxDataViewColumn *editableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_EDITABLE); + + if ( editableCol ) + GetOwner()->EditItem(item, editableCol); + } } break; case WXK_UP: - if ( m_currentRow > 0 ) - OnArrowChar( m_currentRow - 1, event ); + OnVerticalNavigation( -1, event ); break; case WXK_DOWN: - if ( m_currentRow < GetRowCount() - 1 ) - OnArrowChar( m_currentRow + 1, event ); + OnVerticalNavigation( +1, event ); break; // Add the process for tree expanding/collapsing case WXK_LEFT: + OnLeftKey(); + break; + + case WXK_RIGHT: + OnRightKey(); + break; + + case WXK_END: + OnVerticalNavigation( +(int)GetRowCount(), event ); + break; + + case WXK_HOME: + OnVerticalNavigation( -(int)GetRowCount(), event ); + break; + + case WXK_PAGEUP: + OnVerticalNavigation( -(pageSize - 1), event ); + break; + + case WXK_PAGEDOWN: + OnVerticalNavigation( +(pageSize - 1), event ); + break; + + default: + event.Skip(); + } +} + +void wxDataViewMainWindow::OnVerticalNavigation(int delta, const wxKeyEvent& event) +{ + // if there is no selection, we cannot move it anywhere + if (!HasCurrentRow() || IsEmpty()) + return; + + int newRow = (int)m_currentRow + delta; + + // let's keep the new row inside the allowed range + if ( newRow < 0 ) + newRow = 0; + + const int rowCount = (int)GetRowCount(); + if ( newRow >= rowCount ) + newRow = rowCount - 1; + + unsigned int oldCurrent = m_currentRow; + unsigned int newCurrent = (unsigned int)newRow; + + // in single selection we just ignore Shift as we can't select several + // items anyhow + if ( event.ShiftDown() && !IsSingleSel() ) + { + RefreshRow( oldCurrent ); + + ChangeCurrentRow( newCurrent ); + + // select all the items between the old and the new one + if ( oldCurrent > newCurrent ) { - if (IsList()) - break; + newCurrent = oldCurrent; + oldCurrent = m_currentRow; + } - wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow); - if (!node) - break; + SelectRows( oldCurrent, newCurrent, true ); + if (oldCurrent!=newCurrent) + SendSelectionChangedEvent(GetItemByRow(m_selection[0])); + } + else // !shift + { + RefreshRow( oldCurrent ); - if (node->HasChildren() && node->IsOpen()) - { - Collapse(m_currentRow); - } - else // if the node is already closed we move the selection to its parent - { - wxDataViewTreeNode *parent_node = node->GetParent(); + // all previously selected items are unselected unless ctrl is held + if ( !event.ControlDown() ) + SelectAllRows(false); - if(!node->HasChildren()) - delete node; + ChangeCurrentRow( newCurrent ); - if (parent_node) + if ( !event.ControlDown() ) + { + SelectRow( m_currentRow, true ); + SendSelectionChangedEvent(GetItemByRow(m_currentRow)); + } + else + RefreshRow( m_currentRow ); + } + + GetOwner()->EnsureVisible( m_currentRow, -1 ); +} + +void wxDataViewMainWindow::OnLeftKey() +{ + if ( IsList() ) + { + TryAdvanceCurrentColumn(NULL, /*forward=*/false); + } + else + { + wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow); + if ( !node ) + return; + + if ( TryAdvanceCurrentColumn(node, /*forward=*/false) ) + return; + + // Because TryAdvanceCurrentColumn() return false, we are at the first + // column or using whole-row selection. In this situation, we can use + // the standard TreeView handling of the left key. + if (node->HasChildren() && node->IsOpen()) + { + Collapse(m_currentRow); + } + else + { + // if the node is already closed, we move the selection to its parent + wxDataViewTreeNode *parent_node = node->GetParent(); + + if (parent_node) + { + int parent = GetRowByItem( parent_node->GetItem() ); + if ( parent >= 0 ) { - int parent = GetRowByItem( parent_node->GetItem() ); - if ( parent >= 0 ) - { - unsigned int row = m_currentRow; - SelectRow( row, false); - SelectRow( parent, true ); - ChangeCurrentRow( parent ); - GetOwner()->EnsureVisible( parent, -1 ); - SendSelectionChangedEvent( parent_node->GetItem() ); - } + unsigned int row = m_currentRow; + SelectRow( row, false); + SelectRow( parent, true ); + ChangeCurrentRow( parent ); + GetOwner()->EnsureVisible( parent, -1 ); + SendSelectionChangedEvent( parent_node->GetItem() ); } } - break; } - case WXK_RIGHT: + } +} + +void wxDataViewMainWindow::OnRightKey() +{ + if ( IsList() ) + { + TryAdvanceCurrentColumn(NULL, /*forward=*/true); + } + else + { + wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow); + if ( !node ) + return; + + if ( node->HasChildren() ) { - if (!IsExpanded( m_currentRow )) + if ( !node->IsOpen() ) + { Expand( m_currentRow ); + } else { + // if the node is already open, we move the selection to the first child unsigned int row = m_currentRow; SelectRow( row, false ); SelectRow( row + 1, true ); @@ -3416,55 +3928,62 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event ) GetOwner()->EnsureVisible( row + 1, -1 ); SendSelectionChangedEvent( GetItemByRow(row+1) ); } - break; } - case WXK_END: + else { - if (!IsEmpty()) - OnArrowChar( GetRowCount() - 1, event ); - break; + TryAdvanceCurrentColumn(node, /*forward=*/true); } - case WXK_HOME: - if (!IsEmpty()) - OnArrowChar( 0, event ); - break; + } +} - case WXK_PAGEUP: - { - int steps = pageSize - 1; - int index = m_currentRow - steps; - if (index < 0) - index = 0; +bool wxDataViewMainWindow::TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward) +{ + if ( GetOwner()->GetColumnCount() == 0 ) + return false; - OnArrowChar( index, event ); - } - break; + if ( !m_useCellFocus ) + return false; - case WXK_PAGEDOWN: - { - int steps = pageSize - 1; - unsigned int index = m_currentRow + steps; - unsigned int count = GetRowCount(); - if ( index >= count ) - index = count - 1; + if ( node ) + { + // navigation shouldn't work in branch nodes without other columns: + if ( node->HasChildren() && !GetModel()->HasContainerColumns(node->GetItem()) ) + return false; + } - OnArrowChar( index, event ); - } - break; + if ( m_currentCol == NULL || !m_currentColSetByKeyboard ) + { + if ( forward ) + { + m_currentCol = GetOwner()->GetColumnAt(1); + m_currentColSetByKeyboard = true; + RefreshRow(m_currentRow); + return true; + } + else + return false; + } - case WXK_F2: - { - if(m_selection.size() == 1) - { - // TODO: we need to revise that when we have a concept for a 'current column' - GetOwner()->StartEditor(GetItemByRow(m_selection[0]), 0); - } - } - break; + int idx = GetOwner()->GetColumnIndex(m_currentCol) + (forward ? +1 : -1); - default: - event.Skip(); + if ( idx >= (int)GetOwner()->GetColumnCount() ) + return false; + + GetOwner()->EnsureVisible(m_currentRow, idx); + + if ( idx < 1 ) + { + // We are going to the left of the second column. Reset to whole-row + // focus (which means first column would be edited). + m_currentCol = NULL; + RefreshRow(m_currentRow); + return true; } + + m_currentCol = GetOwner()->GetColumnAt(idx); + m_currentColSetByKeyboard = true; + RefreshRow(m_currentRow); + return true; } void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) @@ -3476,9 +3995,13 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) return; } - // set the focus to ourself if any of the mouse buttons are pressed - if(event.ButtonDown() && !HasFocus()) - SetFocus(); + if(event.ButtonDown()) + { + // Not skipping button down events would prevent the system from + // setting focus to this window as most (all?) of them do by default, + // so skip it to enable default handling. + event.Skip(); + } int x = event.GetX(); int y = event.GetY(); @@ -3486,85 +4009,50 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) wxDataViewColumn *col = NULL; int xpos = 0; - unsigned int cols = GetOwner()->GetColumnCount(); - unsigned int i; - for (i = 0; i < cols; i++) - { - wxDataViewColumn *c = GetOwner()->GetColumnAt( i ); - if (c->IsHidden()) - continue; // skip it! - - if (x < xpos + c->GetWidth()) - { - col = c; - break; - } - xpos += c->GetWidth(); - } - if (!col) - { - event.Skip(); - return; - } - - wxDataViewRenderer *cell = col->GetRenderer(); - unsigned int current = GetLineAt( y ); - if ((current >= GetRowCount()) || (x > GetEndOfLastCol())) - { - // Unselect all if below the last row ? - event.Skip(); - return; - } - - // Test whether the mouse is hovered on the tree item button - bool hoverOverExpander = false; - if ((!IsList()) && (GetOwner()->GetExpanderColumn() == col)) - { - wxDataViewTreeNode * node = GetTreeNodeByRow(current); - if( node!=NULL && node->HasChildren() ) - { - int indent = node->GetIndentLevel(); - indent = GetOwner()->GetIndent()*indent; - - // we make the rectangle we are looking in a bit bigger than the actual - // visual expander so the user can hit that little thing reliably - wxRect rect( xpos + indent, - GetLineStart( current ) + (GetLineHeight(current) - m_lineHeight)/2, - m_lineHeight, m_lineHeight); - if( rect.Contains(x, y) ) - { - // So the mouse is over the expander - hoverOverExpander = true; - if (m_underMouse && m_underMouse != node) - { - // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); - RefreshRow(GetRowByItem(m_underMouse->GetItem())); - } - if (m_underMouse != node) - { - // wxLogMessage("Do the row: %d", current); - RefreshRow(current); - } - m_underMouse = node; - } + unsigned int cols = GetOwner()->GetColumnCount(); + unsigned int i; + for (i = 0; i < cols; i++) + { + wxDataViewColumn *c = GetOwner()->GetColumnAt( i ); + if (c->IsHidden()) + continue; // skip it! + + if (x < xpos + c->GetWidth()) + { + col = c; + break; } - if (node!=NULL && !node->HasChildren()) - delete node; + xpos += c->GetWidth(); } - if (!hoverOverExpander) + + wxDataViewModel* const model = GetModel(); + + const unsigned int current = GetLineAt( y ); + const wxDataViewItem item = GetItemByRow(current); + + // Handle right clicking here, before everything else as context menu + // events should be sent even when we click outside of any item, unlike all + // the other ones. + if (event.RightUp()) { - if (m_underMouse != NULL) + wxWindow *parent = GetParent(); + wxDataViewEvent le(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId()); + le.SetEventObject(parent); + le.SetModel(model); + + if ( item.IsOk() && col ) { - // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); - RefreshRow(GetRowByItem(m_underMouse->GetItem())); - m_underMouse = NULL; + le.SetItem( item ); + le.SetColumn( col->GetModelColumn() ); + le.SetDataViewColumn( col ); } - } - wxDataViewModel *model = GetOwner()->GetModel(); + parent->ProcessWindowEvent(le); + return; + } #if wxUSE_DRAG_AND_DROP - if (event.Dragging()) + if (event.Dragging() || ((m_dragCount > 0) && event.Leaving())) { if (m_dragCount == 0) { @@ -3575,8 +4063,9 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) } m_dragCount++; - - if (m_dragCount != 3) + if ((m_dragCount < 3) && (event.Leaving())) + m_dragCount = 3; + else if (m_dragCount != 3) return; if (event.LeftIsDown()) @@ -3584,12 +4073,12 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) m_owner->CalcUnscrolledPosition( m_dragStart.x, m_dragStart.y, &m_dragStart.x, &m_dragStart.y ); unsigned int drag_item_row = GetLineAt( m_dragStart.y ); - wxDataViewItem item = GetItemByRow( drag_item_row ); + wxDataViewItem itemDragged = GetItemByRow( drag_item_row ); // Notify cell about drag - wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() ); + wxDataViewEvent event( wxEVT_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() ); event.SetEventObject( m_owner ); - event.SetItem( item ); + event.SetItem( itemDragged ); event.SetModel( model ); if (!m_owner->HandleWindowEvent( event )) return; @@ -3603,7 +4092,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) wxDataViewDropSource drag( this, drag_item_row ); drag.SetData( *obj ); - /* wxDragResult res = */ drag.DoDragDrop(); + /* wxDragResult res = */ drag.DoDragDrop(event.GetDragFlags()); delete obj; } return; @@ -3614,6 +4103,79 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) } #endif // wxUSE_DRAG_AND_DROP + // Check if we clicked outside the item area. + if ((current >= GetRowCount()) || !col) + { + // Follow Windows convention here: clicking either left or right (but + // not middle) button clears the existing selection. + if (m_owner && (event.LeftDown() || event.RightDown())) + { + if (!GetSelections().empty()) + { + m_owner->UnselectAll(); + SendSelectionChangedEvent(wxDataViewItem()); + } + } + event.Skip(); + return; + } + + wxDataViewRenderer *cell = col->GetRenderer(); + wxDataViewColumn* const + expander = GetExpanderColumnOrFirstOne(GetOwner()); + + // Test whether the mouse is hovering over the expander (a.k.a tree "+" + // button) and also determine the offset of the real cell start, skipping + // the indentation and the expander itself. + bool hoverOverExpander = false; + int itemOffset = 0; + if ((!IsList()) && (expander == col)) + { + wxDataViewTreeNode * node = GetTreeNodeByRow(current); + + int indent = node->GetIndentLevel(); + itemOffset = GetOwner()->GetIndent()*indent; + + if ( node->HasChildren() ) + { + // we make the rectangle we are looking in a bit bigger than the actual + // visual expander so the user can hit that little thing reliably + wxRect rect(itemOffset, + GetLineStart( current ) + (GetLineHeight(current) - m_lineHeight)/2, + m_lineHeight, m_lineHeight); + + if( rect.Contains(x, y) ) + { + // So the mouse is over the expander + hoverOverExpander = true; + if (m_underMouse && m_underMouse != node) + { + // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); + RefreshRow(GetRowByItem(m_underMouse->GetItem())); + } + if (m_underMouse != node) + { + // wxLogMessage("Do the row: %d", current); + RefreshRow(current); + } + m_underMouse = node; + } + } + + // Account for the expander as well, even if this item doesn't have it, + // its parent does so it still counts for the offset. + itemOffset += m_lineHeight; + } + if (!hoverOverExpander) + { + if (m_underMouse != NULL) + { + // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); + RefreshRow(GetRowByItem(m_underMouse->GetItem())); + m_underMouse = NULL; + } + } + bool simulateClick = false; if (event.ButtonDClick()) @@ -3622,9 +4184,8 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) m_lastOnSame = false; } - wxDataViewItem item = GetItemByRow(current); bool ignore_other_columns = - ((GetOwner()->GetExpanderColumn() != col) && + ((expander != col) && (model->IsContainer(item)) && (!model->HasContainerColumns(item))); @@ -3637,28 +4198,15 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) } else if ( current == m_lineLastClicked ) { - if ((!ignore_other_columns) && (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)) - { - const unsigned colIdx = col->GetModelColumn(); - - cell->PrepareForItem(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 ); - le.SetColumn( col->GetModelColumn() ); - le.SetDataViewColumn( col ); - le.SetEventObject(parent); - le.SetModel(GetOwner()->GetModel()); - - parent->GetEventHandler()->ProcessEvent(le); - } + wxWindow *parent = GetParent(); + wxDataViewEvent le(wxEVT_DATAVIEW_ITEM_ACTIVATED, parent->GetId()); + le.SetItem( item ); + le.SetColumn( col->GetModelColumn() ); + le.SetDataViewColumn( col ); + le.SetEventObject(parent); + le.SetModel(GetModel()); + + parent->ProcessWindowEvent(le); return; } else @@ -3684,7 +4232,7 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) if (m_lastOnSame && !ignore_other_columns) { if ((col == m_currentCol) && (current == m_currentRow) && - (cell->GetMode() & wxDATAVIEW_CELL_EDITABLE) ) + IsCellEditableInMode(item, col, wxDATAVIEW_CELL_EDITABLE) ) { m_renameTimer->Start( 100, true ); } @@ -3712,25 +4260,13 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) if (!IsRowSelected(current)) { SelectAllRows(false); + const unsigned oldCurrent = m_currentRow; ChangeCurrentRow(current); SelectRow(m_currentRow,true); + RefreshRow(oldCurrent); SendSelectionChangedEvent(GetItemByRow( m_currentRow ) ); } } - else if (event.RightUp()) - { - wxVariant value; - model->GetValue( value, item, col->GetModelColumn() ); - 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); - parent->GetEventHandler()->ProcessEvent(le); - } else if (event.MiddleDown()) { } @@ -3809,57 +4345,77 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) // Update selection here... m_currentCol = col; - + m_currentColSetByKeyboard = false; + + // This flag is used to decide whether we should start editing the item + // label. We do it if the user clicks twice (but not double clicks, + // i.e. simulateClick is false) on the same item but not if the click + // was used for something else already, e.g. selecting the item (so it + // must have been already selected) or giving the focus to the control + // (so it must have had focus already). m_lastOnSame = !simulateClick && ((col == oldCurrentCol) && - (current == oldCurrentRow)) && oldWasSelected; + (current == oldCurrentRow)) && oldWasSelected && + HasFocus(); - // Call LeftClick after everything else as under GTK+ - if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE) + // Call ActivateCell() after everything else as under GTK+ + if ( IsCellEditableInMode(item, col, wxDATAVIEW_CELL_ACTIVATABLE) ) { // notify cell about click cell->PrepareForItem(model, item, col->GetModelColumn()); - wxRect cell_rect( xpos, GetLineStart( current ), - col->GetWidth(), GetLineHeight( current ) ); + wxRect cell_rect( xpos + itemOffset, + GetLineStart( current ), + col->GetWidth() - itemOffset, + 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 + // not the entire space as given by the control but the one // used by the renderer after calculation of alignment etc. + // + // Notice that this results in negative coordinates when clicking + // in the upper left corner of a centre-aligned cell which doesn't + // fill its column entirely so this is somewhat surprising, but we + // do it like this for compatibility with the native GTK+ version, + // see #12270. // adjust the rectangle ourselves to account for the alignment + int align = cell->GetAlignment(); + if ( align == wxDVR_DEFAULT_ALIGNMENT ) + align = wxALIGN_CENTRE; + 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 ) { - 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.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 ( 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 } - wxPoint pos( event.GetPosition() ); - pos.x -= rectItem.x; - pos.y -= rectItem.y; - - m_owner->CalcUnscrolledPosition( pos.x, pos.y, &pos.x, &pos.y ); + 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 + } - /* ignore ret */ cell->WXOnLeftClick( pos, cell_rect, - model, item, col->GetModelColumn()); + wxMouseEvent event2(event); + event2.m_x -= rectItem.x; + event2.m_y -= rectItem.y; + m_owner->CalcUnscrolledPosition(event2.m_x, event2.m_y, &event2.m_x, &event2.m_y); + + /* ignore ret */ cell->WXActivateCell + ( + cell_rect, + model, + item, + col->GetModelColumn(), + &event2 + ); } } } @@ -3884,12 +4440,23 @@ void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event ) event.Skip(); } -wxDataViewItem wxDataViewMainWindow::GetSelection() const +void wxDataViewMainWindow::OnColumnsCountChanged() { - if( m_selection.GetCount() != 1 ) - return wxDataViewItem(); + int editableCount = 0; + + const unsigned cols = GetOwner()->GetColumnCount(); + for ( unsigned i = 0; i < cols; i++ ) + { + wxDataViewColumn *c = GetOwner()->GetColumnAt(i); + if ( c->IsHidden() ) + continue; + if ( c->GetRenderer()->GetMode() != wxDATAVIEW_CELL_INERT ) + editableCount++; + } + + m_useCellFocus = (editableCount > 1); - return GetItemByRow( m_selection.Item(0)); + UpdateDisplay(); } //----------------------------------------------------------------------------- @@ -3921,6 +4488,9 @@ void wxDataViewCtrl::Init() m_sortingColumnIdx = wxNOT_FOUND; m_headerArea = NULL; + m_clientArea = NULL; + + m_colsDirty = false; } bool wxDataViewCtrl::Create(wxWindow *parent, @@ -4014,6 +4584,16 @@ void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) ) 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() @@ -4022,18 +4602,53 @@ void wxDataViewCtrl::SetFocus() m_clientArea->SetFocus(); } +bool wxDataViewCtrl::SetFont(const wxFont & font) +{ + if (!wxControl::SetFont(font)) + return false; + + if (m_headerArea) + m_headerArea->SetFont(font); + + if (m_clientArea) + { + m_clientArea->SetFont(font); + m_clientArea->SetRowHeight(m_clientArea->GetDefaultRowHeight()); + } + + if (m_headerArea || m_clientArea) + { + InvalidateColBestWidths(); + Layout(); + } + + return true; +} + + + bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model ) { if (!wxDataViewCtrlBase::AssociateModel( model )) return false; - m_notifier = new wxGenericDataViewModelNotifier( m_clientArea ); - - model->AddNotifier( m_notifier ); + if (model) + { + m_notifier = new wxGenericDataViewModelNotifier( m_clientArea ); + model->AddNotifier( m_notifier ); + } + else if (m_notifier) + { + m_notifier->Cleared(); + m_notifier = NULL; + } m_clientArea->DestroyTree(); - m_clientArea->BuildTree(model); + if (model) + { + m_clientArea->BuildTree(model); + } m_clientArea->UpdateDisplay(); @@ -4060,7 +4675,7 @@ bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col ) return false; m_cols.Append( col ); - m_colsBestWidths.push_back(0); + m_colsBestWidths.push_back(CachedColWidthInfo()); OnColumnsCountChanged(); return true; } @@ -4071,7 +4686,7 @@ bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col ) return false; m_cols.Insert( col ); - m_colsBestWidths.insert(m_colsBestWidths.begin(), 0); + m_colsBestWidths.insert(m_colsBestWidths.begin(), CachedColWidthInfo()); OnColumnsCountChanged(); return true; } @@ -4082,7 +4697,7 @@ bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col ) return false; m_cols.Insert( pos, col ); - m_colsBestWidths.insert(m_colsBestWidths.begin() + pos, 0); + m_colsBestWidths.insert(m_colsBestWidths.begin() + pos, CachedColWidthInfo()); OnColumnsCountChanged(); return true; } @@ -4100,11 +4715,19 @@ void wxDataViewCtrl::OnColumnsCountChanged() if (m_headerArea) m_headerArea->SetColumnCount(GetColumnCount()); - m_clientArea->UpdateDisplay(); + m_clientArea->OnColumnsCountChanged(); } void wxDataViewCtrl::DoSetExpanderColumn() { + wxDataViewColumn* column = GetExpanderColumn(); + if ( column ) + { + int index = GetColumnIndex(column); + if ( index != wxNOT_FOUND ) + InvalidateColBestWidth(index); + } + m_clientArea->UpdateDisplay(); } @@ -4118,6 +4741,16 @@ unsigned int wxDataViewCtrl::GetColumnCount() const 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]; @@ -4145,10 +4778,22 @@ int wxDataViewCtrl::GetColumnIndex(const wxDataViewColumn *column) const return wxNOT_FOUND; } +int wxDataViewCtrl::GetModelColumnIndex( unsigned int model_column ) const +{ + const int count = GetColumnCount(); + for ( int index = 0; index < count; index++ ) + { + wxDataViewColumn* column = GetColumn(index); + if ( column->GetModelColumn() == model_column ) + return index; + } + return wxNOT_FOUND; +} + unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const { - if ( m_colsBestWidths[idx] != 0 ) - return m_colsBestWidths[idx]; + if ( m_colsBestWidths[idx].width != 0 ) + return m_colsBestWidths[idx].width; const int count = m_clientArea->GetRowCount(); wxDataViewColumn *column = GetColumn(idx); @@ -4158,16 +4803,27 @@ unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const class MaxWidthCalculator { public: - MaxWidthCalculator(wxDataViewMainWindow *clientArea, + MaxWidthCalculator(const wxDataViewCtrl *dvc, + wxDataViewMainWindow *clientArea, wxDataViewRenderer *renderer, const wxDataViewModel *model, - unsigned column) + unsigned int model_column, + int expanderSize) : m_width(0), + m_dvc(dvc), m_clientArea(clientArea), m_renderer(renderer), m_model(model), - m_column(column) + m_model_column(model_column), + m_expanderSize(expanderSize) + { + int index = dvc->GetModelColumnIndex( model_column ); + wxDataViewColumn* column = index == wxNOT_FOUND ? NULL : dvc->GetColumn(index); + m_isExpanderCol = + !clientArea->IsList() && + (column == 0 || + GetExpanderColumnOrFirstOne(const_cast(dvc)) == column ); } void UpdateWithWidth(int width) @@ -4177,32 +4833,45 @@ unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const 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 indent = 0; + wxDataViewItem item; + + if ( m_isExpanderCol ) + { + wxDataViewTreeNode *node = m_clientArea->GetTreeNodeByRow(row); + item = node->GetItem(); + indent = m_dvc->GetIndent() * node->GetIndentLevel() + m_expanderSize; + } + else + { + item = m_clientArea->GetItemByRow(row); + } + + m_renderer->PrepareForItem(m_model, item, m_model_column); + m_width = wxMax(m_width, m_renderer->GetSize().x + indent); } int GetMaxWidth() const { return m_width; } private: int m_width; + const wxDataViewCtrl *m_dvc; wxDataViewMainWindow *m_clientArea; wxDataViewRenderer *m_renderer; const wxDataViewModel *m_model; - unsigned m_column; + unsigned m_model_column; + bool m_isExpanderCol; + int m_expanderSize; }; - MaxWidthCalculator calculator(m_clientArea, renderer, - GetModel(), column->GetModelColumn()); + MaxWidthCalculator calculator(this, m_clientArea, renderer, + GetModel(), column->GetModelColumn(), + m_clientArea->GetRowHeight()); + + calculator.UpdateWithWidth(column->GetMinWidth()); if ( m_headerArea ) - { - int header_width = m_headerArea->GetTextExtent(column->GetTitle()).x; - // Labels on native MSW header are indented on both sides - header_width += - wxRendererNative::Get().GetHeaderButtonMargin(m_headerArea); - calculator.UpdateWithWidth(header_width); - } + calculator.UpdateWithWidth(m_headerArea->GetColumnTitleWidth(*column)); // The code below deserves some explanation. For very large controls, we // simply can't afford to calculate sizes for all items, it takes too @@ -4276,7 +4945,7 @@ unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const if ( max_width > 0 ) max_width += 2 * PADDING_RIGHTLEFT; - const_cast(this)->m_colsBestWidths[idx] = max_width; + const_cast(this)->m_colsBestWidths[idx].width = max_width; return max_width; } @@ -4297,6 +4966,10 @@ bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column ) m_colsBestWidths.erase(m_colsBestWidths.begin() + GetColumnIndex(column)); m_cols.Erase(ret); + + if ( m_clientArea->GetCurrentColumn() == column ) + m_clientArea->ClearCurrentColumn(); + OnColumnsCountChanged(); return true; @@ -4304,36 +4977,68 @@ bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column ) bool wxDataViewCtrl::ClearColumns() { + SetExpanderColumn(NULL); m_cols.Clear(); m_colsBestWidths.clear(); + + m_clientArea->ClearCurrentColumn(); + OnColumnsCountChanged(); + return true; } void wxDataViewCtrl::InvalidateColBestWidth(int idx) { - m_colsBestWidths[idx] = 0; - - if ( m_headerArea ) - m_headerArea->UpdateColumn(idx); + m_colsBestWidths[idx].width = 0; + m_colsBestWidths[idx].dirty = true; + m_colsDirty = true; } void wxDataViewCtrl::InvalidateColBestWidths() { + // mark all columns as dirty: m_colsBestWidths.clear(); m_colsBestWidths.resize(m_cols.size()); + m_colsDirty = true; +} - if ( m_headerArea ) - { - const unsigned cols = m_headerArea->GetColumnCount(); - for ( unsigned i = 0; i < cols; i++ ) +void wxDataViewCtrl::UpdateColWidths() +{ + m_colsDirty = false; + + if ( !m_headerArea ) + return; + + const unsigned len = m_colsBestWidths.size(); + for ( unsigned i = 0; i < len; i++ ) + { + // Note that we have to have an explicit 'dirty' flag here instead of + // checking if the width==0, as is done in GetBestColumnWidth(). + // + // Testing width==0 wouldn't work correctly if some code called + // GetWidth() after col. width invalidation but before + // wxDataViewCtrl::UpdateColWidths() was called at idle time. This + // would result in the header's column width getting out of sync with + // the control itself. + if ( m_colsBestWidths[i].dirty ) + { m_headerArea->UpdateColumn(i); + m_colsBestWidths[i].dirty = false; + } } } +void wxDataViewCtrl::OnInternalIdle() +{ + wxDataViewCtrlBase::OnInternalIdle(); + + if ( m_colsDirty ) + UpdateColWidths(); +} + int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const { -#if 1 unsigned int len = GetColumnCount(); for ( unsigned int i = 0; i < len; i++ ) { @@ -4343,25 +5048,6 @@ int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const } return wxNOT_FOUND; -#else - // This returns the position in pixels which is not what we want. - int ret = 0, - dummy = 0; - unsigned int len = GetColumnCount(); - for ( unsigned int i = 0; i < len; i++ ) - { - wxDataViewColumn * col = GetColumnAt(i); - if (col->IsHidden()) - continue; - ret += col->GetWidth(); - if (column==col) - { - CalcScrolledPosition( ret, dummy, &ret, &dummy ); - break; - } - } - return ret; -#endif } wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const @@ -4388,23 +5074,36 @@ void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item) } } -// Selection code with wxDataViewItem as parameters -wxDataViewItem wxDataViewCtrl::GetSelection() const +wxDataViewColumn *wxDataViewCtrl::GetCurrentColumn() const +{ + return m_clientArea->GetCurrentColumn(); +} + +int wxDataViewCtrl::GetSelectedItemsCount() const { - return m_clientArea->GetSelection(); + return m_clientArea->GetSelections().size(); } int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const { sel.Empty(); - wxDataViewSelection selection = m_clientArea->GetSelections(); - int len = selection.GetCount(); - for( int i = 0; i < len; i ++) + const wxDataViewSelection& selections = m_clientArea->GetSelections(); + + const size_t len = selections.size(); + for ( size_t i = 0; i < len; i++ ) { - unsigned int row = selection[i]; - sel.Add( m_clientArea->GetItemByRow( row ) ); + wxDataViewItem item = m_clientArea->GetItemByRow(selections[i]); + if ( item.IsOk() ) + { + sel.Add(item); + } + else + { + wxFAIL_MSG( "invalid item in selection - bad internal state" ); + } } - return len; + + return sel.size(); } void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel ) @@ -4468,71 +5167,9 @@ bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const return false; } -// Selection code with row number as parameter -int wxDataViewCtrl::GetSelections( wxArrayInt & sel ) const -{ - sel.Empty(); - wxDataViewSelection selection = m_clientArea->GetSelections(); - int len = selection.GetCount(); - for( int i = 0; i < len; i ++) - { - unsigned int row = selection[i]; - sel.Add( row ); - } - return len; -} - -void wxDataViewCtrl::SetSelections( const wxArrayInt & sel ) -{ - wxDataViewSelection selection(wxDataViewSelectionCmp); - int len = sel.GetCount(); - for( int i = 0; i < len; i ++ ) - { - int row = sel[i]; - if( row >= 0 ) - selection.Add( static_cast(row) ); - } - m_clientArea->SetSelections( selection ); -} - -void wxDataViewCtrl::Select( int row ) -{ - if( row >= 0 ) - { - if (m_clientArea->IsSingleSel()) - m_clientArea->SelectAllRows(false); - m_clientArea->SelectRow( row, true ); - } -} - -void wxDataViewCtrl::Unselect( int row ) -{ - if( row >= 0 ) - m_clientArea->SelectRow(row, false); -} - -bool wxDataViewCtrl::IsSelected( int row ) const -{ - if( row >= 0 ) - return m_clientArea->IsRowSelected(row); - return false; -} - -void wxDataViewCtrl::SelectRange( int from, int to ) -{ - wxArrayInt sel; - for( int i = from; i < to; i ++ ) - sel.Add( i ); - m_clientArea->Select(sel); -} - -void wxDataViewCtrl::UnselectRange( int from, int to ) +void wxDataViewCtrl::SetAlternateRowColour(const wxColour& colour) { - wxDataViewSelection sel = m_clientArea->GetSelections(); - for( int i = from; i < to; i ++ ) - if( sel.Index( i ) != wxNOT_FOUND ) - sel.Remove( i ); - m_clientArea->SetSelections(sel); + m_alternateRowColour = colour; } void wxDataViewCtrl::SelectAll() @@ -4607,14 +5244,20 @@ void wxDataViewCtrl::Expand( const wxDataViewItem & item ) int row = m_clientArea->GetRowByItem( item ); if (row != -1) + { m_clientArea->Expand(row); + InvalidateColBestWidths(); + } } void wxDataViewCtrl::Collapse( const wxDataViewItem & item ) { int row = m_clientArea->GetRowByItem( item ); if (row != -1) + { m_clientArea->Collapse(row); + InvalidateColBestWidths(); + } } bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const @@ -4625,16 +5268,12 @@ bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const return false; } -void wxDataViewCtrl::StartEditor( const wxDataViewItem & item, unsigned int column ) +void wxDataViewCtrl::EditItem(const wxDataViewItem& item, const wxDataViewColumn *column) { - wxDataViewColumn* col = GetColumn( column ); - if (!col) - return; + wxCHECK_RET( item.IsOk(), "invalid item" ); + wxCHECK_RET( column, "no column provided" ); - wxRect itemRect = GetItemRect(item, col); - wxDataViewRenderer* renderer = col->GetRenderer(); - if (renderer->GetMode() == wxDATAVIEW_CELL_EDITABLE) - renderer->StartEditing(item, itemRect); + m_clientArea->StartEditing(item, column); } #endif // !wxUSE_GENERICDATAVIEWCTRL