src/generic/datavgen.cpp

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