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 void wxDataViewCtrlBase::ExpandAncestors( const wxDataViewItem & item )
 905 {
 906     if (!m_model) return;
 907
 908     if (!item.IsOk()) return;
 909
 910     wxVector<wxDataViewItem> parentChain;
 911
 912     // at first we get all the parents of the selected item
 913     wxDataViewItem parent = m_model->GetParent(item);
 914     while (parent.IsOk())
 915     {
 916         parentChain.push_back(parent);
 917         parent = m_model->GetParent(parent);
 918     }
 919
 920     // then we expand the parents, starting at the root
 921     while (!parentChain.empty())
 922     {
 923          Expand(parentChain.back());
 924          parentChain.pop_back();
 925     }
 926 }
 927
 928 wxDataViewColumn *
 929 wxDataViewCtrlBase::AppendTextColumn( const wxString &label, unsigned int model_column,
 930                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 931 {
 932     wxDataViewColumn *ret = new wxDataViewColumn( label,
 933         new wxDataViewTextRenderer( wxT("string"), mode ),
 934         model_column, width, align, flags );
 935     AppendColumn( ret );
 936     return ret;
 937 }
 938
 939 wxDataViewColumn *
 940 wxDataViewCtrlBase::AppendIconTextColumn( const wxString &label, unsigned int model_column,
 941                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 942 {
 943     wxDataViewColumn *ret = new wxDataViewColumn( label,
 944         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
 945         model_column, width, align, flags );
 946     AppendColumn( ret );
 947     return ret;
 948 }
 949
 950 wxDataViewColumn *
 951 wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, unsigned int model_column,
 952                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 953 {
 954     wxDataViewColumn *ret = new wxDataViewColumn( label,
 955         new wxDataViewToggleRenderer( wxT("bool"), mode ),
 956         model_column, width, align, flags );
 957     AppendColumn( ret );
 958     return ret;
 959 }
 960
 961 wxDataViewColumn *
 962 wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, unsigned int model_column,
 963                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 964 {
 965     wxDataViewColumn *ret = new wxDataViewColumn( label,
 966         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
 967         model_column, width, align, flags );
 968     AppendColumn( ret );
 969     return ret;
 970 }
 971
 972 wxDataViewColumn *
 973 wxDataViewCtrlBase::AppendDateColumn( const wxString &label, unsigned int model_column,
 974                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 975 {
 976     wxDataViewColumn *ret = new wxDataViewColumn( label,
 977         new wxDataViewDateRenderer( wxT("datetime"), mode ),
 978         model_column, width, align, flags );
 979     AppendColumn( ret );
 980     return ret;
 981 }
 982
 983 wxDataViewColumn *
 984 wxDataViewCtrlBase::AppendBitmapColumn( const wxString &label, unsigned int model_column,
 985                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 986 {
 987     wxDataViewColumn *ret = new wxDataViewColumn( label,
 988         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
 989         model_column, width, align, flags );
 990     AppendColumn( ret );
 991     return ret;
 992 }
 993
 994 wxDataViewColumn *
 995 wxDataViewCtrlBase::AppendTextColumn( const wxBitmap &label, unsigned int model_column,
 996                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 997 {
 998     wxDataViewColumn *ret = new wxDataViewColumn( label,
 999         new wxDataViewTextRenderer( wxT("string"), mode ),
1000         model_column, width, align, flags );
1001     AppendColumn( ret );
1002     return ret;
1003 }
1004
1005 wxDataViewColumn *
1006 wxDataViewCtrlBase::AppendIconTextColumn( const wxBitmap &label, unsigned int model_column,
1007                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1008 {
1009     wxDataViewColumn *ret = new wxDataViewColumn( label,
1010         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1011         model_column, width, align, flags );
1012     AppendColumn( ret );
1013     return ret;
1014 }
1015
1016 wxDataViewColumn *
1017 wxDataViewCtrlBase::AppendToggleColumn( const wxBitmap &label, unsigned int model_column,
1018                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1019 {
1020     wxDataViewColumn *ret = new wxDataViewColumn( label,
1021         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1022         model_column, width, align, flags );
1023     AppendColumn( ret );
1024     return ret;
1025 }
1026
1027 wxDataViewColumn *
1028 wxDataViewCtrlBase::AppendProgressColumn( const wxBitmap &label, unsigned int model_column,
1029                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1030 {
1031     wxDataViewColumn *ret = new wxDataViewColumn( label,
1032         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1033         model_column, width, align, flags );
1034     AppendColumn( ret );
1035     return ret;
1036 }
1037
1038 wxDataViewColumn *
1039 wxDataViewCtrlBase::AppendDateColumn( const wxBitmap &label, unsigned int model_column,
1040                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1041 {
1042     wxDataViewColumn *ret = new wxDataViewColumn( label,
1043         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1044         model_column, width, align, flags );
1045     AppendColumn( ret );
1046     return ret;
1047 }
1048
1049 wxDataViewColumn *
1050 wxDataViewCtrlBase::AppendBitmapColumn( const wxBitmap &label, unsigned int model_column,
1051                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1052 {
1053     wxDataViewColumn *ret = new wxDataViewColumn( label,
1054         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1055         model_column, width, align, flags );
1056     AppendColumn( ret );
1057     return ret;
1058 }
1059
1060 wxDataViewColumn *
1061 wxDataViewCtrlBase::PrependTextColumn( const wxString &label, unsigned int model_column,
1062                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1063 {
1064     wxDataViewColumn *ret = new wxDataViewColumn( label,
1065         new wxDataViewTextRenderer( wxT("string"), mode ),
1066         model_column, width, align, flags );
1067     PrependColumn( ret );
1068     return ret;
1069 }
1070
1071 wxDataViewColumn *
1072 wxDataViewCtrlBase::PrependIconTextColumn( const wxString &label, unsigned int model_column,
1073                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1074 {
1075     wxDataViewColumn *ret = new wxDataViewColumn( label,
1076         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1077         model_column, width, align, flags );
1078     PrependColumn( ret );
1079     return ret;
1080 }
1081
1082 wxDataViewColumn *
1083 wxDataViewCtrlBase::PrependToggleColumn( const wxString &label, unsigned int model_column,
1084                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1085 {
1086
1087     wxDataViewColumn *ret = new wxDataViewColumn( label,
1088         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1089         model_column, width, align, flags );
1090     PrependColumn( ret );
1091     return ret;
1092 }
1093
1094 wxDataViewColumn *
1095 wxDataViewCtrlBase::PrependProgressColumn( const wxString &label, unsigned int model_column,
1096                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1097 {
1098     wxDataViewColumn *ret = new wxDataViewColumn( label,
1099         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1100         model_column, width, align, flags );
1101     PrependColumn( ret );
1102     return ret;
1103 }
1104
1105 wxDataViewColumn *
1106 wxDataViewCtrlBase::PrependDateColumn( const wxString &label, unsigned int model_column,
1107                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1108 {
1109     wxDataViewColumn *ret = new wxDataViewColumn( label,
1110         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1111         model_column, width, align, flags );
1112     PrependColumn( ret );
1113     return ret;
1114 }
1115
1116 wxDataViewColumn *
1117 wxDataViewCtrlBase::PrependBitmapColumn( const wxString &label, unsigned int model_column,
1118                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1119 {
1120     wxDataViewColumn *ret = new wxDataViewColumn( label,
1121         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1122         model_column, width, align, flags );
1123     PrependColumn( ret );
1124     return ret;
1125 }
1126
1127 wxDataViewColumn *
1128 wxDataViewCtrlBase::PrependTextColumn( const wxBitmap &label, unsigned int model_column,
1129                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1130 {
1131     wxDataViewColumn *ret = new wxDataViewColumn( label,
1132         new wxDataViewTextRenderer( wxT("string"), mode ),
1133         model_column, width, align, flags );
1134     PrependColumn( ret );
1135     return ret;
1136 }
1137
1138 wxDataViewColumn *
1139 wxDataViewCtrlBase::PrependIconTextColumn( const wxBitmap &label, unsigned int model_column,
1140                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1141 {
1142     wxDataViewColumn *ret = new wxDataViewColumn( label,
1143         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1144         model_column, width, align, flags );
1145     PrependColumn( ret );
1146     return ret;
1147 }
1148
1149 wxDataViewColumn *
1150 wxDataViewCtrlBase::PrependToggleColumn( const wxBitmap &label, unsigned int model_column,
1151                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1152 {
1153     wxDataViewColumn *ret = new wxDataViewColumn( label,
1154         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1155         model_column, width, align, flags );
1156     PrependColumn( ret );
1157     return ret;
1158 }
1159
1160 wxDataViewColumn *
1161 wxDataViewCtrlBase::PrependProgressColumn( const wxBitmap &label, unsigned int model_column,
1162                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1163 {
1164     wxDataViewColumn *ret = new wxDataViewColumn( label,
1165         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1166         model_column, width, align, flags );
1167     PrependColumn( ret );
1168     return ret;
1169 }
1170
1171 wxDataViewColumn *
1172 wxDataViewCtrlBase::PrependDateColumn( const wxBitmap &label, unsigned int model_column,
1173                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1174 {
1175     wxDataViewColumn *ret = new wxDataViewColumn( label,
1176         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1177         model_column, width, align, flags );
1178     PrependColumn( ret );
1179     return ret;
1180 }
1181
1182 wxDataViewColumn *
1183 wxDataViewCtrlBase::PrependBitmapColumn( const wxBitmap &label, unsigned int model_column,
1184                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1185 {
1186     wxDataViewColumn *ret = new wxDataViewColumn( label,
1187         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1188         model_column, width, align, flags );
1189     PrependColumn( ret );
1190     return ret;
1191 }
1192
1193 bool
1194 wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
1195 {
1196     col->SetOwner( (wxDataViewCtrl*) this );
1197     return true;
1198 }
1199
1200 bool
1201 wxDataViewCtrlBase::PrependColumn( wxDataViewColumn *col )
1202 {
1203     col->SetOwner( (wxDataViewCtrl*) this );
1204     return true;
1205 }
1206
1207 bool
1208 wxDataViewCtrlBase::InsertColumn( unsigned int WXUNUSED(pos), wxDataViewColumn *col )
1209 {
1210     col->SetOwner( (wxDataViewCtrl*) this );
1211     return true;
1212 }
1213
1214 // ---------------------------------------------------------
1215 // wxDataViewEvent
1216 // ---------------------------------------------------------
1217
1218 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1219
1220 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, wxDataViewEvent )
1221
1222 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, wxDataViewEvent )
1223 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, wxDataViewEvent )
1224 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, wxDataViewEvent )
1225 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, wxDataViewEvent )
1226 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, wxDataViewEvent )
1227 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, wxDataViewEvent )
1228 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, wxDataViewEvent )
1229 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, wxDataViewEvent )
1230
1231 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, wxDataViewEvent )
1232
1233 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, wxDataViewEvent )
1234 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, wxDataViewEvent )
1235 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, wxDataViewEvent )
1236 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED, wxDataViewEvent )
1237
1238 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DRAGGABLE, wxDataViewEvent )
1239 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_GET_DRAG_DATA_SIZE, wxDataViewEvent )
1240 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_GET_DRAG_DATA, wxDataViewEvent )
1241
1242 // -------------------------------------
1243 // wxDataViewSpinRenderer
1244 // -------------------------------------
1245
1246 wxDataViewSpinRenderer::wxDataViewSpinRenderer( int min, int max, wxDataViewCellMode mode, int alignment ) :
1247    wxDataViewCustomRenderer(wxT("long"), mode, alignment )
1248 {
1249     m_min = min;
1250     m_max = max;
1251 }
1252
1253 wxControl* wxDataViewSpinRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1254 {
1255     long l = value;
1256     wxSize size = labelRect.GetSize();
1257 #ifdef __WXMAC__
1258     size = wxSize( wxMax(70,labelRect.width ), -1 );
1259 #endif
1260     wxString str;
1261     str.Printf( wxT("%d"), (int) l );
1262     wxSpinCtrl *sc = new wxSpinCtrl( parent, wxID_ANY, str,
1263                labelRect.GetTopLeft(), size, wxSP_ARROW_KEYS|wxTE_PROCESS_ENTER, m_min, m_max, l );
1264 #ifdef __WXMAC__
1265     size = sc->GetSize();
1266     wxPoint pt = sc->GetPosition();
1267     sc->SetSize( pt.x - 4, pt.y - 4, size.x, size.y );
1268 #endif
1269
1270     return sc;
1271 }
1272
1273 bool wxDataViewSpinRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
1274 {
1275     wxSpinCtrl *sc = (wxSpinCtrl*) editor;
1276     long l = sc->GetValue();
1277     value = l;
1278     return true;
1279 }
1280
1281 bool wxDataViewSpinRenderer::Render( wxRect rect, wxDC *dc, int state )
1282 {
1283     wxString str;
1284     str.Printf(wxT("%d"), (int) m_data );
1285     RenderText( str, 0, rect, dc, state );
1286     return true;
1287 }
1288
1289 wxSize wxDataViewSpinRenderer::GetSize() const
1290 {
1291     return wxSize(80,16);
1292 }
1293
1294 bool wxDataViewSpinRenderer::SetValue( const wxVariant &value )
1295 {
1296     m_data = value.GetLong();
1297     return true;
1298 }
1299
1300 bool wxDataViewSpinRenderer::GetValue( wxVariant &value ) const
1301 {
1302     value = m_data;
1303     return true;
1304 }
1305
1306 // -------------------------------------
1307 // wxDataViewChoiceRenderer
1308 // -------------------------------------
1309
1310 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXMAC__)
1311
1312 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString& choices, wxDataViewCellMode mode, int alignment ) :
1313    wxDataViewCustomRenderer(wxT("string"), mode, alignment )
1314 {
1315     m_choices = choices;
1316 }
1317
1318 wxControl* wxDataViewChoiceRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1319 {
1320     wxString s = value;
1321     wxSize size = labelRect.GetSize();
1322 #ifdef __WXMAC__
1323     size = wxSize( wxMax(70,labelRect.width ), -1 );
1324 #endif
1325     wxChoice *c = new wxChoice( parent, wxID_ANY, labelRect.GetTopLeft(), size, m_choices );
1326     c->SetStringSelection( value.GetString() );
1327
1328     return c;
1329 }
1330
1331 bool wxDataViewChoiceRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
1332 {
1333     wxChoice *c = (wxChoice*) editor;
1334     wxString s = c->GetStringSelection();
1335     value = s;
1336     return true;
1337 }
1338
1339 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
1340 {
1341     RenderText( m_data, 0, rect, dc, state );
1342     return true;
1343 }
1344
1345 wxSize wxDataViewChoiceRenderer::GetSize() const
1346 {
1347     return wxSize(80,16);
1348 }
1349
1350 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
1351 {
1352     m_data = value.GetString();
1353     return true;
1354 }
1355
1356 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
1357 {
1358     value = m_data;
1359     return true;
1360 }
1361
1362 #endif
1363
1364 //-----------------------------------------------------------------------------
1365 // wxDataViewListStore
1366 //-----------------------------------------------------------------------------
1367
1368 wxDataViewListStore::wxDataViewListStore()
1369 {
1370 }
1371
1372 wxDataViewListStore::~wxDataViewListStore()
1373 {
1374     wxVector<wxDataViewListStoreLine*>::iterator it;
1375     for (it = m_data.begin(); it != m_data.end(); ++it)
1376     {
1377         wxDataViewListStoreLine* line = *it;
1378         delete line;
1379     }
1380 }
1381
1382 void wxDataViewListStore::PrependColumn( const wxString &varianttype )
1383 {
1384     m_cols.Insert( varianttype, 0 );
1385 }
1386
1387 void wxDataViewListStore::InsertColumn( unsigned int pos, const wxString &varianttype )
1388 {
1389     m_cols.Insert( varianttype, pos );
1390 }
1391
1392 void wxDataViewListStore::AppendColumn( const wxString &varianttype )
1393 {
1394     m_cols.Add( varianttype );
1395 }
1396
1397 unsigned int wxDataViewListStore::GetColumnCount() const
1398 {
1399     return m_cols.GetCount();
1400 }
1401
1402 wxString wxDataViewListStore::GetColumnType( unsigned int pos ) const
1403 {
1404     return m_cols[pos];
1405 }
1406
1407 void wxDataViewListStore::AppendItem( const wxVector<wxVariant> &values, wxClientData *data )
1408 {
1409     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1410     line->m_values = values;
1411     m_data.push_back( line );
1412
1413     RowAppended();
1414 }
1415
1416 void wxDataViewListStore::PrependItem( const wxVector<wxVariant> &values, wxClientData *data )
1417 {
1418     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1419     line->m_values = values;
1420     m_data.insert( m_data.begin(), line );
1421
1422     RowPrepended();
1423 }
1424
1425 void wxDataViewListStore::InsertItem(  unsigned int row, const wxVector<wxVariant> &values, wxClientData *data )
1426 {
1427     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1428     line->m_values = values;
1429     m_data.insert( m_data.begin()+row, line );
1430
1431     RowInserted( row );
1432 }
1433
1434 void wxDataViewListStore::DeleteItem( unsigned row )
1435 {
1436     wxVector<wxDataViewListStoreLine*>::iterator it = m_data.begin() + row;
1437     m_data.erase( it );
1438
1439     RowDeleted( row );
1440 }
1441
1442 void wxDataViewListStore::DeleteAllItems()
1443 {
1444     wxVector<wxDataViewListStoreLine*>::iterator it;
1445     for (it = m_data.begin(); it != m_data.end(); ++it)
1446     {
1447         wxDataViewListStoreLine* line = *it;
1448         delete line;
1449     }
1450
1451     Reset( 0 );
1452 }
1453
1454 void wxDataViewListStore::GetValueByRow( wxVariant &value, unsigned int row, unsigned int col ) const
1455 {
1456     wxDataViewListStoreLine *line = m_data[row];
1457     value = line->m_values[col];
1458 }
1459
1460 bool wxDataViewListStore::SetValueByRow( const wxVariant &value, unsigned int row, unsigned int col )
1461 {
1462     wxDataViewListStoreLine *line = m_data[row];
1463     line->m_values[col] = value;
1464
1465     return true;
1466 }
1467
1468 //-----------------------------------------------------------------------------
1469 // wxDataViewListCtrl
1470 //-----------------------------------------------------------------------------
1471
1472 IMPLEMENT_DYNAMIC_CLASS(wxDataViewListCtrl,wxDataViewCtrl)
1473
1474 BEGIN_EVENT_TABLE(wxDataViewListCtrl,wxDataViewCtrl)
1475    EVT_SIZE( wxDataViewListCtrl::OnSize )
1476 END_EVENT_TABLE()
1477
1478 wxDataViewListCtrl::wxDataViewListCtrl()
1479 {
1480 }
1481
1482 wxDataViewListCtrl::wxDataViewListCtrl( wxWindow *parent, wxWindowID id,
1483            const wxPoint& pos, const wxSize& size, long style,
1484            const wxValidator& validator )
1485 {
1486     Create( parent, id, pos, size, style, validator );
1487
1488     wxDataViewListStore *store = new wxDataViewListStore;
1489     AssociateModel( store );
1490     store->DecRef();
1491 }
1492
1493 wxDataViewListCtrl::~wxDataViewListCtrl()
1494 {
1495 }
1496
1497
1498 bool wxDataViewListCtrl::Create( wxWindow *parent, wxWindowID id,
1499            const wxPoint& pos, const wxSize& size, long style,
1500            const wxValidator& validator )
1501 {
1502     return wxDataViewCtrl::Create( parent, id, pos, size, style, validator );
1503 }
1504
1505 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *column, const wxString &varianttype )
1506 {
1507     GetStore()->AppendColumn( varianttype );
1508     return wxDataViewCtrl::AppendColumn( column );
1509 }
1510
1511 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *column, const wxString &varianttype )
1512 {
1513     GetStore()->PrependColumn( varianttype );
1514     return wxDataViewCtrl::PrependColumn( column );
1515 }
1516
1517 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *column, const wxString &varianttype )
1518 {
1519     GetStore()->InsertColumn( pos, varianttype );
1520     return wxDataViewCtrl::InsertColumn( pos, column );
1521 }
1522
1523 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *col )
1524 {
1525     return PrependColumn( col, "string" );
1526 }
1527
1528 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
1529 {
1530     return InsertColumn( pos, col, "string" );
1531 }
1532
1533 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *col )
1534 {
1535     return AppendColumn( col, "string" );
1536 }
1537
1538 wxDataViewColumn *wxDataViewListCtrl::AppendTextColumn( const wxString &label,
1539           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1540 {
1541     GetStore()->AppendColumn( wxT("string") );
1542
1543     wxDataViewColumn *ret = new wxDataViewColumn( label,
1544         new wxDataViewTextRenderer( wxT("string"), mode ),
1545         GetStore()->GetColumnCount()-1, width, align, flags );
1546
1547     wxDataViewCtrl::AppendColumn( ret );
1548
1549     return ret;
1550 }
1551
1552 wxDataViewColumn *wxDataViewListCtrl::AppendToggleColumn( const wxString &label,
1553           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1554 {
1555     GetStore()->AppendColumn( wxT("bool") );
1556
1557     wxDataViewColumn *ret = new wxDataViewColumn( label,
1558         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1559         GetStore()->GetColumnCount()-1, width, align, flags );
1560
1561     wxDataViewCtrl::AppendColumn( ret );
1562
1563     return ret;
1564 }
1565
1566 wxDataViewColumn *wxDataViewListCtrl::AppendProgressColumn( const wxString &label,
1567           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1568 {
1569     GetStore()->AppendColumn( wxT("long") );
1570
1571     wxDataViewColumn *ret = new wxDataViewColumn( label,
1572         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1573         GetStore()->GetColumnCount()-1, width, align, flags );
1574
1575     wxDataViewCtrl::AppendColumn( ret );
1576
1577     return ret;
1578 }
1579
1580 wxDataViewColumn *wxDataViewListCtrl::AppendIconTextColumn( const wxString &label,
1581           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1582 {
1583     GetStore()->AppendColumn( wxT("wxDataViewIconText") );
1584
1585     wxDataViewColumn *ret = new wxDataViewColumn( label,
1586         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1587         GetStore()->GetColumnCount()-1, width, align, flags );
1588
1589     wxDataViewCtrl::AppendColumn( ret );
1590
1591     return ret;
1592 }
1593
1594 void wxDataViewListCtrl::OnSize( wxSizeEvent &event )
1595 {
1596     event.Skip( true );
1597 }
1598
1599 //-----------------------------------------------------------------------------
1600 // wxDataViewTreeStore
1601 //-----------------------------------------------------------------------------
1602
1603 wxDataViewTreeStoreNode::wxDataViewTreeStoreNode(
1604         wxDataViewTreeStoreNode *parent,
1605         const wxString &text, const wxIcon &icon, wxClientData *data )
1606 {
1607     m_parent = parent;
1608     m_text = text;
1609     m_icon = icon;
1610     m_data = data;
1611 }
1612
1613 wxDataViewTreeStoreNode::~wxDataViewTreeStoreNode()
1614 {
1615     if (m_data)
1616         delete m_data;
1617 }
1618
1619 #include "wx/listimpl.cpp"
1620 WX_DEFINE_LIST(wxDataViewTreeStoreNodeList)
1621
1622 wxDataViewTreeStoreContainerNode::wxDataViewTreeStoreContainerNode(
1623         wxDataViewTreeStoreNode *parent, const wxString &text,
1624         const wxIcon &icon, const wxIcon &expanded, wxClientData *data ) :
1625     wxDataViewTreeStoreNode( parent, text, icon, data )
1626 {
1627     m_iconExpanded = expanded;
1628     m_isExpanded = false;
1629     m_children.DeleteContents(true);
1630 }
1631
1632 wxDataViewTreeStoreContainerNode::~wxDataViewTreeStoreContainerNode()
1633 {
1634 }
1635
1636 //-----------------------------------------------------------------------------
1637
1638 wxDataViewTreeStore::wxDataViewTreeStore()
1639 {
1640     m_root = new wxDataViewTreeStoreContainerNode( NULL, wxEmptyString );
1641 }
1642
1643 wxDataViewTreeStore::~wxDataViewTreeStore()
1644 {
1645     delete m_root;
1646 }
1647
1648 wxDataViewItem wxDataViewTreeStore::AppendItem( const wxDataViewItem& parent,
1649         const wxString &text, const wxIcon &icon, wxClientData *data )
1650 {
1651     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1652     if (!parent_node) return wxDataViewItem(0);
1653
1654     wxDataViewTreeStoreNode *node =
1655         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1656     parent_node->GetChildren().Append( node );
1657
1658     return node->GetItem();
1659 }
1660
1661 wxDataViewItem wxDataViewTreeStore::PrependItem( const wxDataViewItem& parent,
1662         const wxString &text, const wxIcon &icon, wxClientData *data )
1663 {
1664     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1665     if (!parent_node) return wxDataViewItem(0);
1666
1667     wxDataViewTreeStoreNode *node =
1668         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1669     parent_node->GetChildren().Insert( node );
1670
1671     return node->GetItem();
1672 }
1673
1674 wxDataViewItem
1675 wxDataViewTreeStore::InsertItem(const wxDataViewItem& parent,
1676                                 const wxDataViewItem& previous,
1677                                 const wxString& text,
1678                                 const wxIcon& icon,
1679                                 wxClientData *data)
1680 {
1681     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1682     if (!parent_node) return wxDataViewItem(0);
1683
1684     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
1685     int pos = parent_node->GetChildren().IndexOf( previous_node );
1686     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
1687
1688     wxDataViewTreeStoreNode *node =
1689         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1690     parent_node->GetChildren().Insert( (size_t) pos, node );
1691
1692     return node->GetItem();
1693 }
1694
1695 wxDataViewItem wxDataViewTreeStore::PrependContainer( const wxDataViewItem& parent,
1696         const wxString &text, const wxIcon &icon, const wxIcon &expanded,
1697         wxClientData *data )
1698 {
1699     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1700     if (!parent_node) return wxDataViewItem(0);
1701
1702     wxDataViewTreeStoreContainerNode *node =
1703         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1704     parent_node->GetChildren().Insert( node );
1705
1706     return node->GetItem();
1707 }
1708
1709 wxDataViewItem
1710 wxDataViewTreeStore::AppendContainer(const wxDataViewItem& parent,
1711                                      const wxString &text,
1712                                      const wxIcon& icon,
1713                                      const wxIcon& expanded,
1714                                      wxClientData * data)
1715 {
1716     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1717     if (!parent_node) return wxDataViewItem(0);
1718
1719     wxDataViewTreeStoreContainerNode *node =
1720         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1721     parent_node->GetChildren().Append( node );
1722
1723     return node->GetItem();
1724 }
1725
1726 wxDataViewItem
1727 wxDataViewTreeStore::InsertContainer(const wxDataViewItem& parent,
1728                                      const wxDataViewItem& previous,
1729                                      const wxString& text,
1730                                      const wxIcon& icon,
1731                                      const wxIcon& expanded,
1732                                      wxClientData * data)
1733 {
1734     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1735     if (!parent_node) return wxDataViewItem(0);
1736
1737     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
1738     int pos = parent_node->GetChildren().IndexOf( previous_node );
1739     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
1740
1741     wxDataViewTreeStoreContainerNode *node =
1742         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1743     parent_node->GetChildren().Insert( (size_t) pos, node );
1744
1745     return node->GetItem();
1746 }
1747
1748 wxDataViewItem wxDataViewTreeStore::GetNthChild( const wxDataViewItem& parent, unsigned int pos ) const
1749 {
1750     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1751     if (!parent_node) return wxDataViewItem(0);
1752
1753     wxDataViewTreeStoreNodeList::compatibility_iterator node = parent_node->GetChildren().Item( pos );
1754     if (node)
1755         return node->GetData();
1756
1757     return wxDataViewItem(0);
1758 }
1759
1760 int wxDataViewTreeStore::GetChildCount( const wxDataViewItem& parent ) const
1761 {
1762     wxDataViewTreeStoreNode *node = FindNode( parent );
1763     if (!node) return -1;
1764
1765     if (!node->IsContainer())
1766         return 0;
1767
1768     wxDataViewTreeStoreContainerNode *container_node = (wxDataViewTreeStoreContainerNode*) node;
1769     return (int) container_node->GetChildren().GetCount();
1770 }
1771
1772 void wxDataViewTreeStore::SetItemText( const wxDataViewItem& item, const wxString &text )
1773 {
1774     wxDataViewTreeStoreNode *node = FindNode( item );
1775     if (!node) return;
1776
1777     node->SetText( text );
1778 }
1779
1780 wxString wxDataViewTreeStore::GetItemText( const wxDataViewItem& item ) const
1781 {
1782     wxDataViewTreeStoreNode *node = FindNode( item );
1783     if (!node) return wxEmptyString;
1784
1785     return node->GetText();
1786 }
1787
1788 void wxDataViewTreeStore::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
1789 {
1790     wxDataViewTreeStoreNode *node = FindNode( item );
1791     if (!node) return;
1792
1793     node->SetIcon( icon );
1794 }
1795
1796 const wxIcon &wxDataViewTreeStore::GetItemIcon( const wxDataViewItem& item ) const
1797 {
1798     wxDataViewTreeStoreNode *node = FindNode( item );
1799     if (!node) return wxNullIcon;
1800
1801     return node->GetIcon();
1802 }
1803
1804 void wxDataViewTreeStore::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
1805 {
1806     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1807     if (!node) return;
1808
1809     node->SetExpandedIcon( icon );
1810 }
1811
1812 const wxIcon &wxDataViewTreeStore::GetItemExpandedIcon( const wxDataViewItem& item ) const
1813 {
1814     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1815     if (!node) return wxNullIcon;
1816
1817     return node->GetExpandedIcon();
1818 }
1819
1820 void wxDataViewTreeStore::SetItemData( const wxDataViewItem& item, wxClientData *data )
1821 {
1822     wxDataViewTreeStoreNode *node = FindNode( item );
1823     if (!node) return;
1824
1825     node->SetData( data );
1826 }
1827
1828 wxClientData *wxDataViewTreeStore::GetItemData( const wxDataViewItem& item ) const
1829 {
1830     wxDataViewTreeStoreNode *node = FindNode( item );
1831     if (!node) return NULL;
1832
1833     return node->GetData();
1834 }
1835
1836 void wxDataViewTreeStore::DeleteItem( const wxDataViewItem& item )
1837 {
1838     if (!item.IsOk()) return;
1839
1840     wxDataViewItem parent_item = GetParent( item );
1841
1842     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent_item );
1843     if (!parent_node) return;
1844
1845     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1846     if (!node) return;
1847
1848     parent_node->GetChildren().DeleteObject( node );
1849 }
1850
1851 void wxDataViewTreeStore::DeleteChildren( const wxDataViewItem& item )
1852 {
1853     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1854     if (!node) return;
1855
1856     node->GetChildren().clear();
1857 }
1858
1859 void wxDataViewTreeStore::DeleteAllItems()
1860 {
1861     // TODO
1862 }
1863
1864 void
1865 wxDataViewTreeStore::GetValue(wxVariant &variant,
1866                               const wxDataViewItem &item,
1867                               unsigned int WXUNUSED(col)) const
1868 {
1869     // if (col != 0) return;
1870
1871     wxDataViewTreeStoreNode *node = FindNode( item );
1872     if (!node) return;
1873
1874     wxIcon icon( node->GetIcon());
1875     if (node->IsContainer())
1876     {
1877         wxDataViewTreeStoreContainerNode *container = (wxDataViewTreeStoreContainerNode*) node;
1878         if (container->IsExpanded() && container->GetExpandedIcon().IsOk())
1879            icon = container->GetExpandedIcon();
1880     }
1881
1882     wxDataViewIconText data( node->GetText(), icon );
1883
1884     variant << data;
1885 }
1886
1887 bool
1888 wxDataViewTreeStore::SetValue(const wxVariant& variant,
1889                               const wxDataViewItem& item,
1890                               unsigned int WXUNUSED(col))
1891 {
1892     // if (col != 0) return false;
1893
1894     wxDataViewTreeStoreNode *node = FindNode( item );
1895     if (!node) return false;
1896
1897     wxDataViewIconText data;
1898
1899     data << variant;
1900
1901     node->SetText( data.GetText() );
1902     node->SetIcon( data.GetIcon() );
1903
1904     return true;
1905 }
1906
1907 wxDataViewItem wxDataViewTreeStore::GetParent( const wxDataViewItem &item ) const
1908 {
1909     wxDataViewTreeStoreNode *node = FindNode( item );
1910     if (!node) return wxDataViewItem(0);
1911
1912     wxDataViewTreeStoreNode *parent = node->GetParent();
1913     if (!parent) return wxDataViewItem(0);
1914
1915     if (parent == m_root)
1916         return wxDataViewItem(0);
1917
1918     return parent->GetItem();
1919 }
1920
1921 bool wxDataViewTreeStore::IsContainer( const wxDataViewItem &item ) const
1922 {
1923     wxDataViewTreeStoreNode *node = FindNode( item );
1924     if (!node) return false;
1925
1926     return node->IsContainer();
1927 }
1928
1929 unsigned int wxDataViewTreeStore::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
1930 {
1931     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1932     if (!node) return 0;
1933
1934     wxDataViewTreeStoreNodeList::iterator iter;
1935     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
1936     {
1937         wxDataViewTreeStoreNode* child = *iter;
1938         children.Add( child->GetItem() );
1939     }
1940
1941     return node->GetChildren().GetCount();
1942 }
1943
1944 int wxDataViewTreeStore::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
1945                          unsigned int WXUNUSED(column), bool WXUNUSED(ascending) )
1946 {
1947     wxDataViewTreeStoreNode *node1 = FindNode( item1 );
1948     wxDataViewTreeStoreNode *node2 = FindNode( item2 );
1949
1950     if (!node1 || !node2)
1951         return 0;
1952
1953     wxDataViewTreeStoreContainerNode* parent1 =
1954         (wxDataViewTreeStoreContainerNode*) node1->GetParent();
1955     wxDataViewTreeStoreContainerNode* parent2 =
1956         (wxDataViewTreeStoreContainerNode*) node2->GetParent();
1957
1958     if (parent1 != parent2)
1959     {
1960         wxLogError( wxT("Comparing items with different parent.") );
1961         return 0;
1962     }
1963
1964     if (node1->IsContainer() && !!node2->IsContainer())
1965         return 1;
1966
1967     if (node2->IsContainer() && !!node1->IsContainer())
1968         return -1;
1969
1970     return parent1->GetChildren().IndexOf( node1 ) - parent1->GetChildren().IndexOf( node2 );
1971 }
1972
1973 wxDataViewTreeStoreNode *wxDataViewTreeStore::FindNode( const wxDataViewItem &item ) const
1974 {
1975     if (!item.IsOk())
1976         return m_root;
1977
1978     return (wxDataViewTreeStoreNode*) item.GetID();
1979 }
1980
1981 wxDataViewTreeStoreContainerNode *wxDataViewTreeStore::FindContainerNode( const wxDataViewItem &item ) const
1982 {
1983     if (!item.IsOk())
1984         return (wxDataViewTreeStoreContainerNode*) m_root;
1985
1986     wxDataViewTreeStoreNode* node = (wxDataViewTreeStoreNode*) item.GetID();
1987
1988     if (!node->IsContainer())
1989         return NULL;
1990
1991     return (wxDataViewTreeStoreContainerNode*) node;
1992 }
1993
1994 //-----------------------------------------------------------------------------
1995 // wxDataViewTreeCtrl
1996 //-----------------------------------------------------------------------------
1997
1998 IMPLEMENT_DYNAMIC_CLASS(wxDataViewTreeCtrl,wxDataViewCtrl)
1999
2000 BEGIN_EVENT_TABLE(wxDataViewTreeCtrl,wxDataViewCtrl)
2001    EVT_DATAVIEW_ITEM_EXPANDED(-1, wxDataViewTreeCtrl::OnExpanded)
2002    EVT_DATAVIEW_ITEM_COLLAPSED(-1, wxDataViewTreeCtrl::OnCollapsed)
2003    EVT_SIZE( wxDataViewTreeCtrl::OnSize )
2004 END_EVENT_TABLE()
2005
2006 wxDataViewTreeCtrl::wxDataViewTreeCtrl()
2007 {
2008     m_imageList = NULL;
2009 }
2010
2011 wxDataViewTreeCtrl::wxDataViewTreeCtrl( wxWindow *parent, wxWindowID id,
2012            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2013 {
2014     m_imageList = NULL;
2015     Create( parent, id, pos, size, style, validator );
2016
2017     wxDataViewTreeStore *store = new wxDataViewTreeStore;
2018     AssociateModel( store );
2019     store->DecRef();
2020
2021     AppendIconTextColumn(wxString(),0,wxDATAVIEW_CELL_INERT,-1);
2022 }
2023
2024 wxDataViewTreeCtrl::~wxDataViewTreeCtrl()
2025 {
2026     if (m_imageList)
2027         delete m_imageList;
2028 }
2029
2030 bool wxDataViewTreeCtrl::Create( wxWindow *parent, wxWindowID id,
2031            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2032 {
2033     return wxDataViewCtrl::Create( parent, id, pos, size, style, validator );
2034 }
2035
2036 void wxDataViewTreeCtrl::SetImageList( wxImageList *imagelist )
2037 {
2038     if (m_imageList)
2039         delete m_imageList;
2040
2041     m_imageList = imagelist;
2042 }
2043
2044 wxDataViewItem wxDataViewTreeCtrl::AppendItem( const wxDataViewItem& parent,
2045         const wxString &text, int iconIndex, wxClientData *data )
2046 {
2047     wxIcon icon = wxNullIcon;
2048     if (m_imageList && (iconIndex != -1))
2049         icon = m_imageList->GetIcon( iconIndex );
2050
2051     wxDataViewItem res = GetStore()->AppendItem( parent, text, icon, data );
2052
2053     GetStore()->ItemAdded( parent, res );
2054
2055     return res;
2056 }
2057
2058 wxDataViewItem wxDataViewTreeCtrl::PrependItem( const wxDataViewItem& parent,
2059         const wxString &text, int iconIndex, wxClientData *data )
2060 {
2061     wxIcon icon = wxNullIcon;
2062     if (m_imageList && (iconIndex != -1))
2063         icon = m_imageList->GetIcon( iconIndex );
2064
2065     wxDataViewItem res = GetStore()->PrependItem( parent, text, icon, data );
2066
2067     GetStore()->ItemAdded( parent, res );
2068
2069     return res;
2070 }
2071
2072 wxDataViewItem wxDataViewTreeCtrl::InsertItem( const wxDataViewItem& parent, const wxDataViewItem& previous,
2073         const wxString &text, int iconIndex, wxClientData *data )
2074 {
2075     wxIcon icon = wxNullIcon;
2076     if (m_imageList && (iconIndex != -1))
2077         icon = m_imageList->GetIcon( iconIndex );
2078
2079     wxDataViewItem res = GetStore()->InsertItem( parent, previous, text, icon, data );
2080
2081     GetStore()->ItemAdded( parent, res );
2082
2083     return res;
2084 }
2085
2086 wxDataViewItem wxDataViewTreeCtrl::PrependContainer( const wxDataViewItem& parent,
2087         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2088 {
2089     wxIcon icon = wxNullIcon;
2090     if (m_imageList && (iconIndex != -1))
2091         icon = m_imageList->GetIcon( iconIndex );
2092
2093     wxIcon expanded = wxNullIcon;
2094     if (m_imageList && (expandedIndex != -1))
2095         expanded = m_imageList->GetIcon( expandedIndex );
2096
2097     wxDataViewItem res = GetStore()->PrependContainer( parent, text, icon, expanded, data );
2098
2099     GetStore()->ItemAdded( parent, res );
2100
2101     return res;
2102 }
2103
2104 wxDataViewItem wxDataViewTreeCtrl::AppendContainer( const wxDataViewItem& parent,
2105         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2106 {
2107     wxIcon icon = wxNullIcon;
2108     if (m_imageList && (iconIndex != -1))
2109         icon = m_imageList->GetIcon( iconIndex );
2110
2111     wxIcon expanded = wxNullIcon;
2112     if (m_imageList && (expandedIndex != -1))
2113         expanded = m_imageList->GetIcon( expandedIndex );
2114
2115     wxDataViewItem res = GetStore()->AppendContainer( parent, text, icon, expanded, data );
2116
2117     GetStore()->ItemAdded( parent, res );
2118
2119     return res;
2120 }
2121
2122 wxDataViewItem wxDataViewTreeCtrl::InsertContainer( const wxDataViewItem& parent, const wxDataViewItem& previous,
2123         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2124 {
2125     wxIcon icon = wxNullIcon;
2126     if (m_imageList && (iconIndex != -1))
2127         icon = m_imageList->GetIcon( iconIndex );
2128
2129     wxIcon expanded = wxNullIcon;
2130     if (m_imageList && (expandedIndex != -1))
2131         expanded = m_imageList->GetIcon( expandedIndex );
2132
2133     wxDataViewItem res = GetStore()->InsertContainer( parent, previous, text, icon, expanded, data );
2134
2135     GetStore()->ItemAdded( parent, res );
2136
2137     return res;
2138 }
2139
2140 void wxDataViewTreeCtrl::SetItemText( const wxDataViewItem& item, const wxString &text )
2141 {
2142     GetStore()->SetItemText(item,text);
2143
2144     // notify control
2145     GetStore()->ValueChanged( item, 0 );
2146 }
2147
2148 void wxDataViewTreeCtrl::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2149 {
2150     GetStore()->SetItemIcon(item,icon);
2151
2152     // notify control
2153     GetStore()->ValueChanged( item, 0 );
2154 }
2155
2156 void wxDataViewTreeCtrl::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2157 {
2158     GetStore()->SetItemExpandedIcon(item,icon);
2159
2160     // notify control
2161     GetStore()->ValueChanged( item, 0 );
2162 }
2163
2164 void wxDataViewTreeCtrl::DeleteItem( const wxDataViewItem& item )
2165 {
2166     wxDataViewItem parent_item = GetStore()->GetParent( item );
2167
2168     GetStore()->DeleteItem(item);
2169
2170     // notify control
2171     GetStore()->ItemDeleted( parent_item, item );
2172 }
2173
2174 void wxDataViewTreeCtrl::DeleteChildren( const wxDataViewItem& item )
2175 {
2176     wxDataViewTreeStoreContainerNode *node = GetStore()->FindContainerNode( item );
2177     if (!node) return;
2178
2179     wxDataViewItemArray array;
2180     wxDataViewTreeStoreNodeList::iterator iter;
2181     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2182     {
2183         wxDataViewTreeStoreNode* child = *iter;
2184         array.Add( child->GetItem() );
2185     }
2186
2187     GetStore()->DeleteChildren( item );
2188
2189     // notify control
2190     GetStore()->ItemsDeleted( item, array );
2191 }
2192
2193 void  wxDataViewTreeCtrl::DeleteAllItems()
2194 {
2195     GetStore()->DeleteAllItems();
2196
2197     GetStore()->Cleared();
2198 }
2199
2200 void wxDataViewTreeCtrl::OnExpanded( wxDataViewEvent &event )
2201 {
2202     if (m_imageList) return;
2203
2204     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2205     if (!container) return;
2206
2207     container->SetExpanded( true );
2208
2209     GetStore()->ItemChanged( event.GetItem() );
2210 }
2211
2212 void wxDataViewTreeCtrl::OnCollapsed( wxDataViewEvent &event )
2213 {
2214     if (m_imageList) return;
2215
2216     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2217     if (!container) return;
2218
2219     container->SetExpanded( false );
2220
2221     GetStore()->ItemChanged( event.GetItem() );
2222 }
2223
2224 void wxDataViewTreeCtrl::OnSize( wxSizeEvent &event )
2225 {
2226 #if defined(wxUSE_GENERICDATAVIEWCTRL)
2227     // automatically resize our only column to take the entire control width
2228     if ( GetColumnCount() )
2229     {
2230         wxSize size = GetClientSize();
2231         GetColumn(0)->SetWidth(size.x);
2232     }
2233 #endif
2234     event.Skip( true );
2235 }
2236
2237 #endif // wxUSE_DATAVIEWCTRL
2238