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/log.h"
  24 #endif
  25
  26 const wxChar wxDataViewCtrlNameStr[] = wxT("dataviewCtrl");
  27
  28
  29 // ---------------------------------------------------------
  30 // wxDataViewListModel
  31 // ---------------------------------------------------------
  32
  33 wxDataViewListModel::wxDataViewListModel()
  34 {
  35     m_notifiers.DeleteContents( true );
  36 }
  37
  38 wxDataViewListModel::~wxDataViewListModel()
  39 {
  40 }
  41
  42 bool wxDataViewListModel::RowAppended()
  43 {
  44     bool ret = true;
  45
  46     wxList::compatibility_iterator node = m_notifiers.GetFirst();
  47     while (node)
  48     {
  49         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
  50         if (!notifier->RowAppended())
  51             ret = false;
  52         node = node->GetNext();
  53     }
  54
  55     return ret;
  56 }
  57
  58 bool wxDataViewListModel::RowPrepended()
  59 {
  60     bool ret = true;
  61
  62     wxList::compatibility_iterator node = m_notifiers.GetFirst();
  63     while (node)
  64     {
  65         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
  66         if (!notifier->RowPrepended())
  67             ret = false;
  68         node = node->GetNext();
  69     }
  70
  71     return ret;
  72 }
  73
  74 bool wxDataViewListModel::RowInserted( unsigned int before )
  75 {
  76     bool ret = true;
  77
  78     wxList::compatibility_iterator node = m_notifiers.GetFirst();
  79     while (node)
  80     {
  81         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
  82         if (!notifier->RowInserted(before))
  83             ret = false;
  84         node = node->GetNext();
  85     }
  86
  87     return ret;
  88 }
  89
  90 bool wxDataViewListModel::RowDeleted( unsigned int row )
  91 {
  92     bool ret = true;
  93
  94     wxList::compatibility_iterator node = m_notifiers.GetFirst();
  95     while (node)
  96     {
  97         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
  98         if (!notifier->RowDeleted( row ))
  99             ret = false;
 100         node = node->GetNext();
 101     }
 102
 103     return ret;
 104 }
 105
 106 bool wxDataViewListModel::RowChanged( unsigned int row )
 107 {
 108     bool ret = true;
 109
 110     wxList::compatibility_iterator node = m_notifiers.GetFirst();
 111     while (node)
 112     {
 113         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
 114         if (!notifier->RowChanged( row ))
 115             ret = false;
 116         node = node->GetNext();
 117     }
 118
 119     return ret;
 120 }
 121
 122 bool wxDataViewListModel::ValueChanged( unsigned int col, unsigned int row )
 123 {
 124     bool ret = true;
 125
 126     wxList::compatibility_iterator node = m_notifiers.GetFirst();
 127     while (node)
 128     {
 129         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
 130         if (!notifier->ValueChanged( col, row ))
 131             ret = false;
 132         node = node->GetNext();
 133     }
 134
 135     return ret;
 136 }
 137
 138 bool wxDataViewListModel::RowsReordered( unsigned int *new_order )
 139 {
 140     bool ret = true;
 141
 142     wxList::compatibility_iterator node = m_notifiers.GetFirst();
 143     while (node)
 144     {
 145         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
 146         if (!notifier->RowsReordered( new_order ))
 147             ret = false;
 148         node = node->GetNext();
 149     }
 150
 151     return ret;
 152 }
 153
 154 bool wxDataViewListModel::Cleared()
 155 {
 156     bool ret = true;
 157
 158     wxList::compatibility_iterator node = m_notifiers.GetFirst();
 159     while (node)
 160     {
 161         wxDataViewListModelNotifier* notifier = (wxDataViewListModelNotifier*) node->GetData();
 162         if (!notifier->Cleared())
 163             ret = false;
 164         node = node->GetNext();
 165     }
 166
 167     return ret;
 168 }
 169
 170 void wxDataViewListModel::AddNotifier( wxDataViewListModelNotifier *notifier )
 171 {
 172     m_notifiers.Append( notifier );
 173     notifier->SetOwner( this );
 174 }
 175
 176 void wxDataViewListModel::RemoveNotifier( wxDataViewListModelNotifier *notifier )
 177 {
 178     m_notifiers.DeleteObject( notifier );
 179 }
 180
 181 // ---------------------------------------------------------
 182 // wxDataViewSortedListModelNotifier
 183 // ---------------------------------------------------------
 184
 185 class wxDataViewSortedListModelNotifier: public wxDataViewListModelNotifier
 186 {
 187 public:
 188     wxDataViewSortedListModelNotifier( wxDataViewSortedListModel *model )
 189         { m_model = model; }
 190
 191     virtual bool RowAppended()
 192         { return m_model->ChildRowAppended(); }
 193
 194     virtual bool RowPrepended()
 195         { return m_model->ChildRowPrepended(); }
 196
 197     virtual bool RowInserted( unsigned int before )
 198         { return m_model->ChildRowInserted( before ); }
 199
 200     virtual bool RowDeleted( unsigned int row )
 201         { return m_model->ChildRowDeleted( row ); }
 202
 203     virtual bool RowChanged( unsigned int row )
 204         { return m_model->ChildRowChanged( row ); }
 205
 206     virtual bool ValueChanged( unsigned int col, unsigned int row )
 207         { return m_model->ChildValueChanged( col, row); }
 208
 209     virtual bool RowsReordered( unsigned int *new_order )
 210         { return m_model->ChildRowsReordered( new_order ); }
 211
 212     virtual bool Cleared()
 213         { return m_model->ChildCleared(); }
 214
 215     wxDataViewSortedListModel *m_model;
 216 };
 217
 218 // ---------------------------------------------------------
 219 // wxDataViewSortedListModel compare function
 220 // ---------------------------------------------------------
 221
 222 int wxCALLBACK wxDataViewListModelSortedDefaultCompare
 223       (unsigned int row1, unsigned int row2, unsigned int col, wxDataViewListModel* model )
 224 {
 225     wxVariant value1,value2;
 226     model->GetValue( value1, col, row1 );
 227     model->GetValue( value2, col, row2 );
 228     if (value1.GetType() == wxT("string"))
 229     {
 230         wxString str1 = value1.GetString();
 231         wxString str2 = value2.GetString();
 232         return str1.Cmp( str2 );
 233     }
 234     if (value1.GetType() == wxT("long"))
 235     {
 236         long l1 = value1.GetLong();
 237         long l2 = value2.GetLong();
 238         return l1-l2;
 239     }
 240     if (value1.GetType() == wxT("double"))
 241     {
 242         double d1 = value1.GetDouble();
 243         double d2 = value2.GetDouble();
 244         if (d1 == d2) return 0;
 245         if (d1 < d2) return 1;
 246         return -1;
 247     }
 248     if (value1.GetType() == wxT("datetime"))
 249     {
 250         wxDateTime dt1 = value1.GetDateTime();
 251         wxDateTime dt2 = value2.GetDateTime();
 252         if (dt1.IsEqualTo(dt2)) return 0;
 253         if (dt1.IsEarlierThan(dt2)) return 1;
 254         return -1;
 255     }
 256
 257     return 0;
 258 }
 259
 260 int wxCALLBACK wxDataViewListModelSortedDefaultCompareDescending
 261       (unsigned int row1, unsigned int row2, unsigned int col, wxDataViewListModel* model )
 262 {
 263     return wxDataViewListModelSortedDefaultCompare( row2, row1, col, model );
 264 }
 265
 266 static wxDataViewListModelCompare   s_CmpFunc;
 267 static wxDataViewListModel         *s_CmpModel;
 268 static unsigned int                 s_CmpCol;
 269
 270 int LINKAGEMODE wxDataViewIntermediateCmp( unsigned int row1, unsigned int row2 )
 271 {
 272     return s_CmpFunc( row1, row2, s_CmpCol, s_CmpModel );
 273 }
 274
 275 // ---------------------------------------------------------
 276 // wxDataViewSortedListModel
 277 // ---------------------------------------------------------
 278
 279 wxDataViewSortedListModel::wxDataViewSortedListModel( wxDataViewListModel *child ) :
 280   m_array( wxDataViewIntermediateCmp )
 281 {
 282     m_child = child;
 283
 284     m_ascending = true;
 285
 286     m_notifierOnChild = new wxDataViewSortedListModelNotifier( this );
 287     m_child->AddNotifier( m_notifierOnChild );
 288
 289     m_child->IncRef();
 290
 291     Resort();
 292 }
 293
 294 wxDataViewSortedListModel::~wxDataViewSortedListModel()
 295 {
 296     DetachChild();
 297 }
 298
 299 void wxDataViewSortedListModel::DetachChild()
 300 {
 301     if (m_child)
 302     {
 303         m_child->RemoveNotifier( m_notifierOnChild );
 304         m_child->DecRef();
 305     }
 306
 307     m_child = NULL;
 308 }
 309
 310 // FIXME
 311 void wxDataViewSortedListModel::InitStatics()
 312 {
 313     s_CmpCol = 0;
 314     s_CmpModel = m_child;
 315     if (m_ascending)
 316         s_CmpFunc = wxDataViewListModelSortedDefaultCompare;
 317     else
 318         s_CmpFunc = wxDataViewListModelSortedDefaultCompareDescending;
 319 }
 320
 321 void wxDataViewSortedListModel::Resort()
 322 {
 323     InitStatics();
 324
 325     if (!m_child) return;
 326
 327     unsigned int n = m_child->GetRowCount();
 328
 329     unsigned int i;
 330     if (n != m_array.GetCount())
 331     {
 332         // probably sorted for the first time -> no reordered
 333         // -- just create index and leave
 334         m_array.Clear();
 335         for (i = 0; i < n; i++)
 336             m_array.Add( i );
 337         return;
 338     }
 339
 340     unsigned int *old_array = new unsigned int[ n ];
 341
 342     for (i = 0; i < n; i++)
 343         old_array[i] = m_array[ i ];
 344
 345     m_array.Clear();
 346     for (i = 0; i < n; i++)
 347         m_array.Add( i );
 348
 349     unsigned int *order = new unsigned int[ n ];
 350
 351     for (i = 0; i < n; i++)
 352     {
 353         unsigned int new_value = m_array[i];
 354
 355         unsigned int old_pos;
 356         for (old_pos = 0; old_pos < n; old_pos++)
 357             if (old_array[old_pos] == new_value)
 358                 break;
 359         order[i] = old_pos;
 360     }
 361
 362     delete [] old_array;
 363
 364     wxDataViewListModel::RowsReordered( order );
 365
 366     delete [] order;
 367 }
 368
 369 #if 0
 370 static void Dump( wxDataViewListModel *model, unsigned int col )
 371 {
 372     unsigned int n = model->GetRowCount();
 373     unsigned int i;
 374     for (i = 0; i < n; i++)
 375     {
 376         wxVariant variant;
 377         model->GetValue( variant, col, i );
 378         wxString tmp;
 379         tmp = variant.GetString();
 380         wxPrintf( wxT("%d: %s\n"), (int) i, tmp.c_str() );
 381     }
 382 }
 383 #endif
 384
 385 bool wxDataViewSortedListModel::ChildRowAppended()
 386 {
 387     // no need to fix up array
 388
 389     unsigned int len = m_array.GetCount();
 390
 391     unsigned int pos = m_array.Add( len );
 392
 393     if (pos == 0)
 394         return wxDataViewListModel::RowPrepended();
 395
 396     if (pos == len)
 397         return wxDataViewListModel::RowAppended();
 398
 399     return wxDataViewListModel::RowInserted( pos );
 400 }
 401
 402 bool wxDataViewSortedListModel::ChildRowPrepended()
 403 {
 404     // fix up array
 405     unsigned int i;
 406     unsigned int len = m_array.GetCount();
 407     for (i = 0; i < len; i++)
 408     {
 409         unsigned int value = m_array[i];
 410         m_array[i] = value+1;
 411     }
 412
 413     unsigned int pos = m_array.Add( 0 );
 414
 415     if (pos == 0)
 416         return wxDataViewListModel::RowPrepended();
 417
 418     if (pos == len)
 419         return wxDataViewListModel::RowAppended();
 420
 421     return wxDataViewListModel::RowInserted( pos );
 422 }
 423
 424 bool wxDataViewSortedListModel::ChildRowInserted( unsigned int before )
 425 {
 426     // fix up array
 427     unsigned int i;
 428     unsigned int len = m_array.GetCount();
 429     for (i = 0; i < len; i++)
 430     {
 431         unsigned int value = m_array[i];
 432         if (value >= before)
 433            m_array[i] = value+1;
 434     }
 435
 436     unsigned int pos = m_array.Add( before );
 437
 438     if (pos == 0)
 439         return wxDataViewListModel::RowPrepended();
 440
 441     if (pos == len)
 442         return wxDataViewListModel::RowAppended();
 443
 444     return wxDataViewListModel::RowInserted( pos );
 445 }
 446
 447 bool wxDataViewSortedListModel::ChildRowDeleted( unsigned int row )
 448 {
 449     unsigned int i;
 450     unsigned int len = m_array.GetCount();
 451     int pos = -1;
 452     for (i = 0; i < len; i++)
 453     {
 454         unsigned int value = m_array[i];
 455         if (value == row)
 456         {
 457             // delete later
 458             pos = (int) i;
 459         }
 460         else
 461         {
 462             // Fix up array
 463             if (value > row)
 464                 m_array[i] = value-1;
 465         }
 466     }
 467
 468     if (pos == -1)
 469         return false; // we should probably assert
 470
 471     // remove
 472     m_array.RemoveAt( (unsigned int) pos );
 473
 474     return wxDataViewListModel::RowDeleted( (unsigned int) pos);
 475 }
 476
 477 bool wxDataViewSortedListModel::ChildRowChanged( unsigned int row )
 478 {
 479     unsigned int i;
 480     unsigned int len = m_array.GetCount();
 481
 482     // Remove and readd sorted. Find out at which
 483     // position it was and where it ended.
 484     unsigned int start_pos = 0,end_pos = 0;
 485     for (i = 0; i < len; i++)
 486         if (m_array[i] == row)
 487         {
 488             start_pos = i;
 489             break;
 490         }
 491     m_array.RemoveAt( start_pos );
 492     m_array.Add( row );
 493
 494     for (i = 0; i < len; i++)
 495         if (m_array[i] == row)
 496         {
 497             end_pos = i;
 498             break;
 499         }
 500
 501     if (end_pos == start_pos)
 502         return wxDataViewListModel::RowChanged( start_pos );
 503
 504     // Create an array where order[old] -> new_pos, so that
 505     // if nothing changed order[0] -> 0 etc.
 506     unsigned int *order = new unsigned int[ len ];
 507     // Fill up initial values.
 508     for (i = 0; i < len; i++)
 509         order[i] = i;
 510
 511     if (start_pos < end_pos)
 512     {
 513         for (i = start_pos; i < end_pos; i++)
 514             order[i] = order[i+1];
 515         order[end_pos] = start_pos;
 516     }
 517     else
 518     {
 519         for (i = end_pos; i > start_pos; i--)
 520             order[i] = order[i-1];
 521         order[start_pos] = end_pos;
 522     }
 523
 524     wxDataViewListModel::RowsReordered( order );
 525
 526     delete [] order;
 527
 528     return true;
 529 }
 530
 531 bool wxDataViewSortedListModel::ChildValueChanged( unsigned int col, unsigned int row )
 532 {
 533     unsigned int i;
 534     unsigned int len = m_array.GetCount();
 535
 536     // Remove and readd sorted. Find out at which
 537     // position it was and where it ended.
 538     unsigned int start_pos = 0,end_pos = 0;
 539     for (i = 0; i < len; i++)
 540         if (m_array[i] == row)
 541         {
 542             start_pos = i;
 543             break;
 544         }
 545     m_array.RemoveAt( start_pos );
 546     m_array.Add( row );
 547
 548     for (i = 0; i < len; i++)
 549         if (m_array[i] == row)
 550         {
 551             end_pos = i;
 552             break;
 553         }
 554
 555     if (end_pos == start_pos)
 556         return wxDataViewListModel::ValueChanged( col, start_pos );
 557
 558     // Create an array where order[old] -> new_pos, so that
 559     // if nothing changed order[0] -> 0 etc.
 560     unsigned int *order = new unsigned int[ len ];
 561     // Fill up initial values.
 562     for (i = 0; i < len; i++)
 563         order[i] = i;
 564
 565     if (start_pos < end_pos)
 566     {
 567         for (i = start_pos; i < end_pos; i++)
 568             order[i] = order[i+1];
 569         order[end_pos] = start_pos;
 570     }
 571     else
 572     {
 573         for (i = end_pos; i > start_pos; i--)
 574             order[i] = order[i-1];
 575         order[start_pos] = end_pos;
 576     }
 577
 578     wxDataViewListModel::RowsReordered( order );
 579
 580     delete [] order;
 581
 582     return true;
 583 }
 584
 585 bool wxDataViewSortedListModel::ChildRowsReordered( unsigned int *WXUNUSED(new_order) )
 586 {
 587     // Nothing needs to be done. If the sort criteria
 588     // of this list don't change, the order of the
 589     // items of the child list isn't relevant.
 590     return true;
 591 }
 592
 593 bool wxDataViewSortedListModel::ChildCleared()
 594 {
 595     return wxDataViewListModel::Cleared();
 596 }
 597
 598 unsigned int wxDataViewSortedListModel::GetRowCount() const
 599 {
 600     if (!m_child) return 0;
 601
 602     return m_child->GetRowCount();
 603 }
 604
 605 unsigned int wxDataViewSortedListModel::GetColumnCount() const
 606 {
 607     if (!m_child) return 0;
 608
 609     return m_child->GetColumnCount();
 610 }
 611
 612 wxString wxDataViewSortedListModel::GetColumnType( unsigned int col ) const
 613 {
 614     return m_child->GetColumnType( col );
 615 }
 616
 617 #include "wx/crt.h"
 618
 619 void wxDataViewSortedListModel::GetValue( wxVariant &variant, unsigned int col, unsigned int row ) const
 620 {
 621     unsigned int child_row = m_array[row];
 622     m_child->GetValue( variant, col, child_row );
 623 }
 624
 625 bool wxDataViewSortedListModel::SetValue( const wxVariant &variant, unsigned int col, unsigned int row )
 626 {
 627     unsigned int child_row = m_array[row];
 628     bool ret = m_child->SetValue( variant, col, child_row );
 629
 630     // Do nothing here as the change in the
 631     // child model will be reported back.
 632
 633     return ret;
 634 }
 635
 636 bool wxDataViewSortedListModel::RowAppended()
 637 {
 638     // you can only append
 639     bool ret = m_child->RowAppended();
 640
 641     // Do nothing here as the change in the
 642     // child model will be reported back.
 643
 644     return ret;
 645 }
 646
 647 bool wxDataViewSortedListModel::RowPrepended()
 648 {
 649     // you can only append
 650     bool ret = m_child->RowAppended();
 651
 652     // Do nothing here as the change in the
 653     // child model will be reported back.
 654
 655     return ret;
 656 }
 657
 658 bool wxDataViewSortedListModel::RowInserted( unsigned int WXUNUSED(before) )
 659 {
 660     // you can only append
 661     bool ret = m_child->RowAppended();
 662
 663     // Do nothing here as the change in the
 664     // child model will be reported back.
 665
 666     return ret;
 667 }
 668
 669 bool wxDataViewSortedListModel::RowDeleted( unsigned int row )
 670 {
 671     unsigned int child_row = m_array[row];
 672
 673     bool ret = m_child->RowDeleted( child_row );
 674
 675     // Do nothing here as the change in the
 676     // child model will be reported back.
 677
 678     return ret;
 679 }
 680
 681 bool wxDataViewSortedListModel::RowChanged( unsigned int row )
 682 {
 683     unsigned int child_row = m_array[row];
 684     bool ret = m_child->RowChanged( child_row );
 685
 686     // Do nothing here as the change in the
 687     // child model will be reported back.
 688
 689     return ret;
 690 }
 691
 692 bool wxDataViewSortedListModel::ValueChanged( unsigned int col, unsigned int row )
 693 {
 694     unsigned int child_row = m_array[row];
 695     bool ret = m_child->ValueChanged( col, child_row );
 696
 697     // Do nothing here as the change in the
 698     // child model will be reported back.
 699
 700     return ret;
 701 }
 702
 703 bool wxDataViewSortedListModel::RowsReordered( unsigned int *WXUNUSED(new_order) )
 704 {
 705     // We sort them ourselves.
 706
 707     return false;
 708 }
 709
 710 bool wxDataViewSortedListModel::Cleared()
 711 {
 712     bool ret = m_child->Cleared();
 713
 714     // Do nothing here as the change in the
 715     // child model will be reported back.
 716
 717     return ret;
 718 }
 719
 720 // ---------------------------------------------------------
 721 // wxDataViewRendererBase
 722 // ---------------------------------------------------------
 723
 724 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRendererBase, wxObject)
 725
 726 wxDataViewRendererBase::wxDataViewRendererBase( const wxString &varianttype,
 727                                                 wxDataViewCellMode WXUNUSED(mode),
 728                                                 int WXUNUSED(align) )
 729 {
 730     m_variantType = varianttype;
 731     m_editorCtrl = NULL;
 732     m_row = (unsigned int) -1;
 733 }
 734
 735 const wxDataViewCtrl* wxDataViewRendererBase::GetView() const
 736 {
 737     return wx_const_cast(wxDataViewRendererBase*, this)->GetOwner()->GetOwner();
 738 }
 739
 740 bool wxDataViewRendererBase::StartEditing( unsigned int row, wxRect labelRect )
 741 {
 742     m_row = row; // remember for later
 743
 744     unsigned int col = GetOwner()->GetModelColumn();
 745     wxVariant value;
 746     GetOwner()->GetOwner()->GetModel()->GetValue( value, col, row );
 747
 748     m_editorCtrl = CreateEditorCtrl( GetOwner()->GetOwner()->GetMainWindow(), labelRect, value );
 749
 750     wxDataViewEditorCtrlEvtHandler *handler =
 751         new wxDataViewEditorCtrlEvtHandler( m_editorCtrl, (wxDataViewRenderer*) this );
 752
 753     m_editorCtrl->PushEventHandler( handler );
 754
 755 #if defined(__WXGTK20__) && !defined(wxUSE_GENERICDATAVIEWCTRL)
 756     handler->SetFocusOnIdle();
 757 #else
 758     m_editorCtrl->SetFocus();
 759 #endif
 760
 761     return true;
 762 }
 763
 764 void wxDataViewRendererBase::CancelEditing()
 765 {
 766     wxPendingDelete.Append( m_editorCtrl );
 767
 768     GetOwner()->GetOwner()->GetMainWindow()->SetFocus();
 769
 770     // m_editorCtrl->PopEventHandler( true );
 771 }
 772
 773 bool wxDataViewRendererBase::FinishEditing()
 774 {
 775     wxVariant value;
 776     GetValueFromEditorCtrl( m_editorCtrl, value );
 777
 778     wxPendingDelete.Append( m_editorCtrl );
 779
 780     GetOwner()->GetOwner()->GetMainWindow()->SetFocus();
 781
 782     if (!Validate(value))
 783         return false;
 784
 785     unsigned int col = GetOwner()->GetModelColumn();
 786     GetOwner()->GetOwner()->GetModel()->SetValue( value, col, m_row );
 787     GetOwner()->GetOwner()->GetModel()->ValueChanged( col, m_row );
 788
 789     // m_editorCtrl->PopEventHandler( true );
 790
 791     return true;
 792 }
 793
 794 //-----------------------------------------------------------------------------
 795 // wxDataViewEditorCtrlEvtHandler
 796 //-----------------------------------------------------------------------------
 797
 798 BEGIN_EVENT_TABLE(wxDataViewEditorCtrlEvtHandler, wxEvtHandler)
 799     EVT_CHAR           (wxDataViewEditorCtrlEvtHandler::OnChar)
 800     EVT_KILL_FOCUS     (wxDataViewEditorCtrlEvtHandler::OnKillFocus)
 801     EVT_IDLE           (wxDataViewEditorCtrlEvtHandler::OnIdle)
 802 END_EVENT_TABLE()
 803
 804 wxDataViewEditorCtrlEvtHandler::wxDataViewEditorCtrlEvtHandler(
 805                                 wxControl *editorCtrl,
 806                                 wxDataViewRenderer *owner )
 807 {
 808     m_owner = owner;
 809     m_editorCtrl = editorCtrl;
 810
 811     m_finished = false;
 812 }
 813
 814 void wxDataViewEditorCtrlEvtHandler::OnIdle( wxIdleEvent &event )
 815 {
 816     if (m_focusOnIdle)
 817     {
 818         m_focusOnIdle = false;
 819         if (wxWindow::FindFocus() != m_editorCtrl)
 820             m_editorCtrl->SetFocus();
 821     }
 822
 823     event.Skip();
 824 }
 825
 826 void wxDataViewEditorCtrlEvtHandler::OnChar( wxKeyEvent &event )
 827 {
 828     switch ( event.m_keyCode )
 829     {
 830         case WXK_RETURN:
 831             m_finished = true;
 832             m_owner->FinishEditing();
 833             break;
 834
 835         case WXK_ESCAPE:
 836             m_finished = true;
 837             m_owner->CancelEditing();
 838             break;
 839
 840         default:
 841             event.Skip();
 842     }
 843 }
 844
 845 void wxDataViewEditorCtrlEvtHandler::OnKillFocus( wxFocusEvent &event )
 846 {
 847     if (!m_finished)
 848     {
 849         m_finished = true;
 850         m_owner->FinishEditing();
 851     }
 852
 853     event.Skip();
 854 }
 855
 856 // ---------------------------------------------------------
 857 // wxDataViewColumnBase
 858 // ---------------------------------------------------------
 859
 860 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumnBase, wxObject)
 861
 862 wxDataViewColumnBase::wxDataViewColumnBase(const wxString& WXUNUSED(title),
 863                                            wxDataViewRenderer *renderer,
 864                                            unsigned int model_column,
 865                                            int WXUNUSED(width),
 866                                            wxAlignment WXUNUSED(align),
 867                                            int WXUNUSED(flags))
 868 {
 869     m_renderer = renderer;
 870     m_model_column = model_column;
 871     m_owner = NULL;
 872     m_renderer->SetOwner( (wxDataViewColumn*) this );
 873
 874     // NOTE: the wxDataViewColumn's ctor must store the width, align, flags
 875     //       parameters inside the native control!
 876 }
 877
 878 wxDataViewColumnBase::wxDataViewColumnBase(const wxBitmap& bitmap,
 879                                            wxDataViewRenderer *renderer,
 880                                            unsigned int model_column,
 881                                            int WXUNUSED(width),
 882                                            wxAlignment WXUNUSED(align),
 883                                            int WXUNUSED(flags) )
 884 {
 885     m_renderer = renderer;
 886     m_model_column = model_column;
 887     m_bitmap = bitmap;
 888     m_owner = NULL;
 889     m_renderer->SetOwner( (wxDataViewColumn*) this );
 890 }
 891
 892 wxDataViewColumnBase::~wxDataViewColumnBase()
 893 {
 894     if (m_renderer)
 895         delete m_renderer;
 896 }
 897
 898 int wxDataViewColumnBase::GetFlags() const
 899 {
 900     int ret = 0;
 901
 902     if (IsSortable())
 903         ret |= wxDATAVIEW_COL_SORTABLE;
 904     if (IsResizeable())
 905         ret |= wxDATAVIEW_COL_RESIZABLE;
 906     if (IsHidden())
 907         ret |= wxDATAVIEW_COL_HIDDEN;
 908
 909     return ret;
 910 }
 911
 912 void wxDataViewColumnBase::SetFlags(int flags)
 913 {
 914     SetSortable((flags & wxDATAVIEW_COL_SORTABLE) != 0);
 915     SetResizeable((flags & wxDATAVIEW_COL_RESIZABLE) != 0);
 916     SetHidden((flags & wxDATAVIEW_COL_HIDDEN) != 0);
 917 }
 918
 919 // ---------------------------------------------------------
 920 // wxDataViewEventListModelNotifier
 921 // ---------------------------------------------------------
 922
 923 class WXDLLIMPEXP_ADV wxDataViewEventListModelNotifier: public wxDataViewListModelNotifier
 924 {
 925 public:
 926     wxDataViewEventListModelNotifier( wxDataViewCtrl *ctrl ) { m_ctrl = ctrl; }
 927
 928     bool SendEvent( wxEventType event_type, unsigned int row = 0, unsigned int col = 0 )
 929     {
 930         wxDataViewEvent event( event_type, m_ctrl->GetId() );
 931         event.SetEventObject( m_ctrl );
 932         event.SetModel( m_ctrl->GetModel() );
 933         event.SetRow( row );
 934         event.SetColumn( col );
 935         m_ctrl->GetEventHandler()->ProcessEvent( event );
 936         return true;
 937     }
 938
 939     virtual bool RowAppended()  { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROW_APPENDED ); }
 940     virtual bool RowPrepended() { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROW_PREPENDED ); }
 941     virtual bool RowInserted( unsigned int before )
 942                                 { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROW_INSERTED, before ); }
 943     virtual bool RowDeleted( unsigned int row )
 944                                 { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROW_DELETED, row ); }
 945     virtual bool RowChanged( unsigned int row )
 946                                 { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROW_CHANGED, row ); }
 947     virtual bool ValueChanged( unsigned int col, unsigned int row )
 948                                 { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_VALUE_CHANGED, row, col ); }
 949     virtual bool RowsReordered( unsigned int *new_order )
 950                                 { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_ROWS_REORDERED ); }
 951     virtual bool Cleared()      { return SendEvent( wxEVT_COMMAND_DATAVIEW_MODEL_CLEARED ); }
 952
 953 private:
 954     wxDataViewCtrl *m_ctrl;
 955 };
 956
 957
 958 // ---------------------------------------------------------
 959 // wxDataViewCtrlBase
 960 // ---------------------------------------------------------
 961
 962 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCtrlBase, wxControl)
 963
 964 wxDataViewCtrlBase::wxDataViewCtrlBase()
 965 {
 966     m_model = NULL;
 967     m_cols.DeleteContents( true );
 968     m_eventNotifier = NULL;
 969 }
 970
 971 wxDataViewCtrlBase::~wxDataViewCtrlBase()
 972 {
 973     // IMPORTANT: before calling DecRef() on our model (since it may
 974     //            result in a free() call), erase all columns (since
 975     //            they hold a pointer to our model)
 976     m_cols.Clear();
 977
 978     if (m_model)
 979     {
 980         if (m_eventNotifier)
 981             m_model->RemoveNotifier( m_eventNotifier );
 982         m_eventNotifier = NULL;
 983
 984         m_model->DecRef();
 985         m_model = NULL;
 986     }
 987 }
 988
 989 bool wxDataViewCtrlBase::AssociateModel( wxDataViewListModel *model )
 990 {
 991     if (m_model)
 992     {
 993         if (m_eventNotifier)
 994             m_model->RemoveNotifier( m_eventNotifier );
 995         m_eventNotifier = NULL;
 996
 997         m_model->DecRef();   // discard old model, if any
 998     }
 999
1000     // add our own reference to the new model:
1001     m_model = model;
1002     if (m_model)
1003     {
1004         m_model->IncRef();
1005         m_eventNotifier = new wxDataViewEventListModelNotifier( (wxDataViewCtrl*) this );
1006         m_model->AddNotifier( m_eventNotifier );
1007     }
1008
1009     return true;
1010 }
1011
1012 wxDataViewListModel* wxDataViewCtrlBase::GetModel()
1013 {
1014     return m_model;
1015 }
1016
1017 bool wxDataViewCtrlBase::AppendTextColumn( const wxString &label, unsigned int model_column,
1018                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1019 {
1020     return AppendColumn( new wxDataViewColumn( label,
1021         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
1022         model_column, width, align, flags ) );
1023 }
1024
1025 bool wxDataViewCtrlBase::AppendToggleColumn( const wxString &label, unsigned int model_column,
1026                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1027 {
1028     return AppendColumn( new wxDataViewColumn( label,
1029         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
1030         model_column, width, align, flags ) );
1031 }
1032
1033 bool wxDataViewCtrlBase::AppendProgressColumn( const wxString &label, unsigned int model_column,
1034                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1035 {
1036     return AppendColumn( new wxDataViewColumn( label,
1037         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
1038         model_column, width, align, flags ) );
1039 }
1040
1041 bool wxDataViewCtrlBase::AppendDateColumn( const wxString &label, unsigned int model_column,
1042                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1043 {
1044     return AppendColumn( new wxDataViewColumn( label,
1045         new wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
1046         model_column, width, align, flags ) );
1047 }
1048
1049 bool wxDataViewCtrlBase::AppendBitmapColumn( const wxString &label, unsigned int model_column,
1050                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1051 {
1052     return AppendColumn( new wxDataViewColumn( label,
1053         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
1054         model_column, width, align, flags ) );
1055 }
1056
1057 bool wxDataViewCtrlBase::AppendTextColumn( const wxBitmap &label, unsigned int model_column,
1058                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1059 {
1060     return AppendColumn( new wxDataViewColumn( label,
1061         new wxDataViewTextRenderer( wxT("string"), mode, (int)align ),
1062         model_column, width, align, flags ) );
1063 }
1064
1065 bool wxDataViewCtrlBase::AppendToggleColumn( const wxBitmap &label, unsigned int model_column,
1066                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1067 {
1068     return AppendColumn( new wxDataViewColumn( label,
1069         new wxDataViewToggleRenderer( wxT("bool"), mode, (int)align ),
1070         model_column, width, align, flags ) );
1071 }
1072
1073 bool wxDataViewCtrlBase::AppendProgressColumn( const wxBitmap &label, unsigned int model_column,
1074                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1075 {
1076     return AppendColumn( new wxDataViewColumn( label,
1077         new wxDataViewProgressRenderer( wxEmptyString, wxT("long"), mode, (int)align ),
1078         model_column, width, align, flags ) );
1079 }
1080
1081 bool wxDataViewCtrlBase::AppendDateColumn( const wxBitmap &label, unsigned int model_column,
1082                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1083 {
1084     return AppendColumn( new wxDataViewColumn( label,
1085         new wxDataViewDateRenderer( wxT("datetime"), mode, (int)align ),
1086         model_column, width, align, flags ) );
1087 }
1088
1089 bool wxDataViewCtrlBase::AppendBitmapColumn( const wxBitmap &label, unsigned int model_column,
1090                             wxDataViewCellMode mode, int width, wxAlignment align, int flags )
1091 {
1092     return AppendColumn( new wxDataViewColumn( label,
1093         new wxDataViewBitmapRenderer( wxT("wxBitmap"), mode, (int)align ),
1094         model_column, width, align, flags ) );
1095 }
1096
1097 bool wxDataViewCtrlBase::AppendColumn( wxDataViewColumn *col )
1098 {
1099     m_cols.Append( (wxObject*) col );
1100     col->SetOwner( (wxDataViewCtrl*) this );
1101     return true;
1102 }
1103
1104 unsigned int wxDataViewCtrlBase::GetColumnCount() const
1105 {
1106     return m_cols.GetCount();
1107 }
1108
1109 bool wxDataViewCtrlBase::DeleteColumn( unsigned int WXUNUSED(pos) )
1110 {
1111     return false;
1112 }
1113
1114 bool wxDataViewCtrlBase::ClearColumns()
1115 {
1116     return false;
1117 }
1118
1119 wxDataViewColumn* wxDataViewCtrlBase::GetColumn( unsigned int pos )
1120 {
1121     return (wxDataViewColumn*) m_cols[ pos ];
1122 }
1123
1124 // ---------------------------------------------------------
1125 // wxDataViewEvent
1126 // ---------------------------------------------------------
1127
1128 IMPLEMENT_DYNAMIC_CLASS(wxDataViewEvent,wxNotifyEvent)
1129
1130 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ROW_SELECTED)
1131 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_ROW_ACTIVATED)
1132 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK)
1133 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK)
1134
1135 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROW_APPENDED)
1136 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROW_PREPENDED)
1137 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROW_INSERTED)
1138 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROW_DELETED)
1139 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROW_CHANGED)
1140 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_VALUE_CHANGED)
1141 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_ROWS_REORDERED)
1142 DEFINE_EVENT_TYPE(wxEVT_COMMAND_DATAVIEW_MODEL_CLEARED)
1143
1144 #endif