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