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();
3633
3634     // Set default cell attributes
3635     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
3636     m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
3637     m_defaultCellAttr->SetFont(GetFont());
3638     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
3639     m_defaultCellAttr->SetTextColour(
3640         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
3641     m_defaultCellAttr->SetBackgroundColour(
3642         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
3643     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3644     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
3645
3646
3647     m_numRows = 0;
3648     m_numCols = 0;
3649     m_currentCellCoords = wxGridNoCellCoords;
3650
3651     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3652     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3653
3654     // create the type registry
3655     m_typeRegistry = new wxGridTypeRegistry;
3656     m_selection = 0;
3657     // subwindow components that make up the wxGrid
3658     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3659                                                     -1,
3660                                                     wxDefaultPosition,
3661                                                     wxDefaultSize );
3662
3663     m_rowLabelWin = new wxGridRowLabelWindow( this,
3664                                               -1,
3665                                               wxDefaultPosition,
3666                                               wxDefaultSize );
3667
3668     m_colLabelWin = new wxGridColLabelWindow( this,
3669                                               -1,
3670                                               wxDefaultPosition,
3671                                               wxDefaultSize );
3672
3673     m_gridWin = new wxGridWindow( this,
3674                                   m_rowLabelWin,
3675                                   m_colLabelWin,
3676                                   -1,
3677                                   wxDefaultPosition,
3678                                   wxDefaultSize );
3679
3680     SetTargetWindow( m_gridWin );
3681
3682     Init();
3683 }
3684
3685
3686 bool wxGrid::CreateGrid( int numRows, int numCols,
3687                          wxGrid::wxGridSelectionModes selmode )
3688 {
3689     wxCHECK_MSG( !m_created,
3690                  FALSE,
3691                  wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3692
3693     m_numRows = numRows;
3694     m_numCols = numCols;
3695
3696     m_table = new wxGridStringTable( m_numRows, m_numCols );
3697     m_table->SetView( this );
3698     m_ownTable = TRUE;
3699     m_selection = new wxGridSelection( this, selmode );
3700
3701     CalcDimensions();
3702
3703     m_created = TRUE;
3704
3705     return m_created;
3706 }
3707
3708 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3709 {
3710     wxCHECK_RET( m_created,
3711                  wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3712
3713     m_selection->SetSelectionMode( selmode );
3714 }
3715
3716 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3717                        wxGrid::wxGridSelectionModes selmode )
3718 {
3719     if ( m_created )
3720     {
3721         // RD: Actually, this should probably be allowed.  I think it would be
3722         // nice to be able to switch multiple Tables in and out of a single
3723         // View at runtime.  Is there anything in the implmentation that would
3724         // prevent this?
3725
3726         // At least, you now have to cope with m_selection
3727         wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3728         return FALSE;
3729     }
3730     else
3731     {
3732         m_numRows = table->GetNumberRows();
3733         m_numCols = table->GetNumberCols();
3734
3735         m_table = table;
3736         m_table->SetView( this );
3737         if (takeOwnership)
3738             m_ownTable = TRUE;
3739         m_selection = new wxGridSelection( this, selmode );
3740
3741         CalcDimensions();
3742
3743         m_created = TRUE;
3744     }
3745
3746     return m_created;
3747 }
3748
3749
3750 void wxGrid::Init()
3751 {
3752     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3753     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3754
3755     if ( m_rowLabelWin )
3756     {
3757         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
3758     }
3759     else
3760     {
3761         m_labelBackgroundColour = wxColour( _T("WHITE") );
3762     }
3763
3764     m_labelTextColour = wxColour( _T("BLACK") );
3765
3766     // init attr cache
3767     m_attrCache.row = -1;
3768
3769     // TODO: something better than this ?
3770     //
3771     m_labelFont = this->GetFont();
3772     m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
3773
3774     m_rowLabelHorizAlign = wxALIGN_LEFT;
3775     m_rowLabelVertAlign  = wxALIGN_CENTRE;
3776
3777     m_colLabelHorizAlign = wxALIGN_CENTRE;
3778     m_colLabelVertAlign  = wxALIGN_TOP;
3779
3780     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
3781     m_defaultRowHeight = m_gridWin->GetCharHeight();
3782
3783 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
3784     m_defaultRowHeight += 8;
3785 #else
3786     m_defaultRowHeight += 4;
3787 #endif
3788
3789     m_gridLineColour = wxColour( 128, 128, 255 );
3790     m_gridLinesEnabled = TRUE;
3791     m_cellHighlightColour = m_gridLineColour;
3792     m_cellHighlightPenWidth = 2;
3793     m_cellHighlightROPenWidth = 1;
3794
3795     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
3796     m_winCapture = (wxWindow *)NULL;
3797     m_canDragRowSize = TRUE;
3798     m_canDragColSize = TRUE;
3799     m_canDragGridSize = TRUE;
3800     m_dragLastPos  = -1;
3801     m_dragRowOrCol = -1;
3802     m_isDragging = FALSE;
3803     m_startDragPos = wxDefaultPosition;
3804
3805     m_waitForSlowClick = FALSE;
3806
3807     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
3808     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
3809
3810     m_currentCellCoords = wxGridNoCellCoords;
3811
3812     m_selectingTopLeft = wxGridNoCellCoords;
3813     m_selectingBottomRight = wxGridNoCellCoords;
3814     m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
3815     m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
3816
3817     m_editable = TRUE;  // default for whole grid
3818
3819     m_inOnKeyDown = FALSE;
3820     m_batchCount = 0;
3821
3822     m_extraWidth =
3823     m_extraHeight = 0;
3824 }
3825
3826 // ----------------------------------------------------------------------------
3827 // the idea is to call these functions only when necessary because they create
3828 // quite big arrays which eat memory mostly unnecessary - in particular, if
3829 // default widths/heights are used for all rows/columns, we may not use these
3830 // arrays at all
3831 //
3832 // with some extra code, it should be possible to only store the
3833 // widths/heights different from default ones but this will be done later...
3834 // ----------------------------------------------------------------------------
3835
3836 void wxGrid::InitRowHeights()
3837 {
3838     m_rowHeights.Empty();
3839     m_rowBottoms.Empty();
3840
3841     m_rowHeights.Alloc( m_numRows );
3842     m_rowBottoms.Alloc( m_numRows );
3843
3844     int rowBottom = 0;
3845     for ( int i = 0;  i < m_numRows;  i++ )
3846     {
3847         m_rowHeights.Add( m_defaultRowHeight );
3848         rowBottom += m_defaultRowHeight;
3849         m_rowBottoms.Add( rowBottom );
3850     }
3851 }
3852
3853 void wxGrid::InitColWidths()
3854 {
3855     m_colWidths.Empty();
3856     m_colRights.Empty();
3857
3858     m_colWidths.Alloc( m_numCols );
3859     m_colRights.Alloc( m_numCols );
3860     int colRight = 0;
3861     for ( int i = 0;  i < m_numCols;  i++ )
3862     {
3863         m_colWidths.Add( m_defaultColWidth );
3864         colRight += m_defaultColWidth;
3865         m_colRights.Add( colRight );
3866     }
3867 }
3868
3869 int wxGrid::GetColWidth(int col) const
3870 {
3871     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
3872 }
3873
3874 int wxGrid::GetColLeft(int col) const
3875 {
3876     return m_colRights.IsEmpty() ? col * m_defaultColWidth
3877                                  : m_colRights[col] - m_colWidths[col];
3878 }
3879
3880 int wxGrid::GetColRight(int col) const
3881 {
3882     return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
3883                                  : m_colRights[col];
3884 }
3885
3886 int wxGrid::GetRowHeight(int row) const
3887 {
3888     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
3889 }
3890
3891 int wxGrid::GetRowTop(int row) const
3892 {
3893     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
3894                                   : m_rowBottoms[row] - m_rowHeights[row];
3895 }
3896
3897 int wxGrid::GetRowBottom(int row) const
3898 {
3899     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
3900                                   : m_rowBottoms[row];
3901 }
3902
3903 void wxGrid::CalcDimensions()
3904 {
3905     int cw, ch;
3906     GetClientSize( &cw, &ch );
3907
3908     if ( m_rowLabelWin->IsShown() )
3909         cw -= m_rowLabelWidth;
3910     if ( m_colLabelWin->IsShown() )
3911         ch -= m_colLabelHeight;
3912
3913     // grid total size
3914     int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
3915     int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
3916
3917     // preserve (more or less) the previous position
3918     int x, y;
3919     GetViewStart( &x, &y );
3920
3921     // maybe we don't need scrollbars at all?
3922     //
3923     // also adjust the position to be valid for the new scroll rangs
3924     if ( w <= cw )
3925     {
3926         w = x = 0;
3927     }
3928     else
3929     {
3930         if ( x >= w )
3931             x = w - 1;
3932     }
3933
3934     if ( h <= ch )
3935     {
3936         h = y = 0;
3937     }
3938     else
3939     {
3940         if ( y >= h )
3941             y = h - 1;
3942     }
3943
3944     // do set scrollbar parameters
3945     SetScrollbars( GRID_SCROLL_LINE_X, GRID_SCROLL_LINE_Y,
3946                    GetScrollX(w), GetScrollY(h), x, y,
3947                    GetBatchCount() != 0);
3948 }
3949
3950
3951 void wxGrid::CalcWindowSizes()
3952 {
3953     int cw, ch;
3954     GetClientSize( &cw, &ch );
3955
3956     if ( m_cornerLabelWin->IsShown() )
3957         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
3958
3959     if ( m_colLabelWin->IsShown() )
3960         m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
3961
3962     if ( m_rowLabelWin->IsShown() )
3963         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
3964
3965     if ( m_gridWin->IsShown() )
3966         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
3967 }
3968
3969
3970 // this is called when the grid table sends a message to say that it
3971 // has been redimensioned
3972 //
3973 bool wxGrid::Redimension( wxGridTableMessage& msg )
3974 {
3975     int i;
3976     bool result = FALSE;
3977
3978 #if 0
3979     // if we were using the default widths/heights so far, we must change them
3980     // now
3981     if ( m_colWidths.IsEmpty() )
3982     {
3983         InitColWidths();
3984     }
3985
3986     if ( m_rowHeights.IsEmpty() )
3987     {
3988         InitRowHeights();
3989     }
3990 #endif
3991
3992     switch ( msg.GetId() )
3993     {
3994         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
3995         {
3996             size_t pos = msg.GetCommandInt();
3997             int numRows = msg.GetCommandInt2();
3998
3999             m_numRows += numRows;
4000
4001             if ( !m_rowHeights.IsEmpty() )
4002             {
4003                 for ( i = 0;  i < numRows;  i++ )
4004                 {
4005                     m_rowHeights.Insert( m_defaultRowHeight, pos );
4006                     m_rowBottoms.Insert( 0, pos );
4007                 }
4008
4009                 int bottom = 0;
4010                 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
4011
4012                 for ( i = pos;  i < m_numRows;  i++ )
4013                 {
4014                     bottom += m_rowHeights[i];
4015                     m_rowBottoms[i] = bottom;
4016                 }
4017             }
4018             if ( m_currentCellCoords == wxGridNoCellCoords )
4019             {
4020                 // if we have just inserted cols into an empty grid the current
4021                 // cell will be undefined...
4022                 //
4023                 SetCurrentCell( 0, 0 );
4024             }
4025             m_selection->UpdateRows( pos, numRows );
4026             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4027             if (attrProvider)
4028                 attrProvider->UpdateAttrRows( pos, numRows );
4029
4030             if ( !GetBatchCount() )
4031             {
4032                 CalcDimensions();
4033                 m_rowLabelWin->Refresh();
4034             }
4035         }
4036         result = TRUE;
4037         break;
4038
4039         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4040         {
4041             int numRows = msg.GetCommandInt();
4042             int oldNumRows = m_numRows;
4043             m_numRows += numRows;
4044
4045             if ( !m_rowHeights.IsEmpty() )
4046             {
4047                 for ( i = 0;  i < numRows;  i++ )
4048                 {
4049                     m_rowHeights.Add( m_defaultRowHeight );
4050                     m_rowBottoms.Add( 0 );
4051                 }
4052
4053                 int bottom = 0;
4054                 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
4055
4056                 for ( i = oldNumRows;  i < m_numRows;  i++ )
4057                 {
4058                     bottom += m_rowHeights[i];
4059                     m_rowBottoms[i] = bottom;
4060                 }
4061             }
4062             if ( m_currentCellCoords == wxGridNoCellCoords )
4063             {
4064                 // if we have just inserted cols into an empty grid the current
4065                 // cell will be undefined...
4066                 //
4067                 SetCurrentCell( 0, 0 );
4068             }
4069             if ( !GetBatchCount() )
4070             {
4071                 CalcDimensions();
4072                 m_rowLabelWin->Refresh();
4073             }
4074         }
4075         result = TRUE;
4076         break;
4077
4078         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4079         {
4080             size_t pos = msg.GetCommandInt();
4081             int numRows = msg.GetCommandInt2();
4082             m_numRows -= numRows;
4083
4084             if ( !m_rowHeights.IsEmpty() )
4085             {
4086                 for ( i = 0;  i < numRows;  i++ )
4087                 {
4088                     m_rowHeights.RemoveAt( pos );
4089                     m_rowBottoms.RemoveAt( pos );
4090                 }
4091
4092                 int h = 0;
4093                 for ( i = 0;  i < m_numRows;  i++ )
4094                 {
4095                     h += m_rowHeights[i];
4096                     m_rowBottoms[i] = h;
4097                 }
4098             }
4099             if ( !m_numRows )
4100             {
4101                 m_currentCellCoords = wxGridNoCellCoords;
4102             }
4103             else
4104             {
4105                 if ( m_currentCellCoords.GetRow() >= m_numRows )
4106                     m_currentCellCoords.Set( 0, 0 );
4107             }
4108             m_selection->UpdateRows( pos, -((int)numRows) );
4109             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4110             if (attrProvider) {
4111                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4112 // ifdef'd out following patch from Paul Gammans
4113 #if 0
4114                 // No need to touch column attributes, unless we
4115                 // removed _all_ rows, in this case, we remove
4116                 // all column attributes.
4117                 // I hate to do this here, but the
4118                 // needed data is not available inside UpdateAttrRows.
4119                 if ( !GetNumberRows() )
4120                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4121 #endif
4122             }
4123             if ( !GetBatchCount() )
4124             {
4125                 CalcDimensions();
4126                 m_rowLabelWin->Refresh();
4127             }
4128         }
4129         result = TRUE;
4130         break;
4131
4132         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4133         {
4134             size_t pos = msg.GetCommandInt();
4135             int numCols = msg.GetCommandInt2();
4136             m_numCols += numCols;
4137
4138             if ( !m_colWidths.IsEmpty() )
4139             {
4140                 for ( i = 0;  i < numCols;  i++ )
4141                 {
4142                     m_colWidths.Insert( m_defaultColWidth, pos );
4143                     m_colRights.Insert( 0, pos );
4144                 }
4145
4146                 int right = 0;
4147                 if ( pos > 0 ) right = m_colRights[pos-1];
4148
4149                 for ( i = pos;  i < m_numCols;  i++ )
4150                 {
4151                     right += m_colWidths[i];
4152                     m_colRights[i] = right;
4153                 }
4154             }
4155             if ( m_currentCellCoords == wxGridNoCellCoords )
4156             {
4157                 // if we have just inserted cols into an empty grid the current
4158                 // cell will be undefined...
4159                 //
4160                 SetCurrentCell( 0, 0 );
4161             }
4162             m_selection->UpdateCols( pos, numCols );
4163             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4164             if (attrProvider)
4165                 attrProvider->UpdateAttrCols( pos, numCols );
4166             if ( !GetBatchCount() )
4167             {
4168                 CalcDimensions();
4169                 m_colLabelWin->Refresh();
4170             }
4171
4172         }
4173         result = TRUE;
4174         break;
4175
4176         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4177         {
4178             int numCols = msg.GetCommandInt();
4179             int oldNumCols = m_numCols;
4180             m_numCols += numCols;
4181             if ( !m_colWidths.IsEmpty() )
4182             {
4183                 for ( i = 0;  i < numCols;  i++ )
4184                 {
4185                     m_colWidths.Add( m_defaultColWidth );
4186                     m_colRights.Add( 0 );
4187                 }
4188
4189                 int right = 0;
4190                 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
4191
4192                 for ( i = oldNumCols;  i < m_numCols;  i++ )
4193                 {
4194                     right += m_colWidths[i];
4195                     m_colRights[i] = right;
4196                 }
4197             }
4198             if ( m_currentCellCoords == wxGridNoCellCoords )
4199             {
4200                 // if we have just inserted cols into an empty grid the current
4201                 // cell will be undefined...
4202                 //
4203                 SetCurrentCell( 0, 0 );
4204             }
4205             if ( !GetBatchCount() )
4206             {
4207                 CalcDimensions();
4208                 m_colLabelWin->Refresh();
4209             }
4210         }
4211         result = TRUE;
4212         break;
4213
4214         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4215         {
4216             size_t pos = msg.GetCommandInt();
4217             int numCols = msg.GetCommandInt2();
4218             m_numCols -= numCols;
4219
4220             if ( !m_colWidths.IsEmpty() )
4221             {
4222                 for ( i = 0;  i < numCols;  i++ )
4223                 {
4224                     m_colWidths.RemoveAt( pos );
4225                     m_colRights.RemoveAt( pos );
4226                 }
4227
4228                 int w = 0;
4229                 for ( i = 0;  i < m_numCols;  i++ )
4230                 {
4231                     w += m_colWidths[i];
4232                     m_colRights[i] = w;
4233                 }
4234             }
4235             if ( !m_numCols )
4236             {
4237                 m_currentCellCoords = wxGridNoCellCoords;
4238             }
4239             else
4240             {
4241                 if ( m_currentCellCoords.GetCol() >= m_numCols )
4242                   m_currentCellCoords.Set( 0, 0 );
4243             }
4244             m_selection->UpdateCols( pos, -((int)numCols) );
4245             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4246             if (attrProvider) {
4247                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
4248 // ifdef'd out following patch from Paul Gammans
4249 #if 0
4250                 // No need to touch row attributes, unless we
4251                 // removed _all_ columns, in this case, we remove
4252                 // all row attributes.
4253                 // I hate to do this here, but the
4254                 // needed data is not available inside UpdateAttrCols.
4255                 if ( !GetNumberCols() )
4256                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
4257 #endif
4258             }
4259             if ( !GetBatchCount() )
4260             {
4261                 CalcDimensions();
4262                 m_colLabelWin->Refresh();
4263             }
4264         }
4265         result = TRUE;
4266         break;
4267     }
4268
4269     if (result && !GetBatchCount() )
4270         m_gridWin->Refresh();
4271     return result;
4272 }
4273
4274
4275 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
4276 {
4277     wxRegionIterator iter( reg );
4278     wxRect r;
4279
4280     wxArrayInt  rowlabels;
4281
4282     int top, bottom;
4283     while ( iter )
4284     {
4285         r = iter.GetRect();
4286
4287         // TODO: remove this when we can...
4288         // There is a bug in wxMotif that gives garbage update
4289         // rectangles if you jump-scroll a long way by clicking the
4290         // scrollbar with middle button.  This is a work-around
4291         //
4292 #if defined(__WXMOTIF__)
4293         int cw, ch;
4294         m_gridWin->GetClientSize( &cw, &ch );
4295         if ( r.GetTop() > ch ) r.SetTop( 0 );
4296         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4297 #endif
4298
4299         // logical bounds of update region
4300         //
4301         int dummy;
4302         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4303         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4304
4305         // find the row labels within these bounds
4306         //
4307         int row;
4308         for ( row = 0;  row < m_numRows;  row++ )
4309         {
4310             if ( GetRowBottom(row) < top )
4311                 continue;
4312
4313             if ( GetRowTop(row) > bottom )
4314                 break;
4315
4316             rowlabels.Add( row );
4317         }
4318
4319         iter++ ;
4320     }
4321
4322     return rowlabels;
4323 }
4324
4325
4326 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4327 {
4328     wxRegionIterator iter( reg );
4329     wxRect r;
4330
4331     wxArrayInt colLabels;
4332
4333     int left, right;
4334     while ( iter )
4335     {
4336         r = iter.GetRect();
4337
4338         // TODO: remove this when we can...
4339         // There is a bug in wxMotif that gives garbage update
4340         // rectangles if you jump-scroll a long way by clicking the
4341         // scrollbar with middle button.  This is a work-around
4342         //
4343 #if defined(__WXMOTIF__)
4344         int cw, ch;
4345         m_gridWin->GetClientSize( &cw, &ch );
4346         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4347         r.SetRight( wxMin( r.GetRight(), cw ) );
4348 #endif
4349
4350         // logical bounds of update region
4351         //
4352         int dummy;
4353         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4354         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4355
4356         // find the cells within these bounds
4357         //
4358         int col;
4359         for ( col = 0;  col < m_numCols;  col++ )
4360         {
4361             if ( GetColRight(col) < left )
4362                 continue;
4363
4364             if ( GetColLeft(col) > right )
4365                 break;
4366
4367             colLabels.Add( col );
4368         }
4369
4370         iter++ ;
4371     }
4372     return colLabels;
4373 }
4374
4375
4376 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
4377 {
4378     wxRegionIterator iter( reg );
4379     wxRect r;
4380
4381     wxGridCellCoordsArray  cellsExposed;
4382
4383     int left, top, right, bottom;
4384     while ( iter )
4385     {
4386         r = iter.GetRect();
4387
4388         // TODO: remove this when we can...
4389         // There is a bug in wxMotif that gives garbage update
4390         // rectangles if you jump-scroll a long way by clicking the
4391         // scrollbar with middle button.  This is a work-around
4392         //
4393 #if defined(__WXMOTIF__)
4394         int cw, ch;
4395         m_gridWin->GetClientSize( &cw, &ch );
4396         if ( r.GetTop() > ch ) r.SetTop( 0 );
4397         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4398         r.SetRight( wxMin( r.GetRight(), cw ) );
4399         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4400 #endif
4401
4402         // logical bounds of update region
4403         //
4404         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4405         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4406
4407         // find the cells within these bounds
4408         //
4409         int row, col;
4410         for ( row = 0;  row < m_numRows;  row++ )
4411         {
4412             if ( GetRowBottom(row) <= top )
4413                 continue;
4414
4415             if ( GetRowTop(row) > bottom )
4416                 break;
4417
4418
4419             for ( col = 0;  col < m_numCols;  col++ )
4420             {
4421                 if ( GetColRight(col) <= left )
4422                     continue;
4423
4424                 if ( GetColLeft(col) > right )
4425                     break;
4426
4427                 cellsExposed.Add( wxGridCellCoords( row, col ) );
4428             }
4429         }
4430
4431         iter++;
4432     }
4433
4434     return cellsExposed;
4435 }
4436
4437
4438 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4439 {
4440     int x, y, row;
4441     wxPoint pos( event.GetPosition() );
4442     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4443
4444     if ( event.Dragging() )
4445     {
4446         m_isDragging = TRUE;
4447
4448         if ( event.LeftIsDown() )
4449         {
4450             switch( m_cursorMode )
4451             {
4452                 case WXGRID_CURSOR_RESIZE_ROW:
4453                 {
4454                     int cw, ch, left, dummy;
4455                     m_gridWin->GetClientSize( &cw, &ch );
4456                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
4457
4458                     wxClientDC dc( m_gridWin );
4459                     PrepareDC( dc );
4460                     y = wxMax( y,
4461                                GetRowTop(m_dragRowOrCol) +
4462                                GetRowMinimalHeight(m_dragRowOrCol) );
4463                     dc.SetLogicalFunction(wxINVERT);
4464                     if ( m_dragLastPos >= 0 )
4465                     {
4466                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4467                     }
4468                     dc.DrawLine( left, y, left+cw, y );
4469                     m_dragLastPos = y;
4470                 }
4471                 break;
4472
4473                 case WXGRID_CURSOR_SELECT_ROW:
4474                     if ( (row = YToRow( y )) >= 0 )
4475                     {
4476                         m_selection->SelectRow( row,
4477                                                 event.ControlDown(),
4478                                                 event.ShiftDown(),
4479                                                 event.AltDown(),
4480                                                 event.MetaDown() );
4481                     }
4482
4483                 // default label to suppress warnings about "enumeration value
4484                 // 'xxx' not handled in switch
4485                 default:
4486                     break;
4487             }
4488         }
4489         return;
4490     }
4491
4492     m_isDragging = FALSE;
4493
4494
4495     // ------------ Entering or leaving the window
4496     //
4497     if ( event.Entering() || event.Leaving() )
4498     {
4499         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4500     }
4501
4502
4503     // ------------ Left button pressed
4504     //
4505     else if ( event.LeftDown() )
4506     {
4507         // don't send a label click event for a hit on the
4508         // edge of the row label - this is probably the user
4509         // wanting to resize the row
4510         //
4511         if ( YToEdgeOfRow(y) < 0 )
4512         {
4513             row = YToRow(y);
4514             if ( row >= 0  &&
4515                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4516             {
4517                 if ( !event.ShiftDown() && !event.ControlDown() )
4518                     ClearSelection();
4519                 if ( event.ShiftDown() )
4520                     m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4521                                               0,
4522                                               row,
4523                                               GetNumberCols() - 1,
4524                                               event.ControlDown(),
4525                                               event.ShiftDown(),
4526                                               event.AltDown(),
4527                                               event.MetaDown() );
4528                 else
4529                     m_selection->SelectRow( row,
4530                                             event.ControlDown(),
4531                                             event.ShiftDown(),
4532                                             event.AltDown(),
4533                                             event.MetaDown() );
4534                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4535             }
4536         }
4537         else
4538         {
4539             // starting to drag-resize a row
4540             //
4541             if ( CanDragRowSize() )
4542                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4543         }
4544     }
4545
4546
4547     // ------------ Left double click
4548     //
4549     else if (event.LeftDClick() )
4550     {
4551         if ( YToEdgeOfRow(y) < 0 )
4552         {
4553             row = YToRow(y);
4554             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
4555         }
4556     }
4557
4558
4559     // ------------ Left button released
4560     //
4561     else if ( event.LeftUp() )
4562     {
4563         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4564         {
4565             DoEndDragResizeRow();
4566
4567             // Note: we are ending the event *after* doing
4568             // default processing in this case
4569             //
4570             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4571         }
4572
4573         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4574         m_dragLastPos = -1;
4575     }
4576
4577
4578     // ------------ Right button down
4579     //
4580     else if ( event.RightDown() )
4581     {
4582         row = YToRow(y);
4583         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4584         {
4585             // no default action at the moment
4586         }
4587     }
4588
4589
4590     // ------------ Right double click
4591     //
4592     else if ( event.RightDClick() )
4593     {
4594         row = YToRow(y);
4595         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4596         {
4597             // no default action at the moment
4598         }
4599     }
4600
4601
4602     // ------------ No buttons down and mouse moving
4603     //
4604     else if ( event.Moving() )
4605     {
4606         m_dragRowOrCol = YToEdgeOfRow( y );
4607         if ( m_dragRowOrCol >= 0 )
4608         {
4609             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4610             {
4611                 // don't capture the mouse yet
4612                 if ( CanDragRowSize() )
4613                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4614             }
4615         }
4616         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4617         {
4618             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4619         }
4620     }
4621 }
4622
4623
4624 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4625 {
4626     int x, y, col;
4627     wxPoint pos( event.GetPosition() );
4628     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4629
4630     if ( event.Dragging() )
4631     {
4632         m_isDragging = TRUE;
4633
4634         if ( event.LeftIsDown() )
4635         {
4636             switch( m_cursorMode )
4637             {
4638                 case WXGRID_CURSOR_RESIZE_COL:
4639                 {
4640                     int cw, ch, dummy, top;
4641                     m_gridWin->GetClientSize( &cw, &ch );
4642                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
4643
4644                     wxClientDC dc( m_gridWin );
4645                     PrepareDC( dc );
4646
4647                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4648                                   GetColMinimalWidth(m_dragRowOrCol));
4649                     dc.SetLogicalFunction(wxINVERT);
4650                     if ( m_dragLastPos >= 0 )
4651                     {
4652                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4653                     }
4654                     dc.DrawLine( x, top, x, top+ch );
4655                     m_dragLastPos = x;
4656                 }
4657                 break;
4658
4659                 case WXGRID_CURSOR_SELECT_COL:
4660                     if ( (col = XToCol( x )) >= 0 )
4661                     {
4662                         m_selection->SelectCol( col,
4663                                                 event.ControlDown(),
4664                                                 event.ShiftDown(),
4665                                                 event.AltDown(),
4666                                                 event.MetaDown() );
4667                     }
4668
4669                 // default label to suppress warnings about "enumeration value
4670                 // 'xxx' not handled in switch
4671                 default:
4672                     break;
4673             }
4674         }
4675         return;
4676     }
4677
4678     m_isDragging = FALSE;
4679
4680
4681     // ------------ Entering or leaving the window
4682     //
4683     if ( event.Entering() || event.Leaving() )
4684     {
4685         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4686     }
4687
4688
4689     // ------------ Left button pressed
4690     //
4691     else if ( event.LeftDown() )
4692     {
4693         // don't send a label click event for a hit on the
4694         // edge of the col label - this is probably the user
4695         // wanting to resize the col
4696         //
4697         if ( XToEdgeOfCol(x) < 0 )
4698         {
4699             col = XToCol(x);
4700             if ( col >= 0  &&
4701                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
4702             {
4703                 if ( !event.ShiftDown() && !event.ControlDown() )
4704                     ClearSelection();
4705                 if ( event.ShiftDown() )
4706                     m_selection->SelectBlock( 0,
4707                                               m_currentCellCoords.GetCol(),
4708                                               GetNumberRows() - 1, col,
4709                                               event.ControlDown(),
4710                                               event.ShiftDown(),
4711                                               event.AltDown(),
4712                                               event.MetaDown() );
4713                 else
4714                     m_selection->SelectCol( col,
4715                                             event.ControlDown(),
4716                                             event.ShiftDown(),
4717                                             event.AltDown(),
4718                                             event.MetaDown() );
4719                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
4720             }
4721         }
4722         else
4723         {
4724             // starting to drag-resize a col
4725             //
4726             if ( CanDragColSize() )
4727                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
4728         }
4729     }
4730
4731
4732     // ------------ Left double click
4733     //
4734     if ( event.LeftDClick() )
4735     {
4736         if ( XToEdgeOfCol(x) < 0 )
4737         {
4738             col = XToCol(x);
4739             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
4740         }
4741     }
4742
4743
4744     // ------------ Left button released
4745     //
4746     else if ( event.LeftUp() )
4747     {
4748         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4749         {
4750             DoEndDragResizeCol();
4751
4752             // Note: we are ending the event *after* doing
4753             // default processing in this case
4754             //
4755             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
4756         }
4757
4758         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4759         m_dragLastPos  = -1;
4760     }
4761
4762
4763     // ------------ Right button down
4764     //
4765     else if ( event.RightDown() )
4766     {
4767         col = XToCol(x);
4768         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
4769         {
4770             // no default action at the moment
4771         }
4772     }
4773
4774
4775     // ------------ Right double click
4776     //
4777     else if ( event.RightDClick() )
4778     {
4779         col = XToCol(x);
4780         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
4781         {
4782             // no default action at the moment
4783         }
4784     }
4785
4786
4787     // ------------ No buttons down and mouse moving
4788     //
4789     else if ( event.Moving() )
4790     {
4791         m_dragRowOrCol = XToEdgeOfCol( x );
4792         if ( m_dragRowOrCol >= 0 )
4793         {
4794             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4795             {
4796                 // don't capture the cursor yet
4797                 if ( CanDragColSize() )
4798                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
4799             }
4800         }
4801         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4802         {
4803             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
4804         }
4805     }
4806 }
4807
4808
4809 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
4810 {
4811     if ( event.LeftDown() )
4812     {
4813         // indicate corner label by having both row and
4814         // col args == -1
4815         //
4816         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
4817         {
4818             SelectAll();
4819         }
4820     }
4821
4822     else if ( event.LeftDClick() )
4823     {
4824         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
4825     }
4826
4827     else if ( event.RightDown() )
4828     {
4829         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
4830         {
4831             // no default action at the moment
4832         }
4833     }
4834
4835     else if ( event.RightDClick() )
4836     {
4837         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
4838         {
4839             // no default action at the moment
4840         }
4841     }
4842 }
4843
4844 void wxGrid::ChangeCursorMode(CursorMode mode,
4845                               wxWindow *win,
4846                               bool captureMouse)
4847 {
4848 #ifdef __WXDEBUG__
4849     static const wxChar *cursorModes[] =
4850     {
4851         _T("SELECT_CELL"),
4852         _T("RESIZE_ROW"),
4853         _T("RESIZE_COL"),
4854         _T("SELECT_ROW"),
4855         _T("SELECT_COL")
4856     };
4857
4858     wxLogTrace(_T("grid"),
4859                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
4860                win == m_colLabelWin ? _T("colLabelWin")
4861                                     : win ? _T("rowLabelWin")
4862                                           : _T("gridWin"),
4863                cursorModes[m_cursorMode], cursorModes[mode]);
4864 #endif // __WXDEBUG__
4865
4866     if ( mode == m_cursorMode &&
4867          win == m_winCapture &&
4868          captureMouse == (m_winCapture != NULL))
4869         return;
4870
4871     if ( !win )
4872     {
4873         // by default use the grid itself
4874         win = m_gridWin;
4875     }
4876
4877     if ( m_winCapture )
4878     {
4879         m_winCapture->ReleaseMouse();
4880         m_winCapture = (wxWindow *)NULL;
4881     }
4882
4883     m_cursorMode = mode;
4884
4885     switch ( m_cursorMode )
4886     {
4887         case WXGRID_CURSOR_RESIZE_ROW:
4888             win->SetCursor( m_rowResizeCursor );
4889             break;
4890
4891         case WXGRID_CURSOR_RESIZE_COL:
4892             win->SetCursor( m_colResizeCursor );
4893             break;
4894
4895         default:
4896             win->SetCursor( *wxSTANDARD_CURSOR );
4897     }
4898
4899     // we need to capture mouse when resizing
4900     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
4901                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
4902
4903     if ( captureMouse && resize )
4904     {
4905         win->CaptureMouse();
4906         m_winCapture = win;
4907     }
4908 }
4909
4910 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
4911 {
4912     int x, y;
4913     wxPoint pos( event.GetPosition() );
4914     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4915
4916     wxGridCellCoords coords;
4917     XYToCell( x, y, coords );
4918
4919     if ( event.Dragging() )
4920     {
4921         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4922
4923         // Don't start doing anything until the mouse has been drug at
4924         // least 3 pixels in any direction...
4925         if (! m_isDragging)
4926         {
4927             if (m_startDragPos == wxDefaultPosition)
4928             {
4929                 m_startDragPos = pos;
4930                 return;
4931             }
4932             if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
4933                 return;
4934         }
4935
4936         m_isDragging = TRUE;
4937         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4938         {
4939             // Hide the edit control, so it
4940             // won't interfer with drag-shrinking.
4941             if ( IsCellEditControlShown() )
4942             {
4943                 HideCellEditControl();
4944                 SaveEditControlValue();
4945             }
4946
4947             // Have we captured the mouse yet?
4948             if (! m_winCapture)
4949             {
4950                 m_winCapture = m_gridWin;
4951                 m_winCapture->CaptureMouse();
4952             }
4953
4954             if ( coords != wxGridNoCellCoords )
4955             {
4956                 if ( event.ControlDown() )
4957                 {
4958                     if ( m_selectingKeyboard == wxGridNoCellCoords)
4959                         m_selectingKeyboard = coords;
4960                     HighlightBlock ( m_selectingKeyboard, coords );
4961                 }
4962                 else
4963                 {
4964                     if ( !IsSelection() )
4965                     {
4966                         HighlightBlock( coords, coords );
4967                     }
4968                     else
4969                     {
4970                         HighlightBlock( m_currentCellCoords, coords );
4971                     }
4972                 }
4973
4974                 if (! IsVisible(coords))
4975                 {
4976                     MakeCellVisible(coords);
4977                     // TODO: need to introduce a delay or something here.  The
4978                     // scrolling is way to fast, at least on MSW - also on GTK.
4979                 }
4980             }
4981         }
4982         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4983         {
4984             int cw, ch, left, dummy;
4985             m_gridWin->GetClientSize( &cw, &ch );
4986             CalcUnscrolledPosition( 0, 0, &left, &dummy );
4987
4988             wxClientDC dc( m_gridWin );
4989             PrepareDC( dc );
4990             y = wxMax( y, GetRowTop(m_dragRowOrCol) +
4991                           GetRowMinimalHeight(m_dragRowOrCol) );
4992             dc.SetLogicalFunction(wxINVERT);
4993             if ( m_dragLastPos >= 0 )
4994             {
4995                 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4996             }
4997             dc.DrawLine( left, y, left+cw, y );
4998             m_dragLastPos = y;
4999         }
5000         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5001         {
5002             int cw, ch, dummy, top;
5003             m_gridWin->GetClientSize( &cw, &ch );
5004             CalcUnscrolledPosition( 0, 0, &dummy, &top );
5005
5006             wxClientDC dc( m_gridWin );
5007             PrepareDC( dc );
5008             x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5009                           GetColMinimalWidth(m_dragRowOrCol) );
5010             dc.SetLogicalFunction(wxINVERT);
5011             if ( m_dragLastPos >= 0 )
5012             {
5013                 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5014             }
5015             dc.DrawLine( x, top, x, top+ch );
5016             m_dragLastPos = x;
5017         }
5018
5019         return;
5020     }
5021
5022     m_isDragging = FALSE;
5023     m_startDragPos = wxDefaultPosition;
5024
5025     // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5026     //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5027     //     wxGTK
5028 #if 0
5029     if ( event.Entering() || event.Leaving() )
5030     {
5031         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5032         m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
5033     }
5034     else
5035 #endif // 0
5036
5037     // ------------ Left button pressed
5038     //
5039     if ( event.LeftDown() && coords != wxGridNoCellCoords )
5040     {
5041         if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
5042                        coords.GetRow(),
5043                        coords.GetCol(),
5044                        event ) )
5045         {
5046             if ( !event.ControlDown() )
5047                 ClearSelection();
5048             if ( event.ShiftDown() )
5049             {
5050                 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5051                                           m_currentCellCoords.GetCol(),
5052                                           coords.GetRow(),
5053                                           coords.GetCol(),
5054                                           event.ControlDown(),
5055                                           event.ShiftDown(),
5056                                           event.AltDown(),
5057                                           event.MetaDown() );
5058             }
5059             else if ( XToEdgeOfCol(x) < 0  &&
5060                       YToEdgeOfRow(y) < 0 )
5061             {
5062                 DisableCellEditControl();
5063                 MakeCellVisible( coords );
5064
5065                 // if this is the second click on this cell then start
5066                 // the edit control
5067                 if ( m_waitForSlowClick &&
5068                      (coords == m_currentCellCoords) &&
5069                      CanEnableCellControl())
5070                 {
5071                     EnableCellEditControl();
5072
5073                     wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5074                     wxGridCellEditor *editor = attr->GetEditor(this,
5075                                                                coords.GetRow(),
5076                                                                coords.GetCol());
5077                     editor->StartingClick();
5078                     editor->DecRef();
5079                     attr->DecRef();
5080
5081                     m_waitForSlowClick = FALSE;
5082                 }
5083                 else
5084                 {
5085                     if ( event.ControlDown() )
5086                     {
5087                         m_selection->ToggleCellSelection( coords.GetRow(),
5088                                                           coords.GetCol(),
5089                                                           event.ControlDown(),
5090                                                           event.ShiftDown(),
5091                                                           event.AltDown(),
5092                                                           event.MetaDown() );
5093                         m_selectingTopLeft = wxGridNoCellCoords;
5094                         m_selectingBottomRight = wxGridNoCellCoords;
5095                         m_selectingKeyboard = coords;
5096                     }
5097                     else
5098                     {
5099                         SetCurrentCell( coords );
5100                         if ( m_selection->GetSelectionMode()
5101                              != wxGrid::wxGridSelectCells)
5102                             HighlightBlock( coords, coords );
5103                     }
5104                     m_waitForSlowClick = TRUE;
5105                 }
5106             }
5107         }
5108     }
5109
5110
5111     // ------------ Left double click
5112     //
5113     else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
5114     {
5115         DisableCellEditControl();
5116
5117         if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
5118         {
5119             SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
5120                        coords.GetRow(),
5121                        coords.GetCol(),
5122                        event );
5123         }
5124     }
5125
5126
5127     // ------------ Left button released
5128     //
5129     else if ( event.LeftUp() )
5130     {
5131         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5132         {
5133             if ( m_selectingTopLeft != wxGridNoCellCoords &&
5134                  m_selectingBottomRight != wxGridNoCellCoords )
5135             {
5136                 if (m_winCapture)
5137                 {
5138                     m_winCapture->ReleaseMouse();
5139                     m_winCapture = NULL;
5140                 }
5141                 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5142                                           m_selectingTopLeft.GetCol(),
5143                                           m_selectingBottomRight.GetRow(),
5144                                           m_selectingBottomRight.GetCol(),
5145                                           event.ControlDown(),
5146                                           event.ShiftDown(),
5147                                           event.AltDown(),
5148                                           event.MetaDown() );
5149                 m_selectingTopLeft = wxGridNoCellCoords;
5150                 m_selectingBottomRight = wxGridNoCellCoords;
5151             }
5152
5153             // Show the edit control, if it has been hidden for
5154             // drag-shrinking.
5155             ShowCellEditControl();
5156         }
5157         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5158         {
5159             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5160             DoEndDragResizeRow();
5161
5162             // Note: we are ending the event *after* doing
5163             // default processing in this case
5164             //
5165             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5166         }
5167         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5168         {
5169             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5170             DoEndDragResizeCol();
5171
5172             // Note: we are ending the event *after* doing
5173             // default processing in this case
5174             //
5175             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5176         }
5177
5178         m_dragLastPos = -1;
5179     }
5180
5181
5182     // ------------ Right button down
5183     //
5184     else if ( event.RightDown() && coords != wxGridNoCellCoords )
5185     {
5186         DisableCellEditControl();
5187         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
5188                          coords.GetRow(),
5189                          coords.GetCol(),
5190                          event ) )
5191         {
5192             // no default action at the moment
5193         }
5194     }
5195
5196
5197     // ------------ Right double click
5198     //
5199     else if ( event.RightDClick() && coords != wxGridNoCellCoords )
5200     {
5201         DisableCellEditControl();
5202         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
5203                          coords.GetRow(),
5204                          coords.GetCol(),
5205                          event ) )
5206         {
5207             // no default action at the moment
5208         }
5209     }
5210
5211     // ------------ Moving and no button action
5212     //
5213     else if ( event.Moving() && !event.IsButton() )
5214     {
5215         int dragRow = YToEdgeOfRow( y );
5216         int dragCol = XToEdgeOfCol( x );
5217
5218         // Dragging on the corner of a cell to resize in both
5219         // directions is not implemented yet...
5220         //
5221         if ( dragRow >= 0  &&  dragCol >= 0 )
5222         {
5223             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5224             return;
5225         }
5226
5227         if ( dragRow >= 0 )
5228         {
5229             m_dragRowOrCol = dragRow;
5230
5231             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5232             {
5233                 if ( CanDragRowSize() && CanDragGridSize() )
5234                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
5235             }
5236
5237             if ( dragCol >= 0 )
5238             {
5239                 m_dragRowOrCol = dragCol;
5240             }
5241
5242             return;
5243         }
5244
5245         if ( dragCol >= 0 )
5246         {
5247             m_dragRowOrCol = dragCol;
5248
5249             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5250             {
5251                 if ( CanDragColSize() && CanDragGridSize() )
5252                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
5253             }
5254
5255             return;
5256         }
5257
5258         // Neither on a row or col edge
5259         //
5260         if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5261         {
5262             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5263         }
5264     }
5265 }
5266
5267
5268 void wxGrid::DoEndDragResizeRow()
5269 {
5270     if ( m_dragLastPos >= 0 )
5271     {
5272         // erase the last line and resize the row
5273         //
5274         int cw, ch, left, dummy;
5275         m_gridWin->GetClientSize( &cw, &ch );
5276         CalcUnscrolledPosition( 0, 0, &left, &dummy );
5277
5278         wxClientDC dc( m_gridWin );
5279         PrepareDC( dc );
5280         dc.SetLogicalFunction( wxINVERT );
5281         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5282         HideCellEditControl();
5283         SaveEditControlValue();
5284
5285         int rowTop = GetRowTop(m_dragRowOrCol);
5286         SetRowSize( m_dragRowOrCol,
5287                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
5288
5289         if ( !GetBatchCount() )
5290         {
5291             // Only needed to get the correct rect.y:
5292             wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5293             rect.x = 0;
5294             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5295             rect.width = m_rowLabelWidth;
5296             rect.height = ch - rect.y;
5297             m_rowLabelWin->Refresh( TRUE, &rect );
5298             rect.width = cw;
5299             m_gridWin->Refresh( FALSE, &rect );
5300         }
5301
5302         ShowCellEditControl();
5303     }
5304 }
5305
5306
5307 void wxGrid::DoEndDragResizeCol()
5308 {
5309     if ( m_dragLastPos >= 0 )
5310     {
5311         // erase the last line and resize the col
5312         //
5313         int cw, ch, dummy, top;
5314         m_gridWin->GetClientSize( &cw, &ch );
5315         CalcUnscrolledPosition( 0, 0, &dummy, &top );
5316
5317         wxClientDC dc( m_gridWin );
5318         PrepareDC( dc );
5319         dc.SetLogicalFunction( wxINVERT );
5320         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5321         HideCellEditControl();
5322         SaveEditControlValue();
5323
5324         int colLeft = GetColLeft(m_dragRowOrCol);
5325         SetColSize( m_dragRowOrCol,
5326                     wxMax( m_dragLastPos - colLeft,
5327                            GetColMinimalWidth(m_dragRowOrCol) ) );
5328
5329         if ( !GetBatchCount() )
5330         {
5331             // Only needed to get the correct rect.x:
5332             wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5333             rect.y = 0;
5334             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5335             rect.width = cw - rect.x;
5336             rect.height = m_colLabelHeight;
5337             m_colLabelWin->Refresh( TRUE, &rect );
5338             rect.height = ch;
5339             m_gridWin->Refresh( FALSE, &rect );
5340         }
5341
5342         ShowCellEditControl();
5343     }
5344 }
5345
5346
5347
5348 //
5349 // ------ interaction with data model
5350 //
5351 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5352 {
5353     switch ( msg.GetId() )
5354     {
5355         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5356             return GetModelValues();
5357
5358         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5359             return SetModelValues();
5360
5361         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5362         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5363         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5364         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5365         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5366         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5367             return Redimension( msg );
5368
5369         default:
5370             return FALSE;
5371     }
5372 }
5373
5374
5375
5376 // The behaviour of this function depends on the grid table class
5377 // Clear() function.  For the default wxGridStringTable class the
5378 // behavious is to replace all cell contents with wxEmptyString but
5379 // not to change the number of rows or cols.
5380 //
5381 void wxGrid::ClearGrid()
5382 {
5383     if ( m_table )
5384     {
5385         if (IsCellEditControlEnabled())
5386             DisableCellEditControl();
5387
5388         m_table->Clear();
5389         if ( !GetBatchCount() ) m_gridWin->Refresh();
5390     }
5391 }
5392
5393
5394 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5395 {
5396     // TODO: something with updateLabels flag
5397
5398     if ( !m_created )
5399     {
5400         wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5401         return FALSE;
5402     }
5403
5404     if ( m_table )
5405     {
5406         if (IsCellEditControlEnabled())
5407             DisableCellEditControl();
5408
5409         return m_table->InsertRows( pos, numRows );
5410
5411         // the table will have sent the results of the insert row
5412         // operation to this view object as a grid table message
5413     }
5414     return FALSE;
5415 }
5416
5417
5418 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5419 {
5420     // TODO: something with updateLabels flag
5421
5422     if ( !m_created )
5423     {
5424         wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5425         return FALSE;
5426     }
5427
5428     return ( m_table && m_table->AppendRows( numRows ) );
5429     // the table will have sent the results of the append row
5430     // operation to this view object as a grid table message
5431 }
5432
5433
5434 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5435 {
5436     // TODO: something with updateLabels flag
5437
5438     if ( !m_created )
5439     {
5440         wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5441         return FALSE;
5442     }
5443
5444     if ( m_table )
5445     {
5446         if (IsCellEditControlEnabled())
5447             DisableCellEditControl();
5448
5449         return (m_table->DeleteRows( pos, numRows ));
5450         // the table will have sent the results of the delete row
5451         // operation to this view object as a grid table message
5452     }
5453     return FALSE;
5454 }
5455
5456
5457 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5458 {
5459     // TODO: something with updateLabels flag
5460
5461     if ( !m_created )
5462     {
5463         wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5464         return FALSE;
5465     }
5466
5467     if ( m_table )
5468     {
5469         if (IsCellEditControlEnabled())
5470             DisableCellEditControl();
5471
5472         return m_table->InsertCols( pos, numCols );
5473         // the table will have sent the results of the insert col
5474         // operation to this view object as a grid table message
5475     }
5476     return FALSE;
5477 }
5478
5479
5480 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5481 {
5482     // TODO: something with updateLabels flag
5483
5484     if ( !m_created )
5485     {
5486         wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5487         return FALSE;
5488     }
5489
5490     return ( m_table && m_table->AppendCols( numCols ) );
5491     // the table will have sent the results of the append col
5492     // operation to this view object as a grid table message
5493 }
5494
5495
5496 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5497 {
5498     // TODO: something with updateLabels flag
5499
5500     if ( !m_created )
5501     {
5502         wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5503         return FALSE;
5504     }
5505
5506     if ( m_table )
5507     {
5508         if (IsCellEditControlEnabled())
5509             DisableCellEditControl();
5510
5511         return ( m_table->DeleteCols( pos, numCols ) );
5512         // the table will have sent the results of the delete col
5513         // operation to this view object as a grid table message
5514     }
5515     return FALSE;
5516 }
5517
5518
5519
5520 //
5521 // ----- event handlers
5522 //
5523
5524 // Generate a grid event based on a mouse event and
5525 // return the result of ProcessEvent()
5526 //
5527 int wxGrid::SendEvent( const wxEventType type,
5528                         int row, int col,
5529                         wxMouseEvent& mouseEv )
5530 {
5531    bool claimed;
5532    bool vetoed= FALSE;
5533
5534    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5535    {
5536        int rowOrCol = (row == -1 ? col : row);
5537
5538        wxGridSizeEvent gridEvt( GetId(),
5539                type,
5540                this,
5541                rowOrCol,
5542                mouseEv.GetX() + GetRowLabelSize(),
5543                mouseEv.GetY() + GetColLabelSize(),
5544                mouseEv.ControlDown(),
5545                mouseEv.ShiftDown(),
5546                mouseEv.AltDown(),
5547                mouseEv.MetaDown() );
5548
5549        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5550        vetoed = !gridEvt.IsAllowed();
5551    }
5552    else if ( type == wxEVT_GRID_RANGE_SELECT )
5553    {
5554        // Right now, it should _never_ end up here!
5555        wxGridRangeSelectEvent gridEvt( GetId(),
5556                type,
5557                this,
5558                m_selectingTopLeft,
5559                m_selectingBottomRight,
5560                TRUE,
5561                mouseEv.ControlDown(),
5562                mouseEv.ShiftDown(),
5563                mouseEv.AltDown(),
5564                mouseEv.MetaDown() );
5565
5566        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5567        vetoed = !gridEvt.IsAllowed();
5568    }
5569    else
5570    {
5571        wxGridEvent gridEvt( GetId(),
5572                type,
5573                this,
5574                row, col,
5575                mouseEv.GetX() + GetRowLabelSize(),
5576                mouseEv.GetY() + GetColLabelSize(),
5577                FALSE,
5578                mouseEv.ControlDown(),
5579                mouseEv.ShiftDown(),
5580                mouseEv.AltDown(),
5581                mouseEv.MetaDown() );
5582        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5583        vetoed = !gridEvt.IsAllowed();
5584    }
5585
5586    // A Veto'd event may not be `claimed' so test this first
5587    if (vetoed) return -1;
5588    return claimed ? 1 : 0;
5589 }
5590
5591
5592 // Generate a grid event of specified type and return the result
5593 // of ProcessEvent().
5594 //
5595 int wxGrid::SendEvent( const wxEventType type,
5596                         int row, int col )
5597 {
5598    bool claimed;
5599    bool vetoed= FALSE;
5600
5601     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5602     {
5603         int rowOrCol = (row == -1 ? col : row);
5604
5605         wxGridSizeEvent gridEvt( GetId(),
5606                                  type,
5607                                  this,
5608                                  rowOrCol );
5609
5610         claimed = GetEventHandler()->ProcessEvent(gridEvt);
5611         vetoed  = !gridEvt.IsAllowed();
5612     }
5613     else
5614     {
5615         wxGridEvent gridEvt( GetId(),
5616                              type,
5617                              this,
5618                              row, col );
5619
5620         claimed = GetEventHandler()->ProcessEvent(gridEvt);
5621         vetoed  = !gridEvt.IsAllowed();
5622      }
5623
5624     // A Veto'd event may not be `claimed' so test this first
5625     if (vetoed) return -1;
5626     return claimed ? 1 : 0;
5627 }
5628
5629
5630 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
5631 {
5632     wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
5633 }
5634
5635
5636 void wxGrid::OnSize( wxSizeEvent& event )
5637 {
5638     // position the child windows
5639     CalcWindowSizes();
5640
5641     // don't call CalcDimensions() from here, the base class handles the size
5642     // changes itself
5643     event.Skip();
5644 }
5645
5646
5647 void wxGrid::OnKeyDown( wxKeyEvent& event )
5648 {
5649     if ( m_inOnKeyDown )
5650     {
5651         // shouldn't be here - we are going round in circles...
5652         //
5653         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
5654     }
5655
5656     m_inOnKeyDown = TRUE;
5657
5658     // propagate the event up and see if it gets processed
5659     //
5660     wxWindow *parent = GetParent();
5661     wxKeyEvent keyEvt( event );
5662     keyEvt.SetEventObject( parent );
5663
5664     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
5665     {
5666
5667         // try local handlers
5668         //
5669         switch ( event.KeyCode() )
5670         {
5671             case WXK_UP:
5672                 if ( event.ControlDown() )
5673                 {
5674                     MoveCursorUpBlock( event.ShiftDown() );
5675                 }
5676                 else
5677                 {
5678                     MoveCursorUp( event.ShiftDown() );
5679                 }
5680                 break;
5681
5682             case WXK_DOWN:
5683                 if ( event.ControlDown() )
5684                 {
5685                     MoveCursorDownBlock( event.ShiftDown() );
5686                 }
5687                 else
5688                 {
5689                     MoveCursorDown( event.ShiftDown() );
5690                 }
5691                 break;
5692
5693             case WXK_LEFT:
5694                 if ( event.ControlDown() )
5695                 {
5696                     MoveCursorLeftBlock( event.ShiftDown() );
5697                 }
5698                 else
5699                 {
5700                     MoveCursorLeft( event.ShiftDown() );
5701                 }
5702                 break;
5703
5704             case WXK_RIGHT:
5705                 if ( event.ControlDown() )
5706                 {
5707                     MoveCursorRightBlock( event.ShiftDown() );
5708                 }
5709                 else
5710                 {
5711                     MoveCursorRight( event.ShiftDown() );
5712                 }
5713                 break;
5714
5715             case WXK_RETURN:
5716             case WXK_NUMPAD_ENTER:
5717                 if ( event.ControlDown() )
5718                 {
5719                     event.Skip();  // to let the edit control have the return
5720                 }
5721                 else
5722                 {
5723                     if ( GetGridCursorRow() < GetNumberRows()-1 )
5724                     {
5725                         MoveCursorDown( event.ShiftDown() );
5726                     }
5727                     else
5728                     {
5729                         // at the bottom of a column
5730                         HideCellEditControl();
5731                         SaveEditControlValue();
5732                     }
5733                 }
5734                 break;
5735
5736             case WXK_ESCAPE:
5737                 ClearSelection();
5738                 break;
5739
5740             case WXK_TAB:
5741                 if (event.ShiftDown())
5742                 {
5743                     if ( GetGridCursorCol() > 0 )
5744                     {
5745                         MoveCursorLeft( FALSE );
5746                     }
5747                     else
5748                     {
5749                         // at left of grid
5750                         HideCellEditControl();
5751                         SaveEditControlValue();
5752                     }
5753                 }
5754                 else
5755                 {
5756                     if ( GetGridCursorCol() < GetNumberCols()-1 )
5757                     {
5758                         MoveCursorRight( FALSE );
5759                     }
5760                     else
5761                     {
5762                         // at right of grid
5763                         HideCellEditControl();
5764                         SaveEditControlValue();
5765                     }
5766                 }
5767                 break;
5768
5769             case WXK_HOME:
5770                 if ( event.ControlDown() )
5771                 {
5772                     MakeCellVisible( 0, 0 );
5773                     SetCurrentCell( 0, 0 );
5774                 }
5775                 else
5776                 {
5777                     event.Skip();
5778                 }
5779                 break;
5780
5781             case WXK_END:
5782                 if ( event.ControlDown() )
5783                 {
5784                     MakeCellVisible( m_numRows-1, m_numCols-1 );
5785                     SetCurrentCell( m_numRows-1, m_numCols-1 );
5786                 }
5787                 else
5788                 {
5789                     event.Skip();
5790                 }
5791                 break;
5792
5793             case WXK_PRIOR:
5794                 MovePageUp();
5795                 break;
5796
5797             case WXK_NEXT:
5798                 MovePageDown();
5799                 break;
5800
5801             case WXK_SPACE:
5802                 if ( event.ControlDown() )
5803                 {
5804                     m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
5805                                                       m_currentCellCoords.GetCol(),
5806                                                       event.ControlDown(),
5807                                                       event.ShiftDown(),
5808                                                       event.AltDown(),
5809                                                       event.MetaDown() );
5810                     break;
5811                 }
5812                 if ( !IsEditable() )
5813                 {
5814                     MoveCursorRight( FALSE );
5815                     break;
5816                 }
5817                 // Otherwise fall through to default
5818
5819             default:
5820                 // is it possible to edit the current cell at all?
5821                 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5822                 {
5823                     // yes, now check whether the cells editor accepts the key
5824                     int row = m_currentCellCoords.GetRow();
5825                     int col = m_currentCellCoords.GetCol();
5826                     wxGridCellAttr* attr = GetCellAttr(row, col);
5827                     wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5828
5829                     // <F2> is special and will always start editing, for
5830                     // other keys - ask the editor itself
5831                     if ( (event.KeyCode() == WXK_F2 && !event.HasModifiers())
5832                          || editor->IsAcceptedKey(event) )
5833                     {
5834                         EnableCellEditControl();
5835                         editor->StartingKey(event);
5836                     }
5837                     else
5838                     {
5839                         event.Skip();
5840                     }
5841
5842                     editor->DecRef();
5843                     attr->DecRef();
5844                 }
5845                 else
5846                 {
5847                     // let others process char events with modifiers or all
5848                     // char events for readonly cells
5849                     event.Skip();
5850                 }
5851                 break;
5852         }
5853     }
5854
5855     m_inOnKeyDown = FALSE;
5856 }
5857
5858 void wxGrid::OnKeyUp( wxKeyEvent& event )
5859 {
5860     // try local handlers
5861     //
5862     if ( event.KeyCode() == WXK_SHIFT )
5863     {
5864         if ( m_selectingTopLeft != wxGridNoCellCoords &&
5865              m_selectingBottomRight != wxGridNoCellCoords )
5866             m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5867                                       m_selectingTopLeft.GetCol(),
5868                                       m_selectingBottomRight.GetRow(),
5869                                       m_selectingBottomRight.GetCol(),
5870                                       event.ControlDown(),
5871                                       TRUE,
5872                                       event.AltDown(),
5873                                       event.MetaDown() );
5874         m_selectingTopLeft = wxGridNoCellCoords;
5875         m_selectingBottomRight = wxGridNoCellCoords;
5876         m_selectingKeyboard = wxGridNoCellCoords;
5877     }
5878 }
5879
5880 void wxGrid::OnEraseBackground(wxEraseEvent&)
5881 {
5882 }
5883
5884 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
5885 {
5886     if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
5887     {
5888         // the event has been intercepted - do nothing
5889         return;
5890     }
5891
5892     wxClientDC dc(m_gridWin);
5893     PrepareDC(dc);
5894
5895     if ( m_currentCellCoords != wxGridNoCellCoords )
5896     {
5897         HideCellEditControl();
5898         DisableCellEditControl();
5899
5900         if ( IsVisible( m_currentCellCoords, FALSE ) )
5901         {
5902             wxRect r;
5903             r = BlockToDeviceRect(m_currentCellCoords, coords);
5904             if ( !m_gridLinesEnabled )
5905             {
5906                 r.x--;
5907                 r.y--;
5908                 r.width++;
5909                 r.height++;
5910             }
5911
5912              wxGridCellCoordsArray cells = CalcCellsExposed( r );
5913
5914             // Otherwise refresh redraws the highlight!
5915             m_currentCellCoords = coords;
5916
5917             DrawGridCellArea(dc,cells);
5918             DrawAllGridLines( dc, r );
5919         }
5920     }
5921
5922     m_currentCellCoords = coords;
5923
5924     wxGridCellAttr* attr = GetCellAttr(coords);
5925     DrawCellHighlight(dc, attr);
5926     attr->DecRef();
5927 }
5928
5929
5930 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
5931 {
5932     int temp;
5933     wxGridCellCoords updateTopLeft, updateBottomRight;
5934
5935     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
5936     {
5937         leftCol = 0;
5938         rightCol = GetNumberCols() - 1;
5939     }
5940     else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
5941     {
5942         topRow = 0;
5943         bottomRow = GetNumberRows() - 1;
5944     }
5945     if ( topRow > bottomRow )
5946     {
5947         temp = topRow;
5948         topRow = bottomRow;
5949         bottomRow = temp;
5950     }
5951
5952     if ( leftCol > rightCol )
5953     {
5954         temp = leftCol;
5955         leftCol = rightCol;
5956         rightCol = temp;
5957     }
5958
5959     updateTopLeft = wxGridCellCoords( topRow, leftCol );
5960     updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
5961
5962     if ( m_selectingTopLeft != updateTopLeft ||
5963          m_selectingBottomRight != updateBottomRight )
5964     {
5965         // Compute two optimal update rectangles:
5966         // Either one rectangle is a real subset of the
5967         // other, or they are (almost) disjoint!
5968         wxRect  rect[4];
5969         bool    need_refresh[4];
5970         need_refresh[0] =
5971         need_refresh[1] =
5972         need_refresh[2] =
5973         need_refresh[3] = FALSE;
5974         int     i;
5975
5976         // Store intermediate values
5977         wxCoord oldLeft   = m_selectingTopLeft.GetCol();
5978         wxCoord oldTop    = m_selectingTopLeft.GetRow();
5979         wxCoord oldRight  = m_selectingBottomRight.GetCol();
5980         wxCoord oldBottom = m_selectingBottomRight.GetRow();
5981
5982         // Determine the outer/inner coordinates.
5983         if (oldLeft > leftCol)
5984         {
5985             temp = oldLeft;
5986             oldLeft = leftCol;
5987             leftCol = temp;
5988         }
5989         if (oldTop > topRow )
5990         {
5991             temp = oldTop;
5992             oldTop = topRow;
5993             topRow = temp;
5994         }
5995         if (oldRight < rightCol )
5996         {
5997             temp = oldRight;
5998             oldRight = rightCol;
5999             rightCol = temp;
6000         }
6001         if (oldBottom < bottomRow)
6002         {
6003             temp = oldBottom;
6004             oldBottom = bottomRow;
6005             bottomRow = temp;
6006         }
6007
6008         // Now, either the stuff marked old is the outer
6009         // rectangle or we don't have a situation where one
6010         // is contained in the other.
6011
6012         if ( oldLeft < leftCol )
6013         {
6014             need_refresh[0] = TRUE;
6015             rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6016                                                             oldLeft ),
6017                                          wxGridCellCoords ( oldBottom,
6018                                                             leftCol - 1 ) );
6019         }
6020
6021         if ( oldTop  < topRow )
6022         {
6023             need_refresh[1] = TRUE;
6024             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6025                                                             leftCol ),
6026                                          wxGridCellCoords ( topRow - 1,
6027                                                             rightCol ) );
6028         }
6029
6030         if ( oldRight > rightCol )
6031         {
6032             need_refresh[2] = TRUE;
6033             rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6034                                                             rightCol + 1 ),
6035                                          wxGridCellCoords ( oldBottom,
6036                                                             oldRight ) );
6037         }
6038
6039         if ( oldBottom > bottomRow )
6040         {
6041             need_refresh[3] = TRUE;
6042             rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6043                                                             leftCol ),
6044                                          wxGridCellCoords ( oldBottom,
6045                                                             rightCol ) );
6046         }
6047
6048
6049         // Change Selection
6050         m_selectingTopLeft = updateTopLeft;
6051         m_selectingBottomRight = updateBottomRight;
6052
6053         // various Refresh() calls
6054         for (i = 0; i < 4; i++ )
6055             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6056                 m_gridWin->Refresh( FALSE, &(rect[i]) );
6057     }
6058
6059     // never generate an event as it will be generated from
6060     // wxGridSelection::SelectBlock!
6061     // (old comment from when this was the body of SelectBlock)
6062 }
6063
6064 //
6065 // ------ functions to get/send data (see also public functions)
6066 //
6067
6068 bool wxGrid::GetModelValues()
6069 {
6070     if ( m_table )
6071     {
6072         // all we need to do is repaint the grid
6073         //
6074         m_gridWin->Refresh();
6075         return TRUE;
6076     }
6077
6078     return FALSE;
6079 }
6080
6081
6082 bool wxGrid::SetModelValues()
6083 {
6084     int row, col;
6085
6086     if ( m_table )
6087     {
6088         for ( row = 0;  row < m_numRows;  row++ )
6089         {
6090             for ( col = 0;  col < m_numCols;  col++ )
6091             {
6092                 m_table->SetValue( row, col, GetCellValue(row, col) );
6093             }
6094         }
6095
6096         return TRUE;
6097     }
6098
6099     return FALSE;
6100 }
6101
6102
6103
6104 // Note - this function only draws cells that are in the list of
6105 // exposed cells (usually set from the update region by
6106 // CalcExposedCells)
6107 //
6108 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6109 {
6110     if ( !m_numRows || !m_numCols ) return;
6111
6112     size_t i;
6113     size_t numCells = cells.GetCount();
6114
6115     for ( i = 0;  i < numCells;  i++ )
6116     {
6117         DrawCell( dc, cells[i] );
6118     }
6119 }
6120
6121
6122 void wxGrid::DrawGridSpace( wxDC& dc )
6123 {
6124   int cw, ch;
6125   m_gridWin->GetClientSize( &cw, &ch );
6126
6127   int right, bottom;
6128   CalcUnscrolledPosition( cw, ch, &right, &bottom );
6129
6130   int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6131   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6132
6133   if ( right > rightCol || bottom > bottomRow )
6134   {
6135       int left, top;
6136       CalcUnscrolledPosition( 0, 0, &left, &top );
6137
6138       dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6139       dc.SetPen( *wxTRANSPARENT_PEN );
6140
6141       if ( right > rightCol )
6142       {
6143           dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6144       }
6145
6146       if ( bottom > bottomRow )
6147       {
6148           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6149       }
6150   }
6151 }
6152
6153
6154 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6155 {
6156     int row = coords.GetRow();
6157     int col = coords.GetCol();
6158
6159     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6160         return;
6161
6162     // we draw the cell border ourselves
6163 #if !WXGRID_DRAW_LINES
6164     if ( m_gridLinesEnabled )
6165         DrawCellBorder( dc, coords );
6166 #endif
6167
6168     wxGridCellAttr* attr = GetCellAttr(row, col);
6169
6170     bool isCurrent = coords == m_currentCellCoords;
6171
6172     wxRect rect = CellToRect( row, col );
6173
6174     // if the editor is shown, we should use it and not the renderer
6175     // Note: However, only if it is really _shown_, i.e. not hidden!
6176     if ( isCurrent && IsCellEditControlShown() )
6177     {
6178         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6179         editor->PaintBackground(rect, attr);
6180         editor->DecRef();
6181     }
6182     else
6183     {
6184         // but all the rest is drawn by the cell renderer and hence may be
6185         // customized
6186         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6187         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6188         renderer->DecRef();
6189     }
6190
6191     attr->DecRef();
6192 }
6193
6194 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6195 {
6196     int row = m_currentCellCoords.GetRow();
6197     int col = m_currentCellCoords.GetCol();
6198
6199     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6200         return;
6201
6202     wxRect rect = CellToRect(row, col);
6203
6204     // hmmm... what could we do here to show that the cell is disabled?
6205     // for now, I just draw a thinner border than for the other ones, but
6206     // it doesn't look really good
6207
6208     int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6209
6210     if (penWidth > 0) {
6211
6212         // The center of th drawn line is where the position/width/height of
6213         // the rectangle is actually at, (on wxMSW atr least,) so we will
6214         // reduce the size of the rectangle to compensate for the thickness of
6215         // the line.  If this is too strange on non wxMSW platforms then
6216         // please #ifdef this appropriately.
6217         rect.x += penWidth/2;
6218         rect.y += penWidth/2;
6219         rect.width -= penWidth-1;
6220         rect.height -= penWidth-1;
6221
6222
6223         // Now draw the rectangle
6224         dc.SetPen(wxPen(m_cellHighlightColour, penWidth, wxSOLID));
6225         dc.SetBrush(*wxTRANSPARENT_BRUSH);
6226         dc.DrawRectangle(rect);
6227     }
6228
6229 #if 0
6230         // VZ: my experiments with 3d borders...
6231
6232         // how to properly set colours for arbitrary bg?
6233         wxCoord x1 = rect.x,
6234                 y1 = rect.y,
6235                 x2 = rect.x + rect.width -1,
6236                 y2 = rect.y + rect.height -1;
6237
6238         dc.SetPen(*wxWHITE_PEN);
6239         dc.DrawLine(x1, y1, x2, y1);
6240         dc.DrawLine(x1, y1, x1, y2);
6241
6242         dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
6243         dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
6244
6245         dc.SetPen(*wxBLACK_PEN);
6246         dc.DrawLine(x1, y2, x2, y2);
6247         dc.DrawLine(x2, y1, x2, y2+1);
6248 #endif // 0
6249 }
6250
6251
6252 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
6253 {
6254     int row = coords.GetRow();
6255     int col = coords.GetCol();
6256     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6257         return;
6258
6259     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6260
6261     // right hand border
6262     //
6263     dc.DrawLine( GetColRight(col), GetRowTop(row),
6264                  GetColRight(col), GetRowBottom(row) );
6265
6266     // bottom border
6267     //
6268     dc.DrawLine( GetColLeft(col), GetRowBottom(row),
6269                  GetColRight(col), GetRowBottom(row) );
6270 }
6271
6272 void wxGrid::DrawHighlight(wxDC& dc,const  wxGridCellCoordsArray& cells)
6273 {
6274     // This if block was previously in wxGrid::OnPaint but that doesn't
6275     // seem to get called under wxGTK - MB
6276     //
6277     if ( m_currentCellCoords == wxGridNoCellCoords  &&
6278          m_numRows && m_numCols )
6279     {
6280         m_currentCellCoords.Set(0, 0);
6281     }
6282
6283     if ( IsCellEditControlShown() )
6284     {
6285         // don't show highlight when the edit control is shown
6286         return;
6287     }
6288
6289     // if the active cell was repainted, repaint its highlight too because it
6290     // might have been damaged by the grid lines
6291     size_t count = cells.GetCount();
6292     for ( size_t n = 0; n < count; n++ )
6293     {
6294         if ( cells[n] == m_currentCellCoords )
6295         {
6296             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6297             DrawCellHighlight(dc, attr);
6298             attr->DecRef();
6299
6300             break;
6301         }
6302     }
6303 }
6304
6305 // TODO: remove this ???
6306 // This is used to redraw all grid lines e.g. when the grid line colour
6307 // has been changed
6308 //
6309 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
6310 {
6311     if ( !m_gridLinesEnabled ||
6312          !m_numRows ||
6313          !m_numCols ) return;
6314
6315     int top, bottom, left, right;
6316
6317 #if 0  //#ifndef __WXGTK__
6318     if (reg.IsEmpty())
6319     {
6320       int cw, ch;
6321       m_gridWin->GetClientSize(&cw, &ch);
6322
6323       // virtual coords of visible area
6324       //
6325       CalcUnscrolledPosition( 0, 0, &left, &top );
6326       CalcUnscrolledPosition( cw, ch, &right, &bottom );
6327     }
6328     else
6329     {
6330       wxCoord x, y, w, h;
6331       reg.GetBox(x, y, w, h);
6332       CalcUnscrolledPosition( x, y, &left, &top );
6333       CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
6334     }
6335 #else
6336       int cw, ch;
6337       m_gridWin->GetClientSize(&cw, &ch);
6338       CalcUnscrolledPosition( 0, 0, &left, &top );
6339       CalcUnscrolledPosition( cw, ch, &right, &bottom );
6340 #endif
6341
6342     // avoid drawing grid lines past the last row and col
6343     //
6344     right = wxMin( right, GetColRight(m_numCols - 1) );
6345     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
6346
6347     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6348
6349     // horizontal grid lines
6350     //
6351     int i;
6352     for ( i = 0; i < m_numRows; i++ )
6353     {
6354         int bot = GetRowBottom(i) - 1;
6355
6356         if ( bot > bottom )
6357         {
6358             break;
6359         }
6360
6361         if ( bot >= top )
6362         {
6363             dc.DrawLine( left, bot, right, bot );
6364         }
6365     }
6366
6367
6368     // vertical grid lines
6369     //
6370     for ( i = 0; i < m_numCols; i++ )
6371     {
6372         int colRight = GetColRight(i) - 1;
6373         if ( colRight > right )
6374         {
6375             break;
6376         }
6377
6378         if ( colRight >= left )
6379         {
6380             dc.DrawLine( colRight, top, colRight, bottom );
6381         }
6382     }
6383 }
6384
6385
6386 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
6387 {
6388     if ( !m_numRows ) return;
6389
6390     size_t i;
6391     size_t numLabels = rows.GetCount();
6392
6393     for ( i = 0;  i < numLabels;  i++ )
6394     {
6395         DrawRowLabel( dc, rows[i] );
6396     }
6397 }
6398
6399
6400 void wxGrid::DrawRowLabel( wxDC& dc, int row )
6401 {
6402     if ( GetRowHeight(row) <= 0 )
6403         return;
6404
6405     int rowTop = GetRowTop(row),
6406         rowBottom = GetRowBottom(row) - 1;
6407
6408     dc.SetPen( *wxBLACK_PEN );
6409     dc.DrawLine( m_rowLabelWidth-1, rowTop,
6410                  m_rowLabelWidth-1, rowBottom );
6411
6412     dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
6413
6414     dc.SetPen( *wxWHITE_PEN );
6415     dc.DrawLine( 0, rowTop, 0, rowBottom );
6416     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
6417
6418     dc.SetBackgroundMode( wxTRANSPARENT );
6419     dc.SetTextForeground( GetLabelTextColour() );
6420     dc.SetFont( GetLabelFont() );
6421
6422     int hAlign, vAlign;
6423     GetRowLabelAlignment( &hAlign, &vAlign );
6424
6425     wxRect rect;
6426     rect.SetX( 2 );
6427     rect.SetY( GetRowTop(row) + 2 );
6428     rect.SetWidth( m_rowLabelWidth - 4 );
6429     rect.SetHeight( GetRowHeight(row) - 4 );
6430     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
6431 }
6432
6433
6434 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
6435 {
6436     if ( !m_numCols ) return;
6437
6438     size_t i;
6439     size_t numLabels = cols.GetCount();
6440
6441     for ( i = 0;  i < numLabels;  i++ )
6442     {
6443         DrawColLabel( dc, cols[i] );
6444     }
6445 }
6446
6447
6448 void wxGrid::DrawColLabel( wxDC& dc, int col )
6449 {
6450     if ( GetColWidth(col) <= 0 )
6451         return;
6452
6453     int colLeft = GetColLeft(col),
6454         colRight = GetColRight(col) - 1;
6455
6456     dc.SetPen( *wxBLACK_PEN );
6457     dc.DrawLine( colRight, 0,
6458                  colRight, m_colLabelHeight-1 );
6459
6460     dc.DrawLine( colLeft, m_colLabelHeight-1,
6461                  colRight, m_colLabelHeight-1 );
6462
6463     dc.SetPen( *wxWHITE_PEN );
6464     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
6465     dc.DrawLine( colLeft, 0, colRight, 0 );
6466
6467     dc.SetBackgroundMode( wxTRANSPARENT );
6468     dc.SetTextForeground( GetLabelTextColour() );
6469     dc.SetFont( GetLabelFont() );
6470
6471     dc.SetBackgroundMode( wxTRANSPARENT );
6472     dc.SetTextForeground( GetLabelTextColour() );
6473     dc.SetFont( GetLabelFont() );
6474
6475     int hAlign, vAlign;
6476     GetColLabelAlignment( &hAlign, &vAlign );
6477
6478     wxRect rect;
6479     rect.SetX( colLeft + 2 );
6480     rect.SetY( 2 );
6481     rect.SetWidth( GetColWidth(col) - 4 );
6482     rect.SetHeight( m_colLabelHeight - 4 );
6483     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
6484 }
6485
6486 void wxGrid::DrawTextRectangle( wxDC& dc,
6487                                 const wxString& value,
6488                                 const wxRect& rect,
6489                                 int horizAlign,
6490                                 int vertAlign )
6491 {
6492     wxArrayString lines;
6493
6494     dc.SetClippingRegion( rect );
6495     StringToLines( value, lines );
6496
6497
6498     //Forward to new API.
6499     DrawTextRectangle(  dc,
6500                         lines,
6501                         rect,
6502                         horizAlign,
6503                         vertAlign );
6504
6505 }
6506
6507 void wxGrid::DrawTextRectangle( wxDC& dc,
6508                                 const wxArrayString& lines,
6509                                 const wxRect& rect,
6510                                 int horizAlign,
6511                                 int vertAlign )
6512 {
6513     long textWidth, textHeight;
6514     long lineWidth, lineHeight;
6515
6516     if ( lines.GetCount() )
6517     {
6518         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
6519         dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
6520
6521         float x, y;
6522         switch ( horizAlign )
6523         {
6524             case wxALIGN_RIGHT:
6525                 x = rect.x + (rect.width - textWidth - 1);
6526                 break;
6527
6528             case wxALIGN_CENTRE:
6529                 x = rect.x + ((rect.width - textWidth)/2);
6530                 break;
6531
6532             case wxALIGN_LEFT:
6533             default:
6534                 x = rect.x + 1;
6535                 break;
6536         }
6537
6538         switch ( vertAlign )
6539         {
6540             case wxALIGN_BOTTOM:
6541                 y = rect.y + (rect.height - textHeight - 1);
6542                 break;
6543
6544             case wxALIGN_CENTRE:
6545                 y = rect.y + ((rect.height - textHeight)/2);
6546                 break;
6547
6548             case wxALIGN_TOP:
6549             default:
6550                 y = rect.y + 1;
6551                 break;
6552         }
6553
6554         for ( size_t i = 0;  i < lines.GetCount();  i++ )
6555         {
6556             dc.DrawText( lines[i], (int)x, (int)y );
6557             y += lineHeight;
6558         }
6559     }
6560
6561     dc.DestroyClippingRegion();
6562 }
6563
6564
6565 // Split multi line text up into an array of strings.  Any existing
6566 // contents of the string array are preserved.
6567 //
6568 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
6569 {
6570     int startPos = 0;
6571     int pos;
6572     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
6573     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
6574
6575     while ( startPos < (int)tVal.Length() )
6576     {
6577         pos = tVal.Mid(startPos).Find( eol );
6578         if ( pos < 0 )
6579         {
6580             break;
6581         }
6582         else if ( pos == 0 )
6583         {
6584             lines.Add( wxEmptyString );
6585         }
6586         else
6587         {
6588             lines.Add( value.Mid(startPos, pos) );
6589         }
6590         startPos += pos+1;
6591     }
6592     if ( startPos < (int)value.Length() )
6593     {
6594         lines.Add( value.Mid( startPos ) );
6595     }
6596 }
6597
6598
6599 void wxGrid::GetTextBoxSize( wxDC& dc,
6600                              const wxArrayString& lines,
6601                              long *width, long *height )
6602 {
6603     long w = 0;
6604     long h = 0;
6605     long lineW, lineH;
6606
6607     size_t i;
6608     for ( i = 0;  i < lines.GetCount();  i++ )
6609     {
6610         dc.GetTextExtent( lines[i], &lineW, &lineH );
6611         w = wxMax( w, lineW );
6612         h += lineH;
6613     }
6614
6615     *width = w;
6616     *height = h;
6617 }
6618
6619 //
6620 // ------ Batch processing.
6621 //
6622 void wxGrid::EndBatch()
6623 {
6624     if ( m_batchCount > 0 )
6625     {
6626         m_batchCount--;
6627         if ( !m_batchCount )
6628         {
6629             CalcDimensions();
6630             m_rowLabelWin->Refresh();
6631             m_colLabelWin->Refresh();
6632             m_cornerLabelWin->Refresh();
6633             m_gridWin->Refresh();
6634         }
6635     }
6636 }
6637
6638 // Use this, rather than wxWindow::Refresh(), to force an immediate
6639 // repainting of the grid. Has no effect if you are already inside a
6640 // BeginBatch / EndBatch block.
6641 //
6642 void wxGrid::ForceRefresh()
6643 {
6644     BeginBatch();
6645     EndBatch();
6646 }
6647
6648
6649 //
6650 // ------ Edit control functions
6651 //
6652
6653
6654 void wxGrid::EnableEditing( bool edit )
6655 {
6656     // TODO: improve this ?
6657     //
6658     if ( edit != m_editable )
6659     {
6660         if(!edit) EnableCellEditControl(edit);
6661         m_editable = edit;
6662     }
6663 }
6664
6665
6666 void wxGrid::EnableCellEditControl( bool enable )
6667 {
6668     if (! m_editable)
6669         return;
6670
6671     if ( m_currentCellCoords == wxGridNoCellCoords )
6672         SetCurrentCell( 0, 0 );
6673
6674     if ( enable != m_cellEditCtrlEnabled )
6675     {
6676         if ( enable )
6677         {
6678             if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
6679                 return;
6680
6681             // this should be checked by the caller!
6682             wxASSERT_MSG( CanEnableCellControl(),
6683                           _T("can't enable editing for this cell!") );
6684
6685             // do it before ShowCellEditControl()
6686             m_cellEditCtrlEnabled = enable;
6687
6688             ShowCellEditControl();
6689         }
6690         else
6691         {
6692             //FIXME:add veto support
6693             SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
6694
6695             HideCellEditControl();
6696             SaveEditControlValue();
6697
6698             // do it after HideCellEditControl()
6699             m_cellEditCtrlEnabled = enable;
6700         }
6701     }
6702 }
6703
6704 bool wxGrid::IsCurrentCellReadOnly() const
6705 {
6706     // const_cast
6707     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
6708     bool readonly = attr->IsReadOnly();
6709     attr->DecRef();
6710
6711     return readonly;
6712 }
6713
6714 bool wxGrid::CanEnableCellControl() const
6715 {
6716     return m_editable && !IsCurrentCellReadOnly();
6717 }
6718
6719 bool wxGrid::IsCellEditControlEnabled() const
6720 {
6721     // the cell edit control might be disable for all cells or just for the
6722     // current one if it's read only
6723     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
6724 }
6725
6726 bool wxGrid::IsCellEditControlShown() const
6727 {
6728     bool isShown = FALSE;
6729
6730     if ( m_cellEditCtrlEnabled )
6731     {
6732         int row = m_currentCellCoords.GetRow();
6733         int col = m_currentCellCoords.GetCol();
6734         wxGridCellAttr* attr = GetCellAttr(row, col);
6735         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
6736         attr->DecRef();
6737
6738         if ( editor )
6739         {
6740             if ( editor->IsCreated() )
6741             {
6742                 isShown = editor->GetControl()->IsShown();
6743             }
6744
6745             editor->DecRef();
6746         }
6747     }
6748
6749     return isShown;
6750 }
6751
6752 void wxGrid::ShowCellEditControl()
6753 {
6754     if ( IsCellEditControlEnabled() )
6755     {
6756         if ( !IsVisible( m_currentCellCoords ) )
6757         {
6758             m_cellEditCtrlEnabled = FALSE;
6759             return;
6760         }
6761         else
6762         {
6763             wxRect rect = CellToRect( m_currentCellCoords );
6764             int row = m_currentCellCoords.GetRow();
6765             int col = m_currentCellCoords.GetCol();
6766
6767             // convert to scrolled coords
6768             //
6769             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6770
6771             // done in PaintBackground()
6772 #if 0
6773             // erase the highlight and the cell contents because the editor
6774             // might not cover the entire cell
6775             wxClientDC dc( m_gridWin );
6776             PrepareDC( dc );
6777             dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
6778             dc.SetPen(*wxTRANSPARENT_PEN);
6779             dc.DrawRectangle(rect);
6780 #endif // 0
6781
6782             // cell is shifted by one pixel
6783             rect.x--;
6784             rect.y--;
6785
6786             wxGridCellAttr* attr = GetCellAttr(row, col);
6787             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6788             if ( !editor->IsCreated() )
6789             {
6790                 editor->Create(m_gridWin, -1,
6791                                new wxGridCellEditorEvtHandler(this, editor));
6792
6793                 wxGridEditorCreatedEvent evt(GetId(),
6794                                              wxEVT_GRID_EDITOR_CREATED,
6795                                              this,
6796                                              row,
6797                                              col,
6798                                              editor->GetControl());
6799                 GetEventHandler()->ProcessEvent(evt);
6800             }
6801
6802             editor->Show( TRUE, attr );
6803
6804             editor->SetSize( rect );
6805
6806             editor->BeginEdit(row, col, this);
6807
6808             editor->DecRef();
6809             attr->DecRef();
6810          }
6811     }
6812 }
6813
6814
6815 void wxGrid::HideCellEditControl()
6816 {
6817     if ( IsCellEditControlEnabled() )
6818     {
6819         int row = m_currentCellCoords.GetRow();
6820         int col = m_currentCellCoords.GetCol();
6821
6822         wxGridCellAttr* attr = GetCellAttr(row, col);
6823         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6824         editor->Show( FALSE );
6825         editor->DecRef();
6826         attr->DecRef();
6827         m_gridWin->SetFocus();
6828         wxRect rect( CellToRect( row, col ) );
6829         m_gridWin->Refresh( FALSE, &rect );
6830     }
6831 }
6832
6833
6834 void wxGrid::SaveEditControlValue()
6835 {
6836     if ( IsCellEditControlEnabled() )
6837     {
6838         int row = m_currentCellCoords.GetRow();
6839         int col = m_currentCellCoords.GetCol();
6840
6841         wxString oldval = GetCellValue(row,col);
6842
6843         wxGridCellAttr* attr = GetCellAttr(row, col);
6844         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6845         bool changed = editor->EndEdit(row, col, this);
6846
6847         editor->DecRef();
6848         attr->DecRef();
6849
6850         if (changed)
6851         {
6852             if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
6853                        m_currentCellCoords.GetRow(),
6854                        m_currentCellCoords.GetCol() ) < 0 ) {
6855
6856                 // Event has been vetoed, set the data back.
6857                 SetCellValue(row,col,oldval);
6858             }
6859         }
6860     }
6861 }
6862
6863
6864 //
6865 // ------ Grid location functions
6866 //  Note that all of these functions work with the logical coordinates of
6867 //  grid cells and labels so you will need to convert from device
6868 //  coordinates for mouse events etc.
6869 //
6870
6871 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
6872 {
6873     int row = YToRow(y);
6874     int col = XToCol(x);
6875
6876     if ( row == -1  ||  col == -1 )
6877     {
6878         coords = wxGridNoCellCoords;
6879     }
6880     else
6881     {
6882         coords.Set( row, col );
6883     }
6884 }
6885
6886
6887 int wxGrid::YToRow( int y )
6888 {
6889     int i;
6890
6891     for ( i = 0;  i < m_numRows;  i++ )
6892     {
6893         if ( y < GetRowBottom(i) )
6894             return i;
6895     }
6896
6897     return -1;
6898 }
6899
6900
6901 int wxGrid::XToCol( int x )
6902 {
6903     int i;
6904
6905     for ( i = 0;  i < m_numCols;  i++ )
6906     {
6907         if ( x < GetColRight(i) )
6908             return i;
6909     }
6910
6911     return -1;
6912 }
6913
6914
6915 // return the row number that that the y coord is near the edge of, or
6916 // -1 if not near an edge
6917 //
6918 int wxGrid::YToEdgeOfRow( int y )
6919 {
6920     int i, d;
6921
6922     for ( i = 0;  i < m_numRows;  i++ )
6923     {
6924         if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
6925         {
6926             d = abs( y - GetRowBottom(i) );
6927             if ( d < WXGRID_LABEL_EDGE_ZONE )
6928                 return i;
6929         }
6930     }
6931
6932     return -1;
6933 }
6934
6935
6936 // return the col number that that the x coord is near the edge of, or
6937 // -1 if not near an edge
6938 //
6939 int wxGrid::XToEdgeOfCol( int x )
6940 {
6941     int i, d;
6942
6943     for ( i = 0;  i < m_numCols;  i++ )
6944     {
6945         if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
6946         {
6947             d = abs( x - GetColRight(i) );
6948             if ( d < WXGRID_LABEL_EDGE_ZONE )
6949                 return i;
6950         }
6951     }
6952
6953     return -1;
6954 }
6955
6956
6957 wxRect wxGrid::CellToRect( int row, int col )
6958 {
6959     wxRect rect( -1, -1, -1, -1 );
6960
6961     if ( row >= 0  &&  row < m_numRows  &&
6962          col >= 0  &&  col < m_numCols )
6963     {
6964         rect.x = GetColLeft(col);
6965         rect.y = GetRowTop(row);
6966         rect.width = GetColWidth(col);
6967         rect.height = GetRowHeight(row);
6968     }
6969
6970     // if grid lines are enabled, then the area of the cell is a bit smaller
6971     if (m_gridLinesEnabled) {
6972         rect.width -= 1;
6973         rect.height -= 1;
6974     }
6975     return rect;
6976 }
6977
6978
6979 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
6980 {
6981     // get the cell rectangle in logical coords
6982     //
6983     wxRect r( CellToRect( row, col ) );
6984
6985     // convert to device coords
6986     //
6987     int left, top, right, bottom;
6988     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6989     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6990
6991     // check against the client area of the grid window
6992     //
6993     int cw, ch;
6994     m_gridWin->GetClientSize( &cw, &ch );
6995
6996     if ( wholeCellVisible )
6997     {
6998         // is the cell wholly visible ?
6999         //
7000         return ( left >= 0  &&  right <= cw  &&
7001                  top >= 0  &&  bottom <= ch );
7002     }
7003     else
7004     {
7005         // is the cell partly visible ?
7006         //
7007         return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
7008                  ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
7009     }
7010 }
7011
7012
7013 // make the specified cell location visible by doing a minimal amount
7014 // of scrolling
7015 //
7016 void wxGrid::MakeCellVisible( int row, int col )
7017 {
7018
7019     int i;
7020     int xpos = -1, ypos = -1;
7021
7022     if ( row >= 0  &&  row < m_numRows  &&
7023          col >= 0  &&  col < m_numCols )
7024     {
7025         // get the cell rectangle in logical coords
7026         //
7027         wxRect r( CellToRect( row, col ) );
7028
7029         // convert to device coords
7030         //
7031         int left, top, right, bottom;
7032         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7033         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7034
7035         int cw, ch;
7036         m_gridWin->GetClientSize( &cw, &ch );
7037
7038         if ( top < 0 )
7039         {
7040             ypos = r.GetTop();
7041         }
7042         else if ( bottom > ch )
7043         {
7044             int h = r.GetHeight();
7045             ypos = r.GetTop();
7046             for ( i = row-1;  i >= 0;  i-- )
7047             {
7048                 int rowHeight = GetRowHeight(i);
7049                 if ( h + rowHeight > ch )
7050                     break;
7051
7052                 h += rowHeight;
7053                 ypos -= rowHeight;
7054             }
7055
7056             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7057             // have rounding errors (this is important, because if we do, we
7058             // might not scroll at all and some cells won't be redrawn)
7059             //
7060             // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7061             // scroll unit...
7062             ypos += GRID_SCROLL_LINE_Y;
7063         }
7064
7065         if ( left < 0 )
7066         {
7067             xpos = r.GetLeft();
7068         }
7069         else if ( right > cw )
7070         {
7071             int w = r.GetWidth();
7072             xpos = r.GetLeft();
7073             for ( i = col-1;  i >= 0;  i-- )
7074             {
7075                 int colWidth = GetColWidth(i);
7076                 if ( w + colWidth > cw )
7077                     break;
7078
7079                 w += colWidth;
7080                 xpos -= colWidth;
7081             }
7082
7083             // see comment for ypos above
7084             xpos += GRID_SCROLL_LINE_X;
7085         }
7086
7087         if ( xpos != -1  ||  ypos != -1 )
7088         {
7089             if ( xpos != -1 )
7090                 xpos /= GRID_SCROLL_LINE_X;
7091             if ( ypos != -1 )
7092                 ypos /= GRID_SCROLL_LINE_Y;
7093             Scroll( xpos, ypos );
7094             AdjustScrollbars();
7095         }
7096     }
7097 }
7098
7099
7100 //
7101 // ------ Grid cursor movement functions
7102 //
7103
7104 bool wxGrid::MoveCursorUp( bool expandSelection )
7105 {
7106     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7107          m_currentCellCoords.GetRow() >= 0 )
7108     {
7109         if ( expandSelection)
7110         {
7111             if ( m_selectingKeyboard == wxGridNoCellCoords )
7112                 m_selectingKeyboard = m_currentCellCoords;
7113             if ( m_selectingKeyboard.GetRow() > 0 )
7114             {
7115                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
7116                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7117                                  m_selectingKeyboard.GetCol() );
7118                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7119             }
7120         }
7121         else if ( m_currentCellCoords.GetRow() > 0 )
7122         {
7123             ClearSelection();
7124             MakeCellVisible( m_currentCellCoords.GetRow() - 1,
7125                              m_currentCellCoords.GetCol() );
7126             SetCurrentCell( m_currentCellCoords.GetRow() - 1,
7127                             m_currentCellCoords.GetCol() );
7128         }
7129         else
7130             return FALSE;
7131         return TRUE;
7132     }
7133
7134     return FALSE;
7135 }
7136
7137
7138 bool wxGrid::MoveCursorDown( bool expandSelection )
7139 {
7140     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7141          m_currentCellCoords.GetRow() < m_numRows )
7142     {
7143         if ( expandSelection )
7144         {
7145             if ( m_selectingKeyboard == wxGridNoCellCoords )
7146                 m_selectingKeyboard = m_currentCellCoords;
7147             if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
7148             {
7149                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
7150                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7151                         m_selectingKeyboard.GetCol() );
7152                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7153             }
7154         }
7155         else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
7156         {
7157             ClearSelection();
7158             MakeCellVisible( m_currentCellCoords.GetRow() + 1,
7159                              m_currentCellCoords.GetCol() );
7160             SetCurrentCell( m_currentCellCoords.GetRow() + 1,
7161                             m_currentCellCoords.GetCol() );
7162         }
7163         else
7164             return FALSE;
7165         return TRUE;
7166     }
7167
7168     return FALSE;
7169 }
7170
7171
7172 bool wxGrid::MoveCursorLeft( bool expandSelection )
7173 {
7174     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7175          m_currentCellCoords.GetCol() >= 0 )
7176     {
7177         if ( expandSelection )
7178         {
7179             if ( m_selectingKeyboard == wxGridNoCellCoords )
7180                 m_selectingKeyboard = m_currentCellCoords;
7181             if ( m_selectingKeyboard.GetCol() > 0 )
7182             {
7183                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
7184                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7185                         m_selectingKeyboard.GetCol() );
7186                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7187             }
7188         }
7189         else if ( m_currentCellCoords.GetCol() > 0 )
7190         {
7191             ClearSelection();
7192             MakeCellVisible( m_currentCellCoords.GetRow(),
7193                              m_currentCellCoords.GetCol() - 1 );
7194             SetCurrentCell( m_currentCellCoords.GetRow(),
7195                             m_currentCellCoords.GetCol() - 1 );
7196         }
7197         else
7198             return FALSE;
7199         return TRUE;
7200     }
7201
7202     return FALSE;
7203 }
7204
7205
7206 bool wxGrid::MoveCursorRight( bool expandSelection )
7207 {
7208     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7209          m_currentCellCoords.GetCol() < m_numCols )
7210     {
7211         if ( expandSelection )
7212         {
7213             if ( m_selectingKeyboard == wxGridNoCellCoords )
7214                 m_selectingKeyboard = m_currentCellCoords;
7215             if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
7216             {
7217                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
7218                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7219                         m_selectingKeyboard.GetCol() );
7220                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7221             }
7222         }
7223         else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
7224         {
7225             ClearSelection();
7226             MakeCellVisible( m_currentCellCoords.GetRow(),
7227                              m_currentCellCoords.GetCol() + 1 );
7228             SetCurrentCell( m_currentCellCoords.GetRow(),
7229                             m_currentCellCoords.GetCol() + 1 );
7230         }
7231         else
7232             return FALSE;
7233         return TRUE;
7234     }
7235
7236     return FALSE;
7237 }
7238
7239
7240 bool wxGrid::MovePageUp()
7241 {
7242     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7243
7244     int row = m_currentCellCoords.GetRow();
7245     if ( row > 0 )
7246     {
7247         int cw, ch;
7248         m_gridWin->GetClientSize( &cw, &ch );
7249
7250         int y = GetRowTop(row);
7251         int newRow = YToRow( y - ch + 1 );
7252         if ( newRow == -1 )
7253         {
7254             newRow = 0;
7255         }
7256         else if ( newRow == row )
7257         {
7258             newRow = row - 1;
7259         }
7260
7261         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7262         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7263
7264         return TRUE;
7265     }
7266
7267     return FALSE;
7268 }
7269
7270 bool wxGrid::MovePageDown()
7271 {
7272     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7273
7274     int row = m_currentCellCoords.GetRow();
7275     if ( row < m_numRows )
7276     {
7277         int cw, ch;
7278         m_gridWin->GetClientSize( &cw, &ch );
7279
7280         int y = GetRowTop(row);
7281         int newRow = YToRow( y + ch );
7282         if ( newRow == -1 )
7283         {
7284             newRow = m_numRows - 1;
7285         }
7286         else if ( newRow == row )
7287         {
7288             newRow = row + 1;
7289         }
7290
7291         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7292         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7293
7294         return TRUE;
7295     }
7296
7297     return FALSE;
7298 }
7299
7300 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
7301 {
7302     if ( m_table &&
7303          m_currentCellCoords != wxGridNoCellCoords  &&
7304          m_currentCellCoords.GetRow() > 0 )
7305     {
7306         int row = m_currentCellCoords.GetRow();
7307         int col = m_currentCellCoords.GetCol();
7308
7309         if ( m_table->IsEmptyCell(row, col) )
7310         {
7311             // starting in an empty cell: find the next block of
7312             // non-empty cells
7313             //
7314             while ( row > 0 )
7315             {
7316                 row-- ;
7317                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7318             }
7319         }
7320         else if ( m_table->IsEmptyCell(row-1, col) )
7321         {
7322             // starting at the top of a block: find the next block
7323             //
7324             row--;
7325             while ( row > 0 )
7326             {
7327                 row-- ;
7328                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7329             }
7330         }
7331         else
7332         {
7333             // starting within a block: find the top of the block
7334             //
7335             while ( row > 0 )
7336             {
7337                 row-- ;
7338                 if ( m_table->IsEmptyCell(row, col) )
7339                 {
7340                     row++ ;
7341                     break;
7342                 }
7343             }
7344         }
7345
7346         MakeCellVisible( row, col );
7347         if ( expandSelection )
7348         {
7349             m_selectingKeyboard = wxGridCellCoords( row, col );
7350             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7351         }
7352         else
7353         {
7354             ClearSelection();
7355             SetCurrentCell( row, col );
7356         }
7357         return TRUE;
7358     }
7359
7360     return FALSE;
7361 }
7362
7363 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
7364 {
7365     if ( m_table &&
7366          m_currentCellCoords != wxGridNoCellCoords  &&
7367          m_currentCellCoords.GetRow() < m_numRows-1 )
7368     {
7369         int row = m_currentCellCoords.GetRow();
7370         int col = m_currentCellCoords.GetCol();
7371
7372         if ( m_table->IsEmptyCell(row, col) )
7373         {
7374             // starting in an empty cell: find the next block of
7375             // non-empty cells
7376             //
7377             while ( row < m_numRows-1 )
7378             {
7379                 row++ ;
7380                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7381             }
7382         }
7383         else if ( m_table->IsEmptyCell(row+1, col) )
7384         {
7385             // starting at the bottom of a block: find the next block
7386             //
7387             row++;
7388             while ( row < m_numRows-1 )
7389             {
7390                 row++ ;
7391                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7392             }
7393         }
7394         else
7395         {
7396             // starting within a block: find the bottom of the block
7397             //
7398             while ( row < m_numRows-1 )
7399             {
7400                 row++ ;
7401                 if ( m_table->IsEmptyCell(row, col) )
7402                 {
7403                     row-- ;
7404                     break;
7405                 }
7406             }
7407         }
7408
7409         MakeCellVisible( row, col );
7410         if ( expandSelection )
7411         {
7412             m_selectingKeyboard = wxGridCellCoords( row, col );
7413             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7414         }
7415         else
7416         {
7417             ClearSelection();
7418             SetCurrentCell( row, col );
7419         }
7420
7421         return TRUE;
7422     }
7423
7424     return FALSE;
7425 }
7426
7427 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
7428 {
7429     if ( m_table &&
7430          m_currentCellCoords != wxGridNoCellCoords  &&
7431          m_currentCellCoords.GetCol() > 0 )
7432     {
7433         int row = m_currentCellCoords.GetRow();
7434         int col = m_currentCellCoords.GetCol();
7435
7436         if ( m_table->IsEmptyCell(row, col) )
7437         {
7438             // starting in an empty cell: find the next block of
7439             // non-empty cells
7440             //
7441             while ( col > 0 )
7442             {
7443                 col-- ;
7444                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7445             }
7446         }
7447         else if ( m_table->IsEmptyCell(row, col-1) )
7448         {
7449             // starting at the left of a block: find the next block
7450             //
7451             col--;
7452             while ( col > 0 )
7453             {
7454                 col-- ;
7455                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7456             }
7457         }
7458         else
7459         {
7460             // starting within a block: find the left of the block
7461             //
7462             while ( col > 0 )
7463             {
7464                 col-- ;
7465                 if ( m_table->IsEmptyCell(row, col) )
7466                 {
7467                     col++ ;
7468                     break;
7469                 }
7470             }
7471         }
7472
7473         MakeCellVisible( row, col );
7474         if ( expandSelection )
7475         {
7476             m_selectingKeyboard = wxGridCellCoords( row, col );
7477             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7478         }
7479         else
7480         {
7481             ClearSelection();
7482             SetCurrentCell( row, col );
7483         }
7484
7485         return TRUE;
7486     }
7487
7488     return FALSE;
7489 }
7490
7491 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
7492 {
7493     if ( m_table &&
7494          m_currentCellCoords != wxGridNoCellCoords  &&
7495          m_currentCellCoords.GetCol() < m_numCols-1 )
7496     {
7497         int row = m_currentCellCoords.GetRow();
7498         int col = m_currentCellCoords.GetCol();
7499
7500         if ( m_table->IsEmptyCell(row, col) )
7501         {
7502             // starting in an empty cell: find the next block of
7503             // non-empty cells
7504             //
7505             while ( col < m_numCols-1 )
7506             {
7507                 col++ ;
7508                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7509             }
7510         }
7511         else if ( m_table->IsEmptyCell(row, col+1) )
7512         {
7513             // starting at the right of a block: find the next block
7514             //
7515             col++;
7516             while ( col < m_numCols-1 )
7517             {
7518                 col++ ;
7519                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7520             }
7521         }
7522         else
7523         {
7524             // starting within a block: find the right of the block
7525             //
7526             while ( col < m_numCols-1 )
7527             {
7528                 col++ ;
7529                 if ( m_table->IsEmptyCell(row, col) )
7530                 {
7531                     col-- ;
7532                     break;
7533                 }
7534             }
7535         }
7536
7537         MakeCellVisible( row, col );
7538         if ( expandSelection )
7539         {
7540             m_selectingKeyboard = wxGridCellCoords( row, col );
7541             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7542         }
7543         else
7544         {
7545             ClearSelection();
7546             SetCurrentCell( row, col );
7547         }
7548
7549         return TRUE;
7550     }
7551
7552     return FALSE;
7553 }
7554
7555
7556
7557 //
7558 // ------ Label values and formatting
7559 //
7560
7561 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
7562 {
7563     *horiz = m_rowLabelHorizAlign;
7564     *vert  = m_rowLabelVertAlign;
7565 }
7566
7567 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
7568 {
7569     *horiz = m_colLabelHorizAlign;
7570     *vert  = m_colLabelVertAlign;
7571 }
7572
7573 wxString wxGrid::GetRowLabelValue( int row )
7574 {
7575     if ( m_table )
7576     {
7577         return m_table->GetRowLabelValue( row );
7578     }
7579     else
7580     {
7581         wxString s;
7582         s << row;
7583         return s;
7584     }
7585 }
7586
7587 wxString wxGrid::GetColLabelValue( int col )
7588 {
7589     if ( m_table )
7590     {
7591         return m_table->GetColLabelValue( col );
7592     }
7593     else
7594     {
7595         wxString s;
7596         s << col;
7597         return s;
7598     }
7599 }
7600
7601
7602 void wxGrid::SetRowLabelSize( int width )
7603 {
7604     width = wxMax( width, 0 );
7605     if ( width != m_rowLabelWidth )
7606     {
7607         if ( width == 0 )
7608         {
7609             m_rowLabelWin->Show( FALSE );
7610             m_cornerLabelWin->Show( FALSE );
7611         }
7612         else if ( m_rowLabelWidth == 0 )
7613         {
7614             m_rowLabelWin->Show( TRUE );
7615             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
7616         }
7617
7618         m_rowLabelWidth = width;
7619         CalcWindowSizes();
7620         Refresh( TRUE );
7621     }
7622 }
7623
7624
7625 void wxGrid::SetColLabelSize( int height )
7626 {
7627     height = wxMax( height, 0 );
7628     if ( height != m_colLabelHeight )
7629     {
7630         if ( height == 0 )
7631         {
7632             m_colLabelWin->Show( FALSE );
7633             m_cornerLabelWin->Show( FALSE );
7634         }
7635         else if ( m_colLabelHeight == 0 )
7636         {
7637             m_colLabelWin->Show( TRUE );
7638             if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
7639         }
7640
7641         m_colLabelHeight = height;
7642         CalcWindowSizes();
7643         Refresh( TRUE );
7644     }
7645 }
7646
7647
7648 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
7649 {
7650     if ( m_labelBackgroundColour != colour )
7651     {
7652         m_labelBackgroundColour = colour;
7653         m_rowLabelWin->SetBackgroundColour( colour );
7654         m_colLabelWin->SetBackgroundColour( colour );
7655         m_cornerLabelWin->SetBackgroundColour( colour );
7656
7657         if ( !GetBatchCount() )
7658         {
7659             m_rowLabelWin->Refresh();
7660             m_colLabelWin->Refresh();
7661             m_cornerLabelWin->Refresh();
7662         }
7663     }
7664 }
7665
7666 void wxGrid::SetLabelTextColour( const wxColour& colour )
7667 {
7668     if ( m_labelTextColour != colour )
7669     {
7670         m_labelTextColour = colour;
7671         if ( !GetBatchCount() )
7672         {
7673             m_rowLabelWin->Refresh();
7674             m_colLabelWin->Refresh();
7675         }
7676     }
7677 }
7678
7679 void wxGrid::SetLabelFont( const wxFont& font )
7680 {
7681     m_labelFont = font;
7682     if ( !GetBatchCount() )
7683     {
7684         m_rowLabelWin->Refresh();
7685         m_colLabelWin->Refresh();
7686     }
7687 }
7688
7689 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
7690 {
7691     // allow old (incorrect) defs to be used
7692     switch ( horiz )
7693     {
7694         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7695         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7696         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7697     }
7698
7699     switch ( vert )
7700     {
7701         case wxTOP:    vert = wxALIGN_TOP;    break;
7702         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7703         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7704     }
7705
7706     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7707     {
7708         m_rowLabelHorizAlign = horiz;
7709     }
7710
7711     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7712     {
7713         m_rowLabelVertAlign = vert;
7714     }
7715
7716     if ( !GetBatchCount() )
7717     {
7718         m_rowLabelWin->Refresh();
7719     }
7720 }
7721
7722 void wxGrid::SetColLabelAlignment( int horiz, int vert )
7723 {
7724     // allow old (incorrect) defs to be used
7725     switch ( horiz )
7726     {
7727         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7728         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7729         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7730     }
7731
7732     switch ( vert )
7733     {
7734         case wxTOP:    vert = wxALIGN_TOP;    break;
7735         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7736         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7737     }
7738
7739     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7740     {
7741         m_colLabelHorizAlign = horiz;
7742     }
7743
7744     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7745     {
7746         m_colLabelVertAlign = vert;
7747     }
7748
7749     if ( !GetBatchCount() )
7750     {
7751         m_colLabelWin->Refresh();
7752     }
7753 }
7754
7755 void wxGrid::SetRowLabelValue( int row, const wxString& s )
7756 {
7757     if ( m_table )
7758     {
7759         m_table->SetRowLabelValue( row, s );
7760         if ( !GetBatchCount() )
7761         {
7762             wxRect rect = CellToRect( row, 0);
7763             if ( rect.height > 0 )
7764             {
7765                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
7766                 rect.x = 0;
7767                 rect.width = m_rowLabelWidth;
7768                 m_rowLabelWin->Refresh( TRUE, &rect );
7769             }
7770         }
7771     }
7772 }
7773
7774 void wxGrid::SetColLabelValue( int col, const wxString& s )
7775 {
7776     if ( m_table )
7777     {
7778         m_table->SetColLabelValue( col, s );
7779         if ( !GetBatchCount() )
7780         {
7781             wxRect rect = CellToRect( 0, col );
7782             if ( rect.width > 0 )
7783             {
7784                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
7785                 rect.y = 0;
7786                 rect.height = m_colLabelHeight;
7787                 m_colLabelWin->Refresh( TRUE, &rect );
7788             }
7789         }
7790     }
7791 }
7792
7793 void wxGrid::SetGridLineColour( const wxColour& colour )
7794 {
7795     if ( m_gridLineColour != colour )
7796     {
7797         m_gridLineColour = colour;
7798
7799         wxClientDC dc( m_gridWin );
7800         PrepareDC( dc );
7801         DrawAllGridLines( dc, wxRegion() );
7802     }
7803 }
7804
7805
7806 void wxGrid::SetCellHighlightColour( const wxColour& colour )
7807 {
7808     if ( m_cellHighlightColour != colour )
7809     {
7810         m_cellHighlightColour = colour;
7811
7812         wxClientDC dc( m_gridWin );
7813         PrepareDC( dc );
7814         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7815         DrawCellHighlight(dc, attr);
7816         attr->DecRef();
7817     }
7818 }
7819
7820 void wxGrid::SetCellHighlightPenWidth(int width)
7821 {
7822     if (m_cellHighlightPenWidth != width) {
7823         m_cellHighlightPenWidth = width;
7824
7825         // Just redrawing the cell highlight is not enough since that won't
7826         // make any visible change if the the thickness is getting smaller.
7827         int row = m_currentCellCoords.GetRow();
7828         int col = m_currentCellCoords.GetCol();
7829         if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7830             return;
7831         wxRect rect = CellToRect(row, col);
7832         m_gridWin->Refresh(TRUE, &rect);
7833     }
7834 }
7835
7836 void wxGrid::SetCellHighlightROPenWidth(int width)
7837 {
7838     if (m_cellHighlightROPenWidth != width) {
7839         m_cellHighlightROPenWidth = width;
7840
7841         // Just redrawing the cell highlight is not enough since that won't
7842         // make any visible change if the the thickness is getting smaller.
7843         int row = m_currentCellCoords.GetRow();
7844         int col = m_currentCellCoords.GetCol();
7845         if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7846             return;
7847         wxRect rect = CellToRect(row, col);
7848         m_gridWin->Refresh(TRUE, &rect);
7849     }
7850 }
7851
7852 void wxGrid::EnableGridLines( bool enable )
7853 {
7854     if ( enable != m_gridLinesEnabled )
7855     {
7856         m_gridLinesEnabled = enable;
7857
7858         if ( !GetBatchCount() )
7859         {
7860             if ( enable )
7861             {
7862                 wxClientDC dc( m_gridWin );
7863                 PrepareDC( dc );
7864                 DrawAllGridLines( dc, wxRegion() );
7865             }
7866             else
7867             {
7868                 m_gridWin->Refresh();
7869             }
7870         }
7871     }
7872 }
7873
7874
7875 int wxGrid::GetDefaultRowSize()
7876 {
7877     return m_defaultRowHeight;
7878 }
7879
7880 int wxGrid::GetRowSize( int row )
7881 {
7882     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
7883
7884     return GetRowHeight(row);
7885 }
7886
7887 int wxGrid::GetDefaultColSize()
7888 {
7889     return m_defaultColWidth;
7890 }
7891
7892 int wxGrid::GetColSize( int col )
7893 {
7894     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
7895
7896     return GetColWidth(col);
7897 }
7898
7899 // ============================================================================
7900 // access to the grid attributes: each of them has a default value in the grid
7901 // itself and may be overidden on a per-cell basis
7902 // ============================================================================
7903
7904 // ----------------------------------------------------------------------------
7905 // setting default attributes
7906 // ----------------------------------------------------------------------------
7907
7908 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7909 {
7910     m_defaultCellAttr->SetBackgroundColour(col);
7911 #ifdef __WXGTK__
7912     m_gridWin->SetBackgroundColour(col);
7913 #endif
7914 }
7915
7916 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7917 {
7918     m_defaultCellAttr->SetTextColour(col);
7919 }
7920
7921 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7922 {
7923     m_defaultCellAttr->SetAlignment(horiz, vert);
7924 }
7925
7926 void wxGrid::SetDefaultCellFont( const wxFont& font )
7927 {
7928     m_defaultCellAttr->SetFont(font);
7929 }
7930
7931 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7932 {
7933     m_defaultCellAttr->SetRenderer(renderer);
7934 }
7935
7936 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7937 {
7938     m_defaultCellAttr->SetEditor(editor);
7939 }
7940
7941 // ----------------------------------------------------------------------------
7942 // access to the default attrbiutes
7943 // ----------------------------------------------------------------------------
7944
7945 wxColour wxGrid::GetDefaultCellBackgroundColour()
7946 {
7947     return m_defaultCellAttr->GetBackgroundColour();
7948 }
7949
7950 wxColour wxGrid::GetDefaultCellTextColour()
7951 {
7952     return m_defaultCellAttr->GetTextColour();
7953 }
7954
7955 wxFont wxGrid::GetDefaultCellFont()
7956 {
7957     return m_defaultCellAttr->GetFont();
7958 }
7959
7960 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
7961 {
7962     m_defaultCellAttr->GetAlignment(horiz, vert);
7963 }
7964
7965 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7966 {
7967     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7968 }
7969
7970 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7971 {
7972     return m_defaultCellAttr->GetEditor(NULL,0,0);
7973 }
7974
7975 // ----------------------------------------------------------------------------
7976 // access to cell attributes
7977 // ----------------------------------------------------------------------------
7978
7979 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
7980 {
7981     wxGridCellAttr *attr = GetCellAttr(row, col);
7982     wxColour colour = attr->GetBackgroundColour();
7983     attr->DecRef();
7984     return colour;
7985 }
7986
7987 wxColour wxGrid::GetCellTextColour( int row, int col )
7988 {
7989     wxGridCellAttr *attr = GetCellAttr(row, col);
7990     wxColour colour = attr->GetTextColour();
7991     attr->DecRef();
7992     return colour;
7993 }
7994
7995 wxFont wxGrid::GetCellFont( int row, int col )
7996 {
7997     wxGridCellAttr *attr = GetCellAttr(row, col);
7998     wxFont font = attr->GetFont();
7999     attr->DecRef();
8000     return font;
8001 }
8002
8003 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
8004 {
8005     wxGridCellAttr *attr = GetCellAttr(row, col);
8006     attr->GetAlignment(horiz, vert);
8007     attr->DecRef();
8008 }
8009
8010 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
8011 {
8012     wxGridCellAttr* attr = GetCellAttr(row, col);
8013     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8014     attr->DecRef();
8015
8016     return renderer;
8017 }
8018
8019 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
8020 {
8021     wxGridCellAttr* attr = GetCellAttr(row, col);
8022     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8023     attr->DecRef();
8024
8025     return editor;
8026 }
8027
8028 bool wxGrid::IsReadOnly(int row, int col) const
8029 {
8030     wxGridCellAttr* attr = GetCellAttr(row, col);
8031     bool isReadOnly = attr->IsReadOnly();
8032     attr->DecRef();
8033     return isReadOnly;
8034 }
8035
8036 // ----------------------------------------------------------------------------
8037 // attribute support: cache, automatic provider creation, ...
8038 // ----------------------------------------------------------------------------
8039
8040 bool wxGrid::CanHaveAttributes()
8041 {
8042     if ( !m_table )
8043     {
8044         return FALSE;
8045     }
8046
8047     return m_table->CanHaveAttributes();
8048 }
8049
8050 void wxGrid::ClearAttrCache()
8051 {
8052     if ( m_attrCache.row != -1 )
8053     {
8054         wxSafeDecRef(m_attrCache.attr);
8055         m_attrCache.attr = NULL;
8056         m_attrCache.row = -1;
8057     }
8058 }
8059
8060 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
8061 {
8062     wxGrid *self = (wxGrid *)this;  // const_cast
8063
8064     self->ClearAttrCache();
8065     self->m_attrCache.row = row;
8066     self->m_attrCache.col = col;
8067     self->m_attrCache.attr = attr;
8068     wxSafeIncRef(attr);
8069 }
8070
8071 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
8072 {
8073     if ( row == m_attrCache.row && col == m_attrCache.col )
8074     {
8075         *attr = m_attrCache.attr;
8076         wxSafeIncRef(m_attrCache.attr);
8077
8078 #ifdef DEBUG_ATTR_CACHE
8079         gs_nAttrCacheHits++;
8080 #endif
8081
8082         return TRUE;
8083     }
8084     else
8085     {
8086 #ifdef DEBUG_ATTR_CACHE
8087         gs_nAttrCacheMisses++;
8088 #endif
8089         return FALSE;
8090     }
8091 }
8092
8093 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
8094 {
8095     wxGridCellAttr *attr;
8096     if ( !LookupAttr(row, col, &attr) )
8097     {
8098         attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any) : (wxGridCellAttr *)NULL;
8099         CacheAttr(row, col, attr);
8100     }
8101     if (attr)
8102     {
8103         attr->SetDefAttr(m_defaultCellAttr);
8104     }
8105     else
8106     {
8107         attr = m_defaultCellAttr;
8108         attr->IncRef();
8109     }
8110
8111     return attr;
8112 }
8113
8114 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
8115 {
8116     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8117
8118     wxCHECK_MSG( m_table, attr,
8119                   _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8120
8121     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
8122     if ( !attr )
8123     {
8124         attr = new wxGridCellAttr(m_defaultCellAttr);
8125
8126         // artificially inc the ref count to match DecRef() in caller
8127         attr->IncRef();
8128         m_table->SetAttr(attr, row, col);
8129     }
8130
8131     return attr;
8132 }
8133
8134 // ----------------------------------------------------------------------------
8135 // setting column attributes (wrappers around SetColAttr)
8136 // ----------------------------------------------------------------------------
8137
8138 void wxGrid::SetColFormatBool(int col)
8139 {
8140     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
8141 }
8142
8143 void wxGrid::SetColFormatNumber(int col)
8144 {
8145     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
8146 }
8147
8148 void wxGrid::SetColFormatFloat(int col, int width, int precision)
8149 {
8150     wxString typeName = wxGRID_VALUE_FLOAT;
8151     if ( (width != -1) || (precision != -1) )
8152     {
8153         typeName << _T(':') << width << _T(',') << precision;
8154     }
8155
8156     SetColFormatCustom(col, typeName);
8157 }
8158
8159 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
8160 {
8161     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8162
8163     attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
8164     if(!attr)
8165         attr = new wxGridCellAttr;
8166     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
8167     attr->SetRenderer(renderer);
8168
8169     SetColAttr(col, attr);
8170
8171 }
8172
8173 // ----------------------------------------------------------------------------
8174 // setting cell attributes: this is forwarded to the table
8175 // ----------------------------------------------------------------------------
8176
8177 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
8178 {
8179     if ( CanHaveAttributes() )
8180     {
8181         m_table->SetRowAttr(attr, row);
8182         ClearAttrCache();
8183     }
8184     else
8185     {
8186         wxSafeDecRef(attr);
8187     }
8188 }
8189
8190 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
8191 {
8192     if ( CanHaveAttributes() )
8193     {
8194         m_table->SetColAttr(attr, col);
8195         ClearAttrCache();
8196     }
8197     else
8198     {
8199         wxSafeDecRef(attr);
8200     }
8201 }
8202
8203 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
8204 {
8205     if ( CanHaveAttributes() )
8206     {
8207         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8208         attr->SetBackgroundColour(colour);
8209         attr->DecRef();
8210     }
8211 }
8212
8213 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
8214 {
8215     if ( CanHaveAttributes() )
8216     {
8217         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8218         attr->SetTextColour(colour);
8219         attr->DecRef();
8220     }
8221 }
8222
8223 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
8224 {
8225     if ( CanHaveAttributes() )
8226     {
8227         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8228         attr->SetFont(font);
8229         attr->DecRef();
8230     }
8231 }
8232
8233 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
8234 {
8235     if ( CanHaveAttributes() )
8236     {
8237         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8238         attr->SetAlignment(horiz, vert);
8239         attr->DecRef();
8240     }
8241 }
8242
8243 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
8244 {
8245     if ( CanHaveAttributes() )
8246     {
8247         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8248         attr->SetRenderer(renderer);
8249         attr->DecRef();
8250     }
8251 }
8252
8253 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
8254 {
8255     if ( CanHaveAttributes() )
8256     {
8257         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8258         attr->SetEditor(editor);
8259         attr->DecRef();
8260     }
8261 }
8262
8263 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
8264 {
8265     if ( CanHaveAttributes() )
8266     {
8267         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8268         attr->SetReadOnly(isReadOnly);
8269         attr->DecRef();
8270     }
8271 }
8272
8273 // ----------------------------------------------------------------------------
8274 // Data type registration
8275 // ----------------------------------------------------------------------------
8276
8277 void wxGrid::RegisterDataType(const wxString& typeName,
8278                               wxGridCellRenderer* renderer,
8279                               wxGridCellEditor* editor)
8280 {
8281     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
8282 }
8283
8284
8285 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
8286 {
8287     wxString typeName = m_table->GetTypeName(row, col);
8288     return GetDefaultEditorForType(typeName);
8289 }
8290
8291 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
8292 {
8293     wxString typeName = m_table->GetTypeName(row, col);
8294     return GetDefaultRendererForType(typeName);
8295 }
8296
8297 wxGridCellEditor*
8298 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
8299 {
8300     int index = m_typeRegistry->FindOrCloneDataType(typeName);
8301     if ( index == wxNOT_FOUND )
8302     {
8303         wxFAIL_MSG(wxT("Unknown data type name"));
8304
8305         return NULL;
8306     }
8307
8308     return m_typeRegistry->GetEditor(index);
8309 }
8310
8311 wxGridCellRenderer*
8312 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
8313 {
8314     int index = m_typeRegistry->FindOrCloneDataType(typeName);
8315     if ( index == wxNOT_FOUND )
8316     {
8317         wxFAIL_MSG(wxT("Unknown data type name"));
8318
8319         return NULL;
8320     }
8321
8322     return m_typeRegistry->GetRenderer(index);
8323 }
8324
8325
8326 // ----------------------------------------------------------------------------
8327 // row/col size
8328 // ----------------------------------------------------------------------------
8329
8330 void wxGrid::EnableDragRowSize( bool enable )
8331 {
8332     m_canDragRowSize = enable;
8333 }
8334
8335
8336 void wxGrid::EnableDragColSize( bool enable )
8337 {
8338     m_canDragColSize = enable;
8339 }
8340
8341 void wxGrid::EnableDragGridSize( bool enable )
8342 {
8343     m_canDragGridSize = enable;
8344 }
8345
8346
8347 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
8348 {
8349     m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
8350
8351     if ( resizeExistingRows )
8352     {
8353         InitRowHeights();
8354         if ( !GetBatchCount() )
8355             CalcDimensions();
8356     }
8357 }
8358
8359 void wxGrid::SetRowSize( int row, int height )
8360 {
8361     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
8362
8363     if ( m_rowHeights.IsEmpty() )
8364     {
8365         // need to really create the array
8366         InitRowHeights();
8367     }
8368
8369     int h = wxMax( 0, height );
8370     int diff = h - m_rowHeights[row];
8371
8372     m_rowHeights[row] = h;
8373     int i;
8374     for ( i = row;  i < m_numRows;  i++ )
8375     {
8376         m_rowBottoms[i] += diff;
8377     }
8378     if ( !GetBatchCount() )
8379         CalcDimensions();
8380 }
8381
8382 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
8383 {
8384     m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
8385
8386     if ( resizeExistingCols )
8387     {
8388         InitColWidths();
8389         if ( !GetBatchCount() )
8390             CalcDimensions();
8391     }
8392 }
8393
8394 void wxGrid::SetColSize( int col, int width )
8395 {
8396     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
8397
8398     // should we check that it's bigger than GetColMinimalWidth(col) here?
8399
8400     if ( m_colWidths.IsEmpty() )
8401     {
8402         // need to really create the array
8403         InitColWidths();
8404     }
8405
8406     int w = wxMax( 0, width );
8407     int diff = w - m_colWidths[col];
8408     m_colWidths[col] = w;
8409
8410     int i;
8411     for ( i = col;  i < m_numCols;  i++ )
8412     {
8413         m_colRights[i] += diff;
8414     }
8415     if ( !GetBatchCount() )
8416         CalcDimensions();
8417 }
8418
8419
8420 void wxGrid::SetColMinimalWidth( int col, int width )
8421 {
8422     m_colMinWidths.Put(col, width);
8423 }
8424
8425 void wxGrid::SetRowMinimalHeight( int row, int width )
8426 {
8427     m_rowMinHeights.Put(row, width);
8428 }
8429
8430 int wxGrid::GetColMinimalWidth(int col) const
8431 {
8432     long value = m_colMinWidths.Get(col);
8433     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
8434 }
8435
8436 int wxGrid::GetRowMinimalHeight(int row) const
8437 {
8438     long value = m_rowMinHeights.Get(row);
8439     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
8440 }
8441
8442 // ----------------------------------------------------------------------------
8443 // auto sizing
8444 // ----------------------------------------------------------------------------
8445
8446 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
8447 {
8448     wxClientDC dc(m_gridWin);
8449
8450     // init both of them to avoid compiler warnings, even if weo nly need one
8451     int row = -1,
8452         col = -1;
8453     if ( column )
8454         col = colOrRow;
8455     else
8456         row = colOrRow;
8457
8458     wxCoord extent, extentMax = 0;
8459     int max = column ? m_numRows : m_numCols;
8460     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
8461     {
8462         if ( column )
8463             row = rowOrCol;
8464         else
8465             col = rowOrCol;
8466
8467         wxGridCellAttr* attr = GetCellAttr(row, col);
8468         wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8469         if ( renderer )
8470         {
8471             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
8472             extent = column ? size.x : size.y;
8473             if ( extent > extentMax )
8474             {
8475                 extentMax = extent;
8476             }
8477
8478             renderer->DecRef();
8479         }
8480
8481         attr->DecRef();
8482     }
8483
8484     // now also compare with the column label extent
8485     wxCoord w, h;
8486     dc.SetFont( GetLabelFont() );
8487
8488     if ( column )
8489         dc.GetTextExtent( GetColLabelValue(col), &w, &h );
8490     else
8491         dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
8492
8493     extent = column ? w : h;
8494     if ( extent > extentMax )
8495     {
8496         extentMax = extent;
8497     }
8498
8499     if ( !extentMax )
8500     {
8501         // empty column - give default extent (notice that if extentMax is less
8502         // than default extent but != 0, it's ok)
8503         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
8504     }
8505     else
8506     {
8507         if ( column )
8508         {
8509             // leave some space around text
8510             extentMax += 10;
8511         }
8512         else
8513         {
8514             extentMax += 6;
8515         }
8516     }
8517
8518     if ( column )
8519     {
8520         SetColSize(col, extentMax);
8521         if ( !GetBatchCount() )
8522         {
8523             int cw, ch, dummy;
8524             m_gridWin->GetClientSize( &cw, &ch );
8525             wxRect rect ( CellToRect( 0, col ) );
8526             rect.y = 0;
8527             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
8528             rect.width = cw - rect.x;
8529             rect.height = m_colLabelHeight;
8530             m_colLabelWin->Refresh( TRUE, &rect );
8531         }
8532     }
8533     else
8534     {
8535         SetRowSize(row, extentMax);
8536         if ( !GetBatchCount() )
8537         {
8538             int cw, ch, dummy;
8539             m_gridWin->GetClientSize( &cw, &ch );
8540             wxRect rect ( CellToRect( row, 0 ) );
8541             rect.x = 0;
8542             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8543             rect.width = m_rowLabelWidth;
8544             rect.height = ch - rect.y;
8545             m_rowLabelWin->Refresh( TRUE, &rect );
8546         }
8547     }
8548     if ( setAsMin )
8549     {
8550         if ( column )
8551             SetColMinimalWidth(col, extentMax);
8552         else
8553             SetRowMinimalHeight(row, extentMax);
8554     }
8555 }
8556
8557 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8558 {
8559     int width = m_rowLabelWidth;
8560
8561     if ( !calcOnly )
8562         BeginBatch();
8563
8564     for ( int col = 0; col < m_numCols; col++ )
8565     {
8566         if ( !calcOnly )
8567         {
8568             AutoSizeColumn(col, setAsMin);
8569         }
8570
8571         width += GetColWidth(col);
8572     }
8573
8574     if ( !calcOnly )
8575         EndBatch();
8576
8577     return width;
8578 }
8579
8580 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8581 {
8582     int height = m_colLabelHeight;
8583
8584     if ( !calcOnly )
8585         BeginBatch();
8586
8587     for ( int row = 0; row < m_numRows; row++ )
8588     {
8589         if ( !calcOnly )
8590         {
8591             AutoSizeRow(row, setAsMin);
8592         }
8593
8594         height += GetRowHeight(row);
8595     }
8596
8597     if ( !calcOnly )
8598         EndBatch();
8599
8600     return height;
8601 }
8602
8603 void wxGrid::AutoSize()
8604 {
8605     BeginBatch();
8606
8607     wxSize size(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
8608
8609     // round up the size to a multiple of scroll step - this ensures that we
8610     // won't get the scrollbars if we're sized exactly to this width
8611     wxSize sizeFit(GetScrollX(size.x) * GRID_SCROLL_LINE_X,
8612                    GetScrollY(size.y) * GRID_SCROLL_LINE_Y);
8613
8614     // distribute the extra space between teh columns/rows to avoid having
8615     // extra white space
8616     wxCoord diff = sizeFit.x - size.x;
8617     if ( diff )
8618     {
8619         // try to resize the columns uniformly
8620         wxCoord diffPerCol = diff / m_numCols;
8621         if ( diffPerCol )
8622         {
8623             for ( int col = 0; col < m_numCols; col++ )
8624             {
8625                 SetColSize(col, GetColWidth(col) + diffPerCol);
8626             }
8627         }
8628
8629         // add remaining amount to the last columns
8630         diff -= diffPerCol * m_numCols;
8631         if ( diff )
8632         {
8633             for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
8634             {
8635                 SetColSize(col, GetColWidth(col) + 1);
8636             }
8637         }
8638     }
8639
8640     // same for rows
8641     diff = sizeFit.y - size.y;
8642     if ( diff )
8643     {
8644         // try to resize the columns uniformly
8645         wxCoord diffPerRow = diff / m_numRows;
8646         if ( diffPerRow )
8647         {
8648             for ( int row = 0; row < m_numRows; row++ )
8649             {
8650                 SetRowSize(row, GetRowHeight(row) + diffPerRow);
8651             }
8652         }
8653
8654         // add remaining amount to the last rows
8655         diff -= diffPerRow * m_numRows;
8656         if ( diff )
8657         {
8658             for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
8659             {
8660                 SetRowSize(row, GetRowHeight(row) + 1);
8661             }
8662         }
8663     }
8664
8665     EndBatch();
8666
8667     SetClientSize(sizeFit);
8668 }
8669
8670 wxSize wxGrid::DoGetBestSize() const
8671 {
8672     // don't set sizes, only calculate them
8673     wxGrid *self = (wxGrid *)this;  // const_cast
8674
8675     return wxSize(self->SetOrCalcColumnSizes(TRUE),
8676                   self->SetOrCalcRowSizes(TRUE));
8677 }
8678
8679 void wxGrid::Fit()
8680 {
8681     AutoSize();
8682 }
8683
8684
8685 wxPen& wxGrid::GetDividerPen() const
8686 {
8687     return wxNullPen;
8688 }
8689
8690 // ----------------------------------------------------------------------------
8691 // cell value accessor functions
8692 // ----------------------------------------------------------------------------
8693
8694 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8695 {
8696     if ( m_table )
8697     {
8698         m_table->SetValue( row, col, s );
8699         if ( !GetBatchCount() )
8700         {
8701             wxClientDC dc( m_gridWin );
8702             PrepareDC( dc );
8703             DrawCell( dc, wxGridCellCoords(row, col) );
8704         }
8705
8706         if ( m_currentCellCoords.GetRow() == row &&
8707              m_currentCellCoords.GetCol() == col &&
8708              IsCellEditControlShown())
8709              // Note: If we are using IsCellEditControlEnabled,
8710              // this interacts badly with calling SetCellValue from
8711              // an EVT_GRID_CELL_CHANGE handler.
8712         {
8713             HideCellEditControl();
8714             ShowCellEditControl(); // will reread data from table
8715         }
8716     }
8717 }
8718
8719
8720 //
8721 // ------ Block, row and col selection
8722 //
8723
8724 void wxGrid::SelectRow( int row, bool addToSelected )
8725 {
8726     if ( IsSelection() && !addToSelected )
8727         ClearSelection();
8728
8729     m_selection->SelectRow( row, FALSE, addToSelected );
8730 }
8731
8732
8733 void wxGrid::SelectCol( int col, bool addToSelected )
8734 {
8735     if ( IsSelection() && !addToSelected )
8736         ClearSelection();
8737
8738     m_selection->SelectCol( col, FALSE, addToSelected );
8739 }
8740
8741
8742 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
8743                           bool addToSelected )
8744 {
8745     if ( IsSelection() && !addToSelected )
8746         ClearSelection();
8747
8748     m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
8749                               FALSE, addToSelected );
8750 }
8751
8752
8753 void wxGrid::SelectAll()
8754 {
8755     if ( m_numRows > 0 && m_numCols > 0 )
8756         m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
8757 }
8758
8759 //
8760 // ------ Cell, row and col deselection
8761 //
8762
8763 void wxGrid::DeselectRow( int row )
8764 {
8765     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
8766     {
8767         if ( m_selection->IsInSelection(row, 0 ) )
8768             m_selection->ToggleCellSelection( row, 0);
8769     }
8770     else
8771     {
8772         int nCols = GetNumberCols();
8773         for ( int i = 0; i < nCols ; i++ )
8774         {
8775             if ( m_selection->IsInSelection(row, i ) )
8776                 m_selection->ToggleCellSelection( row, i);
8777         }
8778     }
8779 }
8780
8781 void wxGrid::DeselectCol( int col )
8782 {
8783     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
8784     {
8785         if ( m_selection->IsInSelection(0, col ) )
8786             m_selection->ToggleCellSelection( 0, col);
8787     }
8788     else
8789     {
8790         int nRows = GetNumberRows();
8791         for ( int i = 0; i < nRows ; i++ )
8792         {
8793             if ( m_selection->IsInSelection(i, col ) )
8794                 m_selection->ToggleCellSelection(i, col);
8795         }
8796     }
8797 }
8798
8799 void wxGrid::DeselectCell( int row, int col )
8800 {
8801     if ( m_selection->IsInSelection(row, col) )
8802         m_selection->ToggleCellSelection(row, col);
8803 }
8804
8805 bool wxGrid::IsSelection()
8806 {
8807     return ( m_selection->IsSelection() ||
8808              ( m_selectingTopLeft != wxGridNoCellCoords &&
8809                m_selectingBottomRight != wxGridNoCellCoords ) );
8810 }
8811
8812 bool wxGrid::IsInSelection( int row, int col )
8813 {
8814     return ( m_selection->IsInSelection( row, col ) ||
8815              ( row >= m_selectingTopLeft.GetRow() &&
8816                col >= m_selectingTopLeft.GetCol() &&
8817                row <= m_selectingBottomRight.GetRow() &&
8818                col <= m_selectingBottomRight.GetCol() ) );
8819 }
8820
8821 void wxGrid::ClearSelection()
8822 {
8823     m_selectingTopLeft = wxGridNoCellCoords;
8824     m_selectingBottomRight = wxGridNoCellCoords;
8825     m_selection->ClearSelection();
8826 }
8827
8828
8829 // This function returns the rectangle that encloses the given block
8830 // in device coords clipped to the client size of the grid window.
8831 //
8832 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
8833                                   const wxGridCellCoords &bottomRight )
8834 {
8835     wxRect rect( wxGridNoCellRect );
8836     wxRect cellRect;
8837
8838     cellRect = CellToRect( topLeft );
8839     if ( cellRect != wxGridNoCellRect )
8840     {
8841         rect = cellRect;
8842     }
8843     else
8844     {
8845         rect = wxRect( 0, 0, 0, 0 );
8846     }
8847
8848     cellRect = CellToRect( bottomRight );
8849     if ( cellRect != wxGridNoCellRect )
8850     {
8851         rect += cellRect;
8852     }
8853     else
8854     {
8855         return wxGridNoCellRect;
8856     }
8857
8858     // convert to scrolled coords
8859     //
8860     int left, top, right, bottom;
8861     CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
8862     CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
8863
8864     int cw, ch;
8865     m_gridWin->GetClientSize( &cw, &ch );
8866
8867     if (right < 0 || bottom < 0 || left > cw || top > ch)
8868         return wxRect( 0, 0, 0, 0);
8869
8870     rect.SetLeft( wxMax(0, left) );
8871     rect.SetTop( wxMax(0, top) );
8872     rect.SetRight( wxMin(cw, right) );
8873     rect.SetBottom( wxMin(ch, bottom) );
8874
8875     return rect;
8876 }
8877
8878
8879
8880 //
8881 // ------ Grid event classes
8882 //
8883
8884 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8885
8886 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8887                           int row, int col, int x, int y, bool sel,
8888                           bool control, bool shift, bool alt, bool meta )
8889         : wxNotifyEvent( type, id )
8890 {
8891     m_row = row;
8892     m_col = col;
8893     m_x = x;
8894     m_y = y;
8895     m_selecting = sel;
8896     m_control = control;
8897     m_shift = shift;
8898     m_alt = alt;
8899     m_meta = meta;
8900
8901     SetEventObject(obj);
8902 }
8903
8904
8905 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8906
8907 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8908                                   int rowOrCol, int x, int y,
8909                                   bool control, bool shift, bool alt, bool meta )
8910         : wxNotifyEvent( type, id )
8911 {
8912     m_rowOrCol = rowOrCol;
8913     m_x = x;
8914     m_y = y;
8915     m_control = control;
8916     m_shift = shift;
8917     m_alt = alt;
8918     m_meta = meta;
8919
8920     SetEventObject(obj);
8921 }
8922
8923
8924 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8925
8926 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8927                                                const wxGridCellCoords& topLeft,
8928                                                const wxGridCellCoords& bottomRight,
8929                                                bool sel, bool control,
8930                                                bool shift, bool alt, bool meta )
8931         : wxNotifyEvent( type, id )
8932 {
8933     m_topLeft     = topLeft;
8934     m_bottomRight = bottomRight;
8935     m_selecting   = sel;
8936     m_control     = control;
8937     m_shift       = shift;
8938     m_alt         = alt;
8939     m_meta        = meta;
8940
8941     SetEventObject(obj);
8942 }
8943
8944
8945 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8946
8947 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8948                                                    wxObject* obj, int row,
8949                                                    int col, wxControl* ctrl)
8950     : wxCommandEvent(type, id)
8951 {
8952     SetEventObject(obj);
8953     m_row = row;
8954     m_col = col;
8955     m_ctrl = ctrl;
8956 }
8957
8958
8959 #endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
8960
8961 #endif // wxUSE_GRID
8962