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