src/generic/datavgen.cpp

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