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         HDITEM hdi;
1416         hdi.mask = HDI_TEXT | HDI_FORMAT | HDI_WIDTH;
1417         if (col->GetBitmap().IsOk())
1418         {
1419            m_imageList->Add( col->GetBitmap() );
1420            hdi.mask |= HDI_IMAGE;
1421            hdi.iImage = m_imageList->GetImageCount()-1;
1422         }
1423         hdi.pszText = (wxChar *) col->GetTitle().wx_str();
1424         hdi.cxy = col->GetWidth();
1425         hdi.cchTextMax = sizeof(hdi.pszText)/sizeof(hdi.pszText[0]);
1426         hdi.fmt = HDF_LEFT | HDF_STRING;
1427         if (col->GetBitmap().IsOk())
1428             hdi.fmt |= HDF_IMAGE;
1429
1430         //hdi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP);
1431
1432         if (col->IsSortable() && GetOwner()->GetSortingColumn() == col)
1433         {
1434             //The Microsoft Comctrl32.dll 6.0 support SORTUP/SORTDOWN, but they are not default
1435             //see http://msdn2.microsoft.com/en-us/library/ms649534.aspx for more detail
1436             // VZ: works with 5.81
1437             hdi.fmt |= col->IsSortOrderAscending() ? HDF_SORTUP : HDF_SORTDOWN;
1438         }
1439
1440         // lParam is reserved for application's use:
1441         // we store there the column index to use it later in MSWOnNotify
1442         // (since columns may have been hidden)
1443         hdi.lParam = (LPARAM)i;
1444
1445         // the native wxMSW implementation of the header window
1446         // draws the column separator COLUMN_WIDTH_OFFSET pixels
1447         // on the right: to correct this effect we make the column
1448         // exactly COLUMN_WIDTH_OFFSET wider (for the first column):
1449         if (i == 0)
1450             hdi.cxy += COLUMN_WIDTH_OFFSET;
1451
1452         switch (col->GetAlignment())
1453         {
1454         case wxALIGN_LEFT:
1455             hdi.fmt |= HDF_LEFT;
1456             break;
1457         case wxALIGN_CENTER:
1458         case wxALIGN_CENTER_HORIZONTAL:
1459             hdi.fmt |= HDF_CENTER;
1460             break;
1461         case wxALIGN_RIGHT:
1462             hdi.fmt |= HDF_RIGHT;
1463             break;
1464
1465         default:
1466             // such alignment is not allowed for the column header!
1467             break; // wxFAIL;
1468         }
1469
1470         SendMessage((HWND)m_hWnd, HDM_INSERTITEM,
1471                     (WPARAM)added, (LPARAM)&hdi);
1472         added++;
1473     }
1474 }
1475
1476 unsigned int wxDataViewHeaderWindowMSW::GetColumnIdxFromHeader(NMHEADER *nmHDR)
1477 {
1478     unsigned int idx;
1479
1480     // NOTE: we don't just return nmHDR->iItem because when there are
1481     //       hidden columns, nmHDR->iItem may be different from
1482     //       nmHDR->pitem->lParam
1483
1484     if (nmHDR->pitem && nmHDR->pitem->mask & HDI_LPARAM)
1485     {
1486         idx = (unsigned int)nmHDR->pitem->lParam;
1487         return idx;
1488     }
1489
1490     HDITEM item;
1491     item.mask = HDI_LPARAM;
1492     Header_GetItem((HWND)m_hWnd, nmHDR->iItem, &item);
1493
1494     return (unsigned int)item.lParam;
1495 }
1496
1497 bool wxDataViewHeaderWindowMSW::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
1498 {
1499     NMHDR *nmhdr = (NMHDR *)lParam;
1500
1501     // is it a message from the header?
1502     if ( nmhdr->hwndFrom != (HWND)m_hWnd )
1503         return wxWindow::MSWOnNotify(idCtrl, lParam, result);
1504
1505     NMHEADER *nmHDR = (NMHEADER *)nmhdr;
1506     switch ( nmhdr->code )
1507     {
1508         case HDN_BEGINTRACK:
1509             // user has started to resize a column:
1510             // do we need to veto it?
1511             if (!GetColumn(nmHDR->iItem)->IsResizeable())
1512             {
1513                 // veto it!
1514                 *result = TRUE;
1515             }
1516             break;
1517
1518         case HDN_BEGINDRAG:
1519             // user has started to reorder a column
1520             if ((nmHDR->iItem != -1) && (!GetColumn(nmHDR->iItem)->IsReorderable()))
1521             {
1522                 // veto it!
1523                 *result = TRUE;
1524             }
1525             break;
1526
1527         case HDN_ENDDRAG:       // user has finished reordering a column
1528             {
1529                wxDataViewColumn *col = GetColumn(nmHDR->iItem);
1530                unsigned int new_pos = nmHDR->pitem->iOrder;
1531                m_owner->ColumnMoved( col, new_pos );
1532                m_delayedUpdate = true;
1533             }
1534             break;
1535
1536         case HDN_ITEMCHANGING:
1537             if (nmHDR->pitem != NULL &&
1538                 (nmHDR->pitem->mask & HDI_WIDTH) != 0)
1539             {
1540                 int minWidth = GetColumnFromHeader(nmHDR)->GetMinWidth();
1541                 if (nmHDR->pitem->cxy < minWidth)
1542                 {
1543                     // do not allow the user to resize this column under
1544                     // its minimal width:
1545                     *result = TRUE;
1546                 }
1547             }
1548             break;
1549
1550         case HDN_ITEMCHANGED:   // user is resizing a column
1551         case HDN_ENDTRACK:      // user has finished resizing a column
1552
1553             // update the width of the modified column:
1554             if (nmHDR->pitem != NULL &&
1555                 (nmHDR->pitem->mask & HDI_WIDTH) != 0)
1556             {
1557                 unsigned int idx = GetColumnIdxFromHeader(nmHDR);
1558                 unsigned int w = nmHDR->pitem->cxy;
1559                 wxDataViewColumn *col = GetColumn(idx);
1560
1561                 // see UpdateDisplay() for more info about COLUMN_WIDTH_OFFSET
1562                 if (idx == 0 && w > COLUMN_WIDTH_OFFSET)
1563                     w -= COLUMN_WIDTH_OFFSET;
1564
1565                 if (w >= (unsigned)col->GetMinWidth())
1566                     col->SetInternalWidth(w);
1567             }
1568             break;
1569
1570         case HDN_ITEMCLICK:
1571             {
1572                 unsigned int idx = GetColumnIdxFromHeader(nmHDR);
1573                 wxDataViewModel * model = GetOwner()->GetModel();
1574
1575                 if(nmHDR->iButton == 0)
1576                 {
1577                     wxDataViewColumn *col = GetColumn(idx);
1578                     if(col->IsSortable())
1579                     {
1580                         if(model && m_owner->GetSortingColumn() == col)
1581                         {
1582                             bool order = col->IsSortOrderAscending();
1583                             col->SetSortOrder(!order);
1584                         }
1585                         else if(model)
1586                         {
1587                             m_owner->SetSortingColumn(col);
1588                         }
1589                     }
1590                     UpdateDisplay();
1591                     if(model)
1592                         model->Resort();
1593                 }
1594
1595                 wxEventType evt = nmHDR->iButton == 0 ?
1596                         wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK :
1597                         wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK;
1598                 SendEvent(evt, idx);
1599             }
1600             break;
1601
1602         case NM_RCLICK:
1603             {
1604                 // NOTE: for some reason (i.e. for a bug in Windows)
1605                 //       the HDN_ITEMCLICK notification is not sent on
1606                 //       right clicks, so we need to handle NM_RCLICK
1607
1608                 POINT ptClick;
1609                 int column = wxMSWGetColumnClicked(nmhdr, &ptClick);
1610                 if (column != wxNOT_FOUND)
1611                 {
1612                     HDITEM item;
1613                     item.mask = HDI_LPARAM;
1614                     Header_GetItem((HWND)m_hWnd, column, &item);
1615
1616                     // 'idx' may be different from 'column' if there are
1617                     // hidden columns...
1618                     unsigned int idx = (unsigned int)item.lParam;
1619                     SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK,
1620                               idx);
1621                 }
1622             }
1623             break;
1624
1625         case HDN_GETDISPINFOW:
1626             // see wxListCtrl::MSWOnNotify for more info!
1627             break;
1628
1629         case HDN_ITEMDBLCLICK:
1630             {
1631                 unsigned int idx = GetColumnIdxFromHeader(nmHDR);
1632                 int w = GetOwner()->GetBestColumnWidth(idx);
1633
1634                 // update the native control:
1635                 HDITEM hd;
1636                 ZeroMemory(&hd, sizeof(hd));
1637                 hd.mask = HDI_WIDTH;
1638                 hd.cxy = w;
1639                 Header_SetItem(GetHwnd(),
1640                                nmHDR->iItem,  // NOTE: we don't want 'idx' here!
1641                                &hd);
1642
1643                 // update the wxDataViewColumn class:
1644                 GetColumn(idx)->SetInternalWidth(w);
1645             }
1646             break;
1647
1648         default:
1649             return wxWindow::MSWOnNotify(idCtrl, lParam, result);
1650     }
1651
1652     return true;
1653 }
1654
1655 void wxDataViewHeaderWindowMSW::ScrollWindow(int dx, int WXUNUSED(dy),
1656                                              const wxRect * WXUNUSED(rect))
1657 {
1658     m_scrollOffsetX += dx;
1659
1660     GetParent()->Layout();
1661 }
1662
1663 void wxDataViewHeaderWindowMSW::DoSetSize(int x, int y,
1664                                           int w, int h,
1665                                           int f)
1666 {
1667     // TODO: why is there a border + 2px around it?
1668     wxControl::DoSetSize( x+m_scrollOffsetX+1, y+1, w-m_scrollOffsetX-2, h-2, f );
1669 }
1670
1671 #else       // !defined(__WXMSW__)
1672
1673 IMPLEMENT_ABSTRACT_CLASS(wxGenericDataViewHeaderWindow, wxWindow)
1674 BEGIN_EVENT_TABLE(wxGenericDataViewHeaderWindow, wxWindow)
1675     EVT_PAINT         (wxGenericDataViewHeaderWindow::OnPaint)
1676     EVT_MOUSE_EVENTS  (wxGenericDataViewHeaderWindow::OnMouse)
1677     EVT_SET_FOCUS     (wxGenericDataViewHeaderWindow::OnSetFocus)
1678 END_EVENT_TABLE()
1679
1680 bool wxGenericDataViewHeaderWindow::Create(wxDataViewCtrl *parent, wxWindowID id,
1681                                            const wxPoint &pos, const wxSize &size,
1682                                            const wxString &name )
1683 {
1684     m_owner = parent;
1685
1686     if (!wxDataViewHeaderWindowBase::Create(parent, id, pos, size, name))
1687         return false;
1688
1689     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
1690     SetBackgroundStyle( wxBG_STYLE_CUSTOM );
1691     SetOwnForegroundColour( attr.colFg );
1692     SetOwnBackgroundColour( attr.colBg );
1693     if (!m_hasFont)
1694         SetOwnFont( attr.font );
1695
1696     // set our size hints: wxDataViewCtrl will put this wxWindow inside
1697     // a wxBoxSizer and in order to avoid super-big header windows,
1698     // we need to set our height as fixed
1699     SetMinSize(wxSize(-1, HEADER_WINDOW_HEIGHT));
1700     SetMaxSize(wxSize(-1, HEADER_WINDOW_HEIGHT));
1701
1702     return true;
1703 }
1704
1705 void wxGenericDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1706 {
1707     int w, h;
1708     GetClientSize( &w, &h );
1709
1710     wxAutoBufferedPaintDC dc( this );
1711
1712     dc.SetBackground(GetBackgroundColour());
1713     dc.Clear();
1714
1715     int xpix;
1716     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1717
1718     int x;
1719     m_owner->GetViewStart( &x, NULL );
1720
1721     // account for the horz scrollbar offset
1722     dc.SetDeviceOrigin( -x * xpix, 0 );
1723
1724     dc.SetFont( GetFont() );
1725
1726     unsigned int cols = GetOwner()->GetColumnCount();
1727     unsigned int i;
1728     int xpos = 0;
1729     for (i = 0; i < cols; i++)
1730     {
1731         wxDataViewColumn *col = GetColumn( i );
1732         if (col->IsHidden())
1733             continue;      // skip it!
1734
1735         int cw = col->GetWidth();
1736         int ch = h;
1737
1738         wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE;
1739         if (col->IsSortable() && GetOwner()->GetSortingColumn() == col)
1740         {
1741             if (col->IsSortOrderAscending())
1742                 sortArrow = wxHDR_SORT_ICON_UP;
1743             else
1744                 sortArrow = wxHDR_SORT_ICON_DOWN;
1745         }
1746
1747         int state = 0;
1748         if (m_parent->IsEnabled())
1749         {
1750             if ((int) i == m_hover)
1751                 state = wxCONTROL_CURRENT;
1752         }
1753         else
1754         {
1755             state = (int) wxCONTROL_DISABLED;
1756         }
1757
1758         wxRendererNative::Get().DrawHeaderButton
1759                                 (
1760                                     this,
1761                                     dc,
1762                                     wxRect(xpos, 0, cw, ch-1),
1763                                     state,
1764                                     sortArrow
1765                                 );
1766
1767         // align as required the column title:
1768         int x = xpos;
1769         wxSize titleSz = dc.GetTextExtent(col->GetTitle());
1770         switch (col->GetAlignment())
1771         {
1772         case wxALIGN_LEFT:
1773             x += HEADER_HORIZ_BORDER;
1774             break;
1775         case wxALIGN_RIGHT:
1776             x += cw - titleSz.GetWidth() - HEADER_HORIZ_BORDER;
1777             break;
1778         default:
1779         case wxALIGN_CENTER:
1780         case wxALIGN_CENTER_HORIZONTAL:
1781             x += (cw - titleSz.GetWidth() - 2 * HEADER_HORIZ_BORDER)/2;
1782             break;
1783         }
1784
1785         // always center the title vertically:
1786         int y = wxMax((ch - titleSz.GetHeight()) / 2, HEADER_VERT_BORDER);
1787
1788         dc.SetClippingRegion( xpos+HEADER_HORIZ_BORDER,
1789                               HEADER_VERT_BORDER,
1790                               wxMax(cw - 2 * HEADER_HORIZ_BORDER, 1),  // width
1791                               wxMax(ch - 2 * HEADER_VERT_BORDER, 1));  // height
1792         dc.DrawText( col->GetTitle(), x, y );
1793         dc.DestroyClippingRegion();
1794
1795         xpos += cw;
1796     }
1797 }
1798
1799 void wxGenericDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
1800 {
1801     GetParent()->SetFocus();
1802     event.Skip();
1803 }
1804
1805 void wxGenericDataViewHeaderWindow::OnMouse( wxMouseEvent &event )
1806 {
1807     // we want to work with logical coords
1808     int x;
1809     m_owner->CalcUnscrolledPosition(event.GetX(), 0, &x, NULL);
1810     int y = event.GetY();
1811
1812     if (m_isDragging)
1813     {
1814         // we don't draw the line beyond our window,
1815         // but we allow dragging it there
1816         int w = 0;
1817         GetClientSize( &w, NULL );
1818         m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1819         w -= 6;
1820
1821         if (event.ButtonUp())
1822         {
1823             m_isDragging = false;
1824             if (HasCapture())
1825                 ReleaseMouse();
1826
1827             m_dirty = true;
1828         }
1829         m_currentX = wxMax(m_minX + 7, x);
1830
1831         if (m_currentX < w)
1832         {
1833             GetColumn(m_column)->SetWidth(m_currentX - m_minX);
1834             Refresh();
1835             GetOwner()->Refresh();
1836         }
1837
1838     }
1839     else     // not dragging
1840     {
1841         m_minX = 0;
1842         m_column = wxNOT_FOUND;
1843
1844         bool hit_border = false;
1845
1846         // end of the current column
1847         int xpos = 0;
1848
1849         // find the column where this event occured
1850         int countCol = m_owner->GetColumnCount();
1851         for (int column = 0; column < countCol; column++)
1852         {
1853             wxDataViewColumn *p = GetColumn(column);
1854
1855             if (p->IsHidden())
1856                 continue;   // skip if not shown
1857
1858             xpos += p->GetWidth();
1859             m_column = column;
1860             if ((abs(x-xpos) < 3) && (y < 22))
1861             {
1862                 hit_border = true;
1863                 break;
1864             }
1865
1866             if (x < xpos)
1867             {
1868                 // inside the column
1869                 break;
1870             }
1871
1872             m_minX = xpos;
1873         }
1874
1875         int old_hover = m_hover;
1876         m_hover = m_column;
1877         if (event.Leaving())
1878             m_hover = wxNOT_FOUND;
1879         if (old_hover != m_hover)
1880             Refresh();
1881
1882         if (m_column == wxNOT_FOUND)
1883             return;
1884
1885         bool resizeable = GetColumn(m_column)->IsResizeable();
1886         if (event.LeftDClick() && resizeable)
1887         {
1888             GetColumn(m_column)->SetWidth(GetOwner()->GetBestColumnWidth(m_column));
1889             Refresh();
1890         }
1891         else if (event.LeftDown() || event.RightUp())
1892         {
1893             if (hit_border && event.LeftDown() && resizeable)
1894             {
1895                 m_isDragging = true;
1896                 CaptureMouse();
1897                 m_currentX = x;
1898             }
1899             else    // click on a column
1900             {
1901                 wxDataViewModel * model = GetOwner()->GetModel();
1902                 wxEventType evt = event.LeftDown() ?
1903                         wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK :
1904                         wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK;
1905                 SendEvent(evt, m_column);
1906
1907                 //Left click the header
1908                 if(event.LeftDown())
1909                 {
1910                     wxDataViewColumn *col = GetColumn(m_column);
1911                     if(col->IsSortable())
1912                     {
1913                         wxDataViewColumn* sortCol = m_owner->GetSortingColumn();
1914                         if(model && sortCol == col)
1915                         {
1916                             bool order = col->IsSortOrderAscending();
1917                             col->SetSortOrder(!order);
1918                         }
1919                         else if(model)
1920                         {
1921                             m_owner->SetSortingColumn(col);
1922                         }
1923                     }
1924                     UpdateDisplay();
1925                     if(model)
1926                         model->Resort();
1927                     //Send the column sorted event
1928                     SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, m_column);
1929                 }
1930             }
1931         }
1932         else if (event.Moving())
1933         {
1934             if (hit_border && resizeable)
1935                 m_currentCursor = m_resizeCursor;
1936             else
1937                 m_currentCursor = wxSTANDARD_CURSOR;
1938
1939             SetCursor(*m_currentCursor);
1940         }
1941     }
1942 }
1943
1944 void wxGenericDataViewHeaderWindow::AdjustDC(wxDC& dc)
1945 {
1946     int xpix, x;
1947
1948     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1949     m_owner->GetViewStart( &x, NULL );
1950
1951     // shift the DC origin to match the position of the main window horizontal
1952     // scrollbar: this allows us to always use logical coords
1953     dc.SetDeviceOrigin( -x * xpix, 0 );
1954 }
1955
1956 #endif      // defined(__WXMSW__)
1957
1958 //-----------------------------------------------------------------------------
1959 // wxDataViewRenameTimer
1960 //-----------------------------------------------------------------------------
1961
1962 wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner )
1963 {
1964     m_owner = owner;
1965 }
1966
1967 void wxDataViewRenameTimer::Notify()
1968 {
1969     m_owner->OnRenameTimer();
1970 }
1971
1972 //-----------------------------------------------------------------------------
1973 // wxDataViewMainWindow
1974 //-----------------------------------------------------------------------------
1975
1976 //The tree building helper, declared firstly
1977 static void BuildTreeHelper( wxDataViewModel * model,  wxDataViewItem & item, wxDataViewTreeNode * node);
1978
1979 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
1980 {
1981     if (row1 > row2) return 1;
1982     if (row1 == row2) return 0;
1983     return -1;
1984 }
1985
1986
1987 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
1988
1989 BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
1990     EVT_PAINT         (wxDataViewMainWindow::OnPaint)
1991     EVT_MOUSE_EVENTS  (wxDataViewMainWindow::OnMouse)
1992     EVT_SET_FOCUS     (wxDataViewMainWindow::OnSetFocus)
1993     EVT_KILL_FOCUS    (wxDataViewMainWindow::OnKillFocus)
1994     EVT_CHAR          (wxDataViewMainWindow::OnChar)
1995 END_EVENT_TABLE()
1996
1997 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
1998     const wxPoint &pos, const wxSize &size, const wxString &name ) :
1999     wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE, name ),
2000     m_selection( wxDataViewSelectionCmp )
2001
2002 {
2003     SetOwner( parent );
2004
2005     m_lastOnSame = false;
2006     m_renameTimer = new wxDataViewRenameTimer( this );
2007
2008     // TODO: user better initial values/nothing selected
2009     m_currentCol = NULL;
2010     m_currentRow = 0;
2011
2012     m_lineHeight = wxMax( 17, GetCharHeight() + 2 ); // 17 = mini icon height + 1
2013
2014     m_dragCount = 0;
2015     m_dragStart = wxPoint(0,0);
2016     m_lineLastClicked = (unsigned int) -1;
2017     m_lineBeforeLastClicked = (unsigned int) -1;
2018     m_lineSelectSingleOnUp = (unsigned int) -1;
2019
2020     m_hasFocus = false;
2021
2022     SetBackgroundColour( *wxWHITE );
2023
2024     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
2025
2026     m_penRule = wxPen(GetRuleColour());
2027
2028     //Here I compose a pen can draw black lines, maybe there are something system colour to use
2029     m_penExpander = wxPen(wxColour(0,0,0));
2030     //Some new added code to deal with the tree structure
2031     m_root = new wxDataViewTreeNode( NULL );
2032     m_root->SetHasChildren(true);
2033
2034     //Make m_count = -1 will cause the class recaculate the real displaying number of rows.
2035     m_count = -1 ;
2036     m_underMouse = NULL;
2037     UpdateDisplay();
2038 }
2039
2040 wxDataViewMainWindow::~wxDataViewMainWindow()
2041 {
2042     DestroyTree();
2043     delete m_renameTimer;
2044 }
2045
2046 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
2047 {
2048     wxDataViewModel *model = GetOwner()->GetModel();
2049     wxAutoBufferedPaintDC dc( this );
2050
2051 #ifdef __WXMSW__
2052     dc.SetPen( *wxTRANSPARENT_PEN );
2053     dc.SetBrush( wxBrush( GetBackgroundColour()) );
2054     dc.SetBrush( *wxWHITE_BRUSH );
2055     wxSize size( GetClientSize() );
2056     dc.DrawRectangle( 0,0,size.x,size.y );
2057 #endif
2058
2059     // prepare the DC
2060     GetOwner()->PrepareDC( dc );
2061     dc.SetFont( GetFont() );
2062
2063     wxRect update = GetUpdateRegion().GetBox();
2064     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
2065
2066     // compute which items needs to be redrawn
2067     unsigned int item_start = GetLineAt( wxMax(0,update.y) );
2068     unsigned int item_count =
2069         wxMin( (int)(  GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1),
2070                (int)(GetRowCount( ) - item_start));
2071     unsigned int item_last = item_start + item_count;
2072
2073     // compute which columns needs to be redrawn
2074     unsigned int cols = GetOwner()->GetColumnCount();
2075     unsigned int col_start = 0;
2076     unsigned int x_start = 0;
2077     for (x_start = 0; col_start < cols; col_start++)
2078     {
2079         wxDataViewColumn *col = GetOwner()->GetColumn(col_start);
2080         if (col->IsHidden())
2081             continue;      // skip it!
2082
2083         unsigned int w = col->GetWidth();
2084         if (x_start+w >= (unsigned int)update.x)
2085             break;
2086
2087         x_start += w;
2088     }
2089
2090     unsigned int col_last = col_start;
2091     unsigned int x_last = x_start;
2092     for (; col_last < cols; col_last++)
2093     {
2094         wxDataViewColumn *col = GetOwner()->GetColumn(col_last);
2095         if (col->IsHidden())
2096             continue;      // skip it!
2097
2098         if (x_last > (unsigned int)update.GetRight())
2099             break;
2100
2101         x_last += col->GetWidth();
2102     }
2103
2104     // Draw horizontal rules if required
2105     if ( m_owner->HasFlag(wxDV_HORIZ_RULES) )
2106     {
2107         dc.SetPen(m_penRule);
2108         dc.SetBrush(*wxTRANSPARENT_BRUSH);
2109
2110         for (unsigned int i = item_start; i <= item_last+1; i++)
2111         {
2112             int y = GetLineStart( i );
2113             dc.DrawLine(x_start, y, x_last, y);
2114         }
2115     }
2116
2117     // Draw vertical rules if required
2118     if ( m_owner->HasFlag(wxDV_VERT_RULES) )
2119     {
2120         dc.SetPen(m_penRule);
2121         dc.SetBrush(*wxTRANSPARENT_BRUSH);
2122
2123         int x = x_start;
2124         for (unsigned int i = col_start; i < col_last; i++)
2125         {
2126             wxDataViewColumn *col = GetOwner()->GetColumn(i);
2127             if (col->IsHidden())
2128                 continue;       // skip it
2129
2130             dc.DrawLine(x, GetLineStart( item_start ),
2131                         x, GetLineStart( item_last ) );
2132
2133             x += col->GetWidth();
2134         }
2135
2136         // Draw last vertical rule
2137         dc.DrawLine(x, GetLineStart( item_start ),
2138                     x, GetLineStart( item_last ) );
2139     }
2140
2141     // redraw the background for the items which are selected/current
2142     for (unsigned int item = item_start; item < item_last; item++)
2143     {
2144         bool selected = m_selection.Index( item ) != wxNOT_FOUND;
2145         if (selected || item == m_currentRow)
2146         {
2147             int flags = selected ? (int)wxCONTROL_SELECTED : 0;
2148             if (item == m_currentRow)
2149                 flags |= wxCONTROL_CURRENT;
2150             if (m_hasFocus)
2151                 flags |= wxCONTROL_FOCUSED;
2152
2153             wxRect rect( x_start, GetLineStart( item ), x_last, GetLineHeight( item ) );
2154             wxRendererNative::Get().DrawItemSelectionRect
2155                                 (
2156                                     this,
2157                                     dc,
2158                                     rect,
2159                                     flags
2160                                 );
2161         }
2162     }
2163
2164     wxDataViewColumn *expander = GetOwner()->GetExpanderColumn();
2165     if (!expander)
2166     {
2167         // TODO: last column for RTL support
2168         expander = GetOwner()->GetColumn( 0 );
2169         GetOwner()->SetExpanderColumn(expander);
2170     }
2171
2172     // redraw all cells for all rows which must be repainted and all columns
2173     wxRect cell_rect;
2174     cell_rect.x = x_start;
2175     for (unsigned int i = col_start; i < col_last; i++)
2176     {
2177         cell_rect.height = GetLineHeight( i );     // -1 is for the horizontal rules (?)
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( (void*) 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 the y offset
2222             cell_rect.y = GetLineStart( item );
2223
2224             //Draw the expander here.
2225             int indent = 0;
2226             if ((!IsVirtualList()) && (col == expander))
2227             {
2228                 indent = node->GetIndentLevel();
2229
2230                 //Calculate the indent first
2231                 indent = cell_rect.x + GetOwner()->GetIndent() * indent;
2232
2233                 int expander_width = m_lineHeight - 2*EXPANDER_MARGIN;
2234                 // change the cell_rect.x to the appropriate pos
2235                 int  expander_x = indent + EXPANDER_MARGIN;
2236                 int expander_y = cell_rect.y + EXPANDER_MARGIN + (GetLineHeight(item) / 2) - (expander_width/2) - EXPANDER_OFFSET;
2237                 indent = indent + m_lineHeight ;  //try to use the m_lineHeight as the expander space
2238                 dc.SetPen( m_penExpander );
2239                 dc.SetBrush( wxNullBrush );
2240                 if( node->HasChildren() )
2241                 {
2242                     wxRect rect( expander_x , expander_y, expander_width, expander_width);
2243                     int flag = 0;
2244                     if (m_underMouse == node)
2245                     {
2246                         flag |= wxCONTROL_CURRENT;
2247                     }
2248                     if( node->IsOpen() )
2249                         wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag|wxCONTROL_EXPANDED );
2250                     else
2251                         wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag);
2252                 }
2253                  //force the expander column to left-center align
2254                  cell->SetAlignment( wxALIGN_CENTER_VERTICAL );
2255             }
2256             if (node && !node->HasChildren())
2257             {
2258                 // Yes, if the node does not have any child, it must be a leaf which
2259                 // mean that it is a temporarily created by GetTreeNodeByRow
2260                 wxDELETE(node)
2261             }
2262
2263             // cannot be bigger than allocated space
2264             wxSize size = cell->GetSize();
2265             // Because of the tree structure indent, here we should minus the width of the cell for drawing
2266             size.x = wxMin( size.x + 2*PADDING_RIGHTLEFT, cell_rect.width - indent );
2267             // size.y = wxMin( size.y, cell_rect.height );
2268             size.y = cell_rect.height;
2269
2270             wxRect item_rect(cell_rect.GetTopLeft(), size);
2271             int align = cell->CalculateAlignment();
2272
2273             // horizontal alignment:
2274             item_rect.x = cell_rect.x;
2275             if (align & wxALIGN_CENTER_HORIZONTAL)
2276                 item_rect.x = cell_rect.x + (cell_rect.width / 2) - (size.x / 2);
2277             else if (align & wxALIGN_RIGHT)
2278                 item_rect.x = cell_rect.x + cell_rect.width - size.x;
2279             //else: wxALIGN_LEFT is the default
2280
2281             // vertical alignment:
2282             item_rect.y = cell_rect.y;
2283             if (align & wxALIGN_CENTER_VERTICAL)
2284                 item_rect.y = cell_rect.y + (cell_rect.height / 2) - (size.y / 2);
2285             else if (align & wxALIGN_BOTTOM)
2286                 item_rect.y = cell_rect.y + cell_rect.height - size.y;
2287             //else: wxALIGN_TOP is the default
2288
2289             // add padding
2290             item_rect.x += PADDING_RIGHTLEFT;
2291             item_rect.width = size.x - 2 * PADDING_RIGHTLEFT;
2292
2293             //Here we add the tree indent
2294             item_rect.x += indent;
2295
2296             int state = 0;
2297             if (m_hasFocus && (m_selection.Index(item) != wxNOT_FOUND))
2298                 state |= wxDATAVIEW_CELL_SELECTED;
2299
2300             // TODO: it would be much more efficient to create a clipping
2301             //       region for the entire column being rendered (in the OnPaint
2302             //       of wxDataViewMainWindow) instead of a single clip region for
2303             //       each cell. However it would mean that each renderer should
2304             //       respect the given wxRect's top & bottom coords, eventually
2305             //       violating only the left & right coords - however the user can
2306             //       make its own renderer and thus we cannot be sure of that.
2307             dc.SetClippingRegion( item_rect );
2308             cell->Render( item_rect, &dc, state );
2309             dc.DestroyClippingRegion();
2310         }
2311
2312         cell_rect.x += cell_rect.width;
2313     }
2314 }
2315
2316 void wxDataViewMainWindow::OnRenameTimer()
2317 {
2318     // We have to call this here because changes may just have
2319     // been made and no screen update taken place.
2320     if ( m_dirty )
2321         wxSafeYield();
2322
2323     int xpos = 0;
2324     unsigned int cols = GetOwner()->GetColumnCount();
2325     unsigned int i;
2326     for (i = 0; i < cols; i++)
2327     {
2328         wxDataViewColumn *c = GetOwner()->GetColumn( i );
2329         if (c->IsHidden())
2330             continue;      // skip it!
2331
2332         if (c == m_currentCol)
2333             break;
2334         xpos += c->GetWidth();
2335     }
2336     wxRect labelRect( xpos,
2337                       GetLineStart( m_currentRow ),
2338                       m_currentCol->GetWidth(),
2339                       GetLineHeight( m_currentRow ) );
2340
2341     GetOwner()->CalcScrolledPosition( labelRect.x, labelRect.y,
2342                                      &labelRect.x, &labelRect.y);
2343
2344     wxDataViewItem item = GetItemByRow( m_currentRow );
2345     m_currentCol->GetRenderer()->StartEditing( item, labelRect );
2346
2347 }
2348
2349 //------------------------------------------------------------------
2350 // Helper class for do operation on the tree node
2351 //------------------------------------------------------------------
2352 class DoJob
2353 {
2354 public:
2355     DoJob(){};
2356     virtual ~DoJob(){};
2357
2358     //The return value control how the tree-walker tranverse the tree
2359     // 0: Job done, stop tranverse and return
2360     // 1: Ignore the current node's subtree and continue
2361     // 2: Job not done, continue
2362     enum  { OK = 0 , IGR = 1, CONT = 2 };
2363     virtual int operator() ( wxDataViewTreeNode * node ) = 0 ;
2364     virtual int operator() ( void * n ) = 0;
2365 };
2366
2367 bool Walker( wxDataViewTreeNode * node, DoJob & func )
2368 {
2369     if( node==NULL )
2370         return false;
2371
2372     switch( func( node ) )
2373     {
2374         case DoJob::OK :
2375             return true ;
2376         case DoJob::IGR:
2377             return false;
2378         case DoJob::CONT:
2379             default:
2380                 ;
2381     }
2382
2383     wxDataViewTreeNodes nodes = node->GetNodes();
2384     wxDataViewTreeLeaves leaves = node->GetChildren();
2385
2386     int len_nodes = nodes.GetCount();
2387     int len = leaves.GetCount();
2388     int i = 0, nodes_i = 0;
2389
2390     for( ; i < len ; i ++ )
2391     {
2392         void * n = leaves[i];
2393         if( nodes_i < len_nodes && n == nodes[nodes_i]->GetItem().GetID() )
2394         {
2395             wxDataViewTreeNode * nd = nodes[nodes_i];
2396             nodes_i++;
2397
2398             if( Walker( nd , func ) )
2399                 return true;
2400
2401         }
2402         else
2403             switch( func( n ) )
2404             {
2405                 case DoJob::OK :
2406                     return true ;
2407                 case DoJob::IGR:
2408                     continue;
2409                 case DoJob::CONT:
2410                 default:
2411                     ;
2412             }
2413     }
2414     return false;
2415 }
2416
2417 bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item)
2418 {
2419     if (!m_root)
2420     {
2421         m_count++;
2422         UpdateDisplay();
2423         return true;
2424     }
2425
2426     SortPrepare();
2427
2428     wxDataViewTreeNode * node;
2429     node = FindNode(parent);
2430
2431     if( node == NULL )
2432         return false;
2433
2434     node->SetHasChildren( true );
2435
2436     if( g_model->IsContainer( item ) )
2437     {
2438         wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node );
2439         newnode->SetItem(item);
2440         newnode->SetHasChildren( true );
2441         node->AddNode( newnode);
2442     }
2443     else
2444         node->AddLeaf( item.GetID() );
2445
2446     node->ChangeSubTreeCount(1);
2447
2448     m_count = -1;
2449     UpdateDisplay();
2450
2451     return true;
2452 }
2453
2454 static void DestroyTreeHelper( wxDataViewTreeNode * node);
2455
2456 bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent,
2457                                        const wxDataViewItem& item)
2458 {
2459     if (!m_root)
2460     {
2461         m_count--;
2462         if( m_currentRow > GetRowCount() )
2463             m_currentRow = m_count - 1;
2464
2465         m_selection.Empty();
2466
2467         UpdateDisplay();
2468
2469         return true;
2470     }
2471
2472     wxDataViewTreeNode * node = FindNode(parent);
2473
2474     wxCHECK_MSG( node != NULL, false, "item not found" );
2475     wxCHECK_MSG( node->GetChildren().Index( item.GetID() ) != wxNOT_FOUND, false, "item not found" );
2476
2477     int sub = -1;
2478     node->GetChildren().Remove( item.GetID() );
2479     //Manuplate selection
2480     if( m_selection.GetCount() > 1 )
2481     {
2482         m_selection.Empty();
2483     }
2484     bool isContainer = false;
2485     wxDataViewTreeNodes nds = node->GetNodes();
2486     for (size_t i = 0; i < nds.GetCount(); i ++)
2487     {
2488         if (nds[i]->GetItem() == item)
2489         {
2490             isContainer = true;
2491             break;
2492         }
2493     }
2494     if( isContainer )
2495     {
2496         wxDataViewTreeNode * n = NULL;
2497         wxDataViewTreeNodes nodes = node->GetNodes();
2498         int len = nodes.GetCount();
2499         for( int i = 0 ; i < len; i ++)
2500         {
2501             if( nodes[i]->GetItem() == item )
2502             {
2503                 n = nodes[i];
2504                 break;
2505             }
2506         }
2507
2508         wxCHECK_MSG( n != NULL, false, "item not found" );
2509
2510         node->GetNodes().Remove( n );
2511         sub -= n->GetSubTreeCount();
2512         ::DestroyTreeHelper(n);
2513     }
2514     //Make the row number invalid and get a new valid one when user call GetRowCount
2515     m_count = -1;
2516     node->ChangeSubTreeCount(sub);
2517
2518     //Change the current row to the last row if the current exceed the max row number
2519     if( m_currentRow > GetRowCount() )
2520         m_currentRow = m_count - 1;
2521
2522     UpdateDisplay();
2523
2524     return true;
2525 }
2526
2527 bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item)
2528 {
2529     SortPrepare();
2530     g_model->Resort();
2531
2532     //Send event
2533     wxWindow *parent = GetParent();
2534     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
2535     le.SetEventObject(parent);
2536     le.SetModel(GetOwner()->GetModel());
2537     le.SetItem(item);
2538     parent->GetEventHandler()->ProcessEvent(le);
2539
2540     return true;
2541 }
2542
2543 bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int col )
2544 {
2545     // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
2546 /*#define MAX_VIRTUAL_WIDTH       100000
2547
2548     wxRect rect( 0, row*m_lineHeight, MAX_VIRTUAL_WIDTH, m_lineHeight );
2549     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2550     Refresh( true, &rect );
2551
2552     return true;
2553 */
2554     SortPrepare();
2555     g_model->Resort();
2556
2557     //Send event
2558     wxWindow *parent = GetParent();
2559     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
2560     le.SetEventObject(parent);
2561     le.SetModel(GetOwner()->GetModel());
2562     le.SetItem(item);
2563     le.SetColumn(col);
2564     le.SetDataViewColumn(GetOwner()->GetColumn(col));
2565     parent->GetEventHandler()->ProcessEvent(le);
2566
2567     return true;
2568 }
2569
2570 bool wxDataViewMainWindow::Cleared()
2571 {
2572     DestroyTree();
2573
2574     SortPrepare();
2575     BuildTree( GetOwner()->GetModel() );
2576
2577     UpdateDisplay();
2578
2579     return true;
2580 }
2581
2582 void wxDataViewMainWindow::UpdateDisplay()
2583 {
2584     m_dirty = true;
2585 }
2586
2587 void wxDataViewMainWindow::OnInternalIdle()
2588 {
2589     wxWindow::OnInternalIdle();
2590
2591     if (m_dirty)
2592     {
2593         RecalculateDisplay();
2594         m_dirty = false;
2595     }
2596 }
2597
2598 void wxDataViewMainWindow::RecalculateDisplay()
2599 {
2600     wxDataViewModel *model = GetOwner()->GetModel();
2601     if (!model)
2602     {
2603         Refresh();
2604         return;
2605     }
2606
2607     int width = GetEndOfLastCol();
2608     int height = GetLineStart( GetRowCount() );
2609
2610     SetVirtualSize( width, height );
2611     GetOwner()->SetScrollRate( 10, m_lineHeight );
2612
2613     Refresh();
2614 }
2615
2616 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
2617 {
2618     wxWindow::ScrollWindow( dx, dy, rect );
2619
2620     if (GetOwner()->m_headerArea)
2621         GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
2622 }
2623
2624 void wxDataViewMainWindow::ScrollTo( int rows, int column )
2625 {
2626     int x, y;
2627     m_owner->GetScrollPixelsPerUnit( &x, &y );
2628     int sy = GetLineStart( rows )/y;
2629     int sx = 0;
2630     if( column != -1 )
2631     {
2632         wxRect rect = GetClientRect();
2633         int colnum = 0;
2634         int x_start = 0, x_end = 0, w = 0;
2635         int xx, yy, xe;
2636         m_owner->CalcUnscrolledPosition( rect.x, rect.y, &xx, &yy );
2637         for (x_start = 0; colnum < column; colnum++)
2638         {
2639             wxDataViewColumn *col = GetOwner()->GetColumn(colnum);
2640             if (col->IsHidden())
2641                 continue;      // skip it!
2642
2643             w = col->GetWidth();
2644             x_start += w;
2645         }
2646
2647         x_end = x_start + w;
2648         xe = xx + rect.width;
2649         if( x_end > xe )
2650         {
2651             sx = ( xx + x_end - xe )/x;
2652         }
2653         if( x_start < xx )
2654         {
2655             sx = x_start/x;
2656         }
2657     }
2658     m_owner->Scroll( sx, sy );
2659 }
2660
2661 int wxDataViewMainWindow::GetCountPerPage() const
2662 {
2663     wxSize size = GetClientSize();
2664     return size.y / m_lineHeight;
2665 }
2666
2667 int wxDataViewMainWindow::GetEndOfLastCol() const
2668 {
2669     int width = 0;
2670     unsigned int i;
2671     for (i = 0; i < GetOwner()->GetColumnCount(); i++)
2672     {
2673         const wxDataViewColumn *c =
2674             wx_const_cast(wxDataViewCtrl*, GetOwner())->GetColumn( i );
2675
2676         if (!c->IsHidden())
2677             width += c->GetWidth();
2678     }
2679     return width;
2680 }
2681
2682 unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const
2683 {
2684     int x = 0;
2685     int y = 0;
2686     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
2687
2688     return GetLineAt( y );
2689 }
2690
2691 unsigned int wxDataViewMainWindow::GetLastVisibleRow()
2692 {
2693     wxSize client_size = GetClientSize();
2694     m_owner->CalcUnscrolledPosition( client_size.x, client_size.y,
2695                                      &client_size.x, &client_size.y );
2696
2697     //we should deal with the pixel here
2698     unsigned int row = GetLineAt(client_size.y) - 1;
2699
2700     return wxMin( GetRowCount()-1, row );
2701 }
2702
2703 unsigned int wxDataViewMainWindow::GetRowCount()
2704 {
2705     if ( m_count == -1 )
2706     {
2707         m_count = RecalculateCount();
2708         UpdateDisplay();
2709     }
2710     return m_count;
2711 }
2712
2713 void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
2714 {
2715     m_currentRow = row;
2716
2717     // send event
2718 }
2719
2720 void wxDataViewMainWindow::SelectAllRows( bool on )
2721 {
2722     if (IsEmpty())
2723         return;
2724
2725     if (on)
2726     {
2727         m_selection.Clear();
2728         for (unsigned int i = 0; i < GetRowCount(); i++)
2729             m_selection.Add( i );
2730         Refresh();
2731     }
2732     else
2733     {
2734         unsigned int first_visible = GetFirstVisibleRow();
2735         unsigned int last_visible = GetLastVisibleRow();
2736         unsigned int i;
2737         for (i = 0; i < m_selection.GetCount(); i++)
2738         {
2739             unsigned int row = m_selection[i];
2740             if ((row >= first_visible) && (row <= last_visible))
2741                 RefreshRow( row );
2742         }
2743         m_selection.Clear();
2744     }
2745 }
2746
2747 void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
2748 {
2749     if (m_selection.Index( row ) == wxNOT_FOUND)
2750     {
2751         if (on)
2752         {
2753             m_selection.Add( row );
2754             RefreshRow( row );
2755         }
2756     }
2757     else
2758     {
2759         if (!on)
2760         {
2761             m_selection.Remove( row );
2762             RefreshRow( row );
2763         }
2764     }
2765 }
2766
2767 void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
2768 {
2769     if (from > to)
2770     {
2771         unsigned int tmp = from;
2772         from = to;
2773         to = tmp;
2774     }
2775
2776     unsigned int i;
2777     for (i = from; i <= to; i++)
2778     {
2779         if (m_selection.Index( i ) == wxNOT_FOUND)
2780         {
2781             if (on)
2782                 m_selection.Add( i );
2783         }
2784         else
2785         {
2786             if (!on)
2787                 m_selection.Remove( i );
2788         }
2789     }
2790     RefreshRows( from, to );
2791 }
2792
2793 void wxDataViewMainWindow::Select( const wxArrayInt& aSelections )
2794 {
2795     for (size_t i=0; i < aSelections.GetCount(); i++)
2796     {
2797         int n = aSelections[i];
2798
2799         m_selection.Add( n );
2800         RefreshRow( n );
2801     }
2802 }
2803
2804 void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
2805 {
2806     if (m_selection.Index( row ) == wxNOT_FOUND)
2807         m_selection.Add( row );
2808     else
2809         m_selection.Remove( row );
2810     RefreshRow( row );
2811 }
2812
2813 bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
2814 {
2815     return (m_selection.Index( row ) != wxNOT_FOUND);
2816 }
2817
2818 void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem& item)
2819 {
2820     wxWindow *parent = GetParent();
2821     wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, parent->GetId());
2822
2823     le.SetEventObject(parent);
2824     le.SetModel(GetOwner()->GetModel());
2825     le.SetItem( item );
2826
2827     parent->GetEventHandler()->ProcessEvent(le);
2828 }
2829
2830 void wxDataViewMainWindow::RefreshRow( unsigned int row )
2831 {
2832     wxRect rect( 0, GetLineStart( row ), GetEndOfLastCol(), GetLineHeight( row ) );
2833     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2834
2835     wxSize client_size = GetClientSize();
2836     wxRect client_rect( 0, 0, client_size.x, client_size.y );
2837     wxRect intersect_rect = client_rect.Intersect( rect );
2838     if (intersect_rect.width > 0)
2839         Refresh( true, &intersect_rect );
2840 }
2841
2842 void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
2843 {
2844     if (from > to)
2845     {
2846         unsigned int tmp = to;
2847         to = from;
2848         from = tmp;
2849     }
2850
2851     wxRect rect( 0, GetLineStart( from ), GetEndOfLastCol(), GetLineStart( (to-from+1) ) );
2852     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2853
2854     wxSize client_size = GetClientSize();
2855     wxRect client_rect( 0, 0, client_size.x, client_size.y );
2856     wxRect intersect_rect = client_rect.Intersect( rect );
2857     if (intersect_rect.width > 0)
2858         Refresh( true, &intersect_rect );
2859 }
2860
2861 void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
2862 {
2863     wxSize client_size = GetClientSize();
2864     int start = GetLineStart( firstRow );
2865     m_owner->CalcScrolledPosition( start, 0, &start, NULL );
2866     if (start > client_size.y) return;
2867
2868     wxRect rect( 0, start, client_size.x, client_size.y - start );
2869
2870     Refresh( true, &rect );
2871 }
2872
2873 void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event)
2874 {
2875     wxCHECK_RET( newCurrent < GetRowCount(),
2876                  _T("invalid item index in OnArrowChar()") );
2877
2878     // if there is no selection, we cannot move it anywhere
2879     if (!HasCurrentRow())
2880         return;
2881
2882     unsigned int oldCurrent = m_currentRow;
2883
2884     // in single selection we just ignore Shift as we can't select several
2885     // items anyhow
2886     if ( event.ShiftDown() && !IsSingleSel() )
2887     {
2888         RefreshRow( oldCurrent );
2889
2890         ChangeCurrentRow( newCurrent );
2891
2892         // select all the items between the old and the new one
2893         if ( oldCurrent > newCurrent )
2894         {
2895             newCurrent = oldCurrent;
2896             oldCurrent = m_currentRow;
2897         }
2898
2899         SelectRows( oldCurrent, newCurrent, true );
2900         if (oldCurrent!=newCurrent)
2901             SendSelectionChangedEvent(GetItemByRow(m_selection[0]));
2902     }
2903     else // !shift
2904     {
2905         RefreshRow( oldCurrent );
2906
2907         // all previously selected items are unselected unless ctrl is held
2908         if ( !event.ControlDown() )
2909             SelectAllRows(false);
2910
2911         ChangeCurrentRow( newCurrent );
2912
2913         if ( !event.ControlDown() )
2914         {
2915             SelectRow( m_currentRow, true );
2916             SendSelectionChangedEvent(GetItemByRow(m_currentRow));
2917         }
2918         else
2919             RefreshRow( m_currentRow );
2920     }
2921
2922     GetOwner()->EnsureVisible( m_currentRow, -1 );
2923 }
2924
2925 wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const
2926 {
2927     wxRect rect;
2928     rect.x = 0;
2929     rect.y = GetLineStart( row );
2930     rect.width = GetEndOfLastCol();
2931     rect.height = GetLineHeight( row );
2932
2933     return rect;
2934 }
2935
2936 int wxDataViewMainWindow::GetLineStart( unsigned int row ) const
2937 {
2938     const wxDataViewModel *model = GetOwner()->GetModel();
2939
2940     if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2941     {
2942         // TODO make more efficient
2943
2944         int start = 0;
2945
2946         unsigned int r;
2947         for (r = 0; r < row; r++)
2948         {
2949            const wxDataViewTreeNode* node = GetTreeNodeByRow(r);
2950            if (!node) return start;
2951
2952            wxDataViewItem item = node->GetItem();
2953
2954            unsigned int cols = GetOwner()->GetColumnCount();
2955            unsigned int col;
2956            int height = 0;
2957            for (col = 0; col < cols; col++)
2958            {
2959                 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2960                 if (column->IsHidden())
2961                     continue;      // skip it!
2962
2963                 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
2964                     continue;      // skip it!
2965
2966                 const wxDataViewRenderer *renderer = column->GetRenderer();
2967                 wxVariant value;
2968                 model->GetValue( value, item, column->GetModelColumn() );
2969                 wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
2970                 renderer2->SetValue( value );
2971                 height = wxMax( height, renderer->GetSize().y );
2972            }
2973
2974            start += height;
2975         }
2976
2977         return start;
2978     }
2979     else
2980     {
2981         return row * m_lineHeight;
2982     }
2983 }
2984
2985 int wxDataViewMainWindow::GetLineAt( unsigned int y ) const
2986 {
2987     const wxDataViewModel *model = GetOwner()->GetModel();
2988
2989     if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2990     {
2991         // TODO make more efficient
2992
2993         unsigned int row = 0;
2994         unsigned int yy = 0;
2995         for (;;)
2996         {
2997            const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
2998            if (!node)
2999            {
3000                // not really correct...
3001                return row + ((y-yy) / m_lineHeight);
3002            }
3003
3004            wxDataViewItem item = node->GetItem();
3005
3006            unsigned int cols = GetOwner()->GetColumnCount();
3007            unsigned int col;
3008            int height = 0;
3009            for (col = 0; col < cols; col++)
3010            {
3011                 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
3012                 if (column->IsHidden())
3013                     continue;      // skip it!
3014
3015                 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
3016                     continue;      // skip it!
3017
3018                 const wxDataViewRenderer *renderer = column->GetRenderer();
3019                 wxVariant value;
3020                 model->GetValue( value, item, column->GetModelColumn() );
3021                 wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
3022                 renderer2->SetValue( value );
3023                 height = wxMax( height, renderer->GetSize().y );
3024            }
3025
3026            yy += height;
3027            if (y < yy)
3028                return row;
3029
3030            row++;
3031         }
3032
3033         return -1;
3034     }
3035     else
3036     {
3037         return y / m_lineHeight;
3038     }
3039 }
3040
3041 int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const
3042 {
3043     const wxDataViewModel *model = GetOwner()->GetModel();
3044
3045     if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
3046     {
3047         wxASSERT( !IsVirtualList() );
3048
3049         const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
3050         // wxASSERT( node );
3051         if (!node) return m_lineHeight;
3052
3053         wxDataViewItem item = node->GetItem();
3054
3055         int height = 0;
3056
3057         unsigned int cols = GetOwner()->GetColumnCount();
3058         unsigned int col;
3059         for (col = 0; col < cols; col++)
3060         {
3061             const wxDataViewColumn *column = GetOwner()->GetColumn(col);
3062             if (column->IsHidden())
3063                 continue;      // skip it!
3064
3065             if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
3066                 continue;      // skip it!
3067
3068             const wxDataViewRenderer *renderer = column->GetRenderer();
3069             wxVariant value;
3070             model->GetValue( value, item, column->GetModelColumn() );
3071             wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
3072             renderer2->SetValue( value );
3073             height = wxMax( height, renderer->GetSize().y );
3074         }
3075
3076         return height;
3077     }
3078     else
3079     {
3080         return m_lineHeight;
3081     }
3082 }
3083
3084 class RowToItemJob: public DoJob
3085 {
3086 public:
3087     RowToItemJob( unsigned int row , int current ) { this->row = row; this->current = current ;}
3088     virtual ~RowToItemJob(){};
3089
3090     virtual int operator() ( wxDataViewTreeNode * node )
3091     {
3092         current ++;
3093         if( current == static_cast<int>(row))
3094          {
3095             ret = node->GetItem() ;
3096             return DoJob::OK;
3097         }
3098
3099         if( node->GetSubTreeCount() + current < static_cast<int>(row) )
3100         {
3101             current += node->GetSubTreeCount();
3102             return  DoJob::IGR;
3103         }
3104         else
3105         {
3106             //If the current has no child node, we can find the desired item of the row number directly.
3107             //This if can speed up finding in some case, and will has a very good effect when it comes to list view
3108             if( node->GetNodes().GetCount() == 0)
3109             {
3110                 int index = static_cast<int>(row) - current - 1;
3111                 ret = node->GetChildren().Item( index );
3112                 return DoJob::OK;
3113             }
3114             return DoJob::CONT;
3115         }
3116     }
3117
3118     virtual int operator() ( void * n )
3119     {
3120         current ++;
3121         if( current == static_cast<int>(row))
3122          {
3123             ret = wxDataViewItem( n ) ;
3124             return DoJob::OK;
3125         }
3126         return DoJob::CONT;
3127     }
3128     wxDataViewItem GetResult(){ return ret; }
3129 private:
3130     unsigned int row;
3131     int current ;
3132     wxDataViewItem ret;
3133 };
3134
3135 wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const
3136 {
3137     if (!m_root)
3138     {
3139         return wxDataViewItem( (void*) row );
3140     }
3141     else
3142     {
3143         RowToItemJob job( row, -2 );
3144         Walker( m_root , job );
3145         return job.GetResult();
3146     }
3147 }
3148
3149 class RowToTreeNodeJob: public DoJob
3150 {
3151 public:
3152     RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node )
3153     {
3154         this->row = row;
3155         this->current = current ;
3156         ret = NULL ;
3157         parent = node;
3158     }
3159     virtual ~RowToTreeNodeJob(){};
3160
3161     virtual int operator() ( wxDataViewTreeNode * node )
3162     {
3163         current ++;
3164         if( current == static_cast<int>(row))
3165          {
3166             ret = node ;
3167             return DoJob::OK;
3168         }
3169
3170         if( node->GetSubTreeCount() + current < static_cast<int>(row) )
3171         {
3172             current += node->GetSubTreeCount();
3173             return  DoJob::IGR;
3174         }
3175         else
3176         {
3177             parent = node;
3178             //If the current has no child node, we can find the desired item of the row number directly.
3179             //This if can speed up finding in some case, and will has a very good effect when it comes to list view
3180             if( node->GetNodes().GetCount() == 0)
3181             {
3182                 int index = static_cast<int>(row) - current - 1;
3183                 void * n = node->GetChildren().Item( index );
3184                 ret = new wxDataViewTreeNode( parent ) ;
3185                 ret->SetItem( wxDataViewItem( n ));
3186                 ret->SetHasChildren(false);
3187                 return DoJob::OK;
3188             }
3189             return DoJob::CONT;
3190         }
3191
3192
3193     }
3194
3195     virtual int operator() ( void * n )
3196     {
3197         current ++;
3198         if( current == static_cast<int>(row))
3199          {
3200             ret = new wxDataViewTreeNode( parent ) ;
3201             ret->SetItem( wxDataViewItem( n ));
3202             ret->SetHasChildren(false);
3203             return DoJob::OK;
3204         }
3205
3206         return DoJob::CONT;
3207     }
3208     wxDataViewTreeNode * GetResult(){ return ret; }
3209 private:
3210     unsigned int row;
3211     int current ;
3212     wxDataViewTreeNode * ret;
3213     wxDataViewTreeNode * parent ;
3214 };
3215
3216
3217 wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const
3218 {
3219     wxASSERT( !IsVirtualList() );
3220
3221     RowToTreeNodeJob job( row , -2, m_root );
3222     Walker( m_root , job );
3223     return job.GetResult();
3224 }
3225
3226 wxDataViewEvent wxDataViewMainWindow::SendExpanderEvent( wxEventType type, const wxDataViewItem & item )
3227 {
3228     wxWindow *parent = GetParent();
3229     wxDataViewEvent le(type, parent->GetId());
3230
3231     le.SetEventObject(parent);
3232     le.SetModel(GetOwner()->GetModel());
3233     le.SetItem( item );
3234
3235     parent->GetEventHandler()->ProcessEvent(le);
3236     return le;
3237 }
3238
3239 void wxDataViewMainWindow::OnExpanding( unsigned int row )
3240 {
3241     wxDataViewTreeNode * node = GetTreeNodeByRow(row);
3242     if( node != NULL )
3243     {
3244         if( node->HasChildren())
3245         {
3246             if( !node->IsOpen())
3247             {
3248                wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING,node->GetItem());
3249                //Check if the user prevent expanding
3250                if( e.GetSkipped() )
3251                     return;
3252
3253                node->ToggleOpen();
3254                //Here I build the children of current node
3255                if( node->GetChildrenNumber() == 0 )
3256                {
3257                    SortPrepare();
3258                    ::BuildTreeHelper(GetOwner()->GetModel(), node->GetItem(), node);
3259                }
3260                m_count = -1;
3261                UpdateDisplay();
3262                //Send the expanded event
3263                SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem());
3264             }
3265             else
3266             {
3267                 SelectRow( row, false );
3268                 SelectRow( row + 1, true );
3269                 ChangeCurrentRow( row + 1 );
3270                 SendSelectionChangedEvent( GetItemByRow(row+1));
3271             }
3272         }
3273         else
3274             delete node;
3275     }
3276 }
3277
3278 void wxDataViewMainWindow::OnCollapsing(unsigned int row)
3279 {
3280     wxDataViewTreeNode * node = GetTreeNodeByRow(row);
3281     if( node != NULL )
3282     {
3283         wxDataViewTreeNode * nd = node;
3284
3285         if( node->HasChildren() && node->IsOpen() )
3286         {
3287             wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem());
3288             if( e.GetSkipped() )
3289                 return;
3290             node->ToggleOpen();
3291             m_count = -1;
3292             UpdateDisplay();
3293             SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,nd->GetItem());
3294         }
3295         else
3296         {
3297             node = node->GetParent();
3298             if( node != NULL )
3299             {
3300                 int  parent = GetRowByItem( node->GetItem() ) ;
3301                 if( parent >= 0 )
3302                 {
3303                     SelectRow( row, false);
3304                     SelectRow(parent , true );
3305                     ChangeCurrentRow( parent );
3306                     SendSelectionChangedEvent( node->GetItem() );
3307                 }
3308             }
3309         }
3310         if( !nd->HasChildren())
3311             delete nd;
3312     }
3313 }
3314
3315 wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item )
3316 {
3317     wxDataViewModel * model = GetOwner()->GetModel();
3318     if( model == NULL )
3319         return NULL;
3320
3321     //Compose the a parent-chain of the finding item
3322     ItemList list;
3323     list.DeleteContents( true );
3324     wxDataViewItem it( item );
3325     while( it.IsOk() )
3326     {
3327         wxDataViewItem * pItem = new wxDataViewItem( it );
3328         list.Insert( pItem );
3329         it = model->GetParent( it );
3330     }
3331
3332     //Find the item along the parent-chain.
3333     //This algorithm is designed to speed up the node-finding method
3334     wxDataViewTreeNode * node = m_root;
3335     for( ItemList::const_iterator iter = list.begin(); iter !=list.end() ; iter++ )
3336     {
3337         if( node->HasChildren() )
3338         {
3339             if( node->GetChildrenNumber() == 0 )
3340             {
3341                 SortPrepare();
3342                 ::BuildTreeHelper(model, node->GetItem(), node);
3343             }
3344
3345             wxDataViewTreeNodes nodes = node->GetNodes();
3346             unsigned int i;
3347             bool found = false;
3348
3349             for (i = 0; i < nodes.GetCount(); i ++)
3350             {
3351                 if (nodes[i]->GetItem() == (**iter))
3352                 {
3353                     if (nodes[i]->GetItem() == item)
3354                        return nodes[i];
3355
3356                     node = nodes[i];
3357                     found = true;
3358                     break;
3359                 }
3360             }
3361             if (!found)
3362                 return NULL;
3363         }
3364         else
3365             return NULL;
3366     }
3367     return NULL;
3368 }
3369
3370 void wxDataViewMainWindow::HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column )
3371 {
3372     wxDataViewColumn *col = NULL;
3373     unsigned int cols = GetOwner()->GetColumnCount();
3374     unsigned int colnum = 0;
3375     unsigned int x_start = 0;
3376     int x, y;
3377     m_owner->CalcUnscrolledPosition( point.x, point.y, &x, &y );
3378     for (x_start = 0; colnum < cols; colnum++)
3379     {
3380         col = GetOwner()->GetColumn(colnum);
3381         if (col->IsHidden())
3382             continue;      // skip it!
3383
3384         unsigned int w = col->GetWidth();
3385         if (x_start+w >= (unsigned int)x)
3386             break;
3387
3388         x_start += w;
3389     }
3390
3391     column = col;
3392     item = GetItemByRow( GetLineAt( y ) );
3393 }
3394
3395 wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column )
3396 {
3397     int row = GetRowByItem(item);
3398     int y = GetLineStart( row );
3399     int h = GetLineHeight( m_lineHeight );
3400     int x = 0;
3401     wxDataViewColumn *col = NULL;
3402     for( int i = 0, cols = GetOwner()->GetColumnCount(); i < cols; i ++ )
3403     {
3404        col = GetOwner()->GetColumn( i );
3405        x += col->GetWidth();
3406        if( GetOwner()->GetColumn(i+1) == column )
3407            break;
3408     }
3409     int w = col->GetWidth();
3410     m_owner->CalcScrolledPosition( x, y, &x, &y );
3411     return wxRect(x, y, w, h);
3412 }
3413
3414 int wxDataViewMainWindow::RecalculateCount()
3415 {
3416     if (!m_root)
3417     {
3418         wxDataViewIndexListModel *list_model = (wxDataViewIndexListModel*) GetOwner()->GetModel();
3419 #ifndef __WXMAC__
3420         return list_model->GetLastIndex() + 1;
3421 #else
3422         return list_model->GetLastIndex() - 1;
3423 #endif
3424     }
3425     else
3426     {
3427         return m_root->GetSubTreeCount();
3428     }
3429 }
3430
3431 class ItemToRowJob : public DoJob
3432 {
3433 public:
3434     ItemToRowJob(const wxDataViewItem & item, ItemList::const_iterator iter )
3435     { this->item = item ; ret = -1 ; m_iter = iter ; }
3436     virtual ~ItemToRowJob(){};
3437
3438     //Maybe binary search will help to speed up this process
3439     virtual int operator() ( wxDataViewTreeNode * node)
3440     {
3441          ret ++;
3442          if( node->GetItem() == item )
3443          {
3444              return DoJob::OK;
3445          }
3446
3447          if( node->GetItem() == **m_iter )
3448          {
3449              m_iter++ ;
3450              return DoJob::CONT;
3451          }
3452          else
3453          {
3454              ret += node->GetSubTreeCount();
3455              return DoJob::IGR;
3456          }
3457
3458     }
3459
3460     virtual int operator() ( void * n )
3461     {
3462         ret ++;
3463         if( n == item.GetID() )
3464             return DoJob::OK;
3465         return DoJob::CONT;
3466     }
3467     //the row number is begin from zero
3468     int GetResult(){ return ret -1 ; }
3469 private:
3470     ItemList::const_iterator  m_iter;
3471     wxDataViewItem item;
3472     int ret;
3473
3474 };
3475
3476 int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const
3477 {
3478     const wxDataViewModel * model = GetOwner()->GetModel();
3479     if( model == NULL )
3480         return -1;
3481
3482     if (!m_root)
3483     {
3484         return wxPtrToUInt( item.GetID() );
3485     }
3486     else
3487     {
3488         if( !item.IsOk() )
3489             return -1;
3490
3491         //Compose the a parent-chain of the finding item
3492         ItemList list;
3493         wxDataViewItem * pItem = NULL;
3494         list.DeleteContents( true );
3495         wxDataViewItem it( item );
3496         while( it.IsOk() )
3497         {
3498             pItem = new wxDataViewItem( it );
3499             list.Insert( pItem );
3500             it = model->GetParent( it );
3501         }
3502         pItem = new wxDataViewItem( );
3503         list.Insert( pItem );
3504
3505         ItemToRowJob job( item, list.begin() );
3506         Walker(m_root , job );
3507         return job.GetResult();
3508     }
3509 }
3510
3511 static void BuildTreeHelper( wxDataViewModel * model,  wxDataViewItem & item, wxDataViewTreeNode * node)
3512 {
3513     if( !model->IsContainer( item ) )
3514         return ;
3515
3516     wxDataViewItemArray children;
3517     unsigned int num = model->GetChildren( item, children);
3518     unsigned int index = 0;
3519     while( index < num )
3520     {
3521         if( model->IsContainer( children[index] ) )
3522         {
3523             wxDataViewTreeNode * n = new wxDataViewTreeNode( node );
3524             n->SetItem(children[index]);
3525             n->SetHasChildren( true ) ;
3526             node->AddNode( n );
3527         }
3528         else
3529         {
3530             node->AddLeaf( children[index].GetID() );
3531         }
3532         index ++;
3533     }
3534     node->SetSubTreeCount( num );
3535     wxDataViewTreeNode * n = node->GetParent();
3536     if( n != NULL)
3537         n->ChangeSubTreeCount(num);
3538
3539 }
3540
3541 void wxDataViewMainWindow::BuildTree(wxDataViewModel * model)
3542 {
3543     DestroyTree();
3544
3545     if (GetOwner()->GetModel()->IsVirtualListModel())
3546     {
3547         m_count = -1 ;
3548         return;
3549     }
3550
3551     m_root = new wxDataViewTreeNode( NULL );
3552     m_root->SetHasChildren(true);
3553
3554     //First we define a invalid item to fetch the top-level elements
3555     wxDataViewItem item;
3556     SortPrepare();
3557     BuildTreeHelper( model, item, m_root);
3558     m_count = -1 ;
3559 }
3560
3561 static void DestroyTreeHelper( wxDataViewTreeNode * node )
3562 {
3563     if( node->GetNodeNumber() != 0 )
3564     {
3565         int len = node->GetNodeNumber();
3566         int i = 0 ;
3567         wxDataViewTreeNodes& nodes = node->GetNodes();
3568         for( ; i < len; i ++ )
3569         {
3570             DestroyTreeHelper(nodes[i]);
3571         }
3572     }
3573     delete node;
3574 }
3575
3576 void wxDataViewMainWindow::DestroyTree()
3577 {
3578     if (!IsVirtualList())
3579     {
3580        ::DestroyTreeHelper(m_root);
3581         m_count = 0;
3582         m_root = NULL;
3583     }
3584 }
3585
3586 void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
3587 {
3588     if ( HandleAsNavigationKey(event) )
3589         return;
3590
3591     // no item -> nothing to do
3592     if (!HasCurrentRow())
3593     {
3594         event.Skip();
3595         return;
3596     }
3597
3598     // don't use m_linesPerPage directly as it might not be computed yet
3599     const int pageSize = GetCountPerPage();
3600     wxCHECK_RET( pageSize, _T("should have non zero page size") );
3601
3602     switch ( event.GetKeyCode() )
3603     {
3604         case WXK_RETURN:
3605         {
3606             if (m_currentRow > 0)
3607             {
3608                 wxWindow *parent = GetParent();
3609                 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
3610                 le.SetItem( GetItemByRow(m_currentRow) );
3611                 le.SetEventObject(parent);
3612                 le.SetModel(GetOwner()->GetModel());
3613
3614                 parent->GetEventHandler()->ProcessEvent(le);
3615             }
3616             break;
3617         }
3618         case WXK_UP:
3619             if ( m_currentRow > 0 )
3620                 OnArrowChar( m_currentRow - 1, event );
3621             break;
3622
3623         case WXK_DOWN:
3624             if ( m_currentRow < GetRowCount() - 1 )
3625                 OnArrowChar( m_currentRow + 1, event );
3626             break;
3627         //Add the process for tree expanding/collapsing
3628         case WXK_LEFT:
3629          OnCollapsing(m_currentRow);
3630          break;
3631      case WXK_RIGHT:
3632          OnExpanding( m_currentRow);
3633          break;
3634         case WXK_END:
3635             if (!IsEmpty())
3636                 OnArrowChar( GetRowCount() - 1, event );
3637             break;
3638
3639         case WXK_HOME:
3640             if (!IsEmpty())
3641                 OnArrowChar( 0, event );
3642             break;
3643
3644         case WXK_PAGEUP:
3645             {
3646                 int steps = pageSize - 1;
3647                 int index = m_currentRow - steps;
3648                 if (index < 0)
3649                     index = 0;
3650
3651                 OnArrowChar( index, event );
3652             }
3653             break;
3654
3655         case WXK_PAGEDOWN:
3656             {
3657                 int steps = pageSize - 1;
3658                 unsigned int index = m_currentRow + steps;
3659                 unsigned int count = GetRowCount();
3660                 if ( index >= count )
3661                     index = count - 1;
3662
3663                 OnArrowChar( index, event );
3664             }
3665             break;
3666
3667         default:
3668             event.Skip();
3669     }
3670 }
3671
3672 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
3673 {
3674     if (event.GetEventType() == wxEVT_MOUSEWHEEL)
3675     {
3676         // let the base handle mouse wheel events.
3677         event.Skip();
3678         return;
3679     }
3680
3681     int x = event.GetX();
3682     int y = event.GetY();
3683     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
3684     wxDataViewColumn *col = NULL;
3685
3686     int xpos = 0;
3687     unsigned int cols = GetOwner()->GetColumnCount();
3688     unsigned int i;
3689     for (i = 0; i < cols; i++)
3690     {
3691         wxDataViewColumn *c = GetOwner()->GetColumn( i );
3692         if (c->IsHidden())
3693             continue;      // skip it!
3694
3695         if (x < xpos + c->GetWidth())
3696         {
3697             col = c;
3698             break;
3699         }
3700         xpos += c->GetWidth();
3701     }
3702     if (!col)
3703         return;
3704
3705     wxDataViewRenderer *cell = col->GetRenderer();
3706     unsigned int current = GetLineAt( y );
3707     if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
3708     {
3709         // Unselect all if below the last row ?
3710         return;
3711     }
3712
3713     //Test whether the mouse is hovered on the tree item button
3714     bool hover = false;
3715     if ((!IsVirtualList()) && (GetOwner()->GetExpanderColumn() == col))
3716     {
3717         wxDataViewTreeNode * node = GetTreeNodeByRow(current);
3718         if( node!=NULL && node->HasChildren() )
3719         {
3720             int indent = node->GetIndentLevel();
3721             indent = GetOwner()->GetIndent()*indent;
3722             wxRect rect( xpos + indent + EXPANDER_MARGIN,
3723                          GetLineStart( current ) + EXPANDER_MARGIN + (GetLineHeight(current)/2) - (m_lineHeight/2) - EXPANDER_OFFSET,
3724                          m_lineHeight-2*EXPANDER_MARGIN,
3725                          m_lineHeight-2*EXPANDER_MARGIN);
3726             if( rect.Contains( x, y) )
3727             {
3728                 //So the mouse is over the expander
3729                 hover = true;
3730                 if (m_underMouse && m_underMouse != node)
3731                 {
3732                     //wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3733                     RefreshRow(GetRowByItem(m_underMouse->GetItem()));
3734                 }
3735                 if (m_underMouse != node)
3736                 {
3737                     //wxLogMessage("Do the row: %d", current);
3738                     RefreshRow(current);
3739                 }
3740                 m_underMouse = node;
3741             }
3742         }
3743         if (node!=NULL && !node->HasChildren())
3744             delete node;
3745     }
3746     if (!hover)
3747     {
3748         if (m_underMouse != NULL)
3749         {
3750             //wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3751             RefreshRow(GetRowByItem(m_underMouse->GetItem()));
3752             m_underMouse = NULL;
3753         }
3754     }
3755
3756     wxDataViewModel *model = GetOwner()->GetModel();
3757
3758     if (event.Dragging())
3759     {
3760         if (m_dragCount == 0)
3761         {
3762             // we have to report the raw, physical coords as we want to be
3763             // able to call HitTest(event.m_pointDrag) from the user code to
3764             // get the item being dragged
3765             m_dragStart = event.GetPosition();
3766         }
3767
3768         m_dragCount++;
3769
3770         if (m_dragCount != 3)
3771             return;
3772
3773         if (event.LeftIsDown())
3774         {
3775             // Notify cell about drag
3776         }
3777         return;
3778     }
3779     else
3780     {
3781         m_dragCount = 0;
3782     }
3783
3784     bool forceClick = false;
3785
3786     if (event.ButtonDClick())
3787     {
3788         m_renameTimer->Stop();
3789         m_lastOnSame = false;
3790     }
3791
3792     wxDataViewItem item = GetItemByRow(current);
3793     bool ignore_other_columns =
3794         ((GetOwner()->GetExpanderColumn() != col) &&
3795          (model->IsContainer(item)) &&
3796          (!model->HasContainerColumns(item)));
3797
3798     if (event.LeftDClick())
3799     {
3800         if ( current == m_lineLastClicked )
3801         {
3802             if ((!ignore_other_columns) && (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE))
3803             {
3804                 wxVariant value;
3805                 model->GetValue( value, item, col->GetModelColumn() );
3806                 cell->SetValue( value );
3807                 wxRect cell_rect( xpos, GetLineStart( current ),
3808                                   col->GetWidth(), GetLineHeight( current ) );
3809                 cell->Activate( cell_rect, model, item, col->GetModelColumn() );
3810
3811             }
3812             else
3813             {
3814                 wxWindow *parent = GetParent();
3815                 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
3816                 le.SetItem( item );
3817                 le.SetEventObject(parent);
3818                 le.SetModel(GetOwner()->GetModel());
3819
3820                 parent->GetEventHandler()->ProcessEvent(le);
3821             }
3822             return;
3823         }
3824         else
3825         {
3826             // The first click was on another item, so don't interpret this as
3827             // a double click, but as a simple click instead
3828             forceClick = true;
3829         }
3830     }
3831
3832     if (event.LeftUp())
3833     {
3834         if (m_lineSelectSingleOnUp != (unsigned int)-1)
3835         {
3836             // select single line
3837             SelectAllRows( false );
3838             SelectRow( m_lineSelectSingleOnUp, true );
3839         }
3840
3841         //Process the event of user clicking the expander
3842         bool expander = false;
3843         if ((!IsVirtualList()) && (GetOwner()->GetExpanderColumn() == col))
3844         {
3845             wxDataViewTreeNode * node = GetTreeNodeByRow(current);
3846             if( node!=NULL && node->HasChildren() )
3847             {
3848                 int indent = node->GetIndentLevel();
3849                 indent = GetOwner()->GetIndent()*indent;
3850                 wxRect rect( xpos + indent + EXPANDER_MARGIN,
3851                          GetLineStart( current ) + EXPANDER_MARGIN + (GetLineHeight(current)/2) - (m_lineHeight/2) - EXPANDER_OFFSET,
3852                          m_lineHeight-2*EXPANDER_MARGIN,
3853                          m_lineHeight-2*EXPANDER_MARGIN);
3854
3855                 if( rect.Contains( x, y) )
3856                 {
3857                     expander = true;
3858                     if( node->IsOpen() )
3859                         OnCollapsing(current);
3860                     else
3861                         OnExpanding( current );
3862                 }
3863             }
3864             if (node && !node->HasChildren())
3865                delete node;
3866         }
3867         //If the user click the expander, we do not do editing even if the column with expander are editable
3868         if (m_lastOnSame && !expander && !ignore_other_columns)
3869         {
3870             if ((col == m_currentCol) && (current == m_currentRow) &&
3871                 (cell->GetMode() & wxDATAVIEW_CELL_EDITABLE) )
3872             {
3873                 m_renameTimer->Start( 100, true );
3874             }
3875         }
3876
3877         m_lastOnSame = false;
3878         m_lineSelectSingleOnUp = (unsigned int)-1;
3879     }
3880     else
3881     {
3882         // This is necessary, because after a DnD operation in
3883         // from and to ourself, the up event is swallowed by the
3884         // DnD code. So on next non-up event (which means here and
3885         // now) m_lineSelectSingleOnUp should be reset.
3886         m_lineSelectSingleOnUp = (unsigned int)-1;
3887     }
3888
3889     if (event.RightDown())
3890     {
3891         m_lineBeforeLastClicked = m_lineLastClicked;
3892         m_lineLastClicked = current;
3893
3894         // If the item is already selected, do not update the selection.
3895         // Multi-selections should not be cleared if a selected item is clicked.
3896         if (!IsRowSelected(current))
3897         {
3898             SelectAllRows(false);
3899             ChangeCurrentRow(current);
3900             SelectRow(m_currentRow,true);
3901             SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
3902         }
3903
3904         wxVariant value;
3905         model->GetValue( value, item, col->GetModelColumn() );
3906         wxWindow *parent = GetParent();
3907         wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId());
3908         le.SetItem( item );
3909         le.SetEventObject(parent);
3910         le.SetModel(GetOwner()->GetModel());
3911         le.SetValue(value);
3912         parent->GetEventHandler()->ProcessEvent(le);
3913     }
3914     else if (event.MiddleDown())
3915     {
3916     }
3917     if (event.LeftDown() || forceClick)
3918     {
3919         SetFocus();
3920
3921         m_lineBeforeLastClicked = m_lineLastClicked;
3922         m_lineLastClicked = current;
3923
3924         unsigned int oldCurrentRow = m_currentRow;
3925         bool oldWasSelected = IsRowSelected(m_currentRow);
3926
3927         bool cmdModifierDown = event.CmdDown();
3928         if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
3929         {
3930             if ( IsSingleSel() || !IsRowSelected(current) )
3931             {
3932                 SelectAllRows( false );
3933                 ChangeCurrentRow(current);
3934                 SelectRow(m_currentRow,true);
3935                 SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
3936             }
3937             else // multi sel & current is highlighted & no mod keys
3938             {
3939                 m_lineSelectSingleOnUp = current;
3940                 ChangeCurrentRow(current); // change focus
3941             }
3942         }
3943         else // multi sel & either ctrl or shift is down
3944         {
3945             if (cmdModifierDown)
3946             {
3947                 ChangeCurrentRow(current);
3948                 ReverseRowSelection(m_currentRow);
3949                 SendSelectionChangedEvent(GetItemByRow(m_selection[0]) );
3950             }
3951             else if (event.ShiftDown())
3952             {
3953                 ChangeCurrentRow(current);
3954
3955                 unsigned int lineFrom = oldCurrentRow,
3956                        lineTo = current;
3957
3958                 if ( lineTo < lineFrom )
3959                 {
3960                     lineTo = lineFrom;
3961                     lineFrom = m_currentRow;
3962                 }
3963
3964                 SelectRows(lineFrom, lineTo, true);
3965                 SendSelectionChangedEvent(GetItemByRow(m_selection[0]) );
3966             }
3967             else // !ctrl, !shift
3968             {
3969                 // test in the enclosing if should make it impossible
3970                 wxFAIL_MSG( _T("how did we get here?") );
3971             }
3972         }
3973
3974         if (m_currentRow != oldCurrentRow)
3975             RefreshRow( oldCurrentRow );
3976
3977         wxDataViewColumn *oldCurrentCol = m_currentCol;
3978
3979         // Update selection here...
3980         m_currentCol = col;
3981
3982         m_lastOnSame = !forceClick && ((col == oldCurrentCol) &&
3983                         (current == oldCurrentRow)) && oldWasSelected;
3984
3985         // Call LeftClick after everything else as under GTK+
3986         if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE)
3987         {
3988             // notify cell about right click
3989             wxVariant value;
3990             model->GetValue( value, item, col->GetModelColumn() );
3991             cell->SetValue( value );
3992             wxRect cell_rect( xpos, GetLineStart( current ),
3993                           col->GetWidth(), GetLineHeight( current ) );
3994             /* ignore ret */ cell->LeftClick( event.GetPosition(), cell_rect, model, item, col->GetModelColumn());
3995         }
3996     }
3997 }
3998
3999 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
4000 {
4001     m_hasFocus = true;
4002
4003     if (HasCurrentRow())
4004         Refresh();
4005
4006     event.Skip();
4007 }
4008
4009 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
4010 {
4011     m_hasFocus = false;
4012
4013     if (HasCurrentRow())
4014         Refresh();
4015
4016     event.Skip();
4017 }
4018
4019 wxDataViewItem wxDataViewMainWindow::GetSelection() const
4020 {
4021     if( m_selection.GetCount() != 1 )
4022         return wxDataViewItem();
4023
4024     return GetItemByRow( m_selection.Item(0));
4025 }
4026
4027 //-----------------------------------------------------------------------------
4028 // wxDataViewCtrl
4029 //-----------------------------------------------------------------------------
4030 WX_DEFINE_LIST(wxDataViewColumnList)
4031
4032 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
4033
4034 BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase)
4035     EVT_SIZE(wxDataViewCtrl::OnSize)
4036 END_EVENT_TABLE()
4037
4038 wxDataViewCtrl::~wxDataViewCtrl()
4039 {
4040     if (m_notifier)
4041         GetModel()->RemoveNotifier( m_notifier );
4042
4043     wxDataViewColumnList::const_iterator iter;
4044     for (iter = m_cols.begin(); iter!=m_cols.end(); iter++)
4045     {
4046         delete *iter;
4047     }
4048 }
4049
4050 void wxDataViewCtrl::Init()
4051 {
4052     m_notifier = NULL;
4053 }
4054
4055 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
4056            const wxPoint& pos, const wxSize& size,
4057            long style, const wxValidator& validator )
4058 {
4059     if ( (style & wxBORDER_MASK) == 0)
4060         style |= wxBORDER_SUNKEN;
4061
4062     if (!wxControl::Create( parent, id, pos, size,
4063                             style | wxScrolledWindowStyle, validator))
4064         return false;
4065
4066     SetInitialSize(size);
4067
4068     Init();
4069
4070 #ifdef __WXMAC__
4071     MacSetClipChildren( true ) ;
4072 #endif
4073
4074     m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
4075
4076     if (HasFlag(wxDV_NO_HEADER))
4077         m_headerArea = NULL;
4078     else
4079         m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY );
4080
4081     SetTargetWindow( m_clientArea );
4082
4083     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
4084     if (m_headerArea)
4085         sizer->Add( m_headerArea, 0, wxGROW );
4086     sizer->Add( m_clientArea, 1, wxGROW );
4087     SetSizer( sizer );
4088
4089     return true;
4090 }
4091
4092 #ifdef __WXMSW__
4093 WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
4094                                        WXWPARAM wParam,
4095                                        WXLPARAM lParam)
4096 {
4097     WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
4098
4099 #ifndef __WXWINCE__
4100     // we need to process arrows ourselves for scrolling
4101     if ( nMsg == WM_GETDLGCODE )
4102     {
4103         rc |= DLGC_WANTARROWS;
4104     }
4105 #endif
4106
4107     return rc;
4108 }
4109 #endif
4110
4111 void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
4112 {
4113     // We need to override OnSize so that our scrolled
4114     // window a) does call Layout() to use sizers for
4115     // positioning the controls but b) does not query
4116     // the sizer for their size and use that for setting
4117     // the scrollable area as set that ourselves by
4118     // calling SetScrollbar() further down.
4119
4120     Layout();
4121
4122     AdjustScrollbars();
4123 }
4124
4125 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
4126 {
4127     if (!wxDataViewCtrlBase::AssociateModel( model ))
4128         return false;
4129
4130     m_notifier = new wxGenericDataViewModelNotifier( m_clientArea );
4131
4132     model->AddNotifier( m_notifier );
4133
4134     m_clientArea->DestroyTree();
4135
4136     m_clientArea->BuildTree(model);
4137
4138     m_clientArea->UpdateDisplay();
4139
4140     return true;
4141 }
4142
4143 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
4144 {
4145     if (!wxDataViewCtrlBase::AppendColumn(col))
4146         return false;
4147
4148     m_cols.Append( col );
4149     OnColumnChange();
4150     return true;
4151 }
4152
4153 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
4154 {
4155     if (!wxDataViewCtrlBase::PrependColumn(col))
4156         return false;
4157
4158     m_cols.Insert( col );
4159     OnColumnChange();
4160     return true;
4161 }
4162
4163 void wxDataViewCtrl::OnColumnChange()
4164 {
4165     if (m_headerArea)
4166         m_headerArea->UpdateDisplay();
4167
4168     m_clientArea->UpdateDisplay();
4169 }
4170
4171 void wxDataViewCtrl::DoSetExpanderColumn()
4172 {
4173     m_clientArea->UpdateDisplay();
4174 }
4175
4176 void wxDataViewCtrl::DoSetIndent()
4177 {
4178     m_clientArea->UpdateDisplay();
4179 }
4180
4181 unsigned int wxDataViewCtrl::GetColumnCount() const
4182 {
4183     return m_cols.GetCount();
4184 }
4185
4186 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int pos ) const
4187 {
4188     wxDataViewColumnList::const_iterator iter;
4189     unsigned int i = 0;
4190     for (iter = m_cols.begin(); iter!=m_cols.end(); iter++)
4191     {
4192         if (i == pos)
4193             return *iter;
4194
4195         if ((*iter)->IsHidden())
4196             continue;
4197         i ++;
4198     }
4199     return NULL;
4200 }
4201
4202 void wxDataViewCtrl::ColumnMoved( wxDataViewColumn* col, unsigned int new_pos )
4203 {
4204     if (new_pos > m_cols.GetCount()) return;
4205     m_cols.DeleteObject( col );
4206     m_cols.Insert( new_pos, col );
4207
4208     m_clientArea->UpdateDisplay();
4209 }
4210
4211 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
4212 {
4213     wxDataViewColumnList::compatibility_iterator  ret = m_cols.Find( column );
4214     if (!ret)
4215         return false;
4216
4217     m_cols.Erase(ret);
4218     delete column;
4219     OnColumnChange();
4220
4221     return true;
4222 }
4223
4224 bool wxDataViewCtrl::ClearColumns()
4225 {
4226     m_cols.clear();
4227     OnColumnChange();
4228     return true;
4229 }
4230
4231 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
4232 {
4233     int ret = 0, dead = 0;
4234     int len = GetColumnCount();
4235     for (int i=0; i<len; i++)
4236     {
4237         wxDataViewColumn * col = GetColumn(i);
4238         if (col->IsHidden())
4239             continue;
4240         ret += col->GetWidth();
4241         if (column==col)
4242         {
4243             CalcScrolledPosition( ret, dead, &ret, &dead );
4244             break;
4245         }
4246     }
4247     return ret;
4248 }
4249
4250 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
4251 {
4252     return NULL;
4253 }
4254
4255 //Selection code with wxDataViewItem as parameters
4256 wxDataViewItem wxDataViewCtrl::GetSelection() const
4257 {
4258     return m_clientArea->GetSelection();
4259 }
4260
4261 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
4262 {
4263     sel.Empty();
4264     wxDataViewSelection selection = m_clientArea->GetSelections();
4265     int len = selection.GetCount();
4266     for( int i = 0; i < len; i ++)
4267     {
4268         unsigned int row = selection[i];
4269         sel.Add( m_clientArea->GetItemByRow( row ) );
4270     }
4271     return len;
4272 }
4273
4274 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
4275 {
4276     wxDataViewSelection selection(wxDataViewSelectionCmp) ;
4277     int len = sel.GetCount();
4278     for( int i = 0; i < len; i ++ )
4279     {
4280         int row = m_clientArea->GetRowByItem( sel[i] );
4281         if( row >= 0 )
4282             selection.Add( static_cast<unsigned int>(row) );
4283     }
4284     m_clientArea->SetSelections( selection );
4285 }
4286
4287 void wxDataViewCtrl::Select( const wxDataViewItem & item )
4288 {
4289     int row = m_clientArea->GetRowByItem( item );
4290     if( row >= 0 )
4291     {
4292         //Unselect all rows before select another in the single select mode
4293         if (m_clientArea->IsSingleSel())
4294             m_clientArea->SelectAllRows(false);
4295         m_clientArea->SelectRow(row, true);
4296     }
4297 }
4298
4299 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
4300 {
4301     int row = m_clientArea->GetRowByItem( item );
4302     if( row >= 0 )
4303         m_clientArea->SelectRow(row, false);
4304 }
4305
4306 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
4307 {
4308     int row = m_clientArea->GetRowByItem( item );
4309     if( row >= 0 )
4310     {
4311         return m_clientArea->IsRowSelected(row);
4312     }
4313     return false;
4314 }
4315
4316 //Selection code with row number as parameter
4317 int wxDataViewCtrl::GetSelections( wxArrayInt & sel ) const
4318 {
4319     sel.Empty();
4320     wxDataViewSelection selection = m_clientArea->GetSelections();
4321     int len = selection.GetCount();
4322     for( int i = 0; i < len; i ++)
4323     {
4324         unsigned int row = selection[i];
4325         sel.Add( row );
4326     }
4327     return len;
4328 }
4329
4330 void wxDataViewCtrl::SetSelections( const wxArrayInt & sel )
4331 {
4332     wxDataViewSelection selection(wxDataViewSelectionCmp) ;
4333     int len = sel.GetCount();
4334     for( int i = 0; i < len; i ++ )
4335     {
4336         int row = sel[i];
4337         if( row >= 0 )
4338             selection.Add( static_cast<unsigned int>(row) );
4339     }
4340     m_clientArea->SetSelections( selection );
4341 }
4342
4343 void wxDataViewCtrl::Select( int row )
4344 {
4345     if( row >= 0 )
4346     {
4347         if (m_clientArea->IsSingleSel())
4348             m_clientArea->SelectAllRows(false);
4349         m_clientArea->SelectRow( row, true );
4350     }
4351 }
4352
4353 void wxDataViewCtrl::Unselect( int row )
4354 {
4355     if( row >= 0 )
4356         m_clientArea->SelectRow(row, false);
4357 }
4358
4359 bool wxDataViewCtrl::IsSelected( int row ) const
4360 {
4361     if( row >= 0 )
4362         return m_clientArea->IsRowSelected(row);
4363     return false;
4364 }
4365
4366 void wxDataViewCtrl::SelectRange( int from, int to )
4367 {
4368     wxArrayInt sel;
4369     for( int i = from; i < to; i ++ )
4370         sel.Add( i );
4371     m_clientArea->Select(sel);
4372 }
4373
4374 void wxDataViewCtrl::UnselectRange( int from, int to )
4375 {
4376     wxDataViewSelection sel = m_clientArea->GetSelections();
4377     for( int i = from; i < to; i ++ )
4378         if( sel.Index( i ) != wxNOT_FOUND )
4379             sel.Remove( i );
4380     m_clientArea->SetSelections(sel);
4381 }
4382
4383 void wxDataViewCtrl::SelectAll()
4384 {
4385     m_clientArea->SelectAllRows(true);
4386 }
4387
4388 void wxDataViewCtrl::UnselectAll()
4389 {
4390     m_clientArea->SelectAllRows(false);
4391 }
4392
4393 void wxDataViewCtrl::EnsureVisible( int row, int column )
4394 {
4395     if( row < 0 )
4396         row = 0;
4397     if( row > (int) m_clientArea->GetRowCount() )
4398         row = m_clientArea->GetRowCount();
4399
4400     int first = m_clientArea->GetFirstVisibleRow();
4401     int last = m_clientArea->GetLastVisibleRow();
4402     if( row < first )
4403         m_clientArea->ScrollTo( row, column );
4404     else if( row > last )
4405         m_clientArea->ScrollTo( row - last + first, column );
4406     else
4407         m_clientArea->ScrollTo( first, column );
4408 }
4409
4410 void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, const wxDataViewColumn * column )
4411 {
4412     int row = m_clientArea->GetRowByItem(item);
4413     if( row >= 0 )
4414     {
4415         if( column == NULL )
4416             EnsureVisible(row, -1);
4417         else
4418         {
4419             int col = 0;
4420             int len = GetColumnCount();
4421             for( int i = 0; i < len; i ++ )
4422                 if( GetColumn(i) == column )
4423                 {
4424                     col = i;
4425                     break;
4426                 }
4427             EnsureVisible( row, col );
4428         }
4429     }
4430
4431 }
4432
4433 void wxDataViewCtrl::HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column ) const
4434 {
4435     m_clientArea->HitTest(point, item, column);
4436 }
4437
4438 wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column ) const
4439 {
4440     return m_clientArea->GetItemRect(item, column);
4441 }
4442
4443 wxDataViewItem wxDataViewCtrl::GetItemByRow( unsigned int row ) const
4444 {
4445     return m_clientArea->GetItemByRow( row );
4446 }
4447
4448 int wxDataViewCtrl::GetRowByItem( const wxDataViewItem & item ) const
4449 {
4450     return m_clientArea->GetRowByItem( item );
4451 }
4452
4453 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
4454 {
4455     int row = m_clientArea->GetRowByItem( item );
4456     if (row != -1)
4457         m_clientArea->Expand(row);
4458 }
4459
4460 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
4461 {
4462     int row = m_clientArea->GetRowByItem( item );
4463     if (row != -1)
4464         m_clientArea->Collapse(row);
4465 }
4466
4467  #endif
4468     // !wxUSE_GENERICDATAVIEWCTRL
4469
4470 #endif
4471     // wxUSE_DATAVIEWCTRL