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