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