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