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