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