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     m_editorCtrl = NULL;
 747 }
 748
 749 void wxDataViewRendererBase::CancelEditing()
 750 {
 751     if (!m_editorCtrl)
 752         return;
 753
 754     DestroyEditControl();
 755 }
 756
 757 bool wxDataViewRendererBase::FinishEditing()
 758 {
 759     if (!m_editorCtrl)
 760         return true;
 761
 762     wxVariant value;
 763     GetValueFromEditorCtrl( m_editorCtrl, value );
 764
 765     wxDataViewCtrl* dv_ctrl = GetOwner()->GetOwner();
 766
 767     DestroyEditControl();
 768
 769     dv_ctrl->GetMainWindow()->SetFocus();
 770
 771     bool isValid = Validate(value);
 772     unsigned int col = GetOwner()->GetModelColumn();
 773
 774     // Now we should send Editing Done event
 775     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv_ctrl->GetId() );
 776     event.SetDataViewColumn( GetOwner() );
 777     event.SetModel( dv_ctrl->GetModel() );
 778     event.SetItem( m_item );
 779     event.SetValue( value );
 780     event.SetColumn( col );
 781     event.SetEditCanceled( !isValid );
 782     event.SetEventObject( dv_ctrl );
 783     dv_ctrl->GetEventHandler()->ProcessEvent( event );
 784
 785     if ( isValid && event.IsAllowed() )
 786     {
 787         dv_ctrl->GetModel()->ChangeValue(value, m_item, col);
 788         return true;
 789     }
 790
 791     return false;
 792 }
 793
 794 void wxDataViewRendererBase::PrepareForItem(const wxDataViewModel *model,
 795                                             const wxDataViewItem& item,
 796                                             unsigned column)
 797 {
 798     wxVariant value;
 799     model->GetValue(value, item, column);
 800     SetValue(value);
 801
 802     wxDataViewItemAttr attr;
 803     model->GetAttr(item, column, attr);
 804     SetAttr(attr);
 805
 806     SetEnabled(model->IsEnabled(item, column));
 807 }
 808
 809
 810 // ----------------------------------------------------------------------------
 811 // wxDataViewCustomRendererBase
 812 // ----------------------------------------------------------------------------
 813
 814 bool wxDataViewCustomRendererBase::ActivateCell(const wxRect& cell,
 815                                                 wxDataViewModel *model,
 816                                                 const wxDataViewItem & item,
 817                                                 unsigned int col,
 818                                                 const wxMouseEvent* mouseEvent)
 819 {
 820     // Compatibility code
 821     if ( mouseEvent )
 822         return LeftClick(mouseEvent->GetPosition(), cell, model, item, col);
 823     else
 824         return Activate(cell, model, item, col);
 825 }
 826
 827 void
 828 wxDataViewCustomRendererBase::WXCallRender(wxRect rectCell, wxDC *dc, int state)
 829 {
 830     wxCHECK_RET( dc, "no DC to draw on in custom renderer?" );
 831
 832     // adjust the rectangle ourselves to account for the alignment
 833     wxRect rectItem = rectCell;
 834     const int align = GetAlignment();
 835     if ( align != wxDVR_DEFAULT_ALIGNMENT )
 836     {
 837         const wxSize size = GetSize();
 838
 839         // take alignment into account only if there is enough space, otherwise
 840         // show as much contents as possible
 841         //
 842         // notice that many existing renderers (e.g. wxDataViewSpinRenderer)
 843         // return hard-coded size which can be more than they need and if we
 844         // trusted their GetSize() we'd draw the text out of cell bounds
 845         // entirely
 846
 847         if ( size.x >= 0 && size.x < rectCell.width )
 848         {
 849             if ( align & wxALIGN_CENTER_HORIZONTAL )
 850                 rectItem.x += (rectCell.width - size.x)/2;
 851             else if ( align & wxALIGN_RIGHT )
 852                 rectItem.x += rectCell.width - size.x;
 853             // else: wxALIGN_LEFT is the default
 854
 855             rectItem.width = size.x;
 856         }
 857
 858         if ( size.y >= 0 && size.y < rectCell.height )
 859         {
 860             if ( align & wxALIGN_CENTER_VERTICAL )
 861                 rectItem.y += (rectCell.height - size.y)/2;
 862             else if ( align & wxALIGN_BOTTOM )
 863                 rectItem.y += rectCell.height - size.y;
 864             // else: wxALIGN_TOP is the default
 865
 866             rectItem.height = size.y;
 867         }
 868     }
 869
 870
 871     // set up the DC attributes
 872
 873     // override custom foreground with the standard one for the selected items
 874     // because we currently don't allow changing the selection background and
 875     // custom colours may be unreadable on it
 876     wxColour col;
 877     if ( state & wxDATAVIEW_CELL_SELECTED )
 878         col = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
 879     else if ( m_attr.HasColour() )
 880         col = m_attr.GetColour();
 881     else // use default foreground
 882         col = GetOwner()->GetOwner()->GetForegroundColour();
 883
 884     wxDCTextColourChanger changeFg(*dc, col);
 885
 886     wxDCFontChanger changeFont(*dc);
 887     if ( m_attr.HasFont() )
 888         changeFont.Set(m_attr.GetEffectiveFont(dc->GetFont()));
 889
 890     Render(rectItem, dc, state);
 891 }
 892
 893 wxSize wxDataViewCustomRendererBase::GetTextExtent(const wxString& str) const
 894 {
 895     const wxDataViewCtrl *view = GetView();
 896
 897     if ( m_attr.HasFont() )
 898     {
 899         wxFont font(m_attr.GetEffectiveFont(view->GetFont()));
 900         wxSize size;
 901         view->GetTextExtent(str, &size.x, &size.y, NULL, NULL, &font);
 902         return size;
 903     }
 904     else
 905     {
 906         return view->GetTextExtent(str);
 907     }
 908 }
 909
 910 void
 911 wxDataViewCustomRendererBase::RenderText(const wxString& text,
 912                                          int xoffset,
 913                                          wxRect rect,
 914                                          wxDC *dc,
 915                                          int WXUNUSED(state))
 916 {
 917     wxRect rectText = rect;
 918     rectText.x += xoffset;
 919     rectText.width -= xoffset;
 920
 921     // check if we want to ellipsize the text if it doesn't fit
 922     wxString ellipsizedText;
 923     if ( GetEllipsizeMode() != wxELLIPSIZE_NONE )
 924     {
 925         ellipsizedText = wxControl::Ellipsize
 926                                     (
 927                                         text,
 928                                         *dc,
 929                                         GetEllipsizeMode(),
 930                                         rectText.width,
 931                                         wxELLIPSIZE_FLAGS_NONE
 932                                     );
 933     }
 934
 935     // get the alignment to use
 936     int align = GetAlignment();
 937     if ( align == wxDVR_DEFAULT_ALIGNMENT )
 938     {
 939         // if we don't have an explicit alignment ourselves, use that of the
 940         // column in horizontal direction and default vertical alignment
 941         align = GetOwner()->GetAlignment() | wxALIGN_CENTRE_VERTICAL;
 942     }
 943
 944     dc->DrawLabel(ellipsizedText.empty() ? text : ellipsizedText,
 945                   rectText, align);
 946 }
 947
 948 //-----------------------------------------------------------------------------
 949 // wxDataViewEditorCtrlEvtHandler
 950 //-----------------------------------------------------------------------------
 951
 952 BEGIN_EVENT_TABLE(wxDataViewEditorCtrlEvtHandler, wxEvtHandler)
 953     EVT_CHAR           (wxDataViewEditorCtrlEvtHandler::OnChar)
 954     EVT_KILL_FOCUS     (wxDataViewEditorCtrlEvtHandler::OnKillFocus)
 955     EVT_IDLE           (wxDataViewEditorCtrlEvtHandler::OnIdle)
 956     EVT_TEXT_ENTER     (-1, wxDataViewEditorCtrlEvtHandler::OnTextEnter)
 957 END_EVENT_TABLE()
 958
 959 void wxDataViewEditorCtrlEvtHandler::OnIdle( wxIdleEvent &event )
 960 {
 961     if (m_focusOnIdle)
 962     {
 963         m_focusOnIdle = false;
 964         if (wxWindow::FindFocus() != m_editorCtrl)
 965             m_editorCtrl->SetFocus();
 966     }
 967
 968     event.Skip();
 969 }
 970
 971 void wxDataViewEditorCtrlEvtHandler::OnTextEnter( wxCommandEvent &WXUNUSED(event) )
 972 {
 973     m_finished = true;
 974     m_owner->FinishEditing();
 975 }
 976
 977 void wxDataViewEditorCtrlEvtHandler::OnChar( wxKeyEvent &event )
 978 {
 979     switch ( event.m_keyCode )
 980     {
 981         case WXK_RETURN:
 982             m_finished = true;
 983             m_owner->FinishEditing();
 984             break;
 985
 986         case WXK_ESCAPE:
 987         {
 988             m_finished = true;
 989             m_owner->CancelEditing();
 990             break;
 991         }
 992         default:
 993             event.Skip();
 994     }
 995 }
 996
 997 void wxDataViewEditorCtrlEvtHandler::OnKillFocus( wxFocusEvent &event )
 998 {
 999     if (!m_finished)
1000     {
1001         m_finished = true;
1002         m_owner->FinishEditing();
1003     }
1004
1005     event.Skip();
1006 }
1007
1008 // ---------------------------------------------------------
1009 // wxDataViewColumnBase
1010 // ---------------------------------------------------------
1011
1012 void wxDataViewColumnBase::Init(wxDataViewRenderer *renderer,
1013                                 unsigned int model_column)
1014 {
1015     m_renderer = renderer;
1016     m_model_column = model_column;
1017     m_owner = NULL;
1018     m_renderer->SetOwner( (wxDataViewColumn*) this );
1019 }
1020
1021 wxDataViewColumnBase::~wxDataViewColumnBase()
1022 {
1023     delete m_renderer;
1024 }
1025
1026 // ---------------------------------------------------------
1027 // wxDataViewCtrlBase
1028 // ---------------------------------------------------------
1029
1030 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)
1031
1032 wxDataViewCtrlBase::wxDataViewCtrlBase()
1033 {
1034     m_model = NULL;
1035     m_expander_column = 0;
1036     m_indent = 8;
1037 }
1038
1039 wxDataViewCtrlBase::~wxDataViewCtrlBase()
1040 {
1041     if (m_model)
1042     {
1043         m_model->DecRef();
1044         m_model = NULL;
1045     }
1046 }
1047
1048 bool wxDataViewCtrlBase::AssociateModel( wxDataViewModel *model )
1049 {
1050     if (m_model)
1051     {
1052         m_model->DecRef();   // discard old model, if any
1053     }
1054
1055     // add our own reference to the new model:
1056     m_model = model;
1057     if (m_model)
1058     {
1059         m_model->IncRef();
1060     }
1061
1062     return true;
1063 }
1064
1065 wxDataViewModel* wxDataViewCtrlBase::GetModel()
1066 {
1067     return m_model;
1068 }
1069
1070 const wxDataViewModel* wxDataViewCtrlBase::GetModel() const
1071 {
1072     return m_model;
1073 }
1074
1075 void wxDataViewCtrlBase::ExpandAncestors( const wxDataViewItem & item )
1076 {
1077     if (!m_model) return;
1078
1079     if (!item.IsOk()) return;
1080
1081     wxVector<wxDataViewItem> parentChain;
1082
1083     // at first we get all the parents of the selected item
1084     wxDataViewItem parent = m_model->GetParent(item);
1085     while (parent.IsOk())
1086     {
1087         parentChain.push_back(parent);
1088         parent = m_model->GetParent(parent);
1089     }
1090
1091     // then we expand the parents, starting at the root
1092     while (!parentChain.empty())
1093     {
1094          Expand(parentChain.back());
1095          parentChain.pop_back();
1096     }
1097 }
1098
1099 wxDataViewItem wxDataViewCtrlBase::GetCurrentItem() const
1100 {
1101     return HasFlag(wxDV_MULTIPLE) ? DoGetCurrentItem()
1102                                   : GetSelection();
1103 }
1104
1105 void wxDataViewCtrlBase::SetCurrentItem(const wxDataViewItem& item)
1106 {
1107     wxCHECK_RET( item.IsOk(), "Can't make current an invalid item." );
1108
1109     if ( HasFlag(wxDV_MULTIPLE) )
1110         DoSetCurrentItem(item);
1111     else
1112         Select(item);
1113 }
1114
1115 wxDataViewItem wxDataViewCtrlBase::GetSelection() const
1116 {
1117     if ( GetSelectedItemsCount() != 1 )
1118         return wxDataViewItem();
1119
1120     wxDataViewItemArray selections;
1121     GetSelections(selections);
1122     return selections[0];
1123 }
1124
1125 wxDataViewColumn *
1126 wxDataViewCtrlBase::AppendTextColumn( const wxString &label, unsigned int model_column,
1127                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1128 {
1129     wxDataViewColumn *ret = new wxDataViewColumn( label,
1130         new wxDataViewTextRenderer( wxT("string"), mode ),
1131         model_column, width, align, flags );
1132     AppendColumn( ret );
1133     return ret;
1134 }
1135
1136 wxDataViewColumn *
1137 wxDataViewCtrlBase::AppendIconTextColumn( const wxString &label, unsigned int model_column,
1138                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1139 {
1140     wxDataViewColumn *ret = new wxDataViewColumn( label,
1141         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1142         model_column, width, align, flags );
1143     AppendColumn( ret );
1144     return ret;
1145 }
1146
1147 wxDataViewColumn *
1148 wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, unsigned int model_column,
1149                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1150 {
1151     wxDataViewColumn *ret = new wxDataViewColumn( label,
1152         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1153         model_column, width, align, flags );
1154     AppendColumn( ret );
1155     return ret;
1156 }
1157
1158 wxDataViewColumn *
1159 wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, unsigned int model_column,
1160                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1161 {
1162     wxDataViewColumn *ret = new wxDataViewColumn( label,
1163         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1164         model_column, width, align, flags );
1165     AppendColumn( ret );
1166     return ret;
1167 }
1168
1169 wxDataViewColumn *
1170 wxDataViewCtrlBase::AppendDateColumn( const wxString &label, unsigned int model_column,
1171                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1172 {
1173     wxDataViewColumn *ret = new wxDataViewColumn( label,
1174         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1175         model_column, width, align, flags );
1176     AppendColumn( ret );
1177     return ret;
1178 }
1179
1180 wxDataViewColumn *
1181 wxDataViewCtrlBase::AppendBitmapColumn( const wxString &label, unsigned int model_column,
1182                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1183 {
1184     wxDataViewColumn *ret = new wxDataViewColumn( label,
1185         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1186         model_column, width, align, flags );
1187     AppendColumn( ret );
1188     return ret;
1189 }
1190
1191 wxDataViewColumn *
1192 wxDataViewCtrlBase::AppendTextColumn( const wxBitmap &label, unsigned int model_column,
1193                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1194 {
1195     wxDataViewColumn *ret = new wxDataViewColumn( label,
1196         new wxDataViewTextRenderer( wxT("string"), mode ),
1197         model_column, width, align, flags );
1198     AppendColumn( ret );
1199     return ret;
1200 }
1201
1202 wxDataViewColumn *
1203 wxDataViewCtrlBase::AppendIconTextColumn( const wxBitmap &label, unsigned int model_column,
1204                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1205 {
1206     wxDataViewColumn *ret = new wxDataViewColumn( label,
1207         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1208         model_column, width, align, flags );
1209     AppendColumn( ret );
1210     return ret;
1211 }
1212
1213 wxDataViewColumn *
1214 wxDataViewCtrlBase::AppendToggleColumn( const wxBitmap &label, unsigned int model_column,
1215                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1216 {
1217     wxDataViewColumn *ret = new wxDataViewColumn( label,
1218         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1219         model_column, width, align, flags );
1220     AppendColumn( ret );
1221     return ret;
1222 }
1223
1224 wxDataViewColumn *
1225 wxDataViewCtrlBase::AppendProgressColumn( const wxBitmap &label, unsigned int model_column,
1226                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1227 {
1228     wxDataViewColumn *ret = new wxDataViewColumn( label,
1229         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1230         model_column, width, align, flags );
1231     AppendColumn( ret );
1232     return ret;
1233 }
1234
1235 wxDataViewColumn *
1236 wxDataViewCtrlBase::AppendDateColumn( const wxBitmap &label, unsigned int model_column,
1237                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1238 {
1239     wxDataViewColumn *ret = new wxDataViewColumn( label,
1240         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1241         model_column, width, align, flags );
1242     AppendColumn( ret );
1243     return ret;
1244 }
1245
1246 wxDataViewColumn *
1247 wxDataViewCtrlBase::AppendBitmapColumn( const wxBitmap &label, unsigned int model_column,
1248                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1249 {
1250     wxDataViewColumn *ret = new wxDataViewColumn( label,
1251         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1252         model_column, width, align, flags );
1253     AppendColumn( ret );
1254     return ret;
1255 }
1256
1257 wxDataViewColumn *
1258 wxDataViewCtrlBase::PrependTextColumn( const wxString &label, unsigned int model_column,
1259                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1260 {
1261     wxDataViewColumn *ret = new wxDataViewColumn( label,
1262         new wxDataViewTextRenderer( wxT("string"), mode ),
1263         model_column, width, align, flags );
1264     PrependColumn( ret );
1265     return ret;
1266 }
1267
1268 wxDataViewColumn *
1269 wxDataViewCtrlBase::PrependIconTextColumn( const wxString &label, unsigned int model_column,
1270                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1271 {
1272     wxDataViewColumn *ret = new wxDataViewColumn( label,
1273         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1274         model_column, width, align, flags );
1275     PrependColumn( ret );
1276     return ret;
1277 }
1278
1279 wxDataViewColumn *
1280 wxDataViewCtrlBase::PrependToggleColumn( const wxString &label, unsigned int model_column,
1281                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1282 {
1283
1284     wxDataViewColumn *ret = new wxDataViewColumn( label,
1285         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1286         model_column, width, align, flags );
1287     PrependColumn( ret );
1288     return ret;
1289 }
1290
1291 wxDataViewColumn *
1292 wxDataViewCtrlBase::PrependProgressColumn( const wxString &label, unsigned int model_column,
1293                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1294 {
1295     wxDataViewColumn *ret = new wxDataViewColumn( label,
1296         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1297         model_column, width, align, flags );
1298     PrependColumn( ret );
1299     return ret;
1300 }
1301
1302 wxDataViewColumn *
1303 wxDataViewCtrlBase::PrependDateColumn( const wxString &label, unsigned int model_column,
1304                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1305 {
1306     wxDataViewColumn *ret = new wxDataViewColumn( label,
1307         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1308         model_column, width, align, flags );
1309     PrependColumn( ret );
1310     return ret;
1311 }
1312
1313 wxDataViewColumn *
1314 wxDataViewCtrlBase::PrependBitmapColumn( const wxString &label, unsigned int model_column,
1315                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1316 {
1317     wxDataViewColumn *ret = new wxDataViewColumn( label,
1318         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1319         model_column, width, align, flags );
1320     PrependColumn( ret );
1321     return ret;
1322 }
1323
1324 wxDataViewColumn *
1325 wxDataViewCtrlBase::PrependTextColumn( const wxBitmap &label, unsigned int model_column,
1326                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1327 {
1328     wxDataViewColumn *ret = new wxDataViewColumn( label,
1329         new wxDataViewTextRenderer( wxT("string"), mode ),
1330         model_column, width, align, flags );
1331     PrependColumn( ret );
1332     return ret;
1333 }
1334
1335 wxDataViewColumn *
1336 wxDataViewCtrlBase::PrependIconTextColumn( const wxBitmap &label, unsigned int model_column,
1337                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1338 {
1339     wxDataViewColumn *ret = new wxDataViewColumn( label,
1340         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1341         model_column, width, align, flags );
1342     PrependColumn( ret );
1343     return ret;
1344 }
1345
1346 wxDataViewColumn *
1347 wxDataViewCtrlBase::PrependToggleColumn( const wxBitmap &label, unsigned int model_column,
1348                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1349 {
1350     wxDataViewColumn *ret = new wxDataViewColumn( label,
1351         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1352         model_column, width, align, flags );
1353     PrependColumn( ret );
1354     return ret;
1355 }
1356
1357 wxDataViewColumn *
1358 wxDataViewCtrlBase::PrependProgressColumn( const wxBitmap &label, unsigned int model_column,
1359                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1360 {
1361     wxDataViewColumn *ret = new wxDataViewColumn( label,
1362         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1363         model_column, width, align, flags );
1364     PrependColumn( ret );
1365     return ret;
1366 }
1367
1368 wxDataViewColumn *
1369 wxDataViewCtrlBase::PrependDateColumn( const wxBitmap &label, unsigned int model_column,
1370                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1371 {
1372     wxDataViewColumn *ret = new wxDataViewColumn( label,
1373         new wxDataViewDateRenderer( wxT("datetime"), mode ),
1374         model_column, width, align, flags );
1375     PrependColumn( ret );
1376     return ret;
1377 }
1378
1379 wxDataViewColumn *
1380 wxDataViewCtrlBase::PrependBitmapColumn( const wxBitmap &label, unsigned int model_column,
1381                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1382 {
1383     wxDataViewColumn *ret = new wxDataViewColumn( label,
1384         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode ),
1385         model_column, width, align, flags );
1386     PrependColumn( ret );
1387     return ret;
1388 }
1389
1390 bool
1391 wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
1392 {
1393     col->SetOwner( (wxDataViewCtrl*) this );
1394     return true;
1395 }
1396
1397 bool
1398 wxDataViewCtrlBase::PrependColumn( wxDataViewColumn *col )
1399 {
1400     col->SetOwner( (wxDataViewCtrl*) this );
1401     return true;
1402 }
1403
1404 bool
1405 wxDataViewCtrlBase::InsertColumn( unsigned int WXUNUSED(pos), wxDataViewColumn *col )
1406 {
1407     col->SetOwner( (wxDataViewCtrl*) this );
1408     return true;
1409 }
1410
1411 // ---------------------------------------------------------
1412 // wxDataViewEvent
1413 // ---------------------------------------------------------
1414
1415 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1416
1417 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, wxDataViewEvent );
1418
1419 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, wxDataViewEvent );
1420 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, wxDataViewEvent );
1421 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, wxDataViewEvent );
1422 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, wxDataViewEvent );
1423 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, wxDataViewEvent );
1424 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, wxDataViewEvent );
1425 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, wxDataViewEvent );
1426 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, wxDataViewEvent );
1427 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, wxDataViewEvent );
1428
1429 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, wxDataViewEvent );
1430
1431 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, wxDataViewEvent );
1432 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, wxDataViewEvent );
1433 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, wxDataViewEvent );
1434 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED, wxDataViewEvent );
1435
1436 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_CACHE_HINT, wxDataViewEvent );
1437
1438 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, wxDataViewEvent );
1439 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, wxDataViewEvent );
1440 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, wxDataViewEvent );
1441
1442
1443
1444 // -------------------------------------
1445 // wxDataViewSpinRenderer
1446 // -------------------------------------
1447
1448 wxDataViewSpinRenderer::wxDataViewSpinRenderer( int min, int max, wxDataViewCellMode mode, int alignment ) :
1449    wxDataViewCustomRenderer(wxT("long"), mode, alignment )
1450 {
1451     m_min = min;
1452     m_max = max;
1453 }
1454
1455 wxWindow* wxDataViewSpinRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1456 {
1457     long l = value;
1458     wxSize size = labelRect.GetSize();
1459 #ifdef __WXMAC__
1460     size = wxSize( wxMax(70,labelRect.width ), -1 );
1461 #endif
1462     wxString str;
1463     str.Printf( wxT("%d"), (int) l );
1464     wxSpinCtrl *sc = new wxSpinCtrl( parent, wxID_ANY, str,
1465                labelRect.GetTopLeft(), size, wxSP_ARROW_KEYS|wxTE_PROCESS_ENTER, m_min, m_max, l );
1466 #ifdef __WXMAC__
1467     size = sc->GetSize();
1468     wxPoint pt = sc->GetPosition();
1469     sc->SetSize( pt.x - 4, pt.y - 4, size.x, size.y );
1470 #endif
1471
1472     return sc;
1473 }
1474
1475 bool wxDataViewSpinRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1476 {
1477     wxSpinCtrl *sc = (wxSpinCtrl*) editor;
1478     long l = sc->GetValue();
1479     value = l;
1480     return true;
1481 }
1482
1483 bool wxDataViewSpinRenderer::Render( wxRect rect, wxDC *dc, int state )
1484 {
1485     wxString str;
1486     str.Printf(wxT("%d"), (int) m_data );
1487     RenderText( str, 0, rect, dc, state );
1488     return true;
1489 }
1490
1491 wxSize wxDataViewSpinRenderer::GetSize() const
1492 {
1493     wxSize sz = GetTextExtent(wxString::Format("%d", (int)m_data));
1494
1495     // Allow some space for the spin buttons, which is approximately the size
1496     // of a scrollbar (and getting pixel-exact value would be complicated).
1497     // Also add some whitespace between the text and the button:
1498     sz.x += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1499     sz.x += GetTextExtent("M").x;
1500
1501     return sz;
1502 }
1503
1504 bool wxDataViewSpinRenderer::SetValue( const wxVariant &value )
1505 {
1506     m_data = value.GetLong();
1507     return true;
1508 }
1509
1510 bool wxDataViewSpinRenderer::GetValue( wxVariant &value ) const
1511 {
1512     value = m_data;
1513     return true;
1514 }
1515
1516 // -------------------------------------
1517 // wxDataViewChoiceRenderer
1518 // -------------------------------------
1519
1520 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)
1521
1522 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString& choices, wxDataViewCellMode mode, int alignment ) :
1523    wxDataViewCustomRenderer(wxT("string"), mode, alignment )
1524 {
1525     m_choices = choices;
1526 }
1527
1528 wxWindow* wxDataViewChoiceRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1529 {
1530     wxChoice* c = new wxChoice
1531                       (
1532                           parent,
1533                           wxID_ANY,
1534                           labelRect.GetTopLeft(),
1535                           wxSize(labelRect.GetWidth(), -1),
1536                           m_choices
1537                       );
1538     c->Move(labelRect.GetRight() - c->GetRect().width, wxDefaultCoord);
1539     c->SetStringSelection( value.GetString() );
1540     return c;
1541 }
1542
1543 bool wxDataViewChoiceRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1544 {
1545     wxChoice *c = (wxChoice*) editor;
1546     wxString s = c->GetStringSelection();
1547     value = s;
1548     return true;
1549 }
1550
1551 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
1552 {
1553     RenderText( m_data, 0, rect, dc, state );
1554     return true;
1555 }
1556
1557 wxSize wxDataViewChoiceRenderer::GetSize() const
1558 {
1559     wxSize sz;
1560
1561     for ( wxArrayString::const_iterator i = m_choices.begin(); i != m_choices.end(); ++i )
1562         sz.IncTo(GetTextExtent(*i));
1563
1564     // Allow some space for the right-side button, which is approximately the
1565     // size of a scrollbar (and getting pixel-exact value would be complicated).
1566     // Also add some whitespace between the text and the button:
1567     sz.x += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1568     sz.x += GetTextExtent("M").x;
1569
1570     return sz;
1571 }
1572
1573 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
1574 {
1575     m_data = value.GetString();
1576     return true;
1577 }
1578
1579 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
1580 {
1581     value = m_data;
1582     return true;
1583 }
1584
1585 // ----------------------------------------------------------------------------
1586 // wxDataViewChoiceByIndexRenderer
1587 // ----------------------------------------------------------------------------
1588
1589 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
1590                                   wxDataViewCellMode mode, int alignment ) :
1591       wxDataViewChoiceRenderer( choices, mode, alignment )
1592 {
1593 }
1594
1595 wxWindow* wxDataViewChoiceByIndexRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1596 {
1597     wxVariant string_value = GetChoice( value.GetLong() );
1598
1599     return wxDataViewChoiceRenderer::CreateEditorCtrl( parent, labelRect, string_value );
1600 }
1601
1602 bool wxDataViewChoiceByIndexRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1603 {
1604     wxVariant string_value;
1605     if (!wxDataViewChoiceRenderer::GetValueFromEditorCtrl( editor, string_value ))
1606         return false;
1607
1608     value = (long) GetChoices().Index( string_value.GetString() );
1609     return true;
1610 }
1611
1612 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant &value )
1613 {
1614     wxVariant string_value = GetChoice( value.GetLong() );
1615     return wxDataViewChoiceRenderer::SetValue( string_value );
1616 }
1617
1618 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant &value ) const
1619 {
1620     wxVariant string_value;
1621     if (!wxDataViewChoiceRenderer::GetValue( string_value ))
1622         return false;
1623
1624     value = (long) GetChoices().Index( string_value.GetString() );
1625     return true;
1626 }
1627
1628 #endif
1629
1630 // ---------------------------------------------------------
1631 // wxDataViewDateRenderer
1632 // ---------------------------------------------------------
1633
1634 #if (defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)) && wxUSE_DATEPICKCTRL
1635
1636 wxDataViewDateRenderer::wxDataViewDateRenderer(const wxString& varianttype,
1637                                               wxDataViewCellMode mode, int align)
1638     : wxDataViewCustomRenderer(varianttype, mode, align)
1639 {
1640 }
1641
1642 wxWindow *
1643 wxDataViewDateRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value)
1644 {
1645     return new wxDatePickerCtrl
1646                (
1647                    parent,
1648                    wxID_ANY,
1649                    value.GetDateTime(),
1650                    labelRect.GetTopLeft(),
1651                    labelRect.GetSize()
1652                );
1653 }
1654
1655 bool wxDataViewDateRenderer::GetValueFromEditorCtrl(wxWindow *editor, wxVariant& value)
1656 {
1657     wxDatePickerCtrl *ctrl = static_cast<wxDatePickerCtrl*>(editor);
1658     value = ctrl->GetValue();
1659     return true;
1660 }
1661
1662 bool wxDataViewDateRenderer::SetValue(const wxVariant& value)
1663 {
1664     m_date = value.GetDateTime();
1665     return true;
1666 }
1667
1668 bool wxDataViewDateRenderer::GetValue(wxVariant& value) const
1669 {
1670     value = m_date;
1671     return true;
1672 }
1673
1674 bool wxDataViewDateRenderer::Render(wxRect cell, wxDC* dc, int state)
1675 {
1676     wxString tmp = m_date.FormatDate();
1677     RenderText( tmp, 0, cell, dc, state );
1678     return true;
1679 }
1680
1681 wxSize wxDataViewDateRenderer::GetSize() const
1682 {
1683     return GetTextExtent(m_date.FormatDate());
1684 }
1685
1686 #endif // (defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)) && wxUSE_DATEPICKCTRL
1687
1688 //-----------------------------------------------------------------------------
1689 // wxDataViewListStore
1690 //-----------------------------------------------------------------------------
1691
1692 wxDataViewListStore::wxDataViewListStore()
1693 {
1694 }
1695
1696 wxDataViewListStore::~wxDataViewListStore()
1697 {
1698     wxVector<wxDataViewListStoreLine*>::iterator it;
1699     for (it = m_data.begin(); it != m_data.end(); ++it)
1700     {
1701         wxDataViewListStoreLine* line = *it;
1702         delete line;
1703     }
1704 }
1705
1706 void wxDataViewListStore::PrependColumn( const wxString &varianttype )
1707 {
1708     m_cols.Insert( varianttype, 0 );
1709 }
1710
1711 void wxDataViewListStore::InsertColumn( unsigned int pos, const wxString &varianttype )
1712 {
1713     m_cols.Insert( varianttype, pos );
1714 }
1715
1716 void wxDataViewListStore::AppendColumn( const wxString &varianttype )
1717 {
1718     m_cols.Add( varianttype );
1719 }
1720
1721 unsigned int wxDataViewListStore::GetColumnCount() const
1722 {
1723     return m_cols.GetCount();
1724 }
1725
1726 wxString wxDataViewListStore::GetColumnType( unsigned int pos ) const
1727 {
1728     return m_cols[pos];
1729 }
1730
1731 void wxDataViewListStore::AppendItem( const wxVector<wxVariant> &values, wxClientData *data )
1732 {
1733     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1734     line->m_values = values;
1735     m_data.push_back( line );
1736
1737     RowAppended();
1738 }
1739
1740 void wxDataViewListStore::PrependItem( const wxVector<wxVariant> &values, wxClientData *data )
1741 {
1742     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1743     line->m_values = values;
1744     m_data.insert( m_data.begin(), line );
1745
1746     RowPrepended();
1747 }
1748
1749 void wxDataViewListStore::InsertItem(  unsigned int row, const wxVector<wxVariant> &values,
1750                                        wxClientData *data )
1751 {
1752     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1753     line->m_values = values;
1754     m_data.insert( m_data.begin()+row, line );
1755
1756     RowInserted( row );
1757 }
1758
1759 void wxDataViewListStore::DeleteItem( unsigned int row )
1760 {
1761     wxVector<wxDataViewListStoreLine*>::iterator it = m_data.begin() + row;
1762     delete *it;
1763     m_data.erase( it );
1764
1765     RowDeleted( row );
1766 }
1767
1768 void wxDataViewListStore::DeleteAllItems()
1769 {
1770     wxVector<wxDataViewListStoreLine*>::iterator it;
1771     for (it = m_data.begin(); it != m_data.end(); ++it)
1772     {
1773         wxDataViewListStoreLine* line = *it;
1774         delete line;
1775     }
1776
1777     m_data.clear();
1778
1779     Reset( 0 );
1780 }
1781
1782 void wxDataViewListStore::GetValueByRow( wxVariant &value, unsigned int row, unsigned int col ) const
1783 {
1784     wxDataViewListStoreLine *line = m_data[row];
1785     value = line->m_values[col];
1786 }
1787
1788 bool wxDataViewListStore::SetValueByRow( const wxVariant &value, unsigned int row, unsigned int col )
1789 {
1790     wxDataViewListStoreLine *line = m_data[row];
1791     line->m_values[col] = value;
1792
1793     return true;
1794 }
1795
1796 //-----------------------------------------------------------------------------
1797 // wxDataViewListCtrl
1798 //-----------------------------------------------------------------------------
1799
1800 IMPLEMENT_DYNAMIC_CLASS(wxDataViewListCtrl,wxDataViewCtrl)
1801
1802 BEGIN_EVENT_TABLE(wxDataViewListCtrl,wxDataViewCtrl)
1803    EVT_SIZE( wxDataViewListCtrl::OnSize )
1804 END_EVENT_TABLE()
1805
1806 wxDataViewListCtrl::wxDataViewListCtrl()
1807 {
1808 }
1809
1810 wxDataViewListCtrl::wxDataViewListCtrl( wxWindow *parent, wxWindowID id,
1811            const wxPoint& pos, const wxSize& size, long style,
1812            const wxValidator& validator )
1813 {
1814     Create( parent, id, pos, size, style, validator );
1815 }
1816
1817 wxDataViewListCtrl::~wxDataViewListCtrl()
1818 {
1819 }
1820
1821
1822 bool wxDataViewListCtrl::Create( wxWindow *parent, wxWindowID id,
1823            const wxPoint& pos, const wxSize& size, long style,
1824            const wxValidator& validator )
1825 {
1826     if ( !wxDataViewCtrl::Create( parent, id, pos, size, style, validator ) )
1827         return false;
1828
1829     wxDataViewListStore *store = new wxDataViewListStore;
1830     AssociateModel( store );
1831     store->DecRef();
1832
1833     return true;
1834 }
1835
1836 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *column, const wxString &varianttype )
1837 {
1838     GetStore()->AppendColumn( varianttype );
1839     return wxDataViewCtrl::AppendColumn( column );
1840 }
1841
1842 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *column, const wxString &varianttype )
1843 {
1844     GetStore()->PrependColumn( varianttype );
1845     return wxDataViewCtrl::PrependColumn( column );
1846 }
1847
1848 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *column, const wxString &varianttype )
1849 {
1850     GetStore()->InsertColumn( pos, varianttype );
1851     return wxDataViewCtrl::InsertColumn( pos, column );
1852 }
1853
1854 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *col )
1855 {
1856     return PrependColumn( col, "string" );
1857 }
1858
1859 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
1860 {
1861     return InsertColumn( pos, col, "string" );
1862 }
1863
1864 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *col )
1865 {
1866     return AppendColumn( col, "string" );
1867 }
1868
1869 wxDataViewColumn *wxDataViewListCtrl::AppendTextColumn( const wxString &label,
1870           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1871 {
1872     GetStore()->AppendColumn( wxT("string") );
1873
1874     wxDataViewColumn *ret = new wxDataViewColumn( label,
1875         new wxDataViewTextRenderer( wxT("string"), mode ),
1876         GetStore()->GetColumnCount()-1, width, align, flags );
1877
1878     wxDataViewCtrl::AppendColumn( ret );
1879
1880     return ret;
1881 }
1882
1883 wxDataViewColumn *wxDataViewListCtrl::AppendToggleColumn( const wxString &label,
1884           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1885 {
1886     GetStore()->AppendColumn( wxT("bool") );
1887
1888     wxDataViewColumn *ret = new wxDataViewColumn( label,
1889         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1890         GetStore()->GetColumnCount()-1, width, align, flags );
1891
1892     wxDataViewCtrl::AppendColumn( ret );
1893
1894     return ret;
1895 }
1896
1897 wxDataViewColumn *wxDataViewListCtrl::AppendProgressColumn( const wxString &label,
1898           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1899 {
1900     GetStore()->AppendColumn( wxT("long") );
1901
1902     wxDataViewColumn *ret = new wxDataViewColumn( label,
1903         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1904         GetStore()->GetColumnCount()-1, width, align, flags );
1905
1906     wxDataViewCtrl::AppendColumn( ret );
1907
1908     return ret;
1909 }
1910
1911 wxDataViewColumn *wxDataViewListCtrl::AppendIconTextColumn( const wxString &label,
1912           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1913 {
1914     GetStore()->AppendColumn( wxT("wxDataViewIconText") );
1915
1916     wxDataViewColumn *ret = new wxDataViewColumn( label,
1917         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1918         GetStore()->GetColumnCount()-1, width, align, flags );
1919
1920     wxDataViewCtrl::AppendColumn( ret );
1921
1922     return ret;
1923 }
1924
1925 void wxDataViewListCtrl::OnSize( wxSizeEvent &event )
1926 {
1927     event.Skip( true );
1928 }
1929
1930 //-----------------------------------------------------------------------------
1931 // wxDataViewTreeStore
1932 //-----------------------------------------------------------------------------
1933
1934 wxDataViewTreeStoreNode::wxDataViewTreeStoreNode(
1935         wxDataViewTreeStoreNode *parent,
1936         const wxString &text, const wxIcon &icon, wxClientData *data )
1937 {
1938     m_parent = parent;
1939     m_text = text;
1940     m_icon = icon;
1941     m_data = data;
1942 }
1943
1944 wxDataViewTreeStoreNode::~wxDataViewTreeStoreNode()
1945 {
1946     if (m_data)
1947         delete m_data;
1948 }
1949
1950 #include "wx/listimpl.cpp"
1951 WX_DEFINE_LIST(wxDataViewTreeStoreNodeList)
1952
1953 wxDataViewTreeStoreContainerNode::wxDataViewTreeStoreContainerNode(
1954         wxDataViewTreeStoreNode *parent, const wxString &text,
1955         const wxIcon &icon, const wxIcon &expanded, wxClientData *data ) :
1956     wxDataViewTreeStoreNode( parent, text, icon, data )
1957 {
1958     m_iconExpanded = expanded;
1959     m_isExpanded = false;
1960     m_children.DeleteContents(true);
1961 }
1962
1963 wxDataViewTreeStoreContainerNode::~wxDataViewTreeStoreContainerNode()
1964 {
1965 }
1966
1967 //-----------------------------------------------------------------------------
1968
1969 wxDataViewTreeStore::wxDataViewTreeStore()
1970 {
1971     m_root = new wxDataViewTreeStoreContainerNode( NULL, wxEmptyString );
1972 }
1973
1974 wxDataViewTreeStore::~wxDataViewTreeStore()
1975 {
1976     delete m_root;
1977 }
1978
1979 wxDataViewItem wxDataViewTreeStore::AppendItem( const wxDataViewItem& parent,
1980         const wxString &text, const wxIcon &icon, wxClientData *data )
1981 {
1982     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1983     if (!parent_node) return wxDataViewItem(0);
1984
1985     wxDataViewTreeStoreNode *node =
1986         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1987     parent_node->GetChildren().Append( node );
1988
1989     return node->GetItem();
1990 }
1991
1992 wxDataViewItem wxDataViewTreeStore::PrependItem( const wxDataViewItem& parent,
1993         const wxString &text, const wxIcon &icon, wxClientData *data )
1994 {
1995     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1996     if (!parent_node) return wxDataViewItem(0);
1997
1998     wxDataViewTreeStoreNode *node =
1999         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
2000     parent_node->GetChildren().Insert( node );
2001
2002     return node->GetItem();
2003 }
2004
2005 wxDataViewItem
2006 wxDataViewTreeStore::InsertItem(const wxDataViewItem& parent,
2007                                 const wxDataViewItem& previous,
2008                                 const wxString& text,
2009                                 const wxIcon& icon,
2010                                 wxClientData *data)
2011 {
2012     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2013     if (!parent_node) return wxDataViewItem(0);
2014
2015     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
2016     int pos = parent_node->GetChildren().IndexOf( previous_node );
2017     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
2018
2019     wxDataViewTreeStoreNode *node =
2020         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
2021     parent_node->GetChildren().Insert( (size_t) pos, node );
2022
2023     return node->GetItem();
2024 }
2025
2026 wxDataViewItem wxDataViewTreeStore::PrependContainer( const wxDataViewItem& parent,
2027         const wxString &text, const wxIcon &icon, const wxIcon &expanded,
2028         wxClientData *data )
2029 {
2030     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2031     if (!parent_node) return wxDataViewItem(0);
2032
2033     wxDataViewTreeStoreContainerNode *node =
2034         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2035     parent_node->GetChildren().Insert( node );
2036
2037     return node->GetItem();
2038 }
2039
2040 wxDataViewItem
2041 wxDataViewTreeStore::AppendContainer(const wxDataViewItem& parent,
2042                                      const wxString &text,
2043                                      const wxIcon& icon,
2044                                      const wxIcon& expanded,
2045                                      wxClientData * data)
2046 {
2047     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2048     if (!parent_node) return wxDataViewItem(0);
2049
2050     wxDataViewTreeStoreContainerNode *node =
2051         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2052     parent_node->GetChildren().Append( node );
2053
2054     return node->GetItem();
2055 }
2056
2057 wxDataViewItem
2058 wxDataViewTreeStore::InsertContainer(const wxDataViewItem& parent,
2059                                      const wxDataViewItem& previous,
2060                                      const wxString& text,
2061                                      const wxIcon& icon,
2062                                      const wxIcon& expanded,
2063                                      wxClientData * data)
2064 {
2065     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2066     if (!parent_node) return wxDataViewItem(0);
2067
2068     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
2069     int pos = parent_node->GetChildren().IndexOf( previous_node );
2070     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
2071
2072     wxDataViewTreeStoreContainerNode *node =
2073         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2074     parent_node->GetChildren().Insert( (size_t) pos, node );
2075
2076     return node->GetItem();
2077 }
2078
2079 bool wxDataViewTreeStore::IsContainer( const wxDataViewItem& item ) const
2080 {
2081     wxDataViewTreeStoreNode *node = FindNode( item );
2082     if (!node) return false;
2083
2084     return node->IsContainer();
2085 }
2086
2087 wxDataViewItem wxDataViewTreeStore::GetNthChild( const wxDataViewItem& parent, unsigned int pos ) const
2088 {
2089     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2090     if (!parent_node) return wxDataViewItem(0);
2091
2092     wxDataViewTreeStoreNodeList::compatibility_iterator node = parent_node->GetChildren().Item( pos );
2093     if (node)
2094         return wxDataViewItem(node->GetData());
2095
2096     return wxDataViewItem(0);
2097 }
2098
2099 int wxDataViewTreeStore::GetChildCount( const wxDataViewItem& parent ) const
2100 {
2101     wxDataViewTreeStoreNode *node = FindNode( parent );
2102     if (!node) return -1;
2103
2104     if (!node->IsContainer())
2105         return 0;
2106
2107     wxDataViewTreeStoreContainerNode *container_node = (wxDataViewTreeStoreContainerNode*) node;
2108     return (int) container_node->GetChildren().GetCount();
2109 }
2110
2111 void wxDataViewTreeStore::SetItemText( const wxDataViewItem& item, const wxString &text )
2112 {
2113     wxDataViewTreeStoreNode *node = FindNode( item );
2114     if (!node) return;
2115
2116     node->SetText( text );
2117 }
2118
2119 wxString wxDataViewTreeStore::GetItemText( const wxDataViewItem& item ) const
2120 {
2121     wxDataViewTreeStoreNode *node = FindNode( item );
2122     if (!node) return wxEmptyString;
2123
2124     return node->GetText();
2125 }
2126
2127 void wxDataViewTreeStore::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2128 {
2129     wxDataViewTreeStoreNode *node = FindNode( item );
2130     if (!node) return;
2131
2132     node->SetIcon( icon );
2133 }
2134
2135 const wxIcon &wxDataViewTreeStore::GetItemIcon( const wxDataViewItem& item ) const
2136 {
2137     wxDataViewTreeStoreNode *node = FindNode( item );
2138     if (!node) return wxNullIcon;
2139
2140     return node->GetIcon();
2141 }
2142
2143 void wxDataViewTreeStore::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2144 {
2145     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2146     if (!node) return;
2147
2148     node->SetExpandedIcon( icon );
2149 }
2150
2151 const wxIcon &wxDataViewTreeStore::GetItemExpandedIcon( const wxDataViewItem& item ) const
2152 {
2153     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2154     if (!node) return wxNullIcon;
2155
2156     return node->GetExpandedIcon();
2157 }
2158
2159 void wxDataViewTreeStore::SetItemData( const wxDataViewItem& item, wxClientData *data )
2160 {
2161     wxDataViewTreeStoreNode *node = FindNode( item );
2162     if (!node) return;
2163
2164     node->SetData( data );
2165 }
2166
2167 wxClientData *wxDataViewTreeStore::GetItemData( const wxDataViewItem& item ) const
2168 {
2169     wxDataViewTreeStoreNode *node = FindNode( item );
2170     if (!node) return NULL;
2171
2172     return node->GetData();
2173 }
2174
2175 void wxDataViewTreeStore::DeleteItem( const wxDataViewItem& item )
2176 {
2177     if (!item.IsOk()) return;
2178
2179     wxDataViewItem parent_item = GetParent( item );
2180
2181     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent_item );
2182     if (!parent_node) return;
2183
2184     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2185     if (!node) return;
2186
2187     parent_node->GetChildren().DeleteObject( node );
2188 }
2189
2190 void wxDataViewTreeStore::DeleteChildren( const wxDataViewItem& item )
2191 {
2192     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2193     if (!node) return;
2194
2195     node->GetChildren().clear();
2196 }
2197
2198 void wxDataViewTreeStore::DeleteAllItems()
2199 {
2200     DeleteChildren(wxDataViewItem(m_root));
2201 }
2202
2203 void
2204 wxDataViewTreeStore::GetValue(wxVariant &variant,
2205                               const wxDataViewItem &item,
2206                               unsigned int WXUNUSED(col)) const
2207 {
2208     // if (col != 0) return;
2209
2210     wxDataViewTreeStoreNode *node = FindNode( item );
2211     if (!node) return;
2212
2213     wxIcon icon( node->GetIcon());
2214     if (node->IsContainer())
2215     {
2216         wxDataViewTreeStoreContainerNode *container = (wxDataViewTreeStoreContainerNode*) node;
2217         if (container->IsExpanded() && container->GetExpandedIcon().IsOk())
2218            icon = container->GetExpandedIcon();
2219     }
2220
2221     wxDataViewIconText data( node->GetText(), icon );
2222
2223     variant << data;
2224 }
2225
2226 bool
2227 wxDataViewTreeStore::SetValue(const wxVariant& variant,
2228                               const wxDataViewItem& item,
2229                               unsigned int WXUNUSED(col))
2230 {
2231     // if (col != 0) return false;
2232
2233     wxDataViewTreeStoreNode *node = FindNode( item );
2234     if (!node) return false;
2235
2236     wxDataViewIconText data;
2237
2238     data << variant;
2239
2240     node->SetText( data.GetText() );
2241     node->SetIcon( data.GetIcon() );
2242
2243     return true;
2244 }
2245
2246 wxDataViewItem wxDataViewTreeStore::GetParent( const wxDataViewItem &item ) const
2247 {
2248     wxDataViewTreeStoreNode *node = FindNode( item );
2249     if (!node) return wxDataViewItem(0);
2250
2251     wxDataViewTreeStoreNode *parent = node->GetParent();
2252     if (!parent) return wxDataViewItem(0);
2253
2254     if (parent == m_root)
2255         return wxDataViewItem(0);
2256
2257     return parent->GetItem();
2258 }
2259
2260 unsigned int wxDataViewTreeStore::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
2261 {
2262     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2263     if (!node) return 0;
2264
2265     wxDataViewTreeStoreNodeList::iterator iter;
2266     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2267     {
2268         wxDataViewTreeStoreNode* child = *iter;
2269         children.Add( child->GetItem() );
2270     }
2271
2272     return node->GetChildren().GetCount();
2273 }
2274
2275 int wxDataViewTreeStore::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
2276                          unsigned int WXUNUSED(column), bool WXUNUSED(ascending) ) const
2277 {
2278     wxDataViewTreeStoreNode *node1 = FindNode( item1 );
2279     wxDataViewTreeStoreNode *node2 = FindNode( item2 );
2280
2281     if (!node1 || !node2)
2282         return 0;
2283
2284     wxDataViewTreeStoreContainerNode* parent1 =
2285         (wxDataViewTreeStoreContainerNode*) node1->GetParent();
2286     wxDataViewTreeStoreContainerNode* parent2 =
2287         (wxDataViewTreeStoreContainerNode*) node2->GetParent();
2288
2289     if (parent1 != parent2)
2290     {
2291         wxLogError( wxT("Comparing items with different parent.") );
2292         return 0;
2293     }
2294
2295     if (node1->IsContainer() && !node2->IsContainer())
2296         return -1;
2297
2298     if (node2->IsContainer() && !node1->IsContainer())
2299         return 1;
2300
2301     return parent1->GetChildren().IndexOf( node1 ) - parent2->GetChildren().IndexOf( node2 );
2302 }
2303
2304 wxDataViewTreeStoreNode *wxDataViewTreeStore::FindNode( const wxDataViewItem &item ) const
2305 {
2306     if (!item.IsOk())
2307         return m_root;
2308
2309     return (wxDataViewTreeStoreNode*) item.GetID();
2310 }
2311
2312 wxDataViewTreeStoreContainerNode *wxDataViewTreeStore::FindContainerNode( const wxDataViewItem &item ) const
2313 {
2314     if (!item.IsOk())
2315         return (wxDataViewTreeStoreContainerNode*) m_root;
2316
2317     wxDataViewTreeStoreNode* node = (wxDataViewTreeStoreNode*) item.GetID();
2318
2319     if (!node->IsContainer())
2320         return NULL;
2321
2322     return (wxDataViewTreeStoreContainerNode*) node;
2323 }
2324
2325 //-----------------------------------------------------------------------------
2326 // wxDataViewTreeCtrl
2327 //-----------------------------------------------------------------------------
2328
2329 IMPLEMENT_DYNAMIC_CLASS(wxDataViewTreeCtrl,wxDataViewCtrl)
2330
2331 BEGIN_EVENT_TABLE(wxDataViewTreeCtrl,wxDataViewCtrl)
2332    EVT_DATAVIEW_ITEM_EXPANDED(-1, wxDataViewTreeCtrl::OnExpanded)
2333    EVT_DATAVIEW_ITEM_COLLAPSED(-1, wxDataViewTreeCtrl::OnCollapsed)
2334    EVT_SIZE( wxDataViewTreeCtrl::OnSize )
2335 END_EVENT_TABLE()
2336
2337 bool wxDataViewTreeCtrl::Create( wxWindow *parent, wxWindowID id,
2338            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2339 {
2340     if ( !wxDataViewCtrl::Create( parent, id, pos, size, style, validator ) )
2341         return false;
2342
2343     // create the standard model and a column in the tree
2344     wxDataViewTreeStore *store = new wxDataViewTreeStore;
2345     AssociateModel( store );
2346     store->DecRef();
2347
2348     AppendIconTextColumn
2349     (
2350         wxString(),                 // no label (header is not shown anyhow)
2351         0,                          // the only model column
2352         wxDATAVIEW_CELL_EDITABLE,
2353         -1,                         // default width
2354         wxALIGN_NOT,                //  and alignment
2355         0                           // not resizable
2356     );
2357
2358     return true;
2359 }
2360
2361 wxDataViewItem wxDataViewTreeCtrl::AppendItem( const wxDataViewItem& parent,
2362         const wxString &text, int iconIndex, wxClientData *data )
2363 {
2364     wxDataViewItem res = GetStore()->
2365         AppendItem( parent, text, GetImage(iconIndex), data );
2366
2367     GetStore()->ItemAdded( parent, res );
2368
2369     return res;
2370 }
2371
2372 wxDataViewItem wxDataViewTreeCtrl::PrependItem( const wxDataViewItem& parent,
2373         const wxString &text, int iconIndex, wxClientData *data )
2374 {
2375     wxDataViewItem res = GetStore()->
2376         PrependItem( parent, text, GetImage(iconIndex), data );
2377
2378     GetStore()->ItemAdded( parent, res );
2379
2380     return res;
2381 }
2382
2383 wxDataViewItem wxDataViewTreeCtrl::InsertItem( const wxDataViewItem& parent, const wxDataViewItem& previous,
2384         const wxString &text, int iconIndex, wxClientData *data )
2385 {
2386     wxDataViewItem res = GetStore()->
2387         InsertItem( parent, previous, text, GetImage(iconIndex), data );
2388
2389     GetStore()->ItemAdded( parent, res );
2390
2391     return res;
2392 }
2393
2394 wxDataViewItem wxDataViewTreeCtrl::PrependContainer( const wxDataViewItem& parent,
2395         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2396 {
2397     wxDataViewItem res = GetStore()->
2398         PrependContainer( parent, text,
2399                           GetImage(iconIndex), GetImage(expandedIndex), data );
2400
2401     GetStore()->ItemAdded( parent, res );
2402
2403     return res;
2404 }
2405
2406 wxDataViewItem wxDataViewTreeCtrl::AppendContainer( const wxDataViewItem& parent,
2407         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2408 {
2409     wxDataViewItem res = GetStore()->
2410         AppendContainer( parent, text,
2411                          GetImage(iconIndex), GetImage(expandedIndex), data );
2412
2413     GetStore()->ItemAdded( parent, res );
2414
2415     return res;
2416 }
2417
2418 wxDataViewItem wxDataViewTreeCtrl::InsertContainer( const wxDataViewItem& parent, const wxDataViewItem& previous,
2419         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2420 {
2421     wxDataViewItem res = GetStore()->
2422         InsertContainer( parent, previous, text,
2423                          GetImage(iconIndex), GetImage(expandedIndex), data );
2424
2425     GetStore()->ItemAdded( parent, res );
2426
2427     return res;
2428 }
2429
2430 void wxDataViewTreeCtrl::SetItemText( const wxDataViewItem& item, const wxString &text )
2431 {
2432     GetStore()->SetItemText(item,text);
2433
2434     // notify control
2435     GetStore()->ValueChanged( item, 0 );
2436 }
2437
2438 void wxDataViewTreeCtrl::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2439 {
2440     GetStore()->SetItemIcon(item,icon);
2441
2442     // notify control
2443     GetStore()->ValueChanged( item, 0 );
2444 }
2445
2446 void wxDataViewTreeCtrl::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2447 {
2448     GetStore()->SetItemExpandedIcon(item,icon);
2449
2450     // notify control
2451     GetStore()->ValueChanged( item, 0 );
2452 }
2453
2454 void wxDataViewTreeCtrl::DeleteItem( const wxDataViewItem& item )
2455 {
2456     wxDataViewItem parent_item = GetStore()->GetParent( item );
2457
2458     GetStore()->DeleteItem(item);
2459
2460     // notify control
2461     GetStore()->ItemDeleted( parent_item, item );
2462 }
2463
2464 void wxDataViewTreeCtrl::DeleteChildren( const wxDataViewItem& item )
2465 {
2466     wxDataViewTreeStoreContainerNode *node = GetStore()->FindContainerNode( item );
2467     if (!node) return;
2468
2469     wxDataViewItemArray array;
2470     wxDataViewTreeStoreNodeList::iterator iter;
2471     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2472     {
2473         wxDataViewTreeStoreNode* child = *iter;
2474         array.Add( child->GetItem() );
2475     }
2476
2477     GetStore()->DeleteChildren( item );
2478
2479     // notify control
2480     GetStore()->ItemsDeleted( item, array );
2481 }
2482
2483 void  wxDataViewTreeCtrl::DeleteAllItems()
2484 {
2485     GetStore()->DeleteAllItems();
2486
2487     GetStore()->Cleared();
2488 }
2489
2490 void wxDataViewTreeCtrl::OnExpanded( wxDataViewEvent &event )
2491 {
2492     if (HasImageList()) return;
2493
2494     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2495     if (!container) return;
2496
2497     container->SetExpanded( true );
2498
2499     GetStore()->ItemChanged( event.GetItem() );
2500 }
2501
2502 void wxDataViewTreeCtrl::OnCollapsed( wxDataViewEvent &event )
2503 {
2504     if (HasImageList()) return;
2505
2506     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2507     if (!container) return;
2508
2509     container->SetExpanded( false );
2510
2511     GetStore()->ItemChanged( event.GetItem() );
2512 }
2513
2514 void wxDataViewTreeCtrl::OnSize( wxSizeEvent &event )
2515 {
2516 #if defined(wxUSE_GENERICDATAVIEWCTRL)
2517     // automatically resize our only column to take the entire control width
2518     if ( GetColumnCount() )
2519     {
2520         wxSize size = GetClientSize();
2521         GetColumn(0)->SetWidth(size.x);
2522     }
2523 #endif
2524     event.Skip( true );
2525 }
2526
2527 #endif // wxUSE_DATAVIEWCTRL
2528