X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/aba9bfd00ad88d9005809a217069bc41b896a4ad..c471f7e18f2b6b14c660d0307a9a32f1194b2e2d:/src/generic/datavgen.cpp diff --git a/src/generic/datavgen.cpp b/src/generic/datavgen.cpp index 22efe3dfd2..5caf300891 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,17 +59,14 @@ 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 //----------------------------------------------------------------------------- -#define USE_NATIVE_HEADER_WINDOW 1 +#define USE_NATIVE_HEADER_WINDOW 0 // NB: for some reason, this class must be dllexport'ed or we get warnings from // MSVC in DLL build @@ -182,7 +181,7 @@ public: } virtual void UpdateDisplay() { Refresh(); } - + // event handlers: void OnPaint( wxPaintEvent &event ); @@ -254,52 +253,161 @@ 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; + wxDataViewTreeNode( wxDataViewTreeNode * parent = NULL ) + :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 children.GetCount(); } + 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 ; + } + + 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; +static unsigned int g_column; +static bool g_asending; + +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); class wxDataViewMainWindow: public wxWindow { @@ -312,12 +420,32 @@ public: virtual ~wxDataViewMainWindow(); // notifications from wxDataViewModel + void SendModelEvent( wxEventType type, const wxDataViewItem & item); 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() + { + SortPrepare(); + m_root->Resort(); + UpdateDisplay(); + } + void SortPrepare() + { + g_model = GetOwner()->GetModel(); + g_column = GetOwner()->GetSortingColumn(); + wxDataViewColumn * col = GetOwner()->GetColumn(g_column); + if( !col ) + { + g_asending = true; + return; + } + g_asending = col->IsSortOrderAscending(); + } + void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; } wxDataViewCtrl *GetOwner() { return m_owner; } const wxDataViewCtrl *GetOwner() const { return m_owner; } @@ -336,6 +464,7 @@ public: void OnRenameTimer(); void ScrollWindow( int dx, int dy, const wxRect *rect = NULL ); + void ScrollTo( int rows ); bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; } void ChangeCurrentRow( unsigned int row ); @@ -346,9 +475,13 @@ 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(); + wxDataViewSelection GetSelections(){ return m_selection; } + void SetSelections( const wxDataViewSelection & sel ) { m_selection = sel; UpdateDisplay(); } void Select( const wxArrayInt& aSelections ); void SelectAllRows( bool on ); void SelectRow( unsigned int row, bool on ); @@ -371,11 +504,25 @@ public: //Some useful functions for row and item mapping wxDataViewItem GetItemByRow( unsigned int row ); - unsigned int GetRowByItem( const wxDataViewItem & item ); + int GetRowByItem( const wxDataViewItem & item ); //Methods for building the mapping tree void BuildTree( wxDataViewModel * model ); void DestroyTree(); + void HitTest( const wxPoint & point, wxDataViewItem & item, unsigned int & column ); + wxRect GetItemRect( const wxDataViewItem & item, unsigned int column ); +private: + wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ); + //We did not need this temporarily + //wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item ); + + int RecalculateCount() ; + + wxDataViewEvent SendExpanderEvent( wxEventType type, const wxDataViewItem & item ); + void OnExpanding( unsigned int row ); + void OnCollapsing( unsigned int row ); + + wxDataViewTreeNode * FindNode( const wxDataViewItem & item ); private: wxDataViewCtrl *m_owner; @@ -402,9 +549,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 +572,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 +659,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 +1052,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 +1061,7 @@ void wxDataViewColumn::SetSortable( bool sortable ) void wxDataViewColumn::SetSortOrder( bool ascending ) { m_ascending = ascending; - + // Update header button if (GetOwner()) GetOwner()->OnColumnChange(); @@ -1051,6 +1203,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 ); @@ -1063,6 +1216,16 @@ void wxDataViewHeaderWindowMSW::UpdateDisplay() hdi.cxy = col->GetWidth(); hdi.cchTextMax = sizeof(hdi.pszText)/sizeof(hdi.pszText[0]); hdi.fmt = HDF_LEFT | HDF_STRING; + //hdi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP); + + //sorting support + if(model && m_owner->GetSortingColumn() == i) + { + //The Microsoft Comctrl32.dll 6.0 support SORTUP/SORTDOWN, but they are not default + //see http://msdn2.microsoft.com/en-us/library/ms649534.aspx for more detail + //hdi.fmt |= model->GetSortOrderAscending()? HDF_SORTUP:HDF_SORTDOWN; + ; + } // lParam is reserved for application's use: // we store there the column index to use it later in MSWOnNotify @@ -1184,6 +1347,28 @@ 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 && m_owner->GetSortingColumn() == idx) + { + bool order = col->IsSortOrderAscending(); + col->SetSortOrder(!order); + } + else if(model) + { + m_owner->SetSortingColumn(idx); + } + } + UpdateDisplay(); + if(model) + model->Resort(); + } + wxEventType evt = nmHDR->iButton == 0 ? wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK : wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK; @@ -1340,7 +1525,7 @@ void wxGenericDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) int ch = h; wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE; - if (col->IsSortable()) + if (col->IsSortable() && GetOwner()->GetSortingColumn() == i) { if (col->IsSortOrderAscending()) sortArrow = wxHDR_SORT_ICON_UP; @@ -1493,10 +1678,35 @@ void wxGenericDataViewHeaderWindow::OnMouse( wxMouseEvent &event ) } else // click on a column { + wxDataViewModel * model = GetOwner()->GetModel(); wxEventType evt = event.LeftDown() ? wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK : wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK; SendEvent(evt, m_column); + + //Left click the header + if(event.LeftDown()) + { + wxDataViewColumn *col = GetColumn(m_column); + if(col->IsSortable()) + { + unsigned int colnum = m_owner->GetSortingColumn(); + if(model && static_cast(colnum) == m_column) + { + bool order = col->IsSortOrderAscending(); + col->SetSortOrder(!order); + } + else if(model) + { + m_owner->SetSortingColumn(m_column); + } + } + UpdateDisplay(); + if(model) + model->Resort(); + //Send the column sorted event + SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, m_column); + } } } else if (event.Moving()) @@ -1565,6 +1775,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 +1833,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,82 +1876,186 @@ 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; }; -class ItemAddJob: public DoJob +bool Walker( wxDataViewTreeNode * node, DoJob & func ) { -public: - ItemAddJob( const wxDataViewItem & parent, const wxDataViewItem & item ) - { this->parent = parent ; this->item = item ; } - virtual ~ItemAddJob(){}; + if( node==NULL || !node->HasChildren()) + return false; - virtual bool operator() ( wxDataViewTreeNode * node ) + switch( func( node ) ) { - if( node->GetItem() == parent ) - { - wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node ); - newnode->SetItem(item); - node->AppendChild( newnode); - return true; - } - return false; + case DoJob::OK : + return true ; + case DoJob::IGR: + return false; + case DoJob::CONT: + default: + ; } -private: - wxDataViewItem parent, item; -}; -bool Walker( wxDataViewTreeNode * node, DoJob & func ) -{ - if( !node->HasChildren()) - return false; + wxDataViewTreeNodes nodes = node->GetNodes(); + wxDataViewTreeLeaves leaves = node->GetChildren(); + + int len_nodes = nodes.GetCount(); + int len = leaves.GetCount(); + int i = 0, nodes_i = 0; - wxDataViewTreeNodes nodes = node->GetChildren(); - int len = node->GetChildrenNumber(); - int 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++; + + 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; } +void wxDataViewMainWindow::SendModelEvent( wxEventType type, const wxDataViewItem & item ) +{ + wxWindow *parent = GetParent(); + wxDataViewEvent le(type, parent->GetId()); + + le.SetEventObject(parent); + le.SetModel(GetOwner()->GetModel()); + le.SetItem( item ); + parent->GetEventHandler()->ProcessEvent(le); +} bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item) { - ItemAddJob job( parent, item); - Walker( m_root , job); + SortPrepare(); + + wxDataViewTreeNode * node; + node = FindNode(parent); + SendModelEvent(wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_ADDED, item ); + + if( node == NULL ) + return false; + + node->SetHasChildren( true ); + + if( g_model->IsContainer( item ) ) + { + wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node ); + newnode->SetItem(item); + newnode->SetHasChildren( true ); + node->AddNode( newnode); + } + else + node->AddLeaf( item.GetID() ); + + node->ChangeSubTreeCount(1); + + m_count = -1; UpdateDisplay(); + return true; } -bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem & item) +void DestroyTreeHelper( wxDataViewTreeNode * node); + +bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent, + const wxDataViewItem& item) { + SortPrepare(); + + wxDataViewTreeNode * node; + node = FindNode(parent); + SendModelEvent(wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_DELETED, item); + + 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(); + SortPrepare(); + g_model->Resort(); + + SendModelEvent(wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_CHANGED,item); + return true; } -bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int WXUNUSED(col) ) +bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int col ) { // NOTE: to be valid, we cannot use e.g. INT_MAX - 1 /*#define MAX_VIRTUAL_WIDTH 100000 @@ -1744,13 +2066,35 @@ bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned i return true; */ - UpdateDisplay(); + SortPrepare(); + g_model->Resort(); + + //Send event + wxWindow *parent = GetParent(); + wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_MODEL_VALUE_CHANGED, parent->GetId()); + le.SetEventObject(parent); + le.SetModel(GetOwner()->GetModel()); + le.SetItem(item); + le.SetColumn(col); + le.SetDataViewColumn(GetOwner()->GetColumn(col)); + parent->GetEventHandler()->ProcessEvent(le); + return true; } bool wxDataViewMainWindow::Cleared() { + SortPrepare(); + + DestroyTree(); UpdateDisplay(); + + wxWindow *parent = GetParent(); + wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_MODEL_CLEARED, parent->GetId()); + le.SetEventObject(parent); + le.SetModel(GetOwner()->GetModel()); + parent->GetEventHandler()->ProcessEvent(le); + return true; } @@ -1796,6 +2140,14 @@ void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect ) GetOwner()->m_headerArea->ScrollWindow( dx, 0 ); } +void wxDataViewMainWindow::ScrollTo( int rows ) +{ + int x, y; + m_owner->GetScrollPixelsPerUnit( &x, &y ); + int sc = rows*m_lineHeight/y; + m_owner->Scroll(0, sc ); +} + void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) { wxDataViewModel *model = GetOwner()->GetModel(); @@ -1814,7 +2166,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 +2277,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 +2356,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 +2409,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 +2418,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 +2642,50 @@ 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 + { + //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) + { + int index = static_cast(row) - current - 1; + ret = node->GetChildren().Item( index ); + return DoJob::OK; + } + 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 +2695,380 @@ private: wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) { - RowToItemJob job( row, 0 ); + RowToItemJob job( row, -2 ); 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; + } + + if( node->GetSubTreeCount() + current < static_cast(row) ) + { + current += node->GetSubTreeCount(); + return DoJob::IGR; + } + else + { + parent = node; + //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) + { + 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; + } + + + } + + 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; + } + + 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 , -2, m_root ); + Walker( m_root , job ); + return job.GetResult(); +} + +wxDataViewEvent wxDataViewMainWindow::SendExpanderEvent( wxEventType type, const wxDataViewItem & item ) +{ + wxWindow *parent = GetParent(); + wxDataViewEvent le(type, parent->GetId()); + + le.SetEventObject(parent); + le.SetModel(GetOwner()->GetModel()); + le.SetItem( item ); + + parent->GetEventHandler()->ProcessEvent(le); + return le; +} + +void wxDataViewMainWindow::OnExpanding( unsigned int row ) +{ + wxDataViewTreeNode * node = GetTreeNodeByRow(row); + if( node != NULL ) + { + if( node->HasChildren()) + { + if( !node->IsOpen()) + { + wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING,node->GetItem()); + //Check if the user prevent expanding + if( e.GetSkipped() ) + return; + + node->ToggleOpen(); + //Here I build the children of current node + if( node->GetChildrenNumber() == 0 ) + BuildTreeHelper(GetOwner()->GetModel(), node->GetItem(), node); + m_count = -1; + UpdateDisplay(); + //Send the expanded event + SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem()); + } + 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; - virtual bool operator() ( wxDataViewTreeNode * node) + if( node->HasChildren() && node->IsOpen() ) { - ret ++; - if( node->GetItem() == item ) - return true; + wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem()); + if( e.GetSkipped() ) + return; + node->ToggleOpen(); + m_count = -1; + UpdateDisplay(); + SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,nd->GetItem()); + } + else + { + node = node->GetParent(); + if( node != NULL ) + { + int parent = GetRowByItem( node->GetItem() ) ; + if( parent >= 0 ) + { + SelectRow( row, false); + SelectRow(parent , true ); + ChangeCurrentRow( parent ); + } + } + } + if( !nd->HasChildren()) + delete nd; + } +} - return false; +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 + 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); + + wxDataViewTreeNodes nodes = node->GetNodes(); + //The wxSortedArray search a node in binary search, so using Item() is more efficient + wxDataViewTreeNode temp; + temp.SetItem(*(n->GetData())); + int index = nodes.Index( &temp ); + if( index == wxNOT_FOUND ) + return NULL; + node = nodes[index]; } + else + return NULL; + } + return node; +} + +void wxDataViewMainWindow::HitTest( const wxPoint & point, wxDataViewItem & item, unsigned int & column ) +{ + unsigned int cols = GetOwner()->GetColumnCount(); + unsigned int colnum = 0; + unsigned int x_start = 0; + int x, y; + m_owner->CalcUnscrolledPosition( point.x, point.y, &x, &y ); + for (x_start = 0; colnum < cols; colnum++) + { + wxDataViewColumn *col = GetOwner()->GetColumn(colnum); + if (col->IsHidden()) + continue; // skip it! + + unsigned int w = col->GetWidth(); + if (x_start+w >= (unsigned int)x) + break; + + x_start += w; + } + + column = colnum; + item = GetItemByRow( y/m_lineHeight ); +} + +wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, unsigned int column ) +{ + int row = GetRowByItem(item); + int y = row*m_lineHeight; + int h = m_lineHeight; + int x = 0; + wxDataViewColumn *col = NULL; + for( int i = 0, cols = GetOwner()->GetColumnCount(); i < cols; i ++ ) + { + col = GetOwner()->GetColumn( i ); + x += col->GetWidth(); + if( i == column - 1 ) + break; + } + int w = col->GetWidth(); + m_owner->CalcScrolledPosition( x, y, &x, &y ); + return wxRect(x, y, w, h); +} + +int wxDataViewMainWindow::RecalculateCount() +{ + return m_root->GetSubTreeCount(); +} + +class ItemToRowJob : public DoJob +{ +public: + ItemToRowJob(const wxDataViewItem & item, ItemList::Node * node ) + { this->item = item ; ret = -1 ; nd = node ; } + virtual ~ItemToRowJob(){}; + + //Maybe binary search will help to speed up this process + 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; + } - int GetResult(){ return ret; } + } + + 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) +int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) { - ItemToRowJob job( item ); + wxDataViewModel * model = GetOwner()->GetModel(); + if( model == NULL ) + return 0; + + if( !item.IsOk() ) + return -1; + + //Compose the a parent-chain of the finding item + ItemList list; + wxDataViewItem * pItem = NULL; + list.DeleteContents( true ); + wxDataViewItem it( item ); + while( it.IsOk() ) + { + pItem = new wxDataViewItem( it ); + list.Insert( pItem ); + it = model->GetParent( it ); + } + pItem = new wxDataViewItem( ); + list.Insert( pItem ); + + 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); + SortPrepare(); + 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 +3079,7 @@ void DestroyTreeHelper( wxDataViewTreeNode * node ) void wxDataViewMainWindow::DestroyTree() { DestroyTreeHelper(m_root); + m_root->SetSubTreeCount(0); m_count = 0 ; } @@ -2403,7 +3118,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 +3248,23 @@ 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() ); + + wxWindow *parent = GetParent(); + wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId()); + + le.SetEventObject(parent); + le.SetColumn(col->GetModelColumn()); + le.SetDataViewColumn(col); + le.SetModel(GetOwner()->GetModel()); + + parent->GetEventHandler()->ProcessEvent(le); } return; } @@ -2554,7 +3285,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 +3442,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,49 +3568,179 @@ void wxDataViewCtrl::OnColumnChange() m_clientArea->UpdateDisplay(); } -/******************************************************************** -void wxDataViewCtrl::SetSelection( int row ) + +void wxDataViewCtrl::DoSetExpanderColumn() +{ + m_clientArea->UpdateDisplay(); +} + +void wxDataViewCtrl::DoSetIndent() +{ + m_clientArea->UpdateDisplay(); +} + +//Selection code with wxDataViewItem as parameters +wxDataViewItem wxDataViewCtrl::GetSelection() +{ + return m_clientArea->GetSelection(); +} + +int wxDataViewCtrl::GetSelections( wxDataViewItemArray & 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( m_clientArea->GetItemByRow( row ) ); + } + return len; +} + +void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel ) { - m_clientArea->SelectRow(row, true); + wxDataViewSelection selection(wxDataViewSelectionCmp) ; + int len = sel.GetCount(); + for( int i = 0; i < len; i ++ ) + { + int row = m_clientArea->GetRowByItem( sel[i] ); + if( row >= 0 ) + selection.Add( static_cast(row) ); + } + m_clientArea->SetSelections( selection ); } -void wxDataViewCtrl::SetSelectionRange( unsigned int from, unsigned int to ) +void wxDataViewCtrl::Select( const wxDataViewItem & item ) { - m_clientArea->SelectRows(from, to, true); + int row = m_clientArea->GetRowByItem( item ); + if( row >= 0 ) + m_clientArea->SelectRow(row, true); } -void wxDataViewCtrl::SetSelections( const wxArrayInt& aSelections ) +void wxDataViewCtrl::Unselect( const wxDataViewItem & item ) { - m_clientArea->Select(aSelections); + int row = m_clientArea->GetRowByItem( item ); + if( row >= 0 ) + m_clientArea->SelectRow(row, false); } -void wxDataViewCtrl::Unselect( unsigned int WXUNUSED(row) ) +bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const { - // FIXME - TODO + int row = m_clientArea->GetRowByItem( item ); + if( row >= 0 ) + { + return m_clientArea->IsRowSelected(row); + } + return false; } -bool wxDataViewCtrl::IsSelected( unsigned int WXUNUSED(row) ) const +//Selection code with row number as parameter +int wxDataViewCtrl::GetSelections( wxArrayInt & sel ) const { - // FIXME - TODO + 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 ) + 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; } -int wxDataViewCtrl::GetSelection() const +void wxDataViewCtrl::SelectRange( int from, int to ) { - // FIXME - TODO + wxArrayInt sel; + for( int i = from; i < to; i ++ ) + sel.Add( i ); + m_clientArea->Select(sel); +} - return -1; +void wxDataViewCtrl::UnselectRange( int from, int to ) +{ + 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); } -int wxDataViewCtrl::GetSelections(wxArrayInt& WXUNUSED(aSelections) ) const +void wxDataViewCtrl::SelectAll() { - // FIXME - TODO + m_clientArea->SelectAllRows(true); +} - return 0; +void wxDataViewCtrl::UnselectAll() +{ + m_clientArea->SelectAllRows(false); } -*********************************************************************/ -#endif + +void wxDataViewCtrl::EnsureVisible( int row ) +{ + m_clientArea->ScrollTo( row ); +} + +void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, wxDataViewColumn * column ) +{ + int row = m_clientArea->GetRowByItem(item); + if( row >= 0 ) + EnsureVisible(row); +} + +void wxDataViewCtrl::HitTest( const wxPoint & point, wxDataViewItem & item, unsigned int & column ) const +{ + m_clientArea->HitTest(point, item, column); +} + +wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem & item, unsigned int column ) const +{ + return m_clientArea->GetItemRect(item, column); +} + +wxDataViewItem wxDataViewCtrl::GetItemByRow( unsigned int row ) const +{ + return m_clientArea->GetItemByRow( row ); +} + +int wxDataViewCtrl::GetRowByItem( const wxDataViewItem & item ) const +{ + return m_clientArea->GetRowByItem( item ); +} + + #endif // !wxUSE_GENERICDATAVIEWCTRL #endif