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