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