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