src/generic/datavgen.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/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 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_DATAVIEWCTRL
  18
  19 #include "wx/dataview.h"
  20
  21 #ifdef wxUSE_GENERICDATAVIEWCTRL
  22
  23 #ifndef WX_PRECOMP
  24     #ifdef __WXMSW__
  25         #include "wx/msw/wrapwin.h"
  26     #endif
  27     #include "wx/sizer.h"
  28     #include "wx/log.h"
  29     #include "wx/dcclient.h"
  30     #include "wx/timer.h"
  31     #include "wx/settings.h"
  32 #endif
  33
  34 #include "wx/stockitem.h"
  35 #include "wx/calctrl.h"
  36 #include "wx/popupwin.h"
  37 #include "wx/renderer.h"
  38 #include "wx/icon.h"
  39
  40 //-----------------------------------------------------------------------------
  41 // classes
  42 //-----------------------------------------------------------------------------
  43
  44 class wxDataViewCtrl;
  45
  46 //-----------------------------------------------------------------------------
  47 // wxDataViewHeaderWindow
  48 //-----------------------------------------------------------------------------
  49
  50 class wxDataViewHeaderWindow: public wxWindow
  51 {
  52 public:
  53     wxDataViewHeaderWindow( wxDataViewCtrl *parent,
  54                             wxWindowID id,
  55                             const wxPoint &pos = wxDefaultPosition,
  56                             const wxSize &size = wxDefaultSize,
  57                             const wxString &name = wxT("wxdataviewctrlheaderwindow") );
  58     virtual ~wxDataViewHeaderWindow();
  59
  60     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
  61     wxDataViewCtrl *GetOwner() { return m_owner; }
  62
  63     void OnPaint( wxPaintEvent &event );
  64     void OnMouse( wxMouseEvent &event );
  65     void OnSetFocus( wxFocusEvent &event );
  66
  67 private:
  68     wxDataViewCtrl      *m_owner;
  69     wxCursor            *m_resizeCursor;
  70
  71 private:
  72     DECLARE_DYNAMIC_CLASS(wxDataViewHeaderWindow)
  73     DECLARE_EVENT_TABLE()
  74 };
  75
  76 //-----------------------------------------------------------------------------
  77 // wxDataViewRenameTimer
  78 //-----------------------------------------------------------------------------
  79
  80 class wxDataViewRenameTimer: public wxTimer
  81 {
  82 private:
  83     wxDataViewMainWindow *m_owner;
  84
  85 public:
  86     wxDataViewRenameTimer( wxDataViewMainWindow *owner );
  87     void Notify();
  88 };
  89
  90 //-----------------------------------------------------------------------------
  91 // wxDataViewTextCtrlWrapper: wraps a wxTextCtrl for inline editing
  92 //-----------------------------------------------------------------------------
  93
  94 class wxDataViewTextCtrlWrapper : public wxEvtHandler
  95 {
  96 public:
  97     // NB: text must be a valid object but not Create()d yet
  98     wxDataViewTextCtrlWrapper( wxDataViewMainWindow *owner,
  99                                wxTextCtrl *text,
 100                                wxDataViewListModel *model,
 101                                unsigned int col, unsigned int row,
 102                                wxRect cellLabel );
 103
 104     wxTextCtrl *GetText() const { return m_text; }
 105
 106     void AcceptChangesAndFinish();
 107
 108 protected:
 109     void OnChar( wxKeyEvent &event );
 110     void OnKeyUp( wxKeyEvent &event );
 111     void OnKillFocus( wxFocusEvent &event );
 112
 113     bool AcceptChanges();
 114     void Finish();
 115
 116 private:
 117     wxDataViewMainWindow   *m_owner;
 118     wxTextCtrl             *m_text;
 119     wxString                m_startValue;
 120     wxDataViewListModel    *m_model;
 121     unsigned int                  m_col;
 122     unsigned int                  m_row;
 123     bool                    m_finished;
 124     bool                    m_aboutToFinish;
 125
 126     DECLARE_EVENT_TABLE()
 127 };
 128
 129 //-----------------------------------------------------------------------------
 130 // wxDataViewMainWindow
 131 //-----------------------------------------------------------------------------
 132
 133 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection, WXDLLIMPEXP_ADV);
 134
 135 class wxDataViewMainWindow: public wxWindow
 136 {
 137 public:
 138     wxDataViewMainWindow( wxDataViewCtrl *parent,
 139                             wxWindowID id,
 140                             const wxPoint &pos = wxDefaultPosition,
 141                             const wxSize &size = wxDefaultSize,
 142                             const wxString &name = wxT("wxdataviewctrlmainwindow") );
 143     virtual ~wxDataViewMainWindow();
 144
 145     // notifications from wxDataViewListModel
 146     bool RowAppended();
 147     bool RowPrepended();
 148     bool RowInserted( unsigned int before );
 149     bool RowDeleted( unsigned int row );
 150     bool RowChanged( unsigned int row );
 151     bool ValueChanged( unsigned int col, unsigned int row );
 152     bool RowsReordered( unsigned int *new_order );
 153     bool Cleared();
 154
 155     void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
 156     wxDataViewCtrl *GetOwner() { return m_owner; }
 157
 158     void OnPaint( wxPaintEvent &event );
 159     void OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event);
 160     void OnChar( wxKeyEvent &event );
 161     void OnMouse( wxMouseEvent &event );
 162     void OnSetFocus( wxFocusEvent &event );
 163     void OnKillFocus( wxFocusEvent &event );
 164
 165     void UpdateDisplay();
 166     void RecalculateDisplay();
 167     void OnInternalIdle();
 168
 169     void OnRenameTimer();
 170     void FinishEditing( wxTextCtrl *text );
 171
 172     void ScrollWindow( int dx, int dy, const wxRect *rect );
 173
 174     bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; }
 175     void ChangeCurrentRow( unsigned int row );
 176
 177     bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); };
 178     bool IsEmpty() { return GetRowCount() == 0; }
 179
 180     int GetCountPerPage();
 181     int GetEndOfLastCol();
 182     unsigned int GetFirstVisibleRow();
 183     unsigned int GetLastVisibleRow();
 184     unsigned int GetRowCount();
 185
 186     void SelectAllRows( bool on );
 187     void SelectRow( unsigned int row, bool on );
 188     void SelectRows( unsigned int from, unsigned int to, bool on );
 189     void ReverseRowSelection( unsigned int row );
 190     bool IsRowSelected( unsigned int row );
 191
 192     void RefreshRow( unsigned int row );
 193     void RefreshRows( unsigned int from, unsigned int to );
 194     void RefreshRowsAfter( unsigned int firstRow );
 195
 196 private:
 197     wxDataViewCtrl             *m_owner;
 198     int                         m_lineHeight;
 199     bool                        m_dirty;
 200
 201     wxDataViewColumn           *m_currentCol;
 202     unsigned int                      m_currentRow;
 203     wxDataViewSelection         m_selection;
 204
 205     wxDataViewRenameTimer      *m_renameTimer;
 206     wxDataViewTextCtrlWrapper  *m_textctrlWrapper;
 207     bool                        m_lastOnSame;
 208
 209     bool                        m_hasFocus;
 210
 211     int                         m_dragCount;
 212     wxPoint                     m_dragStart;
 213
 214     // for double click logic
 215     unsigned int m_lineLastClicked,
 216            m_lineBeforeLastClicked,
 217            m_lineSelectSingleOnUp;
 218
 219 private:
 220     DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
 221     DECLARE_EVENT_TABLE()
 222 };
 223
 224 // ---------------------------------------------------------
 225 // wxGenericDataViewListModelNotifier
 226 // ---------------------------------------------------------
 227
 228 class wxGenericDataViewListModelNotifier: public wxDataViewListModelNotifier
 229 {
 230 public:
 231     wxGenericDataViewListModelNotifier( wxDataViewMainWindow *mainWindow )
 232         { m_mainWindow = mainWindow; }
 233
 234     virtual bool RowAppended()
 235         { return m_mainWindow->RowAppended(); }
 236     virtual bool RowPrepended()
 237         { return m_mainWindow->RowPrepended(); }
 238     virtual bool RowInserted( unsigned int before )
 239         { return m_mainWindow->RowInserted( before ); }
 240     virtual bool RowDeleted( unsigned int row )
 241         { return m_mainWindow->RowDeleted( row ); }
 242     virtual bool RowChanged( unsigned int row )
 243         { return m_mainWindow->RowChanged( row ); }
 244     virtual bool ValueChanged( unsigned int col, unsigned int row )
 245         { return m_mainWindow->ValueChanged( col, row ); }
 246     virtual bool RowsReordered( unsigned int *new_order )
 247         { return m_mainWindow->RowsReordered( new_order ); }
 248     virtual bool Cleared()
 249         { return m_mainWindow->Cleared(); }
 250
 251     wxDataViewMainWindow    *m_mainWindow;
 252 };
 253
 254 // ---------------------------------------------------------
 255 // wxDataViewRenderer
 256 // ---------------------------------------------------------
 257
 258 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
 259
 260 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
 261     wxDataViewRendererBase( varianttype, mode )
 262 {
 263     m_dc = NULL;
 264 }
 265
 266 wxDataViewRenderer::~wxDataViewRenderer()
 267 {
 268     if (m_dc)
 269         delete m_dc;
 270 }
 271
 272 wxDC *wxDataViewRenderer::GetDC()
 273 {
 274     if (m_dc == NULL)
 275     {
 276         if (GetOwner() == NULL)
 277             return NULL;
 278         if (GetOwner()->GetOwner() == NULL)
 279             return NULL;
 280         m_dc = new wxClientDC( GetOwner()->GetOwner() );
 281     }
 282
 283     return m_dc;
 284 }
 285
 286 // ---------------------------------------------------------
 287 // wxDataViewCustomRenderer
 288 // ---------------------------------------------------------
 289
 290 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
 291
 292 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
 293                           wxDataViewCellMode mode ) :
 294     wxDataViewRenderer( varianttype, mode )
 295 {
 296 }
 297
 298 // ---------------------------------------------------------
 299 // wxDataViewTextRenderer
 300 // ---------------------------------------------------------
 301
 302 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewCustomRenderer)
 303
 304 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
 305     wxDataViewCustomRenderer( varianttype, mode )
 306 {
 307 }
 308
 309 bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
 310 {
 311     m_text = value.GetString();
 312
 313     return true;
 314 }
 315
 316 bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) )
 317 {
 318     return false;
 319 }
 320
 321 bool wxDataViewTextRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 322 {
 323     dc->DrawText( m_text, cell.x, cell.y );
 324
 325     return true;
 326 }
 327
 328 wxSize wxDataViewTextRenderer::GetSize()
 329 {
 330     return wxSize(80,20);
 331 }
 332
 333 // ---------------------------------------------------------
 334 // wxDataViewBitmapRenderer
 335 // ---------------------------------------------------------
 336
 337 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewCustomRenderer)
 338
 339 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, wxDataViewCellMode mode ) :
 340     wxDataViewCustomRenderer( varianttype, mode )
 341 {
 342 }
 343
 344 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
 345 {
 346     if (value.GetType() == wxT("wxBitmap"))
 347         m_bitmap << value;
 348     if (value.GetType() == wxT("wxIcon"))
 349         m_icon << value;
 350
 351     return true;
 352 }
 353
 354 bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) )
 355 {
 356     return false;
 357 }
 358
 359 bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 360 {
 361     if (m_bitmap.Ok())
 362         dc->DrawBitmap( m_bitmap, cell.x, cell.y );
 363     else if (m_icon.Ok())
 364         dc->DrawIcon( m_icon, cell.x, cell.y );
 365
 366     return true;
 367 }
 368
 369 wxSize wxDataViewBitmapRenderer::GetSize()
 370 {
 371     if (m_bitmap.Ok())
 372         return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
 373     else if (m_icon.Ok())
 374         return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
 375
 376     return wxSize(16,16);
 377 }
 378
 379 // ---------------------------------------------------------
 380 // wxDataViewToggleRenderer
 381 // ---------------------------------------------------------
 382
 383 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewCustomRenderer)
 384
 385 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
 386                         wxDataViewCellMode mode ) :
 387     wxDataViewCustomRenderer( varianttype, mode )
 388 {
 389     m_toggle = false;
 390 }
 391
 392 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
 393 {
 394     m_toggle = value.GetBool();
 395
 396     return true;
 397 }
 398
 399 bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) )
 400 {
 401     return false;
 402 }
 403
 404 bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 405 {
 406     // User wxRenderer here
 407
 408     wxRect rect;
 409     rect.x = cell.x + cell.width/2 - 10;
 410     rect.width = 20;
 411     rect.y = cell.y + cell.height/2 - 10;
 412     rect.height = 20;
 413
 414     int flags = 0;
 415     if (m_toggle)
 416         flags |= wxCONTROL_CHECKED;
 417     if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE)
 418         flags |= wxCONTROL_DISABLED;
 419
 420     wxRendererNative::Get().DrawCheckBox(
 421             GetOwner()->GetOwner(),
 422             *dc,
 423             rect,
 424             flags );
 425
 426     return true;
 427 }
 428
 429 bool wxDataViewToggleRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
 430 {
 431     bool value = !m_toggle;
 432     wxVariant variant = value;
 433     model->SetValue( variant, col, row );
 434     model->ValueChanged( col, row );
 435     return true;
 436 }
 437
 438 wxSize wxDataViewToggleRenderer::GetSize()
 439 {
 440     return wxSize(20,20);
 441 }
 442
 443 // ---------------------------------------------------------
 444 // wxDataViewProgressRenderer
 445 // ---------------------------------------------------------
 446
 447 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
 448
 449 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
 450     const wxString &varianttype, wxDataViewCellMode mode ) :
 451     wxDataViewCustomRenderer( varianttype, mode )
 452 {
 453     m_label = label;
 454     m_value = 0;
 455 }
 456
 457 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
 458 {
 459 }
 460
 461 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
 462 {
 463     m_value = (long) value;
 464
 465     if (m_value < 0) m_value = 0;
 466     if (m_value > 100) m_value = 100;
 467
 468     return true;
 469 }
 470
 471 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 472 {
 473     double pct = (double)m_value / 100.0;
 474     wxRect bar = cell;
 475     bar.width = (int)(cell.width * pct);
 476     dc->SetPen( *wxTRANSPARENT_PEN );
 477     dc->SetBrush( *wxBLUE_BRUSH );
 478     dc->DrawRectangle( bar );
 479
 480     dc->SetBrush( *wxTRANSPARENT_BRUSH );
 481     dc->SetPen( *wxBLACK_PEN );
 482     dc->DrawRectangle( cell );
 483
 484     return true;
 485 }
 486
 487 wxSize wxDataViewProgressRenderer::GetSize()
 488 {
 489     return wxSize(40,12);
 490 }
 491
 492 // ---------------------------------------------------------
 493 // wxDataViewDateRenderer
 494 // ---------------------------------------------------------
 495
 496 class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
 497 {
 498 public:
 499     wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
 500         wxDataViewListModel *model, unsigned int col, unsigned int row ) :
 501         wxPopupTransientWindow( parent, wxBORDER_SIMPLE )
 502     {
 503         m_model = model;
 504         m_col = col;
 505         m_row = row;
 506         m_cal = new wxCalendarCtrl( this, wxID_ANY, *value );
 507         wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
 508         sizer->Add( m_cal, 1, wxGROW );
 509         SetSizer( sizer );
 510         sizer->Fit( this );
 511     }
 512
 513     void OnCalendar( wxCalendarEvent &event );
 514
 515     wxCalendarCtrl      *m_cal;
 516     wxDataViewListModel *m_model;
 517     unsigned int               m_col;
 518     unsigned int               m_row;
 519
 520 protected:
 521     virtual void OnDismiss()
 522     {
 523     }
 524
 525 private:
 526     DECLARE_EVENT_TABLE()
 527 };
 528
 529 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
 530     EVT_CALENDAR( wxID_ANY, wxDataViewDateRendererPopupTransient::OnCalendar )
 531 END_EVENT_TABLE()
 532
 533 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
 534 {
 535     wxDateTime date = event.GetDate();
 536     wxVariant value = date;
 537     m_model->SetValue( value, m_col, m_row );
 538     m_model->ValueChanged( m_col, m_row );
 539     DismissAndNotify();
 540 }
 541
 542 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
 543
 544 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
 545                         wxDataViewCellMode mode ) :
 546     wxDataViewCustomRenderer( varianttype, mode )
 547 {
 548 }
 549
 550 bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
 551 {
 552     m_date = value.GetDateTime();
 553
 554     return true;
 555 }
 556
 557 bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
 558 {
 559     dc->SetFont( GetOwner()->GetOwner()->GetFont() );
 560     wxString tmp = m_date.FormatDate();
 561     dc->DrawText( tmp, cell.x, cell.y );
 562
 563     return true;
 564 }
 565
 566 wxSize wxDataViewDateRenderer::GetSize()
 567 {
 568     wxDataViewCtrl* view = GetOwner()->GetOwner();
 569     wxString tmp = m_date.FormatDate();
 570     wxCoord x,y,d;
 571     view->GetTextExtent( tmp, &x, &y, &d );
 572     return wxSize(x,y+d);
 573 }
 574
 575 bool wxDataViewDateRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewListModel *model, unsigned int col, unsigned int row )
 576 {
 577     wxVariant variant;
 578     model->GetValue( variant, col, row );
 579     wxDateTime value = variant.GetDateTime();
 580
 581     wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
 582         GetOwner()->GetOwner()->GetParent(), &value, model, col, row );
 583     wxPoint pos = wxGetMousePosition();
 584     popup->Move( pos );
 585     popup->Layout();
 586     popup->Popup( popup->m_cal );
 587
 588     return true;
 589 }
 590
 591 // ---------------------------------------------------------
 592 // wxDataViewColumn
 593 // ---------------------------------------------------------
 594
 595 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
 596
 597 wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell, unsigned int model_column,
 598         int width, int flags ) :
 599     wxDataViewColumnBase( title, cell, model_column, width, flags )
 600 {
 601     m_width = width;
 602     if (m_width < 0)
 603         m_width = 80;
 604 }
 605
 606 wxDataViewColumn::wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *cell, unsigned int model_column,
 607         int width, int flags ) :
 608     wxDataViewColumnBase( bitmap, cell, model_column, width, flags )
 609 {
 610     m_width = width;
 611     if (m_width < 0)
 612         m_width = 30;
 613 }
 614
 615 void wxDataViewColumn::SetAlignment( wxAlignment WXUNUSED(align) )
 616 {
 617     // TODO
 618 }
 619
 620 void wxDataViewColumn::SetSortable( bool WXUNUSED(sortable) )
 621 {
 622     // TODO
 623 }
 624
 625 bool wxDataViewColumn::GetSortable()
 626 {
 627     // TODO
 628     return false;
 629 }
 630
 631 void wxDataViewColumn::SetSortOrder( bool WXUNUSED(ascending) )
 632 {
 633     // TODO
 634 }
 635
 636 bool wxDataViewColumn::IsSortOrderAscending()
 637 {
 638     // TODO
 639     return true;
 640 }
 641
 642
 643 wxDataViewColumn::~wxDataViewColumn()
 644 {
 645 }
 646
 647 void wxDataViewColumn::SetTitle( const wxString &title )
 648 {
 649     wxDataViewColumnBase::SetTitle( title );
 650
 651 }
 652
 653 void wxDataViewColumn::SetBitmap( const wxBitmap &bitmap )
 654 {
 655     wxDataViewColumnBase::SetBitmap( bitmap );
 656
 657 }
 658
 659 int wxDataViewColumn::GetWidth()
 660 {
 661     return m_width;
 662 }
 663
 664 //-----------------------------------------------------------------------------
 665 // wxDataViewHeaderWindow
 666 //-----------------------------------------------------------------------------
 667
 668 IMPLEMENT_ABSTRACT_CLASS(wxDataViewHeaderWindow, wxWindow)
 669
 670 BEGIN_EVENT_TABLE(wxDataViewHeaderWindow,wxWindow)
 671     EVT_PAINT         (wxDataViewHeaderWindow::OnPaint)
 672     EVT_MOUSE_EVENTS  (wxDataViewHeaderWindow::OnMouse)
 673     EVT_SET_FOCUS     (wxDataViewHeaderWindow::OnSetFocus)
 674 END_EVENT_TABLE()
 675
 676 wxDataViewHeaderWindow::wxDataViewHeaderWindow( wxDataViewCtrl *parent, wxWindowID id,
 677      const wxPoint &pos, const wxSize &size, const wxString &name ) :
 678     wxWindow( parent, id, pos, size, 0, name )
 679 {
 680     SetOwner( parent );
 681
 682     m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
 683
 684     wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
 685     SetOwnForegroundColour( attr.colFg );
 686     SetOwnBackgroundColour( attr.colBg );
 687     if (!m_hasFont)
 688         SetOwnFont( attr.font );
 689 }
 690
 691 wxDataViewHeaderWindow::~wxDataViewHeaderWindow()
 692 {
 693     delete m_resizeCursor;
 694 }
 695
 696 void wxDataViewHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 697 {
 698     int w, h;
 699     GetClientSize( &w, &h );
 700
 701     wxPaintDC dc( this );
 702
 703     int xpix;
 704     m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
 705
 706     int x;
 707     m_owner->GetViewStart( &x, NULL );
 708
 709     // account for the horz scrollbar offset
 710     dc.SetDeviceOrigin( -x * xpix, 0 );
 711
 712     dc.SetFont( GetFont() );
 713
 714     unsigned int cols = GetOwner()->GetNumberOfColumns();
 715     unsigned int i;
 716     int xpos = 0;
 717     for (i = 0; i < cols; i++)
 718     {
 719         wxDataViewColumn *col = GetOwner()->GetColumn( i );
 720         int width = col->GetWidth();
 721
 722         int cw = width;
 723         int ch = h;
 724
 725         wxRendererNative::Get().DrawHeaderButton
 726                                 (
 727                                     this,
 728                                     dc,
 729                                     wxRect(xpos, 0, cw, ch-1),
 730                                     m_parent->IsEnabled() ? 0
 731                                                           : (int)wxCONTROL_DISABLED
 732                                 );
 733
 734         dc.DrawText( col->GetTitle(), xpos+3, 3 );
 735
 736         xpos += width;
 737     }
 738 }
 739
 740 void wxDataViewHeaderWindow::OnMouse( wxMouseEvent &WXUNUSED(event) )
 741 {
 742 }
 743
 744 void wxDataViewHeaderWindow::OnSetFocus( wxFocusEvent &event )
 745 {
 746     GetParent()->SetFocus();
 747     event.Skip();
 748 }
 749
 750 //-----------------------------------------------------------------------------
 751 // wxDataViewRenameTimer
 752 //-----------------------------------------------------------------------------
 753
 754 wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner )
 755 {
 756     m_owner = owner;
 757 }
 758
 759 void wxDataViewRenameTimer::Notify()
 760 {
 761     m_owner->OnRenameTimer();
 762 }
 763
 764 //-----------------------------------------------------------------------------
 765 // wxDataViewTextCtrlWrapper: wraps a wxTextCtrl for inline editing
 766 //-----------------------------------------------------------------------------
 767
 768 BEGIN_EVENT_TABLE(wxDataViewTextCtrlWrapper, wxEvtHandler)
 769     EVT_CHAR           (wxDataViewTextCtrlWrapper::OnChar)
 770     EVT_KEY_UP         (wxDataViewTextCtrlWrapper::OnKeyUp)
 771     EVT_KILL_FOCUS     (wxDataViewTextCtrlWrapper::OnKillFocus)
 772 END_EVENT_TABLE()
 773
 774 wxDataViewTextCtrlWrapper::wxDataViewTextCtrlWrapper(
 775                         wxDataViewMainWindow *owner,
 776                         wxTextCtrl *text,
 777                         wxDataViewListModel *model,
 778                         unsigned int col, unsigned int row,
 779                         wxRect rectLabel )
 780 {
 781     m_owner = owner;
 782     m_model = model;
 783     m_row = row;
 784     m_col = col;
 785     m_text = text;
 786
 787     m_finished = false;
 788     m_aboutToFinish = false;
 789
 790     wxVariant value;
 791     model->GetValue( value, col, row );
 792     m_startValue = value.GetString();
 793
 794     m_owner->GetOwner()->CalcScrolledPosition(
 795         rectLabel.x, rectLabel.y, &rectLabel.x, &rectLabel.y );
 796
 797     m_text->Create( owner, wxID_ANY, m_startValue,
 798                     wxPoint(rectLabel.x-2,rectLabel.y-2),
 799                     wxSize(rectLabel.width+7,rectLabel.height+4) );
 800     m_text->SetFocus();
 801
 802     m_text->PushEventHandler(this);
 803 }
 804
 805 void wxDataViewTextCtrlWrapper::AcceptChangesAndFinish()
 806 {
 807     m_aboutToFinish = true;
 808
 809     // Notify the owner about the changes
 810     AcceptChanges();
 811
 812     // Even if vetoed, close the control (consistent with MSW)
 813     Finish();
 814 }
 815
 816 void wxDataViewTextCtrlWrapper::OnChar( wxKeyEvent &event )
 817 {
 818     switch ( event.m_keyCode )
 819     {
 820         case WXK_RETURN:
 821             AcceptChangesAndFinish();
 822             break;
 823
 824         case WXK_ESCAPE:
 825             // m_owner->OnRenameCancelled( m_itemEdited );
 826             Finish();
 827             break;
 828
 829         default:
 830             event.Skip();
 831     }
 832 }
 833
 834 void wxDataViewTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
 835 {
 836     if (m_finished)
 837     {
 838         event.Skip();
 839         return;
 840     }
 841
 842     // auto-grow the textctrl
 843     wxSize parentSize = m_owner->GetSize();
 844     wxPoint myPos = m_text->GetPosition();
 845     wxSize mySize = m_text->GetSize();
 846     int sx, sy;
 847     m_text->GetTextExtent(m_text->GetValue() + _T("MM"), &sx, &sy);
 848     if (myPos.x + sx > parentSize.x)
 849         sx = parentSize.x - myPos.x;
 850     if (mySize.x > sx)
 851         sx = mySize.x;
 852     m_text->SetSize(sx, wxDefaultCoord);
 853
 854     event.Skip();
 855 }
 856
 857 void wxDataViewTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
 858 {
 859     if ( !m_finished && !m_aboutToFinish )
 860     {
 861         AcceptChanges();
 862         //if ( !AcceptChanges() )
 863         //    m_owner->OnRenameCancelled( m_itemEdited );
 864
 865         Finish();
 866     }
 867
 868     // We must let the native text control handle focus
 869     event.Skip();
 870 }
 871
 872 bool wxDataViewTextCtrlWrapper::AcceptChanges()
 873 {
 874     const wxString value = m_text->GetValue();
 875
 876     if ( value == m_startValue )
 877         // nothing changed, always accept
 878         return true;
 879
 880 //    if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
 881         // vetoed by the user
 882 //        return false;
 883
 884     // accepted, do rename the item
 885     wxVariant variant;
 886     variant = value;
 887     m_model->SetValue( variant, m_col, m_row );
 888     m_model->ValueChanged( m_col, m_row );
 889
 890     return true;
 891 }
 892
 893 void wxDataViewTextCtrlWrapper::Finish()
 894 {
 895     if ( !m_finished )
 896     {
 897         m_finished = true;
 898
 899         m_text->RemoveEventHandler(this);
 900         m_owner->FinishEditing(m_text);
 901
 902         // delete later
 903         wxPendingDelete.Append( this );
 904     }
 905 }
 906
 907 //-----------------------------------------------------------------------------
 908 // wxDataViewMainWindow
 909 //-----------------------------------------------------------------------------
 910
 911 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
 912 {
 913     if (row1 > row2) return 1;
 914     if (row1 == row2) return 0;
 915     return -1;
 916 }
 917
 918
 919 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
 920
 921 BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
 922     EVT_PAINT         (wxDataViewMainWindow::OnPaint)
 923     EVT_MOUSE_EVENTS  (wxDataViewMainWindow::OnMouse)
 924     EVT_SET_FOCUS     (wxDataViewMainWindow::OnSetFocus)
 925     EVT_KILL_FOCUS    (wxDataViewMainWindow::OnKillFocus)
 926     EVT_CHAR          (wxDataViewMainWindow::OnChar)
 927 END_EVENT_TABLE()
 928
 929 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
 930     const wxPoint &pos, const wxSize &size, const wxString &name ) :
 931     wxWindow( parent, id, pos, size, wxWANTS_CHARS, name ),
 932     m_selection( wxDataViewSelectionCmp )
 933
 934 {
 935     SetOwner( parent );
 936
 937     m_lastOnSame = false;
 938     m_renameTimer = new wxDataViewRenameTimer( this );
 939     m_textctrlWrapper = NULL;
 940
 941     // TODO: user better initial values/nothing selected
 942     m_currentCol = NULL;
 943     m_currentRow = 0;
 944
 945     // TODO: we need to calculate this smartly
 946     m_lineHeight = 20;
 947
 948     m_dragCount = 0;
 949     m_dragStart = wxPoint(0,0);
 950     m_lineLastClicked = (unsigned int) -1;
 951     m_lineBeforeLastClicked = (unsigned int) -1;
 952     m_lineSelectSingleOnUp = (unsigned int) -1;
 953
 954     m_hasFocus = false;
 955
 956     SetBackgroundColour( *wxWHITE );
 957
 958     UpdateDisplay();
 959 }
 960
 961 wxDataViewMainWindow::~wxDataViewMainWindow()
 962 {
 963     delete m_renameTimer;
 964 }
 965
 966 void wxDataViewMainWindow::OnRenameTimer()
 967 {
 968     // We have to call this here because changes may just have
 969     // been made and no screen update taken place.
 970     if ( m_dirty )
 971         wxSafeYield();
 972
 973
 974     int xpos = 0;
 975     unsigned int cols = GetOwner()->GetNumberOfColumns();
 976     unsigned int i;
 977     for (i = 0; i < cols; i++)
 978     {
 979         wxDataViewColumn *c = GetOwner()->GetColumn( i );
 980         if (c == m_currentCol)
 981             break;
 982         xpos += c->GetWidth();
 983     }
 984     wxRect labelRect( xpos, m_currentRow * m_lineHeight, m_currentCol->GetWidth(), m_lineHeight );
 985
 986     wxClassInfo *textControlClass = CLASSINFO(wxTextCtrl);
 987
 988     wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
 989     m_textctrlWrapper = new wxDataViewTextCtrlWrapper(this, text, GetOwner()->GetModel(),
 990         m_currentCol->GetModelColumn(), m_currentRow, labelRect );
 991 }
 992
 993 void wxDataViewMainWindow::FinishEditing( wxTextCtrl *text )
 994 {
 995     delete text;
 996     m_textctrlWrapper = NULL;
 997     SetFocus();
 998   //  SetFocusIgnoringChildren();
 999 }
1000
1001 bool wxDataViewMainWindow::RowAppended()
1002 {
1003     return false;
1004 }
1005
1006 bool wxDataViewMainWindow::RowPrepended()
1007 {
1008     return false;
1009 }
1010
1011 bool wxDataViewMainWindow::RowInserted( unsigned int WXUNUSED(before) )
1012 {
1013     return false;
1014 }
1015
1016 bool wxDataViewMainWindow::RowDeleted( unsigned int WXUNUSED(row) )
1017 {
1018     return false;
1019 }
1020
1021 bool wxDataViewMainWindow::RowChanged( unsigned int WXUNUSED(row) )
1022 {
1023     return false;
1024 }
1025
1026 bool wxDataViewMainWindow::ValueChanged( unsigned int WXUNUSED(col), unsigned int row )
1027 {
1028     wxRect rect( 0, row*m_lineHeight, 10000, m_lineHeight );
1029     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1030     Refresh( true, &rect );
1031
1032     return true;
1033 }
1034
1035 bool wxDataViewMainWindow::RowsReordered( unsigned int *WXUNUSED(new_order) )
1036 {
1037     Refresh();
1038
1039     return true;
1040 }
1041
1042 bool wxDataViewMainWindow::Cleared()
1043 {
1044     return false;
1045 }
1046
1047 void wxDataViewMainWindow::UpdateDisplay()
1048 {
1049     m_dirty = true;
1050 }
1051
1052 void wxDataViewMainWindow::OnInternalIdle()
1053 {
1054     wxWindow::OnInternalIdle();
1055
1056     if (m_dirty)
1057     {
1058         RecalculateDisplay();
1059         m_dirty = false;
1060     }
1061 }
1062
1063 void wxDataViewMainWindow::RecalculateDisplay()
1064 {
1065     wxDataViewListModel *model = GetOwner()->GetModel();
1066     if (!model)
1067     {
1068         Refresh();
1069         return;
1070     }
1071
1072     int width = 0;
1073     unsigned int cols = GetOwner()->GetNumberOfColumns();
1074     unsigned int i;
1075     for (i = 0; i < cols; i++)
1076     {
1077         wxDataViewColumn *col = GetOwner()->GetColumn( i );
1078         width += col->GetWidth();
1079     }
1080
1081     int height = model->GetNumberOfRows() * m_lineHeight;
1082
1083     SetVirtualSize( width, height );
1084     GetOwner()->SetScrollRate( 10, m_lineHeight );
1085
1086     Refresh();
1087 }
1088
1089 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
1090 {
1091     wxWindow::ScrollWindow( dx, dy, rect );
1092     GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
1093 }
1094
1095 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1096 {
1097     wxPaintDC dc( this );
1098
1099     GetOwner()->PrepareDC( dc );
1100
1101     dc.SetFont( GetFont() );
1102
1103     wxRect update = GetUpdateRegion().GetBox();
1104     m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
1105
1106     wxDataViewListModel *model = GetOwner()->GetModel();
1107
1108     unsigned int item_start = wxMax( 0, (update.y / m_lineHeight) );
1109     unsigned int item_count = wxMin( (int)(((update.y + update.height) / m_lineHeight) - item_start + 1),
1110                                (int)(model->GetNumberOfRows()-item_start) );
1111
1112
1113
1114     unsigned int item;
1115     for (item = item_start; item < item_start+item_count; item++)
1116     {
1117         if (m_selection.Index( item ) != wxNOT_FOUND)
1118         {
1119             int flags = wxCONTROL_SELECTED;
1120             if (item == m_currentRow)
1121                 flags |= wxCONTROL_CURRENT;
1122             if (m_hasFocus)
1123                 flags |= wxCONTROL_FOCUSED;
1124             wxRect rect( 0, item*m_lineHeight+1, GetEndOfLastCol(), m_lineHeight-2 );
1125             wxRendererNative::Get().DrawItemSelectionRect
1126                                 (
1127                                     this,
1128                                     dc,
1129                                     rect,
1130                                     flags
1131                                 );
1132         }
1133         else
1134         {
1135             if (item == m_currentRow)
1136             {
1137                 int flags = wxCONTROL_CURRENT;
1138                 if (m_hasFocus)
1139                     flags |= wxCONTROL_FOCUSED;  // should have no effect
1140                 wxRect rect( 0, item*m_lineHeight+1, GetEndOfLastCol(), m_lineHeight-2 );
1141                 wxRendererNative::Get().DrawItemSelectionRect
1142                                 (
1143                                     this,
1144                                     dc,
1145                                     rect,
1146                                     flags
1147                                 );
1148
1149             }
1150         }
1151     }
1152
1153     wxRect cell_rect;
1154     cell_rect.x = 0;
1155     cell_rect.height = m_lineHeight;
1156     unsigned int cols = GetOwner()->GetNumberOfColumns();
1157     unsigned int i;
1158     for (i = 0; i < cols; i++)
1159     {
1160         wxDataViewColumn *col = GetOwner()->GetColumn( i );
1161         wxDataViewRenderer *cell = col->GetRenderer();
1162         cell_rect.width = col->GetWidth();
1163
1164         for (item = item_start; item < item_start+item_count; item++)
1165         {
1166             cell_rect.y = item*m_lineHeight;
1167             wxVariant value;
1168             model->GetValue( value, col->GetModelColumn(), item );
1169             cell->SetValue( value );
1170             wxSize size = cell->GetSize();
1171             // cannot be bigger than allocated space
1172             size.x = wxMin( size.x, cell_rect.width );
1173             size.y = wxMin( size.y, cell_rect.height );
1174             // TODO: check for left/right/centre alignment here
1175             wxRect item_rect;
1176             // for now: centre
1177             item_rect.x = cell_rect.x + (cell_rect.width / 2) - (size.x / 2);
1178             item_rect.y = cell_rect.y + (cell_rect.height / 2) - (size.y / 2);
1179
1180             item_rect.width = size.x;
1181             item_rect.height= size.y;
1182             cell->Render( item_rect, &dc, 0 );
1183         }
1184
1185         cell_rect.x += cell_rect.width;
1186     }
1187 }
1188
1189 int wxDataViewMainWindow::GetCountPerPage()
1190 {
1191     wxSize size = GetClientSize();
1192     return size.y / m_lineHeight;
1193 }
1194
1195 int wxDataViewMainWindow::GetEndOfLastCol()
1196 {
1197     int width = 0;
1198     unsigned int i;
1199     for (i = 0; i < GetOwner()->GetNumberOfColumns(); i++)
1200     {
1201         wxDataViewColumn *c = GetOwner()->GetColumn( i );
1202         width += c->GetWidth();
1203     }
1204     return width;
1205 }
1206
1207 unsigned int wxDataViewMainWindow::GetFirstVisibleRow()
1208 {
1209     int x = 0;
1210     int y = 0;
1211     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
1212
1213     return y / m_lineHeight;
1214 }
1215
1216 unsigned int wxDataViewMainWindow::GetLastVisibleRow()
1217 {
1218     wxSize client_size = GetClientSize();
1219     m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, &client_size.x, &client_size.y );
1220
1221     return wxMin( GetRowCount()-1, ((unsigned)client_size.y/m_lineHeight)+1 );
1222 }
1223
1224 unsigned int wxDataViewMainWindow::GetRowCount()
1225 {
1226     return GetOwner()->GetModel()->GetNumberOfRows();
1227 }
1228
1229 void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
1230 {
1231     m_currentRow = row;
1232
1233     // send event
1234 }
1235
1236 void wxDataViewMainWindow::SelectAllRows( bool on )
1237 {
1238     if (IsEmpty())
1239         return;
1240
1241     if (on)
1242     {
1243         m_selection.Clear();
1244         for (unsigned int i = 0; i < GetRowCount(); i++)
1245             m_selection.Add( i );
1246         Refresh();
1247     }
1248     else
1249     {
1250         unsigned int first_visible = GetFirstVisibleRow();
1251         unsigned int last_visible = GetLastVisibleRow();
1252         unsigned int i;
1253         for (i = 0; i < m_selection.GetCount(); i++)
1254         {
1255             unsigned int row = m_selection[i];
1256             if ((row >= first_visible) && (row <= last_visible))
1257                 RefreshRow( row );
1258         }
1259         m_selection.Clear();
1260     }
1261 }
1262
1263 void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
1264 {
1265     if (m_selection.Index( row ) == wxNOT_FOUND)
1266     {
1267         if (on)
1268         {
1269             m_selection.Add( row );
1270             RefreshRow( row );
1271         }
1272     }
1273     else
1274     {
1275         if (!on)
1276         {
1277             m_selection.Remove( row );
1278             RefreshRow( row );
1279         }
1280     }
1281 }
1282
1283 void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
1284 {
1285     if (from > to)
1286     {
1287         unsigned int tmp = from;
1288         from = to;
1289         to = tmp;
1290     }
1291
1292     unsigned int i;
1293     for (i = from; i <= to; i++)
1294     {
1295         if (m_selection.Index( i ) == wxNOT_FOUND)
1296         {
1297             if (on)
1298                 m_selection.Add( i );
1299         }
1300         else
1301         {
1302             if (!on)
1303                 m_selection.Remove( i );
1304         }
1305     }
1306     RefreshRows( from, to );
1307 }
1308
1309 void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
1310 {
1311     if (m_selection.Index( row ) == wxNOT_FOUND)
1312         m_selection.Add( row );
1313     else
1314         m_selection.Remove( row );
1315     RefreshRow( row );
1316 }
1317
1318 bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
1319 {
1320     return (m_selection.Index( row ) != wxNOT_FOUND);
1321 }
1322
1323 void wxDataViewMainWindow::RefreshRow( unsigned int row )
1324 {
1325     wxRect rect( 0, row*m_lineHeight, GetEndOfLastCol(), m_lineHeight );
1326     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1327
1328     wxSize client_size = GetClientSize();
1329     wxRect client_rect( 0, 0, client_size.x, client_size.y );
1330     wxRect intersect_rect = client_rect.Intersect( rect );
1331     if (intersect_rect.width > 0)
1332         Refresh( true, &intersect_rect );
1333 }
1334
1335 void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
1336 {
1337     if (from > to)
1338     {
1339         unsigned int tmp = to;
1340         to = from;
1341         from = tmp;
1342     }
1343
1344     wxRect rect( 0, from*m_lineHeight, GetEndOfLastCol(), (to-from+1) * m_lineHeight );
1345     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1346
1347     wxSize client_size = GetClientSize();
1348     wxRect client_rect( 0, 0, client_size.x, client_size.y );
1349     wxRect intersect_rect = client_rect.Intersect( rect );
1350     if (intersect_rect.width > 0)
1351         Refresh( true, &intersect_rect );
1352 }
1353
1354 void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
1355 {
1356     unsigned int count = GetRowCount();
1357     if (firstRow > count)
1358         return;
1359
1360     wxRect rect( 0, firstRow*m_lineHeight, GetEndOfLastCol(), count * m_lineHeight );
1361     m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1362
1363     wxSize client_size = GetClientSize();
1364     wxRect client_rect( 0, 0, client_size.x, client_size.y );
1365     wxRect intersect_rect = client_rect.Intersect( rect );
1366     if (intersect_rect.width > 0)
1367         Refresh( true, &intersect_rect );
1368 }
1369
1370 void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event)
1371 {
1372     wxCHECK_RET( newCurrent < GetRowCount(),
1373                  _T("invalid item index in OnArrowChar()") );
1374
1375     // if there is no selection, we cannot move it anywhere
1376     if (!HasCurrentRow())
1377         return;
1378
1379     unsigned int oldCurrent = m_currentRow;
1380
1381     // in single selection we just ignore Shift as we can't select several
1382     // items anyhow
1383     if ( event.ShiftDown() && !IsSingleSel() )
1384     {
1385         RefreshRow( oldCurrent );
1386
1387         ChangeCurrentRow( newCurrent );
1388
1389         // select all the items between the old and the new one
1390         if ( oldCurrent > newCurrent )
1391         {
1392             newCurrent = oldCurrent;
1393             oldCurrent = m_currentRow;
1394         }
1395
1396         SelectRows( oldCurrent, newCurrent, true );
1397     }
1398     else // !shift
1399     {
1400         RefreshRow( oldCurrent );
1401
1402         // all previously selected items are unselected unless ctrl is held
1403         if ( !event.ControlDown() )
1404             SelectAllRows(false);
1405
1406         ChangeCurrentRow( newCurrent );
1407
1408         if ( !event.ControlDown() )
1409             SelectRow( m_currentRow, true );
1410         else
1411             RefreshRow( m_currentRow );
1412     }
1413
1414     // MoveToFocus();
1415 }
1416
1417 void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
1418 {
1419     if (event.GetKeyCode() == WXK_TAB)
1420     {
1421         wxNavigationKeyEvent nevent;
1422         nevent.SetWindowChange( event.ControlDown() );
1423         nevent.SetDirection( !event.ShiftDown() );
1424         nevent.SetEventObject( GetParent()->GetParent() );
1425         nevent.SetCurrentFocus( m_parent );
1426         if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent ))
1427             return;
1428     }
1429
1430     // no item -> nothing to do
1431     if (!HasCurrentRow())
1432     {
1433         event.Skip();
1434         return;
1435     }
1436
1437     // don't use m_linesPerPage directly as it might not be computed yet
1438     const int pageSize = GetCountPerPage();
1439     wxCHECK_RET( pageSize, _T("should have non zero page size") );
1440
1441     switch ( event.GetKeyCode() )
1442     {
1443         case WXK_UP:
1444             if ( m_currentRow > 0 )
1445                 OnArrowChar( m_currentRow - 1, event );
1446             break;
1447
1448         case WXK_DOWN:
1449             if ( m_currentRow < GetRowCount() - 1 )
1450                 OnArrowChar( m_currentRow + 1, event );
1451             break;
1452
1453         case WXK_END:
1454             if (!IsEmpty())
1455                 OnArrowChar( GetRowCount() - 1, event );
1456             break;
1457
1458         case WXK_HOME:
1459             if (!IsEmpty())
1460                 OnArrowChar( 0, event );
1461             break;
1462
1463         case WXK_PAGEUP:
1464             {
1465                 int steps = pageSize - 1;
1466                 int index = m_currentRow - steps;
1467                 if (index < 0)
1468                     index = 0;
1469
1470                 OnArrowChar( index, event );
1471             }
1472             break;
1473
1474         case WXK_PAGEDOWN:
1475             {
1476                 int steps = pageSize - 1;
1477                 unsigned int index = m_currentRow + steps;
1478                 unsigned int count = GetRowCount();
1479                 if ( index >= count )
1480                     index = count - 1;
1481
1482                 OnArrowChar( index, event );
1483             }
1484             break;
1485
1486         default:
1487             event.Skip();
1488     }
1489 }
1490
1491 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
1492 {
1493     if (event.GetEventType() == wxEVT_MOUSEWHEEL)
1494     {
1495         // let the base handle mouse wheel events.
1496         event.Skip();
1497         return;
1498     }
1499
1500     int x = event.GetX();
1501     int y = event.GetY();
1502     m_owner->CalcUnscrolledPosition( x, y, &x, &y );
1503
1504     wxDataViewColumn *col = NULL;
1505
1506     int xpos = 0;
1507     unsigned int cols = GetOwner()->GetNumberOfColumns();
1508     unsigned int i;
1509     for (i = 0; i < cols; i++)
1510     {
1511         wxDataViewColumn *c = GetOwner()->GetColumn( i );
1512         if (x < xpos + c->GetWidth())
1513         {
1514             col = c;
1515             break;
1516         }
1517         xpos += c->GetWidth();
1518     }
1519     if (!col)
1520         return;
1521     wxDataViewRenderer *cell = col->GetRenderer();
1522
1523     unsigned int current = y / m_lineHeight;
1524
1525     if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
1526     {
1527         // Unselect all if below the last row ?
1528         return;
1529     }
1530
1531     wxDataViewListModel *model = GetOwner()->GetModel();
1532
1533     if (event.Dragging())
1534     {
1535         if (m_dragCount == 0)
1536         {
1537             // we have to report the raw, physical coords as we want to be
1538             // able to call HitTest(event.m_pointDrag) from the user code to
1539             // get the item being dragged
1540             m_dragStart = event.GetPosition();
1541         }
1542
1543         m_dragCount++;
1544
1545         if (m_dragCount != 3)
1546             return;
1547
1548         if (event.LeftIsDown())
1549         {
1550             // Notify cell about drag
1551         }
1552         return;
1553     }
1554     else
1555     {
1556         m_dragCount = 0;
1557     }
1558
1559     bool forceClick = false;
1560
1561     if (event.ButtonDClick())
1562     {
1563         m_renameTimer->Stop();
1564         m_lastOnSame = false;
1565     }
1566
1567     if (event.LeftDClick())
1568     {
1569         if ( current == m_lineLastClicked )
1570         {
1571             if (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE)
1572             {
1573                 wxVariant value;
1574                 model->GetValue( value, col->GetModelColumn(), current );
1575                 cell->SetValue( value );
1576                 wxRect cell_rect( xpos, current * m_lineHeight, col->GetWidth(), m_lineHeight );
1577                 cell->Activate( cell_rect, model, col->GetModelColumn(), current );
1578             }
1579             return;
1580         }
1581         else
1582         {
1583             // The first click was on another item, so don't interpret this as
1584             // a double click, but as a simple click instead
1585             forceClick = true;
1586         }
1587     }
1588
1589     if (event.LeftUp())
1590     {
1591         if (m_lineSelectSingleOnUp != (unsigned int)-1)
1592         {
1593             // select single line
1594             SelectAllRows( false );
1595             SelectRow( m_lineSelectSingleOnUp, true );
1596         }
1597
1598         if (m_lastOnSame)
1599         {
1600             if ((col == m_currentCol) && (current == m_currentRow) &&
1601                 (cell->GetMode() == wxDATAVIEW_CELL_EDITABLE) )
1602             {
1603                 m_renameTimer->Start( 100, true );
1604             }
1605         }
1606
1607         m_lastOnSame = false;
1608         m_lineSelectSingleOnUp = (unsigned int)-1;
1609     }
1610     else
1611     {
1612         // This is necessary, because after a DnD operation in
1613         // from and to ourself, the up event is swallowed by the
1614         // DnD code. So on next non-up event (which means here and
1615         // now) m_lineSelectSingleOnUp should be reset.
1616         m_lineSelectSingleOnUp = (unsigned int)-1;
1617     }
1618
1619     if (event.RightDown())
1620     {
1621         m_lineBeforeLastClicked = m_lineLastClicked;
1622         m_lineLastClicked = current;
1623
1624         // If the item is already selected, do not update the selection.
1625         // Multi-selections should not be cleared if a selected item is clicked.
1626         if (!IsRowSelected(current))
1627         {
1628             SelectAllRows(false);
1629             ChangeCurrentRow(current);
1630             SelectRow(m_currentRow,true);
1631         }
1632
1633         // notify cell about right click
1634         // cell->...
1635
1636         // Allow generation of context menu event
1637         event.Skip();
1638     }
1639     else if (event.MiddleDown())
1640     {
1641         // notify cell about middle click
1642         // cell->...
1643     }
1644     if (event.LeftDown() || forceClick)
1645     {
1646 #ifdef __WXMSW__
1647         SetFocus();
1648 #endif
1649
1650         m_lineBeforeLastClicked = m_lineLastClicked;
1651         m_lineLastClicked = current;
1652
1653         unsigned int oldCurrentRow = m_currentRow;
1654         bool oldWasSelected = IsRowSelected(m_currentRow);
1655
1656         bool cmdModifierDown = event.CmdDown();
1657         if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
1658         {
1659             if ( IsSingleSel() || !IsRowSelected(current) )
1660             {
1661                 SelectAllRows( false );
1662
1663                 ChangeCurrentRow(current);
1664
1665                 SelectRow(m_currentRow,true);
1666             }
1667             else // multi sel & current is highlighted & no mod keys
1668             {
1669                 m_lineSelectSingleOnUp = current;
1670                 ChangeCurrentRow(current); // change focus
1671             }
1672         }
1673         else // multi sel & either ctrl or shift is down
1674         {
1675             if (cmdModifierDown)
1676             {
1677                 ChangeCurrentRow(current);
1678
1679                 ReverseRowSelection(m_currentRow);
1680             }
1681             else if (event.ShiftDown())
1682             {
1683                 ChangeCurrentRow(current);
1684
1685                 unsigned int lineFrom = oldCurrentRow,
1686                        lineTo = current;
1687
1688                 if ( lineTo < lineFrom )
1689                 {
1690                     lineTo = lineFrom;
1691                     lineFrom = m_currentRow;
1692                 }
1693
1694                 SelectRows(lineFrom, lineTo, true);
1695             }
1696             else // !ctrl, !shift
1697             {
1698                 // test in the enclosing if should make it impossible
1699                 wxFAIL_MSG( _T("how did we get here?") );
1700             }
1701         }
1702
1703         if (m_currentRow != oldCurrentRow)
1704             RefreshRow( oldCurrentRow );
1705
1706         wxDataViewColumn *oldCurrentCol = m_currentCol;
1707
1708         // Update selection here...
1709         m_currentCol = col;
1710
1711         m_lastOnSame = !forceClick && ((col == oldCurrentCol) && (current == oldCurrentRow)) && oldWasSelected;
1712     }
1713 }
1714
1715 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
1716 {
1717     m_hasFocus = true;
1718
1719     if (HasCurrentRow())
1720         Refresh();
1721
1722     event.Skip();
1723 }
1724
1725 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
1726 {
1727     m_hasFocus = false;
1728
1729     if (HasCurrentRow())
1730         Refresh();
1731
1732     event.Skip();
1733 }
1734
1735 //-----------------------------------------------------------------------------
1736 // wxDataViewCtrl
1737 //-----------------------------------------------------------------------------
1738
1739 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
1740
1741 BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase)
1742     EVT_SIZE(wxDataViewCtrl::OnSize)
1743 END_EVENT_TABLE()
1744
1745 wxDataViewCtrl::~wxDataViewCtrl()
1746 {
1747     if (m_notifier)
1748         GetModel()->RemoveNotifier( m_notifier );
1749 }
1750
1751 void wxDataViewCtrl::Init()
1752 {
1753     m_notifier = NULL;
1754 }
1755
1756 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
1757            const wxPoint& pos, const wxSize& size,
1758            long style, const wxValidator& validator )
1759 {
1760     if (!wxControl::Create( parent, id, pos, size, style | wxScrolledWindowStyle|wxSUNKEN_BORDER, validator))
1761         return false;
1762
1763     Init();
1764
1765 #ifdef __WXMAC__
1766     MacSetClipChildren( true ) ;
1767 #endif
1768
1769     m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
1770 #ifdef __WXMSW__
1771     m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,22) );
1772 #else
1773     m_headerArea = new wxDataViewHeaderWindow( this, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,25) );
1774 #endif
1775
1776     SetTargetWindow( m_clientArea );
1777
1778     wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
1779     sizer->Add( m_headerArea, 0, wxGROW );
1780     sizer->Add( m_clientArea, 1, wxGROW );
1781     SetSizer( sizer );
1782
1783     return true;
1784 }
1785
1786 #ifdef __WXMSW__
1787 WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
1788                                        WXWPARAM wParam,
1789                                        WXLPARAM lParam)
1790 {
1791     WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
1792
1793 #ifndef __WXWINCE__
1794     // we need to process arrows ourselves for scrolling
1795     if ( nMsg == WM_GETDLGCODE )
1796     {
1797         rc |= DLGC_WANTARROWS;
1798     }
1799 #endif
1800
1801     return rc;
1802 }
1803 #endif
1804
1805 void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
1806 {
1807     // We need to override OnSize so that our scrolled
1808     // window a) does call Layout() to use sizers for
1809     // positioning the controls but b) does not query
1810     // the sizer for their size and use that for setting
1811     // the scrollable area as set that ourselves by
1812     // calling SetScrollbar() further down.
1813
1814     Layout();
1815
1816     AdjustScrollbars();
1817 }
1818
1819 bool wxDataViewCtrl::AssociateModel( wxDataViewListModel *model )
1820 {
1821     if (!wxDataViewCtrlBase::AssociateModel( model ))
1822         return false;
1823
1824     m_notifier = new wxGenericDataViewListModelNotifier( m_clientArea );
1825
1826     model->AddNotifier( m_notifier );
1827
1828     m_clientArea->UpdateDisplay();
1829
1830     return true;
1831 }
1832
1833 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
1834 {
1835     if (!wxDataViewCtrlBase::AppendColumn(col))
1836         return false;
1837
1838     m_clientArea->UpdateDisplay();
1839
1840     return true;
1841 }
1842
1843 void wxDataViewCtrl::SetSelection( int WXUNUSED(row) )
1844 {
1845     // FIXME - TODO
1846 }
1847
1848 void wxDataViewCtrl::SetSelectionRange( unsigned int WXUNUSED(from), unsigned int WXUNUSED(to) )
1849 {
1850     // FIXME - TODO
1851 }
1852
1853 void wxDataViewCtrl::SetSelections( const wxArrayInt& WXUNUSED(aSelections) )
1854 {
1855     // FIXME - TODO
1856 }
1857
1858 void wxDataViewCtrl::Unselect( unsigned int WXUNUSED(row) )
1859 {
1860     // FIXME - TODO
1861 }
1862
1863 bool wxDataViewCtrl::IsSelected( unsigned int WXUNUSED(row) ) const
1864 {
1865     // FIXME - TODO
1866
1867     return false;
1868 }
1869
1870 int wxDataViewCtrl::GetSelection() const
1871 {
1872     // FIXME - TODO
1873
1874     return -1;
1875 }
1876
1877 int wxDataViewCtrl::GetSelections(wxArrayInt& WXUNUSED(aSelections) ) const
1878 {
1879     // FIXME - TODO
1880
1881     return 0;
1882 }
1883
1884 #endif
1885     // !wxUSE_GENERICDATAVIEWCTRL
1886
1887 #endif
1888     // wxUSE_DATAVIEWCTRL