X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/aba9bfd00ad88d9005809a217069bc41b896a4ad..6f3f9b50aa275243ade3541ecccb95de22cf57a9:/src/generic/datavgen.cpp diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp index 22efe3dfd2..f47731e5e4 100644 --- a/src/generic/datavgen.cpp +++ b/src/generic/datavgen.cpp @@ -42,6 +42,8 @@ #include "wx/renderer.h" #include "wx/dcbuffer.h" #include "wx/icon.h" +#include "wx/list.h" +#include "wx/listimpl.cpp" //----------------------------------------------------------------------------- // classes @@ -57,11 +59,8 @@ static const int PADDING_RIGHTLEFT = 3; // the cell padding on the top/bottom static const int PADDING_TOPBOTTOM = 1; - -bool operator == ( const wxDataViewItem & left, const wxDataViewItem & right ) -{ - return left.GetID() == right.GetID(); -} +// the expander space margin +static const int EXPANDER_MARGIN = 4; //----------------------------------------------------------------------------- // wxDataViewHeaderWindow @@ -182,7 +181,7 @@ public: } virtual void UpdateDisplay() { Refresh(); } - + // event handlers: void OnPaint( wxPaintEvent &event ); @@ -254,52 +253,159 @@ public: //----------------------------------------------------------------------------- // wxDataViewTreeNode //----------------------------------------------------------------------------- -class wxDataViewTreeNode; -WX_DEFINE_ARRAY_PTR( wxDataViewTreeNode *, wxDataViewTreeNodes ); +class wxDataViewTreeNode; +WX_DEFINE_SORTED_ARRAY( wxDataViewTreeNode *, wxDataViewTreeNodes ); +WX_DEFINE_SORTED_ARRAY( void* , wxDataViewTreeLeaves); + +int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode * node1, wxDataViewTreeNode * node2); +int LINKAGEMODE wxGenericTreeModelItemCmp( void * id1, void * id2); class wxDataViewTreeNode { public: wxDataViewTreeNode( wxDataViewTreeNode * parent ) - { this->parent = parent; + :leaves( wxGenericTreeModelItemCmp ), + nodes(wxGenericTreeModelNodeCmp) + { this->parent = parent; if( parent == NULL ) open = true; else open = false; + hasChildren = false; + subTreeCount = 0; } //I don't know what I need to do in the destructure ~wxDataViewTreeNode() - { } + { + + } wxDataViewTreeNode * GetParent() { return parent; } void SetParent( wxDataViewTreeNode * parent ) { this->parent = parent; } - wxDataViewTreeNodes GetChildren() { return children; } - void SetChildren( wxDataViewTreeNodes children ) { this->children = children; } + wxDataViewTreeNodes & GetNodes() { return nodes; } + wxDataViewTreeLeaves & GetChildren() { return leaves; } - wxDataViewTreeNode * GetChild( unsigned int n ) { return children.Item( n ); } - void InsertChild( wxDataViewTreeNode * child, unsigned int n) { children.Insert( child, n); } - void AppendChild( wxDataViewTreeNode * child ) { children.Add( child ); } + void AddNode( wxDataViewTreeNode * node ) + { + nodes.Add( node ); + leaves.Add( node->GetItem().GetID() ); + } + void AddLeaf( void * leaf ) { leaves.Add( leaf ); } wxDataViewItem & GetItem() { return item; } - void SetItem( wxDataViewItem & item ) { this->item = item; } + void SetItem( const wxDataViewItem & item ) { this->item = item; } + + unsigned int GetChildrenNumber() { return leaves.GetCount(); } + unsigned int GetNodeNumber() { return nodes.GetCount(); } + int GetIndentLevel() + { + int ret = 0 ; + wxDataViewTreeNode * node = this; + while( node->GetParent()->GetParent() != NULL ) + { + node = node->GetParent(); + ret ++; + } + return ret; + } + + bool IsOpen() + { + return open ; + } - unsigned int GetChildrenNumber() { return children.GetCount(); } + void ToggleOpen() + { + int len = nodes.GetCount(); + int sum = 0; + for ( int i = 0 ;i < len ; i ++) + sum += nodes[i]->GetSubTreeCount(); + + sum += leaves.GetCount(); + if( open ) + { + ChangeSubTreeCount(-sum); + open = !open; + } + else + { + open = !open; + ChangeSubTreeCount(sum); + } + } + bool HasChildren() { return hasChildren; } + void SetHasChildren( bool has ){ hasChildren = has; } + + void SetSubTreeCount( int num ) { subTreeCount = num; } + int GetSubTreeCount() { return subTreeCount; } + void ChangeSubTreeCount( int num ) + { + if( !open ) + return ; + subTreeCount += num; + if( parent ) + parent->ChangeSubTreeCount(num); + } + + void Resort() + { + wxDataViewTreeNodes nds = nodes; + wxDataViewTreeLeaves lvs = leaves; + nodes.Empty(); + leaves.Empty(); + + int len = nds.GetCount(); + if(len > 0) + { + int i; + for(i = 0; i < len; i ++) + nodes.Add(nds[i]); + for(i = 0; i < len; i ++) + nodes[i]->Resort(); + } + + len = lvs.GetCount(); + if(len > 0) + { + for(int i = 0; i < len; i++) + leaves.Add(lvs[i]); + } + } - bool IsOpen() { return open; } - bool HasChildren() { return children.GetCount() != 0; } private: wxDataViewTreeNode * parent; - wxDataViewTreeNodes children; - wxDataViewItem item; + wxDataViewTreeNodes nodes; + wxDataViewTreeLeaves leaves; + wxDataViewItem item; bool open; + bool hasChildren; + int subTreeCount; }; +//Below is the compare stuff +//For the generic implements, both the leaf nodes and the nodes are sorted for fast search when needed +static wxDataViewModel * g_model; + +int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode * node1, wxDataViewTreeNode * node2) +{ + return g_model->Compare( node1->GetItem(), node2->GetItem() ); +} + +int LINKAGEMODE wxGenericTreeModelItemCmp( void * id1, void * id2) +{ + return g_model->Compare( id1, id2 ); +} + + + //----------------------------------------------------------------------------- // wxDataViewMainWindow //----------------------------------------------------------------------------- WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection, WXDLLIMPEXP_ADV); +WX_DECLARE_LIST(wxDataViewItem, ItemList); +WX_DEFINE_LIST(ItemList); class wxDataViewMainWindow: public wxWindow { @@ -313,10 +419,12 @@ public: // notifications from wxDataViewModel bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item ); - bool ItemDeleted( const wxDataViewItem &item ); + bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item ); bool ItemChanged( const wxDataViewItem &item ); bool ValueChanged( const wxDataViewItem &item, unsigned int col ); bool Cleared(); + void Resort() + { g_model = GetOwner()->GetModel(); m_root->Resort(); UpdateDisplay(); } void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; } wxDataViewCtrl *GetOwner() { return m_owner; } @@ -346,8 +454,11 @@ public: int GetCountPerPage() const; int GetEndOfLastCol() const; unsigned int GetFirstVisibleRow() const; - unsigned int GetLastVisibleRow() const; - unsigned int GetRowCount() const; + //I change this method to un const because in the tree view, the displaying number of the tree are changing along with the expanding/collapsing of the tree nodes + unsigned int GetLastVisibleRow(); + unsigned int GetRowCount() ; + + wxDataViewItem GetSelection(); void Select( const wxArrayInt& aSelections ); void SelectAllRows( bool on ); @@ -376,6 +487,17 @@ public: //Methods for building the mapping tree void BuildTree( wxDataViewModel * model ); void DestroyTree(); +private: + wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ); + //We did not need this temporarily + //wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item ); + + int RecalculateCount() ; + + void OnExpanding( unsigned int row ); + void OnCollapsing( unsigned int row ); + + wxDataViewTreeNode * FindNode( const wxDataViewItem & item ); private: wxDataViewCtrl *m_owner; @@ -402,9 +524,12 @@ private: // the pen used to draw horiz/vertical rules wxPen m_penRule; + // the pen used to draw the expander and the lines + wxPen m_penExpander; + //This is the tree structure of the model - wxDataViewTreeNode * m_root; - unsigned int m_count; + wxDataViewTreeNode * m_root; + int m_count; private: DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow) DECLARE_EVENT_TABLE() @@ -422,14 +547,16 @@ public: virtual bool ItemAdded( const wxDataViewItem & parent, const wxDataViewItem & item ) { return m_mainWindow->ItemAdded( parent , item ); } - virtual bool ItemDeleted( const wxDataViewItem & item ) - { return m_mainWindow->ItemDeleted( item ); } + virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item ) + { return m_mainWindow->ItemDeleted( parent, item ); } virtual bool ItemChanged( const wxDataViewItem & item ) { return m_mainWindow->ItemChanged(item); } virtual bool ValueChanged( const wxDataViewItem & item , unsigned int col ) { return m_mainWindow->ValueChanged( item, col ); } virtual bool Cleared() { return m_mainWindow->Cleared(); } + virtual void Resort() + { m_mainWindow->Resort(); } wxDataViewMainWindow *m_mainWindow; }; @@ -507,14 +634,14 @@ bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const } bool wxDataViewTextRenderer::HasEditorCtrl() -{ +{ return true; } wxControl* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value ) { - return new wxTextCtrl( parent, wxID_ANY, value, + return new wxTextCtrl( parent, wxID_ANY, value, wxPoint(labelRect.x,labelRect.y), wxSize(labelRect.width,labelRect.height) ); } @@ -900,7 +1027,7 @@ void wxDataViewColumn::SetSortable( bool sortable ) m_flags |= wxDATAVIEW_COL_SORTABLE; else m_flags &= ~wxDATAVIEW_COL_SORTABLE; - + // Update header button if (GetOwner()) GetOwner()->OnColumnChange(); @@ -909,7 +1036,7 @@ void wxDataViewColumn::SetSortable( bool sortable ) void wxDataViewColumn::SetSortOrder( bool ascending ) { m_ascending = ascending; - + // Update header button if (GetOwner()) GetOwner()->OnColumnChange(); @@ -1051,6 +1178,7 @@ void wxDataViewHeaderWindowMSW::UpdateDisplay() // add the updated array of columns to the header control unsigned int cols = GetOwner()->GetColumnCount(); unsigned int added = 0; + wxDataViewModel * model = GetOwner()->GetModel(); for (unsigned int i = 0; i < cols; i++) { wxDataViewColumn *col = GetColumn( i ); @@ -1184,6 +1312,30 @@ bool wxDataViewHeaderWindowMSW::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARA case HDN_ITEMCLICK: { unsigned int idx = GetColumnIdxFromHeader(nmHDR); + wxDataViewModel * model = GetOwner()->GetModel(); + + if(nmHDR->iButton == 0) + { + wxDataViewColumn *col = GetColumn(idx); + if(col->IsSortable()) + { + if(model && model->GetSortingColumn() == idx) + { + bool order = col->IsSortOrderAscending(); + col->SetSortOrder(!order); + model->SetSortOrderAscending(!order); + } + else if(model) + { + model->SetSortingColumn(idx); + model->SetSortOrderAscending(true); + } + } + UpdateDisplay(); + if(model) + model->Resort(); + } + wxEventType evt = nmHDR->iButton == 0 ? wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK : wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK; @@ -1565,6 +1717,9 @@ void wxDataViewRenameTimer::Notify() // wxDataViewMainWindow //----------------------------------------------------------------------------- +//The tree building helper, declared firstly +void BuildTreeHelper( wxDataViewModel * model, wxDataViewItem & item, wxDataViewTreeNode * node); + int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 ) { if (row1 > row2) return 1; @@ -1620,9 +1775,14 @@ wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID i m_penRule = wxPen(GetRuleColour(), 1, wxSOLID); + //Here I compose a pen can draw black lines, maybe there are something system colour to use + m_penExpander = wxPen( wxColour(0,0,0), 1, wxSOLID ); //Some new added code to deal with the tree structure m_root = new wxDataViewTreeNode( NULL ); - m_count = 0 ; + m_root->SetHasChildren(true); + + //Make m_count = -1 will cause the class recaculate the real displaying number of rows. + m_count = -1 ; UpdateDisplay(); } @@ -1658,78 +1818,216 @@ void wxDataViewMainWindow::OnRenameTimer() GetOwner()->CalcScrolledPosition( labelRect.x, labelRect.y, &labelRect.x, &labelRect.y); - m_currentCol->GetRenderer()->StartEditing( m_currentRow, labelRect ); + wxDataViewItem item = GetItemByRow( m_currentRow ); + m_currentCol->GetRenderer()->StartEditing( item, labelRect ); } +//------------------------------------------------------------------ +// Helper class for do operation on the tree node +//------------------------------------------------------------------ class DoJob { public: DoJob(){}; virtual ~DoJob(){}; - virtual bool operator() ( wxDataViewTreeNode * node ) = 0 ; + //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 }; + virtual int operator() ( wxDataViewTreeNode * node ) = 0 ; + virtual int operator() ( void * n ) = 0; }; +#if 0 class ItemAddJob: public DoJob { public: - ItemAddJob( const wxDataViewItem & parent, const wxDataViewItem & item ) - { this->parent = parent ; this->item = item ; } + ItemAddJob( const wxDataViewItem & parent, const wxDataViewItem & item, int * count ) + { this->parent = parent ; this->item = item ; m_count = count; } virtual ~ItemAddJob(){}; - virtual bool operator() ( wxDataViewTreeNode * node ) + virtual int operator() ( wxDataViewTreeNode * node ) { if( node->GetItem() == parent ) { + node->SetHasChildren( true ); wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node ); - newnode->SetItem(item); - node->AppendChild( newnode); - return true; + newnode->SetItem(item); + node->AppendChild( newnode); + *m_count = -1; + return OK; } - return false; + return CONT; } + private: + int * m_count; wxDataViewItem parent, item; }; +#endif bool Walker( wxDataViewTreeNode * node, DoJob & func ) { - if( !node->HasChildren()) + if( node==NULL || !node->HasChildren()) return false; - wxDataViewTreeNodes nodes = node->GetChildren(); - int len = node->GetChildrenNumber(); - int i = 0 ; + wxDataViewTreeNodes nodes = node->GetNodes(); + wxDataViewTreeLeaves leaves = node->GetChildren(); + + int len_nodes = nodes.GetCount(); + int len = leaves.GetCount(); + int i = 0, nodes_i = 0; for( ; i < len ; i ++ ) { - wxDataViewTreeNode * n = nodes[i]; - if( func( n ) ) - return true; - if( Walker( n , func ) ) - return true; + void * n = leaves[i]; + if( nodes_i < len_nodes && n == nodes[nodes_i]->GetItem().GetID() ) + { + wxDataViewTreeNode * nd = nodes[nodes_i]; + nodes_i++; + + switch( func( nd ) ) + { + case DoJob::OK : + return true ; + case DoJob::IGR: + continue; + case DoJob::CONT: + default: + ; + } + + if( Walker( nd , 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) { - ItemAddJob job( parent, item); - Walker( m_root , job); + g_model = GetOwner()->GetModel(); + + wxDataViewTreeNode * node; + node = FindNode(parent); + + if( node == NULL ) + return false; + + node->SetHasChildren( true ); + + if( g_model->IsContainer( item ) ) + { + wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node ); + newnode->SetItem(item); + node->AddNode( newnode); + } + else + node->AddLeaf( item.GetID() ); + + node->ChangeSubTreeCount(1); + + m_count = -1; UpdateDisplay(); return true; } -bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem & item) +#if 0 +class ItemDeleteJob: public DoJob +{ +public: + ItemDeleteJob( const wxDataViewItem & item, int * count ) { m_item = item; m_count = count; } + virtual ~ItemDeleteJob(){} + virtual int operator() ( wxDataViewTreeNode * node ) + { + if( node->GetItem() == m_item ) + { + node->GetParent()->GetChildren().Remove( node ); + delete node; + *m_count = -1; + return DoJob::OK; + } + return DoJob::CONT; + } + +private: + int * m_count; + wxDataViewItem m_item; +}; +#endif + +void DestroyTreeHelper( wxDataViewTreeNode * node); + +bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent, + const wxDataViewItem& item) { + g_model = GetOwner()->GetModel(); + + wxDataViewTreeNode * node; + node = FindNode(parent); + + if( node == NULL || node->GetChildren().Index( item.GetID() ) == wxNOT_FOUND ) + { + return false; + } + + int sub = -1; + node->GetChildren().Remove( item.GetID() ); + if( GetOwner()->GetModel()->IsContainer( item ) ) + { + wxDataViewTreeNode * n = NULL; + wxDataViewTreeNodes nodes = node->GetNodes(); + int len = nodes.GetCount(); + for( int i = 0 ; i < len; i ++) + { + if( nodes[i]->GetItem() == item ) + { + n = nodes[i]; + break; + } + } + + if (!n) + return false; + + node->GetNodes().Remove( n ); + sub -= n->GetSubTreeCount(); + DestroyTreeHelper(n); + } + + if( node->GetChildrenNumber() == 0) + node->SetHasChildren( false ); + + //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; + UpdateDisplay(); return true; } bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item) { - UpdateDisplay(); + g_model = GetOwner()->GetModel(); + + unsigned int row = GetRowByItem(item); + RefreshRow( row ); return true; } @@ -1744,12 +2042,18 @@ bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned i return true; */ - UpdateDisplay(); + g_model = GetOwner()->GetModel(); + + unsigned int row = GetRowByItem(item); + RefreshRow( row ); return true; } bool wxDataViewMainWindow::Cleared() { + g_model = GetOwner()->GetModel(); + + DestroyTree(); UpdateDisplay(); return true; } @@ -1814,7 +2118,7 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) unsigned int item_start = wxMax( 0, (update.y / m_lineHeight) ); unsigned int item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1), - (int)(m_count- item_start) ); + (int)(GetRowCount( )- item_start) ); unsigned int item_last = item_start + item_count; // compute which columns needs to be redrawn @@ -1925,16 +2229,58 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) { // get the cell value and set it into the renderer wxVariant value; - wxDataViewItem dataitem = GetItemByRow(item); - model->GetValue( value, dataitem, col->GetModelColumn()); + wxDataViewTreeNode * node = GetTreeNodeByRow(item); + if( node == NULL ) + { + continue; + } + + wxDataViewItem dataitem = node->GetItem(); + model->GetValue( value, dataitem, col->GetModelColumn()); cell->SetValue( value ); // update the y offset cell_rect.y = item * m_lineHeight; + //Draw the expander here. + int indent = node->GetIndentLevel(); + if( col->GetModelColumn() == GetOwner()->GetExpanderColumn() ) + { + //Calculate the indent first + indent = cell_rect.x + GetOwner()->GetIndent() * indent; + + int expander_width = m_lineHeight - 2*EXPANDER_MARGIN; + // change the cell_rect.x to the appropriate pos + int expander_x = indent + EXPANDER_MARGIN , expander_y = cell_rect.y + EXPANDER_MARGIN ; + indent = indent + m_lineHeight ; //try to use the m_lineHeight as the expander space + dc.SetPen( m_penExpander ); + dc.SetBrush( wxNullBrush ); + if( node->HasChildren() ) + { + //dc.DrawRoundedRectangle( expander_x,expander_y,expander_width,expander_width, 1.0); + //dc.DrawLine( expander_x + 2 , expander_y + expander_width/2, expander_x + expander_width - 2, expander_y + expander_width/2 ); + wxRect rect( expander_x , expander_y, expander_width, expander_width); + if( node->IsOpen() ) + wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, wxCONTROL_EXPANDED ); + else + wxRendererNative::Get().DrawTreeItemButton( this, dc, rect ); + } + else + { + // I am wandering whether we should draw dot lines between tree nodes + delete node; + //Yes, if the node does not have any child, it must be a leaf which mean that it is a temporarily created by GetTreeNodeByRow + } + + //force the expander column to left-center align + cell->SetAlignment( wxALIGN_CENTER_VERTICAL ); + } + + // cannot be bigger than allocated space wxSize size = cell->GetSize(); - size.x = wxMin( size.x + 2*PADDING_RIGHTLEFT, cell_rect.width ); + // Because of the tree structure indent, here we should minus the width of the cell for drawing + size.x = wxMin( size.x + 2*PADDING_RIGHTLEFT, cell_rect.width - indent ); size.y = wxMin( size.y + 2*PADDING_TOPBOTTOM, cell_rect.height ); wxRect item_rect(cell_rect.GetTopLeft(), size); @@ -1962,6 +2308,9 @@ void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) item_rect.width = size.x - 2 * PADDING_RIGHTLEFT; item_rect.height = size.y - 2 * PADDING_TOPBOTTOM; + //Here we add the tree indent + item_rect.x += indent; + int state = 0; if (m_selection.Index(item) != wxNOT_FOUND) state |= wxDATAVIEW_CELL_SELECTED; @@ -2012,7 +2361,7 @@ unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const return y / m_lineHeight; } -unsigned int wxDataViewMainWindow::GetLastVisibleRow() const +unsigned int wxDataViewMainWindow::GetLastVisibleRow() { wxSize client_size = GetClientSize(); m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, @@ -2021,10 +2370,18 @@ unsigned int wxDataViewMainWindow::GetLastVisibleRow() const return wxMin( GetRowCount()-1, ((unsigned)client_size.y/m_lineHeight)+1 ); } -unsigned int wxDataViewMainWindow::GetRowCount() const +unsigned int wxDataViewMainWindow::GetRowCount() { + if ( m_count == -1 ) + { + m_count = RecalculateCount(); + int width, height; + GetVirtualSize( &width, &height ); + height = m_count * m_lineHeight; + + SetVirtualSize( width, height ); + } return m_count; - //return wx_const_cast(wxDataViewCtrl*, GetOwner())->GetModel()->GetRowCount(); } void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row ) @@ -2237,48 +2594,40 @@ wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const return rect; } -/* -static int tree_walk_current ; -wxDataViewTreeNode * TreeWalk( unsigned int row , wxDataViewTreeNode * node ) -{ - wxDataViewTreeNode * ret ; - if( tree_walk_current == row ) - return node; - - if( node->HasChildren() && node->IsOpen()) - { - wxDataViewTreeNodes nodes = node->GetChildren(); - int len = nodes.GetCount(); - int i = 0 ; - for( ; i < len; i ++) - { - tree_walk_current ++; - ret = TreeWalk( row, nodes[i] ); - if( ret != NULL ) - return ret; - } - } - return NULL; -} -*/ - class RowToItemJob: public DoJob { public: RowToItemJob( unsigned int row , int current ) { this->row = row; this->current = current ;} virtual ~RowToItemJob(){}; - virtual bool operator() ( wxDataViewTreeNode * node ) - { - if( current == row) - { - ret = node->GetItem() ; - return true; - } - current ++; - return false; - } + virtual int operator() ( wxDataViewTreeNode * node ) + { + current ++; + if( current == static_cast(row)) + { + ret = node->GetItem() ; + return DoJob::OK; + } + + if( node->GetSubTreeCount() + current < static_cast(row) ) + { + current += node->GetSubTreeCount(); + return DoJob::IGR; + } + else + return DoJob::CONT; + } + virtual int operator() ( void * n ) + { + current ++; + if( current == static_cast(row)) + { + ret = wxDataViewItem( n ) ; + return DoJob::OK; + } + return DoJob::CONT; + } wxDataViewItem GetResult(){ return ret; } private: unsigned int row; @@ -2288,73 +2637,325 @@ private: wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) { - RowToItemJob job( row, 0 ); + RowToItemJob job( row, -1 ); Walker( m_root , job ); return job.GetResult(); } -class ItemToRowJob : public DoJob +class RowToTreeNodeJob: public DoJob { public: - ItemToRowJob(const wxDataViewItem & item){ this->item = item ; } - virtual ~ItemToRowJob(){}; + 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 ) + { + current ++; + if( current == static_cast(row)) + { + ret = node ; + return DoJob::OK; + } - virtual bool operator() ( wxDataViewTreeNode * node) + if( node->GetSubTreeCount() + current < static_cast(row) ) { - ret ++; - if( node->GetItem() == item ) - return true; + current += node->GetSubTreeCount(); + return DoJob::IGR; + } + else + { + parent = node; + return DoJob::CONT; + } - return false; + } + + virtual int operator() ( void * n ) + { + current ++; + if( current == static_cast(row)) + { + ret = new wxDataViewTreeNode( parent ) ; + ret->SetItem( wxDataViewItem( n )); + ret->SetHasChildren(false); + return DoJob::OK; } - int GetResult(){ return ret; } + return DoJob::CONT; + } + wxDataViewTreeNode * GetResult(){ return ret; } private: + unsigned int row; + int current ; + wxDataViewTreeNode * ret; + wxDataViewTreeNode * parent ; +}; + + +wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) +{ + RowToTreeNodeJob job( row , -1, m_root ); + Walker( m_root , job ); + return job.GetResult(); +} + +#if 0 +class CountJob : public DoJob +{ +public: + CountJob(){ count = 0 ; } + virtual ~CountJob(){}; + + virtual int operator () ( wxDataViewTreeNode * node ) + { + count ++; + if ( node->IsOpen()) + return DoJob::CONT; + else + return DoJob::IGR; + } + + unsigned int GetResult() + { + return count ; + } +private: + unsigned int count; +}; +#endif + +void wxDataViewMainWindow::OnExpanding( unsigned int row ) +{ + wxDataViewTreeNode * node = GetTreeNodeByRow(row); + if( node != NULL ) + { + if( node->HasChildren()) + if( !node->IsOpen()) + { + node->ToggleOpen(); + //Here I build the children of current node + if( node->GetChildrenNumber() == 0 ) + BuildTreeHelper(GetOwner()->GetModel(), node->GetItem(), node); + m_count = -1; + UpdateDisplay(); + } + else + { + SelectRow( row, false ); + SelectRow( row + 1, true ); + ChangeCurrentRow( row + 1 ); + } + else + delete node; + } +} + +void wxDataViewMainWindow::OnCollapsing(unsigned int row) +{ + wxDataViewTreeNode * node = GetTreeNodeByRow(row); + if( node != NULL ) + { + wxDataViewTreeNode * nd = node; + + if( node->HasChildren() && node->IsOpen() ) + { + node->ToggleOpen(); + m_count = -1; + UpdateDisplay(); + //RefreshRows(row,GetLastVisibleRow()); + } + else + { + node = node->GetParent(); + if( node != NULL ) + { + int parent = GetRowByItem( node->GetItem()) ; + SelectRow( row, false); + SelectRow(parent , true ); + ChangeCurrentRow( parent ); + } + } + if( !nd->HasChildren()) + delete nd; + } +} + +wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item ) +{ + wxDataViewModel * model = GetOwner()->GetModel(); + if( model == NULL ) + return NULL; + + //Compose the a parent-chain of the finding item + ItemList list; + list.DeleteContents( true ); + wxDataViewItem it( item ); + while( it.IsOk() ) + { + wxDataViewItem * pItem = new wxDataViewItem( it ); + list.Insert( pItem ); + it = model->GetParent( it ); + } + + //Find the item along the parent-chain. + //This algorithm is designed to speed up the node-finding method + bool found = true; + wxDataViewTreeNode * node = m_root; + for( ItemList::Node * n = list.GetFirst(); n; n = n->GetNext() ) + { + if( node->HasChildren() ) + { + if( node->GetChildrenNumber() == 0 ) + BuildTreeHelper(model, node->GetItem(), node); + + int len = node->GetNodeNumber(); + wxDataViewTreeNodes nodes = node->GetNodes(); + int j = 0; + for( ; j < len; j ++) + { + if( nodes[j]->GetItem() == *(n->GetData())) + { + node = nodes[j]; + break; + } + } + // Whenever we can't find the node in any level, return NULL to indicate the item can't be found + if( j == len ) + { + found = false; + return NULL; + } + } + else + return NULL; + } + return node; +} + +int wxDataViewMainWindow::RecalculateCount() +{ + return m_root->GetSubTreeCount(); +} + +class ItemToRowJob : public DoJob +{ +public: + ItemToRowJob(const wxDataViewItem & item, ItemList::Node * node ) + { this->item = item ; ret = 0 ; nd = node ; } + virtual ~ItemToRowJob(){}; + + virtual int operator() ( wxDataViewTreeNode * node) + { + ret ++; + if( node->GetItem() == item ) + { + return DoJob::OK; + } + + if( nd && node->GetItem() == *(nd->GetData())) + { + nd = nd->GetNext(); + return DoJob::CONT; + } + else + { + ret += node->GetSubTreeCount(); + return DoJob::IGR; + } + + } + + 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(){ return ret -1 ; } +private: + ItemList::Node * nd; wxDataViewItem item; int ret; + }; unsigned int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) { - ItemToRowJob job( item ); + wxDataViewModel * model = GetOwner()->GetModel(); + if( model == NULL ) + return 0; + + //Compose the a parent-chain of the finding item + ItemList list; + list.DeleteContents( true ); + wxDataViewItem it( item ); + while( it.IsOk() ) + { + wxDataViewItem * pItem = new wxDataViewItem( it ); + list.Insert( pItem ); + it = model->GetParent( it ); + } + + ItemToRowJob job( item, list.GetFirst() ); Walker(m_root , job ); return job.GetResult(); } -unsigned int BuildTreeHelper( wxDataViewModel * model, wxDataViewItem & item, wxDataViewTreeNode * node) +void BuildTreeHelper( wxDataViewModel * model, wxDataViewItem & item, wxDataViewTreeNode * node) { - int sum = 0 ; - if( !model->HasChildren( item ) ) - return 0; - + if( !model->IsContainer( item ) ) + return ; + wxDataViewItem i = model->GetFirstChild( item ); + int num = 0; while( i.IsOk() ) { - wxDataViewTreeNode * n = new wxDataViewTreeNode( node ); - n->SetItem(i); - node->AppendChild(n); - int num = BuildTreeHelper( model, i, n) + 1; - sum += num ; - i = model->GetNextSibling( i ); + num ++; + if( model->IsContainer( i ) ) + { + wxDataViewTreeNode * n = new wxDataViewTreeNode( node ); + n->SetItem(i); + n->SetHasChildren( true ) ; + node->AddNode( n ); + } + else + { + node->AddLeaf( i.GetID() ); + } + i = model->GetNextSibling( i ); } - return sum; + node->SetSubTreeCount( num ); + wxDataViewTreeNode * n = node->GetParent(); + if( n != NULL) + n->ChangeSubTreeCount(num); + } void wxDataViewMainWindow::BuildTree(wxDataViewModel * model) { //First we define a invalid item to fetch the top-level elements wxDataViewItem item; - m_count = BuildTreeHelper( model, item, m_root); + g_model = GetOwner()->GetModel(); + BuildTreeHelper( model, item, m_root); + m_count = -1 ; } void DestroyTreeHelper( wxDataViewTreeNode * node ) { - if( node->HasChildren() ) + if( node->GetNodeNumber() != 0 ) { - int len = node->GetChildrenNumber(); - int i = 0 ; - wxDataViewTreeNodes nodes = node->GetChildren(); - for( ; i < len; i ++ ) + int len = node->GetNodeNumber(); + int i = 0 ; + wxDataViewTreeNodes nodes = node->GetNodes(); + for( ; i < len; i ++ ) { DestroyTreeHelper(nodes[i]); } @@ -2365,6 +2966,7 @@ void DestroyTreeHelper( wxDataViewTreeNode * node ) void wxDataViewMainWindow::DestroyTree() { DestroyTreeHelper(m_root); + m_root->SetSubTreeCount(0); m_count = 0 ; } @@ -2403,7 +3005,13 @@ void wxDataViewMainWindow::OnChar( wxKeyEvent &event ) if ( m_currentRow < GetRowCount() - 1 ) OnArrowChar( m_currentRow + 1, event ); break; - + //Add the process for tree expanding/collapsing + case WXK_LEFT: + OnCollapsing(m_currentRow); + break; + case WXK_RIGHT: + OnExpanding( m_currentRow); + break; case WXK_END: if (!IsEmpty()) OnArrowChar( GetRowCount() - 1, event ); @@ -2527,13 +3135,13 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) { if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE) { + wxDataViewItem item = GetItemByRow(current); wxVariant value; - model->GetValue( value, col->GetModelColumn(), current ); + model->GetValue( value, item, col->GetModelColumn() ); cell->SetValue( value ); wxRect cell_rect( xpos, current * m_lineHeight, col->GetWidth(), m_lineHeight ); - wxDataViewItem dataitem = GetItemByRow(current); - cell->Activate( cell_rect, model, dataitem, col->GetModelColumn() ); + cell->Activate( cell_rect, model, item, col->GetModelColumn() ); } return; } @@ -2554,7 +3162,26 @@ void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) SelectRow( m_lineSelectSingleOnUp, true ); } - if (m_lastOnSame) + //Process the event of user clicking the expander + bool expander = false; + wxDataViewTreeNode * node = GetTreeNodeByRow(current); + if( node!=NULL && node->HasChildren() ) + { + int indent = node->GetIndentLevel(); + indent = GetOwner()->GetIndent()*indent; + wxRect rect( xpos + indent + EXPANDER_MARGIN, current * m_lineHeight + EXPANDER_MARGIN, m_lineHeight-2*EXPANDER_MARGIN,m_lineHeight-2*EXPANDER_MARGIN); + if( rect.Contains( x, y) ) + { + expander = true; + if( node->IsOpen() ) + OnCollapsing(current); + else + OnExpanding( current ); + } + } + + //If the user click the expander, we do not do editing even if the column with expander are editable + if (m_lastOnSame && !expander ) { if ((col == m_currentCol) && (current == m_currentRow) && (cell->GetMode() == wxDATAVIEW_CELL_EDITABLE) ) @@ -2692,6 +3319,14 @@ void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event ) event.Skip(); } +wxDataViewItem wxDataViewMainWindow::GetSelection() +{ + if( m_selection.GetCount() != 1 ) + return wxDataViewItem(); + + return GetItemByRow( m_selection.Item(0)); +} + //----------------------------------------------------------------------------- // wxDataViewCtrl //----------------------------------------------------------------------------- @@ -2810,6 +3445,22 @@ void wxDataViewCtrl::OnColumnChange() m_clientArea->UpdateDisplay(); } + +void wxDataViewCtrl::DoSetExpanderColumn() +{ + m_clientArea->UpdateDisplay(); +} + +void wxDataViewCtrl::DoSetIndent() +{ + m_clientArea->UpdateDisplay(); +} + +wxDataViewItem wxDataViewCtrl::GetSelection() +{ + return m_clientArea->GetSelection(); +} + /******************************************************************** void wxDataViewCtrl::SetSelection( int row ) {