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