src/common/datavcmn.cpp

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