src/generic/datavgen.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/datavgen.cpp
   3 // Purpose:     wxDataViewCtrl generic implementation
   4 // Author:      Robert Roebling
   5 // Modified by: Francesco Montorsi, Guru Kathiresan, Bo Yang
   6 // Id:          $Id$
   7 // Copyright:   (c) 1998 Robert Roebling
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_DATAVIEWCTRL
  19
  20 #include "wx/dataview.h"
  21
  22 #ifdef wxUSE_GENERICDATAVIEWCTRL
  23
  24 #ifndef WX_PRECOMP
  25     #ifdef __WXMSW__
  26         #include "wx/msw/private.h"
  27         #include "wx/msw/wrapwin.h"
  28         #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
  29     #endif
  30     #include "wx/sizer.h"
  31     #include "wx/log.h"
  32     #include "wx/dcclient.h"
  33     #include "wx/timer.h"
  34     #include "wx/settings.h"
  35     #include "wx/msgdlg.h"
  36     #include "wx/dcscreen.h"
  37     #include "wx/frame.h"
  38 #endif
  39
  40 #include "wx/stockitem.h"
  41 #include "wx/popupwin.h"
  42 #include "wx/renderer.h"
  43 #include "wx/dcbuffer.h"
  44 #include "wx/icon.h"
  45 #include "wx/list.h"
  46 #include "wx/listimpl.cpp"
  47 #include "wx/imaglist.h"
  48 #include "wx/headerctrl.h"
  49 #include "wx/dnd.h"
  50 #include "wx/stopwatch.h"
  51 #include "wx/weakref.h"
  52
  53 //-----------------------------------------------------------------------------
  54 // classes
  55 //-----------------------------------------------------------------------------
  56
  57 class wxDataViewColumn;
  58 class wxDataViewHeaderWindow;
  59 class wxDataViewCtrl;
  60
  61 //-----------------------------------------------------------------------------
  62 // classes
  63 //-----------------------------------------------------------------------------
  64
  65 static const int SCROLL_UNIT_X = 15;
  66
  67 // the cell padding on the left/right
  68 static const int PADDING_RIGHTLEFT = 3;
  69
  70 // the expander space margin
  71 static const int EXPANDER_MARGIN = 4;
  72
  73 #ifdef __WXMSW__
  74 static const int EXPANDER_OFFSET = 4;
  75 #else
  76 static const int EXPANDER_OFFSET = 1;
  77 #endif
  78
  79 // Below is the compare stuff.
  80 // For the generic implementation, both the leaf nodes and the nodes are sorted for
  81 // fast search when needed
  82 static wxDataViewModel* g_model;
  83 static int g_column = -2;
  84 static bool g_asending = true;
  85
  86 // ----------------------------------------------------------------------------
  87 // helper functions
  88 // ----------------------------------------------------------------------------
  89
  90 namespace
  91 {
  92
  93 // Return the expander column or, if it is not set, the first column and also
  94 // set it as the expander one for the future.
  95 wxDataViewColumn* GetExpanderColumnOrFirstOne(wxDataViewCtrl* dataview)
  96 {
  97     wxDataViewColumn* expander = dataview->GetExpanderColumn();
  98     if (!expander)
  99     {
 100         // TODO-RTL: last column for RTL support
 101         expander = dataview->GetColumnAt( 0 );
 102         dataview->SetExpanderColumn(expander);
 103     }
 104
 105     return expander;
 106 }
 107
 108 } // anonymous namespace
 109
 110 //-----------------------------------------------------------------------------
 111 // wxDataViewColumn
 112 //-----------------------------------------------------------------------------
 113
 114 void wxDataViewColumn::Init(int width, wxAlignment align, int flags)
 115 {
 116     m_width = width;
 117     m_minWidth = 0;
 118     m_align = align;
 119     m_flags = flags;
 120     m_sort = false;
 121     m_sortAscending = true;
 122 }
 123
 124 int wxDataViewColumn::GetWidth() const
 125 {
 126     switch ( m_width )
 127     {
 128         case wxCOL_WIDTH_DEFAULT:
 129             return wxDVC_DEFAULT_WIDTH;
 130
 131         case wxCOL_WIDTH_AUTOSIZE:
 132             wxCHECK_MSG( m_owner, wxDVC_DEFAULT_WIDTH, "no owner control" );
 133             return m_owner->GetBestColumnWidth(m_owner->GetColumnIndex(this));
 134
 135         default:
 136             return m_width;
 137     }
 138 }
 139
 140 void wxDataViewColumn::UpdateDisplay()
 141 {
 142     if (m_owner)
 143     {
 144         int idx = m_owner->GetColumnIndex( this );
 145         m_owner->OnColumnChange( idx );
 146     }
 147 }
 148
 149 void wxDataViewColumn::SetSortOrder(bool ascending)
 150 {
 151     if ( !m_owner )
 152         return;
 153
 154     // First unset the old sort column if any.
 155     int oldSortKey = m_owner->GetSortingColumnIndex();
 156     if ( oldSortKey != wxNOT_FOUND )
 157     {
 158         m_owner->GetColumn(oldSortKey)->UnsetAsSortKey();
 159     }
 160
 161     // Now set this one as the new sort column.
 162     const int idx = m_owner->GetColumnIndex(this);
 163     m_owner->SetSortingColumnIndex(idx);
 164
 165     m_sort = true;
 166     m_sortAscending = ascending;
 167
 168     // Call this directly instead of using UpdateDisplay() as we already have
 169     // the column index, no need to look it up again.
 170     m_owner->OnColumnChange(idx);
 171 }
 172
 173 //-----------------------------------------------------------------------------
 174 // wxDataViewHeaderWindow
 175 //-----------------------------------------------------------------------------
 176
 177 class wxDataViewHeaderWindow : public wxHeaderCtrl
 178 {
 179 public:
 180     wxDataViewHeaderWindow(wxDataViewCtrl *parent)
 181         : wxHeaderCtrl(parent)
 182     {
 183     }
 184
 185     wxDataViewCtrl *GetOwner() const
 186         { return static_cast<wxDataViewCtrl *>(GetParent()); }
 187
 188 protected:
 189     // implement/override wxHeaderCtrl functions by forwarding them to the main
 190     // control
 191     virtual const wxHeaderColumn& GetColumn(unsigned int idx) const
 192     {
 193         return *(GetOwner()->GetColumn(idx));
 194     }
 195
 196     virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
 197     {
 198         wxDataViewCtrl * const owner = GetOwner();
 199
 200         int widthContents = owner->GetBestColumnWidth(idx);
 201         owner->GetColumn(idx)->SetWidth(wxMax(widthTitle, widthContents));
 202         owner->OnColumnChange(idx);
 203
 204         return true;
 205     }
 206
 207 private:
 208     bool SendEvent(wxEventType type, unsigned int n)
 209     {
 210         wxDataViewCtrl * const owner = GetOwner();
 211         wxDataViewEvent event(type, owner->GetId());
 212
 213         event.SetEventObject(owner);
 214         event.SetColumn(n);
 215         event.SetDataViewColumn(owner->GetColumn(n));
 216         event.SetModel(owner->GetModel());
 217
 218         // for events created by wxDataViewHeaderWindow the
 219         // row / value fields are not valid
 220         return owner->ProcessWindowEvent(event);
 221     }
 222
 223     void OnClick(wxHeaderCtrlEvent& event)
 224     {
 225         const unsigned idx = event.GetColumn();
 226
 227         if ( SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, idx) )
 228             return;
 229
 230         // default handling for the column click is to sort by this column or
 231         // toggle its sort order
 232         wxDataViewCtrl * const owner = GetOwner();
 233         wxDataViewColumn * const col = owner->GetColumn(idx);
 234         if ( !col->IsSortable() )
 235         {
 236             // no default handling for non-sortable columns
 237             event.Skip();
 238             return;
 239         }
 240
 241         if ( col->IsSortKey() )
 242         {
 243             // already using this column for sorting, just change the order
 244             col->ToggleSortOrder();
 245         }
 246         else // not using this column for sorting yet
 247         {
 248             col->SetSortOrder(true);
 249         }
 250
 251         wxDataViewModel * const model = owner->GetModel();
 252         if ( model )
 253             model->Resort();
 254
 255         owner->OnColumnChange(idx);
 256
 257         SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, idx);
 258     }
 259
 260     void OnRClick(wxHeaderCtrlEvent& event)
 261     {
 262         if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK,
 263                         event.GetColumn()) )
 264             event.Skip();
 265     }
 266
 267     void OnResize(wxHeaderCtrlEvent& event)
 268     {
 269         wxDataViewCtrl * const owner = GetOwner();
 270
 271         const unsigned col = event.GetColumn();
 272         owner->GetColumn(col)->SetWidth(event.GetWidth());
 273         GetOwner()->OnColumnChange(col);
 274     }
 275
 276     void OnEndReorder(wxHeaderCtrlEvent& event)
 277     {
 278         wxDataViewCtrl * const owner = GetOwner();
 279         owner->ColumnMoved(owner->GetColumn(event.GetColumn()),
 280                         event.GetNewOrder());
 281     }
 282
 283     DECLARE_EVENT_TABLE()
 284     wxDECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow);
 285 };
 286
 287 BEGIN_EVENT_TABLE(wxDataViewHeaderWindow, wxHeaderCtrl)
 288     EVT_HEADER_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnClick)
 289     EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnRClick)
 290
 291     EVT_HEADER_RESIZING(wxID_ANY, wxDataViewHeaderWindow::OnResize)
 292     EVT_HEADER_END_RESIZE(wxID_ANY, wxDataViewHeaderWindow::OnResize)
 293
 294     EVT_HEADER_END_REORDER(wxID_ANY, wxDataViewHeaderWindow::OnEndReorder)
 295 END_EVENT_TABLE()
 296
 297 //-----------------------------------------------------------------------------
 298 // wxDataViewRenameTimer
 299 //-----------------------------------------------------------------------------
 300
 301 class wxDataViewRenameTimer: public wxTimer
 302 {
 303 private:
 304     wxDataViewMainWindow *m_owner;
 305
 306 public:
 307     wxDataViewRenameTimer( wxDataViewMainWindow *owner );
 308     void Notify();
 309 };
 310
 311 //-----------------------------------------------------------------------------
 312 // wxDataViewTreeNode
 313 //-----------------------------------------------------------------------------
 314
 315 class wxDataViewTreeNode;
 316 WX_DEFINE_ARRAY( wxDataViewTreeNode *, wxDataViewTreeNodes );
 317
 318 int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1,
 319                                            wxDataViewTreeNode ** node2);
 320
 321 class wxDataViewTreeNode
 322 {
 323 public:
 324     wxDataViewTreeNode(wxDataViewTreeNode *parent, const wxDataViewItem& item)
 325         : m_parent(parent),
 326           m_item(item),
 327           m_branchData(NULL)
 328     {
 329     }
 330
 331     ~wxDataViewTreeNode()
 332     {
 333         if ( m_branchData )
 334         {
 335             wxDataViewTreeNodes& nodes = m_branchData->children;
 336             for ( wxDataViewTreeNodes::iterator i = nodes.begin();
 337                   i != nodes.end();
 338                   ++i )
 339             {
 340                 delete *i;
 341             }
 342
 343             delete m_branchData;
 344         }
 345     }
 346
 347     static wxDataViewTreeNode* CreateRootNode()
 348     {
 349         wxDataViewTreeNode *n = new wxDataViewTreeNode(NULL, wxDataViewItem());
 350         n->SetHasChildren(true);
 351         n->m_branchData->open = true;
 352         return n;
 353     }
 354
 355     wxDataViewTreeNode * GetParent() const { return m_parent; }
 356
 357     const wxDataViewTreeNodes& GetChildNodes() const
 358     {
 359         wxASSERT( m_branchData != NULL );
 360         return m_branchData->children;
 361     }
 362
 363     void InsertChild(wxDataViewTreeNode *node, unsigned index)
 364     {
 365         if ( !m_branchData )
 366             m_branchData = new BranchNodeData;
 367
 368         m_branchData->children.Insert(node, index);
 369
 370         // TODO: insert into sorted array directly in O(log n) instead of resorting in O(n log n)
 371         if (g_column >= -1)
 372             m_branchData->children.Sort( &wxGenericTreeModelNodeCmp );
 373     }
 374
 375     void RemoveChild(wxDataViewTreeNode *node)
 376     {
 377         wxCHECK_RET( m_branchData != NULL, "leaf node doesn't have children" );
 378         m_branchData->children.Remove(node);
 379     }
 380
 381     // returns position of child node for given item in children list or wxNOT_FOUND
 382     int FindChildByItem(const wxDataViewItem& item) const
 383     {
 384         if ( !m_branchData )
 385             return wxNOT_FOUND;
 386
 387         const wxDataViewTreeNodes& nodes = m_branchData->children;
 388         const int len = nodes.size();
 389         for ( int i = 0; i < len; i++ )
 390         {
 391             if ( nodes[i]->m_item == item )
 392                 return i;
 393         }
 394         return wxNOT_FOUND;
 395     }
 396
 397     const wxDataViewItem & GetItem() const { return m_item; }
 398     void SetItem( const wxDataViewItem & item ) { m_item = item; }
 399
 400     int GetIndentLevel() const
 401     {
 402         int ret = 0;
 403         const wxDataViewTreeNode * node = this;
 404         while( node->GetParent()->GetParent() != NULL )
 405         {
 406             node = node->GetParent();
 407             ret ++;
 408         }
 409         return ret;
 410     }
 411
 412     bool IsOpen() const
 413     {
 414         return m_branchData && m_branchData->open;
 415     }
 416
 417     void ToggleOpen()
 418     {
 419         wxCHECK_RET( m_branchData != NULL, "can't open leaf node" );
 420
 421         int sum = 0;
 422
 423         const wxDataViewTreeNodes& nodes = m_branchData->children;
 424         const int len = nodes.GetCount();
 425         for ( int i = 0;i < len; i ++)
 426             sum += 1 + nodes[i]->GetSubTreeCount();
 427
 428         if (m_branchData->open)
 429         {
 430             ChangeSubTreeCount(-sum);
 431             m_branchData->open = !m_branchData->open;
 432         }
 433         else
 434         {
 435             m_branchData->open = !m_branchData->open;
 436             ChangeSubTreeCount(+sum);
 437         }
 438     }
 439
 440     // "HasChildren" property corresponds to model's IsContainer(). Note that it may be true
 441     // even if GetChildNodes() is empty; see below.
 442     bool HasChildren() const
 443     {
 444         return m_branchData != NULL;
 445     }
 446
 447     void SetHasChildren(bool has)
 448     {
 449         if ( !has )
 450         {
 451             wxDELETE(m_branchData);
 452         }
 453         else if ( m_branchData == NULL )
 454         {
 455             m_branchData = new BranchNodeData;
 456         }
 457     }
 458
 459     int GetSubTreeCount() const
 460     {
 461         return m_branchData ? m_branchData->subTreeCount : 0;
 462     }
 463
 464     void ChangeSubTreeCount( int num )
 465     {
 466         wxASSERT( m_branchData != NULL );
 467
 468         if( !m_branchData->open )
 469             return;
 470
 471         m_branchData->subTreeCount += num;
 472         wxASSERT( m_branchData->subTreeCount >= 0 );
 473
 474         if( m_parent )
 475             m_parent->ChangeSubTreeCount(num);
 476     }
 477
 478     void Resort()
 479     {
 480         if ( !m_branchData )
 481             return;
 482
 483         if (g_column >= -1)
 484         {
 485             wxDataViewTreeNodes& nodes = m_branchData->children;
 486
 487             nodes.Sort( &wxGenericTreeModelNodeCmp );
 488             int len = nodes.GetCount();
 489             for (int i = 0; i < len; i ++)
 490             {
 491                 if ( nodes[i]->HasChildren() )
 492                     nodes[i]->Resort();
 493             }
 494         }
 495     }
 496
 497
 498 private:
 499     wxDataViewTreeNode  *m_parent;
 500
 501     // Corresponding model item.
 502     wxDataViewItem       m_item;
 503
 504     // Data specific to non-leaf (branch, inner) nodes. They are kept in a
 505     // separate struct in order to conserve memory.
 506     struct BranchNodeData
 507     {
 508         BranchNodeData()
 509             : open(false),
 510               subTreeCount(0)
 511         {
 512         }
 513
 514         // Child nodes. Note that this may be empty even if m_hasChildren in
 515         // case this branch of the tree wasn't expanded and realized yet.
 516         wxDataViewTreeNodes  children;
 517
 518         // Is the branch node currently open (expanded)?
 519         bool                 open;
 520
 521         // Total count of expanded (i.e. visible with the help of some
 522         // scrolling) items in the subtree, but excluding this node. I.e. it is
 523         // 0 for leaves and is the number of rows the subtree occupies for
 524         // branch nodes.
 525         int                  subTreeCount;
 526     };
 527
 528     BranchNodeData *m_branchData;
 529 };
 530
 531
 532 int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1,
 533                                            wxDataViewTreeNode ** node2)
 534 {
 535     return g_model->Compare( (*node1)->GetItem(), (*node2)->GetItem(), g_column, g_asending );
 536 }
 537
 538
 539 //-----------------------------------------------------------------------------
 540 // wxDataViewMainWindow
 541 //-----------------------------------------------------------------------------
 542
 543 WX_DEFINE_SORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection);
 544
 545 class wxDataViewMainWindow: public wxWindow
 546 {
 547 public:
 548     wxDataViewMainWindow( wxDataViewCtrl *parent,
 549                             wxWindowID id,
 550                             const wxPoint &pos = wxDefaultPosition,
 551                             const wxSize &size = wxDefaultSize,
 552                             const wxString &name = wxT("wxdataviewctrlmainwindow") );
 553     virtual ~wxDataViewMainWindow();
 554
 555     bool IsList() const { return GetModel()->IsListModel(); }
 556     bool IsVirtualList() const { return m_root == NULL; }
 557
 558     // notifications from wxDataViewModel
 559     bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
 560     bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
 561     bool ItemChanged( const wxDataViewItem &item );
 562     bool ValueChanged( const wxDataViewItem &item, unsigned int model_column );
 563     bool Cleared();
 564     void Resort()
 565     {
 566         if (!IsVirtualList())
 567         {
 568             SortPrepare();
 569             m_root->Resort();
 570         }
 571         UpdateDisplay();
 572     }
 573
 574     void SortPrepare()
 575     {
 576         g_model = GetModel();
 577         wxDataViewColumn* col = GetOwner()->GetSortingColumn();
 578         if( !col )
 579         {
 580             if (g_model->HasDefaultCompare())
 581                 g_column = -1;
 582             else
 583                 g_column = -2;
 584
 585             g_asending = true;
 586             return;
 587         }
 588         g_column = col->GetModelColumn();
 589         g_asending = col->IsSortOrderAscending();
 590     }
 591
 592     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
 593     wxDataViewCtrl *GetOwner() { return m_owner; }
 594     const wxDataViewCtrl *GetOwner() const { return m_owner; }
 595
 596     wxDataViewModel* GetModel() { return GetOwner()->GetModel(); }
 597     const wxDataViewModel* GetModel() const { return GetOwner()->GetModel(); }
 598
 599 #if wxUSE_DRAG_AND_DROP
 600     wxBitmap CreateItemBitmap( unsigned int row, int &indent );
 601 #endif // wxUSE_DRAG_AND_DROP
 602     void OnPaint( wxPaintEvent &event );
 603     void OnCharHook( wxKeyEvent &event );
 604     void OnChar( wxKeyEvent &event );
 605     void OnVerticalNavigation(unsigned int newCurrent, const wxKeyEvent& event);
 606     void OnLeftKey();
 607     void OnRightKey();
 608     void OnMouse( wxMouseEvent &event );
 609     void OnSetFocus( wxFocusEvent &event );
 610     void OnKillFocus( wxFocusEvent &event );
 611
 612     void UpdateDisplay();
 613     void RecalculateDisplay();
 614     void OnInternalIdle();
 615
 616     void OnRenameTimer();
 617
 618     void ScrollWindow( int dx, int dy, const wxRect *rect = NULL );
 619     void ScrollTo( int rows, int column );
 620
 621     unsigned GetCurrentRow() const { return m_currentRow; }
 622     bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; }
 623     void ChangeCurrentRow( unsigned int row );
 624     bool TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward);
 625
 626     bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); }
 627     bool IsEmpty() { return GetRowCount() == 0; }
 628
 629     int GetCountPerPage() const;
 630     int GetEndOfLastCol() const;
 631     unsigned int GetFirstVisibleRow() const;
 632
 633     // I change this method to un const because in the tree view,
 634     // the displaying number of the tree are changing along with the
 635     // expanding/collapsing of the tree nodes
 636     unsigned int GetLastVisibleRow();
 637     unsigned int GetRowCount();
 638
 639     const wxDataViewSelection& GetSelections() const { return m_selection; }
 640     void SetSelections( const wxDataViewSelection & sel )
 641         { m_selection = sel; UpdateDisplay(); }
 642     void Select( const wxArrayInt& aSelections );
 643     void SelectAllRows( bool on );
 644     void SelectRow( unsigned int row, bool on );
 645     void SelectRows( unsigned int from, unsigned int to, bool on );
 646     void ReverseRowSelection( unsigned int row );
 647     bool IsRowSelected( unsigned int row );
 648     void SendSelectionChangedEvent( const wxDataViewItem& item);
 649
 650     void RefreshRow( unsigned int row );
 651     void RefreshRows( unsigned int from, unsigned int to );
 652     void RefreshRowsAfter( unsigned int firstRow );
 653
 654     // returns the colour to be used for drawing the rules
 655     wxColour GetRuleColour() const
 656     {
 657         return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
 658     }
 659
 660     wxRect GetLineRect( unsigned int row ) const;
 661
 662     int GetLineStart( unsigned int row ) const;  // row * m_lineHeight in fixed mode
 663     int GetLineHeight( unsigned int row ) const; // m_lineHeight in fixed mode
 664     int GetLineAt( unsigned int y ) const;       // y / m_lineHeight in fixed mode
 665
 666     void SetRowHeight( int lineHeight ) { m_lineHeight = lineHeight; }
 667     int GetRowHeight() const { return m_lineHeight; }
 668
 669     // Some useful functions for row and item mapping
 670     wxDataViewItem GetItemByRow( unsigned int row ) const;
 671     int GetRowByItem( const wxDataViewItem & item ) const;
 672
 673     wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ) const;
 674     // We did not need this temporarily
 675     // wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item );
 676
 677     // Methods for building the mapping tree
 678     void BuildTree( wxDataViewModel  * model );
 679     void DestroyTree();
 680     void HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column );
 681     wxRect GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column );
 682
 683     void Expand( unsigned int row );
 684     void Collapse( unsigned int row );
 685     bool IsExpanded( unsigned int row ) const;
 686     bool HasChildren( unsigned int row ) const;
 687
 688 #if wxUSE_DRAG_AND_DROP
 689     bool EnableDragSource( const wxDataFormat &format );
 690     bool EnableDropTarget( const wxDataFormat &format );
 691
 692     void RemoveDropHint();
 693     wxDragResult OnDragOver( wxDataFormat format, wxCoord x, wxCoord y, wxDragResult def );
 694     bool OnDrop( wxDataFormat format, wxCoord x, wxCoord y );
 695     wxDragResult OnData( wxDataFormat format, wxCoord x, wxCoord y, wxDragResult def );
 696     void OnLeave();
 697 #endif // wxUSE_DRAG_AND_DROP
 698
 699     void OnColumnsCountChanged();
 700
 701     // Called by wxDataViewCtrl and our own OnRenameTimer() to start edit the
 702     // specified item in the given column.
 703     void StartEditing(const wxDataViewItem& item, const wxDataViewColumn* col);
 704
 705 private:
 706     int RecalculateCount();
 707
 708     // Return false only if the event was vetoed by its handler.
 709     bool SendExpanderEvent(wxEventType type, const wxDataViewItem& item);
 710
 711     wxDataViewTreeNode * FindNode( const wxDataViewItem & item );
 712
 713     wxDataViewColumn *FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode);
 714
 715 private:
 716     wxDataViewCtrl             *m_owner;
 717     int                         m_lineHeight;
 718     bool                        m_dirty;
 719
 720     wxDataViewColumn           *m_currentCol;
 721     unsigned int                m_currentRow;
 722     wxDataViewSelection         m_selection;
 723
 724     wxDataViewRenameTimer      *m_renameTimer;
 725     bool                        m_lastOnSame;
 726
 727     bool                        m_hasFocus;
 728     bool                        m_useCellFocus;
 729     bool                        m_currentColSetByKeyboard;
 730
 731 #if wxUSE_DRAG_AND_DROP
 732     int                         m_dragCount;
 733     wxPoint                     m_dragStart;
 734
 735     bool                        m_dragEnabled;
 736     wxDataFormat                m_dragFormat;
 737
 738     bool                        m_dropEnabled;
 739     wxDataFormat                m_dropFormat;
 740     bool                        m_dropHint;
 741     unsigned int                m_dropHintLine;
 742 #endif // wxUSE_DRAG_AND_DROP
 743
 744     // for double click logic
 745     unsigned int m_lineLastClicked,
 746         m_lineBeforeLastClicked,
 747         m_lineSelectSingleOnUp;
 748
 749     // the pen used to draw horiz/vertical rules
 750     wxPen m_penRule;
 751
 752     // the pen used to draw the expander and the lines
 753     wxPen m_penExpander;
 754
 755     // This is the tree structure of the model
 756     wxDataViewTreeNode * m_root;
 757     int m_count;
 758
 759     // This is the tree node under the cursor
 760     wxDataViewTreeNode * m_underMouse;
 761
 762     // The control used for editing or NULL.
 763     wxWeakRef<wxWindow> m_editorCtrl;
 764
 765     // Id m_editorCtrl is non-NULL, pointer to the associated renderer.
 766     wxDataViewRenderer* m_editorRenderer;
 767
 768 private:
 769     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
 770     DECLARE_EVENT_TABLE()
 771 };
 772
 773 // ---------------------------------------------------------
 774 // wxGenericDataViewModelNotifier
 775 // ---------------------------------------------------------
 776
 777 class wxGenericDataViewModelNotifier: public wxDataViewModelNotifier
 778 {
 779 public:
 780     wxGenericDataViewModelNotifier( wxDataViewMainWindow *mainWindow )
 781         { m_mainWindow = mainWindow; }
 782
 783     virtual bool ItemAdded( const wxDataViewItem & parent, const wxDataViewItem & item )
 784         { return m_mainWindow->ItemAdded( parent , item ); }
 785     virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
 786         { return m_mainWindow->ItemDeleted( parent, item ); }
 787     virtual bool ItemChanged( const wxDataViewItem & item )
 788         { return m_mainWindow->ItemChanged(item);  }
 789     virtual bool ValueChanged( const wxDataViewItem & item , unsigned int col )
 790         { return m_mainWindow->ValueChanged( item, col ); }
 791     virtual bool Cleared()
 792         { return m_mainWindow->Cleared(); }
 793     virtual void Resort()
 794         { m_mainWindow->Resort(); }
 795
 796     wxDataViewMainWindow    *m_mainWindow;
 797 };
 798
 799 // ---------------------------------------------------------
 800 // wxDataViewRenderer
 801 // ---------------------------------------------------------
 802
 803 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
 804
 805 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype,
 806                                         wxDataViewCellMode mode,
 807                                         int align) :
 808     wxDataViewCustomRendererBase( varianttype, mode, align )
 809 {
 810     m_align = align;
 811     m_mode = mode;
 812     m_ellipsizeMode = wxELLIPSIZE_MIDDLE;
 813     m_dc = NULL;
 814 }
 815
 816 wxDataViewRenderer::~wxDataViewRenderer()
 817 {
 818     delete m_dc;
 819 }
 820
 821 wxDC *wxDataViewRenderer::GetDC()
 822 {
 823     if (m_dc == NULL)
 824     {
 825         if (GetOwner() == NULL)
 826             return NULL;
 827         if (GetOwner()->GetOwner() == NULL)
 828             return NULL;
 829         m_dc = new wxClientDC( GetOwner()->GetOwner() );
 830     }
 831
 832     return m_dc;
 833 }
 834
 835 void wxDataViewRenderer::SetAlignment( int align )
 836 {
 837     m_align=align;
 838 }
 839
 840 int wxDataViewRenderer::GetAlignment() const
 841 {
 842     return m_align;
 843 }
 844
 845 // ---------------------------------------------------------
 846 // wxDataViewCustomRenderer
 847 // ---------------------------------------------------------
 848
 849 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
 850
 851 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
 852                         wxDataViewCellMode mode, int align ) :
 853     wxDataViewRenderer( varianttype, mode, align )
 854 {
 855 }
 856
 857 // ---------------------------------------------------------
 858 // wxDataViewTextRenderer
 859 // ---------------------------------------------------------
 860
 861 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer)
 862
 863 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype,
 864                                                 wxDataViewCellMode mode, int align ) :
 865     wxDataViewRenderer( varianttype, mode, align )
 866 {
 867 }
 868
 869 bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
 870 {
 871     m_text = value.GetString();
 872
 873     return true;
 874 }
 875
 876 bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
 877 {
 878     return false;
 879 }
 880
 881 bool wxDataViewTextRenderer::HasEditorCtrl() const
 882 {
 883     return true;
 884 }
 885
 886 wxWindow* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent,
 887         wxRect labelRect, const wxVariant &value )
 888 {
 889     wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, value,
 890                                        wxPoint(labelRect.x,labelRect.y),
 891                                        wxSize(labelRect.width,labelRect.height),
 892                                        wxTE_PROCESS_ENTER );
 893
 894     // select the text in the control an place the cursor at the end
 895     ctrl->SetInsertionPointEnd();
 896     ctrl->SelectAll();
 897
 898     return ctrl;
 899 }
 900
 901 bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant &value )
 902 {
 903     wxTextCtrl *text = (wxTextCtrl*) editor;
 904     value = text->GetValue();
 905     return true;
 906 }
 907
 908 bool wxDataViewTextRenderer::Render(wxRect rect, wxDC *dc, int state)
 909 {
 910     RenderText(m_text, 0, rect, dc, state);
 911     return true;
 912 }
 913
 914 wxSize wxDataViewTextRenderer::GetSize() const
 915 {
 916     if (!m_text.empty())
 917         return GetTextExtent(m_text);
 918     else
 919         return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE);
 920 }
 921
 922 // ---------------------------------------------------------
 923 // wxDataViewBitmapRenderer
 924 // ---------------------------------------------------------
 925
 926 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer)
 927
 928 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype,
 929                                                     wxDataViewCellMode mode, int align ) :
 930     wxDataViewRenderer( varianttype, mode, align )
 931 {
 932 }
 933
 934 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
 935 {
 936     if (value.GetType() == wxT("wxBitmap"))
 937         m_bitmap << value;
 938     if (value.GetType() == wxT("wxIcon"))
 939         m_icon << value;
 940
 941     return true;
 942 }
 943
 944 bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
 945 {
 946     return false;
 947 }
 948
 949 bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 950 {
 951     if (m_bitmap.IsOk())
 952         dc->DrawBitmap( m_bitmap, cell.x, cell.y );
 953     else if (m_icon.IsOk())
 954         dc->DrawIcon( m_icon, cell.x, cell.y );
 955
 956     return true;
 957 }
 958
 959 wxSize wxDataViewBitmapRenderer::GetSize() const
 960 {
 961     if (m_bitmap.IsOk())
 962         return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
 963     else if (m_icon.IsOk())
 964         return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
 965
 966     return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE);
 967 }
 968
 969 // ---------------------------------------------------------
 970 // wxDataViewToggleRenderer
 971 // ---------------------------------------------------------
 972
 973 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer)
 974
 975 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
 976                         wxDataViewCellMode mode, int align ) :
 977     wxDataViewRenderer( varianttype, mode, align )
 978 {
 979     m_toggle = false;
 980 }
 981
 982 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
 983 {
 984     m_toggle = value.GetBool();
 985
 986     return true;
 987 }
 988
 989 bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
 990 {
 991     return false;
 992 }
 993
 994 bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 995 {
 996     int flags = 0;
 997     if (m_toggle)
 998         flags |= wxCONTROL_CHECKED;
 999     if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE ||
1000         GetEnabled() == false)
1001         flags |= wxCONTROL_DISABLED;
1002
1003     // check boxes we draw must always have the same, standard size (if it's
1004     // bigger than the cell size the checkbox will be truncated because the
1005     // caller had set the clipping rectangle to prevent us from drawing outside
1006     // the cell)
1007     cell.SetSize(GetSize());
1008
1009     wxRendererNative::Get().DrawCheckBox(
1010             GetOwner()->GetOwner(),
1011             *dc,
1012             cell,
1013             flags );
1014
1015     return true;
1016 }
1017
1018 bool wxDataViewToggleRenderer::WXActivateCell(const wxRect& WXUNUSED(cell),
1019                                               wxDataViewModel *model,
1020                                               const wxDataViewItem& item,
1021                                               unsigned int col,
1022                                               const wxMouseEvent *mouseEvent)
1023 {
1024     if ( !model->IsEnabled(item, col) )
1025         return false;
1026
1027     if ( mouseEvent )
1028     {
1029         // only react to clicks directly on the checkbox, not elsewhere in the same cell:
1030         if ( !wxRect(GetSize()).Contains(mouseEvent->GetPosition()) )
1031             return false;
1032     }
1033
1034     model->ChangeValue(!m_toggle, item, col);
1035     return true;
1036 }
1037
1038 wxSize wxDataViewToggleRenderer::GetSize() const
1039 {
1040     // the window parameter is not used by GetCheckBoxSize() so it's
1041     // safe to pass NULL
1042     return wxRendererNative::Get().GetCheckBoxSize(NULL);
1043 }
1044
1045 // ---------------------------------------------------------
1046 // wxDataViewProgressRenderer
1047 // ---------------------------------------------------------
1048
1049 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewRenderer)
1050
1051 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
1052     const wxString &varianttype, wxDataViewCellMode mode, int align ) :
1053     wxDataViewRenderer( varianttype, mode, align )
1054 {
1055     m_label = label;
1056     m_value = 0;
1057 }
1058
1059 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
1060 {
1061     m_value = (long) value;
1062
1063     if (m_value < 0) m_value = 0;
1064     if (m_value > 100) m_value = 100;
1065
1066     return true;
1067 }
1068
1069 bool wxDataViewProgressRenderer::GetValue( wxVariant &value ) const
1070 {
1071     value = (long) m_value;
1072     return true;
1073 }
1074
1075 bool
1076 wxDataViewProgressRenderer::Render(wxRect rect, wxDC *dc, int WXUNUSED(state))
1077 {
1078     // deflate the rect to leave a small border between bars in adjacent rows
1079     wxRect bar = rect.Deflate(0, 1);
1080
1081     dc->SetBrush( *wxTRANSPARENT_BRUSH );
1082     dc->SetPen( *wxBLACK_PEN );
1083     dc->DrawRectangle( bar );
1084
1085     bar.width = (int)(bar.width * m_value / 100.);
1086     dc->SetPen( *wxTRANSPARENT_PEN );
1087
1088     const wxDataViewItemAttr& attr = GetAttr();
1089     dc->SetBrush( attr.HasColour() ? wxBrush(attr.GetColour())
1090                                   : *wxBLUE_BRUSH );
1091     dc->DrawRectangle( bar );
1092
1093     return true;
1094 }
1095
1096 wxSize wxDataViewProgressRenderer::GetSize() const
1097 {
1098     return wxSize(40,12);
1099 }
1100
1101 // ---------------------------------------------------------
1102 // wxDataViewIconTextRenderer
1103 // ---------------------------------------------------------
1104
1105 IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewRenderer)
1106
1107 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(
1108 const wxString &varianttype, wxDataViewCellMode mode, int align ) :
1109     wxDataViewRenderer( varianttype, mode, align )
1110 {
1111     SetMode(mode);
1112     SetAlignment(align);
1113 }
1114
1115 bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
1116 {
1117     m_value << value;
1118     return true;
1119 }
1120
1121 bool wxDataViewIconTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
1122 {
1123     return false;
1124 }
1125
1126 bool wxDataViewIconTextRenderer::Render(wxRect rect, wxDC *dc, int state)
1127 {
1128     int xoffset = 0;
1129
1130     const wxIcon& icon = m_value.GetIcon();
1131     if ( icon.IsOk() )
1132     {
1133         dc->DrawIcon(icon, rect.x, rect.y + (rect.height - icon.GetHeight())/2);
1134         xoffset = icon.GetWidth()+4;
1135     }
1136
1137     RenderText(m_value.GetText(), xoffset, rect, dc, state);
1138
1139     return true;
1140 }
1141
1142 wxSize wxDataViewIconTextRenderer::GetSize() const
1143 {
1144     if (!m_value.GetText().empty())
1145     {
1146         wxSize size = GetTextExtent(m_value.GetText());
1147
1148         if (m_value.GetIcon().IsOk())
1149             size.x += m_value.GetIcon().GetWidth() + 4;
1150         return size;
1151     }
1152     return wxSize(80,20);
1153 }
1154
1155 wxWindow* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value)
1156 {
1157     wxDataViewIconText iconText;
1158     iconText << value;
1159
1160     wxString text = iconText.GetText();
1161
1162     // adjust the label rect to take the width of the icon into account
1163     if (iconText.GetIcon().IsOk())
1164     {
1165         int w = iconText.GetIcon().GetWidth() + 4;
1166         labelRect.x += w;
1167         labelRect.width -= w;
1168     }
1169
1170     wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, text,
1171                                        wxPoint(labelRect.x,labelRect.y),
1172                                        wxSize(labelRect.width,labelRect.height),
1173                                        wxTE_PROCESS_ENTER );
1174
1175     // select the text in the control an place the cursor at the end
1176     ctrl->SetInsertionPointEnd();
1177     ctrl->SelectAll();
1178
1179     return ctrl;
1180 }
1181
1182 bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant& value )
1183 {
1184     wxTextCtrl *text = (wxTextCtrl*) editor;
1185
1186     wxDataViewIconText iconText(text->GetValue(), m_value.GetIcon());
1187     value << iconText;
1188     return true;
1189 }
1190
1191 //-----------------------------------------------------------------------------
1192 // wxDataViewDropTarget
1193 //-----------------------------------------------------------------------------
1194
1195 #if wxUSE_DRAG_AND_DROP
1196
1197 class wxBitmapCanvas: public wxWindow
1198 {
1199 public:
1200     wxBitmapCanvas( wxWindow *parent, const wxBitmap &bitmap, const wxSize &size ) :
1201     wxWindow( parent, wxID_ANY, wxPoint(0,0), size )
1202     {
1203         m_bitmap = bitmap;
1204         Connect( wxEVT_PAINT, wxPaintEventHandler(wxBitmapCanvas::OnPaint) );
1205     }
1206
1207     void OnPaint( wxPaintEvent &WXUNUSED(event) )
1208     {
1209         wxPaintDC dc(this);
1210         dc.DrawBitmap( m_bitmap, 0, 0);
1211     }
1212
1213     wxBitmap m_bitmap;
1214 };
1215
1216 class wxDataViewDropSource: public wxDropSource
1217 {
1218 public:
1219     wxDataViewDropSource( wxDataViewMainWindow *win, unsigned int row ) :
1220         wxDropSource( win )
1221     {
1222         m_win = win;
1223         m_row = row;
1224         m_hint = NULL;
1225     }
1226
1227     ~wxDataViewDropSource()
1228     {
1229         delete m_hint;
1230     }
1231
1232     virtual bool GiveFeedback( wxDragResult WXUNUSED(effect) )
1233     {
1234         wxPoint pos = wxGetMousePosition();
1235
1236         if (!m_hint)
1237         {
1238             int liney = m_win->GetLineStart( m_row );
1239             int linex = 0;
1240             m_win->GetOwner()->CalcUnscrolledPosition( 0, liney, NULL, &liney );
1241             m_win->ClientToScreen( &linex, &liney );
1242             m_dist_x = pos.x - linex;
1243             m_dist_y = pos.y - liney;
1244
1245             int indent = 0;
1246             wxBitmap ib = m_win->CreateItemBitmap( m_row, indent );
1247             m_dist_x -= indent;
1248             m_hint = new wxFrame( m_win->GetParent(), wxID_ANY, wxEmptyString,
1249                                         wxPoint(pos.x - m_dist_x, pos.y + 5 ),
1250                                         ib.GetSize(),
1251                                         wxFRAME_TOOL_WINDOW |
1252                                         wxFRAME_FLOAT_ON_PARENT |
1253                                         wxFRAME_NO_TASKBAR |
1254                                         wxNO_BORDER );
1255             new wxBitmapCanvas( m_hint, ib, ib.GetSize() );
1256             m_hint->Show();
1257         }
1258         else
1259         {
1260             m_hint->Move( pos.x - m_dist_x, pos.y + 5  );
1261             m_hint->SetTransparent( 128 );
1262         }
1263
1264         return false;
1265     }
1266
1267     wxDataViewMainWindow   *m_win;
1268     unsigned int            m_row;
1269     wxFrame                *m_hint;
1270     int m_dist_x,m_dist_y;
1271 };
1272
1273
1274 class wxDataViewDropTarget: public wxDropTarget
1275 {
1276 public:
1277     wxDataViewDropTarget( wxDataObject *obj, wxDataViewMainWindow *win ) :
1278         wxDropTarget( obj )
1279     {
1280         m_win = win;
1281     }
1282
1283     virtual wxDragResult OnDragOver( wxCoord x, wxCoord y, wxDragResult def )
1284     {
1285         wxDataFormat format = GetMatchingPair();
1286         if (format == wxDF_INVALID)
1287             return wxDragNone;
1288         return m_win->OnDragOver( format, x, y, def);
1289     }
1290
1291     virtual bool OnDrop( wxCoord x, wxCoord y )
1292     {
1293         wxDataFormat format = GetMatchingPair();
1294         if (format == wxDF_INVALID)
1295             return false;
1296         return m_win->OnDrop( format, x, y );
1297     }
1298
1299     virtual wxDragResult OnData( wxCoord x, wxCoord y, wxDragResult def )
1300     {
1301         wxDataFormat format = GetMatchingPair();
1302         if (format == wxDF_INVALID)
1303             return wxDragNone;
1304         if (!GetData())
1305             return wxDragNone;
1306         return m_win->OnData( format, x, y, def );
1307     }
1308
1309     virtual void OnLeave()
1310         { m_win->OnLeave(); }
1311
1312     wxDataViewMainWindow   *m_win;
1313 };
1314
1315 #endif // wxUSE_DRAG_AND_DROP
1316
1317 //-----------------------------------------------------------------------------
1318 // wxDataViewRenameTimer
1319 //-----------------------------------------------------------------------------
1320
1321 wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner )
1322 {
1323     m_owner = owner;
1324 }
1325
1326 void wxDataViewRenameTimer::Notify()
1327 {
1328     m_owner->OnRenameTimer();
1329 }
1330
1331 //-----------------------------------------------------------------------------
1332 // wxDataViewMainWindow
1333 //-----------------------------------------------------------------------------
1334
1335 // The tree building helper, declared firstly
1336 static void BuildTreeHelper( const wxDataViewModel * model,  const wxDataViewItem & item,
1337                              wxDataViewTreeNode * node);
1338
1339 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
1340 {
1341     if (row1 > row2) return 1;
1342     if (row1 == row2) return 0;
1343     return -1;
1344 }
1345
1346 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
1347
1348 BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
1349     EVT_PAINT         (wxDataViewMainWindow::OnPaint)
1350     EVT_MOUSE_EVENTS  (wxDataViewMainWindow::OnMouse)
1351     EVT_SET_FOCUS     (wxDataViewMainWindow::OnSetFocus)
1352     EVT_KILL_FOCUS    (wxDataViewMainWindow::OnKillFocus)
1353     EVT_CHAR_HOOK     (wxDataViewMainWindow::OnCharHook)
1354     EVT_CHAR          (wxDataViewMainWindow::OnChar)
1355 END_EVENT_TABLE()
1356
1357 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
1358     const wxPoint &pos, const wxSize &size, const wxString &name ) :
1359     wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE, name ),
1360     m_selection( wxDataViewSelectionCmp )
1361
1362 {
1363     SetOwner( parent );
1364
1365     m_editorRenderer = NULL;
1366
1367     m_lastOnSame = false;
1368     m_renameTimer = new wxDataViewRenameTimer( this );
1369
1370     // TODO: user better initial values/nothing selected
1371     m_currentCol = NULL;
1372     m_currentColSetByKeyboard = false;
1373     m_useCellFocus = false;
1374     m_currentRow = 0;
1375
1376     m_lineHeight = wxMax( 17, GetCharHeight() + 4 ); // 17 = mini icon height + 1
1377
1378 #if wxUSE_DRAG_AND_DROP
1379     m_dragCount = 0;
1380     m_dragStart = wxPoint(0,0);
1381
1382     m_dragEnabled = false;
1383     m_dropEnabled = false;
1384     m_dropHint = false;
1385     m_dropHintLine = (unsigned int) -1;
1386 #endif // wxUSE_DRAG_AND_DROP
1387
1388     m_lineLastClicked = (unsigned int) -1;
1389     m_lineBeforeLastClicked = (unsigned int) -1;
1390     m_lineSelectSingleOnUp = (unsigned int) -1;
1391
1392     m_hasFocus = false;
1393
1394     SetBackgroundColour( *wxWHITE );
1395
1396     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
1397
1398     m_penRule = wxPen(GetRuleColour());
1399
1400     // compose a pen whichcan draw black lines
1401     // TODO: maybe there is something system colour to use
1402     m_penExpander = wxPen(wxColour(0,0,0));
1403
1404     m_root = wxDataViewTreeNode::CreateRootNode();
1405
1406     // Make m_count = -1 will cause the class recaculate the real displaying number of rows.
1407     m_count = -1;
1408     m_underMouse = NULL;
1409     UpdateDisplay();
1410 }
1411
1412 wxDataViewMainWindow::~wxDataViewMainWindow()
1413 {
1414     DestroyTree();
1415     delete m_renameTimer;
1416 }
1417
1418
1419 #if wxUSE_DRAG_AND_DROP
1420 bool wxDataViewMainWindow::EnableDragSource( const wxDataFormat &format )
1421 {
1422     m_dragFormat = format;
1423     m_dragEnabled = format != wxDF_INVALID;
1424
1425     return true;
1426 }
1427
1428 bool wxDataViewMainWindow::EnableDropTarget( const wxDataFormat &format )
1429 {
1430     m_dropFormat = format;
1431     m_dropEnabled = format != wxDF_INVALID;
1432
1433     if (m_dropEnabled)
1434         SetDropTarget( new wxDataViewDropTarget( new wxCustomDataObject( format ), this ) );
1435
1436     return true;
1437 }
1438
1439 void wxDataViewMainWindow::RemoveDropHint()
1440 {
1441     if (m_dropHint)
1442     {
1443             m_dropHint = false;
1444             RefreshRow( m_dropHintLine );
1445             m_dropHintLine = (unsigned int) -1;
1446     }
1447 }
1448
1449 wxDragResult wxDataViewMainWindow::OnDragOver( wxDataFormat format, wxCoord x,
1450                                                wxCoord y, wxDragResult def )
1451 {
1452     int xx = x;
1453     int yy = y;
1454     m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy );
1455     unsigned int row = GetLineAt( yy );
1456
1457     if ((row >= GetRowCount()) || (xx > GetEndOfLastCol()))
1458     {
1459         RemoveDropHint();
1460         return wxDragNone;
1461     }
1462
1463     wxDataViewItem item = GetItemByRow( row );
1464
1465     wxDataViewModel *model = GetModel();
1466
1467     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() );
1468     event.SetEventObject( m_owner );
1469     event.SetItem( item );
1470     event.SetModel( model );
1471     event.SetDataFormat( format );
1472     if (!m_owner->HandleWindowEvent( event ))
1473     {
1474         RemoveDropHint();
1475         return wxDragNone;
1476     }
1477
1478     if (!event.IsAllowed())
1479     {
1480         RemoveDropHint();
1481         return wxDragNone;
1482     }
1483
1484
1485     if (m_dropHint && (row != m_dropHintLine))
1486         RefreshRow( m_dropHintLine );
1487     m_dropHint = true;
1488     m_dropHintLine = row;
1489     RefreshRow( row );
1490
1491     return def;
1492 }
1493
1494 bool wxDataViewMainWindow::OnDrop( wxDataFormat format, wxCoord x, wxCoord y )
1495 {
1496     RemoveDropHint();
1497
1498     int xx = x;
1499     int yy = y;
1500     m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy );
1501     unsigned int row = GetLineAt( yy );
1502
1503     if ((row >= GetRowCount()) || (xx > GetEndOfLastCol()))
1504         return false;
1505
1506     wxDataViewItem item = GetItemByRow( row );
1507
1508     wxDataViewModel *model = GetModel();
1509
1510     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() );
1511     event.SetEventObject( m_owner );
1512     event.SetItem( item );
1513     event.SetModel( model );
1514     event.SetDataFormat( format );
1515     if (!m_owner->HandleWindowEvent( event ))
1516         return false;
1517
1518     if (!event.IsAllowed())
1519         return false;
1520
1521     return true;
1522 }
1523
1524 wxDragResult wxDataViewMainWindow::OnData( wxDataFormat format, wxCoord x, wxCoord y,
1525                                            wxDragResult def )
1526 {
1527     int xx = x;
1528     int yy = y;
1529     m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy );
1530     unsigned int row = GetLineAt( yy );
1531
1532     if ((row >= GetRowCount()) || (xx > GetEndOfLastCol()))
1533         return wxDragNone;
1534
1535     wxDataViewItem item = GetItemByRow( row );
1536
1537     wxDataViewModel *model = GetModel();
1538
1539     wxCustomDataObject *obj = (wxCustomDataObject *) GetDropTarget()->GetDataObject();
1540
1541     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() );
1542     event.SetEventObject( m_owner );
1543     event.SetItem( item );
1544     event.SetModel( model );
1545     event.SetDataFormat( format );
1546     event.SetDataSize( obj->GetSize() );
1547     event.SetDataBuffer( obj->GetData() );
1548     if (!m_owner->HandleWindowEvent( event ))
1549         return wxDragNone;
1550
1551     if (!event.IsAllowed())
1552         return wxDragNone;
1553
1554     return def;
1555 }
1556
1557 void wxDataViewMainWindow::OnLeave()
1558 {
1559     RemoveDropHint();
1560 }
1561
1562 wxBitmap wxDataViewMainWindow::CreateItemBitmap( unsigned int row, int &indent )
1563 {
1564     int height = GetLineHeight( row );
1565     int width = 0;
1566     unsigned int cols = GetOwner()->GetColumnCount();
1567     unsigned int col;
1568     for (col = 0; col < cols; col++)
1569     {
1570         wxDataViewColumn *column = GetOwner()->GetColumnAt(col);
1571         if (column->IsHidden())
1572             continue;      // skip it!
1573         width += column->GetWidth();
1574     }
1575
1576     indent = 0;
1577     if (!IsList())
1578     {
1579         wxDataViewTreeNode *node = GetTreeNodeByRow(row);
1580         indent = GetOwner()->GetIndent() * node->GetIndentLevel();
1581         indent = indent + m_lineHeight;
1582             // try to use the m_lineHeight as the expander space
1583     }
1584     width -= indent;
1585
1586     wxBitmap bitmap( width, height );
1587     wxMemoryDC dc( bitmap );
1588     dc.SetFont( GetFont() );
1589     dc.SetPen( *wxBLACK_PEN );
1590     dc.SetBrush( *wxWHITE_BRUSH );
1591     dc.DrawRectangle( 0,0,width,height );
1592
1593     wxDataViewModel *model = m_owner->GetModel();
1594
1595     wxDataViewColumn * const
1596         expander = GetExpanderColumnOrFirstOne(GetOwner());
1597
1598     int x = 0;
1599     for (col = 0; col < cols; col++)
1600     {
1601         wxDataViewColumn *column = GetOwner()->GetColumnAt( col );
1602         wxDataViewRenderer *cell = column->GetRenderer();
1603
1604         if (column->IsHidden())
1605             continue;       // skip it!
1606
1607         width = column->GetWidth();
1608
1609         if (column == expander)
1610             width -= indent;
1611
1612         wxDataViewItem item = GetItemByRow( row );
1613         cell->PrepareForItem(model, item, column->GetModelColumn());
1614
1615         wxRect item_rect(x, 0, width, height);
1616         item_rect.Deflate(PADDING_RIGHTLEFT, 0);
1617
1618         // dc.SetClippingRegion( item_rect );
1619         cell->WXCallRender(item_rect, &dc, 0);
1620         // dc.DestroyClippingRegion();
1621
1622         x += width;
1623     }
1624
1625     return bitmap;
1626 }
1627
1628 #endif // wxUSE_DRAG_AND_DROP
1629
1630
1631 // Draw focus rect for individual cell. Unlike native focus rect, we render
1632 // this in foreground text color (typically white) to enhance contrast and
1633 // make it visible.
1634 static void DrawSelectedCellFocusRect(wxDC& dc, const wxRect& rect)
1635 {
1636     // (This code is based on wxRendererGeneric::DrawFocusRect and modified.)
1637
1638     // draw the pixels manually because the "dots" in wxPen with wxDOT style
1639     // may be short traits and not really dots
1640     //
1641     // note that to behave in the same manner as DrawRect(), we must exclude
1642     // the bottom and right borders from the rectangle
1643     wxCoord x1 = rect.GetLeft(),
1644             y1 = rect.GetTop(),
1645             x2 = rect.GetRight(),
1646             y2 = rect.GetBottom();
1647
1648     wxDCPenChanger pen(dc, wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
1649
1650     wxCoord z;
1651     for ( z = x1 + 1; z < x2; z += 2 )
1652         dc.DrawPoint(z, rect.GetTop());
1653
1654     wxCoord shift = z == x2 ? 0 : 1;
1655     for ( z = y1 + shift; z < y2; z += 2 )
1656         dc.DrawPoint(x2, z);
1657
1658     shift = z == y2 ? 0 : 1;
1659     for ( z = x2 - shift; z > x1; z -= 2 )
1660         dc.DrawPoint(z, y2);
1661
1662     shift = z == x1 ? 0 : 1;
1663     for ( z = y2 - shift; z > y1; z -= 2 )
1664         dc.DrawPoint(x1, z);
1665 }
1666
1667
1668 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1669 {
1670     wxDataViewModel *model = GetModel();
1671     wxAutoBufferedPaintDC dc( this );
1672
1673 #ifdef __WXMSW__
1674     dc.SetBrush(GetOwner()->GetBackgroundColour());
1675     dc.SetPen( *wxTRANSPARENT_PEN );
1676     dc.DrawRectangle(GetClientSize());
1677 #endif
1678
1679     if ( IsEmpty() )
1680     {
1681         // No items to draw.
1682         return;
1683     }
1684
1685     // prepare the DC
1686     GetOwner()->PrepareDC( dc );
1687     dc.SetFont( GetFont() );
1688
1689     wxRect update = GetUpdateRegion().GetBox();
1690     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
1691
1692     // compute which items needs to be redrawn
1693     unsigned int item_start = GetLineAt( wxMax(0,update.y) );
1694     unsigned int item_count =
1695         wxMin( (int)(  GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1),
1696             (int)(GetRowCount( ) - item_start));
1697     unsigned int item_last = item_start + item_count;
1698
1699     // Send the event to wxDataViewCtrl itself.
1700     wxWindow * const parent = GetParent();
1701     wxDataViewEvent cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT, parent->GetId());
1702     cache_event.SetEventObject(parent);
1703     cache_event.SetCache(item_start, item_last - 1);
1704     parent->ProcessWindowEvent(cache_event);
1705
1706     // compute which columns needs to be redrawn
1707     unsigned int cols = GetOwner()->GetColumnCount();
1708     if ( !cols )
1709     {
1710         // we assume that we have at least one column below and painting an
1711         // empty control is unnecessary anyhow
1712         return;
1713     }
1714
1715     unsigned int col_start = 0;
1716     unsigned int x_start;
1717     for (x_start = 0; col_start < cols; col_start++)
1718     {
1719         wxDataViewColumn *col = GetOwner()->GetColumnAt(col_start);
1720         if (col->IsHidden())
1721             continue;      // skip it!
1722
1723         unsigned int w = col->GetWidth();
1724         if (x_start+w >= (unsigned int)update.x)
1725             break;
1726
1727         x_start += w;
1728     }
1729
1730     unsigned int col_last = col_start;
1731     unsigned int x_last = x_start;
1732     for (; col_last < cols; col_last++)
1733     {
1734         wxDataViewColumn *col = GetOwner()->GetColumnAt(col_last);
1735         if (col->IsHidden())
1736             continue;      // skip it!
1737
1738         if (x_last > (unsigned int)update.GetRight())
1739             break;
1740
1741         x_last += col->GetWidth();
1742     }
1743
1744     // Draw horizontal rules if required
1745     if ( m_owner->HasFlag(wxDV_HORIZ_RULES) )
1746     {
1747         dc.SetPen(m_penRule);
1748         dc.SetBrush(*wxTRANSPARENT_BRUSH);
1749
1750         for (unsigned int i = item_start; i <= item_last; i++)
1751         {
1752             int y = GetLineStart( i );
1753             dc.DrawLine(x_start, y, x_last, y);
1754         }
1755     }
1756
1757     // Draw vertical rules if required
1758     if ( m_owner->HasFlag(wxDV_VERT_RULES) )
1759     {
1760         dc.SetPen(m_penRule);
1761         dc.SetBrush(*wxTRANSPARENT_BRUSH);
1762
1763         // NB: Vertical rules are drawn in the last pixel of a column so that
1764         //     they align perfectly with native MSW wxHeaderCtrl as well as for
1765         //     consistency with MSW native list control. There's no vertical
1766         //     rule at the most-left side of the control.
1767
1768         int x = x_start - 1;
1769         for (unsigned int i = col_start; i < col_last; i++)
1770         {
1771             wxDataViewColumn *col = GetOwner()->GetColumnAt(i);
1772             if (col->IsHidden())
1773                 continue;       // skip it
1774
1775             x += col->GetWidth();
1776
1777             dc.DrawLine(x, GetLineStart( item_start ),
1778                         x, GetLineStart( item_last ) );
1779         }
1780     }
1781
1782     // redraw the background for the items which are selected/current
1783     for (unsigned int item = item_start; item < item_last; item++)
1784     {
1785         bool selected = m_selection.Index( item ) != wxNOT_FOUND;
1786
1787         if (selected || item == m_currentRow)
1788         {
1789             wxRect rect( x_start, GetLineStart( item ),
1790                          x_last - x_start, GetLineHeight( item ) );
1791
1792             // draw selection and whole-item focus:
1793             if ( selected )
1794             {
1795                 int flags = wxCONTROL_SELECTED;
1796                 if (m_hasFocus)
1797                     flags |= wxCONTROL_FOCUSED;
1798
1799                 wxRendererNative::Get().DrawItemSelectionRect
1800                                     (
1801                                         this,
1802                                         dc,
1803                                         rect,
1804                                         flags
1805                                     );
1806             }
1807
1808             // draw keyboard focus rect if applicable
1809             if ( item == m_currentRow && m_hasFocus )
1810             {
1811                 bool renderColumnFocus = false;
1812
1813                 if ( m_useCellFocus && m_currentCol && m_currentColSetByKeyboard )
1814                 {
1815                     renderColumnFocus = true;
1816
1817                     // If this is container node without columns, render full-row focus:
1818                     if ( !IsList() )
1819                     {
1820                         wxDataViewTreeNode *node = GetTreeNodeByRow(item);
1821                         if ( node->HasChildren() && !model->HasContainerColumns(node->GetItem()) )
1822                             renderColumnFocus = false;
1823                     }
1824                 }
1825
1826                 if ( renderColumnFocus )
1827                 {
1828                     for ( unsigned int i = col_start; i < col_last; i++ )
1829                     {
1830                         wxDataViewColumn *col = GetOwner()->GetColumnAt(i);
1831                         if ( col->IsHidden() )
1832                             continue;
1833
1834                         rect.width = col->GetWidth();
1835
1836                         if ( col == m_currentCol )
1837                         {
1838                             // make the rect more visible by adding a small
1839                             // margin around it:
1840                             rect.Deflate(1, 1);
1841
1842                             if ( selected )
1843                             {
1844                                 // DrawFocusRect() uses XOR and is all but
1845                                 // invisible against dark-blue background. Use
1846                                 // the same color used for selected text.
1847                                 DrawSelectedCellFocusRect(dc, rect);
1848                             }
1849                             else
1850                             {
1851                                 wxRendererNative::Get().DrawFocusRect
1852                                                     (
1853                                                         this,
1854                                                         dc,
1855                                                         rect,
1856                                                         0
1857                                                 );
1858                             }
1859                             break;
1860                         }
1861
1862                         rect.x += rect.width;
1863                     }
1864                 }
1865                 else
1866                 {
1867                     // render focus rectangle for the whole row
1868                     wxRendererNative::Get().DrawFocusRect
1869                                         (
1870                                             this,
1871                                             dc,
1872                                             rect,
1873                                             selected ? (int)wxCONTROL_SELECTED : 0
1874                                         );
1875                 }
1876             }
1877         }
1878     }
1879
1880 #if wxUSE_DRAG_AND_DROP
1881     if (m_dropHint)
1882     {
1883         wxRect rect( x_start, GetLineStart( m_dropHintLine ),
1884                      x_last - x_start, GetLineHeight( m_dropHintLine ) );
1885         dc.SetPen( *wxBLACK_PEN );
1886         dc.SetBrush( *wxTRANSPARENT_BRUSH );
1887         dc.DrawRectangle( rect );
1888     }
1889 #endif // wxUSE_DRAG_AND_DROP
1890
1891     wxDataViewColumn * const
1892         expander = GetExpanderColumnOrFirstOne(GetOwner());
1893
1894     // redraw all cells for all rows which must be repainted and all columns
1895     wxRect cell_rect;
1896     cell_rect.x = x_start;
1897     for (unsigned int i = col_start; i < col_last; i++)
1898     {
1899         wxDataViewColumn *col = GetOwner()->GetColumnAt( i );
1900         wxDataViewRenderer *cell = col->GetRenderer();
1901         cell_rect.width = col->GetWidth();
1902
1903         if ( col->IsHidden() || cell_rect.width <= 0 )
1904             continue;       // skip it!
1905
1906         for (unsigned int item = item_start; item < item_last; item++)
1907         {
1908             // get the cell value and set it into the renderer
1909             wxDataViewTreeNode *node = NULL;
1910             wxDataViewItem dataitem;
1911
1912             if (!IsVirtualList())
1913             {
1914                 node = GetTreeNodeByRow(item);
1915                 if( node == NULL )
1916                     continue;
1917
1918                 dataitem = node->GetItem();
1919
1920                 // Skip all columns of "container" rows except the expander
1921                 // column itself unless HasContainerColumns() overrides this.
1922                 if ( col != expander &&
1923                         model->IsContainer(dataitem) &&
1924                             !model->HasContainerColumns(dataitem) )
1925                     continue;
1926             }
1927             else
1928             {
1929                 dataitem = wxDataViewItem( wxUIntToPtr(item+1) );
1930             }
1931
1932             cell->PrepareForItem(model, dataitem, col->GetModelColumn());
1933
1934             // update cell_rect
1935             cell_rect.y = GetLineStart( item );
1936             cell_rect.height = GetLineHeight( item );
1937
1938             // deal with the expander
1939             int indent = 0;
1940             if ((!IsList()) && (col == expander))
1941             {
1942                 // Calculate the indent first
1943                 indent = GetOwner()->GetIndent() * node->GetIndentLevel();
1944
1945                 // we reserve m_lineHeight of horizontal space for the expander
1946                 // but leave EXPANDER_MARGIN around the expander itself
1947                 int exp_x = cell_rect.x + indent + EXPANDER_MARGIN;
1948
1949                 indent += m_lineHeight;
1950
1951                 // draw expander if needed and visible
1952                 if ( node->HasChildren() && exp_x < cell_rect.GetRight() )
1953                 {
1954                     dc.SetPen( m_penExpander );
1955                     dc.SetBrush( wxNullBrush );
1956
1957                     int exp_size = m_lineHeight - 2*EXPANDER_MARGIN;
1958                     int exp_y = cell_rect.y + (cell_rect.height - exp_size)/2
1959                                    + EXPANDER_MARGIN - EXPANDER_OFFSET;
1960
1961                     const wxRect rect(exp_x, exp_y, exp_size, exp_size);
1962
1963                     int flag = 0;
1964                     if ( m_underMouse == node )
1965                         flag |= wxCONTROL_CURRENT;
1966                     if ( node->IsOpen() )
1967                         flag |= wxCONTROL_EXPANDED;
1968
1969                     // ensure that we don't overflow the cell (which might
1970                     // happen if the column is very narrow)
1971                     wxDCClipper clip(dc, cell_rect);
1972
1973                     wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag);
1974                 }
1975
1976                 // force the expander column to left-center align
1977                 cell->SetAlignment( wxALIGN_CENTER_VERTICAL );
1978             }
1979
1980             wxRect item_rect = cell_rect;
1981             item_rect.Deflate(PADDING_RIGHTLEFT, 0);
1982
1983             // account for the tree indent (harmless if we're not indented)
1984             item_rect.x += indent;
1985             item_rect.width -= indent;
1986
1987             if ( item_rect.width <= 0 )
1988                 continue;
1989
1990             int state = 0;
1991             if (m_hasFocus && (m_selection.Index(item) != wxNOT_FOUND))
1992                 state |= wxDATAVIEW_CELL_SELECTED;
1993
1994             // TODO: it would be much more efficient to create a clipping
1995             //       region for the entire column being rendered (in the OnPaint
1996             //       of wxDataViewMainWindow) instead of a single clip region for
1997             //       each cell. However it would mean that each renderer should
1998             //       respect the given wxRect's top & bottom coords, eventually
1999             //       violating only the left & right coords - however the user can
2000             //       make its own renderer and thus we cannot be sure of that.
2001             wxDCClipper clip(dc, item_rect);
2002
2003             cell->WXCallRender(item_rect, &dc, state);
2004         }
2005
2006         cell_rect.x += cell_rect.width;
2007     }
2008 }
2009
2010 void wxDataViewMainWindow::OnRenameTimer()
2011 {
2012     // We have to call this here because changes may just have
2013     // been made and no screen update taken place.
2014     if ( m_dirty )
2015     {
2016         // TODO: use wxTheApp->SafeYieldFor(NULL, wxEVT_CATEGORY_UI) instead
2017         //       (needs to be tested!)
2018         wxSafeYield();
2019     }
2020
2021     wxDataViewItem item = GetItemByRow( m_currentRow );
2022
2023     StartEditing( item, m_currentCol );
2024 }
2025
2026 void
2027 wxDataViewMainWindow::StartEditing(const wxDataViewItem& item,
2028                                    const wxDataViewColumn* col)
2029 {
2030     wxDataViewRenderer* renderer = col->GetRenderer();
2031     if (renderer->GetMode() != wxDATAVIEW_CELL_EDITABLE)
2032         return;
2033
2034     const wxRect itemRect = GetItemRect(item, col);
2035     if ( renderer->StartEditing(item, itemRect) )
2036     {
2037         // Save the renderer to be able to finish/cancel editing it later and
2038         // save the control to be able to detect if we're still editing it.
2039         m_editorRenderer = renderer;
2040         m_editorCtrl = renderer->GetEditorCtrl();
2041     }
2042 }
2043
2044 //-----------------------------------------------------------------------------
2045 // Helper class for do operation on the tree node
2046 //-----------------------------------------------------------------------------
2047 class DoJob
2048 {
2049 public:
2050     DoJob() { }
2051     virtual ~DoJob() { }
2052
2053     // The return value control how the tree-walker tranverse the tree
2054     enum
2055     {
2056         DONE,          // Job done, stop traversing and return
2057         SKIP_SUBTREE,  // Ignore the current node's subtree and continue
2058         CONTINUE       // Job not done, continue
2059     };
2060
2061     virtual int operator() ( wxDataViewTreeNode * node ) = 0;
2062 };
2063
2064 bool Walker( wxDataViewTreeNode * node, DoJob & func )
2065 {
2066     wxCHECK_MSG( node, false, "can't walk NULL node" );
2067
2068     switch( func( node ) )
2069     {
2070         case DoJob::DONE:
2071             return true;
2072         case DoJob::SKIP_SUBTREE:
2073             return false;
2074         case DoJob::CONTINUE:
2075             break;
2076     }
2077
2078     if ( node->HasChildren() )
2079     {
2080         const wxDataViewTreeNodes& nodes = node->GetChildNodes();
2081
2082         for ( wxDataViewTreeNodes::const_iterator i = nodes.begin();
2083               i != nodes.end();
2084               ++i )
2085         {
2086             if ( Walker(*i, func) )
2087                 return true;
2088         }
2089     }
2090
2091     return false;
2092 }
2093
2094 bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item)
2095 {
2096     if (IsVirtualList())
2097     {
2098         wxDataViewVirtualListModel *list_model =
2099             (wxDataViewVirtualListModel*) GetModel();
2100         m_count = list_model->GetCount();
2101     }
2102     else
2103     {
2104         SortPrepare();
2105
2106         wxDataViewTreeNode *parentNode = FindNode(parent);
2107
2108         if ( !parentNode )
2109             return false;
2110
2111         wxDataViewItemArray modelSiblings;
2112         GetModel()->GetChildren(parent, modelSiblings);
2113         const int modelSiblingsSize = modelSiblings.size();
2114
2115         int posInModel = modelSiblings.Index(item, /*fromEnd=*/true);
2116         wxCHECK_MSG( posInModel != wxNOT_FOUND, false, "adding non-existent item?" );
2117
2118         wxDataViewTreeNode *itemNode = new wxDataViewTreeNode(parentNode, item);
2119         itemNode->SetHasChildren(GetModel()->IsContainer(item));
2120
2121         parentNode->SetHasChildren(true);
2122
2123         const wxDataViewTreeNodes& nodeSiblings = parentNode->GetChildNodes();
2124         const int nodeSiblingsSize = nodeSiblings.size();
2125
2126         int nodePos = 0;
2127
2128         if ( posInModel == modelSiblingsSize - 1 )
2129         {
2130             nodePos = nodeSiblingsSize;
2131         }
2132         else if ( modelSiblingsSize == nodeSiblingsSize + 1 )
2133         {
2134             // This is the simple case when our node tree already matches the
2135             // model and only this one item is missing.
2136             nodePos = posInModel;
2137         }
2138         else
2139         {
2140             // It's possible that a larger discrepancy between the model and
2141             // our realization exists. This can happen e.g. when adding a bunch
2142             // of items to the model and then calling ItemsAdded() just once
2143             // afterwards. In this case, we must find the right position by
2144             // looking at sibling items.
2145
2146             // append to the end if we won't find a better position:
2147             nodePos = nodeSiblingsSize;
2148
2149             for ( int nextItemPos = posInModel + 1;
2150                   nextItemPos < modelSiblingsSize;
2151                   nextItemPos++ )
2152             {
2153                 int nextNodePos = parentNode->FindChildByItem(modelSiblings[nextItemPos]);
2154                 if ( nextNodePos != wxNOT_FOUND )
2155                 {
2156                     nodePos = nextNodePos;
2157                     break;
2158                 }
2159             }
2160         }
2161
2162         parentNode->ChangeSubTreeCount(+1);
2163         parentNode->InsertChild(itemNode, nodePos);
2164
2165         m_count = -1;
2166     }
2167
2168     GetOwner()->InvalidateColBestWidths();
2169     UpdateDisplay();
2170
2171     return true;
2172 }
2173
2174 bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent,
2175                                        const wxDataViewItem& item)
2176 {
2177     if (IsVirtualList())
2178     {
2179         wxDataViewVirtualListModel *list_model =
2180             (wxDataViewVirtualListModel*) GetModel();
2181         m_count = list_model->GetCount();
2182
2183         if ( !m_selection.empty() )
2184         {
2185             const int row = GetRowByItem(item);
2186
2187             int rowIndexInSelection = wxNOT_FOUND;
2188
2189             const size_t selCount = m_selection.size();
2190             for ( size_t i = 0; i < selCount; i++ )
2191             {
2192                 if ( m_selection[i] == (unsigned)row )
2193                     rowIndexInSelection = i;
2194                 else if ( m_selection[i] > (unsigned)row )
2195                     m_selection[i]--;
2196             }
2197
2198             if ( rowIndexInSelection != wxNOT_FOUND )
2199                 m_selection.RemoveAt(rowIndexInSelection);
2200         }
2201
2202     }
2203     else // general case
2204     {
2205         wxDataViewTreeNode *parentNode = FindNode(parent);
2206
2207         // Notice that it is possible that the item being deleted is not in the
2208         // tree at all, for example we could be deleting a never shown (because
2209         // collapsed) item in a tree model. So it's not an error if we don't know
2210         // about this item, just return without doing anything then.
2211         if ( !parentNode )
2212             return true;
2213
2214         wxCHECK_MSG( parentNode->HasChildren(), false, "parent node doesn't have children?" );
2215         const wxDataViewTreeNodes& parentsChildren = parentNode->GetChildNodes();
2216
2217         // We can't use FindNode() to find 'item', because it was already
2218         // removed from the model by the time ItemDeleted() is called, so we
2219         // have to do it manually. We keep track of its position as well for
2220         // later use.
2221         int itemPosInNode = 0;
2222         wxDataViewTreeNode *itemNode = NULL;
2223         for ( wxDataViewTreeNodes::const_iterator i = parentsChildren.begin();
2224               i != parentsChildren.end();
2225               ++i, ++itemPosInNode )
2226         {
2227             if( (*i)->GetItem() == item )
2228             {
2229                 itemNode = *i;
2230                 break;
2231             }
2232         }
2233
2234         // If the parent wasn't expanded, it's possible that we didn't have a
2235         // node corresponding to 'item' and so there's nothing left to do.
2236         if ( !itemNode )
2237         {
2238             // If this was the last child to be removed, it's possible the parent
2239             // node became a leaf. Let's ask the model about it.
2240             if ( parentNode->GetChildNodes().empty() )
2241                 parentNode->SetHasChildren(GetModel()->IsContainer(parent));
2242
2243             return true;
2244         }
2245
2246         // Delete the item from wxDataViewTreeNode representation:
2247         const int itemsDeleted = 1 + itemNode->GetSubTreeCount();
2248
2249         parentNode->RemoveChild(itemNode);
2250         delete itemNode;
2251         parentNode->ChangeSubTreeCount(-itemsDeleted);
2252
2253         // Make the row number invalid and get a new valid one when user call GetRowCount
2254         m_count = -1;
2255
2256         // If this was the last child to be removed, it's possible the parent
2257         // node became a leaf. Let's ask the model about it.
2258         if ( parentNode->GetChildNodes().empty() )
2259             parentNode->SetHasChildren(GetModel()->IsContainer(parent));
2260
2261         // Update selection by removing 'item' and its entire children tree from the selection.
2262         if ( !m_selection.empty() )
2263         {
2264             // we can't call GetRowByItem() on 'item', as it's already deleted, so compute it from
2265             // the parent ('parentNode') and position in its list of children
2266             int itemRow;
2267             if ( itemPosInNode == 0 )
2268             {
2269                 // 1st child, row number is that of the parent parentNode + 1
2270                 itemRow = GetRowByItem(parentNode->GetItem()) + 1;
2271             }
2272             else
2273             {
2274                 // row number is that of the sibling above 'item' + its subtree if any + 1
2275                 const wxDataViewTreeNode *siblingNode = parentNode->GetChildNodes()[itemPosInNode - 1];
2276
2277                 itemRow = GetRowByItem(siblingNode->GetItem()) +
2278                           siblingNode->GetSubTreeCount() +
2279                           1;
2280             }
2281
2282             wxDataViewSelection newsel(wxDataViewSelectionCmp);
2283
2284             const size_t numSelections = m_selection.size();
2285             for ( size_t i = 0; i < numSelections; ++i )
2286             {
2287                 const int s = m_selection[i];
2288                 if ( s < itemRow )
2289                     newsel.push_back(s);
2290                 else if ( s >= itemRow + itemsDeleted )
2291                     newsel.push_back(s - itemsDeleted);
2292                 // else: deleted item, remove from selection
2293             }
2294
2295             m_selection = newsel;
2296         }
2297     }
2298
2299     // Change the current row to the last row if the current exceed the max row number
2300     if( m_currentRow > GetRowCount() )
2301         ChangeCurrentRow(m_count - 1);
2302
2303     GetOwner()->InvalidateColBestWidths();
2304     UpdateDisplay();
2305
2306     return true;
2307 }
2308
2309 bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item)
2310 {
2311     SortPrepare();
2312     g_model->Resort();
2313
2314     GetOwner()->InvalidateColBestWidths();
2315
2316     // Send event
2317     wxWindow *parent = GetParent();
2318     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
2319     le.SetEventObject(parent);
2320     le.SetModel(GetModel());
2321     le.SetItem(item);
2322     parent->ProcessWindowEvent(le);
2323
2324     return true;
2325 }
2326
2327 bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int model_column )
2328 {
2329     int view_column = -1;
2330     unsigned int n_col = m_owner->GetColumnCount();
2331     for (unsigned i = 0; i < n_col; i++)
2332     {
2333         wxDataViewColumn *column = m_owner->GetColumn( i );
2334         if (column->GetModelColumn() == model_column)
2335         {
2336             view_column = (int) i;
2337             break;
2338         }
2339     }
2340     if (view_column == -1)
2341         return false;
2342
2343     // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
2344 /*#define MAX_VIRTUAL_WIDTH       100000
2345
2346     wxRect rect( 0, row*m_lineHeight, MAX_VIRTUAL_WIDTH, m_lineHeight );
2347     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2348     Refresh( true, &rect );
2349
2350     return true;
2351 */
2352     SortPrepare();
2353     g_model->Resort();
2354
2355     GetOwner()->InvalidateColBestWidth(view_column);
2356
2357     // Send event
2358     wxWindow *parent = GetParent();
2359     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
2360     le.SetEventObject(parent);
2361     le.SetModel(GetModel());
2362     le.SetItem(item);
2363     le.SetColumn(view_column);
2364     le.SetDataViewColumn(GetOwner()->GetColumn(view_column));
2365     parent->ProcessWindowEvent(le);
2366
2367     return true;
2368 }
2369
2370 bool wxDataViewMainWindow::Cleared()
2371 {
2372     DestroyTree();
2373     m_selection.Clear();
2374
2375     SortPrepare();
2376     BuildTree( GetModel() );
2377
2378     GetOwner()->InvalidateColBestWidths();
2379     UpdateDisplay();
2380
2381     return true;
2382 }
2383
2384 void wxDataViewMainWindow::UpdateDisplay()
2385 {
2386     m_dirty = true;
2387     m_underMouse = NULL;
2388 }
2389
2390 void wxDataViewMainWindow::OnInternalIdle()
2391 {
2392     wxWindow::OnInternalIdle();
2393
2394     if (m_dirty)
2395     {
2396         RecalculateDisplay();
2397         m_dirty = false;
2398     }
2399 }
2400
2401 void wxDataViewMainWindow::RecalculateDisplay()
2402 {
2403     wxDataViewModel *model = GetModel();
2404     if (!model)
2405     {
2406         Refresh();
2407         return;
2408     }
2409
2410     int width = GetEndOfLastCol();
2411     int height = GetLineStart( GetRowCount() );
2412
2413     SetVirtualSize( width, height );
2414     GetOwner()->SetScrollRate( 10, m_lineHeight );
2415
2416     Refresh();
2417 }
2418
2419 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
2420 {
2421     m_underMouse = NULL;
2422
2423     wxWindow::ScrollWindow( dx, dy, rect );
2424
2425     if (GetOwner()->m_headerArea)
2426         GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
2427 }
2428
2429 void wxDataViewMainWindow::ScrollTo( int rows, int column )
2430 {
2431     m_underMouse = NULL;
2432
2433     int x, y;
2434     m_owner->GetScrollPixelsPerUnit( &x, &y );
2435     int sy = GetLineStart( rows )/y;
2436     int sx = 0;
2437     if( column != -1 )
2438     {
2439         wxRect rect = GetClientRect();
2440         int colnum = 0;
2441         int x_start, w = 0;
2442         int xx, yy, xe;
2443         m_owner->CalcUnscrolledPosition( rect.x, rect.y, &xx, &yy );
2444         for (x_start = 0; colnum < column; colnum++)
2445         {
2446             wxDataViewColumn *col = GetOwner()->GetColumnAt(colnum);
2447             if (col->IsHidden())
2448                 continue;      // skip it!
2449
2450             w = col->GetWidth();
2451             x_start += w;
2452         }
2453
2454         int x_end = x_start + w;
2455         xe = xx + rect.width;
2456         if( x_end > xe )
2457         {
2458             sx = ( xx + x_end - xe )/x;
2459         }
2460         if( x_start < xx )
2461         {
2462             sx = x_start/x;
2463         }
2464     }
2465     m_owner->Scroll( sx, sy );
2466 }
2467
2468 int wxDataViewMainWindow::GetCountPerPage() const
2469 {
2470     wxSize size = GetClientSize();
2471     return size.y / m_lineHeight;
2472 }
2473
2474 int wxDataViewMainWindow::GetEndOfLastCol() const
2475 {
2476     int width = 0;
2477     unsigned int i;
2478     for (i = 0; i < GetOwner()->GetColumnCount(); i++)
2479     {
2480         const wxDataViewColumn *c =
2481             const_cast<wxDataViewCtrl*>(GetOwner())->GetColumnAt( i );
2482
2483         if (!c->IsHidden())
2484             width += c->GetWidth();
2485     }
2486     return width;
2487 }
2488
2489 unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const
2490 {
2491     int x = 0;
2492     int y = 0;
2493     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
2494
2495     return GetLineAt( y );
2496 }
2497
2498 unsigned int wxDataViewMainWindow::GetLastVisibleRow()
2499 {
2500     wxSize client_size = GetClientSize();
2501     m_owner->CalcUnscrolledPosition( client_size.x, client_size.y,
2502                                     &client_size.x, &client_size.y );
2503
2504     // we should deal with the pixel here
2505     unsigned int row = GetLineAt(client_size.y) - 1;
2506
2507     return wxMin( GetRowCount()-1, row );
2508 }
2509
2510 unsigned int wxDataViewMainWindow::GetRowCount()
2511 {
2512     if ( m_count == -1 )
2513     {
2514         m_count = RecalculateCount();
2515         UpdateDisplay();
2516     }
2517     return m_count;
2518 }
2519
2520 void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
2521 {
2522     m_currentRow = row;
2523
2524     // send event
2525 }
2526
2527 void wxDataViewMainWindow::SelectAllRows( bool on )
2528 {
2529     if (IsEmpty())
2530         return;
2531
2532     if (on)
2533     {
2534         m_selection.Clear();
2535         for (unsigned int i = 0; i < GetRowCount(); i++)
2536             m_selection.Add( i );
2537         Refresh();
2538     }
2539     else
2540     {
2541         unsigned int first_visible = GetFirstVisibleRow();
2542         unsigned int last_visible = GetLastVisibleRow();
2543         unsigned int i;
2544         for (i = 0; i < m_selection.GetCount(); i++)
2545         {
2546             unsigned int row = m_selection[i];
2547             if ((row >= first_visible) && (row <= last_visible))
2548                 RefreshRow( row );
2549         }
2550         m_selection.Clear();
2551     }
2552 }
2553
2554 void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
2555 {
2556     if (m_selection.Index( row ) == wxNOT_FOUND)
2557     {
2558         if (on)
2559         {
2560             m_selection.Add( row );
2561             RefreshRow( row );
2562         }
2563     }
2564     else
2565     {
2566         if (!on)
2567         {
2568             m_selection.Remove( row );
2569             RefreshRow( row );
2570         }
2571     }
2572 }
2573
2574 void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
2575 {
2576     if (from > to)
2577     {
2578         unsigned int tmp = from;
2579         from = to;
2580         to = tmp;
2581     }
2582
2583     unsigned int i;
2584     for (i = from; i <= to; i++)
2585     {
2586         if (m_selection.Index( i ) == wxNOT_FOUND)
2587         {
2588             if (on)
2589                 m_selection.Add( i );
2590         }
2591         else
2592         {
2593             if (!on)
2594                 m_selection.Remove( i );
2595         }
2596     }
2597     RefreshRows( from, to );
2598 }
2599
2600 void wxDataViewMainWindow::Select( const wxArrayInt& aSelections )
2601 {
2602     for (size_t i=0; i < aSelections.GetCount(); i++)
2603     {
2604         int n = aSelections[i];
2605
2606         m_selection.Add( n );
2607         RefreshRow( n );
2608     }
2609 }
2610
2611 void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
2612 {
2613     if (m_selection.Index( row ) == wxNOT_FOUND)
2614         m_selection.Add( row );
2615     else
2616         m_selection.Remove( row );
2617     RefreshRow( row );
2618 }
2619
2620 bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
2621 {
2622     return (m_selection.Index( row ) != wxNOT_FOUND);
2623 }
2624
2625 void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem& item)
2626 {
2627     wxWindow *parent = GetParent();
2628     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, parent->GetId());
2629
2630     le.SetEventObject(parent);
2631     le.SetModel(GetModel());
2632     le.SetItem( item );
2633
2634     parent->ProcessWindowEvent(le);
2635 }
2636
2637 void wxDataViewMainWindow::RefreshRow( unsigned int row )
2638 {
2639     wxRect rect( 0, GetLineStart( row ), GetEndOfLastCol(), GetLineHeight( row ) );
2640     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2641
2642     wxSize client_size = GetClientSize();
2643     wxRect client_rect( 0, 0, client_size.x, client_size.y );
2644     wxRect intersect_rect = client_rect.Intersect( rect );
2645     if (intersect_rect.width > 0)
2646         Refresh( true, &intersect_rect );
2647 }
2648
2649 void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
2650 {
2651     if (from > to)
2652     {
2653         unsigned int tmp = to;
2654         to = from;
2655         from = tmp;
2656     }
2657
2658     wxRect rect( 0, GetLineStart( from ), GetEndOfLastCol(), GetLineStart( (to-from+1) ) );
2659     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2660
2661     wxSize client_size = GetClientSize();
2662     wxRect client_rect( 0, 0, client_size.x, client_size.y );
2663     wxRect intersect_rect = client_rect.Intersect( rect );
2664     if (intersect_rect.width > 0)
2665         Refresh( true, &intersect_rect );
2666 }
2667
2668 void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
2669 {
2670     wxSize client_size = GetClientSize();
2671     int start = GetLineStart( firstRow );
2672     m_owner->CalcScrolledPosition( start, 0, &start, NULL );
2673     if (start > client_size.y) return;
2674
2675     wxRect rect( 0, start, client_size.x, client_size.y - start );
2676
2677     Refresh( true, &rect );
2678 }
2679
2680 wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const
2681 {
2682     wxRect rect;
2683     rect.x = 0;
2684     rect.y = GetLineStart( row );
2685     rect.width = GetEndOfLastCol();
2686     rect.height = GetLineHeight( row );
2687
2688     return rect;
2689 }
2690
2691 int wxDataViewMainWindow::GetLineStart( unsigned int row ) const
2692 {
2693     const wxDataViewModel *model = GetModel();
2694
2695     if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2696     {
2697         // TODO make more efficient
2698
2699         int start = 0;
2700
2701         unsigned int r;
2702         for (r = 0; r < row; r++)
2703         {
2704             const wxDataViewTreeNode* node = GetTreeNodeByRow(r);
2705             if (!node) return start;
2706
2707             wxDataViewItem item = node->GetItem();
2708
2709             unsigned int cols = GetOwner()->GetColumnCount();
2710             unsigned int col;
2711             int height = m_lineHeight;
2712             for (col = 0; col < cols; col++)
2713             {
2714                 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2715                 if (column->IsHidden())
2716                     continue;      // skip it!
2717
2718                 if ((col != 0) &&
2719                     model->IsContainer(item) &&
2720                     !model->HasContainerColumns(item))
2721                     continue;      // skip it!
2722
2723                 wxDataViewRenderer *renderer =
2724                     const_cast<wxDataViewRenderer*>(column->GetRenderer());
2725                 renderer->PrepareForItem(model, item, column->GetModelColumn());
2726
2727                 height = wxMax( height, renderer->GetSize().y );
2728             }
2729
2730             start += height;
2731         }
2732
2733         return start;
2734     }
2735     else
2736     {
2737         return row * m_lineHeight;
2738     }
2739 }
2740
2741 int wxDataViewMainWindow::GetLineAt( unsigned int y ) const
2742 {
2743     const wxDataViewModel *model = GetModel();
2744
2745     // check for the easy case first
2746     if ( !GetOwner()->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) )
2747         return y / m_lineHeight;
2748
2749     // TODO make more efficient
2750     unsigned int row = 0;
2751     unsigned int yy = 0;
2752     for (;;)
2753     {
2754         const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
2755         if (!node)
2756         {
2757             // not really correct...
2758             return row + ((y-yy) / m_lineHeight);
2759         }
2760
2761         wxDataViewItem item = node->GetItem();
2762
2763         unsigned int cols = GetOwner()->GetColumnCount();
2764         unsigned int col;
2765         int height = m_lineHeight;
2766         for (col = 0; col < cols; col++)
2767         {
2768             const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2769             if (column->IsHidden())
2770                 continue;      // skip it!
2771
2772             if ((col != 0) &&
2773                 model->IsContainer(item) &&
2774                 !model->HasContainerColumns(item))
2775                 continue;      // skip it!
2776
2777             wxDataViewRenderer *renderer =
2778                 const_cast<wxDataViewRenderer*>(column->GetRenderer());
2779             renderer->PrepareForItem(model, item, column->GetModelColumn());
2780
2781             height = wxMax( height, renderer->GetSize().y );
2782         }
2783
2784         yy += height;
2785         if (y < yy)
2786             return row;
2787
2788         row++;
2789     }
2790 }
2791
2792 int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const
2793 {
2794     const wxDataViewModel *model = GetModel();
2795
2796     if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2797     {
2798         wxASSERT( !IsVirtualList() );
2799
2800         const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
2801         // wxASSERT( node );
2802         if (!node) return m_lineHeight;
2803
2804         wxDataViewItem item = node->GetItem();
2805
2806         int height = m_lineHeight;
2807
2808         unsigned int cols = GetOwner()->GetColumnCount();
2809         unsigned int col;
2810         for (col = 0; col < cols; col++)
2811         {
2812             const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2813             if (column->IsHidden())
2814                 continue;      // skip it!
2815
2816             if ((col != 0) &&
2817                 model->IsContainer(item) &&
2818                 !model->HasContainerColumns(item))
2819                 continue;      // skip it!
2820
2821             wxDataViewRenderer *renderer =
2822                 const_cast<wxDataViewRenderer*>(column->GetRenderer());
2823             renderer->PrepareForItem(model, item, column->GetModelColumn());
2824
2825             height = wxMax( height, renderer->GetSize().y );
2826         }
2827
2828         return height;
2829     }
2830     else
2831     {
2832         return m_lineHeight;
2833     }
2834 }
2835
2836
2837 class RowToTreeNodeJob: public DoJob
2838 {
2839 public:
2840     RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node )
2841     {
2842         this->row = row;
2843         this->current = current;
2844         ret = NULL;
2845         parent = node;
2846     }
2847
2848     virtual int operator() ( wxDataViewTreeNode * node )
2849     {
2850         current ++;
2851         if( current == static_cast<int>(row))
2852         {
2853             ret = node;
2854             return DoJob::DONE;
2855         }
2856
2857         if( node->GetSubTreeCount() + current < static_cast<int>(row) )
2858         {
2859             current += node->GetSubTreeCount();
2860             return  DoJob::SKIP_SUBTREE;
2861         }
2862         else
2863         {
2864             parent = node;
2865
2866             // If the current node has only leaf children, we can find the
2867             // desired node directly. This can speed up finding the node
2868             // in some cases, and will have a very good effect for list views.
2869             if ( node->HasChildren() &&
2870                  (int)node->GetChildNodes().size() == node->GetSubTreeCount() )
2871             {
2872                 const int index = static_cast<int>(row) - current - 1;
2873                 ret = node->GetChildNodes()[index];
2874                 return DoJob::DONE;
2875             }
2876
2877             return DoJob::CONTINUE;
2878         }
2879     }
2880
2881     wxDataViewTreeNode * GetResult() const
2882         { return ret; }
2883
2884 private:
2885     unsigned int row;
2886     int current;
2887     wxDataViewTreeNode * ret;
2888     wxDataViewTreeNode * parent;
2889 };
2890
2891 wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const
2892 {
2893     wxASSERT( !IsVirtualList() );
2894
2895     RowToTreeNodeJob job( row , -2, m_root );
2896     Walker( m_root , job );
2897     return job.GetResult();
2898 }
2899
2900 wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const
2901 {
2902     if (IsVirtualList())
2903     {
2904         return wxDataViewItem( wxUIntToPtr(row+1) );
2905     }
2906     else
2907     {
2908         wxDataViewTreeNode *node = GetTreeNodeByRow(row);
2909         return node ? node->GetItem() : wxDataViewItem();
2910     }
2911 }
2912
2913 bool
2914 wxDataViewMainWindow::SendExpanderEvent(wxEventType type,
2915                                         const wxDataViewItem& item)
2916 {
2917     wxWindow *parent = GetParent();
2918     wxDataViewEvent le(type, parent->GetId());
2919
2920     le.SetEventObject(parent);
2921     le.SetModel(GetModel());
2922     le.SetItem( item );
2923
2924     return !parent->ProcessWindowEvent(le) || le.IsAllowed();
2925 }
2926
2927 bool wxDataViewMainWindow::IsExpanded( unsigned int row ) const
2928 {
2929     if (IsList())
2930         return false;
2931
2932     wxDataViewTreeNode * node = GetTreeNodeByRow(row);
2933     if (!node)
2934         return false;
2935
2936     if (!node->HasChildren())
2937         return false;
2938
2939     return node->IsOpen();
2940 }
2941
2942 bool wxDataViewMainWindow::HasChildren( unsigned int row ) const
2943 {
2944     if (IsList())
2945         return false;
2946
2947     wxDataViewTreeNode * node = GetTreeNodeByRow(row);
2948     if (!node)
2949         return false;
2950
2951     if (!node->HasChildren())
2952         return false;
2953
2954     return true;
2955 }
2956
2957 void wxDataViewMainWindow::Expand( unsigned int row )
2958 {
2959     if (IsList())
2960         return;
2961
2962     wxDataViewTreeNode * node = GetTreeNodeByRow(row);
2963     if (!node)
2964         return;
2965
2966     if (!node->HasChildren())
2967         return;
2968
2969             if (!node->IsOpen())
2970             {
2971                 if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, node->GetItem()) )
2972                 {
2973                     // Vetoed by the event handler.
2974                     return;
2975                 }
2976
2977                 node->ToggleOpen();
2978
2979                 // build the children of current node
2980                 if( node->GetChildNodes().empty() )
2981                 {
2982                     SortPrepare();
2983                     ::BuildTreeHelper(GetModel(), node->GetItem(), node);
2984                 }
2985
2986                 // By expanding the node all row indices that are currently in the selection list
2987                 // and are greater than our node have become invalid. So we have to correct that now.
2988                 const unsigned rowAdjustment = node->GetSubTreeCount();
2989                 for(unsigned i=0; i<m_selection.size(); ++i)
2990                 {
2991                     const unsigned testRow = m_selection[i];
2992                     // all rows above us are not affected, so skip them
2993                     if(testRow <= row)
2994                         continue;
2995
2996                     m_selection[i] += rowAdjustment;
2997                 }
2998
2999                 if(m_currentRow > row)
3000                     ChangeCurrentRow(m_currentRow + rowAdjustment);
3001
3002                 m_count = -1;
3003                 UpdateDisplay();
3004                 // Send the expanded event
3005                 SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem());
3006             }
3007 }
3008
3009 void wxDataViewMainWindow::Collapse(unsigned int row)
3010 {
3011     if (IsList())
3012         return;
3013
3014     wxDataViewTreeNode *node = GetTreeNodeByRow(row);
3015     if (!node)
3016         return;
3017
3018     if (!node->HasChildren())
3019         return;
3020
3021         if (node->IsOpen())
3022         {
3023             if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem()) )
3024             {
3025                 // Vetoed by the event handler.
3026                 return;
3027             }
3028
3029             // Find out if there are selected items below the current node.
3030             bool selectCollapsingRow = false;
3031             const unsigned rowAdjustment = node->GetSubTreeCount();
3032             unsigned maxRowToBeTested = row + rowAdjustment;
3033             for(unsigned i=0; i<m_selection.size(); ++i)
3034             {
3035                 const unsigned testRow = m_selection[i];
3036                 if(testRow > row && testRow <= maxRowToBeTested)
3037                 {
3038                     selectCollapsingRow = true;
3039                     // get out as soon as we have found a node that is selected
3040                     break;
3041                 }
3042             }
3043
3044             node->ToggleOpen();
3045
3046             // If the node to be closed has selected items the user won't see those any longer.
3047             // We select the collapsing node in this case.
3048             if(selectCollapsingRow)
3049             {
3050                 SelectAllRows(false);
3051                 ChangeCurrentRow(row);
3052                 SelectRow(row, true);
3053                 SendSelectionChangedEvent(GetItemByRow(row));
3054             }
3055             else
3056             {
3057                 // if there were no selected items below our node we still need to "fix" the
3058                 // selection list to adjust for the changing of the row indices.
3059                 // We actually do the opposite of what we are doing in Expand().
3060                 for(unsigned i=0; i<m_selection.size(); ++i)
3061                 {
3062                     const unsigned testRow = m_selection[i];
3063                     // all rows above us are not affected, so skip them
3064                     if(testRow <= row)
3065                         continue;
3066
3067                     m_selection[i] -= rowAdjustment;
3068                 }
3069
3070                 // if the "current row" is being collapsed away we change it to the current row ;-)
3071                 if(m_currentRow > row && m_currentRow <= maxRowToBeTested)
3072                     ChangeCurrentRow(row);
3073                 else if(m_currentRow > row)
3074                     ChangeCurrentRow(m_currentRow - rowAdjustment);
3075             }
3076
3077             m_count = -1;
3078             UpdateDisplay();
3079             SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,node->GetItem());
3080         }
3081 }
3082
3083 wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item )
3084 {
3085     const wxDataViewModel * model = GetModel();
3086     if( model == NULL )
3087         return NULL;
3088
3089     if (!item.IsOk())
3090         return m_root;
3091
3092     // Compose the parent-chain for the item we are looking for
3093     wxVector<wxDataViewItem> parentChain;
3094     wxDataViewItem it( item );
3095     while( it.IsOk() )
3096     {
3097         parentChain.push_back(it);
3098         it = model->GetParent(it);
3099     }
3100
3101     // Find the item along the parent-chain.
3102     // This algorithm is designed to speed up the node-finding method
3103     wxDataViewTreeNode* node = m_root;
3104     for( unsigned iter = parentChain.size()-1; ; --iter )
3105     {
3106         if( node->HasChildren() )
3107         {
3108             if( node->GetChildNodes().empty() )
3109             {
3110                 // Even though the item is a container, it doesn't have any
3111                 // child nodes in the control's representation yet. We have
3112                 // to realize its subtree now.
3113                 SortPrepare();
3114                 ::BuildTreeHelper(model, node->GetItem(), node);
3115             }
3116
3117             const wxDataViewTreeNodes& nodes = node->GetChildNodes();
3118             bool found = false;
3119
3120             for (unsigned i = 0; i < nodes.GetCount(); ++i)
3121             {
3122                 wxDataViewTreeNode* currentNode = nodes[i];
3123                 if (currentNode->GetItem() == parentChain[iter])
3124                 {
3125                     if (currentNode->GetItem() == item)
3126                         return currentNode;
3127
3128                     node = currentNode;
3129                     found = true;
3130                     break;
3131                 }
3132             }
3133             if (!found)
3134                 return NULL;
3135         }
3136         else
3137             return NULL;
3138
3139         if ( !iter )
3140             break;
3141     }
3142     return NULL;
3143 }
3144
3145 void wxDataViewMainWindow::HitTest( const wxPoint & point, wxDataViewItem & item,
3146                                     wxDataViewColumn* &column )
3147 {
3148     wxDataViewColumn *col = NULL;
3149     unsigned int cols = GetOwner()->GetColumnCount();
3150     unsigned int colnum = 0;
3151     int x, y;
3152     m_owner->CalcUnscrolledPosition( point.x, point.y, &x, &y );
3153     for (unsigned x_start = 0; colnum < cols; colnum++)
3154     {
3155         col = GetOwner()->GetColumnAt(colnum);
3156         if (col->IsHidden())
3157             continue;      // skip it!
3158
3159         unsigned int w = col->GetWidth();
3160         if (x_start+w >= (unsigned int)x)
3161             break;
3162
3163         x_start += w;
3164     }
3165
3166     column = col;
3167     item = GetItemByRow( GetLineAt( y ) );
3168 }
3169
3170 wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item,
3171                                           const wxDataViewColumn* column )
3172 {
3173     int xpos = 0;
3174     int width = 0;
3175
3176     unsigned int cols = GetOwner()->GetColumnCount();
3177     // If column is null the loop will compute the combined width of all columns.
3178     // Otherwise, it will compute the x position of the column we are looking for.
3179     for (unsigned int i = 0; i < cols; i++)
3180     {
3181         wxDataViewColumn* col = GetOwner()->GetColumnAt( i );
3182
3183         if (col == column)
3184             break;
3185
3186         if (col->IsHidden())
3187             continue;      // skip it!
3188
3189         xpos += col->GetWidth();
3190         width += col->GetWidth();
3191     }
3192
3193     if(column != 0)
3194     {
3195         // If we have a column, we need can get its width directly.
3196         if(column->IsHidden())
3197             width = 0;
3198         else
3199             width = column->GetWidth();
3200
3201     }
3202     else
3203     {
3204         // If we have no column, we reset the x position back to zero.
3205         xpos = 0;
3206     }
3207
3208     // we have to take an expander column into account and compute its indentation
3209     // to get the correct x position where the actual text is
3210     int indent = 0;
3211     int row = GetRowByItem(item);
3212     if (!IsList() &&
3213             (column == 0 || GetExpanderColumnOrFirstOne(GetOwner()) == column) )
3214     {
3215         wxDataViewTreeNode* node = GetTreeNodeByRow(row);
3216         indent = GetOwner()->GetIndent() * node->GetIndentLevel();
3217         indent = indent + m_lineHeight; // use m_lineHeight as the width of the expander
3218     }
3219
3220     wxRect itemRect( xpos + indent,
3221                      GetLineStart( row ),
3222                      width - indent,
3223                      GetLineHeight( row ) );
3224
3225     GetOwner()->CalcScrolledPosition(  itemRect.x,  itemRect.y,
3226                                       &itemRect.x, &itemRect.y );
3227
3228     return itemRect;
3229 }
3230
3231 int wxDataViewMainWindow::RecalculateCount()
3232 {
3233     if (IsVirtualList())
3234     {
3235         wxDataViewVirtualListModel *list_model =
3236             (wxDataViewVirtualListModel*) GetModel();
3237
3238         return list_model->GetCount();
3239     }
3240     else
3241     {
3242         return m_root->GetSubTreeCount();
3243     }
3244 }
3245
3246 class ItemToRowJob : public DoJob
3247 {
3248 public:
3249     ItemToRowJob(const wxDataViewItem& item_, wxVector<wxDataViewItem>::reverse_iterator iter)
3250         : m_iter(iter),
3251         item(item_)
3252     {
3253         ret = -1;
3254     }
3255
3256     // Maybe binary search will help to speed up this process
3257     virtual int operator() ( wxDataViewTreeNode * node)
3258     {
3259         ret ++;
3260         if( node->GetItem() == item )
3261         {
3262             return DoJob::DONE;
3263         }
3264
3265         if( node->GetItem() == *m_iter )
3266         {
3267             m_iter++;
3268             return DoJob::CONTINUE;
3269         }
3270         else
3271         {
3272             ret += node->GetSubTreeCount();
3273             return DoJob::SKIP_SUBTREE;
3274         }
3275
3276     }
3277
3278     // the row number is begin from zero
3279     int GetResult() const
3280         { return ret -1; }
3281
3282 private:
3283     wxVector<wxDataViewItem>::reverse_iterator m_iter;
3284     wxDataViewItem item;
3285     int ret;
3286
3287 };
3288
3289 int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const
3290 {
3291     const wxDataViewModel * model = GetModel();
3292     if( model == NULL )
3293         return -1;
3294
3295     if (IsVirtualList())
3296     {
3297         return wxPtrToUInt( item.GetID() ) -1;
3298     }
3299     else
3300     {
3301         if( !item.IsOk() )
3302             return -1;
3303
3304         // Compose the parent-chain of the item we are looking for
3305         wxVector<wxDataViewItem> parentChain;
3306         wxDataViewItem it( item );
3307         while( it.IsOk() )
3308         {
3309             parentChain.push_back(it);
3310             it = model->GetParent(it);
3311         }
3312
3313         // add an 'invalid' item to represent our 'invisible' root node
3314         parentChain.push_back(wxDataViewItem());
3315
3316         // the parent chain was created by adding the deepest parent first.
3317         // so if we want to start at the root node, we have to iterate backwards through the vector
3318         ItemToRowJob job( item, parentChain.rbegin() );
3319         Walker( m_root, job );
3320         return job.GetResult();
3321     }
3322 }
3323
3324 static void BuildTreeHelper( const wxDataViewModel * model,  const wxDataViewItem & item,
3325                              wxDataViewTreeNode * node)
3326 {
3327     if( !model->IsContainer( item ) )
3328         return;
3329
3330     wxDataViewItemArray children;
3331     unsigned int num = model->GetChildren( item, children);
3332
3333     for ( unsigned int index = 0; index < num; index++ )
3334     {
3335         wxDataViewTreeNode *n = new wxDataViewTreeNode(node, children[index]);
3336
3337         if( model->IsContainer(children[index]) )
3338             n->SetHasChildren( true );
3339
3340         node->InsertChild(n, index);
3341     }
3342
3343     wxASSERT( node->IsOpen() );
3344     node->ChangeSubTreeCount(+num);
3345 }
3346
3347 void wxDataViewMainWindow::BuildTree(wxDataViewModel * model)
3348 {
3349     DestroyTree();
3350
3351     if (GetModel()->IsVirtualListModel())
3352     {
3353         m_count = -1;
3354         return;
3355     }
3356
3357     m_root = wxDataViewTreeNode::CreateRootNode();
3358
3359     // First we define a invalid item to fetch the top-level elements
3360     wxDataViewItem item;
3361     SortPrepare();
3362     BuildTreeHelper( model, item, m_root);
3363     m_count = -1;
3364 }
3365
3366 void wxDataViewMainWindow::DestroyTree()
3367 {
3368     if (!IsVirtualList())
3369     {
3370         wxDELETE(m_root);
3371         m_count = 0;
3372     }
3373 }
3374
3375 wxDataViewColumn*
3376 wxDataViewMainWindow::FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode)
3377 {
3378     // Edit the current column editable in 'mode'. If no column is focused
3379     // (typically because the user has full row selected), try to find the
3380     // first editable column (this would typically be a checkbox for
3381     // wxDATAVIEW_CELL_ACTIVATABLE and we don't want to force the user to set
3382     // focus on the checkbox column; or on the only editable text column).
3383
3384     wxDataViewColumn *candidate = m_currentCol;
3385
3386     if ( candidate &&
3387          candidate->GetRenderer()->GetMode() != mode &&
3388          !m_currentColSetByKeyboard )
3389     {
3390         // If current column was set by mouse to something not editable (in
3391         // 'mode') and the user pressed Space/F2 to edit it, treat the
3392         // situation as if there was whole-row focus, because that's what is
3393         // visually indicated and the mouse click could very well be targeted
3394         // on the row rather than on an individual cell.
3395         //
3396         // But if it was done by keyboard, respect that even if the column
3397         // isn't editable, because focus is visually on that column and editing
3398         // something else would be surprising.
3399         candidate = NULL;
3400     }
3401
3402     if ( !candidate )
3403     {
3404         const unsigned cols = GetOwner()->GetColumnCount();
3405         for ( unsigned i = 0; i < cols; i++ )
3406         {
3407             wxDataViewColumn *c = GetOwner()->GetColumnAt(i);
3408             if ( c->IsHidden() )
3409                 continue;
3410
3411             if ( c->GetRenderer()->GetMode() == mode )
3412             {
3413                 candidate = c;
3414                 break;
3415             }
3416         }
3417     }
3418
3419     // If on container item without columns, only the expander column
3420     // may be directly editable:
3421     if ( candidate &&
3422          GetOwner()->GetExpanderColumn() != candidate &&
3423          GetModel()->IsContainer(item) &&
3424          !GetModel()->HasContainerColumns(item) )
3425     {
3426         candidate = GetOwner()->GetExpanderColumn();
3427     }
3428
3429     if ( !candidate )
3430        return NULL;
3431
3432    if ( candidate->GetRenderer()->GetMode() != mode )
3433        return NULL;
3434
3435    return candidate;
3436 }
3437
3438 void wxDataViewMainWindow::OnCharHook(wxKeyEvent& event)
3439 {
3440     if ( m_editorCtrl )
3441     {
3442         // Handle any keys special for the in-place editor and return without
3443         // calling Skip() below.
3444         switch ( event.GetKeyCode() )
3445         {
3446             case WXK_ESCAPE:
3447                 m_editorRenderer->CancelEditing();
3448                 return;
3449
3450             case WXK_RETURN:
3451                 m_editorRenderer->FinishEditing();
3452                 return;
3453         }
3454     }
3455
3456     event.Skip();
3457 }
3458
3459 void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
3460 {
3461     wxWindow * const parent = GetParent();
3462
3463     // propagate the char event upwards
3464     wxKeyEvent eventForParent(event);
3465     eventForParent.SetEventObject(parent);
3466     if ( parent->ProcessWindowEvent(eventForParent) )
3467         return;
3468
3469     if ( parent->HandleAsNavigationKey(event) )
3470         return;
3471
3472     // no item -> nothing to do
3473     if (!HasCurrentRow())
3474     {
3475         event.Skip();
3476         return;
3477     }
3478
3479     // don't use m_linesPerPage directly as it might not be computed yet
3480     const int pageSize = GetCountPerPage();
3481     wxCHECK_RET( pageSize, wxT("should have non zero page size") );
3482
3483     switch ( event.GetKeyCode() )
3484     {
3485         case WXK_RETURN:
3486             {
3487                 // Enter activates the item, i.e. sends wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED to
3488                 // it. Only if that event is not handled do we activate column renderer (which
3489                 // is normally done by Space) or even inline editing.
3490
3491                 const wxDataViewItem item = GetItemByRow(m_currentRow);
3492
3493                 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED,
3494                                    parent->GetId());
3495                 le.SetItem(item);
3496                 le.SetEventObject(parent);
3497                 le.SetModel(GetModel());
3498
3499                 if ( parent->ProcessWindowEvent(le) )
3500                     break;
3501                 // else: fall through to WXK_SPACE handling
3502             }
3503
3504         case WXK_SPACE:
3505             {
3506                 // Space toggles activatable items or -- if not activatable --
3507                 // starts inline editing (this is normally done using F2 on
3508                 // Windows, but Space is common everywhere else, so use it too
3509                 // for greater cross-platform compatibility).
3510
3511                 const wxDataViewItem item = GetItemByRow(m_currentRow);
3512
3513                 // Activate the current activatable column. If not column is focused (typically
3514                 // because the user has full row selected), try to find the first activatable
3515                 // column (this would typically be a checkbox and we don't want to force the user
3516                 // to set focus on the checkbox column).
3517                 wxDataViewColumn *activatableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_ACTIVATABLE);
3518
3519                 if ( activatableCol )
3520                 {
3521                     const unsigned colIdx = activatableCol->GetModelColumn();
3522                     const wxRect cell_rect = GetOwner()->GetItemRect(item, activatableCol);
3523
3524                     wxDataViewRenderer *cell = activatableCol->GetRenderer();
3525                     cell->PrepareForItem(GetModel(), item, colIdx);
3526                     cell->WXActivateCell(cell_rect, GetModel(), item, colIdx, NULL);
3527
3528                     break;
3529                 }
3530                 // else: fall through to WXK_F2 handling
3531             }
3532
3533         case WXK_F2:
3534             {
3535                 if( !m_selection.empty() )
3536                 {
3537                     // Mimic Windows 7 behavior: edit the item that has focus
3538                     // if it is selected and the first selected item if focus
3539                     // is out of selection.
3540                     int sel;
3541                     if ( m_selection.Index(m_currentRow) != wxNOT_FOUND )
3542                         sel = m_currentRow;
3543                     else
3544                         sel = m_selection[0];
3545
3546
3547                     const wxDataViewItem item = GetItemByRow(sel);
3548
3549                     // Edit the current column. If no column is focused
3550                     // (typically because the user has full row selected), try
3551                     // to find the first editable column.
3552                     wxDataViewColumn *editableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_EDITABLE);
3553
3554                     if ( editableCol )
3555                         GetOwner()->StartEditor(item, GetOwner()->GetColumnIndex(editableCol));
3556                 }
3557             }
3558             break;
3559
3560         case WXK_UP:
3561             if ( m_currentRow > 0 )
3562                 OnVerticalNavigation( m_currentRow - 1, event );
3563             break;
3564
3565         case WXK_DOWN:
3566             if ( m_currentRow + 1 < GetRowCount() )
3567                 OnVerticalNavigation( m_currentRow + 1, event );
3568             break;
3569         // Add the process for tree expanding/collapsing
3570         case WXK_LEFT:
3571             OnLeftKey();
3572             break;
3573
3574         case WXK_RIGHT:
3575             OnRightKey();
3576             break;
3577
3578         case WXK_END:
3579         {
3580             if (!IsEmpty())
3581                 OnVerticalNavigation( GetRowCount() - 1, event );
3582             break;
3583         }
3584         case WXK_HOME:
3585             if (!IsEmpty())
3586                 OnVerticalNavigation( 0, event );
3587             break;
3588
3589         case WXK_PAGEUP:
3590             {
3591                 int steps = pageSize - 1;
3592                 int index = m_currentRow - steps;
3593                 if (index < 0)
3594                     index = 0;
3595
3596                 OnVerticalNavigation( index, event );
3597             }
3598             break;
3599
3600         case WXK_PAGEDOWN:
3601             {
3602                 int steps = pageSize - 1;
3603                 unsigned int index = m_currentRow + steps;
3604                 unsigned int count = GetRowCount();
3605                 if ( index >= count )
3606                     index = count - 1;
3607
3608                 OnVerticalNavigation( index, event );
3609             }
3610             break;
3611
3612         default:
3613             event.Skip();
3614     }
3615 }
3616
3617 void wxDataViewMainWindow::OnVerticalNavigation(unsigned int newCurrent, const wxKeyEvent& event)
3618 {
3619     wxCHECK_RET( newCurrent < GetRowCount(),
3620                 wxT("invalid item index in OnVerticalNavigation()") );
3621
3622     // if there is no selection, we cannot move it anywhere
3623     if (!HasCurrentRow())
3624         return;
3625
3626     unsigned int oldCurrent = m_currentRow;
3627
3628     // in single selection we just ignore Shift as we can't select several
3629     // items anyhow
3630     if ( event.ShiftDown() && !IsSingleSel() )
3631     {
3632         RefreshRow( oldCurrent );
3633
3634         ChangeCurrentRow( newCurrent );
3635
3636         // select all the items between the old and the new one
3637         if ( oldCurrent > newCurrent )
3638         {
3639             newCurrent = oldCurrent;
3640             oldCurrent = m_currentRow;
3641         }
3642
3643         SelectRows( oldCurrent, newCurrent, true );
3644         if (oldCurrent!=newCurrent)
3645             SendSelectionChangedEvent(GetItemByRow(m_selection[0]));
3646     }
3647     else // !shift
3648     {
3649         RefreshRow( oldCurrent );
3650
3651         // all previously selected items are unselected unless ctrl is held
3652         if ( !event.ControlDown() )
3653             SelectAllRows(false);
3654
3655         ChangeCurrentRow( newCurrent );
3656
3657         if ( !event.ControlDown() )
3658         {
3659             SelectRow( m_currentRow, true );
3660             SendSelectionChangedEvent(GetItemByRow(m_currentRow));
3661         }
3662         else
3663             RefreshRow( m_currentRow );
3664     }
3665
3666     GetOwner()->EnsureVisible( m_currentRow, -1 );
3667 }
3668
3669 void wxDataViewMainWindow::OnLeftKey()
3670 {
3671     if ( IsList() )
3672     {
3673         TryAdvanceCurrentColumn(NULL, /*forward=*/false);
3674     }
3675     else
3676     {
3677         wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow);
3678
3679         if ( TryAdvanceCurrentColumn(node, /*forward=*/false) )
3680             return;
3681
3682         // Because TryAdvanceCurrentColumn() return false, we are at the first
3683         // column or using whole-row selection. In this situation, we can use
3684         // the standard TreeView handling of the left key.
3685         if (node->HasChildren() && node->IsOpen())
3686         {
3687             Collapse(m_currentRow);
3688         }
3689         else
3690         {
3691             // if the node is already closed, we move the selection to its parent
3692             wxDataViewTreeNode *parent_node = node->GetParent();
3693
3694             if (parent_node)
3695             {
3696                 int parent = GetRowByItem( parent_node->GetItem() );
3697                 if ( parent >= 0 )
3698                 {
3699                     unsigned int row = m_currentRow;
3700                     SelectRow( row, false);
3701                     SelectRow( parent, true );
3702                     ChangeCurrentRow( parent );
3703                     GetOwner()->EnsureVisible( parent, -1 );
3704                     SendSelectionChangedEvent( parent_node->GetItem() );
3705                 }
3706             }
3707         }
3708     }
3709 }
3710
3711 void wxDataViewMainWindow::OnRightKey()
3712 {
3713     if ( IsList() )
3714     {
3715         TryAdvanceCurrentColumn(NULL, /*forward=*/true);
3716     }
3717     else
3718     {
3719         wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow);
3720
3721         if ( node->HasChildren() )
3722         {
3723             if ( !node->IsOpen() )
3724             {
3725                 Expand( m_currentRow );
3726             }
3727             else
3728             {
3729                 // if the node is already open, we move the selection to the first child
3730                 unsigned int row = m_currentRow;
3731                 SelectRow( row, false );
3732                 SelectRow( row + 1, true );
3733                 ChangeCurrentRow( row + 1 );
3734                 GetOwner()->EnsureVisible( row + 1, -1 );
3735                 SendSelectionChangedEvent( GetItemByRow(row+1) );
3736             }
3737         }
3738         else
3739         {
3740             TryAdvanceCurrentColumn(node, /*forward=*/true);
3741         }
3742     }
3743 }
3744
3745 bool wxDataViewMainWindow::TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward)
3746 {
3747     if ( GetOwner()->GetColumnCount() == 0 )
3748         return false;
3749
3750     if ( !m_useCellFocus )
3751         return false;
3752
3753     if ( node )
3754     {
3755         // navigation shouldn't work in branch nodes without other columns:
3756         if ( node->HasChildren() && !GetModel()->HasContainerColumns(node->GetItem()) )
3757             return false;
3758     }
3759
3760     if ( m_currentCol == NULL || !m_currentColSetByKeyboard )
3761     {
3762         if ( forward )
3763         {
3764             m_currentCol = GetOwner()->GetColumnAt(1);
3765             m_currentColSetByKeyboard = true;
3766             RefreshRow(m_currentRow);
3767             return true;
3768         }
3769         else
3770             return false;
3771     }
3772
3773     int idx = GetOwner()->GetColumnIndex(m_currentCol) + (forward ? +1 : -1);
3774
3775     if ( idx >= (int)GetOwner()->GetColumnCount() )
3776         return false;
3777
3778     GetOwner()->EnsureVisible(m_currentRow, idx);
3779
3780     if ( idx < 1 )
3781     {
3782         // We are going to the left of the second column. Reset to whole-row
3783         // focus (which means first column would be edited).
3784         m_currentCol = NULL;
3785         RefreshRow(m_currentRow);
3786         return true;
3787     }
3788
3789     m_currentCol = GetOwner()->GetColumnAt(idx);
3790     m_currentColSetByKeyboard = true;
3791     RefreshRow(m_currentRow);
3792     return true;
3793 }
3794
3795 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
3796 {
3797     if (event.GetEventType() == wxEVT_MOUSEWHEEL)
3798     {
3799         // let the base handle mouse wheel events.
3800         event.Skip();
3801         return;
3802     }
3803
3804     // set the focus to ourself if any of the mouse buttons are pressed
3805     if(event.ButtonDown() && !HasFocus())
3806         SetFocus();
3807
3808     int x = event.GetX();
3809     int y = event.GetY();
3810     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
3811     wxDataViewColumn *col = NULL;
3812
3813     int xpos = 0;
3814     unsigned int cols = GetOwner()->GetColumnCount();
3815     unsigned int i;
3816     for (i = 0; i < cols; i++)
3817     {
3818         wxDataViewColumn *c = GetOwner()->GetColumnAt( i );
3819         if (c->IsHidden())
3820             continue;      // skip it!
3821
3822         if (x < xpos + c->GetWidth())
3823         {
3824             col = c;
3825             break;
3826         }
3827         xpos += c->GetWidth();
3828     }
3829
3830     wxDataViewModel* const model = GetModel();
3831
3832     const unsigned int current = GetLineAt( y );
3833     const wxDataViewItem item = GetItemByRow(current);
3834
3835     // Handle right clicking here, before everything else as context menu
3836     // events should be sent even when we click outside of any item, unlike all
3837     // the other ones.
3838     if (event.RightUp())
3839     {
3840         wxWindow *parent = GetParent();
3841         wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId());
3842         le.SetEventObject(parent);
3843         le.SetModel(model);
3844
3845         if ( item.IsOk() && col )
3846         {
3847             le.SetItem( item );
3848             le.SetColumn( col->GetModelColumn() );
3849             le.SetDataViewColumn( col );
3850
3851             wxVariant value;
3852             model->GetValue( value, item, col->GetModelColumn() );
3853             le.SetValue(value);
3854         }
3855
3856         parent->ProcessWindowEvent(le);
3857         return;
3858     }
3859
3860     if (!col)
3861     {
3862         event.Skip();
3863         return;
3864     }
3865
3866     wxDataViewRenderer *cell = col->GetRenderer();
3867     if ((current >= GetRowCount()) || (x > GetEndOfLastCol()))
3868     {
3869         // Unselect all if below the last row ?
3870         event.Skip();
3871         return;
3872     }
3873
3874     wxDataViewColumn* const
3875         expander = GetExpanderColumnOrFirstOne(GetOwner());
3876
3877     // Test whether the mouse is hovering over the expander (a.k.a tree "+"
3878     // button) and also determine the offset of the real cell start, skipping
3879     // the indentation and the expander itself.
3880     bool hoverOverExpander = false;
3881     int itemOffset = 0;
3882     if ((!IsList()) && (expander == col))
3883     {
3884         wxDataViewTreeNode * node = GetTreeNodeByRow(current);
3885
3886         int indent = node->GetIndentLevel();
3887         itemOffset = GetOwner()->GetIndent()*indent;
3888
3889         if ( node->HasChildren() )
3890         {
3891             // we make the rectangle we are looking in a bit bigger than the actual
3892             // visual expander so the user can hit that little thing reliably
3893             wxRect rect(itemOffset,
3894                         GetLineStart( current ) + (GetLineHeight(current) - m_lineHeight)/2,
3895                         m_lineHeight, m_lineHeight);
3896
3897             if( rect.Contains(x, y) )
3898             {
3899                 // So the mouse is over the expander
3900                 hoverOverExpander = true;
3901                 if (m_underMouse && m_underMouse != node)
3902                 {
3903                     // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3904                     RefreshRow(GetRowByItem(m_underMouse->GetItem()));
3905                 }
3906                 if (m_underMouse != node)
3907                 {
3908                     // wxLogMessage("Do the row: %d", current);
3909                     RefreshRow(current);
3910                 }
3911                 m_underMouse = node;
3912             }
3913         }
3914
3915         // Account for the expander as well, even if this item doesn't have it,
3916         // its parent does so it still counts for the offset.
3917         itemOffset += m_lineHeight;
3918     }
3919     if (!hoverOverExpander)
3920     {
3921         if (m_underMouse != NULL)
3922         {
3923             // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3924             RefreshRow(GetRowByItem(m_underMouse->GetItem()));
3925             m_underMouse = NULL;
3926         }
3927     }
3928
3929 #if wxUSE_DRAG_AND_DROP
3930     if (event.Dragging())
3931     {
3932         if (m_dragCount == 0)
3933         {
3934             // we have to report the raw, physical coords as we want to be
3935             // able to call HitTest(event.m_pointDrag) from the user code to
3936             // get the item being dragged
3937             m_dragStart = event.GetPosition();
3938         }
3939
3940         m_dragCount++;
3941
3942         if (m_dragCount != 3)
3943             return;
3944
3945         if (event.LeftIsDown())
3946         {
3947             m_owner->CalcUnscrolledPosition( m_dragStart.x, m_dragStart.y,
3948                                              &m_dragStart.x, &m_dragStart.y );
3949             unsigned int drag_item_row = GetLineAt( m_dragStart.y );
3950             wxDataViewItem itemDragged = GetItemByRow( drag_item_row );
3951
3952             // Notify cell about drag
3953             wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() );
3954             event.SetEventObject( m_owner );
3955             event.SetItem( itemDragged );
3956             event.SetModel( model );
3957             if (!m_owner->HandleWindowEvent( event ))
3958                 return;
3959
3960             if (!event.IsAllowed())
3961                 return;
3962
3963             wxDataObject *obj = event.GetDataObject();
3964             if (!obj)
3965                 return;
3966
3967             wxDataViewDropSource drag( this, drag_item_row );
3968             drag.SetData( *obj );
3969             /* wxDragResult res = */ drag.DoDragDrop();
3970             delete obj;
3971         }
3972         return;
3973     }
3974     else
3975     {
3976         m_dragCount = 0;
3977     }
3978 #endif // wxUSE_DRAG_AND_DROP
3979
3980     bool simulateClick = false;
3981
3982     if (event.ButtonDClick())
3983     {
3984         m_renameTimer->Stop();
3985         m_lastOnSame = false;
3986     }
3987
3988     bool ignore_other_columns =
3989         ((expander != col) &&
3990         (model->IsContainer(item)) &&
3991         (!model->HasContainerColumns(item)));
3992
3993     if (event.LeftDClick())
3994     {
3995         if(hoverOverExpander)
3996         {
3997             // a double click on the expander will be converted into a "simulated" normal click
3998             simulateClick = true;
3999         }
4000         else if ( current == m_lineLastClicked )
4001         {
4002             wxWindow *parent = GetParent();
4003             wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
4004             le.SetItem( item );
4005             le.SetColumn( col->GetModelColumn() );
4006             le.SetDataViewColumn( col );
4007             le.SetEventObject(parent);
4008             le.SetModel(GetModel());
4009
4010             parent->ProcessWindowEvent(le);
4011             return;
4012         }
4013         else
4014         {
4015             // The first click was on another item, so don't interpret this as
4016             // a double click, but as a simple click instead
4017             simulateClick = true;
4018         }
4019     }
4020
4021     if (event.LeftUp() && !hoverOverExpander)
4022     {
4023         if (m_lineSelectSingleOnUp != (unsigned int)-1)
4024         {
4025             // select single line
4026             SelectAllRows( false );
4027             SelectRow( m_lineSelectSingleOnUp, true );
4028             SendSelectionChangedEvent( GetItemByRow(m_lineSelectSingleOnUp) );
4029         }
4030
4031         // If the user click the expander, we do not do editing even if the column
4032         // with expander are editable
4033         if (m_lastOnSame && !ignore_other_columns)
4034         {
4035             if ((col == m_currentCol) && (current == m_currentRow) &&
4036                 (cell->GetMode() & wxDATAVIEW_CELL_EDITABLE) )
4037             {
4038                 m_renameTimer->Start( 100, true );
4039             }
4040         }
4041
4042         m_lastOnSame = false;
4043         m_lineSelectSingleOnUp = (unsigned int)-1;
4044     }
4045     else if(!event.LeftUp())
4046     {
4047         // This is necessary, because after a DnD operation in
4048         // from and to ourself, the up event is swallowed by the
4049         // DnD code. So on next non-up event (which means here and
4050         // now) m_lineSelectSingleOnUp should be reset.
4051         m_lineSelectSingleOnUp = (unsigned int)-1;
4052     }
4053
4054     if (event.RightDown())
4055     {
4056         m_lineBeforeLastClicked = m_lineLastClicked;
4057         m_lineLastClicked = current;
4058
4059         // If the item is already selected, do not update the selection.
4060         // Multi-selections should not be cleared if a selected item is clicked.
4061         if (!IsRowSelected(current))
4062         {
4063             SelectAllRows(false);
4064             const unsigned oldCurrent = m_currentRow;
4065             ChangeCurrentRow(current);
4066             SelectRow(m_currentRow,true);
4067             RefreshRow(oldCurrent);
4068             SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
4069         }
4070     }
4071     else if (event.MiddleDown())
4072     {
4073     }
4074
4075     if((event.LeftDown() || simulateClick) && hoverOverExpander)
4076     {
4077         wxDataViewTreeNode* node = GetTreeNodeByRow(current);
4078
4079         // hoverOverExpander being true tells us that our node must be
4080         // valid and have children.
4081         // So we don't need any extra checks.
4082         if( node->IsOpen() )
4083             Collapse(current);
4084         else
4085             Expand(current);
4086     }
4087     else if ((event.LeftDown() || simulateClick) && !hoverOverExpander)
4088     {
4089         m_lineBeforeLastClicked = m_lineLastClicked;
4090         m_lineLastClicked = current;
4091
4092         unsigned int oldCurrentRow = m_currentRow;
4093         bool oldWasSelected = IsRowSelected(m_currentRow);
4094
4095         bool cmdModifierDown = event.CmdDown();
4096         if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
4097         {
4098             if ( IsSingleSel() || !IsRowSelected(current) )
4099             {
4100                 SelectAllRows( false );
4101                 ChangeCurrentRow(current);
4102                 SelectRow(m_currentRow,true);
4103                 SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
4104             }
4105             else // multi sel & current is highlighted & no mod keys
4106             {
4107                 m_lineSelectSingleOnUp = current;
4108                 ChangeCurrentRow(current); // change focus
4109             }
4110         }
4111         else // multi sel & either ctrl or shift is down
4112         {
4113             if (cmdModifierDown)
4114             {
4115                 ChangeCurrentRow(current);
4116                 ReverseRowSelection(m_currentRow);
4117                 SendSelectionChangedEvent(GetItemByRow(m_currentRow));
4118             }
4119             else if (event.ShiftDown())
4120             {
4121                 ChangeCurrentRow(current);
4122
4123                 unsigned int lineFrom = oldCurrentRow,
4124                     lineTo = current;
4125
4126                 if ( lineTo < lineFrom )
4127                 {
4128                     lineTo = lineFrom;
4129                     lineFrom = m_currentRow;
4130                 }
4131
4132                 SelectRows(lineFrom, lineTo, true);
4133                 SendSelectionChangedEvent(GetItemByRow(m_selection[0]) );
4134             }
4135             else // !ctrl, !shift
4136             {
4137                 // test in the enclosing if should make it impossible
4138                 wxFAIL_MSG( wxT("how did we get here?") );
4139             }
4140         }
4141
4142         if (m_currentRow != oldCurrentRow)
4143             RefreshRow( oldCurrentRow );
4144
4145         wxDataViewColumn *oldCurrentCol = m_currentCol;
4146
4147         // Update selection here...
4148         m_currentCol = col;
4149         m_currentColSetByKeyboard = false;
4150
4151         m_lastOnSame = !simulateClick && ((col == oldCurrentCol) &&
4152                         (current == oldCurrentRow)) && oldWasSelected;
4153
4154         // Call ActivateCell() after everything else as under GTK+
4155         if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE)
4156         {
4157             // notify cell about click
4158             cell->PrepareForItem(model, item, col->GetModelColumn());
4159
4160             wxRect cell_rect( xpos + itemOffset,
4161                               GetLineStart( current ),
4162                               col->GetWidth() - itemOffset,
4163                               GetLineHeight( current ) );
4164
4165             // Report position relative to the cell's custom area, i.e.
4166             // no the entire space as given by the control but the one
4167             // used by the renderer after calculation of alignment etc.
4168
4169             // adjust the rectangle ourselves to account for the alignment
4170             wxRect rectItem = cell_rect;
4171             const int align = cell->GetAlignment();
4172             if ( align != wxDVR_DEFAULT_ALIGNMENT )
4173             {
4174                 const wxSize size = cell->GetSize();
4175
4176                 if ( size.x >= 0 && size.x < cell_rect.width )
4177                 {
4178                     if ( align & wxALIGN_CENTER_HORIZONTAL )
4179                         rectItem.x += (cell_rect.width - size.x)/2;
4180                     else if ( align & wxALIGN_RIGHT )
4181                         rectItem.x += cell_rect.width - size.x;
4182                     // else: wxALIGN_LEFT is the default
4183                 }
4184
4185                 if ( size.y >= 0 && size.y < cell_rect.height )
4186                 {
4187                     if ( align & wxALIGN_CENTER_VERTICAL )
4188                         rectItem.y += (cell_rect.height - size.y)/2;
4189                     else if ( align & wxALIGN_BOTTOM )
4190                         rectItem.y += cell_rect.height - size.y;
4191                     // else: wxALIGN_TOP is the default
4192                 }
4193             }
4194
4195             wxMouseEvent event2(event);
4196             event2.m_x -= rectItem.x;
4197             event2.m_y -= rectItem.y;
4198             m_owner->CalcUnscrolledPosition(event2.m_x, event2.m_y, &event2.m_x, &event2.m_y);
4199
4200              /* ignore ret */ cell->WXActivateCell
4201                                     (
4202                                         cell_rect,
4203                                         model,
4204                                         item,
4205                                         col->GetModelColumn(),
4206                                         &event2
4207                                     );
4208         }
4209     }
4210 }
4211
4212 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
4213 {
4214     m_hasFocus = true;
4215
4216     if (HasCurrentRow())
4217         Refresh();
4218
4219     event.Skip();
4220 }
4221
4222 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
4223 {
4224     m_hasFocus = false;
4225
4226     if (HasCurrentRow())
4227         Refresh();
4228
4229     event.Skip();
4230 }
4231
4232 void wxDataViewMainWindow::OnColumnsCountChanged()
4233 {
4234     int editableCount = 0;
4235
4236     const unsigned cols = GetOwner()->GetColumnCount();
4237     for ( unsigned i = 0; i < cols; i++ )
4238     {
4239         wxDataViewColumn *c = GetOwner()->GetColumnAt(i);
4240         if ( c->IsHidden() )
4241             continue;
4242         if ( c->GetRenderer()->GetMode() != wxDATAVIEW_CELL_INERT )
4243             editableCount++;
4244     }
4245
4246     m_useCellFocus = (editableCount > 1);
4247
4248     UpdateDisplay();
4249 }
4250
4251 //-----------------------------------------------------------------------------
4252 // wxDataViewCtrl
4253 //-----------------------------------------------------------------------------
4254
4255 WX_DEFINE_LIST(wxDataViewColumnList)
4256
4257 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
4258 BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase)
4259     EVT_SIZE(wxDataViewCtrl::OnSize)
4260 END_EVENT_TABLE()
4261
4262 wxDataViewCtrl::~wxDataViewCtrl()
4263 {
4264     if (m_notifier)
4265         GetModel()->RemoveNotifier( m_notifier );
4266
4267     m_cols.Clear();
4268     m_colsBestWidths.clear();
4269 }
4270
4271 void wxDataViewCtrl::Init()
4272 {
4273     m_cols.DeleteContents(true);
4274     m_notifier = NULL;
4275
4276     // No sorting column at start
4277     m_sortingColumnIdx = wxNOT_FOUND;
4278
4279     m_headerArea = NULL;
4280
4281     m_colsDirty = false;
4282 }
4283
4284 bool wxDataViewCtrl::Create(wxWindow *parent,
4285                             wxWindowID id,
4286                             const wxPoint& pos,
4287                             const wxSize& size,
4288                             long style,
4289                             const wxValidator& validator,
4290                             const wxString& name)
4291 {
4292 //    if ( (style & wxBORDER_MASK) == 0)
4293 //        style |= wxBORDER_SUNKEN;
4294
4295     Init();
4296
4297     if (!wxControl::Create( parent, id, pos, size,
4298                             style | wxScrolledWindowStyle, validator, name))
4299         return false;
4300
4301     SetInitialSize(size);
4302
4303 #ifdef __WXMAC__
4304     MacSetClipChildren( true );
4305 #endif
4306
4307     m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
4308
4309     // We use the cursor keys for moving the selection, not scrolling, so call
4310     // this method to ensure wxScrollHelperEvtHandler doesn't catch all
4311     // keyboard events forwarded to us from wxListMainWindow.
4312     DisableKeyboardScrolling();
4313
4314     if (HasFlag(wxDV_NO_HEADER))
4315         m_headerArea = NULL;
4316     else
4317         m_headerArea = new wxDataViewHeaderWindow(this);
4318
4319     SetTargetWindow( m_clientArea );
4320
4321     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
4322     if (m_headerArea)
4323         sizer->Add( m_headerArea, 0, wxGROW );
4324     sizer->Add( m_clientArea, 1, wxGROW );
4325     SetSizer( sizer );
4326
4327     return true;
4328 }
4329
4330 wxBorder wxDataViewCtrl::GetDefaultBorder() const
4331 {
4332     return wxBORDER_THEME;
4333 }
4334
4335 #ifdef __WXMSW__
4336 WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
4337                                         WXWPARAM wParam,
4338                                         WXLPARAM lParam)
4339 {
4340     WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
4341
4342 #ifndef __WXWINCE__
4343     // we need to process arrows ourselves for scrolling
4344     if ( nMsg == WM_GETDLGCODE )
4345     {
4346         rc |= DLGC_WANTARROWS;
4347     }
4348 #endif
4349
4350     return rc;
4351 }
4352 #endif
4353
4354 wxSize wxDataViewCtrl::GetSizeAvailableForScrollTarget(const wxSize& size)
4355 {
4356     wxSize newsize = size;
4357     if (!HasFlag(wxDV_NO_HEADER) && (m_headerArea))
4358     newsize.y -= m_headerArea->GetSize().y;
4359
4360     return newsize;
4361 }
4362
4363 void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
4364 {
4365     // We need to override OnSize so that our scrolled
4366     // window a) does call Layout() to use sizers for
4367     // positioning the controls but b) does not query
4368     // the sizer for their size and use that for setting
4369     // the scrollable area as set that ourselves by
4370     // calling SetScrollbar() further down.
4371
4372     Layout();
4373
4374     AdjustScrollbars();
4375
4376     // We must redraw the headers if their height changed. Normally this
4377     // shouldn't happen as the control shouldn't let itself be resized beneath
4378     // its minimal height but avoid the display artefacts that appear if it
4379     // does happen, e.g. because there is really not enough vertical space.
4380     if ( !HasFlag(wxDV_NO_HEADER) && m_headerArea &&
4381             m_headerArea->GetSize().y <= m_headerArea->GetBestSize(). y )
4382     {
4383         m_headerArea->Refresh();
4384     }
4385 }
4386
4387 void wxDataViewCtrl::SetFocus()
4388 {
4389     if (m_clientArea)
4390         m_clientArea->SetFocus();
4391 }
4392
4393 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
4394 {
4395     if (!wxDataViewCtrlBase::AssociateModel( model ))
4396         return false;
4397
4398     m_notifier = new wxGenericDataViewModelNotifier( m_clientArea );
4399
4400     model->AddNotifier( m_notifier );
4401
4402     m_clientArea->DestroyTree();
4403
4404     m_clientArea->BuildTree(model);
4405
4406     m_clientArea->UpdateDisplay();
4407
4408     return true;
4409 }
4410
4411 #if wxUSE_DRAG_AND_DROP
4412
4413 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat &format )
4414 {
4415     return m_clientArea->EnableDragSource( format );
4416 }
4417
4418 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat &format )
4419 {
4420     return m_clientArea->EnableDropTarget( format );
4421 }
4422
4423 #endif // wxUSE_DRAG_AND_DROP
4424
4425 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
4426 {
4427     if (!wxDataViewCtrlBase::AppendColumn(col))
4428         return false;
4429
4430     m_cols.Append( col );
4431     m_colsBestWidths.push_back(0);
4432     OnColumnsCountChanged();
4433     return true;
4434 }
4435
4436 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
4437 {
4438     if (!wxDataViewCtrlBase::PrependColumn(col))
4439         return false;
4440
4441     m_cols.Insert( col );
4442     m_colsBestWidths.insert(m_colsBestWidths.begin(), 0);
4443     OnColumnsCountChanged();
4444     return true;
4445 }
4446
4447 bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
4448 {
4449     if (!wxDataViewCtrlBase::InsertColumn(pos,col))
4450         return false;
4451
4452     m_cols.Insert( pos, col );
4453     m_colsBestWidths.insert(m_colsBestWidths.begin() + pos, 0);
4454     OnColumnsCountChanged();
4455     return true;
4456 }
4457
4458 void wxDataViewCtrl::OnColumnChange(unsigned int idx)
4459 {
4460     if ( m_headerArea )
4461         m_headerArea->UpdateColumn(idx);
4462
4463     m_clientArea->UpdateDisplay();
4464 }
4465
4466 void wxDataViewCtrl::OnColumnsCountChanged()
4467 {
4468     if (m_headerArea)
4469         m_headerArea->SetColumnCount(GetColumnCount());
4470
4471     m_clientArea->OnColumnsCountChanged();
4472 }
4473
4474 void wxDataViewCtrl::DoSetExpanderColumn()
4475 {
4476     m_clientArea->UpdateDisplay();
4477 }
4478
4479 void wxDataViewCtrl::DoSetIndent()
4480 {
4481     m_clientArea->UpdateDisplay();
4482 }
4483
4484 unsigned int wxDataViewCtrl::GetColumnCount() const
4485 {
4486     return m_cols.GetCount();
4487 }
4488
4489 bool wxDataViewCtrl::SetRowHeight( int lineHeight )
4490 {
4491     if ( !m_clientArea )
4492         return false;
4493
4494     m_clientArea->SetRowHeight(lineHeight);
4495
4496     return true;
4497 }
4498
4499 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int idx ) const
4500 {
4501     return m_cols[idx];
4502 }
4503
4504 wxDataViewColumn *wxDataViewCtrl::GetColumnAt(unsigned int pos) const
4505 {
4506     // columns can't be reordered if there is no header window which allows
4507     // to do this
4508     const unsigned idx = m_headerArea ? m_headerArea->GetColumnsOrder()[pos]
4509                                     : pos;
4510
4511     return GetColumn(idx);
4512 }
4513
4514 int wxDataViewCtrl::GetColumnIndex(const wxDataViewColumn *column) const
4515 {
4516     const unsigned count = m_cols.size();
4517     for ( unsigned n = 0; n < count; n++ )
4518     {
4519         if ( m_cols[n] == column )
4520             return n;
4521     }
4522
4523     return wxNOT_FOUND;
4524 }
4525
4526 unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const
4527 {
4528     if ( m_colsBestWidths[idx] != 0 )
4529         return m_colsBestWidths[idx];
4530
4531     const int count = m_clientArea->GetRowCount();
4532     wxDataViewColumn *column = GetColumn(idx);
4533     wxDataViewRenderer *renderer =
4534         const_cast<wxDataViewRenderer*>(column->GetRenderer());
4535
4536     class MaxWidthCalculator
4537     {
4538     public:
4539         MaxWidthCalculator(const wxDataViewCtrl *dvc,
4540                            wxDataViewMainWindow *clientArea,
4541                            wxDataViewRenderer *renderer,
4542                            const wxDataViewModel *model,
4543                            unsigned column,
4544                            int expanderSize)
4545             : m_width(0),
4546               m_dvc(dvc),
4547               m_clientArea(clientArea),
4548               m_renderer(renderer),
4549               m_model(model),
4550               m_column(column),
4551               m_expanderSize(expanderSize)
4552
4553         {
4554             m_isExpanderCol =
4555                 !clientArea->IsList() &&
4556                 (column == 0 ||
4557                  GetExpanderColumnOrFirstOne(const_cast<wxDataViewCtrl*>(dvc)) == dvc->GetColumnAt(column));
4558         }
4559
4560         void UpdateWithWidth(int width)
4561         {
4562             m_width = wxMax(m_width, width);
4563         }
4564
4565         void UpdateWithRow(int row)
4566         {
4567             int indent = 0;
4568             wxDataViewItem item;
4569
4570             if ( m_isExpanderCol )
4571             {
4572                 wxDataViewTreeNode *node = m_clientArea->GetTreeNodeByRow(row);
4573                 item = node->GetItem();
4574                 indent = m_dvc->GetIndent() * node->GetIndentLevel() + m_expanderSize;
4575             }
4576             else
4577             {
4578                 item = m_clientArea->GetItemByRow(row);
4579             }
4580
4581             m_renderer->PrepareForItem(m_model, item, m_column);
4582             m_width = wxMax(m_width, m_renderer->GetSize().x + indent);
4583         }
4584
4585         int GetMaxWidth() const { return m_width; }
4586
4587     private:
4588         int m_width;
4589         const wxDataViewCtrl *m_dvc;
4590         wxDataViewMainWindow *m_clientArea;
4591         wxDataViewRenderer *m_renderer;
4592         const wxDataViewModel *m_model;
4593         unsigned m_column;
4594         bool m_isExpanderCol;
4595         int m_expanderSize;
4596     };
4597
4598     MaxWidthCalculator calculator(this, m_clientArea, renderer,
4599                                   GetModel(), column->GetModelColumn(),
4600                                   m_clientArea->GetRowHeight());
4601
4602     if ( m_headerArea )
4603     {
4604         int header_width = m_headerArea->GetTextExtent(column->GetTitle()).x;
4605         // Labels on native MSW header are indented on both sides
4606         header_width +=
4607             wxRendererNative::Get().GetHeaderButtonMargin(m_headerArea);
4608         calculator.UpdateWithWidth(header_width);
4609     }
4610
4611     // The code below deserves some explanation. For very large controls, we
4612     // simply can't afford to calculate sizes for all items, it takes too
4613     // long. So the best we can do is to check the first and the last N/2
4614     // items in the control for some sufficiently large N and calculate best
4615     // sizes from that. That can result in the calculated best width being too
4616     // small for some outliers, but it's better to get slightly imperfect
4617     // result than to wait several seconds after every update. To avoid highly
4618     // visible miscalculations, we also include all currently visible items
4619     // no matter what.  Finally, the value of N is determined dynamically by
4620     // measuring how much time we spent on the determining item widths so far.
4621
4622 #if wxUSE_STOPWATCH
4623     int top_part_end = count;
4624     static const long CALC_TIMEOUT = 20/*ms*/;
4625     // don't call wxStopWatch::Time() too often
4626     static const unsigned CALC_CHECK_FREQ = 100;
4627     wxStopWatch timer;
4628 #else
4629     // use some hard-coded limit, that's the best we can do without timer
4630     int top_part_end = wxMin(500, count);
4631 #endif // wxUSE_STOPWATCH/!wxUSE_STOPWATCH
4632
4633     int row = 0;
4634
4635     for ( row = 0; row < top_part_end; row++ )
4636     {
4637 #if wxUSE_STOPWATCH
4638         if ( row % CALC_CHECK_FREQ == CALC_CHECK_FREQ-1 &&
4639              timer.Time() > CALC_TIMEOUT )
4640             break;
4641 #endif // wxUSE_STOPWATCH
4642         calculator.UpdateWithRow(row);
4643     }
4644
4645     // row is the first unmeasured item now; that's our value of N/2
4646
4647     if ( row < count )
4648     {
4649         top_part_end = row;
4650
4651         // add bottom N/2 items now:
4652         const int bottom_part_start = wxMax(row, count - row);
4653         for ( row = bottom_part_start; row < count; row++ )
4654         {
4655             calculator.UpdateWithRow(row);
4656         }
4657
4658         // finally, include currently visible items in the calculation:
4659         const wxPoint origin = CalcUnscrolledPosition(wxPoint(0, 0));
4660         int first_visible = m_clientArea->GetLineAt(origin.y);
4661         int last_visible = m_clientArea->GetLineAt(origin.y + GetClientSize().y);
4662
4663         first_visible = wxMax(first_visible, top_part_end);
4664         last_visible = wxMin(bottom_part_start, last_visible);
4665
4666         for ( row = first_visible; row < last_visible; row++ )
4667         {
4668             calculator.UpdateWithRow(row);
4669         }
4670
4671         wxLogTrace("dataview",
4672                    "determined best size from %d top, %d bottom plus %d more visible items out of %d total",
4673                    top_part_end,
4674                    count - bottom_part_start,
4675                    wxMax(0, last_visible - first_visible),
4676                    count);
4677     }
4678
4679     int max_width = calculator.GetMaxWidth();
4680     if ( max_width > 0 )
4681         max_width += 2 * PADDING_RIGHTLEFT;
4682
4683     const_cast<wxDataViewCtrl*>(this)->m_colsBestWidths[idx] = max_width;
4684     return max_width;
4685 }
4686
4687 void wxDataViewCtrl::ColumnMoved(wxDataViewColumn * WXUNUSED(col),
4688                                 unsigned int WXUNUSED(new_pos))
4689 {
4690     // do _not_ reorder m_cols elements here, they should always be in the
4691     // order in which columns were added, we only display the columns in
4692     // different order
4693     m_clientArea->UpdateDisplay();
4694 }
4695
4696 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
4697 {
4698     wxDataViewColumnList::compatibility_iterator ret = m_cols.Find( column );
4699     if (!ret)
4700         return false;
4701
4702     m_colsBestWidths.erase(m_colsBestWidths.begin() + GetColumnIndex(column));
4703     m_cols.Erase(ret);
4704     OnColumnsCountChanged();
4705
4706     return true;
4707 }
4708
4709 bool wxDataViewCtrl::ClearColumns()
4710 {
4711     SetExpanderColumn(NULL);
4712     m_cols.Clear();
4713     m_colsBestWidths.clear();
4714     OnColumnsCountChanged();
4715     return true;
4716 }
4717
4718 void wxDataViewCtrl::InvalidateColBestWidth(int idx)
4719 {
4720     m_colsBestWidths[idx] = 0;
4721     m_colsDirty = true;
4722 }
4723
4724 void wxDataViewCtrl::InvalidateColBestWidths()
4725 {
4726     m_colsBestWidths.clear();
4727     m_colsBestWidths.resize(m_cols.size());
4728     m_colsDirty = true;
4729 }
4730
4731 void wxDataViewCtrl::UpdateColWidths()
4732 {
4733     if ( !m_headerArea )
4734         return;
4735
4736     const unsigned len = m_colsBestWidths.size();
4737     for ( unsigned i = 0; i < len; i++ )
4738     {
4739         if ( m_colsBestWidths[i] == 0 )
4740             m_headerArea->UpdateColumn(i);
4741     }
4742 }
4743
4744 void wxDataViewCtrl::OnInternalIdle()
4745 {
4746     wxDataViewCtrlBase::OnInternalIdle();
4747
4748     if ( m_colsDirty )
4749     {
4750         m_colsDirty = false;
4751         UpdateColWidths();
4752     }
4753 }
4754
4755 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
4756 {
4757 #if 1
4758     unsigned int len = GetColumnCount();
4759     for ( unsigned int i = 0; i < len; i++ )
4760     {
4761         wxDataViewColumn * col = GetColumnAt(i);
4762         if (column==col)
4763             return i;
4764     }
4765
4766     return wxNOT_FOUND;
4767 #else
4768     // This returns the position in pixels which is not what we want.
4769     int ret = 0,
4770         dummy = 0;
4771     unsigned int len = GetColumnCount();
4772     for ( unsigned int i = 0; i < len; i++ )
4773     {
4774         wxDataViewColumn * col = GetColumnAt(i);
4775         if (col->IsHidden())
4776             continue;
4777         ret += col->GetWidth();
4778         if (column==col)
4779         {
4780             CalcScrolledPosition( ret, dummy, &ret, &dummy );
4781             break;
4782         }
4783     }
4784     return ret;
4785 #endif
4786 }
4787
4788 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
4789 {
4790     return m_sortingColumnIdx == wxNOT_FOUND ? NULL
4791                                             : GetColumn(m_sortingColumnIdx);
4792 }
4793
4794 wxDataViewItem wxDataViewCtrl::DoGetCurrentItem() const
4795 {
4796     return GetItemByRow(m_clientArea->GetCurrentRow());
4797 }
4798
4799 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item)
4800 {
4801     const int row = m_clientArea->GetRowByItem(item);
4802
4803     const unsigned oldCurrent = m_clientArea->GetCurrentRow();
4804     if ( static_cast<unsigned>(row) != oldCurrent )
4805     {
4806         m_clientArea->ChangeCurrentRow(row);
4807         m_clientArea->RefreshRow(oldCurrent);
4808         m_clientArea->RefreshRow(row);
4809     }
4810 }
4811
4812 int wxDataViewCtrl::GetSelectedItemsCount() const
4813 {
4814     return m_clientArea->GetSelections().size();
4815 }
4816
4817 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
4818 {
4819     sel.Empty();
4820     const wxDataViewSelection& selections = m_clientArea->GetSelections();
4821
4822     const size_t len = selections.size();
4823     for ( size_t i = 0; i < len; i++ )
4824     {
4825         wxDataViewItem item = m_clientArea->GetItemByRow(selections[i]);
4826         if ( item.IsOk() )
4827         {
4828             sel.Add(item);
4829         }
4830         else
4831         {
4832             wxFAIL_MSG( "invalid item in selection - bad internal state" );
4833         }
4834     }
4835
4836     return sel.size();
4837 }
4838
4839 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
4840 {
4841     wxDataViewSelection selection(wxDataViewSelectionCmp);
4842
4843     wxDataViewItem last_parent;
4844
4845     int len = sel.GetCount();
4846     for( int i = 0; i < len; i ++ )
4847     {
4848         wxDataViewItem item = sel[i];
4849         wxDataViewItem parent = GetModel()->GetParent( item );
4850         if (parent)
4851         {
4852             if (parent != last_parent)
4853                 ExpandAncestors(item);
4854         }
4855
4856         last_parent = parent;
4857         int row = m_clientArea->GetRowByItem( item );
4858         if( row >= 0 )
4859             selection.Add( static_cast<unsigned int>(row) );
4860     }
4861
4862     m_clientArea->SetSelections( selection );
4863 }
4864
4865 void wxDataViewCtrl::Select( const wxDataViewItem & item )
4866 {
4867     ExpandAncestors( item );
4868
4869     int row = m_clientArea->GetRowByItem( item );
4870     if( row >= 0 )
4871     {
4872         // Unselect all rows before select another in the single select mode
4873         if (m_clientArea->IsSingleSel())
4874             m_clientArea->SelectAllRows(false);
4875
4876         m_clientArea->SelectRow(row, true);
4877
4878         // Also set focus to the selected item
4879         m_clientArea->ChangeCurrentRow( row );
4880     }
4881 }
4882
4883 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
4884 {
4885     int row = m_clientArea->GetRowByItem( item );
4886     if( row >= 0 )
4887         m_clientArea->SelectRow(row, false);
4888 }
4889
4890 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
4891 {
4892     int row = m_clientArea->GetRowByItem( item );
4893     if( row >= 0 )
4894     {
4895         return m_clientArea->IsRowSelected(row);
4896     }
4897     return false;
4898 }
4899
4900 void wxDataViewCtrl::SelectAll()
4901 {
4902     m_clientArea->SelectAllRows(true);
4903 }
4904
4905 void wxDataViewCtrl::UnselectAll()
4906 {
4907     m_clientArea->SelectAllRows(false);
4908 }
4909
4910 void wxDataViewCtrl::EnsureVisible( int row, int column )
4911 {
4912     if( row < 0 )
4913         row = 0;
4914     if( row > (int) m_clientArea->GetRowCount() )
4915         row = m_clientArea->GetRowCount();
4916
4917     int first = m_clientArea->GetFirstVisibleRow();
4918     int last = m_clientArea->GetLastVisibleRow();
4919     if( row < first )
4920         m_clientArea->ScrollTo( row, column );
4921     else if( row > last )
4922         m_clientArea->ScrollTo( row - last + first, column );
4923     else
4924         m_clientArea->ScrollTo( first, column );
4925 }
4926
4927 void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, const wxDataViewColumn * column )
4928 {
4929     ExpandAncestors( item );
4930
4931     m_clientArea->RecalculateDisplay();
4932
4933     int row = m_clientArea->GetRowByItem(item);
4934     if( row >= 0 )
4935     {
4936         if( column == NULL )
4937             EnsureVisible(row, -1);
4938         else
4939             EnsureVisible( row, GetColumnIndex(column) );
4940     }
4941
4942 }
4943
4944 void wxDataViewCtrl::HitTest( const wxPoint & point, wxDataViewItem & item,
4945                               wxDataViewColumn* &column ) const
4946 {
4947     m_clientArea->HitTest(point, item, column);
4948 }
4949
4950 wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem & item,
4951                                     const wxDataViewColumn* column ) const
4952 {
4953     return m_clientArea->GetItemRect(item, column);
4954 }
4955
4956 wxDataViewItem wxDataViewCtrl::GetItemByRow( unsigned int row ) const
4957 {
4958     return m_clientArea->GetItemByRow( row );
4959 }
4960
4961 int wxDataViewCtrl::GetRowByItem( const wxDataViewItem & item ) const
4962 {
4963     return m_clientArea->GetRowByItem( item );
4964 }
4965
4966 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
4967 {
4968     ExpandAncestors( item );
4969
4970     int row = m_clientArea->GetRowByItem( item );
4971     if (row != -1)
4972         m_clientArea->Expand(row);
4973 }
4974
4975 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
4976 {
4977     int row = m_clientArea->GetRowByItem( item );
4978     if (row != -1)
4979         m_clientArea->Collapse(row);
4980 }
4981
4982 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const
4983 {
4984     int row = m_clientArea->GetRowByItem( item );
4985     if (row != -1)
4986         return m_clientArea->IsExpanded(row);
4987     return false;
4988 }
4989
4990 void wxDataViewCtrl::StartEditor( const wxDataViewItem & item, unsigned int column )
4991 {
4992     wxDataViewColumn* col = GetColumn( column );
4993     if (!col)
4994         return;
4995
4996     m_clientArea->StartEditing(item, col);
4997 }
4998
4999 #endif // !wxUSE_GENERICDATAVIEWCTRL
5000
5001 #endif // wxUSE_DATAVIEWCTRL