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