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