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