src/common/datavcmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/datavcmn.cpp
   3 // Purpose:     wxDataViewCtrl base classes and common parts
   4 // Author:      Robert Roebling
   5 // Created:     2006/02/20
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006, 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 #ifndef WX_PRECOMP
  23     #include "wx/dc.h"
  24     #include "wx/settings.h"
  25     #include "wx/log.h"
  26     #include "wx/crt.h"
  27 #endif
  28
  29 #include "wx/spinctrl.h"
  30 #include "wx/choice.h"
  31 #include "wx/imaglist.h"
  32
  33 const char wxDataViewCtrlNameStr[] = "dataviewCtrl";
  34
  35 // ---------------------------------------------------------
  36 // wxDataViewModelNotifier
  37 // ---------------------------------------------------------
  38
  39 #include "wx/listimpl.cpp"
  40 WX_DEFINE_LIST(wxDataViewModelNotifiers)
  41
  42 bool wxDataViewModelNotifier::ItemsAdded( const wxDataViewItem &parent, const wxDataViewItemArray &items )
  43 {
  44     size_t count = items.GetCount();
  45     size_t i;
  46     for (i = 0; i < count; i++)
  47         if (!ItemAdded( parent, items[i] )) return false;
  48
  49     return true;
  50 }
  51
  52 bool wxDataViewModelNotifier::ItemsDeleted( const wxDataViewItem &parent, const wxDataViewItemArray &items )
  53 {
  54     size_t count = items.GetCount();
  55     size_t i;
  56     for (i = 0; i < count; i++)
  57         if (!ItemDeleted( parent, items[i] )) return false;
  58
  59     return true;
  60 }
  61
  62 bool wxDataViewModelNotifier::ItemsChanged( const wxDataViewItemArray &items )
  63 {
  64     size_t count = items.GetCount();
  65     size_t i;
  66     for (i = 0; i < count; i++)
  67         if (!ItemChanged( items[i] )) return false;
  68
  69     return true;
  70 }
  71
  72 // ---------------------------------------------------------
  73 // wxDataViewModel
  74 // ---------------------------------------------------------
  75
  76 wxDataViewModel::wxDataViewModel()
  77 {
  78     m_notifiers.DeleteContents( true );
  79 }
  80
  81 bool wxDataViewModel::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
  82 {
  83     bool ret = true;
  84
  85     wxDataViewModelNotifiers::iterator iter;
  86     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
  87     {
  88         wxDataViewModelNotifier* notifier = *iter;
  89         if (!notifier->ItemAdded( parent, item ))
  90             ret = false;
  91     }
  92
  93     return ret;
  94 }
  95
  96 bool wxDataViewModel::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
  97 {
  98     bool ret = true;
  99
 100     wxDataViewModelNotifiers::iterator iter;
 101     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 102     {
 103         wxDataViewModelNotifier* notifier = *iter;
 104         if (!notifier->ItemDeleted( parent, item ))
 105             ret = false;
 106     }
 107
 108     return ret;
 109 }
 110
 111 bool wxDataViewModel::ItemChanged( const wxDataViewItem &item )
 112 {
 113     bool ret = true;
 114
 115     wxDataViewModelNotifiers::iterator iter;
 116     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 117     {
 118         wxDataViewModelNotifier* notifier = *iter;
 119         if (!notifier->ItemChanged( item ))
 120             ret = false;
 121     }
 122
 123     return ret;
 124 }
 125
 126 bool wxDataViewModel::ItemsAdded( const wxDataViewItem &parent, const wxDataViewItemArray &items )
 127 {
 128     bool ret = true;
 129
 130     wxDataViewModelNotifiers::iterator iter;
 131     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 132     {
 133         wxDataViewModelNotifier* notifier = *iter;
 134         if (!notifier->ItemsAdded( parent, items ))
 135             ret = false;
 136     }
 137
 138     return ret;
 139 }
 140
 141 bool wxDataViewModel::ItemsDeleted( const wxDataViewItem &parent, const wxDataViewItemArray &items )
 142 {
 143     bool ret = true;
 144
 145     wxDataViewModelNotifiers::iterator iter;
 146     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 147     {
 148         wxDataViewModelNotifier* notifier = *iter;
 149         if (!notifier->ItemsDeleted( parent, items ))
 150             ret = false;
 151     }
 152
 153     return ret;
 154 }
 155
 156 bool wxDataViewModel::ItemsChanged( const wxDataViewItemArray &items )
 157 {
 158     bool ret = true;
 159
 160     wxDataViewModelNotifiers::iterator iter;
 161     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 162     {
 163         wxDataViewModelNotifier* notifier = *iter;
 164         if (!notifier->ItemsChanged( items ))
 165             ret = false;
 166     }
 167
 168     return ret;
 169 }
 170
 171 bool wxDataViewModel::ValueChanged( const wxDataViewItem &item, unsigned int col )
 172 {
 173     bool ret = true;
 174
 175     wxDataViewModelNotifiers::iterator iter;
 176     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 177     {
 178         wxDataViewModelNotifier* notifier = *iter;
 179         if (!notifier->ValueChanged( item, col ))
 180             ret = false;
 181     }
 182
 183     return ret;
 184 }
 185
 186 bool wxDataViewModel::Cleared()
 187 {
 188     bool ret = true;
 189
 190     wxDataViewModelNotifiers::iterator iter;
 191     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 192     {
 193         wxDataViewModelNotifier* notifier = *iter;
 194         if (!notifier->Cleared())
 195             ret = false;
 196     }
 197
 198     return ret;
 199 }
 200
 201 void wxDataViewModel::Resort()
 202 {
 203     wxDataViewModelNotifiers::iterator iter;
 204     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 205     {
 206         wxDataViewModelNotifier* notifier = *iter;
 207         notifier->Resort();
 208     }
 209 }
 210
 211 void wxDataViewModel::AddNotifier( wxDataViewModelNotifier *notifier )
 212 {
 213     m_notifiers.push_back( notifier );
 214     notifier->SetOwner( this );
 215 }
 216
 217 void wxDataViewModel::RemoveNotifier( wxDataViewModelNotifier *notifier )
 218 {
 219     m_notifiers.DeleteObject( notifier );
 220 }
 221
 222 int wxDataViewModel::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
 223                               unsigned int column, bool ascending ) const
 224 {
 225     // sort branches before leaves
 226     bool item1_is_container = IsContainer(item1);
 227     bool item2_is_container = IsContainer(item2);
 228
 229     if (item1_is_container && !item2_is_container)
 230         return 1;
 231     if (item2_is_container && !item1_is_container)
 232         return -1;
 233
 234     wxVariant value1,value2;
 235     GetValue( value1, item1, column );
 236     GetValue( value2, item2, column );
 237
 238     if (!ascending)
 239     {
 240         wxVariant temp = value1;
 241         value1 = value2;
 242         value2 = temp;
 243     }
 244
 245     if (value1.GetType() == wxT("string"))
 246     {
 247         wxString str1 = value1.GetString();
 248         wxString str2 = value2.GetString();
 249         int res = str1.Cmp( str2 );
 250         if (res)
 251             return res;
 252     }
 253     else if (value1.GetType() == wxT("long"))
 254     {
 255         long l1 = value1.GetLong();
 256         long l2 = value2.GetLong();
 257         long res = l1-l2;
 258         if (res)
 259             return res;
 260     }
 261     else if (value1.GetType() == wxT("double"))
 262     {
 263         double d1 = value1.GetDouble();
 264         double d2 = value2.GetDouble();
 265         if (d1 < d2)
 266             return 1;
 267         if (d1 > d2)
 268             return -1;
 269     }
 270     else if (value1.GetType() == wxT("datetime"))
 271     {
 272         wxDateTime dt1 = value1.GetDateTime();
 273         wxDateTime dt2 = value2.GetDateTime();
 274         if (dt1.IsEarlierThan(dt2))
 275             return 1;
 276         if (dt2.IsEarlierThan(dt1))
 277             return -11;
 278     }
 279
 280     // items must be different
 281     wxUIntPtr id1 = wxPtrToUInt(item1.GetID()),
 282               id2 = wxPtrToUInt(item2.GetID());
 283
 284     return ascending ? id1 - id2 : id2 - id1;
 285 }
 286
 287 // ---------------------------------------------------------
 288 // wxDataViewIndexListModel
 289 // ---------------------------------------------------------
 290
 291 static int my_sort( int *v1, int *v2 )
 292 {
 293    return *v2-*v1;
 294 }
 295
 296
 297 wxDataViewIndexListModel::wxDataViewIndexListModel( unsigned int initial_size )
 298 {
 299     // IDs are ordered until an item gets deleted or inserted
 300     m_ordered = true;
 301
 302     // build initial index
 303     unsigned int i;
 304     for (i = 1; i < initial_size+1; i++)
 305             m_hash.Add( wxUIntToPtr(i) );
 306     m_nextFreeID = initial_size + 1;
 307 }
 308
 309 wxDataViewIndexListModel::~wxDataViewIndexListModel()
 310 {
 311 }
 312
 313 void wxDataViewIndexListModel::Reset( unsigned int new_size )
 314 {
 315     m_hash.Clear();
 316
 317     // IDs are ordered until an item gets deleted or inserted
 318     m_ordered = true;
 319
 320     // build initial index
 321     unsigned int i;
 322     for (i = 1; i < new_size+1; i++)
 323             m_hash.Add( wxUIntToPtr(i) );
 324
 325     m_nextFreeID = new_size + 1;
 326
 327     wxDataViewModel::Cleared();
 328 }
 329
 330 void wxDataViewIndexListModel::RowPrepended()
 331 {
 332     m_ordered = false;
 333
 334     unsigned int id = m_nextFreeID;
 335     m_nextFreeID++;
 336
 337     m_hash.Insert( wxUIntToPtr(id), 0 );
 338     wxDataViewItem item( wxUIntToPtr(id) );
 339     ItemAdded( wxDataViewItem(0), item );
 340
 341 }
 342
 343 void wxDataViewIndexListModel::RowInserted( unsigned int before )
 344 {
 345     m_ordered = false;
 346
 347     unsigned int id = m_nextFreeID;
 348     m_nextFreeID++;
 349
 350     m_hash.Insert( wxUIntToPtr(id), before );
 351     wxDataViewItem item( wxUIntToPtr(id) );
 352     ItemAdded( wxDataViewItem(0), item );
 353 }
 354
 355 void wxDataViewIndexListModel::RowAppended()
 356 {
 357     unsigned int id = m_nextFreeID;
 358     m_nextFreeID++;
 359
 360     m_hash.Add( wxUIntToPtr(id) );
 361     wxDataViewItem item( wxUIntToPtr(id) );
 362     ItemAdded( wxDataViewItem(0), item );
 363 }
 364
 365 void wxDataViewIndexListModel::RowDeleted( unsigned int row )
 366 {
 367     m_ordered = false;
 368
 369     wxDataViewItem item( m_hash[row] );
 370     wxDataViewModel::ItemDeleted( wxDataViewItem(0), item );
 371     m_hash.RemoveAt( row );
 372 }
 373
 374 void wxDataViewIndexListModel::RowsDeleted( const wxArrayInt &rows )
 375 {
 376     wxArrayInt sorted = rows;
 377     sorted.Sort( my_sort );
 378
 379     m_ordered = false;
 380
 381     wxDataViewItemArray array;
 382     unsigned int i;
 383     for (i = 0; i < rows.GetCount(); i++)
 384     {
 385             wxDataViewItem item( m_hash[rows[i]] );
 386             array.Add( item );
 387     }
 388     wxDataViewModel::ItemsDeleted( wxDataViewItem(0), array );
 389
 390     for (i = 0; i < sorted.GetCount(); i++)
 391            m_hash.RemoveAt( sorted[i] );
 392 }
 393
 394 void wxDataViewIndexListModel::RowChanged( unsigned int row )
 395 {
 396     wxDataViewModel::ItemChanged( GetItem(row) );
 397 }
 398
 399 void wxDataViewIndexListModel::RowValueChanged( unsigned int row, unsigned int col )
 400 {
 401     wxDataViewModel::ValueChanged( GetItem(row), col );
 402 }
 403
 404 unsigned int wxDataViewIndexListModel::GetRow( const wxDataViewItem &item ) const
 405 {
 406     if (m_ordered)
 407         return wxPtrToUInt(item.GetID())-1;
 408
 409     // assert for not found
 410     return (unsigned int) m_hash.Index( item.GetID() );
 411 }
 412
 413 wxDataViewItem wxDataViewIndexListModel::GetItem( unsigned int row ) const
 414 {
 415     wxASSERT( row < m_hash.GetCount() );
 416     return wxDataViewItem( m_hash[row] );
 417 }
 418
 419 bool wxDataViewIndexListModel::HasDefaultCompare() const
 420 {
 421     return !m_ordered;
 422 }
 423
 424 int wxDataViewIndexListModel::Compare(const wxDataViewItem& item1,
 425                                       const wxDataViewItem& item2,
 426                                       unsigned int WXUNUSED(column),
 427                                       bool ascending) const
 428 {
 429     if (m_ordered)
 430     {
 431         unsigned int pos1 = wxPtrToUInt(item1.GetID());  // -1 not needed here
 432         unsigned int pos2 = wxPtrToUInt(item2.GetID());  // -1 not needed here
 433
 434         if (ascending)
 435             return pos1 - pos2;
 436         else
 437             return pos2 - pos1;
 438     }
 439
 440     if (ascending)
 441         return GetRow(item1) - GetRow(item2);
 442
 443     return GetRow(item2) - GetRow(item1);
 444 }
 445
 446 void wxDataViewIndexListModel::GetValue( wxVariant &variant,
 447                            const wxDataViewItem &item, unsigned int col ) const
 448 {
 449     GetValueByRow( variant, GetRow(item), col );
 450 }
 451
 452 bool wxDataViewIndexListModel::SetValue( const wxVariant &variant,
 453                            const wxDataViewItem &item, unsigned int col )
 454 {
 455     return SetValueByRow( variant, GetRow(item), col );
 456 }
 457
 458 bool wxDataViewIndexListModel::GetAttr( const wxDataViewItem &item, unsigned int col, wxDataViewItemAttr &attr )
 459 {
 460     return GetAttrByRow( GetRow(item), col, attr );
 461 }
 462
 463 wxDataViewItem wxDataViewIndexListModel::GetParent( const wxDataViewItem & WXUNUSED(item) ) const
 464 {
 465     return wxDataViewItem(0);
 466 }
 467
 468 bool wxDataViewIndexListModel::IsContainer( const wxDataViewItem &item ) const
 469 {
 470     // only the invisible root item has children
 471     if (!item.IsOk())
 472         return true;
 473
 474     return false;
 475 }
 476
 477 unsigned int wxDataViewIndexListModel::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
 478 {
 479     if (item.IsOk())
 480         return 0;
 481
 482     children = m_hash;
 483
 484     return m_hash.GetCount();
 485 }
 486
 487 // ---------------------------------------------------------
 488 // wxDataViewVirtualListModel
 489 // ---------------------------------------------------------
 490
 491 #ifndef __WXMAC__
 492
 493 wxDataViewVirtualListModel::wxDataViewVirtualListModel( unsigned int initial_size )
 494 {
 495     m_size = initial_size;
 496 }
 497
 498 wxDataViewVirtualListModel::~wxDataViewVirtualListModel()
 499 {
 500 }
 501
 502 void wxDataViewVirtualListModel::Reset( unsigned int new_size )
 503 {
 504     m_size = new_size;
 505
 506     wxDataViewModel::Cleared();
 507 }
 508
 509 void wxDataViewVirtualListModel::RowPrepended()
 510 {
 511     m_size++;
 512     wxDataViewItem item( wxUIntToPtr(1) );
 513     ItemAdded( wxDataViewItem(0), item );
 514 }
 515
 516 void wxDataViewVirtualListModel::RowInserted( unsigned int before )
 517 {
 518     m_size++;
 519     wxDataViewItem item( wxUIntToPtr(before+1) );
 520     ItemAdded( wxDataViewItem(0), item );
 521 }
 522
 523 void wxDataViewVirtualListModel::RowAppended()
 524 {
 525     m_size++;
 526     wxDataViewItem item( wxUIntToPtr(m_size) );
 527     ItemAdded( wxDataViewItem(0), item );
 528 }
 529
 530 void wxDataViewVirtualListModel::RowDeleted( unsigned int row )
 531 {
 532     m_size--;
 533     wxDataViewItem item( wxUIntToPtr(row+1) );
 534     wxDataViewModel::ItemDeleted( wxDataViewItem(0), item );
 535 }
 536
 537 void wxDataViewVirtualListModel::RowsDeleted( const wxArrayInt &rows )
 538 {
 539     m_size -= rows.GetCount();
 540
 541     wxArrayInt sorted = rows;
 542     sorted.Sort( my_sort );
 543
 544     wxDataViewItemArray array;
 545     unsigned int i;
 546     for (i = 0; i < sorted.GetCount(); i++)
 547     {
 548             wxDataViewItem item( wxUIntToPtr(sorted[i]+1) );
 549             array.Add( item );
 550     }
 551     wxDataViewModel::ItemsDeleted( wxDataViewItem(0), array );
 552 }
 553
 554 void wxDataViewVirtualListModel::RowChanged( unsigned int row )
 555 {
 556     wxDataViewModel::ItemChanged( GetItem(row) );
 557 }
 558
 559 void wxDataViewVirtualListModel::RowValueChanged( unsigned int row, unsigned int col )
 560 {
 561     wxDataViewModel::ValueChanged( GetItem(row), col );
 562 }
 563
 564 unsigned int wxDataViewVirtualListModel::GetRow( const wxDataViewItem &item ) const
 565 {
 566     return wxPtrToUInt( item.GetID() ) -1;
 567 }
 568
 569 wxDataViewItem wxDataViewVirtualListModel::GetItem( unsigned int row ) const
 570 {
 571     return wxDataViewItem( wxUIntToPtr(row+1) );
 572 }
 573
 574 bool wxDataViewVirtualListModel::HasDefaultCompare() const
 575 {
 576     return true;
 577 }
 578
 579 int wxDataViewVirtualListModel::Compare(const wxDataViewItem& item1,
 580                                       const wxDataViewItem& item2,
 581                                       unsigned int WXUNUSED(column),
 582                                       bool ascending) const
 583 {
 584     unsigned int pos1 = wxPtrToUInt(item1.GetID());  // -1 not needed here
 585     unsigned int pos2 = wxPtrToUInt(item2.GetID());  // -1 not needed here
 586
 587     if (ascending)
 588        return pos1 - pos2;
 589     else
 590        return pos2 - pos1;
 591 }
 592
 593 void wxDataViewVirtualListModel::GetValue( wxVariant &variant,
 594                            const wxDataViewItem &item, unsigned int col ) const
 595 {
 596     GetValueByRow( variant, GetRow(item), col );
 597 }
 598
 599 bool wxDataViewVirtualListModel::SetValue( const wxVariant &variant,
 600                            const wxDataViewItem &item, unsigned int col )
 601 {
 602     return SetValueByRow( variant, GetRow(item), col );
 603 }
 604
 605 bool wxDataViewVirtualListModel::GetAttr( const wxDataViewItem &item, unsigned int col, wxDataViewItemAttr &attr )
 606 {
 607     return GetAttrByRow( GetRow(item), col, attr );
 608 }
 609
 610 wxDataViewItem wxDataViewVirtualListModel::GetParent( const wxDataViewItem & WXUNUSED(item) ) const
 611 {
 612     return wxDataViewItem(0);
 613 }
 614
 615 bool wxDataViewVirtualListModel::IsContainer( const wxDataViewItem &item ) const
 616 {
 617     // only the invisible root item has children
 618     if (!item.IsOk())
 619         return true;
 620
 621     return false;
 622 }
 623
 624 unsigned int wxDataViewVirtualListModel::GetChildren( const wxDataViewItem &WXUNUSED(item), wxDataViewItemArray &WXUNUSED(children) ) const
 625 {
 626     return 0;  // should we report an error ?
 627 }
 628
 629 #endif  // __WXMAC__
 630
 631 //-----------------------------------------------------------------------------
 632 // wxDataViewIconText
 633 //-----------------------------------------------------------------------------
 634
 635 IMPLEMENT_DYNAMIC_CLASS(wxDataViewIconText,wxObject)
 636
 637 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
 638
 639 // ---------------------------------------------------------
 640 // wxDataViewRendererBase
 641 // ---------------------------------------------------------
 642
 643 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRendererBase, wxObject)
 644
 645 wxDataViewRendererBase::wxDataViewRendererBase( const wxString &varianttype,
 646                                                 wxDataViewCellMode WXUNUSED(mode),
 647                                                 int WXUNUSED(align) )
 648 {
 649     m_variantType = varianttype;
 650     m_owner = NULL;
 651 }
 652
 653 wxDataViewRendererBase::~wxDataViewRendererBase()
 654 {
 655 }
 656
 657 const wxDataViewCtrl* wxDataViewRendererBase::GetView() const
 658 {
 659     return const_cast<wxDataViewRendererBase*>(this)->GetOwner()->GetOwner();
 660 }
 661
 662 class wxKillRef: public wxWindowRef
 663 {
 664 public:
 665    wxKillRef( wxWindow *win ) : wxWindowRef( win ) { }
 666    virtual void OnObjectDestroy()
 667    {
 668       get()->PopEventHandler( true );
 669       m_pobj = NULL;
 670       delete this;
 671    }
 672 };
 673
 674 bool wxDataViewRendererBase::StartEditing( const wxDataViewItem &item, wxRect labelRect )
 675 {
 676     wxDataViewCtrl* dv_ctrl = GetOwner()->GetOwner();
 677
 678     // Before doing anything we send an event asking if editing of this item is really wanted.
 679     wxDataViewEvent start_event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, dv_ctrl->GetId() );
 680     start_event.SetDataViewColumn( GetOwner() );
 681     start_event.SetModel( dv_ctrl->GetModel() );
 682     start_event.SetItem( item );
 683     start_event.SetEventObject( dv_ctrl );
 684     dv_ctrl->GetEventHandler()->ProcessEvent( start_event );
 685     if( !start_event.IsAllowed() )
 686         return false;
 687
 688     m_item = item; // remember for later
 689
 690     unsigned int col = GetOwner()->GetModelColumn();
 691     wxVariant value;
 692     dv_ctrl->GetModel()->GetValue( value, item, col );
 693
 694     m_editorCtrl = CreateEditorCtrl( dv_ctrl->GetMainWindow(), labelRect, value );
 695
 696     // there might be no editor control for the given item
 697     if(!m_editorCtrl)
 698         return false;
 699
 700     (void) new wxKillRef( m_editorCtrl.get() );
 701
 702     wxDataViewEditorCtrlEvtHandler *handler =
 703         new wxDataViewEditorCtrlEvtHandler( m_editorCtrl, (wxDataViewRenderer*) this );
 704
 705     m_editorCtrl->PushEventHandler( handler );
 706
 707 #if defined(__WXGTK20__) && !defined(wxUSE_GENERICDATAVIEWCTRL)
 708     handler->SetFocusOnIdle();
 709 #else
 710     m_editorCtrl->SetFocus();
 711 #endif
 712
 713     // Now we should send Editing Started event
 714     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv_ctrl->GetId() );
 715     event.SetDataViewColumn( GetOwner() );
 716     event.SetModel( dv_ctrl->GetModel() );
 717     event.SetItem( item );
 718     event.SetEventObject( dv_ctrl );
 719     dv_ctrl->GetEventHandler()->ProcessEvent( event );
 720
 721     return true;
 722 }
 723
 724 void wxDataViewRendererBase::CancelEditing()
 725 {
 726     if (!m_editorCtrl)
 727         return;
 728
 729     GetOwner()->GetOwner()->GetMainWindow()->SetFocus();
 730
 731     m_editorCtrl->Hide();
 732     wxPendingDelete.Append( m_editorCtrl );
 733 }
 734
 735 bool wxDataViewRendererBase::FinishEditing()
 736 {
 737     if (!m_editorCtrl)
 738         return true;
 739
 740     wxVariant value;
 741     GetValueFromEditorCtrl( m_editorCtrl, value );
 742
 743     wxDataViewCtrl* dv_ctrl = GetOwner()->GetOwner();
 744
 745     dv_ctrl->GetMainWindow()->SetFocus();
 746
 747     m_editorCtrl->Hide();
 748     wxPendingDelete.Append( m_editorCtrl );
 749
 750     if (!Validate(value))
 751         return false;
 752
 753     unsigned int col = GetOwner()->GetModelColumn();
 754     dv_ctrl->GetModel()->SetValue( value, m_item, col );
 755     dv_ctrl->GetModel()->ValueChanged( m_item, col );
 756
 757     // Now we should send Editing Done event
 758     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv_ctrl->GetId() );
 759     event.SetDataViewColumn( GetOwner() );
 760     event.SetModel( dv_ctrl->GetModel() );
 761     event.SetItem( m_item );
 762     event.SetEventObject( dv_ctrl );
 763     dv_ctrl->GetEventHandler()->ProcessEvent( event );
 764
 765     return true;
 766 }
 767
 768 //-----------------------------------------------------------------------------
 769 // wxDataViewEditorCtrlEvtHandler
 770 //-----------------------------------------------------------------------------
 771
 772 BEGIN_EVENT_TABLE(wxDataViewEditorCtrlEvtHandler, wxEvtHandler)
 773     EVT_CHAR           (wxDataViewEditorCtrlEvtHandler::OnChar)
 774     EVT_KILL_FOCUS     (wxDataViewEditorCtrlEvtHandler::OnKillFocus)
 775     EVT_IDLE           (wxDataViewEditorCtrlEvtHandler::OnIdle)
 776     EVT_TEXT_ENTER     (-1, wxDataViewEditorCtrlEvtHandler::OnTextEnter)
 777 END_EVENT_TABLE()
 778
 779 wxDataViewEditorCtrlEvtHandler::wxDataViewEditorCtrlEvtHandler(
 780                                 wxControl *editorCtrl,
 781                                 wxDataViewRenderer *owner )
 782 {
 783     m_owner = owner;
 784     m_editorCtrl = editorCtrl;
 785
 786     m_finished = false;
 787 }
 788
 789 void wxDataViewEditorCtrlEvtHandler::OnIdle( wxIdleEvent &event )
 790 {
 791     if (m_focusOnIdle)
 792     {
 793         m_focusOnIdle = false;
 794         if (wxWindow::FindFocus() != m_editorCtrl)
 795             m_editorCtrl->SetFocus();
 796     }
 797
 798     event.Skip();
 799 }
 800
 801 void wxDataViewEditorCtrlEvtHandler::OnTextEnter( wxCommandEvent &WXUNUSED(event) )
 802 {
 803     m_finished = true;
 804     m_owner->FinishEditing();
 805 }
 806
 807 void wxDataViewEditorCtrlEvtHandler::OnChar( wxKeyEvent &event )
 808 {
 809     switch ( event.m_keyCode )
 810     {
 811         case WXK_RETURN:
 812             m_finished = true;
 813             m_owner->FinishEditing();
 814             break;
 815
 816         case WXK_ESCAPE:
 817         {
 818             m_finished = true;
 819             m_owner->CancelEditing();
 820             break;
 821         }
 822         default:
 823             event.Skip();
 824     }
 825 }
 826
 827 void wxDataViewEditorCtrlEvtHandler::OnKillFocus( wxFocusEvent &event )
 828 {
 829     if (!m_finished)
 830     {
 831         m_finished = true;
 832         m_owner->FinishEditing();
 833     }
 834
 835     event.Skip();
 836 }
 837
 838 // ---------------------------------------------------------
 839 // wxDataViewColumnBase
 840 // ---------------------------------------------------------
 841
 842 void wxDataViewColumnBase::Init(wxDataViewRenderer *renderer,
 843                                 unsigned int model_column)
 844 {
 845     m_renderer = renderer;
 846     m_model_column = model_column;
 847     m_owner = NULL;
 848     m_renderer->SetOwner( (wxDataViewColumn*) this );
 849 }
 850
 851 wxDataViewColumnBase::~wxDataViewColumnBase()
 852 {
 853     delete m_renderer;
 854 }
 855
 856 // ---------------------------------------------------------
 857 // wxDataViewCtrlBase
 858 // ---------------------------------------------------------
 859
 860 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)
 861
 862 wxDataViewCtrlBase::wxDataViewCtrlBase()
 863 {
 864     m_model = NULL;
 865     m_expander_column = 0;
 866     m_indent = 8;
 867 }
 868
 869 wxDataViewCtrlBase::~wxDataViewCtrlBase()
 870 {
 871     if (m_model)
 872     {
 873         m_model->DecRef();
 874         m_model = NULL;
 875     }
 876 }
 877
 878 bool wxDataViewCtrlBase::AssociateModel( wxDataViewModel *model )
 879 {
 880     if (m_model)
 881     {
 882         m_model->DecRef();   // discard old model, if any
 883     }
 884
 885     // add our own reference to the new model:
 886     m_model = model;
 887     if (m_model)
 888     {
 889         m_model->IncRef();
 890     }
 891
 892     return true;
 893 }
 894
 895 wxDataViewModel* wxDataViewCtrlBase::GetModel()
 896 {
 897     return m_model;
 898 }
 899
 900 const wxDataViewModel* wxDataViewCtrlBase::GetModel() const
 901 {
 902     return m_model;
 903 }
 904
 905 void wxDataViewCtrlBase::ExpandAncestors( const wxDataViewItem & item )
 906 {
 907     if (!m_model) return;
 908
 909     if (!item.IsOk()) return;
 910
 911     wxVector<wxDataViewItem> parentChain;
 912
 913     // at first we get all the parents of the selected item
 914     wxDataViewItem parent = m_model->GetParent(item);
 915     while (parent.IsOk())
 916     {
 917         parentChain.push_back(parent);
 918         parent = m_model->GetParent(parent);
 919     }
 920
 921     // then we expand the parents, starting at the root
 922     while (!parentChain.empty())
 923     {
 924          Expand(parentChain.back());
 925          parentChain.pop_back();
 926     }
 927 }
 928
 929 wxDataViewColumn *
 930 wxDataViewCtrlBase::AppendTextColumn( const wxString &label, unsigned int model_column,
 931                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 932 {
 933     wxDataViewColumn *ret = new wxDataViewColumn( label,
 934         new wxDataViewTextRenderer( wxT("string"), mode ),
 935         model_column, width, align, flags );
 936     AppendColumn( ret );
 937     return ret;
 938 }
 939
 940 wxDataViewColumn *
 941 wxDataViewCtrlBase::AppendIconTextColumn( const wxString &label, unsigned int model_column,
 942                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 943 {
 944     wxDataViewColumn *ret = new wxDataViewColumn( label,
 945         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
 946         model_column, width, align, flags );
 947     AppendColumn( ret );
 948     return ret;
 949 }
 950
 951 wxDataViewColumn *
 952 wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, unsigned int model_column,
 953                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 954 {
 955     wxDataViewColumn *ret = new wxDataViewColumn( label,
 956         new wxDataViewToggleRenderer( wxT("bool"), mode ),
 957         model_column, width, align, flags );
 958     AppendColumn( ret );
 959     return ret;
 960 }
 961
 962 wxDataViewColumn *
 963 wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, unsigned int model_column,
 964                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 965 {
 966     wxDataViewColumn *ret = new wxDataViewColumn( label,
 967         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
 968         model_column, width, align, flags );
 969     AppendColumn( ret );
 970     return ret;
 971 }
 972
 973 wxDataViewColumn *
 974 wxDataViewCtrlBase::AppendDateColumn( const wxString &label, unsigned int model_column,
 975                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 976 {
 977     wxDataViewColumn *ret = new wxDataViewColumn( label,
 978         new wxDataViewDateRenderer( wxT("datetime"), mode ),
 979         model_column, width, align, flags );
 980     AppendColumn( ret );
 981     return ret;
 982 }
 983
 984 wxDataViewColumn *
 985 wxDataViewCtrlBase::AppendBitmapColumn( const wxString &label, unsigned int model_column,
 986                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 987 {
 988     wxDataViewColumn *ret = new wxDataViewColumn( label,
 989         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
 990         model_column, width, align, flags );
 991     AppendColumn( ret );
 992     return ret;
 993 }
 994
 995 wxDataViewColumn *
 996 wxDataViewCtrlBase::AppendTextColumn( const wxBitmap &label, unsigned int model_column,
 997                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 998 {
 999     wxDataViewColumn *ret = new wxDataViewColumn( label,
1000         new wxDataViewTextRenderer( wxT("string"), mode ),
1001         model_column, width, align, flags );
1002     AppendColumn( ret );
1003     return ret;
1004 }
1005
1006 wxDataViewColumn *
1007 wxDataViewCtrlBase::AppendIconTextColumn( const wxBitmap &label, unsigned int model_column,
1008                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1009 {
1010     wxDataViewColumn *ret = new wxDataViewColumn( label,
1011         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1012         model_column, width, align, flags );
1013     AppendColumn( ret );
1014     return ret;
1015 }
1016
1017 wxDataViewColumn *
1018 wxDataViewCtrlBase::AppendToggleColumn( const wxBitmap &label, unsigned int model_column,
1019                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1020 {
1021     wxDataViewColumn *ret = new wxDataViewColumn( label,
1022         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1023         model_column, width, align, flags );
1024     AppendColumn( ret );
1025     return ret;
1026 }
1027
1028 wxDataViewColumn *
1029 wxDataViewCtrlBase::AppendProgressColumn( const wxBitmap &label, unsigned int model_column,
1030                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1031 {
1032     wxDataViewColumn *ret = new wxDataViewColumn( label,
1033         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1034         model_column, width, align, flags );
1035     AppendColumn( ret );
1036     return ret;
1037 }
1038
1039 wxDataViewColumn *
1040 wxDataViewCtrlBase::AppendDateColumn( const wxBitmap &label, unsigned int model_column,
1041                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1042 {
1043     wxDataViewColumn *ret = new wxDataViewColumn( label,
1044         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1045         model_column, width, align, flags );
1046     AppendColumn( ret );
1047     return ret;
1048 }
1049
1050 wxDataViewColumn *
1051 wxDataViewCtrlBase::AppendBitmapColumn( const wxBitmap &label, unsigned int model_column,
1052                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1053 {
1054     wxDataViewColumn *ret = new wxDataViewColumn( label,
1055         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1056         model_column, width, align, flags );
1057     AppendColumn( ret );
1058     return ret;
1059 }
1060
1061 wxDataViewColumn *
1062 wxDataViewCtrlBase::PrependTextColumn( const wxString &label, unsigned int model_column,
1063                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1064 {
1065     wxDataViewColumn *ret = new wxDataViewColumn( label,
1066         new wxDataViewTextRenderer( wxT("string"), mode ),
1067         model_column, width, align, flags );
1068     PrependColumn( ret );
1069     return ret;
1070 }
1071
1072 wxDataViewColumn *
1073 wxDataViewCtrlBase::PrependIconTextColumn( const wxString &label, unsigned int model_column,
1074                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1075 {
1076     wxDataViewColumn *ret = new wxDataViewColumn( label,
1077         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1078         model_column, width, align, flags );
1079     PrependColumn( ret );
1080     return ret;
1081 }
1082
1083 wxDataViewColumn *
1084 wxDataViewCtrlBase::PrependToggleColumn( const wxString &label, unsigned int model_column,
1085                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1086 {
1087
1088     wxDataViewColumn *ret = new wxDataViewColumn( label,
1089         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1090         model_column, width, align, flags );
1091     PrependColumn( ret );
1092     return ret;
1093 }
1094
1095 wxDataViewColumn *
1096 wxDataViewCtrlBase::PrependProgressColumn( const wxString &label, unsigned int model_column,
1097                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1098 {
1099     wxDataViewColumn *ret = new wxDataViewColumn( label,
1100         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1101         model_column, width, align, flags );
1102     PrependColumn( ret );
1103     return ret;
1104 }
1105
1106 wxDataViewColumn *
1107 wxDataViewCtrlBase::PrependDateColumn( const wxString &label, unsigned int model_column,
1108                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1109 {
1110     wxDataViewColumn *ret = new wxDataViewColumn( label,
1111         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1112         model_column, width, align, flags );
1113     PrependColumn( ret );
1114     return ret;
1115 }
1116
1117 wxDataViewColumn *
1118 wxDataViewCtrlBase::PrependBitmapColumn( const wxString &label, unsigned int model_column,
1119                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1120 {
1121     wxDataViewColumn *ret = new wxDataViewColumn( label,
1122         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1123         model_column, width, align, flags );
1124     PrependColumn( ret );
1125     return ret;
1126 }
1127
1128 wxDataViewColumn *
1129 wxDataViewCtrlBase::PrependTextColumn( const wxBitmap &label, unsigned int model_column,
1130                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1131 {
1132     wxDataViewColumn *ret = new wxDataViewColumn( label,
1133         new wxDataViewTextRenderer( wxT("string"), mode ),
1134         model_column, width, align, flags );
1135     PrependColumn( ret );
1136     return ret;
1137 }
1138
1139 wxDataViewColumn *
1140 wxDataViewCtrlBase::PrependIconTextColumn( const wxBitmap &label, unsigned int model_column,
1141                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1142 {
1143     wxDataViewColumn *ret = new wxDataViewColumn( label,
1144         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1145         model_column, width, align, flags );
1146     PrependColumn( ret );
1147     return ret;
1148 }
1149
1150 wxDataViewColumn *
1151 wxDataViewCtrlBase::PrependToggleColumn( const wxBitmap &label, unsigned int model_column,
1152                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1153 {
1154     wxDataViewColumn *ret = new wxDataViewColumn( label,
1155         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1156         model_column, width, align, flags );
1157     PrependColumn( ret );
1158     return ret;
1159 }
1160
1161 wxDataViewColumn *
1162 wxDataViewCtrlBase::PrependProgressColumn( const wxBitmap &label, unsigned int model_column,
1163                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1164 {
1165     wxDataViewColumn *ret = new wxDataViewColumn( label,
1166         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1167         model_column, width, align, flags );
1168     PrependColumn( ret );
1169     return ret;
1170 }
1171
1172 wxDataViewColumn *
1173 wxDataViewCtrlBase::PrependDateColumn( const wxBitmap &label, unsigned int model_column,
1174                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1175 {
1176     wxDataViewColumn *ret = new wxDataViewColumn( label,
1177         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1178         model_column, width, align, flags );
1179     PrependColumn( ret );
1180     return ret;
1181 }
1182
1183 wxDataViewColumn *
1184 wxDataViewCtrlBase::PrependBitmapColumn( const wxBitmap &label, unsigned int model_column,
1185                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1186 {
1187     wxDataViewColumn *ret = new wxDataViewColumn( label,
1188         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1189         model_column, width, align, flags );
1190     PrependColumn( ret );
1191     return ret;
1192 }
1193
1194 bool
1195 wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
1196 {
1197     col->SetOwner( (wxDataViewCtrl*) this );
1198     return true;
1199 }
1200
1201 bool
1202 wxDataViewCtrlBase::PrependColumn( wxDataViewColumn *col )
1203 {
1204     col->SetOwner( (wxDataViewCtrl*) this );
1205     return true;
1206 }
1207
1208 bool
1209 wxDataViewCtrlBase::InsertColumn( unsigned int WXUNUSED(pos), wxDataViewColumn *col )
1210 {
1211     col->SetOwner( (wxDataViewCtrl*) this );
1212     return true;
1213 }
1214
1215 // ---------------------------------------------------------
1216 // wxDataViewEvent
1217 // ---------------------------------------------------------
1218
1219 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1220
1221 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, wxDataViewEvent );
1222
1223 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, wxDataViewEvent );
1224 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, wxDataViewEvent );
1225 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, wxDataViewEvent );
1226 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, wxDataViewEvent );
1227 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, wxDataViewEvent );
1228 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, wxDataViewEvent );
1229 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, wxDataViewEvent );
1230 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, wxDataViewEvent );
1231 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, wxDataViewEvent );
1232
1233 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, wxDataViewEvent );
1234
1235 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, wxDataViewEvent );
1236 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, wxDataViewEvent );
1237 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, wxDataViewEvent );
1238 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED, wxDataViewEvent );
1239
1240 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_CACHE_HINT, wxDataViewEvent );
1241
1242 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, wxDataViewEvent );
1243 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, wxDataViewEvent );
1244 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, wxDataViewEvent );
1245
1246
1247
1248 // -------------------------------------
1249 // wxDataViewSpinRenderer
1250 // -------------------------------------
1251
1252 wxDataViewSpinRenderer::wxDataViewSpinRenderer( int min, int max, wxDataViewCellMode mode, int alignment ) :
1253    wxDataViewCustomRenderer(wxT("long"), mode, alignment )
1254 {
1255     m_min = min;
1256     m_max = max;
1257 }
1258
1259 wxControl* wxDataViewSpinRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1260 {
1261     long l = value;
1262     wxSize size = labelRect.GetSize();
1263 #ifdef __WXMAC__
1264     size = wxSize( wxMax(70,labelRect.width ), -1 );
1265 #endif
1266     wxString str;
1267     str.Printf( wxT("%d"), (int) l );
1268     wxSpinCtrl *sc = new wxSpinCtrl( parent, wxID_ANY, str,
1269                labelRect.GetTopLeft(), size, wxSP_ARROW_KEYS|wxTE_PROCESS_ENTER, m_min, m_max, l );
1270 #ifdef __WXMAC__
1271     size = sc->GetSize();
1272     wxPoint pt = sc->GetPosition();
1273     sc->SetSize( pt.x - 4, pt.y - 4, size.x, size.y );
1274 #endif
1275
1276     return sc;
1277 }
1278
1279 bool wxDataViewSpinRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
1280 {
1281     wxSpinCtrl *sc = (wxSpinCtrl*) editor;
1282     long l = sc->GetValue();
1283     value = l;
1284     return true;
1285 }
1286
1287 bool wxDataViewSpinRenderer::Render( wxRect rect, wxDC *dc, int state )
1288 {
1289     wxString str;
1290     str.Printf(wxT("%d"), (int) m_data );
1291     RenderText( str, 0, rect, dc, state );
1292     return true;
1293 }
1294
1295 wxSize wxDataViewSpinRenderer::GetSize() const
1296 {
1297     return wxSize(80,16);
1298 }
1299
1300 bool wxDataViewSpinRenderer::SetValue( const wxVariant &value )
1301 {
1302     m_data = value.GetLong();
1303     return true;
1304 }
1305
1306 bool wxDataViewSpinRenderer::GetValue( wxVariant &value ) const
1307 {
1308     value = m_data;
1309     return true;
1310 }
1311
1312 // -------------------------------------
1313 // wxDataViewChoiceRenderer
1314 // -------------------------------------
1315
1316 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)
1317
1318 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString& choices, wxDataViewCellMode mode, int alignment ) :
1319    wxDataViewCustomRenderer(wxT("string"), mode, alignment )
1320 {
1321     m_choices = choices;
1322 }
1323
1324 wxControl* wxDataViewChoiceRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1325 {
1326     wxString s = value;
1327     wxSize size = labelRect.GetSize();
1328 #ifdef __WXMAC__
1329     size = wxSize( wxMax(70,labelRect.width ), -1 );
1330 #endif
1331     wxChoice *c = new wxChoice( parent, wxID_ANY, labelRect.GetTopLeft(), size, m_choices );
1332     c->SetStringSelection( value.GetString() );
1333
1334     return c;
1335 }
1336
1337 bool wxDataViewChoiceRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
1338 {
1339     wxChoice *c = (wxChoice*) editor;
1340     wxString s = c->GetStringSelection();
1341     value = s;
1342     return true;
1343 }
1344
1345 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
1346 {
1347     RenderText( m_data, 0, rect, dc, state );
1348     return true;
1349 }
1350
1351 wxSize wxDataViewChoiceRenderer::GetSize() const
1352 {
1353     return wxSize(80,16);
1354 }
1355
1356 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
1357 {
1358     m_data = value.GetString();
1359     return true;
1360 }
1361
1362 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
1363 {
1364     value = m_data;
1365     return true;
1366 }
1367
1368 #endif
1369
1370 //-----------------------------------------------------------------------------
1371 // wxDataViewListStore
1372 //-----------------------------------------------------------------------------
1373
1374 wxDataViewListStore::wxDataViewListStore()
1375 {
1376 }
1377
1378 wxDataViewListStore::~wxDataViewListStore()
1379 {
1380     wxVector<wxDataViewListStoreLine*>::iterator it;
1381     for (it = m_data.begin(); it != m_data.end(); ++it)
1382     {
1383         wxDataViewListStoreLine* line = *it;
1384         delete line;
1385     }
1386 }
1387
1388 void wxDataViewListStore::PrependColumn( const wxString &varianttype )
1389 {
1390     m_cols.Insert( varianttype, 0 );
1391 }
1392
1393 void wxDataViewListStore::InsertColumn( unsigned int pos, const wxString &varianttype )
1394 {
1395     m_cols.Insert( varianttype, pos );
1396 }
1397
1398 void wxDataViewListStore::AppendColumn( const wxString &varianttype )
1399 {
1400     m_cols.Add( varianttype );
1401 }
1402
1403 unsigned int wxDataViewListStore::GetColumnCount() const
1404 {
1405     return m_cols.GetCount();
1406 }
1407
1408 wxString wxDataViewListStore::GetColumnType( unsigned int pos ) const
1409 {
1410     return m_cols[pos];
1411 }
1412
1413 void wxDataViewListStore::AppendItem( const wxVector<wxVariant> &values, wxClientData *data )
1414 {
1415     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1416     line->m_values = values;
1417     m_data.push_back( line );
1418
1419     RowAppended();
1420 }
1421
1422 void wxDataViewListStore::PrependItem( const wxVector<wxVariant> &values, wxClientData *data )
1423 {
1424     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1425     line->m_values = values;
1426     m_data.insert( m_data.begin(), line );
1427
1428     RowPrepended();
1429 }
1430
1431 void wxDataViewListStore::InsertItem(  unsigned int row, const wxVector<wxVariant> &values,
1432                                        wxClientData *data )
1433 {
1434     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1435     line->m_values = values;
1436     m_data.insert( m_data.begin()+row, line );
1437
1438     RowInserted( row );
1439 }
1440
1441 void wxDataViewListStore::DeleteItem( unsigned int row )
1442 {
1443     wxVector<wxDataViewListStoreLine*>::iterator it = m_data.begin() + row;
1444     m_data.erase( it );
1445
1446     RowDeleted( row );
1447 }
1448
1449 void wxDataViewListStore::DeleteAllItems()
1450 {
1451     wxVector<wxDataViewListStoreLine*>::iterator it;
1452     for (it = m_data.begin(); it != m_data.end(); ++it)
1453     {
1454         wxDataViewListStoreLine* line = *it;
1455         delete line;
1456     }
1457
1458     m_data.clear();
1459
1460     Reset( 0 );
1461 }
1462
1463 void wxDataViewListStore::GetValueByRow( wxVariant &value, unsigned int row, unsigned int col ) const
1464 {
1465     wxDataViewListStoreLine *line = m_data[row];
1466     value = line->m_values[col];
1467 }
1468
1469 bool wxDataViewListStore::SetValueByRow( const wxVariant &value, unsigned int row, unsigned int col )
1470 {
1471     wxDataViewListStoreLine *line = m_data[row];
1472     line->m_values[col] = value;
1473
1474     return true;
1475 }
1476
1477 //-----------------------------------------------------------------------------
1478 // wxDataViewListCtrl
1479 //-----------------------------------------------------------------------------
1480
1481 IMPLEMENT_DYNAMIC_CLASS(wxDataViewListCtrl,wxDataViewCtrl)
1482
1483 BEGIN_EVENT_TABLE(wxDataViewListCtrl,wxDataViewCtrl)
1484    EVT_SIZE( wxDataViewListCtrl::OnSize )
1485 END_EVENT_TABLE()
1486
1487 wxDataViewListCtrl::wxDataViewListCtrl()
1488 {
1489 }
1490
1491 wxDataViewListCtrl::wxDataViewListCtrl( wxWindow *parent, wxWindowID id,
1492            const wxPoint& pos, const wxSize& size, long style,
1493            const wxValidator& validator )
1494 {
1495     Create( parent, id, pos, size, style, validator );
1496
1497     wxDataViewListStore *store = new wxDataViewListStore;
1498     AssociateModel( store );
1499     store->DecRef();
1500 }
1501
1502 wxDataViewListCtrl::~wxDataViewListCtrl()
1503 {
1504 }
1505
1506
1507 bool wxDataViewListCtrl::Create( wxWindow *parent, wxWindowID id,
1508            const wxPoint& pos, const wxSize& size, long style,
1509            const wxValidator& validator )
1510 {
1511     return wxDataViewCtrl::Create( parent, id, pos, size, style, validator );
1512 }
1513
1514 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *column, const wxString &varianttype )
1515 {
1516     GetStore()->AppendColumn( varianttype );
1517     return wxDataViewCtrl::AppendColumn( column );
1518 }
1519
1520 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *column, const wxString &varianttype )
1521 {
1522     GetStore()->PrependColumn( varianttype );
1523     return wxDataViewCtrl::PrependColumn( column );
1524 }
1525
1526 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *column, const wxString &varianttype )
1527 {
1528     GetStore()->InsertColumn( pos, varianttype );
1529     return wxDataViewCtrl::InsertColumn( pos, column );
1530 }
1531
1532 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *col )
1533 {
1534     return PrependColumn( col, "string" );
1535 }
1536
1537 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
1538 {
1539     return InsertColumn( pos, col, "string" );
1540 }
1541
1542 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *col )
1543 {
1544     return AppendColumn( col, "string" );
1545 }
1546
1547 wxDataViewColumn *wxDataViewListCtrl::AppendTextColumn( const wxString &label,
1548           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1549 {
1550     GetStore()->AppendColumn( wxT("string") );
1551
1552     wxDataViewColumn *ret = new wxDataViewColumn( label,
1553         new wxDataViewTextRenderer( wxT("string"), mode ),
1554         GetStore()->GetColumnCount()-1, width, align, flags );
1555
1556     wxDataViewCtrl::AppendColumn( ret );
1557
1558     return ret;
1559 }
1560
1561 wxDataViewColumn *wxDataViewListCtrl::AppendToggleColumn( const wxString &label,
1562           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1563 {
1564     GetStore()->AppendColumn( wxT("bool") );
1565
1566     wxDataViewColumn *ret = new wxDataViewColumn( label,
1567         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1568         GetStore()->GetColumnCount()-1, width, align, flags );
1569
1570     wxDataViewCtrl::AppendColumn( ret );
1571
1572     return ret;
1573 }
1574
1575 wxDataViewColumn *wxDataViewListCtrl::AppendProgressColumn( const wxString &label,
1576           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1577 {
1578     GetStore()->AppendColumn( wxT("long") );
1579
1580     wxDataViewColumn *ret = new wxDataViewColumn( label,
1581         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1582         GetStore()->GetColumnCount()-1, width, align, flags );
1583
1584     wxDataViewCtrl::AppendColumn( ret );
1585
1586     return ret;
1587 }
1588
1589 wxDataViewColumn *wxDataViewListCtrl::AppendIconTextColumn( const wxString &label,
1590           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1591 {
1592     GetStore()->AppendColumn( wxT("wxDataViewIconText") );
1593
1594     wxDataViewColumn *ret = new wxDataViewColumn( label,
1595         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1596         GetStore()->GetColumnCount()-1, width, align, flags );
1597
1598     wxDataViewCtrl::AppendColumn( ret );
1599
1600     return ret;
1601 }
1602
1603 void wxDataViewListCtrl::OnSize( wxSizeEvent &event )
1604 {
1605     event.Skip( true );
1606 }
1607
1608 //-----------------------------------------------------------------------------
1609 // wxDataViewTreeStore
1610 //-----------------------------------------------------------------------------
1611
1612 wxDataViewTreeStoreNode::wxDataViewTreeStoreNode(
1613         wxDataViewTreeStoreNode *parent,
1614         const wxString &text, const wxIcon &icon, wxClientData *data )
1615 {
1616     m_parent = parent;
1617     m_text = text;
1618     m_icon = icon;
1619     m_data = data;
1620 }
1621
1622 wxDataViewTreeStoreNode::~wxDataViewTreeStoreNode()
1623 {
1624     if (m_data)
1625         delete m_data;
1626 }
1627
1628 #include "wx/listimpl.cpp"
1629 WX_DEFINE_LIST(wxDataViewTreeStoreNodeList)
1630
1631 wxDataViewTreeStoreContainerNode::wxDataViewTreeStoreContainerNode(
1632         wxDataViewTreeStoreNode *parent, const wxString &text,
1633         const wxIcon &icon, const wxIcon &expanded, wxClientData *data ) :
1634     wxDataViewTreeStoreNode( parent, text, icon, data )
1635 {
1636     m_iconExpanded = expanded;
1637     m_isExpanded = false;
1638     m_children.DeleteContents(true);
1639 }
1640
1641 wxDataViewTreeStoreContainerNode::~wxDataViewTreeStoreContainerNode()
1642 {
1643 }
1644
1645 //-----------------------------------------------------------------------------
1646
1647 wxDataViewTreeStore::wxDataViewTreeStore()
1648 {
1649     m_root = new wxDataViewTreeStoreContainerNode( NULL, wxEmptyString );
1650 }
1651
1652 wxDataViewTreeStore::~wxDataViewTreeStore()
1653 {
1654     delete m_root;
1655 }
1656
1657 wxDataViewItem wxDataViewTreeStore::AppendItem( const wxDataViewItem& parent,
1658         const wxString &text, const wxIcon &icon, wxClientData *data )
1659 {
1660     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1661     if (!parent_node) return wxDataViewItem(0);
1662
1663     wxDataViewTreeStoreNode *node =
1664         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1665     parent_node->GetChildren().Append( node );
1666
1667     return node->GetItem();
1668 }
1669
1670 wxDataViewItem wxDataViewTreeStore::PrependItem( const wxDataViewItem& parent,
1671         const wxString &text, const wxIcon &icon, wxClientData *data )
1672 {
1673     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1674     if (!parent_node) return wxDataViewItem(0);
1675
1676     wxDataViewTreeStoreNode *node =
1677         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1678     parent_node->GetChildren().Insert( node );
1679
1680     return node->GetItem();
1681 }
1682
1683 wxDataViewItem
1684 wxDataViewTreeStore::InsertItem(const wxDataViewItem& parent,
1685                                 const wxDataViewItem& previous,
1686                                 const wxString& text,
1687                                 const wxIcon& icon,
1688                                 wxClientData *data)
1689 {
1690     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1691     if (!parent_node) return wxDataViewItem(0);
1692
1693     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
1694     int pos = parent_node->GetChildren().IndexOf( previous_node );
1695     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
1696
1697     wxDataViewTreeStoreNode *node =
1698         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1699     parent_node->GetChildren().Insert( (size_t) pos, node );
1700
1701     return node->GetItem();
1702 }
1703
1704 wxDataViewItem wxDataViewTreeStore::PrependContainer( const wxDataViewItem& parent,
1705         const wxString &text, const wxIcon &icon, const wxIcon &expanded,
1706         wxClientData *data )
1707 {
1708     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1709     if (!parent_node) return wxDataViewItem(0);
1710
1711     wxDataViewTreeStoreContainerNode *node =
1712         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1713     parent_node->GetChildren().Insert( node );
1714
1715     return node->GetItem();
1716 }
1717
1718 wxDataViewItem
1719 wxDataViewTreeStore::AppendContainer(const wxDataViewItem& parent,
1720                                      const wxString &text,
1721                                      const wxIcon& icon,
1722                                      const wxIcon& expanded,
1723                                      wxClientData * data)
1724 {
1725     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1726     if (!parent_node) return wxDataViewItem(0);
1727
1728     wxDataViewTreeStoreContainerNode *node =
1729         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1730     parent_node->GetChildren().Append( node );
1731
1732     return node->GetItem();
1733 }
1734
1735 wxDataViewItem
1736 wxDataViewTreeStore::InsertContainer(const wxDataViewItem& parent,
1737                                      const wxDataViewItem& previous,
1738                                      const wxString& text,
1739                                      const wxIcon& icon,
1740                                      const wxIcon& expanded,
1741                                      wxClientData * data)
1742 {
1743     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1744     if (!parent_node) return wxDataViewItem(0);
1745
1746     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
1747     int pos = parent_node->GetChildren().IndexOf( previous_node );
1748     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
1749
1750     wxDataViewTreeStoreContainerNode *node =
1751         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1752     parent_node->GetChildren().Insert( (size_t) pos, node );
1753
1754     return node->GetItem();
1755 }
1756
1757 wxDataViewItem wxDataViewTreeStore::GetNthChild( const wxDataViewItem& parent, unsigned int pos ) const
1758 {
1759     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1760     if (!parent_node) return wxDataViewItem(0);
1761
1762     wxDataViewTreeStoreNodeList::compatibility_iterator node = parent_node->GetChildren().Item( pos );
1763     if (node)
1764         return node->GetData();
1765
1766     return wxDataViewItem(0);
1767 }
1768
1769 int wxDataViewTreeStore::GetChildCount( const wxDataViewItem& parent ) const
1770 {
1771     wxDataViewTreeStoreNode *node = FindNode( parent );
1772     if (!node) return -1;
1773
1774     if (!node->IsContainer())
1775         return 0;
1776
1777     wxDataViewTreeStoreContainerNode *container_node = (wxDataViewTreeStoreContainerNode*) node;
1778     return (int) container_node->GetChildren().GetCount();
1779 }
1780
1781 void wxDataViewTreeStore::SetItemText( const wxDataViewItem& item, const wxString &text )
1782 {
1783     wxDataViewTreeStoreNode *node = FindNode( item );
1784     if (!node) return;
1785
1786     node->SetText( text );
1787 }
1788
1789 wxString wxDataViewTreeStore::GetItemText( const wxDataViewItem& item ) const
1790 {
1791     wxDataViewTreeStoreNode *node = FindNode( item );
1792     if (!node) return wxEmptyString;
1793
1794     return node->GetText();
1795 }
1796
1797 void wxDataViewTreeStore::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
1798 {
1799     wxDataViewTreeStoreNode *node = FindNode( item );
1800     if (!node) return;
1801
1802     node->SetIcon( icon );
1803 }
1804
1805 const wxIcon &wxDataViewTreeStore::GetItemIcon( const wxDataViewItem& item ) const
1806 {
1807     wxDataViewTreeStoreNode *node = FindNode( item );
1808     if (!node) return wxNullIcon;
1809
1810     return node->GetIcon();
1811 }
1812
1813 void wxDataViewTreeStore::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
1814 {
1815     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1816     if (!node) return;
1817
1818     node->SetExpandedIcon( icon );
1819 }
1820
1821 const wxIcon &wxDataViewTreeStore::GetItemExpandedIcon( const wxDataViewItem& item ) const
1822 {
1823     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1824     if (!node) return wxNullIcon;
1825
1826     return node->GetExpandedIcon();
1827 }
1828
1829 void wxDataViewTreeStore::SetItemData( const wxDataViewItem& item, wxClientData *data )
1830 {
1831     wxDataViewTreeStoreNode *node = FindNode( item );
1832     if (!node) return;
1833
1834     node->SetData( data );
1835 }
1836
1837 wxClientData *wxDataViewTreeStore::GetItemData( const wxDataViewItem& item ) const
1838 {
1839     wxDataViewTreeStoreNode *node = FindNode( item );
1840     if (!node) return NULL;
1841
1842     return node->GetData();
1843 }
1844
1845 void wxDataViewTreeStore::DeleteItem( const wxDataViewItem& item )
1846 {
1847     if (!item.IsOk()) return;
1848
1849     wxDataViewItem parent_item = GetParent( item );
1850
1851     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent_item );
1852     if (!parent_node) return;
1853
1854     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1855     if (!node) return;
1856
1857     parent_node->GetChildren().DeleteObject( node );
1858 }
1859
1860 void wxDataViewTreeStore::DeleteChildren( const wxDataViewItem& item )
1861 {
1862     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1863     if (!node) return;
1864
1865     node->GetChildren().clear();
1866 }
1867
1868 void wxDataViewTreeStore::DeleteAllItems()
1869 {
1870     DeleteChildren(m_root);
1871 }
1872
1873 void
1874 wxDataViewTreeStore::GetValue(wxVariant &variant,
1875                               const wxDataViewItem &item,
1876                               unsigned int WXUNUSED(col)) const
1877 {
1878     // if (col != 0) return;
1879
1880     wxDataViewTreeStoreNode *node = FindNode( item );
1881     if (!node) return;
1882
1883     wxIcon icon( node->GetIcon());
1884     if (node->IsContainer())
1885     {
1886         wxDataViewTreeStoreContainerNode *container = (wxDataViewTreeStoreContainerNode*) node;
1887         if (container->IsExpanded() && container->GetExpandedIcon().IsOk())
1888            icon = container->GetExpandedIcon();
1889     }
1890
1891     wxDataViewIconText data( node->GetText(), icon );
1892
1893     variant << data;
1894 }
1895
1896 bool
1897 wxDataViewTreeStore::SetValue(const wxVariant& variant,
1898                               const wxDataViewItem& item,
1899                               unsigned int WXUNUSED(col))
1900 {
1901     // if (col != 0) return false;
1902
1903     wxDataViewTreeStoreNode *node = FindNode( item );
1904     if (!node) return false;
1905
1906     wxDataViewIconText data;
1907
1908     data << variant;
1909
1910     node->SetText( data.GetText() );
1911     node->SetIcon( data.GetIcon() );
1912
1913     return true;
1914 }
1915
1916 wxDataViewItem wxDataViewTreeStore::GetParent( const wxDataViewItem &item ) const
1917 {
1918     wxDataViewTreeStoreNode *node = FindNode( item );
1919     if (!node) return wxDataViewItem(0);
1920
1921     wxDataViewTreeStoreNode *parent = node->GetParent();
1922     if (!parent) return wxDataViewItem(0);
1923
1924     if (parent == m_root)
1925         return wxDataViewItem(0);
1926
1927     return parent->GetItem();
1928 }
1929
1930 bool wxDataViewTreeStore::IsContainer( const wxDataViewItem &item ) const
1931 {
1932     wxDataViewTreeStoreNode *node = FindNode( item );
1933     if (!node) return false;
1934
1935     return node->IsContainer();
1936 }
1937
1938 unsigned int wxDataViewTreeStore::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
1939 {
1940     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1941     if (!node) return 0;
1942
1943     wxDataViewTreeStoreNodeList::iterator iter;
1944     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
1945     {
1946         wxDataViewTreeStoreNode* child = *iter;
1947         children.Add( child->GetItem() );
1948     }
1949
1950     return node->GetChildren().GetCount();
1951 }
1952
1953 int wxDataViewTreeStore::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
1954                          unsigned int WXUNUSED(column), bool WXUNUSED(ascending) ) const
1955 {
1956     wxDataViewTreeStoreNode *node1 = FindNode( item1 );
1957     wxDataViewTreeStoreNode *node2 = FindNode( item2 );
1958
1959     if (!node1 || !node2)
1960         return 0;
1961
1962     wxDataViewTreeStoreContainerNode* parent1 =
1963         (wxDataViewTreeStoreContainerNode*) node1->GetParent();
1964     wxDataViewTreeStoreContainerNode* parent2 =
1965         (wxDataViewTreeStoreContainerNode*) node2->GetParent();
1966
1967     if (parent1 != parent2)
1968     {
1969         wxLogError( wxT("Comparing items with different parent.") );
1970         return 0;
1971     }
1972
1973     if (node1->IsContainer() && !!node2->IsContainer())
1974         return 1;
1975
1976     if (node2->IsContainer() && !!node1->IsContainer())
1977         return -1;
1978
1979     return parent1->GetChildren().IndexOf( node1 ) - parent1->GetChildren().IndexOf( node2 );
1980 }
1981
1982 wxDataViewTreeStoreNode *wxDataViewTreeStore::FindNode( const wxDataViewItem &item ) const
1983 {
1984     if (!item.IsOk())
1985         return m_root;
1986
1987     return (wxDataViewTreeStoreNode*) item.GetID();
1988 }
1989
1990 wxDataViewTreeStoreContainerNode *wxDataViewTreeStore::FindContainerNode( const wxDataViewItem &item ) const
1991 {
1992     if (!item.IsOk())
1993         return (wxDataViewTreeStoreContainerNode*) m_root;
1994
1995     wxDataViewTreeStoreNode* node = (wxDataViewTreeStoreNode*) item.GetID();
1996
1997     if (!node->IsContainer())
1998         return NULL;
1999
2000     return (wxDataViewTreeStoreContainerNode*) node;
2001 }
2002
2003 //-----------------------------------------------------------------------------
2004 // wxDataViewTreeCtrl
2005 //-----------------------------------------------------------------------------
2006
2007 IMPLEMENT_DYNAMIC_CLASS(wxDataViewTreeCtrl,wxDataViewCtrl)
2008
2009 BEGIN_EVENT_TABLE(wxDataViewTreeCtrl,wxDataViewCtrl)
2010    EVT_DATAVIEW_ITEM_EXPANDED(-1, wxDataViewTreeCtrl::OnExpanded)
2011    EVT_DATAVIEW_ITEM_COLLAPSED(-1, wxDataViewTreeCtrl::OnCollapsed)
2012    EVT_SIZE( wxDataViewTreeCtrl::OnSize )
2013 END_EVENT_TABLE()
2014
2015 wxDataViewTreeCtrl::wxDataViewTreeCtrl()
2016 {
2017     m_imageList = NULL;
2018 }
2019
2020 wxDataViewTreeCtrl::wxDataViewTreeCtrl( wxWindow *parent, wxWindowID id,
2021            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2022 {
2023     m_imageList = NULL;
2024     Create( parent, id, pos, size, style, validator );
2025
2026     wxDataViewTreeStore *store = new wxDataViewTreeStore;
2027     AssociateModel( store );
2028     store->DecRef();
2029
2030     AppendIconTextColumn(wxString(),0,wxDATAVIEW_CELL_INERT,-1);
2031 }
2032
2033 wxDataViewTreeCtrl::~wxDataViewTreeCtrl()
2034 {
2035     if (m_imageList)
2036         delete m_imageList;
2037 }
2038
2039 bool wxDataViewTreeCtrl::Create( wxWindow *parent, wxWindowID id,
2040            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2041 {
2042     return wxDataViewCtrl::Create( parent, id, pos, size, style, validator );
2043 }
2044
2045 void wxDataViewTreeCtrl::SetImageList( wxImageList *imagelist )
2046 {
2047     if (m_imageList)
2048         delete m_imageList;
2049
2050     m_imageList = imagelist;
2051 }
2052
2053 wxDataViewItem wxDataViewTreeCtrl::AppendItem( const wxDataViewItem& parent,
2054         const wxString &text, int iconIndex, wxClientData *data )
2055 {
2056     wxIcon icon = wxNullIcon;
2057     if (m_imageList && (iconIndex != -1))
2058         icon = m_imageList->GetIcon( iconIndex );
2059
2060     wxDataViewItem res = GetStore()->AppendItem( parent, text, icon, data );
2061
2062     GetStore()->ItemAdded( parent, res );
2063
2064     return res;
2065 }
2066
2067 wxDataViewItem wxDataViewTreeCtrl::PrependItem( const wxDataViewItem& parent,
2068         const wxString &text, int iconIndex, wxClientData *data )
2069 {
2070     wxIcon icon = wxNullIcon;
2071     if (m_imageList && (iconIndex != -1))
2072         icon = m_imageList->GetIcon( iconIndex );
2073
2074     wxDataViewItem res = GetStore()->PrependItem( parent, text, icon, data );
2075
2076     GetStore()->ItemAdded( parent, res );
2077
2078     return res;
2079 }
2080
2081 wxDataViewItem wxDataViewTreeCtrl::InsertItem( const wxDataViewItem& parent, const wxDataViewItem& previous,
2082         const wxString &text, int iconIndex, wxClientData *data )
2083 {
2084     wxIcon icon = wxNullIcon;
2085     if (m_imageList && (iconIndex != -1))
2086         icon = m_imageList->GetIcon( iconIndex );
2087
2088     wxDataViewItem res = GetStore()->InsertItem( parent, previous, text, icon, data );
2089
2090     GetStore()->ItemAdded( parent, res );
2091
2092     return res;
2093 }
2094
2095 wxDataViewItem wxDataViewTreeCtrl::PrependContainer( const wxDataViewItem& parent,
2096         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2097 {
2098     wxIcon icon = wxNullIcon;
2099     if (m_imageList && (iconIndex != -1))
2100         icon = m_imageList->GetIcon( iconIndex );
2101
2102     wxIcon expanded = wxNullIcon;
2103     if (m_imageList && (expandedIndex != -1))
2104         expanded = m_imageList->GetIcon( expandedIndex );
2105
2106     wxDataViewItem res = GetStore()->PrependContainer( parent, text, icon, expanded, data );
2107
2108     GetStore()->ItemAdded( parent, res );
2109
2110     return res;
2111 }
2112
2113 wxDataViewItem wxDataViewTreeCtrl::AppendContainer( const wxDataViewItem& parent,
2114         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2115 {
2116     wxIcon icon = wxNullIcon;
2117     if (m_imageList && (iconIndex != -1))
2118         icon = m_imageList->GetIcon( iconIndex );
2119
2120     wxIcon expanded = wxNullIcon;
2121     if (m_imageList && (expandedIndex != -1))
2122         expanded = m_imageList->GetIcon( expandedIndex );
2123
2124     wxDataViewItem res = GetStore()->AppendContainer( parent, text, icon, expanded, data );
2125
2126     GetStore()->ItemAdded( parent, res );
2127
2128     return res;
2129 }
2130
2131 wxDataViewItem wxDataViewTreeCtrl::InsertContainer( const wxDataViewItem& parent, const wxDataViewItem& previous,
2132         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2133 {
2134     wxIcon icon = wxNullIcon;
2135     if (m_imageList && (iconIndex != -1))
2136         icon = m_imageList->GetIcon( iconIndex );
2137
2138     wxIcon expanded = wxNullIcon;
2139     if (m_imageList && (expandedIndex != -1))
2140         expanded = m_imageList->GetIcon( expandedIndex );
2141
2142     wxDataViewItem res = GetStore()->InsertContainer( parent, previous, text, icon, expanded, data );
2143
2144     GetStore()->ItemAdded( parent, res );
2145
2146     return res;
2147 }
2148
2149 void wxDataViewTreeCtrl::SetItemText( const wxDataViewItem& item, const wxString &text )
2150 {
2151     GetStore()->SetItemText(item,text);
2152
2153     // notify control
2154     GetStore()->ValueChanged( item, 0 );
2155 }
2156
2157 void wxDataViewTreeCtrl::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2158 {
2159     GetStore()->SetItemIcon(item,icon);
2160
2161     // notify control
2162     GetStore()->ValueChanged( item, 0 );
2163 }
2164
2165 void wxDataViewTreeCtrl::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2166 {
2167     GetStore()->SetItemExpandedIcon(item,icon);
2168
2169     // notify control
2170     GetStore()->ValueChanged( item, 0 );
2171 }
2172
2173 void wxDataViewTreeCtrl::DeleteItem( const wxDataViewItem& item )
2174 {
2175     wxDataViewItem parent_item = GetStore()->GetParent( item );
2176
2177     GetStore()->DeleteItem(item);
2178
2179     // notify control
2180     GetStore()->ItemDeleted( parent_item, item );
2181 }
2182
2183 void wxDataViewTreeCtrl::DeleteChildren( const wxDataViewItem& item )
2184 {
2185     wxDataViewTreeStoreContainerNode *node = GetStore()->FindContainerNode( item );
2186     if (!node) return;
2187
2188     wxDataViewItemArray array;
2189     wxDataViewTreeStoreNodeList::iterator iter;
2190     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2191     {
2192         wxDataViewTreeStoreNode* child = *iter;
2193         array.Add( child->GetItem() );
2194     }
2195
2196     GetStore()->DeleteChildren( item );
2197
2198     // notify control
2199     GetStore()->ItemsDeleted( item, array );
2200 }
2201
2202 void  wxDataViewTreeCtrl::DeleteAllItems()
2203 {
2204     GetStore()->DeleteAllItems();
2205
2206     GetStore()->Cleared();
2207 }
2208
2209 void wxDataViewTreeCtrl::OnExpanded( wxDataViewEvent &event )
2210 {
2211     if (m_imageList) return;
2212
2213     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2214     if (!container) return;
2215
2216     container->SetExpanded( true );
2217
2218     GetStore()->ItemChanged( event.GetItem() );
2219 }
2220
2221 void wxDataViewTreeCtrl::OnCollapsed( wxDataViewEvent &event )
2222 {
2223     if (m_imageList) return;
2224
2225     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2226     if (!container) return;
2227
2228     container->SetExpanded( false );
2229
2230     GetStore()->ItemChanged( event.GetItem() );
2231 }
2232
2233 void wxDataViewTreeCtrl::OnSize( wxSizeEvent &event )
2234 {
2235 #if defined(wxUSE_GENERICDATAVIEWCTRL)
2236     // automatically resize our only column to take the entire control width
2237     if ( GetColumnCount() )
2238     {
2239         wxSize size = GetClientSize();
2240         GetColumn(0)->SetWidth(size.x);
2241     }
2242 #endif
2243     event.Skip( true );
2244 }
2245
2246 #endif // wxUSE_DATAVIEWCTRL
2247