src/generic/datavgen.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        datavgen.cpp
   3 // Purpose:     wxDataViewCtrl generic implementation
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #include "wx/defs.h"
  14
  15 #if wxUSE_DATAVIEWCTRL
  16
  17 #include "wx/dataview.h"
  18
  19 #ifdef wxUSE_GENERICDATAVIEWCTRL
  20
  21 #include "wx/stockitem.h"
  22 #include "wx/dcclient.h"
  23 #include "wx/calctrl.h"
  24 #include "wx/popupwin.h"
  25 #include "wx/sizer.h"
  26 #include "wx/log.h"
  27 #include "wx/renderer.h"
  28
  29 #ifdef __WXMSW__
  30     #include <windows.h> // for DLGC_WANTARROWS
  31     #include "wx/msw/winundef.h"
  32 #endif
  33
  34 //-----------------------------------------------------------------------------
  35 // classes
  36 //-----------------------------------------------------------------------------
  37
  38 class wxDataViewCtrl;
  39
  40 //-----------------------------------------------------------------------------
  41 // wxDataViewHeaderWindow
  42 //-----------------------------------------------------------------------------
  43
  44 class wxDataViewHeaderWindow: public wxWindow
  45 {
  46 public:
  47     wxDataViewHeaderWindow( wxDataViewCtrl *parent,
  48                             wxWindowID id,
  49                             const wxPoint &pos = wxDefaultPosition,
  50                             const wxSize &size = wxDefaultSize,
  51                             const wxString &name = wxT("wxdataviewctrlheaderwindow") );
  52     ~wxDataViewHeaderWindow();
  53
  54     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
  55     wxDataViewCtrl *GetOwner() { return m_owner; }
  56
  57     void OnPaint( wxPaintEvent &event );
  58     void OnMouse( wxMouseEvent &event );
  59     void OnSetFocus( wxFocusEvent &event );
  60
  61 private:
  62     wxDataViewCtrl      *m_owner;
  63     wxCursor            *m_resizeCursor;
  64
  65 private:
  66     DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
  67     DECLARE_EVENT_TABLE()
  68 };
  69
  70 //-----------------------------------------------------------------------------
  71 // wxDataViewMainWindow
  72 //-----------------------------------------------------------------------------
  73
  74 class wxDataViewMainWindow: public wxWindow
  75 {
  76 public:
  77     wxDataViewMainWindow( wxDataViewCtrl *parent,
  78                             wxWindowID id,
  79                             const wxPoint &pos = wxDefaultPosition,
  80                             const wxSize &size = wxDefaultSize,
  81                             const wxString &name = wxT("wxdataviewctrlmainwindow") );
  82     ~wxDataViewMainWindow();
  83
  84     // notifications from wxDataViewListModel
  85     bool RowAppended();
  86     bool RowPrepended();
  87     bool RowInserted( size_t before );
  88     bool RowDeleted( size_t row );
  89     bool RowChanged( size_t row );
  90     bool ValueChanged( size_t col, size_t row );
  91     bool RowsReordered( size_t *new_order );
  92     bool Cleared();
  93
  94     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
  95     wxDataViewCtrl *GetOwner() { return m_owner; }
  96
  97     void OnPaint( wxPaintEvent &event );
  98     void OnMouse( wxMouseEvent &event );
  99     void OnSetFocus( wxFocusEvent &event );
 100
 101     void UpdateDisplay();
 102     void RecalculateDisplay();
 103     void OnInternalIdle();
 104
 105     void ScrollWindow( int dx, int dy, const wxRect *rect );
 106 private:
 107     wxDataViewCtrl      *m_owner;
 108     int                  m_lineHeight;
 109     bool                 m_dirty;
 110
 111 private:
 112     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
 113     DECLARE_EVENT_TABLE()
 114 };
 115
 116 // ---------------------------------------------------------
 117 // wxGenericDataViewListModelNotifier
 118 // ---------------------------------------------------------
 119
 120 class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
 121 {
 122 public:
 123     wxGenericDataViewListModelNotifier( wxDataViewMainWindow *mainWindow )
 124         { m_mainWindow = mainWindow; }
 125
 126     virtual bool RowAppended()
 127         { return m_mainWindow->RowAppended(); }
 128     virtual bool RowPrepended()
 129         { return m_mainWindow->RowPrepended(); }
 130     virtual bool RowInserted( size_t before )
 131         { return m_mainWindow->RowInserted( before ); }
 132     virtual bool RowDeleted( size_t row )
 133         { return m_mainWindow->RowDeleted( row ); }
 134     virtual bool RowChanged( size_t row )
 135         { return m_mainWindow->RowChanged( row ); }
 136     virtual bool ValueChanged( size_t col, size_t row )
 137         { return m_mainWindow->ValueChanged( col, row ); }
 138     virtual bool RowsReordered( size_t *new_order )
 139         { return m_mainWindow->RowsReordered( new_order ); }
 140     virtual bool Cleared()
 141         { return m_mainWindow->Cleared(); }
 142
 143     wxDataViewMainWindow    *m_mainWindow;
 144 };
 145
 146 // ---------------------------------------------------------
 147 // wxDataViewCell
 148 // ---------------------------------------------------------
 149
 150 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCell, wxDataViewCellBase)
 151
 152 wxDataViewCell::wxDataViewCell( const wxString &varianttype, wxDataViewCellMode mode ) :
 153     wxDataViewCellBase( varianttype, mode )
 154 {
 155     m_dc = NULL;
 156 }
 157
 158 wxDataViewCell::~wxDataViewCell()
 159 {
 160     if (m_dc)
 161         delete m_dc;
 162 }
 163
 164 wxDC *wxDataViewCell::GetDC()
 165 {
 166     if (m_dc == NULL)
 167     {
 168         if (GetOwner() == NULL)
 169             return NULL;
 170         if (GetOwner()->GetOwner() == NULL)
 171             return NULL;
 172         m_dc = new wxClientDC( GetOwner()->GetOwner() );
 173     }
 174
 175     return m_dc;
 176 }
 177
 178 // ---------------------------------------------------------
 179 // wxDataViewCustomCell
 180 // ---------------------------------------------------------
 181
 182 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomCell, wxDataViewCell)
 183
 184 wxDataViewCustomCell::wxDataViewCustomCell( const wxString &varianttype,
 185                           wxDataViewCellMode mode ) :
 186     wxDataViewCell( varianttype, mode )
 187 {
 188 }
 189
 190
 191 // ---------------------------------------------------------
 192 // wxDataViewTextCell
 193 // ---------------------------------------------------------
 194
 195 IMPLEMENT_ABSTRACT_CLASS(wxDataViewTextCell, wxDataViewCustomCell)
 196
 197 wxDataViewTextCell::wxDataViewTextCell( const wxString &varianttype, wxDataViewCellMode mode ) :
 198     wxDataViewCustomCell( varianttype, mode )
 199 {
 200 }
 201
 202 bool wxDataViewTextCell::SetValue( const wxVariant &value )
 203 {
 204     m_text = value.GetString();
 205
 206     return true;
 207 }
 208
 209 bool wxDataViewTextCell::GetValue( wxVariant &value )
 210 {
 211     return false;
 212 }
 213
 214 bool wxDataViewTextCell::Render( wxRect cell, wxDC *dc, int state )
 215 {
 216     dc->DrawText( m_text, cell.x, cell.y );
 217
 218     return true;
 219 }
 220
 221 wxSize wxDataViewTextCell::GetSize()
 222 {
 223     return wxSize(80,20);
 224 }
 225
 226 // ---------------------------------------------------------
 227 // wxDataViewToggleCell
 228 // ---------------------------------------------------------
 229
 230 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleCell, wxDataViewCustomCell)
 231
 232 wxDataViewToggleCell::wxDataViewToggleCell( const wxString &varianttype,
 233                         wxDataViewCellMode mode ) :
 234     wxDataViewCustomCell( varianttype, mode )
 235 {
 236     m_toggle = false;
 237 }
 238
 239 bool wxDataViewToggleCell::SetValue( const wxVariant &value )
 240 {
 241     m_toggle = value.GetBool();
 242
 243     return true;;
 244 }
 245
 246 bool wxDataViewToggleCell::GetValue( wxVariant &value )
 247 {
 248     return false;
 249 }
 250
 251 bool wxDataViewToggleCell::Render( wxRect cell, wxDC *dc, int state )
 252 {
 253     // User wxRenderer here
 254
 255     if (GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
 256         dc->SetPen( *wxBLACK_PEN );
 257     else
 258         dc->SetPen( *wxGREY_PEN );
 259     dc->SetBrush( *wxTRANSPARENT_BRUSH );
 260     wxRect rect;
 261     rect.x = cell.x + cell.width/2 - 10;
 262     rect.width = 20;
 263     rect.y = cell.y + cell.height/2 - 10;
 264     rect.height = 20;
 265     dc->DrawRectangle( rect );
 266     if (m_toggle)
 267     {
 268         rect.x += 2;
 269         rect.y += 2;
 270         rect.width -= 4;
 271         rect.height -= 4;
 272         dc->DrawLine( rect.x, rect.y, rect.x+rect.width, rect.y+rect.height );
 273         dc->DrawLine( rect.x+rect.width, rect.y, rect.x, rect.y+rect.height );
 274     }
 275
 276     return true;
 277 }
 278
 279 bool wxDataViewToggleCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
 280 {
 281     bool value = !m_toggle;
 282     wxVariant variant = value;
 283     model->SetValue( variant, col, row );
 284     model->ValueChanged( col, row );
 285     return true;
 286 }
 287
 288 wxSize wxDataViewToggleCell::GetSize()
 289 {
 290     return wxSize(20,20);
 291 }
 292
 293 // ---------------------------------------------------------
 294 // wxDataViewProgressCell
 295 // ---------------------------------------------------------
 296
 297 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressCell, wxDataViewCustomCell)
 298
 299 wxDataViewProgressCell::wxDataViewProgressCell( const wxString &label,
 300     const wxString &varianttype, wxDataViewCellMode mode ) :
 301     wxDataViewCustomCell( varianttype, mode )
 302 {
 303     m_label = label;
 304     m_value = 0;
 305 }
 306
 307 wxDataViewProgressCell::~wxDataViewProgressCell()
 308 {
 309 }
 310
 311 bool wxDataViewProgressCell::SetValue( const wxVariant &value )
 312 {
 313     m_value = (long) value;
 314
 315     if (m_value < 0) m_value = 0;
 316     if (m_value > 100) m_value = 100;
 317
 318     return true;
 319 }
 320
 321 bool wxDataViewProgressCell::Render( wxRect cell, wxDC *dc, int state )
 322 {
 323     double pct = (double)m_value / 100.0;
 324     wxRect bar = cell;
 325     bar.width = (int)(cell.width * pct);
 326     dc->SetPen( *wxTRANSPARENT_PEN );
 327     dc->SetBrush( *wxBLUE_BRUSH );
 328     dc->DrawRectangle( bar );
 329
 330     dc->SetBrush( *wxTRANSPARENT_BRUSH );
 331     dc->SetPen( *wxBLACK_PEN );
 332     dc->DrawRectangle( cell );
 333
 334     return true;
 335 }
 336
 337 wxSize wxDataViewProgressCell::GetSize()
 338 {
 339     return wxSize(40,12);
 340 }
 341
 342 // ---------------------------------------------------------
 343 // wxDataViewDateCell
 344 // ---------------------------------------------------------
 345
 346 class wxDataViewDateCellPopupTransient: public wxPopupTransientWindow
 347 {
 348 public:
 349     wxDataViewDateCellPopupTransient( wxWindow* parent, wxDateTime *value,
 350         wxDataViewListModel *model, size_t col, size_t row ) :
 351         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
 352     {
 353         m_model = model;
 354         m_col = col;
 355         m_row = row;
 356         m_cal = new wxCalendarCtrl( this, -1, *value );
 357         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
 358         sizer->Add( m_cal, 1, wxGROW );
 359         SetSizer( sizer );
 360         sizer->Fit( this );
 361     }
 362
 363     virtual void OnDismiss()
 364     {
 365     }
 366
 367     void OnCalendar( wxCalendarEvent &event );
 368
 369     wxCalendarCtrl      *m_cal;
 370     wxDataViewListModel *m_model;
 371     size_t               m_col;
 372     size_t               m_row;
 373
 374 private:
 375     DECLARE_EVENT_TABLE()
 376 };
 377
 378 BEGIN_EVENT_TABLE(wxDataViewDateCellPopupTransient,wxPopupTransientWindow)
 379     EVT_CALENDAR( -1, wxDataViewDateCellPopupTransient::OnCalendar )
 380 END_EVENT_TABLE()
 381
 382 void wxDataViewDateCellPopupTransient::OnCalendar( wxCalendarEvent &event )
 383 {
 384     wxDateTime date = event.GetDate();
 385     wxVariant value = date;
 386     m_model->SetValue( value, m_col, m_row );
 387     m_model->ValueChanged( m_col, m_row );
 388     DismissAndNotify();
 389 }
 390
 391 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateCell, wxDataViewCustomCell)
 392
 393 wxDataViewDateCell::wxDataViewDateCell( const wxString &varianttype,
 394                         wxDataViewCellMode mode ) :
 395     wxDataViewCustomCell( varianttype, mode )
 396 {
 397 }
 398
 399 bool wxDataViewDateCell::SetValue( const wxVariant &value )
 400 {
 401     m_date = value.GetDateTime();
 402
 403     return true;
 404 }
 405
 406 bool wxDataViewDateCell::Render( wxRect cell, wxDC *dc, int state )
 407 {
 408     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
 409     wxString tmp = m_date.FormatDate();
 410     dc->DrawText( tmp, cell.x, cell.y );
 411
 412     return true;
 413 }
 414
 415 wxSize wxDataViewDateCell::GetSize()
 416 {
 417     wxDataViewCtrl* view = GetOwner()->GetOwner();
 418     wxString tmp = m_date.FormatDate();
 419     wxCoord x,y,d;
 420     view->GetTextExtent( tmp, &x, &y, &d );
 421     return wxSize(x,y+d);
 422 }
 423
 424 bool wxDataViewDateCell::Activate( wxRect cell, wxDataViewListModel *model, size_t col, size_t row )
 425 {
 426     wxVariant variant;
 427     model->GetValue( variant, col, row );
 428     wxDateTime value = variant.GetDateTime();
 429
 430     wxDataViewDateCellPopupTransient *popup = new wxDataViewDateCellPopupTransient(
 431         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
 432     wxPoint pos = wxGetMousePosition();
 433     popup->Move( pos );
 434     popup->Layout();
 435     popup->Popup( popup->m_cal );
 436
 437     return true;
 438 }
 439
 440 // ---------------------------------------------------------
 441 // wxDataViewColumn
 442 // ---------------------------------------------------------
 443
 444 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 445
 446 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewCell *cell,
 447     size_t model_column, int flags ) :
 448     wxDataViewColumnBase( title, cell, model_column, flags )
 449 {
 450     m_width = 80;
 451 }
 452
 453 wxDataViewColumn::~wxDataViewColumn()
 454 {
 455 }
 456
 457 void wxDataViewColumn::SetTitle( const wxString &title )
 458 {
 459     wxDataViewColumnBase::SetTitle( title );
 460
 461 }
 462
 463 //-----------------------------------------------------------------------------
 464 // wxDataViewHeaderWindow
 465 //-----------------------------------------------------------------------------
 466
 467 IMPLEMENT_ABSTRACT_CLASS(wxDataViewHeaderWindow, wxWindow)
 468
 469 BEGIN_EVENT_TABLE(wxDataViewHeaderWindow,wxWindow)
 470     EVT_PAINT         (wxDataViewHeaderWindow::OnPaint)
 471     EVT_MOUSE_EVENTS  (wxDataViewHeaderWindow::OnMouse)
 472     EVT_SET_FOCUS     (wxDataViewHeaderWindow::OnSetFocus)
 473 END_EVENT_TABLE()
 474
 475 wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindowID id,
 476      const wxPoint &pos, const wxSize &size, const wxString &name ) :
 477     wxWindow( parent, id, pos, size, 0, name )
 478 {
 479     SetOwner( parent );
 480
 481     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
 482
 483     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
 484     SetOwnForegroundColour( attr.colFg );
 485     SetOwnBackgroundColour( attr.colBg );
 486     if (!m_hasFont)
 487         SetOwnFont( attr.font );
 488 }
 489
 490 wxDataViewHeaderWindow::~wxDataViewHeaderWindow()
 491 {
 492     delete m_resizeCursor;
 493 }
 494
 495 void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &event )
 496 {
 497     int w, h;
 498     GetClientSize( &w, &h );
 499
 500     wxPaintDC dc( this );
 501
 502     int xpix;
 503     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
 504
 505     int x;
 506     m_owner->GetViewStart( &x, NULL );
 507
 508     // account for the horz scrollbar offset
 509     dc.SetDeviceOrigin( -x * xpix, 0 );
 510
 511     dc.SetFont( GetFont() );
 512
 513     size_t cols = GetOwner()->GetNumberOfColumns();
 514     size_t i;
 515     int xpos = 0;
 516     for (i = 0; i < cols; i++)
 517     {
 518         wxDataViewColumn *col = GetOwner()->GetColumn( i );
 519         int width = col->GetWidth();
 520
 521         // the width of the rect to draw: make it smaller to fit entirely
 522         // inside the column rect
 523 #ifdef __WXMAC__
 524         int cw = width;
 525         int ch = h;
 526 #else
 527         int cw = width - 2;
 528         int ch = h - 2;
 529 #endif
 530
 531         wxRendererNative::Get().DrawHeaderButton
 532                                 (
 533                                     this,
 534                                     dc,
 535                                     wxRect(xpos, 0, cw, ch),
 536                                     m_parent->IsEnabled() ? 0
 537                                                           : (int)wxCONTROL_DISABLED
 538                                 );
 539
 540         dc.DrawText( col->GetTitle(), xpos+3, 3 );
 541
 542         xpos += width;
 543     }
 544 }
 545
 546 void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &event )
 547 {
 548 }
 549
 550 void wxDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
 551 {
 552     event.Skip();
 553 }
 554
 555 //-----------------------------------------------------------------------------
 556 // wxDataViewMainWindow
 557 //-----------------------------------------------------------------------------
 558
 559 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
 560
 561 BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
 562     EVT_PAINT         (wxDataViewMainWindow::OnPaint)
 563     EVT_MOUSE_EVENTS  (wxDataViewMainWindow::OnMouse)
 564     EVT_SET_FOCUS     (wxDataViewMainWindow::OnSetFocus)
 565 END_EVENT_TABLE()
 566
 567 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
 568     const wxPoint &pos, const wxSize &size, const wxString &name ) :
 569     wxWindow( parent, id, pos, size, 0, name )
 570 {
 571     SetOwner( parent );
 572
 573     // We need to calculate this smartly..
 574     m_lineHeight = 20;
 575
 576     UpdateDisplay();
 577 }
 578
 579 wxDataViewMainWindow::~wxDataViewMainWindow()
 580 {
 581 }
 582
 583 bool wxDataViewMainWindow::RowAppended()
 584 {
 585     return false;
 586 }
 587
 588 bool wxDataViewMainWindow::RowPrepended()
 589 {
 590     return false;
 591 }
 592
 593 bool wxDataViewMainWindow::RowInserted( size_t before )
 594 {
 595     return false;
 596 }
 597
 598 bool wxDataViewMainWindow::RowDeleted( size_t row )
 599 {
 600     return false;
 601 }
 602
 603 bool wxDataViewMainWindow::RowChanged( size_t row )
 604 {
 605     return false;
 606 }
 607
 608 bool wxDataViewMainWindow::ValueChanged( size_t col, size_t row )
 609 {
 610     wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
 611     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
 612     Refresh( true, &rect );
 613
 614     return true;
 615 }
 616
 617 bool wxDataViewMainWindow::RowsReordered( size_t *new_order )
 618 {
 619     return false;
 620 }
 621
 622 bool wxDataViewMainWindow::Cleared()
 623 {
 624     return false;
 625 }
 626
 627 void wxDataViewMainWindow::UpdateDisplay()
 628 {
 629     m_dirty = true;
 630 }
 631
 632 void wxDataViewMainWindow::OnInternalIdle()
 633 {
 634     wxWindow::OnInternalIdle();
 635
 636     if (m_dirty)
 637     {
 638         RecalculateDisplay();
 639         m_dirty = false;
 640     }
 641 }
 642
 643 void wxDataViewMainWindow::RecalculateDisplay()
 644 {
 645     wxDataViewListModel *model = GetOwner()->GetModel();
 646     if (!model)
 647     {
 648         Refresh();
 649         return;
 650     }
 651
 652     int width = 0;
 653     size_t cols = GetOwner()->GetNumberOfColumns();
 654     size_t i;
 655     for (i = 0; i < cols; i++)
 656     {
 657         wxDataViewColumn *col = GetOwner()->GetColumn( i );
 658         width += col->GetWidth();
 659     }
 660
 661     int height = model->GetNumberOfRows() * m_lineHeight;
 662
 663     SetVirtualSize( width, height );
 664     GetOwner()->SetScrollRate( 10, m_lineHeight );
 665
 666     Refresh();
 667 }
 668
 669 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
 670 {
 671     wxWindow::ScrollWindow( dx, dy, rect );
 672     GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
 673 }
 674
 675 void wxDataViewMainWindow::OnPaint( wxPaintEvent &event )
 676 {
 677     wxPaintDC dc( this );
 678
 679     GetOwner()->PrepareDC( dc );
 680
 681     dc.SetFont( GetFont() );
 682
 683     wxRect update = GetUpdateRegion().GetBox();
 684     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
 685
 686     wxDataViewListModel *model = GetOwner()->GetModel();
 687
 688     size_t item_start = update.y / m_lineHeight;
 689     size_t item_count = (update.height / m_lineHeight) + 1;
 690
 691     wxRect cell_rect;
 692     cell_rect.x = 0;
 693     cell_rect.height = m_lineHeight;
 694     size_t cols = GetOwner()->GetNumberOfColumns();
 695     size_t i;
 696     for (i = 0; i < cols; i++)
 697     {
 698         wxDataViewColumn *col = GetOwner()->GetColumn( i );
 699         wxDataViewCell *cell = col->GetCell();
 700         cell_rect.width = col->GetWidth();
 701
 702         size_t item;
 703         for (item = item_start; item <= item_start+item_count; item++)
 704         {
 705             cell_rect.y = item*m_lineHeight;
 706             wxVariant value;
 707             model->GetValue( value, col->GetModelColumn(), item );
 708             cell->SetValue( value );
 709             cell->Render( cell_rect, &dc, 0 );
 710         }
 711
 712         cell_rect.x += cell_rect.width;
 713     }
 714 }
 715
 716 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
 717 {
 718     int x = event.GetX();
 719     int y = event.GetY();
 720     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
 721
 722     wxDataViewColumn *col = NULL;
 723
 724     int xpos = 0;
 725     size_t cols = GetOwner()->GetNumberOfColumns();
 726     size_t i;
 727     for (i = 0; i < cols; i++)
 728     {
 729         wxDataViewColumn *c = GetOwner()->GetColumn( i );
 730         if (x < xpos + c->GetWidth())
 731         {
 732             col = c;
 733             break;
 734         }
 735         xpos += c->GetWidth();
 736     }
 737     if (!col)
 738         return;
 739     wxDataViewCell *cell = col->GetCell();
 740
 741     size_t row = y / m_lineHeight;
 742
 743     wxDataViewListModel *model = GetOwner()->GetModel();
 744
 745     if (event.LeftDClick())
 746     {
 747         if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
 748         {
 749             wxVariant value;
 750             model->GetValue( value, col->GetModelColumn(), row );
 751             cell->SetValue( value );
 752             wxRect cell_rect( xpos, row * m_lineHeight, col->GetWidth(), m_lineHeight );
 753             cell->Activate( cell_rect, model, col->GetModelColumn(), row );
 754         }
 755
 756         return;
 757     }
 758
 759     event.Skip();
 760 }
 761
 762 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
 763 {
 764     event.Skip();
 765 }
 766
 767 //-----------------------------------------------------------------------------
 768 // wxDataViewCtrl
 769 //-----------------------------------------------------------------------------
 770
 771 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
 772
 773 BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase)
 774     EVT_SIZE(wxDataViewCtrl::OnSize)
 775 END_EVENT_TABLE()
 776
 777 wxDataViewCtrl::~wxDataViewCtrl()
 778 {
 779     if (m_notifier)
 780         GetModel()->RemoveNotifier( m_notifier );
 781 }
 782
 783 void wxDataViewCtrl::Init()
 784 {
 785     m_notifier = NULL;
 786 }
 787
 788 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
 789            const wxPoint& pos, const wxSize& size,
 790            long style, const wxValidator& validator )
 791 {
 792     if (!wxControl::Create( parent, id, pos, size, style | wxScrolledWindowStyle|wxSUNKEN_BORDER, validator))
 793         return false;
 794
 795     Init();
 796
 797 #ifdef __WXMAC__
 798     MacSetClipChildren( true ) ;
 799 #endif
 800
 801     m_clientArea = new wxDataViewMainWindow( this, -1 );
 802     m_headerArea = new wxDataViewHeaderWindow( this, -1, wxDefaultPosition, wxSize(-1,25) );
 803
 804     SetTargetWindow( m_clientArea );
 805
 806     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
 807     sizer->Add( m_headerArea, 0, wxGROW );
 808     sizer->Add( m_clientArea, 1, wxGROW );
 809     SetSizer( sizer );
 810
 811     return true;
 812 }
 813
 814 #ifdef __WXMSW__
 815 WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
 816                                        WXWPARAM wParam,
 817                                        WXLPARAM lParam)
 818 {
 819     WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
 820
 821 #ifndef __WXWINCE__
 822     // we need to process arrows ourselves for scrolling
 823     if ( nMsg == WM_GETDLGCODE )
 824     {
 825         rc |= DLGC_WANTARROWS;
 826     }
 827 #endif
 828
 829     return rc;
 830 }
 831 #endif
 832
 833 void wxDataViewCtrl::OnSize( wxSizeEvent &event )
 834 {
 835     // We need to override OnSize so that our scrolled
 836     // window a) does call Layout() to use sizers for
 837     // positioning the controls but b) does not query
 838     // the sizer for their size and use that for setting
 839     // the scrollable area as set that ourselves by
 840     // calling SetScrollbar() further down.
 841
 842     Layout();
 843
 844     AdjustScrollbars();
 845 }
 846
 847 bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
 848 {
 849     if (!wxDataViewCtrlBase::AssociateModel( model ))
 850         return false;
 851
 852     m_notifier = new wxGenericDataViewListModelNotifier( m_clientArea );
 853
 854     model->AddNotifier( m_notifier );
 855
 856     m_clientArea->UpdateDisplay();
 857
 858     return true;
 859 }
 860
 861 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
 862 {
 863     if (!wxDataViewCtrlBase::AppendColumn(col))
 864         return false;
 865
 866     m_clientArea->UpdateDisplay();
 867
 868     return true;
 869 }
 870
 871 #endif
 872     // !wxUSE_GENERICDATAVIEWCTRL
 873
 874 #endif
 875     // wxUSE_DATAVIEWCTRL
 876