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