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