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 unsigned int wxDataViewIndexListModel::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
 504 {
 505     if (item.IsOk())
 506         return 0;
 507
 508     children = m_hash;
 509
 510     return m_hash.GetCount();
 511 }
 512
 513 // ---------------------------------------------------------
 514 // wxDataViewVirtualListModel
 515 // ---------------------------------------------------------
 516
 517 #ifndef __WXMAC__
 518
 519 wxDataViewVirtualListModel::wxDataViewVirtualListModel( unsigned int initial_size )
 520 {
 521     m_size = initial_size;
 522 }
 523
 524 void wxDataViewVirtualListModel::Reset( unsigned int new_size )
 525 {
 526     /* wxDataViewModel:: */ BeforeReset();
 527
 528     m_size = new_size;
 529
 530     /* wxDataViewModel:: */ AfterReset();
 531 }
 532
 533 void wxDataViewVirtualListModel::RowPrepended()
 534 {
 535     m_size++;
 536     wxDataViewItem item( wxUIntToPtr(1) );
 537     ItemAdded( wxDataViewItem(0), item );
 538 }
 539
 540 void wxDataViewVirtualListModel::RowInserted( unsigned int before )
 541 {
 542     m_size++;
 543     wxDataViewItem item( wxUIntToPtr(before+1) );
 544     ItemAdded( wxDataViewItem(0), item );
 545 }
 546
 547 void wxDataViewVirtualListModel::RowAppended()
 548 {
 549     m_size++;
 550     wxDataViewItem item( wxUIntToPtr(m_size) );
 551     ItemAdded( wxDataViewItem(0), item );
 552 }
 553
 554 void wxDataViewVirtualListModel::RowDeleted( unsigned int row )
 555 {
 556     m_size--;
 557     wxDataViewItem item( wxUIntToPtr(row+1) );
 558     /* wxDataViewModel:: */ ItemDeleted( wxDataViewItem(0), item );
 559 }
 560
 561 void wxDataViewVirtualListModel::RowsDeleted( const wxArrayInt &rows )
 562 {
 563     m_size -= rows.GetCount();
 564
 565     wxArrayInt sorted = rows;
 566     sorted.Sort( my_sort );
 567
 568     wxDataViewItemArray array;
 569     unsigned int i;
 570     for (i = 0; i < sorted.GetCount(); i++)
 571     {
 572         wxDataViewItem item( wxUIntToPtr(sorted[i]+1) );
 573         array.Add( item );
 574     }
 575     /* wxDataViewModel:: */ ItemsDeleted( wxDataViewItem(0), array );
 576 }
 577
 578 void wxDataViewVirtualListModel::RowChanged( unsigned int row )
 579 {
 580     /* wxDataViewModel:: */ ItemChanged( GetItem(row) );
 581 }
 582
 583 void wxDataViewVirtualListModel::RowValueChanged( unsigned int row, unsigned int col )
 584 {
 585     /* wxDataViewModel:: */ ValueChanged( GetItem(row), col );
 586 }
 587
 588 unsigned int wxDataViewVirtualListModel::GetRow( const wxDataViewItem &item ) const
 589 {
 590     return wxPtrToUInt( item.GetID() ) -1;
 591 }
 592
 593 wxDataViewItem wxDataViewVirtualListModel::GetItem( unsigned int row ) const
 594 {
 595     return wxDataViewItem( wxUIntToPtr(row+1) );
 596 }
 597
 598 bool wxDataViewVirtualListModel::HasDefaultCompare() const
 599 {
 600     return true;
 601 }
 602
 603 int wxDataViewVirtualListModel::Compare(const wxDataViewItem& item1,
 604                                       const wxDataViewItem& item2,
 605                                       unsigned int WXUNUSED(column),
 606                                       bool ascending) const
 607 {
 608     unsigned int pos1 = wxPtrToUInt(item1.GetID());  // -1 not needed here
 609     unsigned int pos2 = wxPtrToUInt(item2.GetID());  // -1 not needed here
 610
 611     if (ascending)
 612        return pos1 - pos2;
 613     else
 614        return pos2 - pos1;
 615 }
 616
 617 unsigned int wxDataViewVirtualListModel::GetChildren( const wxDataViewItem &WXUNUSED(item), wxDataViewItemArray &WXUNUSED(children) ) const
 618 {
 619     return 0;  // should we report an error ?
 620 }
 621
 622 #endif  // __WXMAC__
 623
 624 //-----------------------------------------------------------------------------
 625 // wxDataViewIconText
 626 //-----------------------------------------------------------------------------
 627
 628 IMPLEMENT_DYNAMIC_CLASS(wxDataViewIconText,wxObject)
 629
 630 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
 631
 632 // ---------------------------------------------------------
 633 // wxDataViewRendererBase
 634 // ---------------------------------------------------------
 635
 636 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRendererBase, wxObject)
 637
 638 wxDataViewRendererBase::wxDataViewRendererBase( const wxString &varianttype,
 639                                                 wxDataViewCellMode WXUNUSED(mode),
 640                                                 int WXUNUSED(align) )
 641 {
 642     m_variantType = varianttype;
 643     m_owner = NULL;
 644 }
 645
 646 wxDataViewRendererBase::~wxDataViewRendererBase()
 647 {
 648     if ( m_editorCtrl )
 649         DestroyEditControl();
 650 }
 651
 652 wxDataViewCtrl* wxDataViewRendererBase::GetView() const
 653 {
 654     return const_cast<wxDataViewRendererBase*>(this)->GetOwner()->GetOwner();
 655 }
 656
 657 bool wxDataViewRendererBase::StartEditing( const wxDataViewItem &item, wxRect labelRect )
 658 {
 659     wxDataViewCtrl* dv_ctrl = GetOwner()->GetOwner();
 660
 661     // Before doing anything we send an event asking if editing of this item is really wanted.
 662     wxDataViewEvent start_event( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, dv_ctrl->GetId() );
 663     start_event.SetDataViewColumn( GetOwner() );
 664     start_event.SetModel( dv_ctrl->GetModel() );
 665     start_event.SetItem( item );
 666     start_event.SetEventObject( dv_ctrl );
 667     dv_ctrl->GetEventHandler()->ProcessEvent( start_event );
 668     if( !start_event.IsAllowed() )
 669         return false;
 670
 671     m_item = item; // remember for later
 672
 673     unsigned int col = GetOwner()->GetModelColumn();
 674     wxVariant value;
 675     dv_ctrl->GetModel()->GetValue( value, item, col );
 676
 677     m_editorCtrl = CreateEditorCtrl( dv_ctrl->GetMainWindow(), labelRect, value );
 678
 679     // there might be no editor control for the given item
 680     if(!m_editorCtrl)
 681         return false;
 682
 683     wxDataViewEditorCtrlEvtHandler *handler =
 684         new wxDataViewEditorCtrlEvtHandler( m_editorCtrl, (wxDataViewRenderer*) this );
 685
 686     m_editorCtrl->PushEventHandler( handler );
 687
 688 #if defined(__WXGTK20__) && !defined(wxUSE_GENERICDATAVIEWCTRL)
 689     handler->SetFocusOnIdle();
 690 #else
 691     m_editorCtrl->SetFocus();
 692 #endif
 693
 694     // Now we should send Editing Started event
 695     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv_ctrl->GetId() );
 696     event.SetDataViewColumn( GetOwner() );
 697     event.SetModel( dv_ctrl->GetModel() );
 698     event.SetItem( item );
 699     event.SetEventObject( dv_ctrl );
 700     dv_ctrl->GetEventHandler()->ProcessEvent( event );
 701
 702     return true;
 703 }
 704
 705 void wxDataViewRendererBase::DestroyEditControl()
 706 {
 707     // Remove our event handler first to prevent it from (recursively) calling
 708     // us again as it would do via a call to FinishEditing() when the editor
 709     // loses focus when we hide it below.
 710     wxEvtHandler * const handler = m_editorCtrl->PopEventHandler();
 711
 712     // Hide the control immediately but don't delete it yet as there could be
 713     // some pending messages for it.
 714     m_editorCtrl->Hide();
 715
 716     wxPendingDelete.Append(handler);
 717     wxPendingDelete.Append(m_editorCtrl);
 718 }
 719
 720 void wxDataViewRendererBase::CancelEditing()
 721 {
 722     if (!m_editorCtrl)
 723         return;
 724
 725     DestroyEditControl();
 726 }
 727
 728 bool wxDataViewRendererBase::FinishEditing()
 729 {
 730     if (!m_editorCtrl)
 731         return true;
 732
 733     wxVariant value;
 734     GetValueFromEditorCtrl( m_editorCtrl, value );
 735
 736     wxDataViewCtrl* dv_ctrl = GetOwner()->GetOwner();
 737
 738     DestroyEditControl();
 739
 740     dv_ctrl->GetMainWindow()->SetFocus();
 741
 742     bool isValid = Validate(value);
 743     unsigned int col = GetOwner()->GetModelColumn();
 744
 745     // Now we should send Editing Done event
 746     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv_ctrl->GetId() );
 747     event.SetDataViewColumn( GetOwner() );
 748     event.SetModel( dv_ctrl->GetModel() );
 749     event.SetItem( m_item );
 750     event.SetValue( value );
 751     event.SetColumn( col );
 752     event.SetEditCanceled( !isValid );
 753     event.SetEventObject( dv_ctrl );
 754     dv_ctrl->GetEventHandler()->ProcessEvent( event );
 755
 756     if ( isValid && event.IsAllowed() )
 757     {
 758         dv_ctrl->GetModel()->ChangeValue(value, m_item, col);
 759         return true;
 760     }
 761
 762     return false;
 763 }
 764
 765 void wxDataViewRendererBase::PrepareForItem(const wxDataViewModel *model,
 766                                             const wxDataViewItem& item,
 767                                             unsigned column)
 768 {
 769     wxVariant value;
 770     model->GetValue(value, item, column);
 771     SetValue(value);
 772
 773     wxDataViewItemAttr attr;
 774     model->GetAttr(item, column, attr);
 775     SetAttr(attr);
 776
 777     SetEnabled(model->IsEnabled(item, column));
 778 }
 779
 780
 781 // ----------------------------------------------------------------------------
 782 // wxDataViewCustomRendererBase
 783 // ----------------------------------------------------------------------------
 784
 785 bool wxDataViewCustomRendererBase::ActivateCell(const wxRect& cell,
 786                                                 wxDataViewModel *model,
 787                                                 const wxDataViewItem & item,
 788                                                 unsigned int col,
 789                                                 const wxMouseEvent* mouseEvent)
 790 {
 791     // Compatibility code
 792     if ( mouseEvent )
 793         return LeftClick(mouseEvent->GetPosition(), cell, model, item, col);
 794     else
 795         return Activate(cell, model, item, col);
 796 }
 797
 798 void wxDataViewCustomRendererBase::RenderBackground(wxDC* dc, const wxRect& rect)
 799 {
 800     if ( !m_attr.HasBackgroundColour() )
 801         return;
 802
 803     const wxColour& colour = m_attr.GetBackgroundColour();
 804     wxDCPenChanger changePen(*dc, colour);
 805     wxDCBrushChanger changeBrush(*dc, colour);
 806
 807     dc->DrawRectangle(rect);
 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 void wxDataViewCtrlBase::StartEditor(const wxDataViewItem& item, unsigned int column)
1395 {
1396     EditItem(item, GetColumn(column));
1397 }
1398
1399 // ---------------------------------------------------------
1400 // wxDataViewEvent
1401 // ---------------------------------------------------------
1402
1403 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1404
1405 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, wxDataViewEvent );
1406
1407 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, wxDataViewEvent );
1408 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING, wxDataViewEvent );
1409 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED, wxDataViewEvent );
1410 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, wxDataViewEvent );
1411 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED, wxDataViewEvent );
1412 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, wxDataViewEvent );
1413 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_START_EDITING, wxDataViewEvent );
1414 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, wxDataViewEvent );
1415 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, wxDataViewEvent );
1416
1417 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, wxDataViewEvent );
1418
1419 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, wxDataViewEvent );
1420 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, wxDataViewEvent );
1421 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, wxDataViewEvent );
1422 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED, wxDataViewEvent );
1423
1424 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_CACHE_HINT, wxDataViewEvent );
1425
1426 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, wxDataViewEvent );
1427 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, wxDataViewEvent );
1428 wxDEFINE_EVENT( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, wxDataViewEvent );
1429
1430
1431
1432 // -------------------------------------
1433 // wxDataViewSpinRenderer
1434 // -------------------------------------
1435
1436 wxDataViewSpinRenderer::wxDataViewSpinRenderer( int min, int max, wxDataViewCellMode mode, int alignment ) :
1437    wxDataViewCustomRenderer(wxT("long"), mode, alignment )
1438 {
1439     m_min = min;
1440     m_max = max;
1441 }
1442
1443 wxWindow* wxDataViewSpinRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1444 {
1445     long l = value;
1446     wxSize size = labelRect.GetSize();
1447 #ifdef __WXMAC__
1448     size = wxSize( wxMax(70,labelRect.width ), -1 );
1449 #endif
1450     wxString str;
1451     str.Printf( wxT("%d"), (int) l );
1452     wxSpinCtrl *sc = new wxSpinCtrl( parent, wxID_ANY, str,
1453                labelRect.GetTopLeft(), size, wxSP_ARROW_KEYS|wxTE_PROCESS_ENTER, m_min, m_max, l );
1454 #ifdef __WXMAC__
1455     size = sc->GetSize();
1456     wxPoint pt = sc->GetPosition();
1457     sc->SetSize( pt.x - 4, pt.y - 4, size.x, size.y );
1458 #endif
1459
1460     return sc;
1461 }
1462
1463 bool wxDataViewSpinRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1464 {
1465     wxSpinCtrl *sc = (wxSpinCtrl*) editor;
1466     long l = sc->GetValue();
1467     value = l;
1468     return true;
1469 }
1470
1471 bool wxDataViewSpinRenderer::Render( wxRect rect, wxDC *dc, int state )
1472 {
1473     wxString str;
1474     str.Printf(wxT("%d"), (int) m_data );
1475     RenderText( str, 0, rect, dc, state );
1476     return true;
1477 }
1478
1479 wxSize wxDataViewSpinRenderer::GetSize() const
1480 {
1481     wxSize sz = GetTextExtent(wxString::Format("%d", (int)m_data));
1482
1483     // Allow some space for the spin buttons, which is approximately the size
1484     // of a scrollbar (and getting pixel-exact value would be complicated).
1485     // Also add some whitespace between the text and the button:
1486     sz.x += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1487     sz.x += GetTextExtent("M").x;
1488
1489     return sz;
1490 }
1491
1492 bool wxDataViewSpinRenderer::SetValue( const wxVariant &value )
1493 {
1494     m_data = value.GetLong();
1495     return true;
1496 }
1497
1498 bool wxDataViewSpinRenderer::GetValue( wxVariant &value ) const
1499 {
1500     value = m_data;
1501     return true;
1502 }
1503
1504 // -------------------------------------
1505 // wxDataViewChoiceRenderer
1506 // -------------------------------------
1507
1508 #if defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXOSX_CARBON__)
1509
1510 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer( const wxArrayString& choices, wxDataViewCellMode mode, int alignment ) :
1511    wxDataViewCustomRenderer(wxT("string"), mode, alignment )
1512 {
1513     m_choices = choices;
1514 }
1515
1516 wxWindow* wxDataViewChoiceRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1517 {
1518     wxChoice* c = new wxChoice
1519                       (
1520                           parent,
1521                           wxID_ANY,
1522                           labelRect.GetTopLeft(),
1523                           wxSize(labelRect.GetWidth(), -1),
1524                           m_choices
1525                       );
1526     c->Move(labelRect.GetRight() - c->GetRect().width, wxDefaultCoord);
1527     c->SetStringSelection( value.GetString() );
1528     return c;
1529 }
1530
1531 bool wxDataViewChoiceRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1532 {
1533     wxChoice *c = (wxChoice*) editor;
1534     wxString s = c->GetStringSelection();
1535     value = s;
1536     return true;
1537 }
1538
1539 bool wxDataViewChoiceRenderer::Render( wxRect rect, wxDC *dc, int state )
1540 {
1541     RenderText( m_data, 0, rect, dc, state );
1542     return true;
1543 }
1544
1545 wxSize wxDataViewChoiceRenderer::GetSize() const
1546 {
1547     wxSize sz;
1548
1549     for ( wxArrayString::const_iterator i = m_choices.begin(); i != m_choices.end(); ++i )
1550         sz.IncTo(GetTextExtent(*i));
1551
1552     // Allow some space for the right-side button, which is approximately the
1553     // size of a scrollbar (and getting pixel-exact value would be complicated).
1554     // Also add some whitespace between the text and the button:
1555     sz.x += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
1556     sz.x += GetTextExtent("M").x;
1557
1558     return sz;
1559 }
1560
1561 bool wxDataViewChoiceRenderer::SetValue( const wxVariant &value )
1562 {
1563     m_data = value.GetString();
1564     return true;
1565 }
1566
1567 bool wxDataViewChoiceRenderer::GetValue( wxVariant &value ) const
1568 {
1569     value = m_data;
1570     return true;
1571 }
1572
1573 // ----------------------------------------------------------------------------
1574 // wxDataViewChoiceByIndexRenderer
1575 // ----------------------------------------------------------------------------
1576
1577 wxDataViewChoiceByIndexRenderer::wxDataViewChoiceByIndexRenderer( const wxArrayString &choices,
1578                                   wxDataViewCellMode mode, int alignment ) :
1579       wxDataViewChoiceRenderer( choices, mode, alignment )
1580 {
1581 }
1582
1583 wxWindow* wxDataViewChoiceByIndexRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1584 {
1585     wxVariant string_value = GetChoice( value.GetLong() );
1586
1587     return wxDataViewChoiceRenderer::CreateEditorCtrl( parent, labelRect, string_value );
1588 }
1589
1590 bool wxDataViewChoiceByIndexRenderer::GetValueFromEditorCtrl( wxWindow* editor, wxVariant &value )
1591 {
1592     wxVariant string_value;
1593     if (!wxDataViewChoiceRenderer::GetValueFromEditorCtrl( editor, string_value ))
1594         return false;
1595
1596     value = (long) GetChoices().Index( string_value.GetString() );
1597     return true;
1598 }
1599
1600 bool wxDataViewChoiceByIndexRenderer::SetValue( const wxVariant &value )
1601 {
1602     wxVariant string_value = GetChoice( value.GetLong() );
1603     return wxDataViewChoiceRenderer::SetValue( string_value );
1604 }
1605
1606 bool wxDataViewChoiceByIndexRenderer::GetValue( wxVariant &value ) const
1607 {
1608     wxVariant string_value;
1609     if (!wxDataViewChoiceRenderer::GetValue( string_value ))
1610         return false;
1611
1612     value = (long) GetChoices().Index( string_value.GetString() );
1613     return true;
1614 }
1615
1616 #endif
1617
1618 // ---------------------------------------------------------
1619 // wxDataViewDateRenderer
1620 // ---------------------------------------------------------
1621
1622 #if (defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)) && wxUSE_DATEPICKCTRL
1623
1624 wxDataViewDateRenderer::wxDataViewDateRenderer(const wxString& varianttype,
1625                                               wxDataViewCellMode mode, int align)
1626     : wxDataViewCustomRenderer(varianttype, mode, align)
1627 {
1628 }
1629
1630 wxWindow *
1631 wxDataViewDateRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value)
1632 {
1633     return new wxDatePickerCtrl
1634                (
1635                    parent,
1636                    wxID_ANY,
1637                    value.GetDateTime(),
1638                    labelRect.GetTopLeft(),
1639                    labelRect.GetSize()
1640                );
1641 }
1642
1643 bool wxDataViewDateRenderer::GetValueFromEditorCtrl(wxWindow *editor, wxVariant& value)
1644 {
1645     wxDatePickerCtrl *ctrl = static_cast<wxDatePickerCtrl*>(editor);
1646     value = ctrl->GetValue();
1647     return true;
1648 }
1649
1650 bool wxDataViewDateRenderer::SetValue(const wxVariant& value)
1651 {
1652     m_date = value.GetDateTime();
1653     return true;
1654 }
1655
1656 bool wxDataViewDateRenderer::GetValue(wxVariant& value) const
1657 {
1658     value = m_date;
1659     return true;
1660 }
1661
1662 bool wxDataViewDateRenderer::Render(wxRect cell, wxDC* dc, int state)
1663 {
1664     wxString tmp = m_date.FormatDate();
1665     RenderText( tmp, 0, cell, dc, state );
1666     return true;
1667 }
1668
1669 wxSize wxDataViewDateRenderer::GetSize() const
1670 {
1671     return GetTextExtent(m_date.FormatDate());
1672 }
1673
1674 #endif // (defined(wxHAS_GENERIC_DATAVIEWCTRL) || defined(__WXGTK__)) && wxUSE_DATEPICKCTRL
1675
1676 //-----------------------------------------------------------------------------
1677 // wxDataViewListStore
1678 //-----------------------------------------------------------------------------
1679
1680 wxDataViewListStore::wxDataViewListStore()
1681 {
1682 }
1683
1684 wxDataViewListStore::~wxDataViewListStore()
1685 {
1686     wxVector<wxDataViewListStoreLine*>::iterator it;
1687     for (it = m_data.begin(); it != m_data.end(); ++it)
1688     {
1689         wxDataViewListStoreLine* line = *it;
1690         delete line;
1691     }
1692 }
1693
1694 void wxDataViewListStore::PrependColumn( const wxString &varianttype )
1695 {
1696     m_cols.Insert( varianttype, 0 );
1697 }
1698
1699 void wxDataViewListStore::InsertColumn( unsigned int pos, const wxString &varianttype )
1700 {
1701     m_cols.Insert( varianttype, pos );
1702 }
1703
1704 void wxDataViewListStore::AppendColumn( const wxString &varianttype )
1705 {
1706     m_cols.Add( varianttype );
1707 }
1708
1709 unsigned int wxDataViewListStore::GetColumnCount() const
1710 {
1711     return m_cols.GetCount();
1712 }
1713
1714 wxString wxDataViewListStore::GetColumnType( unsigned int pos ) const
1715 {
1716     return m_cols[pos];
1717 }
1718
1719 void wxDataViewListStore::AppendItem( const wxVector<wxVariant> &values, wxClientData *data )
1720 {
1721     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1722     line->m_values = values;
1723     m_data.push_back( line );
1724
1725     RowAppended();
1726 }
1727
1728 void wxDataViewListStore::PrependItem( const wxVector<wxVariant> &values, wxClientData *data )
1729 {
1730     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1731     line->m_values = values;
1732     m_data.insert( m_data.begin(), line );
1733
1734     RowPrepended();
1735 }
1736
1737 void wxDataViewListStore::InsertItem(  unsigned int row, const wxVector<wxVariant> &values,
1738                                        wxClientData *data )
1739 {
1740     wxDataViewListStoreLine *line = new wxDataViewListStoreLine( data );
1741     line->m_values = values;
1742     m_data.insert( m_data.begin()+row, line );
1743
1744     RowInserted( row );
1745 }
1746
1747 void wxDataViewListStore::DeleteItem( unsigned int row )
1748 {
1749     wxVector<wxDataViewListStoreLine*>::iterator it = m_data.begin() + row;
1750     delete *it;
1751     m_data.erase( it );
1752
1753     RowDeleted( row );
1754 }
1755
1756 void wxDataViewListStore::DeleteAllItems()
1757 {
1758     wxVector<wxDataViewListStoreLine*>::iterator it;
1759     for (it = m_data.begin(); it != m_data.end(); ++it)
1760     {
1761         wxDataViewListStoreLine* line = *it;
1762         delete line;
1763     }
1764
1765     m_data.clear();
1766
1767     Reset( 0 );
1768 }
1769
1770 void wxDataViewListStore::GetValueByRow( wxVariant &value, unsigned int row, unsigned int col ) const
1771 {
1772     wxDataViewListStoreLine *line = m_data[row];
1773     value = line->m_values[col];
1774 }
1775
1776 bool wxDataViewListStore::SetValueByRow( const wxVariant &value, unsigned int row, unsigned int col )
1777 {
1778     wxDataViewListStoreLine *line = m_data[row];
1779     line->m_values[col] = value;
1780
1781     return true;
1782 }
1783
1784 //-----------------------------------------------------------------------------
1785 // wxDataViewListCtrl
1786 //-----------------------------------------------------------------------------
1787
1788 IMPLEMENT_DYNAMIC_CLASS(wxDataViewListCtrl,wxDataViewCtrl)
1789
1790 BEGIN_EVENT_TABLE(wxDataViewListCtrl,wxDataViewCtrl)
1791    EVT_SIZE( wxDataViewListCtrl::OnSize )
1792 END_EVENT_TABLE()
1793
1794 wxDataViewListCtrl::wxDataViewListCtrl()
1795 {
1796 }
1797
1798 wxDataViewListCtrl::wxDataViewListCtrl( wxWindow *parent, wxWindowID id,
1799            const wxPoint& pos, const wxSize& size, long style,
1800            const wxValidator& validator )
1801 {
1802     Create( parent, id, pos, size, style, validator );
1803 }
1804
1805 wxDataViewListCtrl::~wxDataViewListCtrl()
1806 {
1807 }
1808
1809
1810 bool wxDataViewListCtrl::Create( wxWindow *parent, wxWindowID id,
1811            const wxPoint& pos, const wxSize& size, long style,
1812            const wxValidator& validator )
1813 {
1814     if ( !wxDataViewCtrl::Create( parent, id, pos, size, style, validator ) )
1815         return false;
1816
1817     wxDataViewListStore *store = new wxDataViewListStore;
1818     AssociateModel( store );
1819     store->DecRef();
1820
1821     return true;
1822 }
1823
1824 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *column, const wxString &varianttype )
1825 {
1826     GetStore()->AppendColumn( varianttype );
1827     return wxDataViewCtrl::AppendColumn( column );
1828 }
1829
1830 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *column, const wxString &varianttype )
1831 {
1832     GetStore()->PrependColumn( varianttype );
1833     return wxDataViewCtrl::PrependColumn( column );
1834 }
1835
1836 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *column, const wxString &varianttype )
1837 {
1838     GetStore()->InsertColumn( pos, varianttype );
1839     return wxDataViewCtrl::InsertColumn( pos, column );
1840 }
1841
1842 bool wxDataViewListCtrl::PrependColumn( wxDataViewColumn *col )
1843 {
1844     return PrependColumn( col, "string" );
1845 }
1846
1847 bool wxDataViewListCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
1848 {
1849     return InsertColumn( pos, col, "string" );
1850 }
1851
1852 bool wxDataViewListCtrl::AppendColumn( wxDataViewColumn *col )
1853 {
1854     return AppendColumn( col, "string" );
1855 }
1856
1857 wxDataViewColumn *wxDataViewListCtrl::AppendTextColumn( const wxString &label,
1858           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1859 {
1860     GetStore()->AppendColumn( wxT("string") );
1861
1862     wxDataViewColumn *ret = new wxDataViewColumn( label,
1863         new wxDataViewTextRenderer( wxT("string"), mode ),
1864         GetStore()->GetColumnCount()-1, width, align, flags );
1865
1866     wxDataViewCtrl::AppendColumn( ret );
1867
1868     return ret;
1869 }
1870
1871 wxDataViewColumn *wxDataViewListCtrl::AppendToggleColumn( const wxString &label,
1872           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1873 {
1874     GetStore()->AppendColumn( wxT("bool") );
1875
1876     wxDataViewColumn *ret = new wxDataViewColumn( label,
1877         new wxDataViewToggleRenderer( wxT("bool"), mode ),
1878         GetStore()->GetColumnCount()-1, width, align, flags );
1879
1880     wxDataViewCtrl::AppendColumn( ret );
1881
1882     return ret;
1883 }
1884
1885 wxDataViewColumn *wxDataViewListCtrl::AppendProgressColumn( const wxString &label,
1886           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1887 {
1888     GetStore()->AppendColumn( wxT("long") );
1889
1890     wxDataViewColumn *ret = new wxDataViewColumn( label,
1891         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode ),
1892         GetStore()->GetColumnCount()-1, width, align, flags );
1893
1894     wxDataViewCtrl::AppendColumn( ret );
1895
1896     return ret;
1897 }
1898
1899 wxDataViewColumn *wxDataViewListCtrl::AppendIconTextColumn( const wxString &label,
1900           wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1901 {
1902     GetStore()->AppendColumn( wxT("wxDataViewIconText") );
1903
1904     wxDataViewColumn *ret = new wxDataViewColumn( label,
1905         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode ),
1906         GetStore()->GetColumnCount()-1, width, align, flags );
1907
1908     wxDataViewCtrl::AppendColumn( ret );
1909
1910     return ret;
1911 }
1912
1913 void wxDataViewListCtrl::OnSize( wxSizeEvent &event )
1914 {
1915     event.Skip( true );
1916 }
1917
1918 //-----------------------------------------------------------------------------
1919 // wxDataViewTreeStore
1920 //-----------------------------------------------------------------------------
1921
1922 wxDataViewTreeStoreNode::wxDataViewTreeStoreNode(
1923         wxDataViewTreeStoreNode *parent,
1924         const wxString &text, const wxIcon &icon, wxClientData *data )
1925 {
1926     m_parent = parent;
1927     m_text = text;
1928     m_icon = icon;
1929     m_data = data;
1930 }
1931
1932 wxDataViewTreeStoreNode::~wxDataViewTreeStoreNode()
1933 {
1934     if (m_data)
1935         delete m_data;
1936 }
1937
1938 #include "wx/listimpl.cpp"
1939 WX_DEFINE_LIST(wxDataViewTreeStoreNodeList)
1940
1941 wxDataViewTreeStoreContainerNode::wxDataViewTreeStoreContainerNode(
1942         wxDataViewTreeStoreNode *parent, const wxString &text,
1943         const wxIcon &icon, const wxIcon &expanded, wxClientData *data ) :
1944     wxDataViewTreeStoreNode( parent, text, icon, data )
1945 {
1946     m_iconExpanded = expanded;
1947     m_isExpanded = false;
1948     m_children.DeleteContents(true);
1949 }
1950
1951 wxDataViewTreeStoreContainerNode::~wxDataViewTreeStoreContainerNode()
1952 {
1953 }
1954
1955 //-----------------------------------------------------------------------------
1956
1957 wxDataViewTreeStore::wxDataViewTreeStore()
1958 {
1959     m_root = new wxDataViewTreeStoreContainerNode( NULL, wxEmptyString );
1960 }
1961
1962 wxDataViewTreeStore::~wxDataViewTreeStore()
1963 {
1964     delete m_root;
1965 }
1966
1967 wxDataViewItem wxDataViewTreeStore::AppendItem( const wxDataViewItem& parent,
1968         const wxString &text, const wxIcon &icon, wxClientData *data )
1969 {
1970     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1971     if (!parent_node) return wxDataViewItem(0);
1972
1973     wxDataViewTreeStoreNode *node =
1974         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1975     parent_node->GetChildren().Append( node );
1976
1977     return node->GetItem();
1978 }
1979
1980 wxDataViewItem wxDataViewTreeStore::PrependItem( const wxDataViewItem& parent,
1981         const wxString &text, const wxIcon &icon, wxClientData *data )
1982 {
1983     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1984     if (!parent_node) return wxDataViewItem(0);
1985
1986     wxDataViewTreeStoreNode *node =
1987         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1988     parent_node->GetChildren().Insert( node );
1989
1990     return node->GetItem();
1991 }
1992
1993 wxDataViewItem
1994 wxDataViewTreeStore::InsertItem(const wxDataViewItem& parent,
1995                                 const wxDataViewItem& previous,
1996                                 const wxString& text,
1997                                 const wxIcon& icon,
1998                                 wxClientData *data)
1999 {
2000     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2001     if (!parent_node) return wxDataViewItem(0);
2002
2003     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
2004     int pos = parent_node->GetChildren().IndexOf( previous_node );
2005     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
2006
2007     wxDataViewTreeStoreNode *node =
2008         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
2009     parent_node->GetChildren().Insert( (size_t) pos, node );
2010
2011     return node->GetItem();
2012 }
2013
2014 wxDataViewItem wxDataViewTreeStore::PrependContainer( const wxDataViewItem& parent,
2015         const wxString &text, const wxIcon &icon, const wxIcon &expanded,
2016         wxClientData *data )
2017 {
2018     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2019     if (!parent_node) return wxDataViewItem(0);
2020
2021     wxDataViewTreeStoreContainerNode *node =
2022         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2023     parent_node->GetChildren().Insert( node );
2024
2025     return node->GetItem();
2026 }
2027
2028 wxDataViewItem
2029 wxDataViewTreeStore::AppendContainer(const wxDataViewItem& parent,
2030                                      const wxString &text,
2031                                      const wxIcon& icon,
2032                                      const wxIcon& expanded,
2033                                      wxClientData * data)
2034 {
2035     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2036     if (!parent_node) return wxDataViewItem(0);
2037
2038     wxDataViewTreeStoreContainerNode *node =
2039         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2040     parent_node->GetChildren().Append( node );
2041
2042     return node->GetItem();
2043 }
2044
2045 wxDataViewItem
2046 wxDataViewTreeStore::InsertContainer(const wxDataViewItem& parent,
2047                                      const wxDataViewItem& previous,
2048                                      const wxString& text,
2049                                      const wxIcon& icon,
2050                                      const wxIcon& expanded,
2051                                      wxClientData * data)
2052 {
2053     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2054     if (!parent_node) return wxDataViewItem(0);
2055
2056     wxDataViewTreeStoreNode *previous_node = FindNode( previous );
2057     int pos = parent_node->GetChildren().IndexOf( previous_node );
2058     if (pos == wxNOT_FOUND) return wxDataViewItem(0);
2059
2060     wxDataViewTreeStoreContainerNode *node =
2061         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
2062     parent_node->GetChildren().Insert( (size_t) pos, node );
2063
2064     return node->GetItem();
2065 }
2066
2067 bool wxDataViewTreeStore::IsContainer( const wxDataViewItem& item ) const
2068 {
2069     wxDataViewTreeStoreNode *node = FindNode( item );
2070     if (!node) return false;
2071
2072     return node->IsContainer();
2073 }
2074
2075 wxDataViewItem wxDataViewTreeStore::GetNthChild( const wxDataViewItem& parent, unsigned int pos ) const
2076 {
2077     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
2078     if (!parent_node) return wxDataViewItem(0);
2079
2080     wxDataViewTreeStoreNodeList::compatibility_iterator node = parent_node->GetChildren().Item( pos );
2081     if (node)
2082         return wxDataViewItem(node->GetData());
2083
2084     return wxDataViewItem(0);
2085 }
2086
2087 int wxDataViewTreeStore::GetChildCount( const wxDataViewItem& parent ) const
2088 {
2089     wxDataViewTreeStoreNode *node = FindNode( parent );
2090     if (!node) return -1;
2091
2092     if (!node->IsContainer())
2093         return 0;
2094
2095     wxDataViewTreeStoreContainerNode *container_node = (wxDataViewTreeStoreContainerNode*) node;
2096     return (int) container_node->GetChildren().GetCount();
2097 }
2098
2099 void wxDataViewTreeStore::SetItemText( const wxDataViewItem& item, const wxString &text )
2100 {
2101     wxDataViewTreeStoreNode *node = FindNode( item );
2102     if (!node) return;
2103
2104     node->SetText( text );
2105 }
2106
2107 wxString wxDataViewTreeStore::GetItemText( const wxDataViewItem& item ) const
2108 {
2109     wxDataViewTreeStoreNode *node = FindNode( item );
2110     if (!node) return wxEmptyString;
2111
2112     return node->GetText();
2113 }
2114
2115 void wxDataViewTreeStore::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2116 {
2117     wxDataViewTreeStoreNode *node = FindNode( item );
2118     if (!node) return;
2119
2120     node->SetIcon( icon );
2121 }
2122
2123 const wxIcon &wxDataViewTreeStore::GetItemIcon( const wxDataViewItem& item ) const
2124 {
2125     wxDataViewTreeStoreNode *node = FindNode( item );
2126     if (!node) return wxNullIcon;
2127
2128     return node->GetIcon();
2129 }
2130
2131 void wxDataViewTreeStore::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2132 {
2133     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2134     if (!node) return;
2135
2136     node->SetExpandedIcon( icon );
2137 }
2138
2139 const wxIcon &wxDataViewTreeStore::GetItemExpandedIcon( const wxDataViewItem& item ) const
2140 {
2141     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2142     if (!node) return wxNullIcon;
2143
2144     return node->GetExpandedIcon();
2145 }
2146
2147 void wxDataViewTreeStore::SetItemData( const wxDataViewItem& item, wxClientData *data )
2148 {
2149     wxDataViewTreeStoreNode *node = FindNode( item );
2150     if (!node) return;
2151
2152     node->SetData( data );
2153 }
2154
2155 wxClientData *wxDataViewTreeStore::GetItemData( const wxDataViewItem& item ) const
2156 {
2157     wxDataViewTreeStoreNode *node = FindNode( item );
2158     if (!node) return NULL;
2159
2160     return node->GetData();
2161 }
2162
2163 void wxDataViewTreeStore::DeleteItem( const wxDataViewItem& item )
2164 {
2165     if (!item.IsOk()) return;
2166
2167     wxDataViewItem parent_item = GetParent( item );
2168
2169     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent_item );
2170     if (!parent_node) return;
2171
2172     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2173     if (!node) return;
2174
2175     parent_node->GetChildren().DeleteObject( node );
2176 }
2177
2178 void wxDataViewTreeStore::DeleteChildren( const wxDataViewItem& item )
2179 {
2180     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2181     if (!node) return;
2182
2183     node->GetChildren().clear();
2184 }
2185
2186 void wxDataViewTreeStore::DeleteAllItems()
2187 {
2188     DeleteChildren(wxDataViewItem(m_root));
2189 }
2190
2191 void
2192 wxDataViewTreeStore::GetValue(wxVariant &variant,
2193                               const wxDataViewItem &item,
2194                               unsigned int WXUNUSED(col)) const
2195 {
2196     // if (col != 0) return;
2197
2198     wxDataViewTreeStoreNode *node = FindNode( item );
2199     if (!node) return;
2200
2201     wxIcon icon( node->GetIcon());
2202     if (node->IsContainer())
2203     {
2204         wxDataViewTreeStoreContainerNode *container = (wxDataViewTreeStoreContainerNode*) node;
2205         if (container->IsExpanded() && container->GetExpandedIcon().IsOk())
2206            icon = container->GetExpandedIcon();
2207     }
2208
2209     wxDataViewIconText data( node->GetText(), icon );
2210
2211     variant << data;
2212 }
2213
2214 bool
2215 wxDataViewTreeStore::SetValue(const wxVariant& variant,
2216                               const wxDataViewItem& item,
2217                               unsigned int WXUNUSED(col))
2218 {
2219     // if (col != 0) return false;
2220
2221     wxDataViewTreeStoreNode *node = FindNode( item );
2222     if (!node) return false;
2223
2224     wxDataViewIconText data;
2225
2226     data << variant;
2227
2228     node->SetText( data.GetText() );
2229     node->SetIcon( data.GetIcon() );
2230
2231     return true;
2232 }
2233
2234 wxDataViewItem wxDataViewTreeStore::GetParent( const wxDataViewItem &item ) const
2235 {
2236     wxDataViewTreeStoreNode *node = FindNode( item );
2237     if (!node) return wxDataViewItem(0);
2238
2239     wxDataViewTreeStoreNode *parent = node->GetParent();
2240     if (!parent) return wxDataViewItem(0);
2241
2242     if (parent == m_root)
2243         return wxDataViewItem(0);
2244
2245     return parent->GetItem();
2246 }
2247
2248 unsigned int wxDataViewTreeStore::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
2249 {
2250     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
2251     if (!node) return 0;
2252
2253     wxDataViewTreeStoreNodeList::iterator iter;
2254     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2255     {
2256         wxDataViewTreeStoreNode* child = *iter;
2257         children.Add( child->GetItem() );
2258     }
2259
2260     return node->GetChildren().GetCount();
2261 }
2262
2263 int wxDataViewTreeStore::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
2264                          unsigned int WXUNUSED(column), bool WXUNUSED(ascending) ) const
2265 {
2266     wxDataViewTreeStoreNode *node1 = FindNode( item1 );
2267     wxDataViewTreeStoreNode *node2 = FindNode( item2 );
2268
2269     if (!node1 || !node2)
2270         return 0;
2271
2272     wxDataViewTreeStoreContainerNode* parent1 =
2273         (wxDataViewTreeStoreContainerNode*) node1->GetParent();
2274     wxDataViewTreeStoreContainerNode* parent2 =
2275         (wxDataViewTreeStoreContainerNode*) node2->GetParent();
2276
2277     if (parent1 != parent2)
2278     {
2279         wxLogError( wxT("Comparing items with different parent.") );
2280         return 0;
2281     }
2282
2283     if (node1->IsContainer() && !node2->IsContainer())
2284         return -1;
2285
2286     if (node2->IsContainer() && !node1->IsContainer())
2287         return 1;
2288
2289     return parent1->GetChildren().IndexOf( node1 ) - parent2->GetChildren().IndexOf( node2 );
2290 }
2291
2292 wxDataViewTreeStoreNode *wxDataViewTreeStore::FindNode( const wxDataViewItem &item ) const
2293 {
2294     if (!item.IsOk())
2295         return m_root;
2296
2297     return (wxDataViewTreeStoreNode*) item.GetID();
2298 }
2299
2300 wxDataViewTreeStoreContainerNode *wxDataViewTreeStore::FindContainerNode( const wxDataViewItem &item ) const
2301 {
2302     if (!item.IsOk())
2303         return (wxDataViewTreeStoreContainerNode*) m_root;
2304
2305     wxDataViewTreeStoreNode* node = (wxDataViewTreeStoreNode*) item.GetID();
2306
2307     if (!node->IsContainer())
2308         return NULL;
2309
2310     return (wxDataViewTreeStoreContainerNode*) node;
2311 }
2312
2313 //-----------------------------------------------------------------------------
2314 // wxDataViewTreeCtrl
2315 //-----------------------------------------------------------------------------
2316
2317 IMPLEMENT_DYNAMIC_CLASS(wxDataViewTreeCtrl,wxDataViewCtrl)
2318
2319 BEGIN_EVENT_TABLE(wxDataViewTreeCtrl,wxDataViewCtrl)
2320    EVT_DATAVIEW_ITEM_EXPANDED(-1, wxDataViewTreeCtrl::OnExpanded)
2321    EVT_DATAVIEW_ITEM_COLLAPSED(-1, wxDataViewTreeCtrl::OnCollapsed)
2322    EVT_SIZE( wxDataViewTreeCtrl::OnSize )
2323 END_EVENT_TABLE()
2324
2325 bool wxDataViewTreeCtrl::Create( wxWindow *parent, wxWindowID id,
2326            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
2327 {
2328     if ( !wxDataViewCtrl::Create( parent, id, pos, size, style, validator ) )
2329         return false;
2330
2331     // create the standard model and a column in the tree
2332     wxDataViewTreeStore *store = new wxDataViewTreeStore;
2333     AssociateModel( store );
2334     store->DecRef();
2335
2336     AppendIconTextColumn
2337     (
2338         wxString(),                 // no label (header is not shown anyhow)
2339         0,                          // the only model column
2340         wxDATAVIEW_CELL_EDITABLE,
2341         -1,                         // default width
2342         wxALIGN_NOT,                //  and alignment
2343         0                           // not resizable
2344     );
2345
2346     return true;
2347 }
2348
2349 wxDataViewItem wxDataViewTreeCtrl::AppendItem( const wxDataViewItem& parent,
2350         const wxString &text, int iconIndex, wxClientData *data )
2351 {
2352     wxDataViewItem res = GetStore()->
2353         AppendItem( parent, text, GetImage(iconIndex), data );
2354
2355     GetStore()->ItemAdded( parent, res );
2356
2357     return res;
2358 }
2359
2360 wxDataViewItem wxDataViewTreeCtrl::PrependItem( const wxDataViewItem& parent,
2361         const wxString &text, int iconIndex, wxClientData *data )
2362 {
2363     wxDataViewItem res = GetStore()->
2364         PrependItem( parent, text, GetImage(iconIndex), data );
2365
2366     GetStore()->ItemAdded( parent, res );
2367
2368     return res;
2369 }
2370
2371 wxDataViewItem wxDataViewTreeCtrl::InsertItem( const wxDataViewItem& parent, const wxDataViewItem& previous,
2372         const wxString &text, int iconIndex, wxClientData *data )
2373 {
2374     wxDataViewItem res = GetStore()->
2375         InsertItem( parent, previous, text, GetImage(iconIndex), data );
2376
2377     GetStore()->ItemAdded( parent, res );
2378
2379     return res;
2380 }
2381
2382 wxDataViewItem wxDataViewTreeCtrl::PrependContainer( const wxDataViewItem& parent,
2383         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2384 {
2385     wxDataViewItem res = GetStore()->
2386         PrependContainer( parent, text,
2387                           GetImage(iconIndex), GetImage(expandedIndex), data );
2388
2389     GetStore()->ItemAdded( parent, res );
2390
2391     return res;
2392 }
2393
2394 wxDataViewItem wxDataViewTreeCtrl::AppendContainer( const wxDataViewItem& parent,
2395         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2396 {
2397     wxDataViewItem res = GetStore()->
2398         AppendContainer( parent, text,
2399                          GetImage(iconIndex), GetImage(expandedIndex), data );
2400
2401     GetStore()->ItemAdded( parent, res );
2402
2403     return res;
2404 }
2405
2406 wxDataViewItem wxDataViewTreeCtrl::InsertContainer( const wxDataViewItem& parent, const wxDataViewItem& previous,
2407         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
2408 {
2409     wxDataViewItem res = GetStore()->
2410         InsertContainer( parent, previous, text,
2411                          GetImage(iconIndex), GetImage(expandedIndex), data );
2412
2413     GetStore()->ItemAdded( parent, res );
2414
2415     return res;
2416 }
2417
2418 void wxDataViewTreeCtrl::SetItemText( const wxDataViewItem& item, const wxString &text )
2419 {
2420     GetStore()->SetItemText(item,text);
2421
2422     // notify control
2423     GetStore()->ValueChanged( item, 0 );
2424 }
2425
2426 void wxDataViewTreeCtrl::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
2427 {
2428     GetStore()->SetItemIcon(item,icon);
2429
2430     // notify control
2431     GetStore()->ValueChanged( item, 0 );
2432 }
2433
2434 void wxDataViewTreeCtrl::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
2435 {
2436     GetStore()->SetItemExpandedIcon(item,icon);
2437
2438     // notify control
2439     GetStore()->ValueChanged( item, 0 );
2440 }
2441
2442 void wxDataViewTreeCtrl::DeleteItem( const wxDataViewItem& item )
2443 {
2444     wxDataViewItem parent_item = GetStore()->GetParent( item );
2445
2446     GetStore()->DeleteItem(item);
2447
2448     // notify control
2449     GetStore()->ItemDeleted( parent_item, item );
2450 }
2451
2452 void wxDataViewTreeCtrl::DeleteChildren( const wxDataViewItem& item )
2453 {
2454     wxDataViewTreeStoreContainerNode *node = GetStore()->FindContainerNode( item );
2455     if (!node) return;
2456
2457     wxDataViewItemArray array;
2458     wxDataViewTreeStoreNodeList::iterator iter;
2459     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
2460     {
2461         wxDataViewTreeStoreNode* child = *iter;
2462         array.Add( child->GetItem() );
2463     }
2464
2465     GetStore()->DeleteChildren( item );
2466
2467     // notify control
2468     GetStore()->ItemsDeleted( item, array );
2469 }
2470
2471 void  wxDataViewTreeCtrl::DeleteAllItems()
2472 {
2473     GetStore()->DeleteAllItems();
2474
2475     GetStore()->Cleared();
2476 }
2477
2478 void wxDataViewTreeCtrl::OnExpanded( wxDataViewEvent &event )
2479 {
2480     if (HasImageList()) return;
2481
2482     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2483     if (!container) return;
2484
2485     container->SetExpanded( true );
2486
2487     GetStore()->ItemChanged( event.GetItem() );
2488 }
2489
2490 void wxDataViewTreeCtrl::OnCollapsed( wxDataViewEvent &event )
2491 {
2492     if (HasImageList()) return;
2493
2494     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
2495     if (!container) return;
2496
2497     container->SetExpanded( false );
2498
2499     GetStore()->ItemChanged( event.GetItem() );
2500 }
2501
2502 void wxDataViewTreeCtrl::OnSize( wxSizeEvent &event )
2503 {
2504 #if defined(wxUSE_GENERICDATAVIEWCTRL)
2505     // automatically resize our only column to take the entire control width
2506     if ( GetColumnCount() )
2507     {
2508         wxSize size = GetClientSize();
2509         GetColumn(0)->SetWidth(size.x);
2510     }
2511 #endif
2512     event.Skip( true );
2513 }
2514
2515 #endif // wxUSE_DATAVIEWCTRL
2516