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