src/generic/datavgen.cpp

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