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