src/generic/grid.cpp

   1 ///////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/grid.cpp
   3 // Purpose:     wxGrid and related classes
   4 // Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)
   5 // Modified by:
   6 // Created:     1/08/1999
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Michael Bedward (mbedward@ozemail.com.au)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "grid.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx/wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #include "wx/defs.h"
  28
  29 #ifdef __BORLANDC__
  30     #pragma hdrstop
  31 #endif
  32
  33 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
  34 #include "gridg.cpp"
  35 #else
  36
  37 #ifndef WX_PRECOMP
  38     #include "wx/utils.h"
  39     #include "wx/dcclient.h"
  40     #include "wx/settings.h"
  41     #include "wx/log.h"
  42     #include "wx/textctrl.h"
  43     #include "wx/checkbox.h"
  44     #include "wx/valtext.h"
  45 #endif
  46
  47 #include "wx/textfile.h"
  48 #include "wx/spinctrl.h"
  49
  50 #include "wx/grid.h"
  51
  52 // ----------------------------------------------------------------------------
  53 // array classes
  54 // ----------------------------------------------------------------------------
  55
  56 WX_DEFINE_ARRAY(wxGridCellAttr *, wxArrayAttrs);
  57
  58 struct wxGridCellWithAttr
  59 {
  60     wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
  61         : coords(row, col), attr(attr_)
  62     {
  63     }
  64
  65     ~wxGridCellWithAttr()
  66     {
  67         attr->DecRef();
  68     }
  69
  70     wxGridCellCoords coords;
  71     wxGridCellAttr  *attr;
  72 };
  73
  74 WX_DECLARE_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
  75
  76 #include "wx/arrimpl.cpp"
  77
  78 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
  79 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
  80
  81 // ----------------------------------------------------------------------------
  82 // private classes
  83 // ----------------------------------------------------------------------------
  84
  85 class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
  86 {
  87 public:
  88     wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
  89     wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
  90                           const wxPoint &pos, const wxSize &size );
  91
  92 private:
  93     wxGrid   *m_owner;
  94
  95     void OnPaint( wxPaintEvent& event );
  96     void OnMouseEvent( wxMouseEvent& event );
  97     void OnKeyDown( wxKeyEvent& event );
  98
  99     DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
 100     DECLARE_EVENT_TABLE()
 101 };
 102
 103
 104 class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
 105 {
 106 public:
 107     wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
 108     wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
 109                           const wxPoint &pos, const wxSize &size );
 110
 111 private:
 112     wxGrid   *m_owner;
 113
 114     void OnPaint( wxPaintEvent &event );
 115     void OnMouseEvent( wxMouseEvent& event );
 116     void OnKeyDown( wxKeyEvent& event );
 117
 118     DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
 119     DECLARE_EVENT_TABLE()
 120 };
 121
 122
 123 class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
 124 {
 125 public:
 126     wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
 127     wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
 128                              const wxPoint &pos, const wxSize &size );
 129
 130 private:
 131     wxGrid *m_owner;
 132
 133     void OnMouseEvent( wxMouseEvent& event );
 134     void OnKeyDown( wxKeyEvent& event );
 135     void OnPaint( wxPaintEvent& event );
 136
 137     DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
 138     DECLARE_EVENT_TABLE()
 139 };
 140
 141 class WXDLLEXPORT wxGridWindow : public wxPanel
 142 {
 143 public:
 144     wxGridWindow()
 145     {
 146         m_owner = (wxGrid *)NULL;
 147         m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
 148         m_colLabelWin = (wxGridColLabelWindow *)NULL;
 149     }
 150
 151     wxGridWindow( wxGrid *parent,
 152                   wxGridRowLabelWindow *rowLblWin,
 153                   wxGridColLabelWindow *colLblWin,
 154                   wxWindowID id, const wxPoint &pos, const wxSize &size );
 155     ~wxGridWindow();
 156
 157     void ScrollWindow( int dx, int dy, const wxRect *rect );
 158
 159 private:
 160     wxGrid                   *m_owner;
 161     wxGridRowLabelWindow     *m_rowLabelWin;
 162     wxGridColLabelWindow     *m_colLabelWin;
 163
 164     void OnPaint( wxPaintEvent &event );
 165     void OnMouseEvent( wxMouseEvent& event );
 166     void OnKeyDown( wxKeyEvent& );
 167     void OnEraseBackground( wxEraseEvent& );
 168
 169
 170     DECLARE_DYNAMIC_CLASS(wxGridWindow)
 171     DECLARE_EVENT_TABLE()
 172 };
 173
 174
 175
 176 class wxGridCellEditorEvtHandler : public wxEvtHandler
 177 {
 178 public:
 179     wxGridCellEditorEvtHandler()
 180         : m_grid(0), m_editor(0)
 181         { }
 182     wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
 183         : m_grid(grid), m_editor(editor)
 184         { }
 185
 186     void OnKeyDown(wxKeyEvent& event);
 187     void OnChar(wxKeyEvent& event);
 188
 189 private:
 190     wxGrid*             m_grid;
 191     wxGridCellEditor*   m_editor;
 192     DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
 193     DECLARE_EVENT_TABLE()
 194 };
 195
 196
 197 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
 198 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
 199     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
 200     EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
 201 END_EVENT_TABLE()
 202
 203
 204
 205 // ----------------------------------------------------------------------------
 206 // the internal data representation used by wxGridCellAttrProvider
 207 // ----------------------------------------------------------------------------
 208
 209 // this class stores attributes set for cells
 210 class WXDLLEXPORT wxGridCellAttrData
 211 {
 212 public:
 213     void SetAttr(wxGridCellAttr *attr, int row, int col);
 214     wxGridCellAttr *GetAttr(int row, int col) const;
 215     void UpdateAttrRows( size_t pos, int numRows );
 216     void UpdateAttrCols( size_t pos, int numCols );
 217
 218 private:
 219     // searches for the attr for given cell, returns wxNOT_FOUND if not found
 220     int FindIndex(int row, int col) const;
 221
 222     wxGridCellWithAttrArray m_attrs;
 223 };
 224
 225 // this class stores attributes set for rows or columns
 226 class WXDLLEXPORT wxGridRowOrColAttrData
 227 {
 228 public:
 229     // empty ctor to suppress warnings
 230     wxGridRowOrColAttrData() { }
 231     ~wxGridRowOrColAttrData();
 232
 233     void SetAttr(wxGridCellAttr *attr, int rowOrCol);
 234     wxGridCellAttr *GetAttr(int rowOrCol) const;
 235     void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
 236
 237 private:
 238     wxArrayInt m_rowsOrCols;
 239     wxArrayAttrs m_attrs;
 240 };
 241
 242 // NB: this is just a wrapper around 3 objects: one which stores cell
 243 //     attributes, and 2 others for row/col ones
 244 class WXDLLEXPORT wxGridCellAttrProviderData
 245 {
 246 public:
 247     wxGridCellAttrData m_cellAttrs;
 248     wxGridRowOrColAttrData m_rowAttrs,
 249                            m_colAttrs;
 250 };
 251
 252
 253 // ----------------------------------------------------------------------------
 254 // data structures used for the data type registry
 255 // ----------------------------------------------------------------------------
 256
 257 struct wxGridDataTypeInfo {
 258     wxGridDataTypeInfo(const wxString& typeName,
 259                        wxGridCellRenderer* renderer,
 260                        wxGridCellEditor* editor)
 261         : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
 262         { }
 263
 264     ~wxGridDataTypeInfo() { delete m_renderer; delete m_editor; }
 265
 266     wxString            m_typeName;
 267     wxGridCellRenderer* m_renderer;
 268     wxGridCellEditor*   m_editor;
 269 };
 270
 271
 272 WX_DEFINE_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
 273
 274
 275 class WXDLLEXPORT wxGridTypeRegistry {
 276 public:
 277     ~wxGridTypeRegistry();
 278     void RegisterDataType(const wxString& typeName,
 279                      wxGridCellRenderer* renderer,
 280                      wxGridCellEditor* editor);
 281     int FindDataType(const wxString& typeName);
 282     wxGridCellRenderer* GetRenderer(int index);
 283     wxGridCellEditor*   GetEditor(int index);
 284
 285 private:
 286     wxGridDataTypeInfoArray m_typeinfo;
 287 };
 288
 289
 290
 291
 292 // ----------------------------------------------------------------------------
 293 // conditional compilation
 294 // ----------------------------------------------------------------------------
 295
 296 #ifndef WXGRID_DRAW_LINES
 297 #define WXGRID_DRAW_LINES 1
 298 #endif
 299
 300 // ----------------------------------------------------------------------------
 301 // globals
 302 // ----------------------------------------------------------------------------
 303
 304 //#define DEBUG_ATTR_CACHE
 305 #ifdef DEBUG_ATTR_CACHE
 306     static size_t gs_nAttrCacheHits = 0;
 307     static size_t gs_nAttrCacheMisses = 0;
 308 #endif // DEBUG_ATTR_CACHE
 309
 310 // ----------------------------------------------------------------------------
 311 // constants
 312 // ----------------------------------------------------------------------------
 313
 314 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 315 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 316
 317 // scroll line size
 318 // TODO: fixed so far - make configurable later (and also different for x/y)
 319 static const size_t GRID_SCROLL_LINE = 10;
 320
 321 // the size of hash tables used a bit everywhere (the max number of elements
 322 // in these hash tables is the number of rows/columns)
 323 static const int GRID_HASH_SIZE = 100;
 324
 325 // ============================================================================
 326 // implementation
 327 // ============================================================================
 328
 329 // ----------------------------------------------------------------------------
 330 // wxGridCellEditor
 331 // ----------------------------------------------------------------------------
 332
 333 wxGridCellEditor::wxGridCellEditor()
 334 {
 335     m_control = NULL;
 336 }
 337
 338
 339 wxGridCellEditor::~wxGridCellEditor()
 340 {
 341     Destroy();
 342 }
 343
 344 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
 345                               wxWindowID WXUNUSED(id),
 346                               wxEvtHandler* evtHandler)
 347 {
 348     if ( evtHandler )
 349         m_control->PushEventHandler(evtHandler);
 350 }
 351
 352 void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
 353                                        wxGridCellAttr *attr)
 354 {
 355     // erase the background because we might not fill the cell
 356     wxClientDC dc(m_control->GetParent());
 357     dc.SetPen(*wxTRANSPARENT_PEN);
 358     dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
 359     dc.DrawRectangle(rectCell);
 360
 361     // redraw the control we just painted over
 362     m_control->Refresh();
 363 }
 364
 365 void wxGridCellEditor::Destroy()
 366 {
 367     if (m_control)
 368     {
 369         m_control->Destroy();
 370         m_control = NULL;
 371     }
 372 }
 373
 374 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
 375 {
 376     wxASSERT_MSG(m_control,
 377                  wxT("The wxGridCellEditor must be Created first!"));
 378     m_control->Show(show);
 379
 380     if ( show )
 381     {
 382         // set the colours/fonts if we have any
 383         if ( attr )
 384         {
 385             m_colFgOld = m_control->GetForegroundColour();
 386             m_control->SetForegroundColour(attr->GetTextColour());
 387
 388             m_colBgOld = m_control->GetBackgroundColour();
 389             m_control->SetBackgroundColour(attr->GetBackgroundColour());
 390
 391             m_fontOld = m_control->GetFont();
 392             m_control->SetFont(attr->GetFont());
 393
 394             // can't do anything more in the base class version, the other
 395             // attributes may only be used by the derived classes
 396         }
 397     }
 398     else
 399     {
 400         // restore the standard colours fonts
 401         if ( m_colFgOld.Ok() )
 402         {
 403             m_control->SetForegroundColour(m_colFgOld);
 404             m_colFgOld = wxNullColour;
 405         }
 406
 407         if ( m_colBgOld.Ok() )
 408         {
 409             m_control->SetBackgroundColour(m_colBgOld);
 410             m_colBgOld = wxNullColour;
 411         }
 412
 413         if ( m_fontOld.Ok() )
 414         {
 415             m_control->SetFont(m_fontOld);
 416             m_fontOld = wxNullFont;
 417         }
 418     }
 419 }
 420
 421 void wxGridCellEditor::SetSize(const wxRect& rect)
 422 {
 423     wxASSERT_MSG(m_control,
 424                  wxT("The wxGridCellEditor must be Created first!"));
 425     m_control->SetSize(rect);
 426 }
 427
 428 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
 429 {
 430     event.Skip();
 431 }
 432
 433
 434 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
 435 {
 436     event.Skip();
 437 }
 438
 439 void wxGridCellEditor::StartingClick()
 440 {
 441 }
 442
 443 // ----------------------------------------------------------------------------
 444 // wxGridCellTextEditor
 445 // ----------------------------------------------------------------------------
 446
 447 wxGridCellTextEditor::wxGridCellTextEditor()
 448 {
 449 }
 450
 451 void wxGridCellTextEditor::Create(wxWindow* parent,
 452                                   wxWindowID id,
 453                                   wxEvtHandler* evtHandler)
 454 {
 455     m_control = new wxTextCtrl(parent, id, wxEmptyString,
 456                                wxDefaultPosition, wxDefaultSize
 457 #if defined(__WXMSW__)
 458                                , wxTE_MULTILINE | wxTE_NO_VSCROLL // necessary ???
 459 #endif
 460                               );
 461
 462     wxGridCellEditor::Create(parent, id, evtHandler);
 463 }
 464
 465 void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
 466                                            wxGridCellAttr * WXUNUSED(attr))
 467 {
 468     // as we fill the entire client area, don't do anything here to minimize
 469     // flicker
 470 }
 471
 472 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
 473 {
 474     wxRect rect(rectOrig);
 475
 476     // Make the edit control large enough to allow for internal
 477     // margins
 478     //
 479     // TODO: remove this if the text ctrl sizing is improved esp. for
 480     // unix
 481     //
 482 #if defined(__WXGTK__)
 483     rect.Inflate(rect.x ? 1 : 0, rect.y ? 1 : 0);
 484 #else // !GTK
 485     int extra = row && col ? 2 : 1;
 486 #if defined(__WXMOTIF__)
 487     extra *= 2;
 488 #endif
 489     rect.SetLeft( wxMax(0, rect.x - extra) );
 490     rect.SetTop( wxMax(0, rect.y - extra) );
 491     rect.SetRight( rect.GetRight() + 2*extra );
 492     rect.SetBottom( rect.GetBottom() + 2*extra );
 493 #endif // GTK/!GTK
 494
 495     wxGridCellEditor::SetSize(rect);
 496 }
 497
 498 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
 499 {
 500     wxASSERT_MSG(m_control,
 501                  wxT("The wxGridCellEditor must be Created first!"));
 502
 503     m_startValue = grid->GetTable()->GetValue(row, col);
 504
 505     DoBeginEdit(m_startValue);
 506 }
 507
 508 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
 509 {
 510     Text()->SetValue(startValue);
 511     Text()->SetInsertionPointEnd();
 512     Text()->SetFocus();
 513 }
 514
 515 bool wxGridCellTextEditor::EndEdit(int row, int col, bool saveValue,
 516                                    wxGrid* grid)
 517 {
 518     wxASSERT_MSG(m_control,
 519                  wxT("The wxGridCellEditor must be Created first!"));
 520
 521     bool changed = FALSE;
 522     wxString value = Text()->GetValue();
 523     if (value != m_startValue)
 524         changed = TRUE;
 525
 526     if (changed)
 527         grid->GetTable()->SetValue(row, col, value);
 528
 529     m_startValue = wxEmptyString;
 530     Text()->SetValue(m_startValue);
 531
 532     return changed;
 533 }
 534
 535
 536 void wxGridCellTextEditor::Reset()
 537 {
 538     wxASSERT_MSG(m_control,
 539                  wxT("The wxGridCellEditor must be Created first!"));
 540
 541     DoReset(m_startValue);
 542 }
 543
 544 void wxGridCellTextEditor::DoReset(const wxString& startValue)
 545 {
 546     Text()->SetValue(startValue);
 547     Text()->SetInsertionPointEnd();
 548 }
 549
 550 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
 551 {
 552     if ( !event.AltDown() && !event.MetaDown() && !event.ControlDown() )
 553     {
 554         // insert the key in the control
 555         long keycode = event.KeyCode();
 556         if ( isprint(keycode) )
 557         {
 558             // FIXME this is not going to work for non letters...
 559             if ( !event.ShiftDown() )
 560             {
 561                 keycode = tolower(keycode);
 562             }
 563
 564             Text()->AppendText((wxChar)keycode);
 565
 566             return;
 567         }
 568
 569     }
 570
 571     event.Skip();
 572 }
 573
 574 void wxGridCellTextEditor::HandleReturn(wxKeyEvent& event)
 575 {
 576 #if defined(__WXMOTIF__) || defined(__WXGTK__)
 577     // wxMotif needs a little extra help...
 578     int pos = Text()->GetInsertionPoint();
 579     wxString s( Text()->GetValue() );
 580     s = s.Left(pos) + "\n" + s.Mid(pos);
 581     Text()->SetValue(s);
 582     Text()->SetInsertionPoint( pos );
 583 #else
 584     // the other ports can handle a Return key press
 585     //
 586     event.Skip();
 587 #endif
 588 }
 589
 590 // ----------------------------------------------------------------------------
 591 // wxGridCellNumberEditor
 592 // ----------------------------------------------------------------------------
 593
 594 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
 595 {
 596     m_min = min;
 597     m_max = max;
 598 }
 599
 600 void wxGridCellNumberEditor::Create(wxWindow* parent,
 601                                     wxWindowID id,
 602                                     wxEvtHandler* evtHandler)
 603 {
 604     if ( HasRange() )
 605     {
 606         // create a spin ctrl
 607         m_control = new wxSpinCtrl(parent, -1, wxEmptyString,
 608                                    wxDefaultPosition, wxDefaultSize,
 609                                    wxSP_ARROW_KEYS,
 610                                    m_min, m_max);
 611
 612         wxGridCellEditor::Create(parent, id, evtHandler);
 613     }
 614     else
 615     {
 616         // just a text control
 617         wxGridCellTextEditor::Create(parent, id, evtHandler);
 618
 619 #if wxUSE_VALIDATORS
 620         Text()->SetValidator(new wxTextValidator(wxFILTER_NUMERIC));
 621 #endif // wxUSE_VALIDATORS
 622     }
 623 }
 624
 625 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
 626 {
 627     // first get the value
 628     wxGridTableBase *table = grid->GetTable();
 629     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 630     {
 631         m_valueOld = table->GetValueAsLong(row, col);
 632     }
 633     else
 634     {
 635         wxFAIL_MSG( _T("this cell doesn't have numeric value") );
 636
 637         return;
 638     }
 639
 640     if ( HasRange() )
 641     {
 642         Spin()->SetValue(m_valueOld);
 643     }
 644     else
 645     {
 646         DoBeginEdit(GetString());
 647     }
 648 }
 649
 650 bool wxGridCellNumberEditor::EndEdit(int row, int col, bool saveValue,
 651                                      wxGrid* grid)
 652 {
 653     bool changed;
 654     long value;
 655
 656     if ( HasRange() )
 657     {
 658         value = Spin()->GetValue();
 659         changed = value != m_valueOld;
 660     }
 661     else
 662     {
 663         changed = Text()->GetValue().ToLong(&value) && (value != m_valueOld);
 664     }
 665
 666     if ( changed )
 667     {
 668         grid->GetTable()->SetValueAsLong(row, col, value);
 669     }
 670
 671     return changed;
 672 }
 673
 674 void wxGridCellNumberEditor::Reset()
 675 {
 676     if ( HasRange() )
 677     {
 678         Spin()->SetValue(m_valueOld);
 679     }
 680     else
 681     {
 682         DoReset(GetString());
 683     }
 684 }
 685
 686 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
 687 {
 688     if ( !HasRange() )
 689     {
 690         long keycode = event.KeyCode();
 691         if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
 692         {
 693             wxGridCellTextEditor::StartingKey(event);
 694
 695             // skip Skip() below
 696             return;
 697         }
 698     }
 699
 700     event.Skip();
 701 }
 702 // ----------------------------------------------------------------------------
 703 // wxGridCellFloatEditor
 704 // ----------------------------------------------------------------------------
 705
 706 void wxGridCellFloatEditor::Create(wxWindow* parent,
 707                                    wxWindowID id,
 708                                    wxEvtHandler* evtHandler)
 709 {
 710     wxGridCellTextEditor::Create(parent, id, evtHandler);
 711
 712 #if wxUSE_VALIDATORS
 713     Text()->SetValidator(new wxTextValidator(wxFILTER_NUMERIC));
 714 #endif // wxUSE_VALIDATORS
 715 }
 716
 717 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
 718 {
 719     // first get the value
 720     wxGridTableBase *table = grid->GetTable();
 721     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
 722     {
 723         m_valueOld = table->GetValueAsDouble(row, col);
 724     }
 725     else
 726     {
 727         wxFAIL_MSG( _T("this cell doesn't have float value") );
 728
 729         return;
 730     }
 731
 732     DoBeginEdit(GetString());
 733 }
 734
 735 bool wxGridCellFloatEditor::EndEdit(int row, int col, bool saveValue,
 736                                      wxGrid* grid)
 737 {
 738     double value;
 739     if ( Text()->GetValue().ToDouble(&value) && (value != m_valueOld) )
 740     {
 741         grid->GetTable()->SetValueAsDouble(row, col, value);
 742
 743         return TRUE;
 744     }
 745     else
 746     {
 747         return FALSE;
 748     }
 749 }
 750
 751 void wxGridCellFloatEditor::Reset()
 752 {
 753     DoReset(GetString());
 754 }
 755
 756 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
 757 {
 758     long keycode = event.KeyCode();
 759     if ( isdigit(keycode) ||
 760          keycode == '+' || keycode == '-' || keycode == '.' )
 761     {
 762         wxGridCellTextEditor::StartingKey(event);
 763
 764         // skip Skip() below
 765         return;
 766     }
 767
 768     event.Skip();
 769 }
 770
 771 // ----------------------------------------------------------------------------
 772 // wxGridCellBoolEditor
 773 // ----------------------------------------------------------------------------
 774
 775 void wxGridCellBoolEditor::Create(wxWindow* parent,
 776                                   wxWindowID id,
 777                                   wxEvtHandler* evtHandler)
 778 {
 779     m_control = new wxCheckBox(parent, id, wxEmptyString,
 780                                wxDefaultPosition, wxDefaultSize,
 781                                wxNO_BORDER);
 782
 783     wxGridCellEditor::Create(parent, id, evtHandler);
 784 }
 785
 786 void wxGridCellBoolEditor::SetSize(const wxRect& r)
 787 {
 788     // position it in the centre of the rectangle (TODO: support alignment?)
 789     wxCoord w, h;
 790     m_control->GetSize(&w, &h);
 791
 792     // the checkbox without label still has some space to the right in wxGTK,
 793     // so shift it to the right
 794 #ifdef __WXGTK__
 795     w -= 8;
 796 #endif // GTK
 797
 798     m_control->Move(r.x + r.width/2 - w/2, r.y + r.height/2 - h/2);
 799 }
 800
 801 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
 802 {
 803     m_control->Show(show);
 804
 805     if ( show )
 806     {
 807         wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
 808         CBox()->SetBackgroundColour(colBg);
 809     }
 810 }
 811
 812 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
 813 {
 814     wxASSERT_MSG(m_control,
 815                  wxT("The wxGridCellEditor must be Created first!"));
 816
 817     if (grid->GetTable()->CanGetValueAs(row, col, wxT("bool")))
 818         m_startValue = grid->GetTable()->GetValueAsBool(row, col);
 819     else
 820         m_startValue = !!grid->GetTable()->GetValue(row, col);
 821     CBox()->SetValue(m_startValue);
 822     CBox()->SetFocus();
 823 }
 824
 825 bool wxGridCellBoolEditor::EndEdit(int row, int col,
 826                                    bool saveValue,
 827                                    wxGrid* grid)
 828 {
 829     wxASSERT_MSG(m_control,
 830                  wxT("The wxGridCellEditor must be Created first!"));
 831
 832     bool changed = FALSE;
 833     bool value = CBox()->GetValue();
 834     if ( value != m_startValue )
 835         changed = TRUE;
 836
 837     if ( changed )
 838     {
 839         if (grid->GetTable()->CanGetValueAs(row, col, wxT("bool")))
 840             grid->GetTable()->SetValueAsBool(row, col, value);
 841         else
 842             grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
 843     }
 844
 845     return changed;
 846 }
 847
 848 void wxGridCellBoolEditor::Reset()
 849 {
 850     wxASSERT_MSG(m_control,
 851                  wxT("The wxGridCellEditor must be Created first!"));
 852
 853     CBox()->SetValue(m_startValue);
 854 }
 855
 856 void wxGridCellBoolEditor::StartingClick()
 857 {
 858     CBox()->SetValue(!CBox()->GetValue());
 859 }
 860
 861 // ----------------------------------------------------------------------------
 862 // wxGridCellEditorEvtHandler
 863 // ----------------------------------------------------------------------------
 864
 865 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 866 {
 867     switch ( event.KeyCode() )
 868     {
 869         case WXK_ESCAPE:
 870             m_editor->Reset();
 871             m_grid->DisableCellEditControl();
 872             break;
 873
 874         case WXK_TAB:
 875             event.Skip( m_grid->ProcessEvent( event ) );
 876             break;
 877
 878         case WXK_RETURN:
 879             if (!m_grid->ProcessEvent(event))
 880                 m_editor->HandleReturn(event);
 881             break;
 882
 883
 884         default:
 885             event.Skip();
 886     }
 887 }
 888
 889 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
 890 {
 891     switch ( event.KeyCode() )
 892     {
 893         case WXK_ESCAPE:
 894         case WXK_TAB:
 895         case WXK_RETURN:
 896             break;
 897
 898         default:
 899             event.Skip();
 900     }
 901 }
 902
 903 // ============================================================================
 904 // renderer classes
 905 // ============================================================================
 906
 907 // ----------------------------------------------------------------------------
 908 // wxGridCellRenderer
 909 // ----------------------------------------------------------------------------
 910
 911 void wxGridCellRenderer::Draw(wxGrid& grid,
 912                               wxGridCellAttr& attr,
 913                               wxDC& dc,
 914                               const wxRect& rect,
 915                               int row, int col,
 916                               bool isSelected)
 917 {
 918     dc.SetBackgroundMode( wxSOLID );
 919
 920     if ( isSelected )
 921     {
 922         dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
 923     }
 924     else
 925     {
 926         dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
 927     }
 928
 929     dc.SetPen( *wxTRANSPARENT_PEN );
 930     dc.DrawRectangle(rect);
 931 }
 932
 933 wxGridCellRenderer::~wxGridCellRenderer()
 934 {
 935 }
 936
 937 // ----------------------------------------------------------------------------
 938 // wxGridCellStringRenderer
 939 // ----------------------------------------------------------------------------
 940
 941 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
 942                                                      wxGridCellAttr& attr,
 943                                                      wxDC& dc,
 944                                                      bool isSelected)
 945 {
 946     dc.SetBackgroundMode( wxTRANSPARENT );
 947
 948     // TODO some special colours for attr.IsReadOnly() case?
 949
 950     if ( isSelected )
 951     {
 952         dc.SetTextBackground( grid.GetSelectionBackground() );
 953         dc.SetTextForeground( grid.GetSelectionForeground() );
 954     }
 955     else
 956     {
 957         dc.SetTextBackground( attr.GetBackgroundColour() );
 958         dc.SetTextForeground( attr.GetTextColour() );
 959     }
 960
 961     dc.SetFont( attr.GetFont() );
 962 }
 963
 964 void wxGridCellStringRenderer::Draw(wxGrid& grid,
 965                                     wxGridCellAttr& attr,
 966                                     wxDC& dc,
 967                                     const wxRect& rectCell,
 968                                     int row, int col,
 969                                     bool isSelected)
 970 {
 971     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
 972
 973     // now we only have to draw the text
 974     SetTextColoursAndFont(grid, attr, dc, isSelected);
 975
 976     int hAlign, vAlign;
 977     attr.GetAlignment(&hAlign, &vAlign);
 978
 979     wxRect rect = rectCell;
 980     rect.Inflate(-1);
 981
 982     grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
 983                            rect, hAlign, vAlign);
 984 }
 985
 986 void wxGridCellNumberRenderer::Draw(wxGrid& grid,
 987                                     wxGridCellAttr& attr,
 988                                     wxDC& dc,
 989                                     const wxRect& rectCell,
 990                                     int row, int col,
 991                                     bool isSelected)
 992 {
 993     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
 994
 995     SetTextColoursAndFont(grid, attr, dc, isSelected);
 996
 997     // draw the text right aligned by default
 998     int hAlign, vAlign;
 999     attr.GetAlignment(&hAlign, &vAlign);
1000     hAlign = wxRIGHT;
1001
1002     wxRect rect = rectCell;
1003     rect.Inflate(-1);
1004
1005     wxGridTableBase *table = grid.GetTable();
1006     wxString text;
1007     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1008     {
1009         text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1010     }
1011     //else: leave the string empty or put 0 into it?
1012
1013     grid.DrawTextRectangle(dc, text, rect, hAlign, vAlign);
1014 }
1015
1016 // ----------------------------------------------------------------------------
1017 // wxGridCellFloatRenderer
1018 // ----------------------------------------------------------------------------
1019
1020 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1021 {
1022     SetWidth(width);
1023     SetPrecision(precision);
1024 }
1025
1026 void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1027                                    wxGridCellAttr& attr,
1028                                    wxDC& dc,
1029                                    const wxRect& rectCell,
1030                                    int row, int col,
1031                                    bool isSelected)
1032 {
1033     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1034
1035     SetTextColoursAndFont(grid, attr, dc, isSelected);
1036
1037     // draw the text right aligned by default
1038     int hAlign, vAlign;
1039     attr.GetAlignment(&hAlign, &vAlign);
1040     hAlign = wxRIGHT;
1041
1042     wxRect rect = rectCell;
1043     rect.Inflate(-1);
1044
1045     wxGridTableBase *table = grid.GetTable();
1046     wxString text;
1047     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1048     {
1049         if ( !m_format )
1050         {
1051             m_format.Printf(_T("%%%d.%d%%f"), m_width, m_precision);
1052         }
1053
1054         text.Printf(m_format, table->GetValueAsDouble(row, col));
1055     }
1056     //else: leave the string empty or put 0 into it?
1057
1058     grid.DrawTextRectangle(dc, text, rect, hAlign, vAlign);
1059 }
1060
1061 // ----------------------------------------------------------------------------
1062 // wxGridCellBoolRenderer
1063 // ----------------------------------------------------------------------------
1064
1065 void wxGridCellBoolRenderer::Draw(wxGrid& grid,
1066                                   wxGridCellAttr& attr,
1067                                   wxDC& dc,
1068                                   const wxRect& rect,
1069                                   int row, int col,
1070                                   bool isSelected)
1071 {
1072     wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1073
1074     // between checkmark and box
1075     static const wxCoord margin = 4;
1076
1077     // get checkbox size
1078     static wxCoord s_checkSize = 0;
1079     if ( s_checkSize == 0 )
1080     {
1081         // compute it only once (no locks for MT safeness in GUI thread...)
1082         wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
1083         wxSize size = checkbox->GetBestSize();
1084         s_checkSize = size.y + margin;
1085
1086         // FIXME wxGTK::wxCheckBox::GetBestSize() is really weird...
1087 #ifdef __WXGTK__
1088         s_checkSize -= size.y / 2;
1089 #endif
1090
1091         delete checkbox;
1092     }
1093
1094     // draw a check mark in the centre (ignoring alignment - TODO)
1095     wxRect rectMark;
1096     rectMark.x = rect.x + rect.width/2 - s_checkSize/2;
1097     rectMark.y = rect.y + rect.height/2 - s_checkSize/2;
1098     rectMark.width = rectMark.height = s_checkSize;
1099
1100     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1101     dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
1102     dc.DrawRectangle(rectMark);
1103
1104     rectMark.Inflate(-margin);
1105
1106     bool value;
1107     if (grid.GetTable()->CanGetValueAs(row, col, wxT("bool")))
1108         value = grid.GetTable()->GetValueAsBool(row, col);
1109     else
1110         value = !!grid.GetTable()->GetValue(row, col);
1111
1112     if ( value )
1113     {
1114         dc.SetTextForeground(attr.GetTextColour());
1115         dc.DrawCheckMark(rectMark);
1116     }
1117 }
1118
1119 // ----------------------------------------------------------------------------
1120 // wxGridCellAttr
1121 // ----------------------------------------------------------------------------
1122
1123 const wxColour& wxGridCellAttr::GetTextColour() const
1124 {
1125     if (HasTextColour())
1126     {
1127         return m_colText;
1128     }
1129     else if (m_defGridAttr != this)
1130     {
1131         return m_defGridAttr->GetTextColour();
1132     }
1133     else
1134     {
1135         wxFAIL_MSG(wxT("Missing default cell attribute"));
1136         return wxNullColour;
1137     }
1138 }
1139
1140
1141 const wxColour& wxGridCellAttr::GetBackgroundColour() const
1142 {
1143     if (HasBackgroundColour())
1144         return m_colBack;
1145     else if (m_defGridAttr != this)
1146         return m_defGridAttr->GetBackgroundColour();
1147     else
1148     {
1149         wxFAIL_MSG(wxT("Missing default cell attribute"));
1150         return wxNullColour;
1151     }
1152 }
1153
1154
1155 const wxFont& wxGridCellAttr::GetFont() const
1156 {
1157     if (HasFont())
1158         return m_font;
1159     else if (m_defGridAttr != this)
1160         return m_defGridAttr->GetFont();
1161     else
1162     {
1163         wxFAIL_MSG(wxT("Missing default cell attribute"));
1164         return wxNullFont;
1165     }
1166 }
1167
1168
1169 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
1170 {
1171     if (HasAlignment())
1172     {
1173         if ( hAlign ) *hAlign = m_hAlign;
1174         if ( vAlign ) *vAlign = m_vAlign;
1175     }
1176     else if (m_defGridAttr != this)
1177         m_defGridAttr->GetAlignment(hAlign, vAlign);
1178     else
1179     {
1180         wxFAIL_MSG(wxT("Missing default cell attribute"));
1181     }
1182 }
1183
1184
1185 // GetRenderer and GetEditor use a slightly different decision path about
1186 // which to use.  If a non-default attr object has one then it is used,
1187 // otherwise the default editor or renderer passed in is used.  It should be
1188 // the default for the data type of the cell.  If it is NULL (because the
1189 // table has a type that the grid does not have in its registry,) then the
1190 // grid's default editor or renderer is used.
1191
1192 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGridCellRenderer* def) const
1193 {
1194     if ((m_defGridAttr != this || def == NULL) && HasRenderer())
1195         return m_renderer;
1196     else if (def)
1197         return def;
1198     else if (m_defGridAttr != this)
1199         return m_defGridAttr->GetRenderer(NULL);
1200     else
1201     {
1202         wxFAIL_MSG(wxT("Missing default cell attribute"));
1203         return NULL;
1204     }
1205 }
1206
1207 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGridCellEditor* def) const
1208 {
1209     if ((m_defGridAttr != this || def == NULL) && HasEditor())
1210         return m_editor;
1211     else if (def)
1212         return def;
1213     else if (m_defGridAttr != this)
1214         return m_defGridAttr->GetEditor(NULL);
1215     else
1216     {
1217         wxFAIL_MSG(wxT("Missing default cell attribute"));
1218         return NULL;
1219     }
1220 }
1221
1222 // ----------------------------------------------------------------------------
1223 // wxGridCellAttrData
1224 // ----------------------------------------------------------------------------
1225
1226 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
1227 {
1228     int n = FindIndex(row, col);
1229     if ( n == wxNOT_FOUND )
1230     {
1231         // add the attribute
1232         m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
1233     }
1234     else
1235     {
1236         if ( attr )
1237         {
1238             // change the attribute
1239             m_attrs[(size_t)n].attr = attr;
1240         }
1241         else
1242         {
1243             // remove this attribute
1244             m_attrs.RemoveAt((size_t)n);
1245         }
1246     }
1247 }
1248
1249 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
1250 {
1251     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1252
1253     int n = FindIndex(row, col);
1254     if ( n != wxNOT_FOUND )
1255     {
1256         attr = m_attrs[(size_t)n].attr;
1257         attr->IncRef();
1258     }
1259
1260     return attr;
1261 }
1262
1263 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
1264 {
1265     size_t count = m_attrs.GetCount();
1266     for ( size_t n = 0; n < count; n++ )
1267     {
1268         wxGridCellCoords& coords = m_attrs[n].coords;
1269         wxCoord row = coords.GetRow();
1270         if ((size_t)row >= pos)
1271         {
1272             if (numRows > 0)
1273             {
1274                 // If rows inserted, include row counter where necessary
1275                 coords.SetRow(row + numRows);
1276             }
1277             else if (numRows < 0)
1278             {
1279                 // If rows deleted ...
1280                 if ((size_t)row >= pos - numRows)
1281                 {
1282                     // ...either decrement row counter (if row still exists)...
1283                     coords.SetRow(row + numRows);
1284                 }
1285                 else
1286                 {
1287                     // ...or remove the attribute
1288                     m_attrs.RemoveAt((size_t)n);
1289                     n--; count--;
1290                 }
1291             }
1292         }
1293     }
1294 }
1295
1296 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
1297 {
1298     size_t count = m_attrs.GetCount();
1299     for ( size_t n = 0; n < count; n++ )
1300     {
1301         wxGridCellCoords& coords = m_attrs[n].coords;
1302         wxCoord col = coords.GetCol();
1303         if ( (size_t)col >= pos )
1304         {
1305             if ( numCols > 0 )
1306             {
1307                 // If rows inserted, include row counter where necessary
1308                 coords.SetCol(col + numCols);
1309             }
1310             else if (numCols < 0)
1311             {
1312                 // If rows deleted ...
1313                 if ((size_t)col >= pos - numCols)
1314                 {
1315                     // ...either decrement row counter (if row still exists)...
1316                     coords.SetCol(col + numCols);
1317                 }
1318                 else
1319                 {
1320                     // ...or remove the attribute
1321                     m_attrs.RemoveAt((size_t)n);
1322                     n--; count--;
1323                 }
1324             }
1325         }
1326     }
1327 }
1328
1329 int wxGridCellAttrData::FindIndex(int row, int col) const
1330 {
1331     size_t count = m_attrs.GetCount();
1332     for ( size_t n = 0; n < count; n++ )
1333     {
1334         const wxGridCellCoords& coords = m_attrs[n].coords;
1335         if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
1336         {
1337             return n;
1338         }
1339     }
1340
1341     return wxNOT_FOUND;
1342 }
1343
1344 // ----------------------------------------------------------------------------
1345 // wxGridRowOrColAttrData
1346 // ----------------------------------------------------------------------------
1347
1348 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
1349 {
1350     size_t count = m_attrs.Count();
1351     for ( size_t n = 0; n < count; n++ )
1352     {
1353         m_attrs[n]->DecRef();
1354     }
1355 }
1356
1357 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
1358 {
1359     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1360
1361     int n = m_rowsOrCols.Index(rowOrCol);
1362     if ( n != wxNOT_FOUND )
1363     {
1364         attr = m_attrs[(size_t)n];
1365         attr->IncRef();
1366     }
1367
1368     return attr;
1369 }
1370
1371 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
1372 {
1373     int n = m_rowsOrCols.Index(rowOrCol);
1374     if ( n == wxNOT_FOUND )
1375     {
1376         // add the attribute
1377         m_rowsOrCols.Add(rowOrCol);
1378         m_attrs.Add(attr);
1379     }
1380     else
1381     {
1382         if ( attr )
1383         {
1384             // change the attribute
1385             m_attrs[(size_t)n] = attr;
1386         }
1387         else
1388         {
1389             // remove this attribute
1390             m_attrs[(size_t)n]->DecRef();
1391             m_rowsOrCols.RemoveAt((size_t)n);
1392             m_attrs.RemoveAt((size_t)n);
1393         }
1394     }
1395 }
1396
1397 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
1398 {
1399     size_t count = m_attrs.GetCount();
1400     for ( size_t n = 0; n < count; n++ )
1401     {
1402         int & rowOrCol = m_rowsOrCols[n];
1403         if ( (size_t)rowOrCol >= pos )
1404         {
1405             if ( numRowsOrCols > 0 )
1406             {
1407                 // If rows inserted, include row counter where necessary
1408                 rowOrCol += numRowsOrCols;
1409             }
1410             else if ( numRowsOrCols < 0)
1411             {
1412                 // If rows deleted, either decrement row counter (if row still exists)
1413                 if ((size_t)rowOrCol >= pos - numRowsOrCols)
1414                     rowOrCol += numRowsOrCols;
1415                 else
1416                 {
1417                     m_rowsOrCols.RemoveAt((size_t)n);
1418                     m_attrs.RemoveAt((size_t)n);
1419                     n--; count--;
1420                 }
1421             }
1422         }
1423     }
1424 }
1425
1426 // ----------------------------------------------------------------------------
1427 // wxGridCellAttrProvider
1428 // ----------------------------------------------------------------------------
1429
1430 wxGridCellAttrProvider::wxGridCellAttrProvider()
1431 {
1432     m_data = (wxGridCellAttrProviderData *)NULL;
1433 }
1434
1435 wxGridCellAttrProvider::~wxGridCellAttrProvider()
1436 {
1437     delete m_data;
1438 }
1439
1440 void wxGridCellAttrProvider::InitData()
1441 {
1442     m_data = new wxGridCellAttrProviderData;
1443 }
1444
1445 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
1446 {
1447     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
1448     if ( m_data )
1449     {
1450         // first look for the attribute of this specific cell
1451         attr = m_data->m_cellAttrs.GetAttr(row, col);
1452
1453         if ( !attr )
1454         {
1455             // then look for the col attr (col attributes are more common than
1456             // the row ones, hence they have priority)
1457             attr = m_data->m_colAttrs.GetAttr(col);
1458         }
1459
1460         if ( !attr )
1461         {
1462             // finally try the row attributes
1463             attr = m_data->m_rowAttrs.GetAttr(row);
1464         }
1465     }
1466
1467     return attr;
1468 }
1469
1470 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
1471                                      int row, int col)
1472 {
1473     if ( !m_data )
1474         InitData();
1475
1476     m_data->m_cellAttrs.SetAttr(attr, row, col);
1477 }
1478
1479 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
1480 {
1481     if ( !m_data )
1482         InitData();
1483
1484     m_data->m_rowAttrs.SetAttr(attr, row);
1485 }
1486
1487 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
1488 {
1489     if ( !m_data )
1490         InitData();
1491
1492     m_data->m_colAttrs.SetAttr(attr, col);
1493 }
1494
1495 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
1496 {
1497     if ( m_data )
1498     {
1499         m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
1500
1501         m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
1502     }
1503 }
1504
1505 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
1506 {
1507     if ( m_data )
1508     {
1509         m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
1510
1511         m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
1512     }
1513 }
1514
1515 // ----------------------------------------------------------------------------
1516 // wxGridTypeRegistry
1517 // ----------------------------------------------------------------------------
1518
1519 wxGridTypeRegistry::~wxGridTypeRegistry()
1520 {
1521     for (size_t i=0; i<m_typeinfo.Count(); i++)
1522         delete m_typeinfo[i];
1523 }
1524
1525
1526 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
1527                                           wxGridCellRenderer* renderer,
1528                                           wxGridCellEditor* editor)
1529 {
1530     int loc;
1531     wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
1532
1533     // is it already registered?
1534     if ((loc = FindDataType(typeName)) != -1) {
1535         delete m_typeinfo[loc];
1536         m_typeinfo[loc] = info;
1537     }
1538     else {
1539         m_typeinfo.Add(info);
1540     }
1541 }
1542
1543 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
1544 {
1545     int found = -1;
1546
1547     for (size_t i=0; i<m_typeinfo.Count(); i++) {
1548         if (typeName == m_typeinfo[i]->m_typeName) {
1549             found = i;
1550             break;
1551         }
1552     }
1553
1554     return found;
1555 }
1556
1557 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
1558 {
1559     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
1560     return renderer;
1561 }
1562
1563 wxGridCellEditor*   wxGridTypeRegistry::GetEditor(int index)
1564 {
1565     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
1566     return editor;
1567 }
1568
1569 // ----------------------------------------------------------------------------
1570 // wxGridTableBase
1571 // ----------------------------------------------------------------------------
1572
1573 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
1574
1575
1576 wxGridTableBase::wxGridTableBase()
1577 {
1578     m_view = (wxGrid *) NULL;
1579     m_attrProvider = (wxGridCellAttrProvider *) NULL;
1580 }
1581
1582 wxGridTableBase::~wxGridTableBase()
1583 {
1584     delete m_attrProvider;
1585 }
1586
1587 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
1588 {
1589     delete m_attrProvider;
1590     m_attrProvider = attrProvider;
1591 }
1592
1593 bool wxGridTableBase::CanHaveAttributes()
1594 {
1595     if ( ! GetAttrProvider() )
1596     {
1597         // use the default attr provider by default
1598         SetAttrProvider(new wxGridCellAttrProvider);
1599     }
1600     return TRUE;
1601 }
1602
1603 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
1604 {
1605     if ( m_attrProvider )
1606         return m_attrProvider->GetAttr(row, col);
1607     else
1608         return (wxGridCellAttr *)NULL;
1609 }
1610
1611 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
1612 {
1613     if ( m_attrProvider )
1614     {
1615         m_attrProvider->SetAttr(attr, row, col);
1616     }
1617     else
1618     {
1619         // as we take ownership of the pointer and don't store it, we must
1620         // free it now
1621         attr->SafeDecRef();
1622     }
1623 }
1624
1625 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
1626 {
1627     if ( m_attrProvider )
1628     {
1629         m_attrProvider->SetRowAttr(attr, row);
1630     }
1631     else
1632     {
1633         // as we take ownership of the pointer and don't store it, we must
1634         // free it now
1635         attr->SafeDecRef();
1636     }
1637 }
1638
1639 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
1640 {
1641     if ( m_attrProvider )
1642     {
1643         m_attrProvider->SetColAttr(attr, col);
1644     }
1645     else
1646     {
1647         // as we take ownership of the pointer and don't store it, we must
1648         // free it now
1649         attr->SafeDecRef();
1650     }
1651 }
1652
1653 void wxGridTableBase::UpdateAttrRows( size_t pos, int numRows )
1654 {
1655     if ( m_attrProvider )
1656     {
1657         m_attrProvider->UpdateAttrRows( pos, numRows );
1658     }
1659 }
1660
1661 void wxGridTableBase::UpdateAttrCols( size_t pos, int numCols )
1662 {
1663     if ( m_attrProvider )
1664     {
1665         m_attrProvider->UpdateAttrCols( pos, numCols );
1666     }
1667 }
1668
1669 bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
1670 {
1671     wxFAIL_MSG( wxT("Called grid table class function InsertRows\n"
1672                     "but your derived table class does not override this function") );
1673
1674     return FALSE;
1675 }
1676
1677 bool wxGridTableBase::AppendRows( size_t numRows )
1678 {
1679     wxFAIL_MSG( wxT("Called grid table class function AppendRows\n"
1680                     "but your derived table class does not override this function"));
1681
1682     return FALSE;
1683 }
1684
1685 bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
1686 {
1687     wxFAIL_MSG( wxT("Called grid table class function DeleteRows\n"
1688                     "but your derived table class does not override this function"));
1689
1690     return FALSE;
1691 }
1692
1693 bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
1694 {
1695     wxFAIL_MSG( wxT("Called grid table class function InsertCols\n"
1696                   "but your derived table class does not override this function"));
1697
1698     return FALSE;
1699 }
1700
1701 bool wxGridTableBase::AppendCols( size_t numCols )
1702 {
1703     wxFAIL_MSG(wxT("Called grid table class function AppendCols\n"
1704                    "but your derived table class does not override this function"));
1705
1706     return FALSE;
1707 }
1708
1709 bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
1710 {
1711     wxFAIL_MSG( wxT("Called grid table class function DeleteCols\n"
1712                     "but your derived table class does not override this function"));
1713
1714     return FALSE;
1715 }
1716
1717
1718 wxString wxGridTableBase::GetRowLabelValue( int row )
1719 {
1720     wxString s;
1721     s << row + 1; // RD: Starting the rows at zero confuses users, no matter
1722                   //     how much it makes sense to us geeks.
1723     return s;
1724 }
1725
1726 wxString wxGridTableBase::GetColLabelValue( int col )
1727 {
1728     // default col labels are:
1729     //   cols 0 to 25   : A-Z
1730     //   cols 26 to 675 : AA-ZZ
1731     //   etc.
1732
1733     wxString s;
1734     unsigned int i, n;
1735     for ( n = 1; ; n++ )
1736     {
1737         s += (_T('A') + (wxChar)( col%26 ));
1738         col = col/26 - 1;
1739         if ( col < 0 ) break;
1740     }
1741
1742     // reverse the string...
1743     wxString s2;
1744     for ( i = 0;  i < n;  i++ )
1745     {
1746         s2 += s[n-i-1];
1747     }
1748
1749     return s2;
1750 }
1751
1752
1753 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
1754 {
1755     return wxGRID_VALUE_STRING;
1756 }
1757
1758 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
1759                                      const wxString& typeName )
1760 {
1761     return typeName == wxGRID_VALUE_STRING;
1762 }
1763
1764 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
1765 {
1766     return CanGetValueAs(row, col, typeName);
1767 }
1768
1769 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
1770 {
1771     return 0;
1772 }
1773
1774 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
1775 {
1776     return 0.0;
1777 }
1778
1779 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
1780 {
1781     return FALSE;
1782 }
1783
1784 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
1785                                       long WXUNUSED(value) )
1786 {
1787 }
1788
1789 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
1790                                         double WXUNUSED(value) )
1791 {
1792 }
1793
1794 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
1795                                       bool WXUNUSED(value) )
1796 {
1797 }
1798
1799
1800 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
1801                                          const wxString& WXUNUSED(typeName) )
1802 {
1803     return NULL;
1804 }
1805
1806 void  wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
1807                                          const wxString& WXUNUSED(typeName),
1808                                          void* WXUNUSED(value) )
1809 {
1810 }
1811
1812
1813 //////////////////////////////////////////////////////////////////////
1814 //
1815 // Message class for the grid table to send requests and notifications
1816 // to the grid view
1817 //
1818
1819 wxGridTableMessage::wxGridTableMessage()
1820 {
1821     m_table = (wxGridTableBase *) NULL;
1822     m_id = -1;
1823     m_comInt1 = -1;
1824     m_comInt2 = -1;
1825 }
1826
1827 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
1828                                         int commandInt1, int commandInt2 )
1829 {
1830     m_table = table;
1831     m_id = id;
1832     m_comInt1 = commandInt1;
1833     m_comInt2 = commandInt2;
1834 }
1835
1836
1837
1838 //////////////////////////////////////////////////////////////////////
1839 //
1840 // A basic grid table for string data. An object of this class will
1841 // created by wxGrid if you don't specify an alternative table class.
1842 //
1843
1844 WX_DEFINE_OBJARRAY(wxGridStringArray)
1845
1846 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
1847
1848 wxGridStringTable::wxGridStringTable()
1849         : wxGridTableBase()
1850 {
1851 }
1852
1853 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
1854         : wxGridTableBase()
1855 {
1856     int row, col;
1857
1858     m_data.Alloc( numRows );
1859
1860     wxArrayString sa;
1861     sa.Alloc( numCols );
1862     for ( col = 0;  col < numCols;  col++ )
1863     {
1864         sa.Add( wxEmptyString );
1865     }
1866
1867     for ( row = 0;  row < numRows;  row++ )
1868     {
1869         m_data.Add( sa );
1870     }
1871 }
1872
1873 wxGridStringTable::~wxGridStringTable()
1874 {
1875 }
1876
1877 long wxGridStringTable::GetNumberRows()
1878 {
1879     return m_data.GetCount();
1880 }
1881
1882 long wxGridStringTable::GetNumberCols()
1883 {
1884     if ( m_data.GetCount() > 0 )
1885         return m_data[0].GetCount();
1886     else
1887         return 0;
1888 }
1889
1890 wxString wxGridStringTable::GetValue( int row, int col )
1891 {
1892     // TODO: bounds checking
1893     //
1894     return m_data[row][col];
1895 }
1896
1897 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
1898 {
1899     // TODO: bounds checking
1900     //
1901     m_data[row][col] = value;
1902 }
1903
1904 bool wxGridStringTable::IsEmptyCell( int row, int col )
1905 {
1906     // TODO: bounds checking
1907     //
1908     return (m_data[row][col] == wxEmptyString);
1909 }
1910
1911
1912 void wxGridStringTable::Clear()
1913 {
1914     int row, col;
1915     int numRows, numCols;
1916
1917     numRows = m_data.GetCount();
1918     if ( numRows > 0 )
1919     {
1920         numCols = m_data[0].GetCount();
1921
1922         for ( row = 0;  row < numRows;  row++ )
1923         {
1924             for ( col = 0;  col < numCols;  col++ )
1925             {
1926                 m_data[row][col] = wxEmptyString;
1927             }
1928         }
1929     }
1930 }
1931
1932
1933 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
1934 {
1935     size_t row, col;
1936
1937     size_t curNumRows = m_data.GetCount();
1938     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
1939
1940     if ( pos >= curNumRows )
1941     {
1942         return AppendRows( numRows );
1943     }
1944
1945     wxArrayString sa;
1946     sa.Alloc( curNumCols );
1947     for ( col = 0;  col < curNumCols;  col++ )
1948     {
1949         sa.Add( wxEmptyString );
1950     }
1951
1952     for ( row = pos;  row < pos + numRows;  row++ )
1953     {
1954         m_data.Insert( sa, row );
1955     }
1956     UpdateAttrRows( pos, numRows );
1957     if ( GetView() )
1958     {
1959         wxGridTableMessage msg( this,
1960                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
1961                                 pos,
1962                                 numRows );
1963
1964         GetView()->ProcessTableMessage( msg );
1965     }
1966
1967     return TRUE;
1968 }
1969
1970 bool wxGridStringTable::AppendRows( size_t numRows )
1971 {
1972     size_t row, col;
1973
1974     size_t curNumRows = m_data.GetCount();
1975     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
1976
1977     wxArrayString sa;
1978     if ( curNumCols > 0 )
1979     {
1980         sa.Alloc( curNumCols );
1981         for ( col = 0;  col < curNumCols;  col++ )
1982         {
1983             sa.Add( wxEmptyString );
1984         }
1985     }
1986
1987     for ( row = 0;  row < numRows;  row++ )
1988     {
1989         m_data.Add( sa );
1990     }
1991
1992     if ( GetView() )
1993     {
1994         wxGridTableMessage msg( this,
1995                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
1996                                 numRows );
1997
1998         GetView()->ProcessTableMessage( msg );
1999     }
2000
2001     return TRUE;
2002 }
2003
2004 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
2005 {
2006     size_t n;
2007
2008     size_t curNumRows = m_data.GetCount();
2009
2010     if ( pos >= curNumRows )
2011     {
2012         wxString errmsg;
2013         errmsg.Printf("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\n"
2014                       "Pos value is invalid for present table with %d rows",
2015                       pos, numRows, curNumRows );
2016         wxFAIL_MSG( wxT(errmsg) );
2017         return FALSE;
2018     }
2019
2020     if ( numRows > curNumRows - pos )
2021     {
2022         numRows = curNumRows - pos;
2023     }
2024
2025     if ( numRows >= curNumRows )
2026     {
2027         m_data.Empty();  // don't release memory just yet
2028     }
2029     else
2030     {
2031         for ( n = 0;  n < numRows;  n++ )
2032         {
2033             m_data.Remove( pos );
2034         }
2035     }
2036     UpdateAttrRows( pos, -((int)numRows) );
2037     if ( GetView() )
2038     {
2039         wxGridTableMessage msg( this,
2040                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
2041                                 pos,
2042                                 numRows );
2043
2044         GetView()->ProcessTableMessage( msg );
2045     }
2046
2047     return TRUE;
2048 }
2049
2050 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
2051 {
2052     size_t row, col;
2053
2054     size_t curNumRows = m_data.GetCount();
2055     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
2056
2057     if ( pos >= curNumCols )
2058     {
2059         return AppendCols( numCols );
2060     }
2061
2062     for ( row = 0;  row < curNumRows;  row++ )
2063     {
2064         for ( col = pos;  col < pos + numCols;  col++ )
2065         {
2066             m_data[row].Insert( wxEmptyString, col );
2067         }
2068     }
2069     UpdateAttrCols( pos, numCols );
2070     if ( GetView() )
2071     {
2072         wxGridTableMessage msg( this,
2073                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
2074                                 pos,
2075                                 numCols );
2076
2077         GetView()->ProcessTableMessage( msg );
2078     }
2079
2080     return TRUE;
2081 }
2082
2083 bool wxGridStringTable::AppendCols( size_t numCols )
2084 {
2085     size_t row, n;
2086
2087     size_t curNumRows = m_data.GetCount();
2088     if ( !curNumRows )
2089     {
2090         // TODO: something better than this ?
2091         //
2092         wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\n"
2093                         "Call AppendRows() first") );
2094         return FALSE;
2095     }
2096
2097     for ( row = 0;  row < curNumRows;  row++ )
2098     {
2099         for ( n = 0;  n < numCols;  n++ )
2100         {
2101             m_data[row].Add( wxEmptyString );
2102         }
2103     }
2104
2105     if ( GetView() )
2106     {
2107         wxGridTableMessage msg( this,
2108                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
2109                                 numCols );
2110
2111         GetView()->ProcessTableMessage( msg );
2112     }
2113
2114     return TRUE;
2115 }
2116
2117 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
2118 {
2119     size_t row, n;
2120
2121     size_t curNumRows = m_data.GetCount();
2122     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
2123
2124     if ( pos >= curNumCols )
2125     {
2126         wxString errmsg;
2127         errmsg.Printf( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
2128                         "Pos value is invalid for present table with %d cols",
2129                         pos, numCols, curNumCols );
2130         wxFAIL_MSG( wxT( errmsg ) );
2131         return FALSE;
2132     }
2133
2134     if ( numCols > curNumCols - pos )
2135     {
2136         numCols = curNumCols - pos;
2137     }
2138
2139     for ( row = 0;  row < curNumRows;  row++ )
2140     {
2141         if ( numCols >= curNumCols )
2142         {
2143             m_data[row].Clear();
2144         }
2145         else
2146         {
2147             for ( n = 0;  n < numCols;  n++ )
2148             {
2149                 m_data[row].Remove( pos );
2150             }
2151         }
2152     }
2153     UpdateAttrCols( pos, -((int)numCols) );
2154     if ( GetView() )
2155     {
2156         wxGridTableMessage msg( this,
2157                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
2158                                 pos,
2159                                 numCols );
2160
2161         GetView()->ProcessTableMessage( msg );
2162     }
2163
2164     return TRUE;
2165 }
2166
2167 wxString wxGridStringTable::GetRowLabelValue( int row )
2168 {
2169     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
2170     {
2171         // using default label
2172         //
2173         return wxGridTableBase::GetRowLabelValue( row );
2174     }
2175     else
2176     {
2177         return m_rowLabels[ row ];
2178     }
2179 }
2180
2181 wxString wxGridStringTable::GetColLabelValue( int col )
2182 {
2183     if ( col > (int)(m_colLabels.GetCount()) - 1 )
2184     {
2185         // using default label
2186         //
2187         return wxGridTableBase::GetColLabelValue( col );
2188     }
2189     else
2190     {
2191         return m_colLabels[ col ];
2192     }
2193 }
2194
2195 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
2196 {
2197     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
2198     {
2199         int n = m_rowLabels.GetCount();
2200         int i;
2201         for ( i = n;  i <= row;  i++ )
2202         {
2203             m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
2204         }
2205     }
2206
2207     m_rowLabels[row] = value;
2208 }
2209
2210 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
2211 {
2212     if ( col > (int)(m_colLabels.GetCount()) - 1 )
2213     {
2214         int n = m_colLabels.GetCount();
2215         int i;
2216         for ( i = n;  i <= col;  i++ )
2217         {
2218             m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
2219         }
2220     }
2221
2222     m_colLabels[col] = value;
2223 }
2224
2225
2226
2227 //////////////////////////////////////////////////////////////////////
2228 //////////////////////////////////////////////////////////////////////
2229
2230 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
2231
2232 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
2233     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
2234     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
2235     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
2236 END_EVENT_TABLE()
2237
2238 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
2239                                             wxWindowID id,
2240                                             const wxPoint &pos, const wxSize &size )
2241   : wxWindow( parent, id, pos, size )
2242 {
2243     m_owner = parent;
2244 }
2245
2246 void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
2247 {
2248     wxPaintDC dc(this);
2249
2250     // NO - don't do this because it will set both the x and y origin
2251     // coords to match the parent scrolled window and we just want to
2252     // set the y coord  - MB
2253     //
2254     // m_owner->PrepareDC( dc );
2255
2256     int x, y;
2257     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
2258     dc.SetDeviceOrigin( 0, -y );
2259
2260     m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
2261     m_owner->DrawRowLabels( dc );
2262 }
2263
2264
2265 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
2266 {
2267     m_owner->ProcessRowLabelMouseEvent( event );
2268 }
2269
2270
2271 // This seems to be required for wxMotif otherwise the mouse
2272 // cursor must be in the cell edit control to get key events
2273 //
2274 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
2275 {
2276     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2277 }
2278
2279
2280
2281 //////////////////////////////////////////////////////////////////////
2282
2283 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
2284
2285 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
2286     EVT_PAINT( wxGridColLabelWindow::OnPaint )
2287     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
2288     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
2289 END_EVENT_TABLE()
2290
2291 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
2292                                             wxWindowID id,
2293                                             const wxPoint &pos, const wxSize &size )
2294   : wxWindow( parent, id, pos, size )
2295 {
2296     m_owner = parent;
2297 }
2298
2299 void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
2300 {
2301     wxPaintDC dc(this);
2302
2303     // NO - don't do this because it will set both the x and y origin
2304     // coords to match the parent scrolled window and we just want to
2305     // set the x coord  - MB
2306     //
2307     // m_owner->PrepareDC( dc );
2308
2309     int x, y;
2310     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
2311     dc.SetDeviceOrigin( -x, 0 );
2312
2313     m_owner->CalcColLabelsExposed( GetUpdateRegion() );
2314     m_owner->DrawColLabels( dc );
2315 }
2316
2317
2318 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
2319 {
2320     m_owner->ProcessColLabelMouseEvent( event );
2321 }
2322
2323
2324 // This seems to be required for wxMotif otherwise the mouse
2325 // cursor must be in the cell edit control to get key events
2326 //
2327 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
2328 {
2329     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2330 }
2331
2332
2333
2334 //////////////////////////////////////////////////////////////////////
2335
2336 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
2337
2338 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
2339     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
2340     EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
2341     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
2342 END_EVENT_TABLE()
2343
2344 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
2345                                                   wxWindowID id,
2346                                                   const wxPoint &pos, const wxSize &size )
2347   : wxWindow( parent, id, pos, size )
2348 {
2349     m_owner = parent;
2350 }
2351
2352 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
2353 {
2354     wxPaintDC dc(this);
2355
2356     int client_height = 0;
2357     int client_width = 0;
2358     GetClientSize( &client_width, &client_height );
2359
2360     dc.SetPen( *wxBLACK_PEN );
2361     dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
2362     dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
2363
2364     dc.SetPen( *wxWHITE_PEN );
2365     dc.DrawLine( 0, 0, client_width, 0 );
2366     dc.DrawLine( 0, 0, 0, client_height );
2367 }
2368
2369
2370 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
2371 {
2372     m_owner->ProcessCornerLabelMouseEvent( event );
2373 }
2374
2375
2376 // This seems to be required for wxMotif otherwise the mouse
2377 // cursor must be in the cell edit control to get key events
2378 //
2379 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
2380 {
2381     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2382 }
2383
2384
2385
2386 //////////////////////////////////////////////////////////////////////
2387
2388 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
2389
2390 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
2391     EVT_PAINT( wxGridWindow::OnPaint )
2392     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
2393     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
2394     EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
2395 END_EVENT_TABLE()
2396
2397 wxGridWindow::wxGridWindow( wxGrid *parent,
2398                             wxGridRowLabelWindow *rowLblWin,
2399                             wxGridColLabelWindow *colLblWin,
2400                             wxWindowID id, const wxPoint &pos, const wxSize &size )
2401         : wxPanel( parent, id, pos, size, 0, "grid window" )
2402 {
2403     m_owner = parent;
2404     m_rowLabelWin = rowLblWin;
2405     m_colLabelWin = colLblWin;
2406     SetBackgroundColour( "WHITE" );
2407 }
2408
2409
2410 wxGridWindow::~wxGridWindow()
2411 {
2412 }
2413
2414
2415 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
2416 {
2417     wxPaintDC dc( this );
2418     m_owner->PrepareDC( dc );
2419     wxRegion reg = GetUpdateRegion();
2420     m_owner->CalcCellsExposed( reg );
2421     m_owner->DrawGridCellArea( dc );
2422 #if WXGRID_DRAW_LINES
2423     m_owner->DrawAllGridLines( dc, reg );
2424 #endif
2425     m_owner->DrawHighlight( dc );
2426 }
2427
2428
2429 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
2430 {
2431     wxPanel::ScrollWindow( dx, dy, rect );
2432     m_rowLabelWin->ScrollWindow( 0, dy, rect );
2433     m_colLabelWin->ScrollWindow( dx, 0, rect );
2434 }
2435
2436
2437 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
2438 {
2439     m_owner->ProcessGridCellMouseEvent( event );
2440 }
2441
2442
2443 // This seems to be required for wxMotif otherwise the mouse
2444 // cursor must be in the cell edit control to get key events
2445 //
2446 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
2447 {
2448     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
2449 }
2450
2451 // We are trapping erase background events to reduce flicker under MSW
2452 // and GTK but this can leave junk in the space beyond the last row and
2453 // col.  So here we paint these spaces if they are visible.
2454 //
2455 void wxGridWindow::OnEraseBackground(wxEraseEvent& event)
2456 {
2457     int cw, ch;
2458     GetClientSize( &cw, &ch );
2459
2460     int right, bottom;
2461     m_owner->CalcUnscrolledPosition( cw, ch, &right, &bottom );
2462
2463     wxRect rightRect;
2464     rightRect = m_owner->CellToRect( 0, m_owner->GetNumberCols()-1 );
2465
2466     wxRect bottomRect;
2467     bottomRect = m_owner->CellToRect( m_owner->GetNumberRows()-1, 0 );
2468
2469     if ( right > rightRect.GetRight()  ||  bottom > bottomRect.GetBottom() )
2470     {
2471         int left, top;
2472         m_owner->CalcUnscrolledPosition( 0, 0, &left, &top );
2473
2474         wxClientDC dc( this );
2475         m_owner->PrepareDC( dc );
2476         dc.SetBrush( wxBrush(m_owner->GetDefaultCellBackgroundColour(), wxSOLID) );
2477         dc.SetPen( *wxTRANSPARENT_PEN );
2478
2479         if ( right > rightRect.GetRight() )
2480             dc.DrawRectangle( rightRect.GetRight()+1, top, right - rightRect.GetRight(), ch );
2481
2482         if ( bottom > bottomRect.GetBottom() )
2483             dc.DrawRectangle( left, bottomRect.GetBottom()+1, cw, bottom - bottomRect.GetBottom() );
2484     }
2485 }
2486
2487
2488 //////////////////////////////////////////////////////////////////////
2489
2490
2491 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
2492
2493 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
2494     EVT_PAINT( wxGrid::OnPaint )
2495     EVT_SIZE( wxGrid::OnSize )
2496     EVT_KEY_DOWN( wxGrid::OnKeyDown )
2497     EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
2498 END_EVENT_TABLE()
2499
2500 wxGrid::wxGrid( wxWindow *parent,
2501                  wxWindowID id,
2502                  const wxPoint& pos,
2503                  const wxSize& size,
2504                  long style,
2505                  const wxString& name )
2506   : wxScrolledWindow( parent, id, pos, size, style, name ),
2507     m_colMinWidths(wxKEY_INTEGER, GRID_HASH_SIZE)
2508 {
2509     Create();
2510 }
2511
2512
2513 wxGrid::~wxGrid()
2514 {
2515     ClearAttrCache();
2516     m_defaultCellAttr->SafeDecRef();
2517
2518 #ifdef DEBUG_ATTR_CACHE
2519     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
2520     wxPrintf(_T("wxGrid attribute cache statistics: "
2521                 "total: %u, hits: %u (%u%%)\n"),
2522              total, gs_nAttrCacheHits,
2523              total ? (gs_nAttrCacheHits*100) / total : 0);
2524 #endif
2525
2526     if (m_ownTable)
2527         delete m_table;
2528
2529     delete m_typeRegistry;
2530 }
2531
2532
2533 //
2534 // ----- internal init and update functions
2535 //
2536
2537 void wxGrid::Create()
2538 {
2539     m_created = FALSE;    // set to TRUE by CreateGrid
2540     m_displayed = TRUE; // FALSE;  // set to TRUE by OnPaint
2541
2542     m_table        = (wxGridTableBase *) NULL;
2543     m_ownTable     = FALSE;
2544
2545     m_cellEditCtrlEnabled = FALSE;
2546
2547     m_defaultCellAttr = new wxGridCellAttr;
2548     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
2549
2550     // Set default cell attributes
2551     m_defaultCellAttr->SetFont(GetFont());
2552     m_defaultCellAttr->SetAlignment(wxLEFT, wxTOP);
2553     m_defaultCellAttr->SetTextColour(
2554         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
2555     m_defaultCellAttr->SetBackgroundColour(
2556         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
2557     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
2558     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
2559
2560
2561     m_numRows = 0;
2562     m_numCols = 0;
2563     m_currentCellCoords = wxGridNoCellCoords;
2564
2565     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
2566     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
2567
2568     // data type registration: register all standard data types
2569     // TODO: may be allow the app to selectively disable some of them?
2570     m_typeRegistry = new wxGridTypeRegistry;
2571     RegisterDataType(wxGRID_VALUE_STRING,
2572                      new wxGridCellStringRenderer,
2573                      new wxGridCellTextEditor);
2574     RegisterDataType(wxGRID_VALUE_BOOL,
2575                      new wxGridCellBoolRenderer,
2576                      new wxGridCellBoolEditor);
2577     RegisterDataType(wxGRID_VALUE_NUMBER,
2578                      new wxGridCellNumberRenderer,
2579                      new wxGridCellNumberEditor);
2580
2581     // subwindow components that make up the wxGrid
2582     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
2583                                                     -1,
2584                                                     wxDefaultPosition,
2585                                                     wxDefaultSize );
2586
2587     m_rowLabelWin = new wxGridRowLabelWindow( this,
2588                                               -1,
2589                                               wxDefaultPosition,
2590                                               wxDefaultSize );
2591
2592     m_colLabelWin = new wxGridColLabelWindow( this,
2593                                               -1,
2594                                               wxDefaultPosition,
2595                                               wxDefaultSize );
2596
2597     m_gridWin = new wxGridWindow( this,
2598                                   m_rowLabelWin,
2599                                   m_colLabelWin,
2600                                   -1,
2601                                   wxDefaultPosition,
2602                                   wxDefaultSize );
2603
2604     SetTargetWindow( m_gridWin );
2605 }
2606
2607
2608 bool wxGrid::CreateGrid( int numRows, int numCols )
2609 {
2610     if ( m_created )
2611     {
2612         wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
2613         return FALSE;
2614     }
2615     else
2616     {
2617         m_numRows = numRows;
2618         m_numCols = numCols;
2619
2620         m_table = new wxGridStringTable( m_numRows, m_numCols );
2621         m_table->SetView( this );
2622         m_ownTable = TRUE;
2623         Init();
2624         m_created = TRUE;
2625     }
2626
2627     return m_created;
2628 }
2629
2630 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership )
2631 {
2632     if ( m_created )
2633     {
2634         // RD: Actually, this should probably be allowed.  I think it would be
2635         // nice to be able to switch multiple Tables in and out of a single
2636         // View at runtime.  Is there anything in the implmentation that would
2637         // prevent this?
2638
2639         wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
2640         return FALSE;
2641     }
2642     else
2643     {
2644         m_numRows = table->GetNumberRows();
2645         m_numCols = table->GetNumberCols();
2646
2647         m_table = table;
2648         m_table->SetView( this );
2649         if (takeOwnership)
2650             m_ownTable = TRUE;
2651         Init();
2652         m_created = TRUE;
2653     }
2654
2655     return m_created;
2656 }
2657
2658
2659 void wxGrid::Init()
2660 {
2661     if ( m_numRows <= 0 )
2662         m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
2663
2664     if ( m_numCols <= 0 )
2665         m_numCols = WXGRID_DEFAULT_NUMBER_COLS;
2666
2667     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
2668     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
2669
2670     if ( m_rowLabelWin )
2671     {
2672         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
2673     }
2674     else
2675     {
2676         m_labelBackgroundColour = wxColour( _T("WHITE") );
2677     }
2678
2679     m_labelTextColour = wxColour( _T("BLACK") );
2680
2681     // init attr cache
2682     m_attrCache.row = -1;
2683
2684     // TODO: something better than this ?
2685     //
2686     m_labelFont = this->GetFont();
2687     m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
2688
2689     m_rowLabelHorizAlign = wxLEFT;
2690     m_rowLabelVertAlign  = wxCENTRE;
2691
2692     m_colLabelHorizAlign = wxCENTRE;
2693     m_colLabelVertAlign  = wxTOP;
2694
2695     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
2696     m_defaultRowHeight = m_gridWin->GetCharHeight();
2697
2698 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
2699     m_defaultRowHeight += 8;
2700 #else
2701     m_defaultRowHeight += 4;
2702 #endif
2703
2704     m_gridLineColour = wxColour( 128, 128, 255 );
2705     m_gridLinesEnabled = TRUE;
2706
2707     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
2708     m_winCapture = (wxWindow *)NULL;
2709     m_canDragRowSize = TRUE;
2710     m_canDragColSize = TRUE;
2711     m_dragLastPos  = -1;
2712     m_dragRowOrCol = -1;
2713     m_isDragging = FALSE;
2714     m_startDragPos = wxDefaultPosition;
2715
2716     m_waitForSlowClick = FALSE;
2717
2718     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
2719     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
2720
2721     m_currentCellCoords = wxGridNoCellCoords;
2722
2723     m_selectedTopLeft = wxGridNoCellCoords;
2724     m_selectedBottomRight = wxGridNoCellCoords;
2725     m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
2726     m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2727
2728     m_editable = TRUE;  // default for whole grid
2729
2730     m_inOnKeyDown = FALSE;
2731     m_batchCount = 0;
2732 }
2733
2734 // ----------------------------------------------------------------------------
2735 // the idea is to call these functions only when necessary because they create
2736 // quite big arrays which eat memory mostly unnecessary - in particular, if
2737 // default widths/heights are used for all rows/columns, we may not use these
2738 // arrays at all
2739 //
2740 // with some extra code, it should be possible to only store the
2741 // widths/heights different from default ones but this will be done later...
2742 // ----------------------------------------------------------------------------
2743
2744 void wxGrid::InitRowHeights()
2745 {
2746     m_rowHeights.Empty();
2747     m_rowBottoms.Empty();
2748
2749     m_rowHeights.Alloc( m_numRows );
2750     m_rowBottoms.Alloc( m_numRows );
2751
2752     int rowBottom = 0;
2753     for ( int i = 0;  i < m_numRows;  i++ )
2754     {
2755         m_rowHeights.Add( m_defaultRowHeight );
2756         rowBottom += m_defaultRowHeight;
2757         m_rowBottoms.Add( rowBottom );
2758     }
2759 }
2760
2761 void wxGrid::InitColWidths()
2762 {
2763     m_colWidths.Empty();
2764     m_colRights.Empty();
2765
2766     m_colWidths.Alloc( m_numCols );
2767     m_colRights.Alloc( m_numCols );
2768     int colRight = 0;
2769     for ( int i = 0;  i < m_numCols;  i++ )
2770     {
2771         m_colWidths.Add( m_defaultColWidth );
2772         colRight += m_defaultColWidth;
2773         m_colRights.Add( colRight );
2774     }
2775 }
2776
2777 int wxGrid::GetColWidth(int col) const
2778 {
2779     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
2780 }
2781
2782 int wxGrid::GetColLeft(int col) const
2783 {
2784     return m_colRights.IsEmpty() ? col * m_defaultColWidth
2785                                  : m_colRights[col] - m_colWidths[col];
2786 }
2787
2788 int wxGrid::GetColRight(int col) const
2789 {
2790     return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
2791                                  : m_colRights[col];
2792 }
2793
2794 int wxGrid::GetRowHeight(int row) const
2795 {
2796     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
2797 }
2798
2799 int wxGrid::GetRowTop(int row) const
2800 {
2801     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
2802                                   : m_rowBottoms[row] - m_rowHeights[row];
2803 }
2804
2805 int wxGrid::GetRowBottom(int row) const
2806 {
2807     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
2808                                   : m_rowBottoms[row];
2809 }
2810
2811 void wxGrid::CalcDimensions()
2812 {
2813     int cw, ch;
2814     GetClientSize( &cw, &ch );
2815
2816     if ( m_numRows > 0  &&  m_numCols > 0 )
2817     {
2818         int right = GetColRight( m_numCols-1 ) + 50;
2819         int bottom = GetRowBottom( m_numRows-1 ) + 50;
2820
2821         // TODO: restore the scroll position that we had before sizing
2822         //
2823         int x, y;
2824         GetViewStart( &x, &y );
2825         SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
2826                        right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
2827                        x, y );
2828     }
2829 }
2830
2831
2832 void wxGrid::CalcWindowSizes()
2833 {
2834     int cw, ch;
2835     GetClientSize( &cw, &ch );
2836
2837     if ( m_cornerLabelWin->IsShown() )
2838         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
2839
2840     if ( m_colLabelWin->IsShown() )
2841         m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
2842
2843     if ( m_rowLabelWin->IsShown() )
2844         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
2845
2846     if ( m_gridWin->IsShown() )
2847         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
2848 }
2849
2850
2851 // this is called when the grid table sends a message to say that it
2852 // has been redimensioned
2853 //
2854 bool wxGrid::Redimension( wxGridTableMessage& msg )
2855 {
2856     int i;
2857
2858     // if we were using the default widths/heights so far, we must change them
2859     // now
2860     if ( m_colWidths.IsEmpty() )
2861     {
2862         InitColWidths();
2863     }
2864
2865     if ( m_rowHeights.IsEmpty() )
2866     {
2867         InitRowHeights();
2868     }
2869
2870     switch ( msg.GetId() )
2871     {
2872         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
2873         {
2874             size_t pos = msg.GetCommandInt();
2875             int numRows = msg.GetCommandInt2();
2876             for ( i = 0;  i < numRows;  i++ )
2877             {
2878                 m_rowHeights.Insert( m_defaultRowHeight, pos );
2879                 m_rowBottoms.Insert( 0, pos );
2880             }
2881             m_numRows += numRows;
2882
2883             int bottom = 0;
2884             if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
2885
2886             for ( i = pos;  i < m_numRows;  i++ )
2887             {
2888                 bottom += m_rowHeights[i];
2889                 m_rowBottoms[i] = bottom;
2890             }
2891             CalcDimensions();
2892         }
2893         return TRUE;
2894
2895         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
2896         {
2897             int numRows = msg.GetCommandInt();
2898             for ( i = 0;  i < numRows;  i++ )
2899             {
2900                 m_rowHeights.Add( m_defaultRowHeight );
2901                 m_rowBottoms.Add( 0 );
2902             }
2903
2904             int oldNumRows = m_numRows;
2905             m_numRows += numRows;
2906
2907             int bottom = 0;
2908             if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
2909
2910             for ( i = oldNumRows;  i < m_numRows;  i++ )
2911             {
2912                 bottom += m_rowHeights[i];
2913                 m_rowBottoms[i] = bottom;
2914             }
2915             CalcDimensions();
2916         }
2917         return TRUE;
2918
2919         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
2920         {
2921             size_t pos = msg.GetCommandInt();
2922             int numRows = msg.GetCommandInt2();
2923             for ( i = 0;  i < numRows;  i++ )
2924             {
2925                 m_rowHeights.Remove( pos );
2926                 m_rowBottoms.Remove( pos );
2927             }
2928             m_numRows -= numRows;
2929
2930             if ( !m_numRows )
2931             {
2932                 m_numCols = 0;
2933                 m_colWidths.Clear();
2934                 m_colRights.Clear();
2935                 m_currentCellCoords = wxGridNoCellCoords;
2936             }
2937             else
2938             {
2939                 if ( m_currentCellCoords.GetRow() >= m_numRows )
2940                     m_currentCellCoords.Set( 0, 0 );
2941
2942                 int h = 0;
2943                 for ( i = 0;  i < m_numRows;  i++ )
2944                 {
2945                     h += m_rowHeights[i];
2946                     m_rowBottoms[i] = h;
2947                 }
2948             }
2949
2950             CalcDimensions();
2951         }
2952         return TRUE;
2953
2954         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
2955         {
2956             size_t pos = msg.GetCommandInt();
2957             int numCols = msg.GetCommandInt2();
2958             for ( i = 0;  i < numCols;  i++ )
2959             {
2960                 m_colWidths.Insert( m_defaultColWidth, pos );
2961                 m_colRights.Insert( 0, pos );
2962             }
2963             m_numCols += numCols;
2964
2965             int right = 0;
2966             if ( pos > 0 ) right = m_colRights[pos-1];
2967
2968             for ( i = pos;  i < m_numCols;  i++ )
2969             {
2970                 right += m_colWidths[i];
2971                 m_colRights[i] = right;
2972             }
2973             CalcDimensions();
2974         }
2975         return TRUE;
2976
2977         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
2978         {
2979             int numCols = msg.GetCommandInt();
2980             for ( i = 0;  i < numCols;  i++ )
2981             {
2982                 m_colWidths.Add( m_defaultColWidth );
2983                 m_colRights.Add( 0 );
2984             }
2985
2986             int oldNumCols = m_numCols;
2987             m_numCols += numCols;
2988
2989             int right = 0;
2990             if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
2991
2992             for ( i = oldNumCols;  i < m_numCols;  i++ )
2993             {
2994                 right += m_colWidths[i];
2995                 m_colRights[i] = right;
2996             }
2997             CalcDimensions();
2998         }
2999         return TRUE;
3000
3001         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
3002         {
3003             size_t pos = msg.GetCommandInt();
3004             int numCols = msg.GetCommandInt2();
3005             for ( i = 0;  i < numCols;  i++ )
3006             {
3007                 m_colWidths.Remove( pos );
3008                 m_colRights.Remove( pos );
3009             }
3010             m_numCols -= numCols;
3011
3012             if ( !m_numCols )
3013             {
3014 #if 0  // leave the row alone here so that AppendCols will work subsequently
3015                 m_numRows = 0;
3016                 m_rowHeights.Clear();
3017                 m_rowBottoms.Clear();
3018 #endif
3019                 m_currentCellCoords = wxGridNoCellCoords;
3020             }
3021             else
3022             {
3023                 if ( m_currentCellCoords.GetCol() >= m_numCols )
3024                     m_currentCellCoords.Set( 0, 0 );
3025
3026                 int w = 0;
3027                 for ( i = 0;  i < m_numCols;  i++ )
3028                 {
3029                     w += m_colWidths[i];
3030                     m_colRights[i] = w;
3031                 }
3032             }
3033             CalcDimensions();
3034         }
3035         return TRUE;
3036     }
3037
3038     return FALSE;
3039 }
3040
3041
3042 void wxGrid::CalcRowLabelsExposed( wxRegion& reg )
3043 {
3044     wxRegionIterator iter( reg );
3045     wxRect r;
3046
3047     m_rowLabelsExposed.Empty();
3048
3049     int top, bottom;
3050     while ( iter )
3051     {
3052         r = iter.GetRect();
3053
3054         // TODO: remove this when we can...
3055         // There is a bug in wxMotif that gives garbage update
3056         // rectangles if you jump-scroll a long way by clicking the
3057         // scrollbar with middle button.  This is a work-around
3058         //
3059 #if defined(__WXMOTIF__)
3060         int cw, ch;
3061         m_gridWin->GetClientSize( &cw, &ch );
3062         if ( r.GetTop() > ch ) r.SetTop( 0 );
3063         r.SetBottom( wxMin( r.GetBottom(), ch ) );
3064 #endif
3065
3066         // logical bounds of update region
3067         //
3068         int dummy;
3069         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
3070         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
3071
3072         // find the row labels within these bounds
3073         //
3074         int row;
3075         for ( row = 0;  row < m_numRows;  row++ )
3076         {
3077             if ( GetRowBottom(row) < top )
3078                 continue;
3079
3080             if ( GetRowTop(row) > bottom )
3081                 break;
3082
3083             m_rowLabelsExposed.Add( row );
3084         }
3085
3086         iter++ ;
3087     }
3088 }
3089
3090
3091 void wxGrid::CalcColLabelsExposed( wxRegion& reg )
3092 {
3093     wxRegionIterator iter( reg );
3094     wxRect r;
3095
3096     m_colLabelsExposed.Empty();
3097
3098     int left, right;
3099     while ( iter )
3100     {
3101         r = iter.GetRect();
3102
3103         // TODO: remove this when we can...
3104         // There is a bug in wxMotif that gives garbage update
3105         // rectangles if you jump-scroll a long way by clicking the
3106         // scrollbar with middle button.  This is a work-around
3107         //
3108 #if defined(__WXMOTIF__)
3109         int cw, ch;
3110         m_gridWin->GetClientSize( &cw, &ch );
3111         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
3112         r.SetRight( wxMin( r.GetRight(), cw ) );
3113 #endif
3114
3115         // logical bounds of update region
3116         //
3117         int dummy;
3118         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
3119         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
3120
3121         // find the cells within these bounds
3122         //
3123         int col;
3124         for ( col = 0;  col < m_numCols;  col++ )
3125         {
3126             if ( GetColRight(col) < left )
3127                 continue;
3128
3129             if ( GetColLeft(col) > right )
3130                 break;
3131
3132             m_colLabelsExposed.Add( col );
3133         }
3134
3135         iter++ ;
3136     }
3137 }
3138
3139
3140 void wxGrid::CalcCellsExposed( wxRegion& reg )
3141 {
3142     wxRegionIterator iter( reg );
3143     wxRect r;
3144
3145     m_cellsExposed.Empty();
3146     m_rowsExposed.Empty();
3147     m_colsExposed.Empty();
3148
3149     int left, top, right, bottom;
3150     while ( iter )
3151     {
3152         r = iter.GetRect();
3153
3154         // TODO: remove this when we can...
3155         // There is a bug in wxMotif that gives garbage update
3156         // rectangles if you jump-scroll a long way by clicking the
3157         // scrollbar with middle button.  This is a work-around
3158         //
3159 #if defined(__WXMOTIF__)
3160         int cw, ch;
3161         m_gridWin->GetClientSize( &cw, &ch );
3162         if ( r.GetTop() > ch ) r.SetTop( 0 );
3163         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
3164         r.SetRight( wxMin( r.GetRight(), cw ) );
3165         r.SetBottom( wxMin( r.GetBottom(), ch ) );
3166 #endif
3167
3168         // logical bounds of update region
3169         //
3170         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
3171         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
3172
3173         // find the cells within these bounds
3174         //
3175         int row, col;
3176         for ( row = 0;  row < m_numRows;  row++ )
3177         {
3178             if ( GetRowBottom(row) <= top )
3179                 continue;
3180
3181             if ( GetRowTop(row) > bottom )
3182                 break;
3183
3184             m_rowsExposed.Add( row );
3185
3186             for ( col = 0;  col < m_numCols;  col++ )
3187             {
3188                 if ( GetColRight(col) <= left )
3189                     continue;
3190
3191                 if ( GetColLeft(col) > right )
3192                     break;
3193
3194                 if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
3195                     m_colsExposed.Add( col );
3196                 m_cellsExposed.Add( wxGridCellCoords( row, col ) );
3197             }
3198         }
3199
3200         iter++;
3201     }
3202 }
3203
3204
3205 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
3206 {
3207     int x, y, row;
3208     wxPoint pos( event.GetPosition() );
3209     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
3210
3211     if ( event.Dragging() )
3212     {
3213         m_isDragging = TRUE;
3214
3215         if ( event.LeftIsDown() )
3216         {
3217             switch( m_cursorMode )
3218             {
3219                 case WXGRID_CURSOR_RESIZE_ROW:
3220                 {
3221                     int cw, ch, left, dummy;
3222                     m_gridWin->GetClientSize( &cw, &ch );
3223                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
3224
3225                     wxClientDC dc( m_gridWin );
3226                     PrepareDC( dc );
3227                     y = wxMax( y, GetRowTop(m_dragRowOrCol) + WXGRID_MIN_ROW_HEIGHT );
3228                     dc.SetLogicalFunction(wxINVERT);
3229                     if ( m_dragLastPos >= 0 )
3230                     {
3231                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
3232                     }
3233                     dc.DrawLine( left, y, left+cw, y );
3234                     m_dragLastPos = y;
3235                 }
3236                 break;
3237
3238                 case WXGRID_CURSOR_SELECT_ROW:
3239                     if ( (row = YToRow( y )) >= 0  &&
3240                          !IsInSelection( row, 0 ) )
3241                     {
3242                         SelectRow( row, TRUE );
3243                     }
3244
3245                 // default label to suppress warnings about "enumeration value
3246                 // 'xxx' not handled in switch
3247                 default:
3248                     break;
3249             }
3250         }
3251         return;
3252     }
3253
3254     m_isDragging = FALSE;
3255
3256
3257     // ------------ Entering or leaving the window
3258     //
3259     if ( event.Entering() || event.Leaving() )
3260     {
3261         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
3262     }
3263
3264
3265     // ------------ Left button pressed
3266     //
3267     else if ( event.LeftDown() )
3268     {
3269         // don't send a label click event for a hit on the
3270         // edge of the row label - this is probably the user
3271         // wanting to resize the row
3272         //
3273         if ( YToEdgeOfRow(y) < 0 )
3274         {
3275             row = YToRow(y);
3276             if ( row >= 0  &&
3277                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
3278             {
3279                 SelectRow( row, event.ShiftDown() );
3280                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
3281             }
3282         }
3283         else
3284         {
3285             // starting to drag-resize a row
3286             //
3287             if ( CanDragRowSize() )
3288                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
3289         }
3290     }
3291
3292
3293     // ------------ Left double click
3294     //
3295     else if (event.LeftDClick() )
3296     {
3297         if ( YToEdgeOfRow(y) < 0 )
3298         {
3299             row = YToRow(y);
3300             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
3301         }
3302     }
3303
3304
3305     // ------------ Left button released
3306     //
3307     else if ( event.LeftUp() )
3308     {
3309         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3310         {
3311             DoEndDragResizeRow();
3312
3313             // Note: we are ending the event *after* doing
3314             // default processing in this case
3315             //
3316             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
3317         }
3318
3319         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
3320         m_dragLastPos = -1;
3321     }
3322
3323
3324     // ------------ Right button down
3325     //
3326     else if ( event.RightDown() )
3327     {
3328         row = YToRow(y);
3329         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
3330         {
3331             // no default action at the moment
3332         }
3333     }
3334
3335
3336     // ------------ Right double click
3337     //
3338     else if ( event.RightDClick() )
3339     {
3340         row = YToRow(y);
3341         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
3342         {
3343             // no default action at the moment
3344         }
3345     }
3346
3347
3348     // ------------ No buttons down and mouse moving
3349     //
3350     else if ( event.Moving() )
3351     {
3352         m_dragRowOrCol = YToEdgeOfRow( y );
3353         if ( m_dragRowOrCol >= 0 )
3354         {
3355             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3356             {
3357                 // don't capture the mouse yet
3358                 if ( CanDragRowSize() )
3359                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
3360             }
3361         }
3362         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3363         {
3364             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
3365         }
3366     }
3367 }
3368
3369
3370 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
3371 {
3372     int x, y, col;
3373     wxPoint pos( event.GetPosition() );
3374     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
3375
3376     if ( event.Dragging() )
3377     {
3378         m_isDragging = TRUE;
3379
3380         if ( event.LeftIsDown() )
3381         {
3382             switch( m_cursorMode )
3383             {
3384                 case WXGRID_CURSOR_RESIZE_COL:
3385                 {
3386                     int cw, ch, dummy, top;
3387                     m_gridWin->GetClientSize( &cw, &ch );
3388                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
3389
3390                     wxClientDC dc( m_gridWin );
3391                     PrepareDC( dc );
3392
3393                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
3394                                   GetColMinimalWidth(m_dragRowOrCol));
3395                     dc.SetLogicalFunction(wxINVERT);
3396                     if ( m_dragLastPos >= 0 )
3397                     {
3398                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
3399                     }
3400                     dc.DrawLine( x, top, x, top+ch );
3401                     m_dragLastPos = x;
3402                 }
3403                 break;
3404
3405                 case WXGRID_CURSOR_SELECT_COL:
3406                     if ( (col = XToCol( x )) >= 0  &&
3407                          !IsInSelection( 0, col ) )
3408                     {
3409                         SelectCol( col, TRUE );
3410                     }
3411
3412                 // default label to suppress warnings about "enumeration value
3413                 // 'xxx' not handled in switch
3414                 default:
3415                     break;
3416             }
3417         }
3418         return;
3419     }
3420
3421     m_isDragging = FALSE;
3422
3423
3424     // ------------ Entering or leaving the window
3425     //
3426     if ( event.Entering() || event.Leaving() )
3427     {
3428         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
3429     }
3430
3431
3432     // ------------ Left button pressed
3433     //
3434     else if ( event.LeftDown() )
3435     {
3436         // don't send a label click event for a hit on the
3437         // edge of the col label - this is probably the user
3438         // wanting to resize the col
3439         //
3440         if ( XToEdgeOfCol(x) < 0 )
3441         {
3442             col = XToCol(x);
3443             if ( col >= 0  &&
3444                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
3445             {
3446                 SelectCol( col, event.ShiftDown() );
3447                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
3448             }
3449         }
3450         else
3451         {
3452             // starting to drag-resize a col
3453             //
3454             if ( CanDragColSize() )
3455                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
3456         }
3457     }
3458
3459
3460     // ------------ Left double click
3461     //
3462     if ( event.LeftDClick() )
3463     {
3464         if ( XToEdgeOfCol(x) < 0 )
3465         {
3466             col = XToCol(x);
3467             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
3468         }
3469     }
3470
3471
3472     // ------------ Left button released
3473     //
3474     else if ( event.LeftUp() )
3475     {
3476         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3477         {
3478             DoEndDragResizeCol();
3479
3480             // Note: we are ending the event *after* doing
3481             // default processing in this case
3482             //
3483             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
3484         }
3485
3486         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
3487         m_dragLastPos  = -1;
3488     }
3489
3490
3491     // ------------ Right button down
3492     //
3493     else if ( event.RightDown() )
3494     {
3495         col = XToCol(x);
3496         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
3497         {
3498             // no default action at the moment
3499         }
3500     }
3501
3502
3503     // ------------ Right double click
3504     //
3505     else if ( event.RightDClick() )
3506     {
3507         col = XToCol(x);
3508         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
3509         {
3510             // no default action at the moment
3511         }
3512     }
3513
3514
3515     // ------------ No buttons down and mouse moving
3516     //
3517     else if ( event.Moving() )
3518     {
3519         m_dragRowOrCol = XToEdgeOfCol( x );
3520         if ( m_dragRowOrCol >= 0 )
3521         {
3522             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3523             {
3524                 // don't capture the cursor yet
3525                 if ( CanDragColSize() )
3526                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
3527             }
3528         }
3529         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3530         {
3531             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
3532         }
3533     }
3534 }
3535
3536
3537 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
3538 {
3539     if ( event.LeftDown() )
3540     {
3541         // indicate corner label by having both row and
3542         // col args == -1
3543         //
3544         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
3545         {
3546             SelectAll();
3547         }
3548     }
3549
3550     else if ( event.LeftDClick() )
3551     {
3552         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
3553     }
3554
3555     else if ( event.RightDown() )
3556     {
3557         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
3558         {
3559             // no default action at the moment
3560         }
3561     }
3562
3563     else if ( event.RightDClick() )
3564     {
3565         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
3566         {
3567             // no default action at the moment
3568         }
3569     }
3570 }
3571
3572 void wxGrid::ChangeCursorMode(CursorMode mode,
3573                               wxWindow *win,
3574                               bool captureMouse)
3575 {
3576 #ifdef __WXDEBUG__
3577     static const wxChar *cursorModes[] =
3578     {
3579         _T("SELECT_CELL"),
3580         _T("RESIZE_ROW"),
3581         _T("RESIZE_COL"),
3582         _T("SELECT_ROW"),
3583         _T("SELECT_COL")
3584     };
3585
3586     wxLogTrace(_T("grid"),
3587                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
3588                win == m_colLabelWin ? _T("colLabelWin")
3589                                     : win ? _T("rowLabelWin")
3590                                           : _T("gridWin"),
3591                cursorModes[m_cursorMode], cursorModes[mode]);
3592 #endif // __WXDEBUG__
3593
3594     if ( mode == m_cursorMode )
3595         return;
3596
3597     if ( !win )
3598     {
3599         // by default use the grid itself
3600         win = m_gridWin;
3601     }
3602
3603     if ( m_winCapture )
3604     {
3605         m_winCapture->ReleaseMouse();
3606         m_winCapture = (wxWindow *)NULL;
3607     }
3608
3609     m_cursorMode = mode;
3610
3611     switch ( m_cursorMode )
3612     {
3613         case WXGRID_CURSOR_RESIZE_ROW:
3614             win->SetCursor( m_rowResizeCursor );
3615             break;
3616
3617         case WXGRID_CURSOR_RESIZE_COL:
3618             win->SetCursor( m_colResizeCursor );
3619             break;
3620
3621         default:
3622             win->SetCursor( *wxSTANDARD_CURSOR );
3623     }
3624
3625     // we need to capture mouse when resizing
3626     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
3627                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
3628
3629     if ( captureMouse && resize )
3630     {
3631         win->CaptureMouse();
3632         m_winCapture = win;
3633     }
3634 }
3635
3636 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
3637 {
3638     int x, y;
3639     wxPoint pos( event.GetPosition() );
3640     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
3641
3642     wxGridCellCoords coords;
3643     XYToCell( x, y, coords );
3644
3645     if ( event.Dragging() )
3646     {
3647         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
3648
3649         // Don't start doing anything until the mouse has been drug at
3650         // least 3 pixels in any direction...
3651         if (! m_isDragging)
3652         {
3653             if (m_startDragPos == wxDefaultPosition)
3654             {
3655                 m_startDragPos = pos;
3656                 return;
3657             }
3658             if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
3659                 return;
3660         }
3661
3662         m_isDragging = TRUE;
3663         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3664         {
3665             // Hide the edit control, so it
3666             // won't interfer with drag-shrinking.
3667             if ( IsCellEditControlEnabled() )
3668                 HideCellEditControl();
3669
3670             // Have we captured the mouse yet?
3671             if (! m_winCapture)
3672             {
3673                 m_winCapture = m_gridWin;
3674                 m_winCapture->CaptureMouse();
3675             }
3676
3677             if ( coords != wxGridNoCellCoords )
3678             {
3679                 if ( !IsSelection() )
3680                 {
3681                     SelectBlock( coords, coords );
3682                 }
3683                 else
3684                 {
3685                     SelectBlock( m_currentCellCoords, coords );
3686                 }
3687
3688                 if (! IsVisible(coords))
3689                 {
3690                     MakeCellVisible(coords);
3691                     // TODO: need to introduce a delay or something here.  The
3692                     // scrolling is way to fast, at least on MSW.
3693                 }
3694             }
3695         }
3696         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3697         {
3698             int cw, ch, left, dummy;
3699             m_gridWin->GetClientSize( &cw, &ch );
3700             CalcUnscrolledPosition( 0, 0, &left, &dummy );
3701
3702             wxClientDC dc( m_gridWin );
3703             PrepareDC( dc );
3704             y = wxMax( y, GetRowTop(m_dragRowOrCol) + WXGRID_MIN_ROW_HEIGHT );
3705             dc.SetLogicalFunction(wxINVERT);
3706             if ( m_dragLastPos >= 0 )
3707             {
3708                 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
3709             }
3710             dc.DrawLine( left, y, left+cw, y );
3711             m_dragLastPos = y;
3712         }
3713         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3714         {
3715             int cw, ch, dummy, top;
3716             m_gridWin->GetClientSize( &cw, &ch );
3717             CalcUnscrolledPosition( 0, 0, &dummy, &top );
3718
3719             wxClientDC dc( m_gridWin );
3720             PrepareDC( dc );
3721             x = wxMax( x, GetColLeft(m_dragRowOrCol) +
3722                           GetColMinimalWidth(m_dragRowOrCol) );
3723             dc.SetLogicalFunction(wxINVERT);
3724             if ( m_dragLastPos >= 0 )
3725             {
3726                 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
3727             }
3728             dc.DrawLine( x, top, x, top+ch );
3729             m_dragLastPos = x;
3730         }
3731
3732         return;
3733     }
3734
3735     m_isDragging = FALSE;
3736     m_startDragPos = wxDefaultPosition;
3737
3738
3739     if ( coords != wxGridNoCellCoords )
3740     {
3741         // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
3742         //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
3743         //     wxGTK
3744 #if 0
3745         if ( event.Entering() || event.Leaving() )
3746         {
3747             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3748             m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
3749         }
3750         else
3751 #endif // 0
3752
3753         // ------------ Left button pressed
3754         //
3755         if ( event.LeftDown() )
3756         {
3757             DisableCellEditControl();
3758             if ( event.ShiftDown() )
3759             {
3760                 SelectBlock( m_currentCellCoords, coords );
3761             }
3762             else if ( XToEdgeOfCol(x) < 0  &&
3763                       YToEdgeOfRow(y) < 0 )
3764             {
3765                 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
3766                                  coords.GetRow(),
3767                                  coords.GetCol(),
3768                                  event ) )
3769                 {
3770                     MakeCellVisible( coords );
3771
3772                     // if this is the second click on this cell then start
3773                     // the edit control
3774                     if ( m_waitForSlowClick &&
3775                          (coords == m_currentCellCoords) &&
3776                          CanEnableCellControl())
3777                     {
3778                         EnableCellEditControl();
3779
3780                         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
3781                         attr->GetEditor(GetDefaultEditorForCell(coords.GetRow(), coords.GetCol()))->StartingClick();
3782                         attr->DecRef();
3783
3784                         m_waitForSlowClick = FALSE;
3785                     }
3786                     else
3787                     {
3788                         SetCurrentCell( coords );
3789                         m_waitForSlowClick = TRUE;
3790                     }
3791                 }
3792             }
3793         }
3794
3795
3796         // ------------ Left double click
3797         //
3798         else if ( event.LeftDClick() )
3799         {
3800             DisableCellEditControl();
3801             if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
3802             {
3803                 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
3804                            coords.GetRow(),
3805                            coords.GetCol(),
3806                            event );
3807             }
3808         }
3809
3810
3811         // ------------ Left button released
3812         //
3813         else if ( event.LeftUp() )
3814         {
3815             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3816             {
3817                 if ( IsSelection() )
3818                 {
3819                     if (m_winCapture)
3820                     {
3821                         m_winCapture->ReleaseMouse();
3822                         m_winCapture = NULL;
3823                     }
3824                     SendEvent( wxEVT_GRID_RANGE_SELECT, -1, -1, event );
3825                 }
3826
3827                 // Show the edit control, if it has been hidden for
3828                 // drag-shrinking.
3829                 ShowCellEditControl();
3830             }
3831             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3832             {
3833                 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3834                 DoEndDragResizeRow();
3835
3836                 // Note: we are ending the event *after* doing
3837                 // default processing in this case
3838                 //
3839                 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
3840             }
3841             else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3842             {
3843                 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3844                 DoEndDragResizeCol();
3845
3846                 // Note: we are ending the event *after* doing
3847                 // default processing in this case
3848                 //
3849                 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
3850             }
3851
3852             m_dragLastPos = -1;
3853         }
3854
3855
3856         // ------------ Right button down
3857         //
3858         else if ( event.RightDown() )
3859         {
3860             DisableCellEditControl();
3861             if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
3862                              coords.GetRow(),
3863                              coords.GetCol(),
3864                              event ) )
3865             {
3866                 // no default action at the moment
3867             }
3868         }
3869
3870
3871         // ------------ Right double click
3872         //
3873         else if ( event.RightDClick() )
3874         {
3875             DisableCellEditControl();
3876             if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
3877                              coords.GetRow(),
3878                              coords.GetCol(),
3879                              event ) )
3880             {
3881                 // no default action at the moment
3882             }
3883         }
3884
3885         // ------------ Moving and no button action
3886         //
3887         else if ( event.Moving() && !event.IsButton() )
3888         {
3889             int dragRow = YToEdgeOfRow( y );
3890             int dragCol = XToEdgeOfCol( x );
3891
3892             // Dragging on the corner of a cell to resize in both
3893             // directions is not implemented yet...
3894             //
3895             if ( dragRow >= 0  &&  dragCol >= 0 )
3896             {
3897                 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3898                 return;
3899             }
3900
3901             if ( dragRow >= 0 )
3902             {
3903                 m_dragRowOrCol = dragRow;
3904
3905                 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3906                 {
3907                     if ( CanDragRowSize() )
3908                         ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
3909                 }
3910
3911                 return;
3912             }
3913
3914             if ( dragCol >= 0 )
3915             {
3916                 m_dragRowOrCol = dragCol;
3917
3918                 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3919                 {
3920                     if ( CanDragColSize() )
3921                         ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
3922                 }
3923
3924                 return;
3925             }
3926
3927             // Neither on a row or col edge
3928             //
3929             if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3930             {
3931                 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3932             }
3933         }
3934     }
3935 }
3936
3937
3938 void wxGrid::DoEndDragResizeRow()
3939 {
3940     if ( m_dragLastPos >= 0 )
3941     {
3942         // erase the last line and resize the row
3943         //
3944         int cw, ch, left, dummy;
3945         m_gridWin->GetClientSize( &cw, &ch );
3946         CalcUnscrolledPosition( 0, 0, &left, &dummy );
3947
3948         wxClientDC dc( m_gridWin );
3949         PrepareDC( dc );
3950         dc.SetLogicalFunction( wxINVERT );
3951         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
3952         HideCellEditControl();
3953
3954         int rowTop = GetRowTop(m_dragRowOrCol);
3955         SetRowSize( m_dragRowOrCol,
3956                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
3957
3958         if ( !GetBatchCount() )
3959         {
3960             // Only needed to get the correct rect.y:
3961             wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
3962             rect.x = 0;
3963             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
3964             rect.width = m_rowLabelWidth;
3965             rect.height = ch - rect.y;
3966             m_rowLabelWin->Refresh( TRUE, &rect );
3967             rect.width = cw;
3968             m_gridWin->Refresh( FALSE, &rect );
3969         }
3970
3971         ShowCellEditControl();
3972     }
3973 }
3974
3975
3976 void wxGrid::DoEndDragResizeCol()
3977 {
3978     if ( m_dragLastPos >= 0 )
3979     {
3980         // erase the last line and resize the col
3981         //
3982         int cw, ch, dummy, top;
3983         m_gridWin->GetClientSize( &cw, &ch );
3984         CalcUnscrolledPosition( 0, 0, &dummy, &top );
3985
3986         wxClientDC dc( m_gridWin );
3987         PrepareDC( dc );
3988         dc.SetLogicalFunction( wxINVERT );
3989         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
3990         HideCellEditControl();
3991
3992         int colLeft = GetColLeft(m_dragRowOrCol);
3993         SetColSize( m_dragRowOrCol,
3994                     wxMax( m_dragLastPos - colLeft,
3995                            GetColMinimalWidth(m_dragRowOrCol) ) );
3996
3997         if ( !GetBatchCount() )
3998         {
3999             // Only needed to get the correct rect.x:
4000             wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
4001             rect.y = 0;
4002             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
4003             rect.width = cw - rect.x;
4004             rect.height = m_colLabelHeight;
4005             m_colLabelWin->Refresh( TRUE, &rect );
4006             rect.height = ch;
4007             m_gridWin->Refresh( FALSE, &rect );
4008         }
4009
4010         ShowCellEditControl();
4011     }
4012 }
4013
4014
4015
4016 //
4017 // ------ interaction with data model
4018 //
4019 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
4020 {
4021     switch ( msg.GetId() )
4022     {
4023         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
4024             return GetModelValues();
4025
4026         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4027             return SetModelValues();
4028
4029         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4030         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4031         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4032         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4033         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4034         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4035             return Redimension( msg );
4036
4037         default:
4038             return FALSE;
4039     }
4040 }
4041
4042
4043
4044 // The behaviour of this function depends on the grid table class
4045 // Clear() function.  For the default wxGridStringTable class the
4046 // behavious is to replace all cell contents with wxEmptyString but
4047 // not to change the number of rows or cols.
4048 //
4049 void wxGrid::ClearGrid()
4050 {
4051     if ( m_table )
4052     {
4053         m_table->Clear();
4054         SetEditControlValue();
4055         if ( !GetBatchCount() ) m_gridWin->Refresh();
4056     }
4057 }
4058
4059
4060 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
4061 {
4062     // TODO: something with updateLabels flag
4063
4064     if ( !m_created )
4065     {
4066         wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
4067         return FALSE;
4068     }
4069
4070     if ( m_table )
4071     {
4072         if (IsCellEditControlEnabled())
4073             DisableCellEditControl();
4074
4075         bool ok = m_table->InsertRows( pos, numRows );
4076
4077         // the table will have sent the results of the insert row
4078         // operation to this view object as a grid table message
4079         //
4080         if ( ok )
4081         {
4082             if ( m_numCols == 0 )
4083             {
4084                 m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
4085                 //
4086                 // TODO: perhaps instead of appending the default number of cols
4087                 // we should remember what the last non-zero number of cols was ?
4088                 //
4089             }
4090
4091             if ( m_currentCellCoords == wxGridNoCellCoords )
4092             {
4093                 // if we have just inserted cols into an empty grid the current
4094                 // cell will be undefined...
4095                 //
4096                 SetCurrentCell( 0, 0 );
4097             }
4098
4099             ClearSelection();
4100             if ( !GetBatchCount() ) Refresh();
4101         }
4102
4103         SetEditControlValue();
4104         return ok;
4105     }
4106     else
4107     {
4108         return FALSE;
4109     }
4110 }
4111
4112
4113 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
4114 {
4115     // TODO: something with updateLabels flag
4116
4117     if ( !m_created )
4118     {
4119         wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
4120         return FALSE;
4121     }
4122
4123     if ( m_table && m_table->AppendRows( numRows ) )
4124     {
4125         if ( m_currentCellCoords == wxGridNoCellCoords )
4126         {
4127             // if we have just inserted cols into an empty grid the current
4128             // cell will be undefined...
4129             //
4130             SetCurrentCell( 0, 0 );
4131         }
4132
4133         // the table will have sent the results of the append row
4134         // operation to this view object as a grid table message
4135         //
4136         ClearSelection();
4137         if ( !GetBatchCount() ) Refresh();
4138         return TRUE;
4139     }
4140     else
4141     {
4142         return FALSE;
4143     }
4144 }
4145
4146
4147 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
4148 {
4149     // TODO: something with updateLabels flag
4150
4151     if ( !m_created )
4152     {
4153         wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
4154         return FALSE;
4155     }
4156
4157     if ( m_table )
4158     {
4159         if (IsCellEditControlEnabled())
4160             DisableCellEditControl();
4161
4162         if (m_table->DeleteRows( pos, numRows ))
4163         {
4164
4165             // the table will have sent the results of the delete row
4166             // operation to this view object as a grid table message
4167             //
4168             ClearSelection();
4169             if ( !GetBatchCount() ) Refresh();
4170             return TRUE;
4171         }
4172     }
4173     return FALSE;
4174 }
4175
4176
4177 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
4178 {
4179     // TODO: something with updateLabels flag
4180
4181     if ( !m_created )
4182     {
4183         wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
4184         return FALSE;
4185     }
4186
4187     if ( m_table )
4188     {
4189         if (IsCellEditControlEnabled())
4190             DisableCellEditControl();
4191
4192         bool ok = m_table->InsertCols( pos, numCols );
4193
4194         // the table will have sent the results of the insert col
4195         // operation to this view object as a grid table message
4196         //
4197         if ( ok )
4198         {
4199             if ( m_currentCellCoords == wxGridNoCellCoords )
4200             {
4201                 // if we have just inserted cols into an empty grid the current
4202                 // cell will be undefined...
4203                 //
4204                 SetCurrentCell( 0, 0 );
4205             }
4206
4207             ClearSelection();
4208             if ( !GetBatchCount() ) Refresh();
4209         }
4210
4211         SetEditControlValue();
4212         return ok;
4213     }
4214     else
4215     {
4216         return FALSE;
4217     }
4218 }
4219
4220
4221 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
4222 {
4223     // TODO: something with updateLabels flag
4224
4225     if ( !m_created )
4226     {
4227         wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
4228         return FALSE;
4229     }
4230
4231     if ( m_table && m_table->AppendCols( numCols ) )
4232     {
4233         // the table will have sent the results of the append col
4234         // operation to this view object as a grid table message
4235         //
4236         if ( m_currentCellCoords == wxGridNoCellCoords )
4237         {
4238             // if we have just inserted cols into an empty grid the current
4239             // cell will be undefined...
4240             //
4241             SetCurrentCell( 0, 0 );
4242         }
4243
4244         ClearSelection();
4245         if ( !GetBatchCount() ) Refresh();
4246         return TRUE;
4247     }
4248     else
4249     {
4250         return FALSE;
4251     }
4252 }
4253
4254
4255 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
4256 {
4257     // TODO: something with updateLabels flag
4258
4259     if ( !m_created )
4260     {
4261         wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
4262         return FALSE;
4263     }
4264
4265     if ( m_table )
4266     {
4267         if (IsCellEditControlEnabled())
4268             DisableCellEditControl();
4269
4270         if ( m_table->DeleteCols( pos, numCols ) )
4271         {
4272             // the table will have sent the results of the delete col
4273             // operation to this view object as a grid table message
4274             //
4275             ClearSelection();
4276             if ( !GetBatchCount() ) Refresh();
4277             return TRUE;
4278         }
4279     }
4280     return FALSE;
4281 }
4282
4283
4284
4285 //
4286 // ----- event handlers
4287 //
4288
4289 // Generate a grid event based on a mouse event and
4290 // return the result of ProcessEvent()
4291 //
4292 bool wxGrid::SendEvent( const wxEventType type,
4293                         int row, int col,
4294                         wxMouseEvent& mouseEv )
4295 {
4296     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
4297     {
4298         int rowOrCol = (row == -1 ? col : row);
4299
4300         wxGridSizeEvent gridEvt( GetId(),
4301                                  type,
4302                                  this,
4303                                  rowOrCol,
4304                                  mouseEv.GetX(), mouseEv.GetY(),
4305                                  mouseEv.ControlDown(),
4306                                  mouseEv.ShiftDown(),
4307                                  mouseEv.AltDown(),
4308                                  mouseEv.MetaDown() );
4309
4310         return GetEventHandler()->ProcessEvent(gridEvt);
4311     }
4312     else if ( type == wxEVT_GRID_RANGE_SELECT )
4313     {
4314         wxGridRangeSelectEvent gridEvt( GetId(),
4315                                         type,
4316                                         this,
4317                                         m_selectedTopLeft,
4318                                         m_selectedBottomRight,
4319                                         mouseEv.ControlDown(),
4320                                         mouseEv.ShiftDown(),
4321                                         mouseEv.AltDown(),
4322                                         mouseEv.MetaDown() );
4323
4324         return GetEventHandler()->ProcessEvent(gridEvt);
4325     }
4326     else
4327     {
4328         wxGridEvent gridEvt( GetId(),
4329                              type,
4330                              this,
4331                              row, col,
4332                              mouseEv.GetX(), mouseEv.GetY(),
4333                              mouseEv.ControlDown(),
4334                              mouseEv.ShiftDown(),
4335                              mouseEv.AltDown(),
4336                              mouseEv.MetaDown() );
4337
4338         return GetEventHandler()->ProcessEvent(gridEvt);
4339     }
4340 }
4341
4342
4343 // Generate a grid event of specified type and return the result
4344 // of ProcessEvent().
4345 //
4346 bool wxGrid::SendEvent( const wxEventType type,
4347                         int row, int col )
4348 {
4349     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
4350     {
4351         int rowOrCol = (row == -1 ? col : row);
4352
4353         wxGridSizeEvent gridEvt( GetId(),
4354                                  type,
4355                                  this,
4356                                  rowOrCol );
4357
4358         return GetEventHandler()->ProcessEvent(gridEvt);
4359     }
4360     else
4361     {
4362         wxGridEvent gridEvt( GetId(),
4363                              type,
4364                              this,
4365                              row, col );
4366
4367         return GetEventHandler()->ProcessEvent(gridEvt);
4368     }
4369 }
4370
4371
4372 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
4373 {
4374     wxPaintDC dc( this );
4375
4376     if ( m_currentCellCoords == wxGridNoCellCoords  &&
4377          m_numRows && m_numCols )
4378     {
4379         m_currentCellCoords.Set(0, 0);
4380         SetEditControlValue();
4381         ShowCellEditControl();
4382     }
4383
4384     m_displayed = TRUE;
4385 }
4386
4387
4388 // This is just here to make sure that CalcDimensions gets called when
4389 // the grid view is resized... then the size event is skipped to allow
4390 // the box sizers to handle everything
4391 //
4392 void wxGrid::OnSize( wxSizeEvent& event )
4393 {
4394     CalcWindowSizes();
4395     CalcDimensions();
4396 }
4397
4398
4399 void wxGrid::OnKeyDown( wxKeyEvent& event )
4400 {
4401     if ( m_inOnKeyDown )
4402     {
4403         // shouldn't be here - we are going round in circles...
4404         //
4405         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
4406     }
4407
4408     m_inOnKeyDown = TRUE;
4409
4410     // propagate the event up and see if it gets processed
4411     //
4412     wxWindow *parent = GetParent();
4413     wxKeyEvent keyEvt( event );
4414     keyEvt.SetEventObject( parent );
4415
4416     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
4417     {
4418
4419         // TODO:  Should also support Shift-cursor keys for
4420         //        extending the selection.  Maybe add a flag to
4421         //        MoveCursorXXX() and MoveCursorXXXBlock() and
4422         //        just send event.ShiftDown().
4423
4424         // try local handlers
4425         //
4426         switch ( event.KeyCode() )
4427         {
4428             case WXK_UP:
4429                 if ( event.ControlDown() )
4430                 {
4431                     MoveCursorUpBlock();
4432                 }
4433                 else
4434                 {
4435                     MoveCursorUp();
4436                 }
4437                 break;
4438
4439             case WXK_DOWN:
4440                 if ( event.ControlDown() )
4441                 {
4442                     MoveCursorDownBlock();
4443                 }
4444                 else
4445                 {
4446                     MoveCursorDown();
4447                 }
4448                 break;
4449
4450             case WXK_LEFT:
4451                 if ( event.ControlDown() )
4452                 {
4453                     MoveCursorLeftBlock();
4454                 }
4455                 else
4456                 {
4457                     MoveCursorLeft();
4458                 }
4459                 break;
4460
4461             case WXK_RIGHT:
4462                 if ( event.ControlDown() )
4463                 {
4464                     MoveCursorRightBlock();
4465                 }
4466                 else
4467                 {
4468                     MoveCursorRight();
4469                 }
4470                 break;
4471
4472             case WXK_RETURN:
4473                 if ( event.ControlDown() )
4474                 {
4475                     event.Skip();  // to let the edit control have the return
4476                 }
4477                 else
4478                 {
4479                     MoveCursorDown();
4480                 }
4481                 break;
4482
4483             case WXK_TAB:
4484                 if (event.ShiftDown())
4485                     MoveCursorLeft();
4486                 else
4487                     MoveCursorRight();
4488                 break;
4489
4490             case WXK_HOME:
4491                 if ( event.ControlDown() )
4492                 {
4493                     MakeCellVisible( 0, 0 );
4494                     SetCurrentCell( 0, 0 );
4495                 }
4496                 else
4497                 {
4498                     event.Skip();
4499                 }
4500                 break;
4501
4502             case WXK_END:
4503                 if ( event.ControlDown() )
4504                 {
4505                     MakeCellVisible( m_numRows-1, m_numCols-1 );
4506                     SetCurrentCell( m_numRows-1, m_numCols-1 );
4507                 }
4508                 else
4509                 {
4510                     event.Skip();
4511                 }
4512                 break;
4513
4514             case WXK_PRIOR:
4515                 MovePageUp();
4516                 break;
4517
4518             case WXK_NEXT:
4519                 MovePageDown();
4520                 break;
4521
4522             // We don't want these keys to trigger the edit control, any others?
4523             case WXK_SHIFT:
4524             case WXK_ALT:
4525             case WXK_CONTROL:
4526             case WXK_CAPITAL:
4527                 event.Skip();
4528                 break;
4529
4530             case WXK_SPACE:
4531                 if ( !IsEditable() )
4532                 {
4533                     MoveCursorRight();
4534                     break;
4535                 }
4536                 // Otherwise fall through to default
4537
4538             default:
4539                 // now try the cell edit control
4540                 //
4541                 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
4542                 {
4543                     EnableCellEditControl();
4544                     int row = m_currentCellCoords.GetRow();
4545                     int col = m_currentCellCoords.GetCol();
4546                     wxGridCellAttr* attr = GetCellAttr(row, col);
4547                     attr->GetEditor(GetDefaultEditorForCell(row, col))->StartingKey(event);
4548                     attr->DecRef();
4549                 }
4550                 else
4551                 {
4552                     // let others process char events for readonly cells
4553                     event.Skip();
4554                 }
4555                 break;
4556         }
4557     }
4558
4559     m_inOnKeyDown = FALSE;
4560 }
4561
4562
4563 void wxGrid::OnEraseBackground(wxEraseEvent&)
4564 {
4565 }
4566
4567 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
4568 {
4569     if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
4570     {
4571         // the event has been intercepted - do nothing
4572         return;
4573     }
4574
4575     if ( m_displayed  &&
4576          m_currentCellCoords != wxGridNoCellCoords )
4577     {
4578         HideCellEditControl();
4579         SaveEditControlValue();
4580         DisableCellEditControl();
4581
4582         // Clear the old current cell highlight
4583         wxRect r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
4584
4585         // Otherwise refresh redraws the highlight!
4586         m_currentCellCoords = coords;
4587
4588         m_gridWin->Refresh( FALSE, &r );
4589     }
4590
4591     m_currentCellCoords = coords;
4592
4593     SetEditControlValue();
4594
4595     if ( m_displayed )
4596     {
4597         wxClientDC dc(m_gridWin);
4598         PrepareDC(dc);
4599
4600         wxGridCellAttr* attr = GetCellAttr(coords);
4601         DrawCellHighlight(dc, attr);
4602         attr->DecRef();
4603
4604         if ( IsSelection() )
4605         {
4606             wxRect r( SelectionToDeviceRect() );
4607             ClearSelection();
4608             if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
4609         }
4610     }
4611 }
4612
4613
4614 //
4615 // ------ functions to get/send data (see also public functions)
4616 //
4617
4618 bool wxGrid::GetModelValues()
4619 {
4620     if ( m_table )
4621     {
4622         // all we need to do is repaint the grid
4623         //
4624         m_gridWin->Refresh();
4625         return TRUE;
4626     }
4627
4628     return FALSE;
4629 }
4630
4631
4632 bool wxGrid::SetModelValues()
4633 {
4634     int row, col;
4635
4636     if ( m_table )
4637     {
4638         for ( row = 0;  row < m_numRows;  row++ )
4639         {
4640             for ( col = 0;  col < m_numCols;  col++ )
4641             {
4642                 m_table->SetValue( row, col, GetCellValue(row, col) );
4643             }
4644         }
4645
4646         return TRUE;
4647     }
4648
4649     return FALSE;
4650 }
4651
4652
4653
4654 // Note - this function only draws cells that are in the list of
4655 // exposed cells (usually set from the update region by
4656 // CalcExposedCells)
4657 //
4658 void wxGrid::DrawGridCellArea( wxDC& dc )
4659 {
4660     if ( !m_numRows || !m_numCols ) return;
4661
4662     size_t i;
4663     size_t numCells = m_cellsExposed.GetCount();
4664
4665     for ( i = 0;  i < numCells;  i++ )
4666     {
4667         DrawCell( dc, m_cellsExposed[i] );
4668     }
4669 }
4670
4671
4672 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
4673 {
4674     int row = coords.GetRow();
4675     int col = coords.GetCol();
4676
4677     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
4678         return;
4679
4680     // we draw the cell border ourselves
4681 #if !WXGRID_DRAW_LINES
4682     if ( m_gridLinesEnabled )
4683         DrawCellBorder( dc, coords );
4684 #endif
4685
4686     wxGridCellAttr* attr = GetCellAttr(row, col);
4687
4688     bool isCurrent = coords == m_currentCellCoords;
4689
4690     wxRect rect;
4691     rect.x = GetColLeft(col);
4692     rect.y = GetRowTop(row);
4693     rect.width = GetColWidth(col) - 1;
4694     rect.height = GetRowHeight(row) - 1;
4695
4696     // if the editor is shown, we should use it and not the renderer
4697     if ( isCurrent && IsCellEditControlEnabled() )
4698     {
4699         attr->GetEditor(GetDefaultEditorForCell(row, col))->
4700             PaintBackground(rect, attr);
4701     }
4702     else
4703     {
4704         // but all the rest is drawn by the cell renderer and hence may be
4705         // customized
4706         attr->GetRenderer(GetDefaultRendererForCell(row,col))->
4707             Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
4708
4709     }
4710
4711     attr->DecRef();
4712 }
4713
4714 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
4715 {
4716     int row = m_currentCellCoords.GetRow();
4717     int col = m_currentCellCoords.GetCol();
4718
4719     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
4720         return;
4721
4722     wxRect rect;
4723     rect.x = GetColLeft(col);
4724     rect.y = GetRowTop(row);
4725     rect.width = GetColWidth(col) - 1;
4726     rect.height = GetRowHeight(row) - 1;
4727
4728     // hmmm... what could we do here to show that the cell is disabled?
4729     // for now, I just draw a thinner border than for the other ones, but
4730     // it doesn't look really good
4731     dc.SetPen(wxPen(m_gridLineColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
4732     dc.SetBrush(*wxTRANSPARENT_BRUSH);
4733
4734     dc.DrawRectangle(rect);
4735
4736 #if 0
4737         // VZ: my experiments with 3d borders...
4738
4739         // how to properly set colours for arbitrary bg?
4740         wxCoord x1 = rect.x,
4741                 y1 = rect.y,
4742                 x2 = rect.x + rect.width -1,
4743                 y2 = rect.y + rect.height -1;
4744
4745         dc.SetPen(*wxWHITE_PEN);
4746         dc.DrawLine(x1, y1, x2, y1);
4747         dc.DrawLine(x1, y1, x1, y2);
4748
4749         dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
4750         dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
4751
4752         dc.SetPen(*wxBLACK_PEN);
4753         dc.DrawLine(x1, y2, x2, y2);
4754         dc.DrawLine(x2, y1, x2, y2+1);
4755 #endif // 0
4756 }
4757
4758
4759 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
4760 {
4761     int row = coords.GetRow();
4762     int col = coords.GetCol();
4763     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
4764         return;
4765
4766     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
4767
4768     // right hand border
4769     //
4770     dc.DrawLine( GetColRight(col), GetRowTop(row),
4771                  GetColRight(col), GetRowBottom(row) );
4772
4773     // bottom border
4774     //
4775     dc.DrawLine( GetColLeft(col), GetRowBottom(row),
4776                  GetColRight(col), GetRowBottom(row) );
4777 }
4778
4779 void wxGrid::DrawHighlight(wxDC& dc)
4780 {
4781     if ( IsCellEditControlEnabled() )
4782     {
4783         // don't show highlight when the edit control is shown
4784         return;
4785     }
4786
4787     // if the active cell was repainted, repaint its highlight too because it
4788     // might have been damaged by the grid lines
4789     size_t count = m_cellsExposed.GetCount();
4790     for ( size_t n = 0; n < count; n++ )
4791     {
4792         if ( m_cellsExposed[n] == m_currentCellCoords )
4793         {
4794             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
4795             DrawCellHighlight(dc, attr);
4796             attr->DecRef();
4797
4798             break;
4799         }
4800     }
4801 }
4802
4803 // TODO: remove this ???
4804 // This is used to redraw all grid lines e.g. when the grid line colour
4805 // has been changed
4806 //
4807 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )
4808 {
4809     if ( !m_gridLinesEnabled ||
4810          !m_numRows ||
4811          !m_numCols ) return;
4812
4813     int top, bottom, left, right;
4814
4815     if (reg.IsEmpty())
4816     {
4817       int cw, ch;
4818       m_gridWin->GetClientSize(&cw, &ch);
4819
4820       // virtual coords of visible area
4821       //
4822       CalcUnscrolledPosition( 0, 0, &left, &top );
4823       CalcUnscrolledPosition( cw, ch, &right, &bottom );
4824     }
4825     else
4826     {
4827       wxCoord x, y, w, h;
4828       reg.GetBox(x, y, w, h);
4829       CalcUnscrolledPosition( x, y, &left, &top );
4830       CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
4831     }
4832
4833     // avoid drawing grid lines past the last row and col
4834     //
4835     right = wxMin( right, GetColRight(m_numCols - 1) );
4836     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
4837
4838     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
4839
4840     // horizontal grid lines
4841     //
4842     int i;
4843     for ( i = 0; i < m_numRows; i++ )
4844     {
4845         int bot = GetRowBottom(i) - 1;
4846
4847         if ( bot > bottom )
4848         {
4849             break;
4850         }
4851
4852         if ( bot >= top )
4853         {
4854             dc.DrawLine( left, bot, right, bot );
4855         }
4856     }
4857
4858
4859     // vertical grid lines
4860     //
4861     for ( i = 0; i < m_numCols; i++ )
4862     {
4863         int colRight = GetColRight(i) - 1;
4864         if ( colRight > right )
4865         {
4866             break;
4867         }
4868
4869         if ( colRight >= left )
4870         {
4871             dc.DrawLine( colRight, top, colRight, bottom );
4872         }
4873     }
4874 }
4875
4876
4877 void wxGrid::DrawRowLabels( wxDC& dc )
4878 {
4879     if ( !m_numRows || !m_numCols ) return;
4880
4881     size_t i;
4882     size_t numLabels = m_rowLabelsExposed.GetCount();
4883
4884     for ( i = 0;  i < numLabels;  i++ )
4885     {
4886         DrawRowLabel( dc, m_rowLabelsExposed[i] );
4887     }
4888 }
4889
4890
4891 void wxGrid::DrawRowLabel( wxDC& dc, int row )
4892 {
4893     if ( GetRowHeight(row) <= 0 )
4894         return;
4895
4896     int rowTop = GetRowTop(row),
4897         rowBottom = GetRowBottom(row) - 1;
4898
4899     dc.SetPen( *wxBLACK_PEN );
4900     dc.DrawLine( m_rowLabelWidth-1, rowTop,
4901                  m_rowLabelWidth-1, rowBottom );
4902
4903     dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
4904
4905     dc.SetPen( *wxWHITE_PEN );
4906     dc.DrawLine( 0, rowTop, 0, rowBottom );
4907     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
4908
4909     dc.SetBackgroundMode( wxTRANSPARENT );
4910     dc.SetTextForeground( GetLabelTextColour() );
4911     dc.SetFont( GetLabelFont() );
4912
4913     int hAlign, vAlign;
4914     GetRowLabelAlignment( &hAlign, &vAlign );
4915
4916     wxRect rect;
4917     rect.SetX( 2 );
4918     rect.SetY( GetRowTop(row) + 2 );
4919     rect.SetWidth( m_rowLabelWidth - 4 );
4920     rect.SetHeight( GetRowHeight(row) - 4 );
4921     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
4922 }
4923
4924
4925 void wxGrid::DrawColLabels( wxDC& dc )
4926 {
4927     if ( !m_numRows || !m_numCols ) return;
4928
4929     size_t i;
4930     size_t numLabels = m_colLabelsExposed.GetCount();
4931
4932     for ( i = 0;  i < numLabels;  i++ )
4933     {
4934         DrawColLabel( dc, m_colLabelsExposed[i] );
4935     }
4936 }
4937
4938
4939 void wxGrid::DrawColLabel( wxDC& dc, int col )
4940 {
4941     if ( GetColWidth(col) <= 0 )
4942         return;
4943
4944     int colLeft = GetColLeft(col),
4945         colRight = GetColRight(col) - 1;
4946
4947     dc.SetPen( *wxBLACK_PEN );
4948     dc.DrawLine( colRight, 0,
4949                  colRight, m_colLabelHeight-1 );
4950
4951     dc.DrawLine( colLeft, m_colLabelHeight-1,
4952                  colRight, m_colLabelHeight-1 );
4953
4954     dc.SetPen( *wxWHITE_PEN );
4955     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
4956     dc.DrawLine( colLeft, 0, colRight, 0 );
4957
4958     dc.SetBackgroundMode( wxTRANSPARENT );
4959     dc.SetTextForeground( GetLabelTextColour() );
4960     dc.SetFont( GetLabelFont() );
4961
4962     dc.SetBackgroundMode( wxTRANSPARENT );
4963     dc.SetTextForeground( GetLabelTextColour() );
4964     dc.SetFont( GetLabelFont() );
4965
4966     int hAlign, vAlign;
4967     GetColLabelAlignment( &hAlign, &vAlign );
4968
4969     wxRect rect;
4970     rect.SetX( colLeft + 2 );
4971     rect.SetY( 2 );
4972     rect.SetWidth( GetColWidth(col) - 4 );
4973     rect.SetHeight( m_colLabelHeight - 4 );
4974     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
4975 }
4976
4977
4978 void wxGrid::DrawTextRectangle( wxDC& dc,
4979                                 const wxString& value,
4980                                 const wxRect& rect,
4981                                 int horizAlign,
4982                                 int vertAlign )
4983 {
4984     long textWidth, textHeight;
4985     long lineWidth, lineHeight;
4986     wxArrayString lines;
4987
4988     dc.SetClippingRegion( rect );
4989     StringToLines( value, lines );
4990     if ( lines.GetCount() )
4991     {
4992         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
4993         dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
4994
4995         float x, y;
4996         switch ( horizAlign )
4997         {
4998             case wxRIGHT:
4999                 x = rect.x + (rect.width - textWidth - 1);
5000                 break;
5001
5002             case wxCENTRE:
5003                 x = rect.x + ((rect.width - textWidth)/2);
5004                 break;
5005
5006             case wxLEFT:
5007             default:
5008                 x = rect.x + 1;
5009                 break;
5010         }
5011
5012         switch ( vertAlign )
5013         {
5014             case wxBOTTOM:
5015                 y = rect.y + (rect.height - textHeight - 1);
5016                 break;
5017
5018             case wxCENTRE:
5019                 y = rect.y + ((rect.height - textHeight)/2);
5020                 break;
5021
5022             case wxTOP:
5023             default:
5024                 y = rect.y + 1;
5025                 break;
5026         }
5027
5028         for ( size_t i = 0;  i < lines.GetCount();  i++ )
5029         {
5030             dc.DrawText( lines[i], (long)x, (long)y );
5031             y += lineHeight;
5032         }
5033     }
5034
5035     dc.DestroyClippingRegion();
5036 }
5037
5038
5039 // Split multi line text up into an array of strings.  Any existing
5040 // contents of the string array are preserved.
5041 //
5042 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
5043 {
5044     int startPos = 0;
5045     int pos;
5046     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
5047     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
5048
5049     while ( startPos < (int)tVal.Length() )
5050     {
5051         pos = tVal.Mid(startPos).Find( eol );
5052         if ( pos < 0 )
5053         {
5054             break;
5055         }
5056         else if ( pos == 0 )
5057         {
5058             lines.Add( wxEmptyString );
5059         }
5060         else
5061         {
5062             lines.Add( value.Mid(startPos, pos) );
5063         }
5064         startPos += pos+1;
5065     }
5066     if ( startPos < (int)value.Length() )
5067     {
5068         lines.Add( value.Mid( startPos ) );
5069     }
5070 }
5071
5072
5073 void wxGrid::GetTextBoxSize( wxDC& dc,
5074                              wxArrayString& lines,
5075                              long *width, long *height )
5076 {
5077     long w = 0;
5078     long h = 0;
5079     long lineW, lineH;
5080
5081     size_t i;
5082     for ( i = 0;  i < lines.GetCount();  i++ )
5083     {
5084         dc.GetTextExtent( lines[i], &lineW, &lineH );
5085         w = wxMax( w, lineW );
5086         h += lineH;
5087     }
5088
5089     *width = w;
5090     *height = h;
5091 }
5092
5093
5094 //
5095 // ------ Edit control functions
5096 //
5097
5098
5099 void wxGrid::EnableEditing( bool edit )
5100 {
5101     // TODO: improve this ?
5102     //
5103     if ( edit != m_editable )
5104     {
5105         m_editable = edit;
5106
5107         // FIXME IMHO this won't disable the edit control if edit == FALSE
5108         //       because of the check in the beginning of
5109         //       EnableCellEditControl() just below (VZ)
5110         EnableCellEditControl(m_editable);
5111     }
5112 }
5113
5114
5115 void wxGrid::EnableCellEditControl( bool enable )
5116 {
5117     if (! m_editable)
5118         return;
5119
5120     if ( m_currentCellCoords == wxGridNoCellCoords )
5121         SetCurrentCell( 0, 0 );
5122
5123     if ( enable != m_cellEditCtrlEnabled )
5124     {
5125         // TODO allow the app to Veto() this event?
5126         SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
5127
5128         if ( enable )
5129         {
5130             // this should be checked by the caller!
5131             wxASSERT_MSG( CanEnableCellControl(),
5132                           _T("can't enable editing for this cell!") );
5133
5134             // do it before ShowCellEditControl()
5135             m_cellEditCtrlEnabled = enable;
5136
5137             SetEditControlValue();
5138             ShowCellEditControl();
5139         }
5140         else
5141         {
5142             HideCellEditControl();
5143             SaveEditControlValue();
5144
5145             // do it after HideCellEditControl()
5146             m_cellEditCtrlEnabled = enable;
5147         }
5148     }
5149 }
5150
5151 bool wxGrid::IsCurrentCellReadOnly() const
5152 {
5153     // const_cast
5154     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
5155     bool readonly = attr->IsReadOnly();
5156     attr->DecRef();
5157
5158     return readonly;
5159 }
5160
5161 bool wxGrid::CanEnableCellControl() const
5162 {
5163     return m_editable && !IsCurrentCellReadOnly();
5164 }
5165
5166 bool wxGrid::IsCellEditControlEnabled() const
5167 {
5168     // the cell edit control might be disable for all cells or just for the
5169     // current one if it's read only
5170     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
5171 }
5172
5173 void wxGrid::ShowCellEditControl()
5174 {
5175     if ( IsCellEditControlEnabled() )
5176     {
5177         if ( !IsVisible( m_currentCellCoords ) )
5178         {
5179             return;
5180         }
5181         else
5182         {
5183             wxRect rect = CellToRect( m_currentCellCoords );
5184             int row = m_currentCellCoords.GetRow();
5185             int col = m_currentCellCoords.GetCol();
5186
5187             // convert to scrolled coords
5188             //
5189             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5190
5191             // done in PaintBackground()
5192 #if 0
5193             // erase the highlight and the cell contents because the editor
5194             // might not cover the entire cell
5195             wxClientDC dc( m_gridWin );
5196             PrepareDC( dc );
5197             dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
5198             dc.SetPen(*wxTRANSPARENT_PEN);
5199             dc.DrawRectangle(rect);
5200 #endif // 0
5201
5202             // cell is shifted by one pixel
5203             rect.x--;
5204             rect.y--;
5205
5206             wxGridCellAttr* attr = GetCellAttr(row, col);
5207             wxGridCellEditor* editor = attr->GetEditor(GetDefaultEditorForCell(row, col));
5208             if ( !editor->IsCreated() )
5209             {
5210                 editor->Create(m_gridWin, -1,
5211                                new wxGridCellEditorEvtHandler(this, editor));
5212             }
5213
5214             editor->SetSize( rect );
5215
5216             editor->Show( TRUE, attr );
5217             editor->BeginEdit(row, col, this);
5218             attr->DecRef();
5219          }
5220     }
5221 }
5222
5223
5224 void wxGrid::HideCellEditControl()
5225 {
5226     if ( IsCellEditControlEnabled() )
5227     {
5228         int row = m_currentCellCoords.GetRow();
5229         int col = m_currentCellCoords.GetCol();
5230
5231         wxGridCellAttr* attr = GetCellAttr(row, col);
5232         attr->GetEditor(GetDefaultEditorForCell(row, col))->Show( FALSE );
5233         attr->DecRef();
5234         m_gridWin->SetFocus();
5235     }
5236 }
5237
5238
5239 void wxGrid::SetEditControlValue( const wxString& value )
5240 {
5241     // RD: The new Editors get the value from the table themselves now.  This
5242     // method can probably be removed...
5243 }
5244
5245
5246 void wxGrid::SaveEditControlValue()
5247 {
5248     if ( IsCellEditControlEnabled() )
5249     {
5250         int row = m_currentCellCoords.GetRow();
5251         int col = m_currentCellCoords.GetCol();
5252
5253         wxGridCellAttr* attr = GetCellAttr(row, col);
5254         wxGridCellEditor* editor = attr->GetEditor(GetDefaultEditorForCell(row, col));
5255         bool changed = editor->EndEdit(row, col, TRUE, this);
5256
5257         attr->DecRef();
5258
5259         if (changed)
5260         {
5261             SendEvent( wxEVT_GRID_CELL_CHANGE,
5262                        m_currentCellCoords.GetRow(),
5263                        m_currentCellCoords.GetCol() );
5264         }
5265     }
5266 }
5267
5268
5269 //
5270 // ------ Grid location functions
5271 //  Note that all of these functions work with the logical coordinates of
5272 //  grid cells and labels so you will need to convert from device
5273 //  coordinates for mouse events etc.
5274 //
5275
5276 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
5277 {
5278     int row = YToRow(y);
5279     int col = XToCol(x);
5280
5281     if ( row == -1  ||  col == -1 )
5282     {
5283         coords = wxGridNoCellCoords;
5284     }
5285     else
5286     {
5287         coords.Set( row, col );
5288     }
5289 }
5290
5291
5292 int wxGrid::YToRow( int y )
5293 {
5294     int i;
5295
5296     for ( i = 0;  i < m_numRows;  i++ )
5297     {
5298         if ( y < GetRowBottom(i) )
5299             return i;
5300     }
5301
5302     return m_numRows; //-1;
5303 }
5304
5305
5306 int wxGrid::XToCol( int x )
5307 {
5308     int i;
5309
5310     for ( i = 0;  i < m_numCols;  i++ )
5311     {
5312         if ( x < GetColRight(i) )
5313             return i;
5314     }
5315
5316     return m_numCols; //-1;
5317 }
5318
5319
5320 // return the row number that that the y coord is near the edge of, or
5321 // -1 if not near an edge
5322 //
5323 int wxGrid::YToEdgeOfRow( int y )
5324 {
5325     int i, d;
5326
5327     for ( i = 0;  i < m_numRows;  i++ )
5328     {
5329         if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
5330         {
5331             d = abs( y - GetRowBottom(i) );
5332             if ( d < WXGRID_LABEL_EDGE_ZONE )
5333                 return i;
5334         }
5335     }
5336
5337     return -1;
5338 }
5339
5340
5341 // return the col number that that the x coord is near the edge of, or
5342 // -1 if not near an edge
5343 //
5344 int wxGrid::XToEdgeOfCol( int x )
5345 {
5346     int i, d;
5347
5348     for ( i = 0;  i < m_numCols;  i++ )
5349     {
5350         if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
5351         {
5352             d = abs( x - GetColRight(i) );
5353             if ( d < WXGRID_LABEL_EDGE_ZONE )
5354                 return i;
5355         }
5356     }
5357
5358     return -1;
5359 }
5360
5361
5362 wxRect wxGrid::CellToRect( int row, int col )
5363 {
5364     wxRect rect( -1, -1, -1, -1 );
5365
5366     if ( row >= 0  &&  row < m_numRows  &&
5367          col >= 0  &&  col < m_numCols )
5368     {
5369         rect.x = GetColLeft(col);
5370         rect.y = GetRowTop(row);
5371         rect.width = GetColWidth(col);
5372         rect.height = GetRowHeight(row);
5373     }
5374
5375     return rect;
5376 }
5377
5378
5379 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
5380 {
5381     // get the cell rectangle in logical coords
5382     //
5383     wxRect r( CellToRect( row, col ) );
5384
5385     // convert to device coords
5386     //
5387     int left, top, right, bottom;
5388     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
5389     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
5390
5391     // check against the client area of the grid window
5392     //
5393     int cw, ch;
5394     m_gridWin->GetClientSize( &cw, &ch );
5395
5396     if ( wholeCellVisible )
5397     {
5398         // is the cell wholly visible ?
5399         //
5400         return ( left >= 0  &&  right <= cw  &&
5401                  top >= 0  &&  bottom <= ch );
5402     }
5403     else
5404     {
5405         // is the cell partly visible ?
5406         //
5407         return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
5408                  ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
5409     }
5410 }
5411
5412
5413 // make the specified cell location visible by doing a minimal amount
5414 // of scrolling
5415 //
5416 void wxGrid::MakeCellVisible( int row, int col )
5417 {
5418     int i;
5419     int xpos = -1, ypos = -1;
5420
5421     if ( row >= 0  &&  row < m_numRows  &&
5422          col >= 0  &&  col < m_numCols )
5423     {
5424         // get the cell rectangle in logical coords
5425         //
5426         wxRect r( CellToRect( row, col ) );
5427
5428         // convert to device coords
5429         //
5430         int left, top, right, bottom;
5431         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
5432         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
5433
5434         int cw, ch;
5435         m_gridWin->GetClientSize( &cw, &ch );
5436
5437         if ( top < 0 )
5438         {
5439             ypos = r.GetTop();
5440         }
5441         else if ( bottom > ch )
5442         {
5443             int h = r.GetHeight();
5444             ypos = r.GetTop();
5445             for ( i = row-1;  i >= 0;  i-- )
5446             {
5447                 int rowHeight = GetRowHeight(i);
5448                 if ( h + rowHeight > ch )
5449                     break;
5450
5451                 h += rowHeight;
5452                 ypos -= rowHeight;
5453             }
5454
5455             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
5456             // have rounding errors (this is important, because if we do, we
5457             // might not scroll at all and some cells won't be redrawn)
5458             ypos += GRID_SCROLL_LINE / 2;
5459         }
5460
5461         if ( left < 0 )
5462         {
5463             xpos = r.GetLeft();
5464         }
5465         else if ( right > cw )
5466         {
5467             int w = r.GetWidth();
5468             xpos = r.GetLeft();
5469             for ( i = col-1;  i >= 0;  i-- )
5470             {
5471                 int colWidth = GetColWidth(i);
5472                 if ( w + colWidth > cw )
5473                     break;
5474
5475                 w += colWidth;
5476                 xpos -= colWidth;
5477             }
5478
5479             // see comment for ypos above
5480             xpos += GRID_SCROLL_LINE / 2;
5481         }
5482
5483         if ( xpos != -1  ||  ypos != -1 )
5484         {
5485             if ( xpos != -1 ) xpos /= GRID_SCROLL_LINE;
5486             if ( ypos != -1 ) ypos /= GRID_SCROLL_LINE;
5487             Scroll( xpos, ypos );
5488             AdjustScrollbars();
5489         }
5490     }
5491 }
5492
5493
5494 //
5495 // ------ Grid cursor movement functions
5496 //
5497
5498 bool wxGrid::MoveCursorUp()
5499 {
5500     if ( m_currentCellCoords != wxGridNoCellCoords  &&
5501          m_currentCellCoords.GetRow() > 0 )
5502     {
5503         MakeCellVisible( m_currentCellCoords.GetRow() - 1,
5504                         m_currentCellCoords.GetCol() );
5505
5506         SetCurrentCell( m_currentCellCoords.GetRow() - 1,
5507                         m_currentCellCoords.GetCol() );
5508
5509         return TRUE;
5510     }
5511
5512     return FALSE;
5513 }
5514
5515
5516 bool wxGrid::MoveCursorDown()
5517 {
5518     // TODO: allow for scrolling
5519     //
5520     if ( m_currentCellCoords != wxGridNoCellCoords  &&
5521          m_currentCellCoords.GetRow() < m_numRows-1 )
5522     {
5523         MakeCellVisible( m_currentCellCoords.GetRow() + 1,
5524                         m_currentCellCoords.GetCol() );
5525
5526         SetCurrentCell( m_currentCellCoords.GetRow() + 1,
5527                         m_currentCellCoords.GetCol() );
5528
5529         return TRUE;
5530     }
5531
5532     return FALSE;
5533 }
5534
5535
5536 bool wxGrid::MoveCursorLeft()
5537 {
5538     if ( m_currentCellCoords != wxGridNoCellCoords  &&
5539          m_currentCellCoords.GetCol() > 0 )
5540     {
5541         MakeCellVisible( m_currentCellCoords.GetRow(),
5542                         m_currentCellCoords.GetCol() - 1 );
5543
5544         SetCurrentCell( m_currentCellCoords.GetRow(),
5545                         m_currentCellCoords.GetCol() - 1 );
5546
5547         return TRUE;
5548     }
5549
5550     return FALSE;
5551 }
5552
5553
5554 bool wxGrid::MoveCursorRight()
5555 {
5556     if ( m_currentCellCoords != wxGridNoCellCoords  &&
5557          m_currentCellCoords.GetCol() < m_numCols - 1 )
5558     {
5559         MakeCellVisible( m_currentCellCoords.GetRow(),
5560                         m_currentCellCoords.GetCol() + 1 );
5561
5562         SetCurrentCell( m_currentCellCoords.GetRow(),
5563                         m_currentCellCoords.GetCol() + 1 );
5564
5565         return TRUE;
5566     }
5567
5568     return FALSE;
5569 }
5570
5571
5572 bool wxGrid::MovePageUp()
5573 {
5574     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
5575
5576     int row = m_currentCellCoords.GetRow();
5577     if ( row > 0 )
5578     {
5579         int cw, ch;
5580         m_gridWin->GetClientSize( &cw, &ch );
5581
5582         int y = GetRowTop(row);
5583         int newRow = YToRow( y - ch + 1 );
5584         if ( newRow == -1 )
5585         {
5586             newRow = 0;
5587         }
5588         else if ( newRow == row )
5589         {
5590             newRow = row - 1;
5591         }
5592
5593         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
5594         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
5595
5596         return TRUE;
5597     }
5598
5599     return FALSE;
5600 }
5601
5602 bool wxGrid::MovePageDown()
5603 {
5604     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
5605
5606     int row = m_currentCellCoords.GetRow();
5607     if ( row < m_numRows )
5608     {
5609         int cw, ch;
5610         m_gridWin->GetClientSize( &cw, &ch );
5611
5612         int y = GetRowTop(row);
5613         int newRow = YToRow( y + ch );
5614         if ( newRow == -1 )
5615         {
5616             newRow = m_numRows - 1;
5617         }
5618         else if ( newRow == row )
5619         {
5620             newRow = row + 1;
5621         }
5622
5623         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
5624         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
5625
5626         return TRUE;
5627     }
5628
5629     return FALSE;
5630 }
5631
5632 bool wxGrid::MoveCursorUpBlock()
5633 {
5634     if ( m_table &&
5635          m_currentCellCoords != wxGridNoCellCoords  &&
5636          m_currentCellCoords.GetRow() > 0 )
5637     {
5638         int row = m_currentCellCoords.GetRow();
5639         int col = m_currentCellCoords.GetCol();
5640
5641         if ( m_table->IsEmptyCell(row, col) )
5642         {
5643             // starting in an empty cell: find the next block of
5644             // non-empty cells
5645             //
5646             while ( row > 0 )
5647             {
5648                 row-- ;
5649                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5650             }
5651         }
5652         else if ( m_table->IsEmptyCell(row-1, col) )
5653         {
5654             // starting at the top of a block: find the next block
5655             //
5656             row--;
5657             while ( row > 0 )
5658             {
5659                 row-- ;
5660                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5661             }
5662         }
5663         else
5664         {
5665             // starting within a block: find the top of the block
5666             //
5667             while ( row > 0 )
5668             {
5669                 row-- ;
5670                 if ( m_table->IsEmptyCell(row, col) )
5671                 {
5672                     row++ ;
5673                     break;
5674                 }
5675             }
5676         }
5677
5678         MakeCellVisible( row, col );
5679         SetCurrentCell( row, col );
5680
5681         return TRUE;
5682     }
5683
5684     return FALSE;
5685 }
5686
5687 bool wxGrid::MoveCursorDownBlock()
5688 {
5689     if ( m_table &&
5690          m_currentCellCoords != wxGridNoCellCoords  &&
5691          m_currentCellCoords.GetRow() < m_numRows-1 )
5692     {
5693         int row = m_currentCellCoords.GetRow();
5694         int col = m_currentCellCoords.GetCol();
5695
5696         if ( m_table->IsEmptyCell(row, col) )
5697         {
5698             // starting in an empty cell: find the next block of
5699             // non-empty cells
5700             //
5701             while ( row < m_numRows-1 )
5702             {
5703                 row++ ;
5704                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5705             }
5706         }
5707         else if ( m_table->IsEmptyCell(row+1, col) )
5708         {
5709             // starting at the bottom of a block: find the next block
5710             //
5711             row++;
5712             while ( row < m_numRows-1 )
5713             {
5714                 row++ ;
5715                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5716             }
5717         }
5718         else
5719         {
5720             // starting within a block: find the bottom of the block
5721             //
5722             while ( row < m_numRows-1 )
5723             {
5724                 row++ ;
5725                 if ( m_table->IsEmptyCell(row, col) )
5726                 {
5727                     row-- ;
5728                     break;
5729                 }
5730             }
5731         }
5732
5733         MakeCellVisible( row, col );
5734         SetCurrentCell( row, col );
5735
5736         return TRUE;
5737     }
5738
5739     return FALSE;
5740 }
5741
5742 bool wxGrid::MoveCursorLeftBlock()
5743 {
5744     if ( m_table &&
5745          m_currentCellCoords != wxGridNoCellCoords  &&
5746          m_currentCellCoords.GetCol() > 0 )
5747     {
5748         int row = m_currentCellCoords.GetRow();
5749         int col = m_currentCellCoords.GetCol();
5750
5751         if ( m_table->IsEmptyCell(row, col) )
5752         {
5753             // starting in an empty cell: find the next block of
5754             // non-empty cells
5755             //
5756             while ( col > 0 )
5757             {
5758                 col-- ;
5759                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5760             }
5761         }
5762         else if ( m_table->IsEmptyCell(row, col-1) )
5763         {
5764             // starting at the left of a block: find the next block
5765             //
5766             col--;
5767             while ( col > 0 )
5768             {
5769                 col-- ;
5770                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5771             }
5772         }
5773         else
5774         {
5775             // starting within a block: find the left of the block
5776             //
5777             while ( col > 0 )
5778             {
5779                 col-- ;
5780                 if ( m_table->IsEmptyCell(row, col) )
5781                 {
5782                     col++ ;
5783                     break;
5784                 }
5785             }
5786         }
5787
5788         MakeCellVisible( row, col );
5789         SetCurrentCell( row, col );
5790
5791         return TRUE;
5792     }
5793
5794     return FALSE;
5795 }
5796
5797 bool wxGrid::MoveCursorRightBlock()
5798 {
5799     if ( m_table &&
5800          m_currentCellCoords != wxGridNoCellCoords  &&
5801          m_currentCellCoords.GetCol() < m_numCols-1 )
5802     {
5803         int row = m_currentCellCoords.GetRow();
5804         int col = m_currentCellCoords.GetCol();
5805
5806         if ( m_table->IsEmptyCell(row, col) )
5807         {
5808             // starting in an empty cell: find the next block of
5809             // non-empty cells
5810             //
5811             while ( col < m_numCols-1 )
5812             {
5813                 col++ ;
5814                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5815             }
5816         }
5817         else if ( m_table->IsEmptyCell(row, col+1) )
5818         {
5819             // starting at the right of a block: find the next block
5820             //
5821             col++;
5822             while ( col < m_numCols-1 )
5823             {
5824                 col++ ;
5825                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
5826             }
5827         }
5828         else
5829         {
5830             // starting within a block: find the right of the block
5831             //
5832             while ( col < m_numCols-1 )
5833             {
5834                 col++ ;
5835                 if ( m_table->IsEmptyCell(row, col) )
5836                 {
5837                     col-- ;
5838                     break;
5839                 }
5840             }
5841         }
5842
5843         MakeCellVisible( row, col );
5844         SetCurrentCell( row, col );
5845
5846         return TRUE;
5847     }
5848
5849     return FALSE;
5850 }
5851
5852
5853
5854 //
5855 // ------ Label values and formatting
5856 //
5857
5858 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
5859 {
5860     *horiz = m_rowLabelHorizAlign;
5861     *vert  = m_rowLabelVertAlign;
5862 }
5863
5864 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
5865 {
5866     *horiz = m_colLabelHorizAlign;
5867     *vert  = m_colLabelVertAlign;
5868 }
5869
5870 wxString wxGrid::GetRowLabelValue( int row )
5871 {
5872     if ( m_table )
5873     {
5874         return m_table->GetRowLabelValue( row );
5875     }
5876     else
5877     {
5878         wxString s;
5879         s << row;
5880         return s;
5881     }
5882 }
5883
5884 wxString wxGrid::GetColLabelValue( int col )
5885 {
5886     if ( m_table )
5887     {
5888         return m_table->GetColLabelValue( col );
5889     }
5890     else
5891     {
5892         wxString s;
5893         s << col;
5894         return s;
5895     }
5896 }
5897
5898
5899 void wxGrid::SetRowLabelSize( int width )
5900 {
5901     width = wxMax( width, 0 );
5902     if ( width != m_rowLabelWidth )
5903     {
5904         if ( width == 0 )
5905         {
5906             m_rowLabelWin->Show( FALSE );
5907             m_cornerLabelWin->Show( FALSE );
5908         }
5909         else if ( m_rowLabelWidth == 0 )
5910         {
5911             m_rowLabelWin->Show( TRUE );
5912             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
5913         }
5914
5915         m_rowLabelWidth = width;
5916         CalcWindowSizes();
5917         Refresh( TRUE );
5918     }
5919 }
5920
5921
5922 void wxGrid::SetColLabelSize( int height )
5923 {
5924     height = wxMax( height, 0 );
5925     if ( height != m_colLabelHeight )
5926     {
5927         if ( height == 0 )
5928         {
5929             m_colLabelWin->Show( FALSE );
5930             m_cornerLabelWin->Show( FALSE );
5931         }
5932         else if ( m_colLabelHeight == 0 )
5933         {
5934             m_colLabelWin->Show( TRUE );
5935             if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
5936         }
5937
5938         m_colLabelHeight = height;
5939         CalcWindowSizes();
5940         Refresh( TRUE );
5941     }
5942 }
5943
5944
5945 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
5946 {
5947     if ( m_labelBackgroundColour != colour )
5948     {
5949         m_labelBackgroundColour = colour;
5950         m_rowLabelWin->SetBackgroundColour( colour );
5951         m_colLabelWin->SetBackgroundColour( colour );
5952         m_cornerLabelWin->SetBackgroundColour( colour );
5953
5954         if ( !GetBatchCount() )
5955         {
5956             m_rowLabelWin->Refresh();
5957             m_colLabelWin->Refresh();
5958             m_cornerLabelWin->Refresh();
5959         }
5960     }
5961 }
5962
5963 void wxGrid::SetLabelTextColour( const wxColour& colour )
5964 {
5965     if ( m_labelTextColour != colour )
5966     {
5967         m_labelTextColour = colour;
5968         if ( !GetBatchCount() )
5969         {
5970             m_rowLabelWin->Refresh();
5971             m_colLabelWin->Refresh();
5972         }
5973     }
5974 }
5975
5976 void wxGrid::SetLabelFont( const wxFont& font )
5977 {
5978     m_labelFont = font;
5979     if ( !GetBatchCount() )
5980     {
5981         m_rowLabelWin->Refresh();
5982         m_colLabelWin->Refresh();
5983     }
5984 }
5985
5986 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
5987 {
5988     if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
5989     {
5990         m_rowLabelHorizAlign = horiz;
5991     }
5992
5993     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
5994     {
5995         m_rowLabelVertAlign = vert;
5996     }
5997
5998     if ( !GetBatchCount() )
5999     {
6000         m_rowLabelWin->Refresh();
6001     }
6002 }
6003
6004 void wxGrid::SetColLabelAlignment( int horiz, int vert )
6005 {
6006     if ( horiz == wxLEFT || horiz == wxCENTRE || horiz == wxRIGHT )
6007     {
6008         m_colLabelHorizAlign = horiz;
6009     }
6010
6011     if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
6012     {
6013         m_colLabelVertAlign = vert;
6014     }
6015
6016     if ( !GetBatchCount() )
6017     {
6018         m_colLabelWin->Refresh();
6019     }
6020 }
6021
6022 void wxGrid::SetRowLabelValue( int row, const wxString& s )
6023 {
6024     if ( m_table )
6025     {
6026         m_table->SetRowLabelValue( row, s );
6027         if ( !GetBatchCount() )
6028         {
6029             wxRect rect = CellToRect( row, 0);
6030             if ( rect.height > 0 )
6031             {
6032                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
6033                 rect.x = m_left;
6034                 rect.width = m_rowLabelWidth;
6035                 m_rowLabelWin->Refresh( TRUE, &rect );
6036             }
6037         }
6038     }
6039 }
6040
6041 void wxGrid::SetColLabelValue( int col, const wxString& s )
6042 {
6043     if ( m_table )
6044     {
6045         m_table->SetColLabelValue( col, s );
6046         if ( !GetBatchCount() )
6047         {
6048             wxRect rect = CellToRect( 0, col );
6049             if ( rect.width > 0 )
6050             {
6051                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
6052                 rect.y = m_top;
6053                 rect.height = m_colLabelHeight;
6054                 m_colLabelWin->Refresh( TRUE, &rect );
6055             }
6056         }
6057     }
6058 }
6059
6060 void wxGrid::SetGridLineColour( const wxColour& colour )
6061 {
6062     if ( m_gridLineColour != colour )
6063     {
6064         m_gridLineColour = colour;
6065
6066         wxClientDC dc( m_gridWin );
6067         PrepareDC( dc );
6068         DrawAllGridLines( dc, wxRegion() );
6069     }
6070 }
6071
6072 void wxGrid::EnableGridLines( bool enable )
6073 {
6074     if ( enable != m_gridLinesEnabled )
6075     {
6076         m_gridLinesEnabled = enable;
6077
6078         if ( !GetBatchCount() )
6079         {
6080             if ( enable )
6081             {
6082                 wxClientDC dc( m_gridWin );
6083                 PrepareDC( dc );
6084                 DrawAllGridLines( dc, wxRegion() );
6085             }
6086             else
6087             {
6088                 m_gridWin->Refresh();
6089             }
6090         }
6091     }
6092 }
6093
6094
6095 int wxGrid::GetDefaultRowSize()
6096 {
6097     return m_defaultRowHeight;
6098 }
6099
6100 int wxGrid::GetRowSize( int row )
6101 {
6102     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
6103
6104     return GetRowHeight(row);
6105 }
6106
6107 int wxGrid::GetDefaultColSize()
6108 {
6109     return m_defaultColWidth;
6110 }
6111
6112 int wxGrid::GetColSize( int col )
6113 {
6114     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
6115
6116     return GetColWidth(col);
6117 }
6118
6119 // ============================================================================
6120 // access to the grid attributes: each of them has a default value in the grid
6121 // itself and may be overidden on a per-cell basis
6122 // ============================================================================
6123
6124 // ----------------------------------------------------------------------------
6125 // setting default attributes
6126 // ----------------------------------------------------------------------------
6127
6128 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
6129 {
6130     m_defaultCellAttr->SetBackgroundColour(col);
6131 #ifdef __WXGTK__
6132     m_gridWin->SetBackgroundColour(col);
6133 #endif
6134 }
6135
6136 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
6137 {
6138     m_defaultCellAttr->SetTextColour(col);
6139 }
6140
6141 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
6142 {
6143     m_defaultCellAttr->SetAlignment(horiz, vert);
6144 }
6145
6146 void wxGrid::SetDefaultCellFont( const wxFont& font )
6147 {
6148     m_defaultCellAttr->SetFont(font);
6149 }
6150
6151 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
6152 {
6153     m_defaultCellAttr->SetRenderer(renderer);
6154 }
6155
6156 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
6157 {
6158     m_defaultCellAttr->SetEditor(editor);
6159 }
6160
6161 // ----------------------------------------------------------------------------
6162 // access to the default attrbiutes
6163 // ----------------------------------------------------------------------------
6164
6165 wxColour wxGrid::GetDefaultCellBackgroundColour()
6166 {
6167     return m_defaultCellAttr->GetBackgroundColour();
6168 }
6169
6170 wxColour wxGrid::GetDefaultCellTextColour()
6171 {
6172     return m_defaultCellAttr->GetTextColour();
6173 }
6174
6175 wxFont wxGrid::GetDefaultCellFont()
6176 {
6177     return m_defaultCellAttr->GetFont();
6178 }
6179
6180 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
6181 {
6182     m_defaultCellAttr->GetAlignment(horiz, vert);
6183 }
6184
6185 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
6186 {
6187     return m_defaultCellAttr->GetRenderer(NULL);
6188 }
6189
6190 wxGridCellEditor *wxGrid::GetDefaultEditor() const
6191 {
6192     return m_defaultCellAttr->GetEditor(NULL);
6193 }
6194
6195 // ----------------------------------------------------------------------------
6196 // access to cell attributes
6197 // ----------------------------------------------------------------------------
6198
6199 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
6200 {
6201     wxGridCellAttr *attr = GetCellAttr(row, col);
6202     wxColour colour = attr->GetBackgroundColour();
6203     attr->SafeDecRef();
6204     return colour;
6205 }
6206
6207 wxColour wxGrid::GetCellTextColour( int row, int col )
6208 {
6209     wxGridCellAttr *attr = GetCellAttr(row, col);
6210     wxColour colour = attr->GetTextColour();
6211     attr->SafeDecRef();
6212     return colour;
6213 }
6214
6215 wxFont wxGrid::GetCellFont( int row, int col )
6216 {
6217     wxGridCellAttr *attr = GetCellAttr(row, col);
6218     wxFont font = attr->GetFont();
6219     attr->SafeDecRef();
6220     return font;
6221 }
6222
6223 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
6224 {
6225     wxGridCellAttr *attr = GetCellAttr(row, col);
6226     attr->GetAlignment(horiz, vert);
6227     attr->SafeDecRef();
6228 }
6229
6230 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
6231 {
6232     wxGridCellAttr* attr = GetCellAttr(row, col);
6233     wxGridCellRenderer* renderer = attr->GetRenderer(GetDefaultRendererForCell(row,col));
6234     attr->DecRef();
6235     return renderer;
6236 }
6237
6238 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
6239 {
6240     wxGridCellAttr* attr = GetCellAttr(row, col);
6241     wxGridCellEditor* editor = attr->GetEditor(GetDefaultEditorForCell(row, col));
6242     attr->DecRef();
6243     return editor;
6244 }
6245
6246 bool wxGrid::IsReadOnly(int row, int col) const
6247 {
6248     wxGridCellAttr* attr = GetCellAttr(row, col);
6249     bool isReadOnly = attr->IsReadOnly();
6250     attr->DecRef();
6251     return isReadOnly;
6252 }
6253
6254 // ----------------------------------------------------------------------------
6255 // attribute support: cache, automatic provider creation, ...
6256 // ----------------------------------------------------------------------------
6257
6258 bool wxGrid::CanHaveAttributes()
6259 {
6260     if ( !m_table )
6261     {
6262         return FALSE;
6263     }
6264
6265     return m_table->CanHaveAttributes();
6266 }
6267
6268 void wxGrid::ClearAttrCache()
6269 {
6270     if ( m_attrCache.row != -1 )
6271     {
6272         m_attrCache.attr->SafeDecRef();
6273         m_attrCache.row = -1;
6274     }
6275 }
6276
6277 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
6278 {
6279     wxGrid *self = (wxGrid *)this;  // const_cast
6280
6281     self->ClearAttrCache();
6282     self->m_attrCache.row = row;
6283     self->m_attrCache.col = col;
6284     self->m_attrCache.attr = attr;
6285     attr->SafeIncRef();
6286 }
6287
6288 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
6289 {
6290     if ( row == m_attrCache.row && col == m_attrCache.col )
6291     {
6292         *attr = m_attrCache.attr;
6293         (*attr)->SafeIncRef();
6294
6295 #ifdef DEBUG_ATTR_CACHE
6296         gs_nAttrCacheHits++;
6297 #endif
6298
6299         return TRUE;
6300     }
6301     else
6302     {
6303 #ifdef DEBUG_ATTR_CACHE
6304         gs_nAttrCacheMisses++;
6305 #endif
6306         return FALSE;
6307     }
6308 }
6309
6310 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
6311 {
6312     wxGridCellAttr *attr;
6313     if ( !LookupAttr(row, col, &attr) )
6314     {
6315         attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
6316         CacheAttr(row, col, attr);
6317     }
6318     if (attr)
6319     {
6320         attr->SetDefAttr(m_defaultCellAttr);
6321     }
6322     else
6323     {
6324         attr = m_defaultCellAttr;
6325         attr->IncRef();
6326     }
6327
6328     return attr;
6329 }
6330
6331 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
6332 {
6333     wxGridCellAttr *attr;
6334     if ( !LookupAttr(row, col, &attr) || !attr )
6335     {
6336         wxASSERT_MSG( m_table,
6337                       _T("we may only be called if CanHaveAttributes() "
6338                          "returned TRUE and then m_table should be !NULL") );
6339
6340         attr = m_table->GetAttr(row, col);
6341         if ( !attr )
6342         {
6343             attr = new wxGridCellAttr;
6344
6345             // artificially inc the ref count to match DecRef() in caller
6346             attr->IncRef();
6347
6348             m_table->SetAttr(attr, row, col);
6349         }
6350
6351         CacheAttr(row, col, attr);
6352     }
6353     attr->SetDefAttr(m_defaultCellAttr);
6354     return attr;
6355 }
6356
6357 // ----------------------------------------------------------------------------
6358 // setting cell attributes: this is forwarded to the table
6359 // ----------------------------------------------------------------------------
6360
6361 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
6362 {
6363     if ( CanHaveAttributes() )
6364     {
6365         m_table->SetRowAttr(attr, row);
6366     }
6367     else
6368     {
6369         attr->SafeDecRef();
6370     }
6371 }
6372
6373 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
6374 {
6375     if ( CanHaveAttributes() )
6376     {
6377         m_table->SetColAttr(attr, col);
6378     }
6379     else
6380     {
6381         attr->SafeDecRef();
6382     }
6383 }
6384
6385 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
6386 {
6387     if ( CanHaveAttributes() )
6388     {
6389         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6390         attr->SetBackgroundColour(colour);
6391         attr->DecRef();
6392     }
6393 }
6394
6395 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
6396 {
6397     if ( CanHaveAttributes() )
6398     {
6399         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6400         attr->SetTextColour(colour);
6401         attr->DecRef();
6402     }
6403 }
6404
6405 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
6406 {
6407     if ( CanHaveAttributes() )
6408     {
6409         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6410         attr->SetFont(font);
6411         attr->DecRef();
6412     }
6413 }
6414
6415 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
6416 {
6417     if ( CanHaveAttributes() )
6418     {
6419         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6420         attr->SetAlignment(horiz, vert);
6421         attr->DecRef();
6422     }
6423 }
6424
6425 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
6426 {
6427     if ( CanHaveAttributes() )
6428     {
6429         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6430         attr->SetRenderer(renderer);
6431         attr->DecRef();
6432     }
6433 }
6434
6435 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
6436 {
6437     if ( CanHaveAttributes() )
6438     {
6439         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6440         attr->SetEditor(editor);
6441         attr->DecRef();
6442     }
6443 }
6444
6445 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
6446 {
6447     if ( CanHaveAttributes() )
6448     {
6449         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
6450         attr->SetReadOnly(isReadOnly);
6451         attr->DecRef();
6452     }
6453 }
6454
6455 // ----------------------------------------------------------------------------
6456 // Data type registration
6457 // ----------------------------------------------------------------------------
6458
6459 void wxGrid::RegisterDataType(const wxString& typeName,
6460                               wxGridCellRenderer* renderer,
6461                               wxGridCellEditor* editor)
6462 {
6463     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
6464 }
6465
6466
6467 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
6468 {
6469     wxString typeName = m_table->GetTypeName(row, col);
6470     return GetDefaultEditorForType(typeName);
6471 }
6472
6473 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
6474 {
6475     wxString typeName = m_table->GetTypeName(row, col);
6476     return GetDefaultRendererForType(typeName);
6477 }
6478
6479 wxGridCellEditor*
6480 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
6481 {
6482     int index = m_typeRegistry->FindDataType(typeName);
6483     if (index == -1) {
6484         // Should we force the failure here or let it fallback to string handling???
6485         // wxFAIL_MSG(wxT("Unknown data type name"));
6486         return NULL;
6487     }
6488     return m_typeRegistry->GetEditor(index);
6489 }
6490
6491 wxGridCellRenderer*
6492 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
6493 {
6494     int index = m_typeRegistry->FindDataType(typeName);
6495     if (index == -1) {
6496         // Should we force the failure here or let it fallback to string handling???
6497         // wxFAIL_MSG(wxT("Unknown data type name"));
6498         return NULL;
6499     }
6500     return m_typeRegistry->GetRenderer(index);
6501 }
6502
6503
6504 // ----------------------------------------------------------------------------
6505 // row/col size
6506 // ----------------------------------------------------------------------------
6507
6508 void wxGrid::EnableDragRowSize( bool enable )
6509 {
6510     m_canDragRowSize = enable;
6511 }
6512
6513
6514 void wxGrid::EnableDragColSize( bool enable )
6515 {
6516     m_canDragColSize = enable;
6517 }
6518
6519
6520 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
6521 {
6522     m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
6523
6524     if ( resizeExistingRows )
6525     {
6526         InitRowHeights();
6527
6528         CalcDimensions();
6529     }
6530 }
6531
6532 void wxGrid::SetRowSize( int row, int height )
6533 {
6534     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
6535
6536     if ( m_rowHeights.IsEmpty() )
6537     {
6538         // need to really create the array
6539         InitRowHeights();
6540     }
6541
6542     int h = wxMax( 0, height );
6543     int diff = h - m_rowHeights[row];
6544
6545     m_rowHeights[row] = h;
6546     int i;
6547     for ( i = row;  i < m_numRows;  i++ )
6548     {
6549         m_rowBottoms[i] += diff;
6550     }
6551     CalcDimensions();
6552 }
6553
6554 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
6555 {
6556     m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
6557
6558     if ( resizeExistingCols )
6559     {
6560         InitColWidths();
6561
6562         CalcDimensions();
6563     }
6564 }
6565
6566 void wxGrid::SetColSize( int col, int width )
6567 {
6568     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
6569
6570     // should we check that it's bigger than GetColMinimalWidth(col) here?
6571
6572     if ( m_colWidths.IsEmpty() )
6573     {
6574         // need to really create the array
6575         InitColWidths();
6576     }
6577
6578     int w = wxMax( 0, width );
6579     int diff = w - m_colWidths[col];
6580     m_colWidths[col] = w;
6581
6582     int i;
6583     for ( i = col;  i < m_numCols;  i++ )
6584     {
6585         m_colRights[i] += diff;
6586     }
6587     CalcDimensions();
6588 }
6589
6590
6591 void wxGrid::SetColMinimalWidth( int col, int width )
6592 {
6593     m_colMinWidths.Put(col, (wxObject *)width);
6594 }
6595
6596 int wxGrid::GetColMinimalWidth(int col) const
6597 {
6598     wxObject *obj = m_colMinWidths.Get(m_dragRowOrCol);
6599     return obj ? (int)obj : WXGRID_MIN_COL_WIDTH;
6600 }
6601
6602 //
6603 // ------ cell value accessor functions
6604 //
6605
6606 void wxGrid::SetCellValue( int row, int col, const wxString& s )
6607 {
6608     if ( m_table )
6609     {
6610         m_table->SetValue( row, col, s.c_str() );
6611         if ( !GetBatchCount() )
6612         {
6613             wxClientDC dc( m_gridWin );
6614             PrepareDC( dc );
6615             DrawCell( dc, wxGridCellCoords(row, col) );
6616         }
6617
6618 #if 0  // TODO: edit in place
6619
6620         if ( m_currentCellCoords.GetRow() == row &&
6621              m_currentCellCoords.GetCol() == col )
6622         {
6623             SetEditControlValue( s );
6624         }
6625 #endif
6626
6627     }
6628 }
6629
6630
6631 //
6632 // ------ Block, row and col selection
6633 //
6634
6635 void wxGrid::SelectRow( int row, bool addToSelected )
6636 {
6637     wxRect r;
6638
6639     if ( IsSelection() && addToSelected )
6640     {
6641         wxRect  rect[4];
6642         bool    need_refresh[4];
6643         need_refresh[0] =
6644         need_refresh[1] =
6645         need_refresh[2] =
6646         need_refresh[3] = FALSE;
6647
6648         int     i;
6649
6650         wxCoord oldLeft   = m_selectedTopLeft.GetCol();
6651         wxCoord oldTop    = m_selectedTopLeft.GetRow();
6652         wxCoord oldRight  = m_selectedBottomRight.GetCol();
6653         wxCoord oldBottom = m_selectedBottomRight.GetRow();
6654
6655         if ( oldTop > row )
6656         {
6657             need_refresh[0] = TRUE;
6658             rect[0] = BlockToDeviceRect( wxGridCellCoords ( row, 0 ),
6659                                          wxGridCellCoords ( oldTop - 1,
6660                                                             m_numCols - 1 ) );
6661             m_selectedTopLeft.SetRow( row );
6662         }
6663
6664         if ( oldLeft > 0 )
6665         {
6666             need_refresh[1] = TRUE;
6667             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop, 0 ),
6668                                          wxGridCellCoords ( oldBottom,
6669                                                             oldLeft - 1 ) );
6670
6671             m_selectedTopLeft.SetCol( 0 );
6672         }
6673
6674         if ( oldBottom < row )
6675         {
6676             need_refresh[2] = TRUE;
6677             rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1, 0 ),
6678                                          wxGridCellCoords ( row,
6679                                                             m_numCols - 1 ) );
6680             m_selectedBottomRight.SetRow( row );
6681         }
6682
6683         if ( oldRight < m_numCols - 1 )
6684         {
6685             need_refresh[3] = TRUE;
6686             rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldTop ,
6687                                                             oldRight + 1 ),
6688                                          wxGridCellCoords ( oldBottom,
6689                                                             m_numCols - 1 ) );
6690             m_selectedBottomRight.SetCol( m_numCols - 1 );
6691         }
6692
6693         for (i = 0; i < 4; i++ )
6694             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6695                 m_gridWin->Refresh( FALSE, &(rect[i]) );
6696     }
6697     else
6698     {
6699         r = SelectionToDeviceRect();
6700         ClearSelection();
6701         if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
6702
6703         m_selectedTopLeft.Set( row, 0 );
6704         m_selectedBottomRight.Set( row, m_numCols-1 );
6705         r = SelectionToDeviceRect();
6706         m_gridWin->Refresh( FALSE, &r );
6707     }
6708
6709     wxGridRangeSelectEvent gridEvt( GetId(),
6710                                     wxEVT_GRID_RANGE_SELECT,
6711                                     this,
6712                                     m_selectedTopLeft,
6713                                     m_selectedBottomRight );
6714
6715     GetEventHandler()->ProcessEvent(gridEvt);
6716 }
6717
6718
6719 void wxGrid::SelectCol( int col, bool addToSelected )
6720 {
6721     if ( IsSelection() && addToSelected )
6722     {
6723         wxRect  rect[4];
6724         bool    need_refresh[4];
6725         need_refresh[0] =
6726         need_refresh[1] =
6727         need_refresh[2] =
6728         need_refresh[3] = FALSE;
6729         int     i;
6730
6731         wxCoord oldLeft   = m_selectedTopLeft.GetCol();
6732         wxCoord oldTop    = m_selectedTopLeft.GetRow();
6733         wxCoord oldRight  = m_selectedBottomRight.GetCol();
6734         wxCoord oldBottom = m_selectedBottomRight.GetRow();
6735
6736         if ( oldLeft > col )
6737         {
6738             need_refresh[0] = TRUE;
6739             rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
6740                                          wxGridCellCoords ( m_numRows - 1,
6741                                                             oldLeft - 1 ) );
6742             m_selectedTopLeft.SetCol( col );
6743         }
6744
6745         if ( oldTop  > 0 )
6746         {
6747             need_refresh[1] = TRUE;
6748             rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
6749                                          wxGridCellCoords ( oldTop - 1,
6750                                                             oldRight ) );
6751             m_selectedTopLeft.SetRow( 0 );
6752         }
6753
6754         if ( oldRight < col )
6755         {
6756             need_refresh[2] = TRUE;
6757             rect[2] = BlockToDeviceRect( wxGridCellCoords ( 0, oldRight + 1 ),
6758                                          wxGridCellCoords ( m_numRows - 1,
6759                                                             col            ) );
6760             m_selectedBottomRight.SetCol( col );
6761         }
6762
6763         if ( oldBottom < m_numRows - 1 )
6764         {
6765             need_refresh[3] = TRUE;
6766             rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1,
6767                                                             oldLeft ),
6768                                          wxGridCellCoords ( m_numRows - 1,
6769                                                             oldRight ) );
6770             m_selectedBottomRight.SetRow( m_numRows - 1 );
6771         }
6772
6773         for (i = 0; i < 4; i++ )
6774             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6775                 m_gridWin->Refresh( FALSE, &(rect[i]) );
6776     }
6777     else
6778     {
6779         wxRect r;
6780
6781         r = SelectionToDeviceRect();
6782         ClearSelection();
6783         if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );
6784
6785         m_selectedTopLeft.Set( 0, col );
6786         m_selectedBottomRight.Set( m_numRows-1, col );
6787         r = SelectionToDeviceRect();
6788         m_gridWin->Refresh( FALSE, &r );
6789     }
6790
6791     wxGridRangeSelectEvent gridEvt( GetId(),
6792                                     wxEVT_GRID_RANGE_SELECT,
6793                                     this,
6794                                     m_selectedTopLeft,
6795                                     m_selectedBottomRight );
6796
6797     GetEventHandler()->ProcessEvent(gridEvt);
6798 }
6799
6800
6801 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
6802 {
6803     int temp;
6804     wxGridCellCoords updateTopLeft, updateBottomRight;
6805
6806     if ( topRow > bottomRow )
6807     {
6808         temp = topRow;
6809         topRow = bottomRow;
6810         bottomRow = temp;
6811     }
6812
6813     if ( leftCol > rightCol )
6814     {
6815         temp = leftCol;
6816         leftCol = rightCol;
6817         rightCol = temp;
6818     }
6819
6820     updateTopLeft = wxGridCellCoords( topRow, leftCol );
6821     updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
6822
6823     if ( m_selectedTopLeft != updateTopLeft ||
6824          m_selectedBottomRight != updateBottomRight )
6825     {
6826         // Compute two optimal update rectangles:
6827         // Either one rectangle is a real subset of the
6828         // other, or they are (almost) disjoint!
6829         wxRect  rect[4];
6830         bool    need_refresh[4];
6831         need_refresh[0] =
6832         need_refresh[1] =
6833         need_refresh[2] =
6834         need_refresh[3] = FALSE;
6835         int     i;
6836
6837         // Store intermediate values
6838         wxCoord oldLeft   = m_selectedTopLeft.GetCol();
6839         wxCoord oldTop    = m_selectedTopLeft.GetRow();
6840         wxCoord oldRight  = m_selectedBottomRight.GetCol();
6841         wxCoord oldBottom = m_selectedBottomRight.GetRow();
6842
6843         // Determine the outer/inner coordinates.
6844         if (oldLeft > leftCol)
6845         {
6846             temp = oldLeft;
6847             oldLeft = leftCol;
6848             leftCol = temp;
6849         }
6850         if (oldTop > topRow )
6851         {
6852             temp = oldTop;
6853             oldTop = topRow;
6854             topRow = temp;
6855         }
6856         if (oldRight < rightCol )
6857         {
6858             temp = oldRight;
6859             oldRight = rightCol;
6860             rightCol = temp;
6861         }
6862         if (oldBottom < bottomRow)
6863         {
6864             temp = oldBottom;
6865             oldBottom = bottomRow;
6866             bottomRow = temp;
6867         }
6868
6869         // Now, either the stuff marked old is the outer
6870         // rectangle or we don't have a situation where one
6871         // is contained in the other.
6872
6873         if ( oldLeft < leftCol )
6874         {
6875             need_refresh[0] = TRUE;
6876             rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6877                                                             oldLeft ),
6878                                          wxGridCellCoords ( oldBottom,
6879                                                             leftCol - 1 ) );
6880         }
6881
6882         if ( oldTop  < topRow )
6883         {
6884             need_refresh[1] = TRUE;
6885             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6886                                                             leftCol ),
6887                                          wxGridCellCoords ( topRow - 1,
6888                                                             rightCol ) );
6889         }
6890
6891         if ( oldRight > rightCol )
6892         {
6893             need_refresh[2] = TRUE;
6894             rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6895                                                             rightCol + 1 ),
6896                                          wxGridCellCoords ( oldBottom,
6897                                                             oldRight ) );
6898         }
6899
6900         if ( oldBottom > bottomRow )
6901         {
6902             need_refresh[3] = TRUE;
6903             rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6904                                                             leftCol ),
6905                                          wxGridCellCoords ( oldBottom,
6906                                                             rightCol ) );
6907         }
6908
6909
6910         // Change Selection
6911         m_selectedTopLeft = updateTopLeft;
6912         m_selectedBottomRight = updateBottomRight;
6913
6914         // various Refresh() calls
6915         for (i = 0; i < 4; i++ )
6916             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6917                 m_gridWin->Refresh( FALSE, &(rect[i]) );
6918     }
6919
6920     // only generate an event if the block is not being selected by
6921     // dragging the mouse (in which case the event will be generated in
6922     // the mouse event handler)
6923     if ( !m_isDragging )
6924     {
6925         wxGridRangeSelectEvent gridEvt( GetId(),
6926                                         wxEVT_GRID_RANGE_SELECT,
6927                                         this,
6928                                         m_selectedTopLeft,
6929                                         m_selectedBottomRight );
6930
6931         GetEventHandler()->ProcessEvent(gridEvt);
6932     }
6933 }
6934
6935 void wxGrid::SelectAll()
6936 {
6937     m_selectedTopLeft.Set( 0, 0 );
6938     m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
6939
6940     m_gridWin->Refresh();
6941 }
6942
6943
6944 void wxGrid::ClearSelection()
6945 {
6946     m_selectedTopLeft = wxGridNoCellCoords;
6947     m_selectedBottomRight = wxGridNoCellCoords;
6948 }
6949
6950
6951 // This function returns the rectangle that encloses the given block
6952 // in device coords clipped to the client size of the grid window.
6953 //
6954 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
6955                                   const wxGridCellCoords &bottomRight )
6956 {
6957     wxRect rect( wxGridNoCellRect );
6958     wxRect cellRect;
6959
6960     cellRect = CellToRect( topLeft );
6961     if ( cellRect != wxGridNoCellRect )
6962     {
6963         rect = cellRect;
6964     }
6965     else
6966     {
6967         rect = wxRect( 0, 0, 0, 0 );
6968     }
6969
6970     cellRect = CellToRect( bottomRight );
6971     if ( cellRect != wxGridNoCellRect )
6972     {
6973         rect += cellRect;
6974     }
6975     else
6976     {
6977         return wxGridNoCellRect;
6978     }
6979
6980     // convert to scrolled coords
6981     //
6982     int left, top, right, bottom;
6983     CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
6984     CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
6985
6986     int cw, ch;
6987     m_gridWin->GetClientSize( &cw, &ch );
6988
6989     rect.SetLeft( wxMax(0, left) );
6990     rect.SetTop( wxMax(0, top) );
6991     rect.SetRight( wxMin(cw, right) );
6992     rect.SetBottom( wxMin(ch, bottom) );
6993
6994     return rect;
6995 }
6996
6997
6998
6999 //
7000 // ------ Grid event classes
7001 //
7002
7003 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
7004
7005 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
7006                           int row, int col, int x, int y,
7007                           bool control, bool shift, bool alt, bool meta )
7008         : wxNotifyEvent( type, id )
7009 {
7010     m_row = row;
7011     m_col = col;
7012     m_x = x;
7013     m_y = y;
7014     m_control = control;
7015     m_shift = shift;
7016     m_alt = alt;
7017     m_meta = meta;
7018
7019     SetEventObject(obj);
7020 }
7021
7022
7023 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
7024
7025 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
7026                                   int rowOrCol, int x, int y,
7027                                   bool control, bool shift, bool alt, bool meta )
7028         : wxNotifyEvent( type, id )
7029 {
7030     m_rowOrCol = rowOrCol;
7031     m_x = x;
7032     m_y = y;
7033     m_control = control;
7034     m_shift = shift;
7035     m_alt = alt;
7036     m_meta = meta;
7037
7038     SetEventObject(obj);
7039 }
7040
7041
7042 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
7043
7044 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
7045                                                const wxGridCellCoords& topLeft,
7046                                                const wxGridCellCoords& bottomRight,
7047                                                bool control, bool shift, bool alt, bool meta )
7048         : wxNotifyEvent( type, id )
7049 {
7050     m_topLeft     = topLeft;
7051     m_bottomRight = bottomRight;
7052     m_control     = control;
7053     m_shift       = shift;
7054     m_alt         = alt;
7055     m_meta        = meta;
7056
7057     SetEventObject(obj);
7058 }
7059
7060
7061 #endif // ifndef wxUSE_NEW_GRID
7062