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