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