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