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 #include "wx/spinctrl.h"
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/dc.h"
  26     #include "wx/settings.h"
  27     #include "wx/log.h"
  28     #include "wx/icon.h"
  29     #include "wx/crt.h"
  30 #endif
  31
  32 const wxChar wxDataViewCtrlNameStr[] = wxT("dataviewCtrl");
  33
  34
  35 bool operator == (const wxDataViewItem &left, const wxDataViewItem &right)
  36 {
  37     return (left.GetID() == right.GetID() );
  38 }
  39
  40 #ifdef __WXDEBUG__
  41 void wxDataViewItem::Print(const wxString& text) const
  42 {
  43     wxPrintf(wxT("item %s: %l\n"), text.GetData(), (long)m_id);
  44 }
  45 #endif
  46
  47 // ---------------------------------------------------------
  48 // wxDataViewModelNotifier
  49 // ---------------------------------------------------------
  50
  51 #include "wx/listimpl.cpp"
  52 WX_DEFINE_LIST(wxDataViewModelNotifiers)
  53
  54 bool wxDataViewModelNotifier::ItemsAdded( const wxDataViewItem &parent, const wxDataViewItemArray &items )
  55 {
  56     size_t count = items.GetCount();
  57     size_t i;
  58     for (i = 0; i < count; i++)
  59         if (!ItemAdded( parent, items[i] )) return false;
  60
  61     return true;
  62 }
  63
  64 bool wxDataViewModelNotifier::ItemsDeleted( const wxDataViewItem &parent, const wxDataViewItemArray &items )
  65 {
  66     size_t count = items.GetCount();
  67     size_t i;
  68     for (i = 0; i < count; i++)
  69         if (!ItemDeleted( parent, items[i] )) return false;
  70
  71     return true;
  72 }
  73
  74 bool wxDataViewModelNotifier::ItemsChanged( const wxDataViewItemArray &items )
  75 {
  76     size_t count = items.GetCount();
  77     size_t i;
  78     for (i = 0; i < count; i++)
  79         if (!ItemChanged( items[i] )) return false;
  80
  81     return true;
  82 }
  83
  84 // ---------------------------------------------------------
  85 // wxDataViewModel
  86 // ---------------------------------------------------------
  87
  88 wxDataViewModel::wxDataViewModel()
  89 {
  90     m_notifiers.DeleteContents( true );
  91 }
  92
  93 bool wxDataViewModel::ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item )
  94 {
  95     bool ret = true;
  96
  97     wxDataViewModelNotifiers::iterator iter;
  98     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
  99     {
 100         wxDataViewModelNotifier* notifier = *iter;
 101         if (!notifier->ItemAdded( parent, item ))
 102             ret = false;
 103     }
 104
 105     return ret;
 106 }
 107
 108 bool wxDataViewModel::ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
 109 {
 110     bool ret = true;
 111
 112     wxDataViewModelNotifiers::iterator iter;
 113     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 114     {
 115         wxDataViewModelNotifier* notifier = *iter;
 116         if (!notifier->ItemDeleted( parent, item ))
 117             ret = false;
 118     }
 119
 120     return ret;
 121 }
 122
 123 bool wxDataViewModel::ItemChanged( const wxDataViewItem &item )
 124 {
 125     bool ret = true;
 126
 127     wxDataViewModelNotifiers::iterator iter;
 128     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 129     {
 130         wxDataViewModelNotifier* notifier = *iter;
 131         if (!notifier->ItemChanged( item ))
 132             ret = false;
 133     }
 134
 135     return ret;
 136 }
 137
 138 bool wxDataViewModel::ItemsAdded( const wxDataViewItem &parent, const wxDataViewItemArray &items )
 139 {
 140     bool ret = true;
 141
 142     wxDataViewModelNotifiers::iterator iter;
 143     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 144     {
 145         wxDataViewModelNotifier* notifier = *iter;
 146         if (!notifier->ItemsAdded( parent, items ))
 147             ret = false;
 148     }
 149
 150     return ret;
 151 }
 152
 153 bool wxDataViewModel::ItemsDeleted( const wxDataViewItem &parent, const wxDataViewItemArray &items )
 154 {
 155     bool ret = true;
 156
 157     wxDataViewModelNotifiers::iterator iter;
 158     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 159     {
 160         wxDataViewModelNotifier* notifier = *iter;
 161         if (!notifier->ItemsDeleted( parent, items ))
 162             ret = false;
 163     }
 164
 165     return ret;
 166 }
 167
 168 bool wxDataViewModel::ItemsChanged( const wxDataViewItemArray &items )
 169 {
 170     bool ret = true;
 171
 172     wxDataViewModelNotifiers::iterator iter;
 173     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 174     {
 175         wxDataViewModelNotifier* notifier = *iter;
 176         if (!notifier->ItemsChanged( items ))
 177             ret = false;
 178     }
 179
 180     return ret;
 181 }
 182
 183 bool wxDataViewModel::ValueChanged( const wxDataViewItem &item, unsigned int col )
 184 {
 185     bool ret = true;
 186
 187     wxDataViewModelNotifiers::iterator iter;
 188     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 189     {
 190         wxDataViewModelNotifier* notifier = *iter;
 191         if (!notifier->ValueChanged( item, col ))
 192             ret = false;
 193     }
 194
 195     return ret;
 196 }
 197
 198 bool wxDataViewModel::Cleared()
 199 {
 200     bool ret = true;
 201
 202     wxDataViewModelNotifiers::iterator iter;
 203     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 204     {
 205         wxDataViewModelNotifier* notifier = *iter;
 206         if (!notifier->Cleared())
 207             ret = false;
 208     }
 209
 210     return ret;
 211 }
 212
 213 void wxDataViewModel::Resort()
 214 {
 215     wxDataViewModelNotifiers::iterator iter;
 216     for (iter = m_notifiers.begin(); iter != m_notifiers.end(); ++iter)
 217     {
 218         wxDataViewModelNotifier* notifier = *iter;
 219         notifier->Resort();
 220     }
 221 }
 222
 223 void wxDataViewModel::AddNotifier( wxDataViewModelNotifier *notifier )
 224 {
 225     m_notifiers.push_back( notifier );
 226     notifier->SetOwner( this );
 227 }
 228
 229 void wxDataViewModel::RemoveNotifier( wxDataViewModelNotifier *notifier )
 230 {
 231     m_notifiers.DeleteObject( notifier );
 232 }
 233
 234 int wxDataViewModel::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
 235                               unsigned int column, bool ascending )
 236 {
 237     // sort branches before leaves
 238     bool item1_is_container = IsContainer(item1);
 239     bool item2_is_container = IsContainer(item2);
 240
 241     if (item1_is_container && !item2_is_container)
 242         return 1;
 243     if (item2_is_container && !item1_is_container)
 244         return -1;
 245
 246     wxVariant value1,value2;
 247     GetValue( value1, item1, column );
 248     GetValue( value2, item2, column );
 249
 250     if (!ascending)
 251     {
 252         wxVariant temp = value1;
 253         value1 = value2;
 254         value2 = temp;
 255     }
 256
 257     if (value1.GetType() == wxT("string"))
 258     {
 259         wxString str1 = value1.GetString();
 260         wxString str2 = value2.GetString();
 261         int res = str1.Cmp( str2 );
 262         if (res) return res;
 263     } else
 264     if (value1.GetType() == wxT("long"))
 265     {
 266         long l1 = value1.GetLong();
 267         long l2 = value2.GetLong();
 268         long res = l1-l2;
 269         if (res) return res;
 270     } else
 271     if (value1.GetType() == wxT("double"))
 272     {
 273         double d1 = value1.GetDouble();
 274         double d2 = value2.GetDouble();
 275         if (d1 < d2) return 1;
 276         if (d1 > d2) return -1;
 277     } else
 278     if (value1.GetType() == wxT("datetime"))
 279     {
 280         wxDateTime dt1 = value1.GetDateTime();
 281         wxDateTime dt2 = value2.GetDateTime();
 282         if (dt1.IsEarlierThan(dt2)) return 1;
 283         if (dt2.IsEarlierThan(dt1)) return -11;
 284     }
 285
 286     // items must be different
 287     unsigned long litem1 = (unsigned long) item1.GetID();
 288     unsigned long litem2 = (unsigned long) item2.GetID();
 289
 290     if (!ascending)
 291         return litem2-litem2;
 292
 293     return litem1-litem2;
 294 }
 295
 296 // ---------------------------------------------------------
 297 // wxDataViewIndexListModel
 298 // ---------------------------------------------------------
 299
 300 static int my_sort( int *v1, int *v2 )
 301 {
 302    return *v2-*v1;
 303 }
 304
 305
 306 wxDataViewIndexListModel::wxDataViewIndexListModel( unsigned int initial_size )
 307 {
 308     // IDs are ordered until an item gets deleted or inserted
 309     m_ordered = true;
 310
 311     // build initial index
 312     unsigned int i;
 313     for (i = 1; i < initial_size+1; i++)
 314             m_hash.Add( (void*) i );
 315     m_lastIndex = initial_size + 1;
 316 }
 317
 318 wxDataViewIndexListModel::~wxDataViewIndexListModel()
 319 {
 320 }
 321
 322 void wxDataViewIndexListModel::Reset( unsigned int new_size )
 323 {
 324     m_hash.Clear();
 325
 326     // IDs are ordered until an item gets deleted or inserted
 327     m_ordered = true;
 328
 329     // build initial index
 330     unsigned int i;
 331     for (i = 1; i < new_size+1; i++)
 332             m_hash.Add( (void*) i );
 333     m_lastIndex = new_size + 1;
 334
 335     wxDataViewModel::Cleared();
 336 }
 337
 338 void wxDataViewIndexListModel::RowPrepended()
 339 {
 340     m_ordered = false;
 341
 342     unsigned int id = m_lastIndex++;
 343     m_hash.Insert( (void*) id, 0 );
 344     wxDataViewItem item( (void*) id );
 345     ItemAdded( wxDataViewItem(0), item );
 346 }
 347
 348 void wxDataViewIndexListModel::RowInserted( unsigned int before )
 349 {
 350     m_ordered = false;
 351
 352     unsigned int id = m_lastIndex++;
 353     m_hash.Insert( (void*) id, before );
 354     wxDataViewItem item( (void*) id );
 355     ItemAdded( wxDataViewItem(0), item );
 356 }
 357
 358 void wxDataViewIndexListModel::RowAppended()
 359 {
 360     unsigned int id = m_lastIndex++;
 361     m_hash.Add( (void*) id );
 362     wxDataViewItem item( (void*) id );
 363     ItemAdded( wxDataViewItem(0), item );
 364 }
 365
 366 void wxDataViewIndexListModel::RowDeleted( unsigned int row )
 367 {
 368     m_ordered = false;
 369
 370     wxDataViewItem item( m_hash[row] );
 371     wxDataViewModel::ItemDeleted( wxDataViewItem(0), item );
 372     m_hash.RemoveAt( row );
 373 }
 374
 375 void wxDataViewIndexListModel::RowsDeleted( const wxArrayInt &rows )
 376 {
 377     wxArrayInt sorted = rows;
 378     sorted.Sort( my_sort );
 379
 380     m_ordered = false;
 381
 382     wxDataViewItemArray array;
 383     unsigned int i;
 384     for (i = 0; i < rows.GetCount(); i++)
 385     {
 386             wxDataViewItem item( m_hash[rows[i]] );
 387             array.Add( item );
 388     }
 389     wxDataViewModel::ItemsDeleted( wxDataViewItem(0), array );
 390
 391     for (i = 0; i < sorted.GetCount(); i++)
 392            m_hash.RemoveAt( sorted[i] );
 393 }
 394
 395 void wxDataViewIndexListModel::RowChanged( unsigned int row )
 396 {
 397     wxDataViewModel::ItemChanged( GetItem(row) );
 398 }
 399
 400 void wxDataViewIndexListModel::RowValueChanged( unsigned int row, unsigned int col )
 401 {
 402     wxDataViewModel::ValueChanged( GetItem(row), col );
 403 }
 404
 405 unsigned int wxDataViewIndexListModel::GetRow( const wxDataViewItem &item ) const
 406 {
 407     if (m_ordered)
 408     {
 409             unsigned int pos = wxPtrToUInt( item.GetID() );
 410             return pos-1;
 411     }
 412
 413     // assert for not found
 414     return (unsigned int) m_hash.Index( item.GetID() );
 415 }
 416
 417 wxDataViewItem wxDataViewIndexListModel::GetItem( unsigned int row ) const
 418 {
 419     wxASSERT( row < m_hash.GetCount() );
 420     return wxDataViewItem( m_hash[row] );
 421 }
 422
 423 bool wxDataViewIndexListModel::HasDefaultCompare() const
 424 {
 425     return !m_ordered;
 426 }
 427
 428 int wxDataViewIndexListModel::Compare(const wxDataViewItem& item1,
 429                                       const wxDataViewItem& item2,
 430                                       unsigned int WXUNUSED(column),
 431                                       bool ascending)
 432 {
 433     if (m_ordered)
 434     {
 435         unsigned int pos1 = wxPtrToUInt(item1.GetID());
 436         unsigned int pos2 = wxPtrToUInt(item2.GetID());
 437
 438         if (ascending)
 439             return pos1 - pos2;
 440         else
 441             return pos2 - pos1;
 442     }
 443
 444     if (ascending)
 445         return GetRow(item1) - GetRow(item2);
 446
 447     return GetRow(item2) - GetRow(item1);
 448 }
 449
 450 void wxDataViewIndexListModel::GetValue( wxVariant &variant,
 451                            const wxDataViewItem &item, unsigned int col ) const
 452 {
 453     GetValue( variant, GetRow(item), col );
 454 }
 455
 456 bool wxDataViewIndexListModel::SetValue( const wxVariant &variant,
 457                            const wxDataViewItem &item, unsigned int col )
 458 {
 459     return SetValue( variant, GetRow(item), col );
 460 }
 461
 462 bool wxDataViewIndexListModel::GetAttr( const wxDataViewItem &item, unsigned int col, wxDataViewItemAttr &attr )
 463 {
 464     return GetAttr( GetRow(item), col, attr );
 465 }
 466
 467 wxDataViewItem wxDataViewIndexListModel::GetParent( const wxDataViewItem & WXUNUSED(item) ) const
 468 {
 469     return wxDataViewItem(0);
 470 }
 471
 472 bool wxDataViewIndexListModel::IsContainer( const wxDataViewItem &item ) const
 473 {
 474     // only the invisible root item has children
 475     if (!item.IsOk())
 476         return true;
 477
 478     return false;
 479 }
 480
 481 unsigned int wxDataViewIndexListModel::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
 482 {
 483     if (item.IsOk())
 484         return 0;
 485
 486     children = m_hash;
 487
 488     return m_hash.GetCount();
 489 }
 490
 491 // ---------------------------------------------------------
 492 // wxDataViewVirtualListModel
 493 // ---------------------------------------------------------
 494
 495 #ifndef __WXMAC__
 496
 497 wxDataViewVirtualListModel::wxDataViewVirtualListModel( unsigned int initial_size )
 498 {
 499     m_lastIndex = initial_size-1;
 500 }
 501
 502 wxDataViewVirtualListModel::~wxDataViewVirtualListModel()
 503 {
 504 }
 505
 506 void wxDataViewVirtualListModel::Reset( unsigned int new_size )
 507 {
 508     m_lastIndex = new_size-1;
 509
 510     wxDataViewModel::Cleared();
 511 }
 512
 513 void wxDataViewVirtualListModel::RowPrepended()
 514 {
 515     m_lastIndex++;
 516     wxDataViewItem item( (void*) 0 );
 517     ItemAdded( wxDataViewItem(0), item );
 518 }
 519
 520 void wxDataViewVirtualListModel::RowInserted( unsigned int before )
 521 {
 522     m_lastIndex++;
 523     wxDataViewItem item( (void*) before );
 524     ItemAdded( wxDataViewItem(0), item );
 525 }
 526
 527 void wxDataViewVirtualListModel::RowAppended()
 528 {
 529     m_lastIndex++;
 530     wxDataViewItem item( (void*) m_lastIndex );
 531     ItemAdded( wxDataViewItem(0), item );
 532 }
 533
 534 void wxDataViewVirtualListModel::RowDeleted( unsigned int row )
 535 {
 536     wxDataViewItem item( (void*) row );
 537     wxDataViewModel::ItemDeleted( wxDataViewItem(0), item );
 538     m_lastIndex++;
 539 }
 540
 541 void wxDataViewVirtualListModel::RowsDeleted( const wxArrayInt &rows )
 542 {
 543     wxArrayInt sorted = rows;
 544     sorted.Sort( my_sort );
 545
 546     wxDataViewItemArray array;
 547     unsigned int i;
 548     for (i = 0; i < sorted.GetCount(); i++)
 549     {
 550             wxDataViewItem item( (void*) sorted[i] );
 551             array.Add( item );
 552     }
 553     wxDataViewModel::ItemsDeleted( wxDataViewItem(0), array );
 554
 555     m_lastIndex -= rows.GetCount();
 556 }
 557
 558 void wxDataViewVirtualListModel::RowChanged( unsigned int row )
 559 {
 560     wxDataViewModel::ItemChanged( GetItem(row) );
 561 }
 562
 563 void wxDataViewVirtualListModel::RowValueChanged( unsigned int row, unsigned int col )
 564 {
 565     wxDataViewModel::ValueChanged( GetItem(row), col );
 566 }
 567
 568 unsigned int wxDataViewVirtualListModel::GetRow( const wxDataViewItem &item ) const
 569 {
 570     return wxPtrToUInt( item.GetID() );
 571 }
 572
 573 wxDataViewItem wxDataViewVirtualListModel::GetItem( unsigned int row ) const
 574 {
 575     return wxDataViewItem( (void*) row  );
 576 }
 577
 578 bool wxDataViewVirtualListModel::HasDefaultCompare() const
 579 {
 580     return true;
 581 }
 582
 583 int wxDataViewVirtualListModel::Compare(const wxDataViewItem& item1,
 584                                       const wxDataViewItem& item2,
 585                                       unsigned int WXUNUSED(column),
 586                                       bool ascending)
 587 {
 588     unsigned int pos1 = wxPtrToUInt(item1.GetID());
 589     unsigned int pos2 = wxPtrToUInt(item2.GetID());
 590
 591     if (ascending)
 592        return pos1 - pos2;
 593     else
 594        return pos2 - pos1;
 595 }
 596
 597 void wxDataViewVirtualListModel::GetValue( wxVariant &variant,
 598                            const wxDataViewItem &item, unsigned int col ) const
 599 {
 600     GetValue( variant, GetRow(item), col );
 601 }
 602
 603 bool wxDataViewVirtualListModel::SetValue( const wxVariant &variant,
 604                            const wxDataViewItem &item, unsigned int col )
 605 {
 606     return SetValue( variant, GetRow(item), col );
 607 }
 608
 609 bool wxDataViewVirtualListModel::GetAttr( const wxDataViewItem &item, unsigned int col, wxDataViewItemAttr &attr )
 610 {
 611     return GetAttr( GetRow(item), col, attr );
 612 }
 613
 614 wxDataViewItem wxDataViewVirtualListModel::GetParent( const wxDataViewItem & WXUNUSED(item) ) const
 615 {
 616     return wxDataViewItem(0);
 617 }
 618
 619 bool wxDataViewVirtualListModel::IsContainer( const wxDataViewItem &item ) const
 620 {
 621     // only the invisible root item has children
 622     if (!item.IsOk())
 623         return true;
 624
 625     return false;
 626 }
 627
 628 unsigned int wxDataViewVirtualListModel::GetChildren( const wxDataViewItem &WXUNUSED(item), wxDataViewItemArray &WXUNUSED(children) ) const
 629 {
 630     return 0;  // should we report an error ?
 631 }
 632
 633 #endif  // __WXMAC__
 634
 635 //-----------------------------------------------------------------------------
 636 // wxDataViewIconText
 637 //-----------------------------------------------------------------------------
 638
 639 IMPLEMENT_DYNAMIC_CLASS(wxDataViewIconText,wxObject)
 640
 641 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxDataViewIconText, WXDLLIMPEXP_ADV)
 642
 643 bool operator == (const wxDataViewIconText &one, const wxDataViewIconText &two)
 644 {
 645     if (one.GetText() != two.GetText()) return false;
 646     if (one.IsSameAs(two)) return false;
 647     return true;
 648 }
 649
 650 // ---------------------------------------------------------
 651 // wxDataViewRendererBase
 652 // ---------------------------------------------------------
 653
 654 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRendererBase, wxObject)
 655
 656 wxDataViewRendererBase::wxDataViewRendererBase( const wxString &varianttype,
 657                                                 wxDataViewCellMode WXUNUSED(mode),
 658                                                 int WXUNUSED(align) )
 659 {
 660     m_variantType = varianttype;
 661     m_editorCtrl = NULL;
 662 }
 663
 664 const wxDataViewCtrl* wxDataViewRendererBase::GetView() const
 665 {
 666     return wx_const_cast(wxDataViewRendererBase*, this)->GetOwner()->GetOwner();
 667 }
 668
 669 bool wxDataViewRendererBase::StartEditing( const wxDataViewItem &item, wxRect labelRect )
 670 {
 671     m_item = item; // remember for later
 672
 673     unsigned int col = GetOwner()->GetModelColumn();
 674     wxVariant value;
 675     GetOwner()->GetOwner()->GetModel()->GetValue( value, item, col );
 676
 677     m_editorCtrl = CreateEditorCtrl( GetOwner()->GetOwner()->GetMainWindow(), labelRect, value );
 678
 679     wxDataViewEditorCtrlEvtHandler *handler =
 680         new wxDataViewEditorCtrlEvtHandler( m_editorCtrl, (wxDataViewRenderer*) this );
 681
 682     m_editorCtrl->PushEventHandler( handler );
 683
 684 #if defined(__WXGTK20__) && !defined(wxUSE_GENERICDATAVIEWCTRL)
 685     handler->SetFocusOnIdle();
 686 #else
 687     m_editorCtrl->SetFocus();
 688 #endif
 689
 690     // Now we should send Editing Started event
 691     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, GetOwner()->GetOwner()->GetId() );
 692     event.SetDataViewColumn( GetOwner() );
 693     event.SetModel( GetOwner()->GetOwner()->GetModel() );
 694     event.SetItem( item );
 695     GetOwner()->GetOwner()->GetEventHandler()->ProcessEvent( event );
 696
 697     return true;
 698 }
 699
 700 void wxDataViewRendererBase::CancelEditing()
 701 {
 702     wxPendingDelete.Append( m_editorCtrl );
 703
 704     GetOwner()->GetOwner()->GetMainWindow()->SetFocus();
 705
 706     // m_editorCtrl->PopEventHandler( true );
 707 }
 708
 709 bool wxDataViewRendererBase::FinishEditing()
 710 {
 711     wxVariant value;
 712     GetValueFromEditorCtrl( m_editorCtrl, value );
 713
 714     wxPendingDelete.Append( m_editorCtrl );
 715
 716     GetOwner()->GetOwner()->GetMainWindow()->SetFocus();
 717
 718     if (!Validate(value))
 719         return false;
 720
 721     unsigned int col = GetOwner()->GetModelColumn();
 722     GetOwner()->GetOwner()->GetModel()->SetValue( value, m_item, col );
 723     GetOwner()->GetOwner()->GetModel()->ValueChanged( m_item, col );
 724
 725     // m_editorCtrl->PopEventHandler( true );
 726
 727     // Now we should send Editing Done event
 728     wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, GetOwner()->GetOwner()->GetId() );
 729     event.SetDataViewColumn( GetOwner() );
 730     event.SetModel( GetOwner()->GetOwner()->GetModel() );
 731     event.SetItem( m_item );
 732     GetOwner()->GetOwner()->GetEventHandler()->ProcessEvent( event );
 733
 734     return true;
 735 }
 736
 737 //-----------------------------------------------------------------------------
 738 // wxDataViewEditorCtrlEvtHandler
 739 //-----------------------------------------------------------------------------
 740
 741 BEGIN_EVENT_TABLE(wxDataViewEditorCtrlEvtHandler, wxEvtHandler)
 742     EVT_CHAR           (wxDataViewEditorCtrlEvtHandler::OnChar)
 743     EVT_KILL_FOCUS     (wxDataViewEditorCtrlEvtHandler::OnKillFocus)
 744     EVT_IDLE           (wxDataViewEditorCtrlEvtHandler::OnIdle)
 745 END_EVENT_TABLE()
 746
 747 wxDataViewEditorCtrlEvtHandler::wxDataViewEditorCtrlEvtHandler(
 748                                 wxControl *editorCtrl,
 749                                 wxDataViewRenderer *owner )
 750 {
 751     m_owner = owner;
 752     m_editorCtrl = editorCtrl;
 753
 754     m_finished = false;
 755 }
 756
 757 void wxDataViewEditorCtrlEvtHandler::OnIdle( wxIdleEvent &event )
 758 {
 759     if (m_focusOnIdle)
 760     {
 761         m_focusOnIdle = false;
 762         if (wxWindow::FindFocus() != m_editorCtrl)
 763             m_editorCtrl->SetFocus();
 764     }
 765
 766     event.Skip();
 767 }
 768
 769 void wxDataViewEditorCtrlEvtHandler::OnChar( wxKeyEvent &event )
 770 {
 771     switch ( event.m_keyCode )
 772     {
 773         case WXK_RETURN:
 774             m_finished = true;
 775             m_owner->FinishEditing();
 776             break;
 777
 778         case WXK_ESCAPE:
 779             m_finished = true;
 780             m_owner->CancelEditing();
 781             break;
 782
 783         default:
 784             event.Skip();
 785     }
 786 }
 787
 788 void wxDataViewEditorCtrlEvtHandler::OnKillFocus( wxFocusEvent &event )
 789 {
 790     if (!m_finished)
 791     {
 792         m_finished = true;
 793         m_owner->FinishEditing();
 794     }
 795
 796     event.Skip();
 797 }
 798
 799 // ---------------------------------------------------------
 800 // wxDataViewColumnBase
 801 // ---------------------------------------------------------
 802
 803 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumnBase, wxObject)
 804
 805 wxDataViewColumnBase::wxDataViewColumnBase(const wxString& WXUNUSED(title),
 806                                            wxDataViewRenderer *renderer,
 807                                            unsigned int model_column,
 808                                            int WXUNUSED(width),
 809                                            wxAlignment WXUNUSED(align),
 810                                            int WXUNUSED(flags))
 811 {
 812     m_renderer = renderer;
 813     m_model_column = model_column;
 814     m_owner = NULL;
 815     m_renderer->SetOwner( (wxDataViewColumn*) this );
 816
 817     // NOTE: the wxDataViewColumn's ctor must store the width, align, flags
 818     //       parameters inside the native control!
 819 }
 820
 821 wxDataViewColumnBase::wxDataViewColumnBase(const wxBitmap& bitmap,
 822                                            wxDataViewRenderer *renderer,
 823                                            unsigned int model_column,
 824                                            int WXUNUSED(width),
 825                                            wxAlignment WXUNUSED(align),
 826                                            int WXUNUSED(flags) )
 827 {
 828     m_renderer = renderer;
 829     m_model_column = model_column;
 830     m_bitmap = bitmap;
 831     m_owner = NULL;
 832     m_renderer->SetOwner( (wxDataViewColumn*) this );
 833 }
 834
 835 wxDataViewColumnBase::~wxDataViewColumnBase()
 836 {
 837     if (m_renderer)
 838         delete m_renderer;
 839 }
 840
 841 int wxDataViewColumnBase::GetFlags() const
 842 {
 843     int ret = 0;
 844
 845     if (IsSortable())
 846         ret |= wxDATAVIEW_COL_SORTABLE;
 847     if (IsResizeable())
 848         ret |= wxDATAVIEW_COL_RESIZABLE;
 849     if (IsHidden())
 850         ret |= wxDATAVIEW_COL_HIDDEN;
 851
 852     return ret;
 853 }
 854
 855 void wxDataViewColumnBase::SetFlags(int flags)
 856 {
 857     SetSortable((flags & wxDATAVIEW_COL_SORTABLE) != 0);
 858     SetResizeable((flags & wxDATAVIEW_COL_RESIZABLE) != 0);
 859     SetHidden((flags & wxDATAVIEW_COL_HIDDEN) != 0);
 860     SetReorderable((flags & wxDATAVIEW_COL_REORDERABLE) != 0);
 861 }
 862
 863 // ---------------------------------------------------------
 864 // wxDataViewCtrlBase
 865 // ---------------------------------------------------------
 866
 867 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)
 868
 869 wxDataViewCtrlBase::wxDataViewCtrlBase()
 870 {
 871     m_model = NULL;
 872     m_expander_column = 0;
 873     m_indent = 8;
 874 }
 875
 876 wxDataViewCtrlBase::~wxDataViewCtrlBase()
 877 {
 878     if (m_model)
 879     {
 880         m_model->DecRef();
 881         m_model = NULL;
 882     }
 883 }
 884
 885 bool wxDataViewCtrlBase::AssociateModel( wxDataViewModel *model )
 886 {
 887     if (m_model)
 888     {
 889         m_model->DecRef();   // discard old model, if any
 890     }
 891
 892     // add our own reference to the new model:
 893     m_model = model;
 894     if (m_model)
 895     {
 896         m_model->IncRef();
 897     }
 898
 899     return true;
 900 }
 901
 902 wxDataViewModel* wxDataViewCtrlBase::GetModel()
 903 {
 904     return m_model;
 905 }
 906
 907 const wxDataViewModel* wxDataViewCtrlBase::GetModel() const
 908 {
 909     return m_model;
 910 }
 911
 912 wxDataViewColumn *
 913 wxDataViewCtrlBase::AppendTextColumn( const wxString &label, unsigned int model_column,
 914                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 915 {
 916     wxDataViewColumn *ret = new wxDataViewColumn( label,
 917         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
 918         model_column, width, align, flags );
 919     AppendColumn( ret );
 920     return ret;
 921 }
 922
 923 wxDataViewColumn *
 924 wxDataViewCtrlBase::AppendIconTextColumn( const wxString &label, unsigned int model_column,
 925                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 926 {
 927     wxDataViewColumn *ret = new wxDataViewColumn( label,
 928         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode, (int)align ),
 929         model_column, width, align, flags );
 930     AppendColumn( ret );
 931     return ret;
 932 }
 933
 934 wxDataViewColumn *
 935 wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, unsigned int model_column,
 936                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 937 {
 938
 939     wxDataViewColumn *ret = new wxDataViewColumn( label,
 940         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
 941         model_column, width, align, flags );
 942     AppendColumn( ret );
 943     return ret;
 944 }
 945
 946 wxDataViewColumn *
 947 wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, unsigned int model_column,
 948                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 949 {
 950     wxDataViewColumn *ret = new wxDataViewColumn( label,
 951         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
 952         model_column, width, align, flags );
 953     AppendColumn( ret );
 954     return ret;
 955 }
 956
 957 wxDataViewColumn *
 958 wxDataViewCtrlBase::AppendDateColumn( const wxString &label, unsigned int model_column,
 959                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 960 {
 961     wxDataViewColumn *ret = new wxDataViewColumn( label,
 962         new wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
 963         model_column, width, align, flags );
 964     AppendColumn( ret );
 965     return ret;
 966 }
 967
 968 wxDataViewColumn *
 969 wxDataViewCtrlBase::AppendBitmapColumn( const wxString &label, unsigned int model_column,
 970                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 971 {
 972     wxDataViewColumn *ret = new wxDataViewColumn( label,
 973         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
 974         model_column, width, align, flags );
 975     AppendColumn( ret );
 976     return ret;
 977 }
 978
 979 wxDataViewColumn *
 980 wxDataViewCtrlBase::AppendTextColumn( const wxBitmap &label, unsigned int model_column,
 981                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 982 {
 983     wxDataViewColumn *ret = new wxDataViewColumn( label,
 984         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
 985         model_column, width, align, flags );
 986     AppendColumn( ret );
 987     return ret;
 988 }
 989
 990 wxDataViewColumn *
 991 wxDataViewCtrlBase::AppendIconTextColumn( const wxBitmap &label, unsigned int model_column,
 992                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
 993 {
 994     wxDataViewColumn *ret = new wxDataViewColumn( label,
 995         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode, (int)align ),
 996         model_column, width, align, flags );
 997     AppendColumn( ret );
 998     return ret;
 999 }
1000
1001 wxDataViewColumn *
1002 wxDataViewCtrlBase::AppendToggleColumn( const wxBitmap &label, unsigned int model_column,
1003                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1004 {
1005     wxDataViewColumn *ret = new wxDataViewColumn( label,
1006         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
1007         model_column, width, align, flags );
1008     AppendColumn( ret );
1009     return ret;
1010 }
1011
1012 wxDataViewColumn *
1013 wxDataViewCtrlBase::AppendProgressColumn( const wxBitmap &label, unsigned int model_column,
1014                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1015 {
1016     wxDataViewColumn *ret = new wxDataViewColumn( label,
1017         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
1018         model_column, width, align, flags );
1019     AppendColumn( ret );
1020     return ret;
1021 }
1022
1023 wxDataViewColumn *
1024 wxDataViewCtrlBase::AppendDateColumn( const wxBitmap &label, unsigned int model_column,
1025                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1026 {
1027     wxDataViewColumn *ret = new wxDataViewColumn( label,
1028         new wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
1029         model_column, width, align, flags );
1030     AppendColumn( ret );
1031     return ret;
1032 }
1033
1034 wxDataViewColumn *
1035 wxDataViewCtrlBase::AppendBitmapColumn( const wxBitmap &label, unsigned int model_column,
1036                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1037 {
1038     wxDataViewColumn *ret = new wxDataViewColumn( label,
1039         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
1040         model_column, width, align, flags );
1041     AppendColumn( ret );
1042     return ret;
1043 }
1044
1045 wxDataViewColumn *
1046 wxDataViewCtrlBase::PrependTextColumn( const wxString &label, unsigned int model_column,
1047                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1048 {
1049     wxDataViewColumn *ret = new wxDataViewColumn( label,
1050         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
1051         model_column, width, align, flags );
1052     PrependColumn( ret );
1053     return ret;
1054 }
1055
1056 wxDataViewColumn *
1057 wxDataViewCtrlBase::PrependIconTextColumn( const wxString &label, unsigned int model_column,
1058                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1059 {
1060     wxDataViewColumn *ret = new wxDataViewColumn( label,
1061         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode, (int)align ),
1062         model_column, width, align, flags );
1063     PrependColumn( ret );
1064     return ret;
1065 }
1066
1067 wxDataViewColumn *
1068 wxDataViewCtrlBase::PrependToggleColumn( const wxString &label, unsigned int model_column,
1069                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1070 {
1071
1072     wxDataViewColumn *ret = new wxDataViewColumn( label,
1073         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
1074         model_column, width, align, flags );
1075     PrependColumn( ret );
1076     return ret;
1077 }
1078
1079 wxDataViewColumn *
1080 wxDataViewCtrlBase::PrependProgressColumn( const wxString &label, unsigned int model_column,
1081                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1082 {
1083     wxDataViewColumn *ret = new wxDataViewColumn( label,
1084         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
1085         model_column, width, align, flags );
1086     PrependColumn( ret );
1087     return ret;
1088 }
1089
1090 wxDataViewColumn *
1091 wxDataViewCtrlBase::PrependDateColumn( 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 wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
1096         model_column, width, align, flags );
1097     PrependColumn( ret );
1098     return ret;
1099 }
1100
1101 wxDataViewColumn *
1102 wxDataViewCtrlBase::PrependBitmapColumn( 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 wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
1107         model_column, width, align, flags );
1108     PrependColumn( ret );
1109     return ret;
1110 }
1111
1112 wxDataViewColumn *
1113 wxDataViewCtrlBase::PrependTextColumn( const wxBitmap &label, unsigned int model_column,
1114                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1115 {
1116     wxDataViewColumn *ret = new wxDataViewColumn( label,
1117         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
1118         model_column, width, align, flags );
1119     PrependColumn( ret );
1120     return ret;
1121 }
1122
1123 wxDataViewColumn *
1124 wxDataViewCtrlBase::PrependIconTextColumn( const wxBitmap &label, unsigned int model_column,
1125                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1126 {
1127     wxDataViewColumn *ret = new wxDataViewColumn( label,
1128         new wxDataViewIconTextRenderer( wxT("wxDataViewIconText"), mode, (int)align ),
1129         model_column, width, align, flags );
1130     PrependColumn( ret );
1131     return ret;
1132 }
1133
1134 wxDataViewColumn *
1135 wxDataViewCtrlBase::PrependToggleColumn( const wxBitmap &label, unsigned int model_column,
1136                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1137 {
1138     wxDataViewColumn *ret = new wxDataViewColumn( label,
1139         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
1140         model_column, width, align, flags );
1141     PrependColumn( ret );
1142     return ret;
1143 }
1144
1145 wxDataViewColumn *
1146 wxDataViewCtrlBase::PrependProgressColumn( const wxBitmap &label, unsigned int model_column,
1147                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1148 {
1149     wxDataViewColumn *ret = new wxDataViewColumn( label,
1150         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
1151         model_column, width, align, flags );
1152     PrependColumn( ret );
1153     return ret;
1154 }
1155
1156 wxDataViewColumn *
1157 wxDataViewCtrlBase::PrependDateColumn( 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 wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
1162         model_column, width, align, flags );
1163     PrependColumn( ret );
1164     return ret;
1165 }
1166
1167 wxDataViewColumn *
1168 wxDataViewCtrlBase::PrependBitmapColumn( 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 wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
1173         model_column, width, align, flags );
1174     PrependColumn( ret );
1175     return ret;
1176 }
1177
1178 bool
1179 wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
1180 {
1181     col->SetOwner( (wxDataViewCtrl*) this );
1182     return true;
1183 }
1184
1185 bool
1186 wxDataViewCtrlBase::PrependColumn( wxDataViewColumn *col )
1187 {
1188     col->SetOwner( (wxDataViewCtrl*) this );
1189     return true;
1190 }
1191
1192 // ---------------------------------------------------------
1193 // wxDataViewEvent
1194 // ---------------------------------------------------------
1195
1196 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1197
1198 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED)
1199
1200 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED)
1201 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING)
1202 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED)
1203 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING)
1204 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED)
1205 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED)
1206 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE)
1207 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED)
1208
1209 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU)
1210
1211 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK)
1212 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK)
1213 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED)
1214 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED)
1215
1216
1217 // -------------------------------------
1218 // wxDataViewSpinRenderer
1219 // -------------------------------------
1220
1221 wxDataViewSpinRenderer::wxDataViewSpinRenderer( int min, int max, wxDataViewCellMode mode, int alignment ) :
1222    wxDataViewCustomRenderer(wxT("long"), mode, alignment )
1223 {
1224     m_min = min;
1225     m_max = max;
1226 }
1227
1228 wxControl* wxDataViewSpinRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
1229 {
1230     long l = value;
1231     wxSize size = labelRect.GetSize();
1232 #ifdef __WXMAC__
1233     size = wxSize( wxMax(70,labelRect.width ), -1 );
1234 #endif
1235     wxString str;
1236     str.Printf( wxT("%d"), (int) l );
1237     wxSpinCtrl *sc = new wxSpinCtrl( parent, wxID_ANY, str,
1238                labelRect.GetTopLeft(), size, wxSP_ARROW_KEYS, m_min, m_max, l );
1239 #ifdef __WXMAC__
1240     size = sc->GetSize();
1241     wxPoint pt = sc->GetPosition();
1242     sc->SetSize( pt.x - 4, pt.y - 4, size.x, size.y );
1243 #endif
1244
1245     return sc;
1246 }
1247
1248 bool wxDataViewSpinRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
1249 {
1250     wxSpinCtrl *sc = (wxSpinCtrl*) editor;
1251     long l = sc->GetValue();
1252     value = l;
1253     return true;
1254 }
1255
1256 bool wxDataViewSpinRenderer::Render( wxRect rect, wxDC *dc, int state )
1257 {
1258     wxString str;
1259     str.Printf(wxT("%d"), (int) m_data );
1260     RenderText( str, 0, rect, dc, state );
1261     return true;
1262 }
1263
1264 wxSize wxDataViewSpinRenderer::GetSize() const
1265 {
1266     return wxSize(80,16);
1267 }
1268
1269 bool wxDataViewSpinRenderer::SetValue( const wxVariant &value )
1270 {
1271     m_data = value.GetLong();
1272     return true;
1273 }
1274
1275 bool wxDataViewSpinRenderer::GetValue( wxVariant &value ) const
1276 {
1277     value = m_data;
1278     return true;
1279 }
1280
1281 //-----------------------------------------------------------------------------
1282 // wxDataViewTreeStore
1283 //-----------------------------------------------------------------------------
1284
1285 wxDataViewTreeStoreNode::wxDataViewTreeStoreNode(
1286         wxDataViewTreeStoreNode *parent,
1287         const wxString &text, const wxIcon &icon, wxClientData *data )
1288 {
1289     m_parent = parent;
1290     m_text = text;
1291     m_icon = icon;
1292     m_data = data;
1293 }
1294
1295 wxDataViewTreeStoreNode::~wxDataViewTreeStoreNode()
1296 {
1297     if (m_data)
1298         delete m_data;
1299 }
1300
1301 #include "wx/listimpl.cpp"
1302 WX_DEFINE_LIST(wxDataViewTreeStoreNodeList)
1303
1304 wxDataViewTreeStoreContainerNode::wxDataViewTreeStoreContainerNode(
1305         wxDataViewTreeStoreNode *parent, const wxString &text,
1306         const wxIcon &icon, const wxIcon &expanded, wxClientData *data ) :
1307     wxDataViewTreeStoreNode( parent, text, icon, data )
1308 {
1309     m_iconExpanded = expanded;
1310     m_isExpanded = false;
1311     m_children.DeleteContents(true);
1312 }
1313
1314 wxDataViewTreeStoreContainerNode::~wxDataViewTreeStoreContainerNode()
1315 {
1316 }
1317
1318 //-----------------------------------------------------------------------------
1319
1320 wxDataViewTreeStore::wxDataViewTreeStore()
1321 {
1322     m_root = new wxDataViewTreeStoreContainerNode( NULL, wxEmptyString );
1323 }
1324
1325 wxDataViewTreeStore::~wxDataViewTreeStore()
1326 {
1327     delete m_root;
1328 }
1329
1330 wxDataViewItem wxDataViewTreeStore::AppendItem( const wxDataViewItem& parent,
1331         const wxString &text, const wxIcon &icon, wxClientData *data )
1332 {
1333     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1334     if (!parent_node) return wxDataViewItem(0);
1335
1336     wxDataViewTreeStoreNode *node =
1337         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1338     parent_node->GetChildren().Append( node );
1339
1340     // notify control
1341     ItemAdded( parent, node->GetItem() );
1342
1343     return node->GetItem();
1344 }
1345
1346 wxDataViewItem wxDataViewTreeStore::PrependItem( const wxDataViewItem& parent,
1347         const wxString &text, const wxIcon &icon, wxClientData *data )
1348 {
1349     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1350     if (!parent_node) return wxDataViewItem(0);
1351
1352     wxDataViewTreeStoreNode *node =
1353         new wxDataViewTreeStoreNode( parent_node, text, icon, data );
1354     parent_node->GetChildren().Insert( node );
1355
1356     // notify control
1357     ItemAdded( parent, node->GetItem() );
1358
1359     return node->GetItem();
1360 }
1361
1362 wxDataViewItem
1363 wxDataViewTreeStore::InsertItem(const wxDataViewItem& WXUNUSED(parent),
1364                                 const wxDataViewItem& WXUNUSED(previous),
1365                                 const wxString& WXUNUSED(text),
1366                                 const wxIcon& WXUNUSED(icon),
1367                                 wxClientData * WXUNUSED(data))
1368 {
1369     return wxDataViewItem(0);
1370 }
1371
1372 wxDataViewItem wxDataViewTreeStore::PrependContainer( const wxDataViewItem& parent,
1373         const wxString &text, const wxIcon &icon, const wxIcon &expanded,
1374         wxClientData *data )
1375 {
1376     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1377     if (!parent_node) return wxDataViewItem(0);
1378
1379     wxDataViewTreeStoreContainerNode *node =
1380         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1381     parent_node->GetChildren().Insert( node );
1382
1383     // notify control
1384     ItemAdded( parent, node->GetItem() );
1385
1386     return node->GetItem();
1387 }
1388
1389 wxDataViewItem
1390 wxDataViewTreeStore::AppendContainer(const wxDataViewItem& parent,
1391                                      const wxString &text,
1392                                      const wxIcon& icon,
1393                                      const wxIcon& expanded,
1394                                      wxClientData * data)
1395 {
1396     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1397     if (!parent_node) return wxDataViewItem(0);
1398
1399     wxDataViewTreeStoreContainerNode *node =
1400         new wxDataViewTreeStoreContainerNode( parent_node, text, icon, expanded, data );
1401     parent_node->GetChildren().Append( node );
1402
1403     // notify control
1404     ItemAdded( parent, node->GetItem() );
1405
1406     return node->GetItem();
1407 }
1408
1409 wxDataViewItem
1410 wxDataViewTreeStore::InsertContainer(const wxDataViewItem& WXUNUSED(parent),
1411                                      const wxDataViewItem& WXUNUSED(previous),
1412                                      const wxString& WXUNUSED(text),
1413                                      const wxIcon& WXUNUSED(icon),
1414                                      const wxIcon& WXUNUSED(expanded),
1415                                      wxClientData * WXUNUSED(data))
1416 {
1417     return wxDataViewItem(0);
1418 }
1419
1420 wxDataViewItem wxDataViewTreeStore::GetNthChild( const wxDataViewItem& parent, unsigned int pos ) const
1421 {
1422     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent );
1423     if (!parent_node) return wxDataViewItem(0);
1424
1425     wxDataViewTreeStoreNodeList::compatibility_iterator node = parent_node->GetChildren().Item( pos );
1426     if (node)
1427         return node->GetData();
1428
1429     return wxDataViewItem(0);
1430 }
1431
1432 int wxDataViewTreeStore::GetChildCount( const wxDataViewItem& parent ) const
1433 {
1434     wxDataViewTreeStoreNode *node = FindNode( parent );
1435     if (!node) return -1;
1436
1437     if (!node->IsContainer())
1438         return 0;
1439
1440     wxDataViewTreeStoreContainerNode *container_node = (wxDataViewTreeStoreContainerNode*) node;
1441     return (int) container_node->GetChildren().GetCount();
1442 }
1443
1444 void wxDataViewTreeStore::SetItemText( const wxDataViewItem& item, const wxString &text )
1445 {
1446     wxDataViewTreeStoreNode *node = FindNode( item );
1447     if (!node) return;
1448
1449     node->SetText( text );
1450
1451     // notify control
1452     ValueChanged( item, 0 );
1453 }
1454
1455 wxString wxDataViewTreeStore::GetItemText( const wxDataViewItem& item ) const
1456 {
1457     wxDataViewTreeStoreNode *node = FindNode( item );
1458     if (!node) return wxEmptyString;
1459
1460     return node->GetText();
1461 }
1462
1463 void wxDataViewTreeStore::SetItemIcon( const wxDataViewItem& item, const wxIcon &icon )
1464 {
1465     wxDataViewTreeStoreNode *node = FindNode( item );
1466     if (!node) return;
1467
1468     node->SetIcon( icon );
1469
1470     // notify control
1471     ValueChanged( item, 0 );
1472 }
1473
1474 const wxIcon &wxDataViewTreeStore::GetItemIcon( const wxDataViewItem& item ) const
1475 {
1476     wxDataViewTreeStoreNode *node = FindNode( item );
1477     if (!node) return wxNullIcon;
1478
1479     return node->GetIcon();
1480 }
1481
1482 void wxDataViewTreeStore::SetItemExpandedIcon( const wxDataViewItem& item, const wxIcon &icon )
1483 {
1484     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1485     if (!node) return;
1486
1487     node->SetExpandedIcon( icon );
1488
1489     // notify control
1490     ValueChanged( item, 0 );
1491 }
1492
1493 const wxIcon &wxDataViewTreeStore::GetItemExpandedIcon( const wxDataViewItem& item ) const
1494 {
1495     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1496     if (!node) return wxNullIcon;
1497
1498     return node->GetExpandedIcon();
1499 }
1500
1501 void wxDataViewTreeStore::SetItemData( const wxDataViewItem& item, wxClientData *data )
1502 {
1503     wxDataViewTreeStoreNode *node = FindNode( item );
1504     if (!node) return;
1505
1506     node->SetData( data );
1507
1508     // notify control? only sensible when sorting on client data
1509     // ValueChanged( item, 0 );
1510 }
1511
1512 wxClientData *wxDataViewTreeStore::GetItemData( const wxDataViewItem& item ) const
1513 {
1514     wxDataViewTreeStoreNode *node = FindNode( item );
1515     if (!node) return NULL;
1516
1517     return node->GetData();
1518 }
1519
1520 void wxDataViewTreeStore::DeleteItem( const wxDataViewItem& item )
1521 {
1522     if (!item.IsOk()) return;
1523
1524     wxDataViewItem parent_item = GetParent( item );
1525
1526     wxDataViewTreeStoreContainerNode *parent_node = FindContainerNode( parent_item );
1527     if (!parent_node) return;
1528
1529     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1530     if (!node) return;
1531
1532     parent_node->GetChildren().DeleteObject( node );
1533
1534     // notify control
1535     ItemDeleted( parent_item, item );
1536 }
1537
1538 void wxDataViewTreeStore::DeleteChildren( const wxDataViewItem& item )
1539 {
1540     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1541     if (!node) return;
1542
1543     wxDataViewItemArray array;
1544     wxDataViewTreeStoreNodeList::iterator iter;
1545     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
1546     {
1547         wxDataViewTreeStoreNode* child = *iter;
1548         array.Add( child->GetItem() );
1549     }
1550
1551     node->GetChildren().clear();
1552
1553     // notify control
1554     ItemsDeleted( item, array );
1555 }
1556
1557 void wxDataViewTreeStore::DeleteAllItems()
1558 {
1559     // TODO
1560 }
1561
1562 void
1563 wxDataViewTreeStore::GetValue(wxVariant &variant,
1564                               const wxDataViewItem &item,
1565                               unsigned int WXUNUSED(col)) const
1566 {
1567     // if (col != 0) return;
1568
1569     wxDataViewTreeStoreNode *node = FindNode( item );
1570     if (!node) return;
1571
1572     wxIcon icon( node->GetIcon());
1573     if (node->IsContainer())
1574     {
1575         wxDataViewTreeStoreContainerNode *container = (wxDataViewTreeStoreContainerNode*) node;
1576         if (container->IsExpanded() && container->GetExpandedIcon().IsOk())
1577            icon = container->GetExpandedIcon();
1578     }
1579
1580     wxDataViewIconText data( node->GetText(), icon );
1581
1582     variant << data;
1583 }
1584
1585 bool
1586 wxDataViewTreeStore::SetValue(const wxVariant& variant,
1587                               const wxDataViewItem& item,
1588                               unsigned int WXUNUSED(col))
1589 {
1590     // if (col != 0) return false;
1591
1592     wxDataViewTreeStoreNode *node = FindNode( item );
1593     if (!node) return false;
1594
1595     wxDataViewIconText data;
1596
1597     data << variant;
1598
1599     node->SetText( data.GetText() );
1600     node->SetIcon( data.GetIcon() );
1601
1602     return true;
1603 }
1604
1605 wxDataViewItem wxDataViewTreeStore::GetParent( const wxDataViewItem &item ) const
1606 {
1607     wxDataViewTreeStoreNode *node = FindNode( item );
1608     if (!node) return wxDataViewItem(0);
1609
1610     wxDataViewTreeStoreNode *parent = node->GetParent();
1611     if (!parent) return wxDataViewItem(0);
1612
1613     if (parent == m_root)
1614         return wxDataViewItem(0);
1615
1616     return parent->GetItem();
1617 }
1618
1619 bool wxDataViewTreeStore::IsContainer( const wxDataViewItem &item ) const
1620 {
1621     wxDataViewTreeStoreNode *node = FindNode( item );
1622     if (!node) return false;
1623
1624     return node->IsContainer();
1625 }
1626
1627 unsigned int wxDataViewTreeStore::GetChildren( const wxDataViewItem &item, wxDataViewItemArray &children ) const
1628 {
1629     wxDataViewTreeStoreContainerNode *node = FindContainerNode( item );
1630     if (!node) return 0;
1631
1632     wxDataViewTreeStoreNodeList::iterator iter;
1633     for (iter = node->GetChildren().begin(); iter != node->GetChildren().end(); iter++)
1634     {
1635         wxDataViewTreeStoreNode* child = *iter;
1636         children.Add( child->GetItem() );
1637     }
1638
1639     return node->GetChildren().GetCount();
1640 }
1641
1642 int wxDataViewTreeStore::Compare( const wxDataViewItem &item1, const wxDataViewItem &item2,
1643                          unsigned int WXUNUSED(column), bool WXUNUSED(ascending) )
1644 {
1645     wxDataViewTreeStoreNode *node1 = FindNode( item1 );
1646     wxDataViewTreeStoreNode *node2 = FindNode( item2 );
1647
1648     if (!node1 || !node2)
1649         return 0;
1650
1651     wxDataViewTreeStoreContainerNode* parent1 =
1652         (wxDataViewTreeStoreContainerNode*) node1->GetParent();
1653     wxDataViewTreeStoreContainerNode* parent2 =
1654         (wxDataViewTreeStoreContainerNode*) node2->GetParent();
1655
1656     if (parent1 != parent2)
1657     {
1658         wxLogError( wxT("Comparing items with different parent.") );
1659         return 0;
1660     }
1661
1662     if (node1->IsContainer() && !!node2->IsContainer())
1663         return 1;
1664
1665     if (node2->IsContainer() && !!node1->IsContainer())
1666         return -1;
1667
1668     return parent1->GetChildren().IndexOf( node1 ) - parent1->GetChildren().IndexOf( node2 );
1669 }
1670
1671 wxDataViewTreeStoreNode *wxDataViewTreeStore::FindNode( const wxDataViewItem &item ) const
1672 {
1673     if (!item.IsOk())
1674         return m_root;
1675
1676     return (wxDataViewTreeStoreNode*) item.GetID();
1677 }
1678
1679 wxDataViewTreeStoreContainerNode *wxDataViewTreeStore::FindContainerNode( const wxDataViewItem &item ) const
1680 {
1681     if (!item.IsOk())
1682         return (wxDataViewTreeStoreContainerNode*) m_root;
1683
1684     wxDataViewTreeStoreNode* node = (wxDataViewTreeStoreNode*) item.GetID();
1685
1686     if (!node->IsContainer())
1687         return NULL;
1688
1689     return (wxDataViewTreeStoreContainerNode*) node;
1690 }
1691
1692 //-----------------------------------------------------------------------------
1693 // wxDataViewTreeCtrl
1694 //-----------------------------------------------------------------------------
1695
1696 IMPLEMENT_DYNAMIC_CLASS(wxDataViewTreeCtrl,wxDataViewCtrl)
1697
1698 BEGIN_EVENT_TABLE(wxDataViewTreeCtrl,wxDataViewCtrl)
1699    EVT_DATAVIEW_ITEM_EXPANDED(-1, wxDataViewTreeCtrl::OnExpanded)
1700    EVT_DATAVIEW_ITEM_COLLAPSED(-1, wxDataViewTreeCtrl::OnCollapsed)
1701    EVT_SIZE( wxDataViewTreeCtrl::OnSize )
1702 END_EVENT_TABLE()
1703
1704 wxDataViewTreeCtrl::wxDataViewTreeCtrl()
1705 {
1706     m_imageList = NULL;
1707 }
1708
1709 wxDataViewTreeCtrl::wxDataViewTreeCtrl( wxWindow *parent, wxWindowID id,
1710            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
1711 {
1712     m_imageList = NULL;
1713     Create( parent, id, pos, size, style, validator );
1714
1715     wxDataViewTreeStore *store = new wxDataViewTreeStore;
1716     AssociateModel( store );
1717     store->DecRef();
1718
1719     AppendIconTextColumn(wxString(),0,wxDATAVIEW_CELL_INERT,-1);
1720 }
1721
1722 wxDataViewTreeCtrl::~wxDataViewTreeCtrl()
1723 {
1724     if (m_imageList)
1725         delete m_imageList;
1726 }
1727
1728 bool wxDataViewTreeCtrl::Create( wxWindow *parent, wxWindowID id,
1729            const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
1730 {
1731     return wxDataViewCtrl::Create( parent, id, pos, size, style, validator );
1732 }
1733
1734 void wxDataViewTreeCtrl::SetImageList( wxImageList *imagelist )
1735 {
1736     if (m_imageList)
1737         delete m_imageList;
1738
1739     m_imageList = imagelist;
1740 }
1741
1742 wxDataViewItem wxDataViewTreeCtrl::AppendItem( const wxDataViewItem& parent,
1743         const wxString &text, int iconIndex, wxClientData *data )
1744 {
1745     wxIcon icon = wxNullIcon;
1746     if (m_imageList && (iconIndex != -1))
1747         icon = m_imageList->GetIcon( iconIndex );
1748
1749     return GetStore()->AppendItem( parent, text, icon, data );
1750 }
1751
1752 wxDataViewItem wxDataViewTreeCtrl::PrependItem( const wxDataViewItem& parent,
1753         const wxString &text, int iconIndex, wxClientData *data )
1754 {
1755     wxIcon icon = wxNullIcon;
1756     if (m_imageList && (iconIndex != -1))
1757         icon = m_imageList->GetIcon( iconIndex );
1758
1759     return GetStore()->PrependItem( parent, text, icon, data );
1760 }
1761
1762 wxDataViewItem wxDataViewTreeCtrl::InsertItem( const wxDataViewItem& parent, const wxDataViewItem& previous,
1763         const wxString &text, int iconIndex, wxClientData *data )
1764 {
1765     wxIcon icon = wxNullIcon;
1766     if (m_imageList && (iconIndex != -1))
1767         icon = m_imageList->GetIcon( iconIndex );
1768
1769     return GetStore()->InsertItem( parent, previous, text, icon, data );
1770 }
1771
1772 wxDataViewItem wxDataViewTreeCtrl::PrependContainer( const wxDataViewItem& parent,
1773         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
1774 {
1775     wxIcon icon = wxNullIcon;
1776     if (m_imageList && (iconIndex != -1))
1777         icon = m_imageList->GetIcon( iconIndex );
1778
1779     wxIcon expanded = wxNullIcon;
1780     if (m_imageList && (expandedIndex != -1))
1781         expanded = m_imageList->GetIcon( expandedIndex );
1782
1783     return GetStore()->PrependContainer( parent, text, icon, expanded, data );
1784 }
1785
1786 wxDataViewItem wxDataViewTreeCtrl::AppendContainer( const wxDataViewItem& parent,
1787         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
1788 {
1789     wxIcon icon = wxNullIcon;
1790     if (m_imageList && (iconIndex != -1))
1791         icon = m_imageList->GetIcon( iconIndex );
1792
1793     wxIcon expanded = wxNullIcon;
1794     if (m_imageList && (expandedIndex != -1))
1795         expanded = m_imageList->GetIcon( expandedIndex );
1796
1797     return GetStore()->AppendContainer( parent, text, icon, expanded, data );
1798 }
1799
1800 wxDataViewItem wxDataViewTreeCtrl::InsertContainer( const wxDataViewItem& parent, const wxDataViewItem& previous,
1801         const wxString &text, int iconIndex, int expandedIndex, wxClientData *data )
1802 {
1803     wxIcon icon = wxNullIcon;
1804     if (m_imageList && (iconIndex != -1))
1805         icon = m_imageList->GetIcon( iconIndex );
1806
1807     wxIcon expanded = wxNullIcon;
1808     if (m_imageList && (expandedIndex != -1))
1809         expanded = m_imageList->GetIcon( expandedIndex );
1810
1811     return GetStore()->InsertContainer( parent, previous, text, icon, expanded, data );
1812 }
1813
1814 void wxDataViewTreeCtrl::OnExpanded( wxDataViewEvent &event )
1815 {
1816     if (m_imageList) return;
1817
1818     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
1819     if (!container) return;
1820
1821     container->SetExpanded( true );
1822     GetStore()->ItemChanged( event.GetItem() );
1823 }
1824
1825 void wxDataViewTreeCtrl::OnCollapsed( wxDataViewEvent &event )
1826 {
1827     if (m_imageList) return;
1828
1829     wxDataViewTreeStoreContainerNode* container = GetStore()->FindContainerNode( event.GetItem() );
1830     if (!container) return;
1831
1832     container->SetExpanded( false );
1833     GetStore()->ItemChanged( event.GetItem() );
1834 }
1835
1836 void wxDataViewTreeCtrl::OnSize( wxSizeEvent &event )
1837 {
1838 #if defined(wxUSE_GENERICDATAVIEWCTRL)
1839     wxSize size = GetClientSize();
1840     wxDataViewColumn *col = GetColumn( 0 );
1841     if (col)
1842        col->SetWidth( size.x );
1843 #endif
1844     event.Skip( true );
1845 }
1846
1847 #endif // wxUSE_DATAVIEWCTRL
1848