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