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