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