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