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 wxPanel
 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 wxGridCellAttr *wxGridCellAttr::Clone() const
1902 {
1903     wxGridCellAttr *attr = new wxGridCellAttr;
1904     if ( HasTextColour() )
1905         attr->SetTextColour(GetTextColour());
1906     if ( HasBackgroundColour() )
1907         attr->SetBackgroundColour(GetBackgroundColour());
1908     if ( HasFont() )
1909         attr->SetFont(GetFont());
1910     if ( HasAlignment() )
1911         attr->SetAlignment(m_hAlign, m_vAlign);
1912
1913     if ( m_renderer )
1914     {
1915         attr->SetRenderer(m_renderer);
1916         m_renderer->IncRef();
1917     }
1918     if ( m_editor )
1919     {
1920         attr->SetEditor(m_editor);
1921         m_editor->IncRef();
1922     }
1923
1924     if ( IsReadOnly() )
1925         attr->SetReadOnly();
1926
1927     attr->SetKind( m_attrkind );
1928
1929     attr->SetDefAttr(m_defGridAttr);
1930
1931     return attr;
1932 }
1933
1934 void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
1935 {
1936     if ( !HasTextColour() && mergefrom->HasTextColour() )
1937         SetTextColour(mergefrom->GetTextColour());
1938     if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
1939         SetBackgroundColour(mergefrom->GetBackgroundColour());
1940     if ( !HasFont() && mergefrom->HasFont() )
1941         SetFont(mergefrom->GetFont());
1942     if ( !!HasAlignment() && mergefrom->HasAlignment() ){
1943         int hAlign, vAlign;
1944         mergefrom->GetAlignment( &hAlign, &vAlign);
1945         SetAlignment(hAlign, vAlign);
1946     }
1947
1948     // Directly access member functions as GetRender/Editor don't just return
1949     // m_renderer/m_editor
1950     //
1951     // Maybe add support for merge of Render and Editor?
1952     if (!HasRenderer() && mergefrom->HasRenderer() )
1953     {
1954         m_renderer = mergefrom->m_renderer;
1955         m_renderer->IncRef();
1956     }
1957     if ( !HasEditor() && mergefrom->HasEditor() )
1958     {
1959         m_editor =  mergefrom->m_editor;
1960         m_editor->IncRef();
1961     }
1962     if ( !HasReadWriteMode()  && mergefrom->HasReadWriteMode() )
1963         SetReadOnly(mergefrom->IsReadOnly());
1964
1965     SetDefAttr(mergefrom->m_defGridAttr);
1966 }
1967
1968 const wxColour& wxGridCellAttr::GetTextColour() const
1969 {
1970     if (HasTextColour())
1971     {
1972         return m_colText;
1973     }
1974     else if (m_defGridAttr != this)
1975     {
1976         return m_defGridAttr->GetTextColour();
1977     }
1978     else
1979     {
1980         wxFAIL_MSG(wxT("Missing default cell attribute"));
1981         return wxNullColour;
1982     }
1983 }
1984
1985
1986 const wxColour& wxGridCellAttr::GetBackgroundColour() const
1987 {
1988     if (HasBackgroundColour())
1989         return m_colBack;
1990     else if (m_defGridAttr != this)
1991         return m_defGridAttr->GetBackgroundColour();
1992     else
1993     {
1994         wxFAIL_MSG(wxT("Missing default cell attribute"));
1995         return wxNullColour;
1996     }
1997 }
1998
1999
2000 const wxFont& wxGridCellAttr::GetFont() const
2001 {
2002     if (HasFont())
2003         return m_font;
2004     else if (m_defGridAttr != this)
2005         return m_defGridAttr->GetFont();
2006     else
2007     {
2008         wxFAIL_MSG(wxT("Missing default cell attribute"));
2009         return wxNullFont;
2010     }
2011 }
2012
2013
2014 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
2015 {
2016     if (HasAlignment())
2017     {
2018         if ( hAlign ) *hAlign = m_hAlign;
2019         if ( vAlign ) *vAlign = m_vAlign;
2020     }
2021     else if (m_defGridAttr != this)
2022         m_defGridAttr->GetAlignment(hAlign, vAlign);
2023     else
2024     {
2025         wxFAIL_MSG(wxT("Missing default cell attribute"));
2026     }
2027 }
2028
2029
2030 // GetRenderer and GetEditor use a slightly different decision path about
2031 // which attribute to use.  If a non-default attr object has one then it is
2032 // used, otherwise the default editor or renderer is fetched from the grid and
2033 // used.  It should be the default for the data type of the cell.  If it is
2034 // NULL (because the table has a type that the grid does not have in its
2035 // registry,) then the grid's default editor or renderer is used.
2036
2037 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
2038 {
2039     wxGridCellRenderer *renderer;
2040
2041     if ( m_renderer && this != m_defGridAttr )
2042     {
2043         // use the cells renderer if it has one
2044         renderer = m_renderer;
2045         renderer->IncRef();
2046     }
2047     else // no non default cell renderer
2048     {
2049         // get default renderer for the data type
2050         if ( grid )
2051         {
2052             // GetDefaultRendererForCell() will do IncRef() for us
2053             renderer = grid->GetDefaultRendererForCell(row, col);
2054         }
2055         else
2056         {
2057             renderer = NULL;
2058         }
2059
2060         if ( !renderer )
2061         {
2062             if ( this != m_defGridAttr )
2063             {
2064                 // if we still don't have one then use the grid default
2065                 // (no need for IncRef() here neither)
2066                 renderer = m_defGridAttr->GetRenderer(NULL, 0, 0);
2067             }
2068             else // default grid attr
2069             {
2070                 // use m_renderer which we had decided not to use initially
2071                 renderer = m_renderer;
2072                 if ( renderer )
2073                     renderer->IncRef();
2074             }
2075         }
2076     }
2077
2078     // we're supposed to always find something
2079     wxASSERT_MSG(renderer, wxT("Missing default cell renderer"));
2080
2081     return renderer;
2082 }
2083
2084 // same as above, except for s/renderer/editor/g
2085 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
2086 {
2087     wxGridCellEditor *editor;
2088
2089     if ( m_editor && this != m_defGridAttr )
2090     {
2091         // use the cells editor if it has one
2092         editor = m_editor;
2093         editor->IncRef();
2094     }
2095     else // no non default cell editor
2096     {
2097         // get default editor for the data type
2098         if ( grid )
2099         {
2100             // GetDefaultEditorForCell() will do IncRef() for us
2101             editor = grid->GetDefaultEditorForCell(row, col);
2102         }
2103         else
2104         {
2105             editor = NULL;
2106         }
2107
2108         if ( !editor )
2109         {
2110             if ( this != m_defGridAttr )
2111             {
2112                 // if we still don't have one then use the grid default
2113                 // (no need for IncRef() here neither)
2114                 editor = m_defGridAttr->GetEditor(NULL, 0, 0);
2115             }
2116             else // default grid attr
2117             {
2118                 // use m_editor which we had decided not to use initially
2119                 editor = m_editor;
2120                 if ( editor )
2121                     editor->IncRef();
2122             }
2123         }
2124     }
2125
2126     // we're supposed to always find something
2127     wxASSERT_MSG(editor, wxT("Missing default cell editor"));
2128
2129     return editor;
2130 }
2131
2132 // ----------------------------------------------------------------------------
2133 // wxGridCellAttrData
2134 // ----------------------------------------------------------------------------
2135
2136 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
2137 {
2138     int n = FindIndex(row, col);
2139     if ( n == wxNOT_FOUND )
2140     {
2141         // add the attribute
2142         m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
2143     }
2144     else
2145     {
2146         // free the old attribute
2147         m_attrs[(size_t)n].attr->DecRef();
2148
2149         if ( attr )
2150         {
2151             // change the attribute
2152             m_attrs[(size_t)n].attr = attr;
2153         }
2154         else
2155         {
2156             // remove this attribute
2157             m_attrs.RemoveAt((size_t)n);
2158         }
2159     }
2160 }
2161
2162 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
2163 {
2164     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2165
2166     int n = FindIndex(row, col);
2167     if ( n != wxNOT_FOUND )
2168     {
2169         attr = m_attrs[(size_t)n].attr;
2170         attr->IncRef();
2171     }
2172
2173     return attr;
2174 }
2175
2176 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
2177 {
2178     size_t count = m_attrs.GetCount();
2179     for ( size_t n = 0; n < count; n++ )
2180     {
2181         wxGridCellCoords& coords = m_attrs[n].coords;
2182         wxCoord row = coords.GetRow();
2183         if ((size_t)row >= pos)
2184         {
2185             if (numRows > 0)
2186             {
2187                 // If rows inserted, include row counter where necessary
2188                 coords.SetRow(row + numRows);
2189             }
2190             else if (numRows < 0)
2191             {
2192                 // If rows deleted ...
2193                 if ((size_t)row >= pos - numRows)
2194                 {
2195                     // ...either decrement row counter (if row still exists)...
2196                     coords.SetRow(row + numRows);
2197                 }
2198                 else
2199                 {
2200                     // ...or remove the attribute
2201                     m_attrs.RemoveAt((size_t)n);
2202                     n--; count--;
2203                 }
2204             }
2205         }
2206     }
2207 }
2208
2209 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
2210 {
2211     size_t count = m_attrs.GetCount();
2212     for ( size_t n = 0; n < count; n++ )
2213     {
2214         wxGridCellCoords& coords = m_attrs[n].coords;
2215         wxCoord col = coords.GetCol();
2216         if ( (size_t)col >= pos )
2217         {
2218             if ( numCols > 0 )
2219             {
2220                 // If rows inserted, include row counter where necessary
2221                 coords.SetCol(col + numCols);
2222             }
2223             else if (numCols < 0)
2224             {
2225                 // If rows deleted ...
2226                 if ((size_t)col >= pos - numCols)
2227                 {
2228                     // ...either decrement row counter (if row still exists)...
2229                     coords.SetCol(col + numCols);
2230                 }
2231                 else
2232                 {
2233                     // ...or remove the attribute
2234                     m_attrs.RemoveAt((size_t)n);
2235                     n--; count--;
2236                 }
2237             }
2238         }
2239     }
2240 }
2241
2242 int wxGridCellAttrData::FindIndex(int row, int col) const
2243 {
2244     size_t count = m_attrs.GetCount();
2245     for ( size_t n = 0; n < count; n++ )
2246     {
2247         const wxGridCellCoords& coords = m_attrs[n].coords;
2248         if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
2249         {
2250             return n;
2251         }
2252     }
2253
2254     return wxNOT_FOUND;
2255 }
2256
2257 // ----------------------------------------------------------------------------
2258 // wxGridRowOrColAttrData
2259 // ----------------------------------------------------------------------------
2260
2261 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2262 {
2263     size_t count = m_attrs.Count();
2264     for ( size_t n = 0; n < count; n++ )
2265     {
2266         m_attrs[n]->DecRef();
2267     }
2268 }
2269
2270 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
2271 {
2272     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2273
2274     int n = m_rowsOrCols.Index(rowOrCol);
2275     if ( n != wxNOT_FOUND )
2276     {
2277         attr = m_attrs[(size_t)n];
2278         attr->IncRef();
2279     }
2280
2281     return attr;
2282 }
2283
2284 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
2285 {
2286     int i = m_rowsOrCols.Index(rowOrCol);
2287     if ( i == wxNOT_FOUND )
2288     {
2289         // add the attribute
2290         m_rowsOrCols.Add(rowOrCol);
2291         m_attrs.Add(attr);
2292     }
2293     else
2294     {
2295         size_t n = (size_t)i;
2296         if ( attr )
2297         {
2298             // change the attribute
2299             m_attrs[n]->DecRef();
2300             m_attrs[n] = attr;
2301         }
2302         else
2303         {
2304             // remove this attribute
2305             m_attrs[n]->DecRef();
2306             m_rowsOrCols.RemoveAt(n);
2307             m_attrs.RemoveAt(n);
2308         }
2309     }
2310 }
2311
2312 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2313 {
2314     size_t count = m_attrs.GetCount();
2315     for ( size_t n = 0; n < count; n++ )
2316     {
2317         int & rowOrCol = m_rowsOrCols[n];
2318         if ( (size_t)rowOrCol >= pos )
2319         {
2320             if ( numRowsOrCols > 0 )
2321             {
2322                 // If rows inserted, include row counter where necessary
2323                 rowOrCol += numRowsOrCols;
2324             }
2325             else if ( numRowsOrCols < 0)
2326             {
2327                 // If rows deleted, either decrement row counter (if row still exists)
2328                 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2329                     rowOrCol += numRowsOrCols;
2330                 else
2331                 {
2332                     m_rowsOrCols.RemoveAt((size_t)n);
2333                     m_attrs.RemoveAt((size_t)n);
2334                     n--; count--;
2335                 }
2336             }
2337         }
2338     }
2339 }
2340
2341 // ----------------------------------------------------------------------------
2342 // wxGridCellAttrProvider
2343 // ----------------------------------------------------------------------------
2344
2345 wxGridCellAttrProvider::wxGridCellAttrProvider()
2346 {
2347     m_data = (wxGridCellAttrProviderData *)NULL;
2348 }
2349
2350 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2351 {
2352     delete m_data;
2353 }
2354
2355 void wxGridCellAttrProvider::InitData()
2356 {
2357     m_data = new wxGridCellAttrProviderData;
2358 }
2359
2360 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
2361                                                 wxGridCellAttr::wxAttrKind  kind ) const
2362 {
2363     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2364     if ( m_data )
2365     {
2366         switch(kind)
2367         {
2368             case (wxGridCellAttr::Any):
2369                 //Get cached merge attributes.
2370                 // Currenlty not used as no cache implemented as not mutiable
2371                 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2372                 if(!attr)
2373                 {
2374                     //Basicaly implement old version.
2375                     //Also check merge cache, so we don't have to re-merge every time..
2376                     wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
2377                                    *attrrow = (wxGridCellAttr *)NULL,
2378                                    *attrcol = (wxGridCellAttr *)NULL;
2379
2380                     attrcell = m_data->m_cellAttrs.GetAttr(row, col);
2381                     attrcol = m_data->m_colAttrs.GetAttr(col);
2382                     attrrow = m_data->m_rowAttrs.GetAttr(row);
2383
2384                     if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){
2385                         // Two or move are non NULL
2386                         attr = new wxGridCellAttr;
2387                         attr->SetKind(wxGridCellAttr::Merged);
2388
2389                         //Order important..
2390                         if(attrcell){
2391                             attr->MergeWith(attrcell);
2392                             attrcell->DecRef();
2393                         }
2394                         if(attrcol){
2395                             attr->MergeWith(attrcol);
2396                             attrcol->DecRef();
2397                         }
2398                         if(attrrow){
2399                             attr->MergeWith(attrrow);
2400                             attrrow->DecRef();
2401                         }
2402                         //store merge attr if cache implemented
2403                         //attr->IncRef();
2404                         //m_data->m_mergeAttr.SetAttr(attr, row, col);
2405                     }
2406                     else
2407         {
2408                         // one or none is non null return it or null.
2409                         if(attrrow) attr = attrrow;
2410                         if(attrcol) attr = attrcol;
2411                         if(attrcell) attr = attrcell;
2412                     }
2413                 }
2414             break;
2415             case (wxGridCellAttr::Cell):
2416                 attr = m_data->m_cellAttrs.GetAttr(row, col);
2417             break;
2418             case (wxGridCellAttr::Col):
2419                  attr = m_data->m_colAttrs.GetAttr(col);
2420             break;
2421             case (wxGridCellAttr::Row):
2422             attr = m_data->m_rowAttrs.GetAttr(row);
2423             break;
2424             default:
2425                 // unused as yet...
2426                 // (wxGridCellAttr::Default):
2427                 // (wxGridCellAttr::Merged):
2428             break;
2429         }
2430     }
2431     return attr;
2432 }
2433
2434 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2435                                      int row, int col)
2436 {
2437     if ( !m_data )
2438         InitData();
2439
2440     m_data->m_cellAttrs.SetAttr(attr, row, col);
2441 }
2442
2443 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2444 {
2445     if ( !m_data )
2446         InitData();
2447
2448     m_data->m_rowAttrs.SetAttr(attr, row);
2449 }
2450
2451 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2452 {
2453     if ( !m_data )
2454         InitData();
2455
2456     m_data->m_colAttrs.SetAttr(attr, col);
2457 }
2458
2459 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2460 {
2461     if ( m_data )
2462     {
2463         m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2464
2465         m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2466     }
2467 }
2468
2469 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2470 {
2471     if ( m_data )
2472     {
2473         m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2474
2475         m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2476     }
2477 }
2478
2479 // ----------------------------------------------------------------------------
2480 // wxGridTypeRegistry
2481 // ----------------------------------------------------------------------------
2482
2483 wxGridTypeRegistry::~wxGridTypeRegistry()
2484 {
2485     size_t count = m_typeinfo.Count();
2486     for ( size_t i = 0; i < count; i++ )
2487         delete m_typeinfo[i];
2488 }
2489
2490
2491 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2492                                           wxGridCellRenderer* renderer,
2493                                           wxGridCellEditor* editor)
2494 {
2495     wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2496
2497     // is it already registered?
2498     int loc = FindRegisteredDataType(typeName);
2499     if ( loc != wxNOT_FOUND )
2500     {
2501         delete m_typeinfo[loc];
2502         m_typeinfo[loc] = info;
2503     }
2504     else
2505     {
2506         m_typeinfo.Add(info);
2507     }
2508 }
2509
2510 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2511 {
2512     size_t count = m_typeinfo.GetCount();
2513     for ( size_t i = 0; i < count; i++ )
2514     {
2515         if ( typeName == m_typeinfo[i]->m_typeName )
2516         {
2517             return i;
2518         }
2519     }
2520
2521     return wxNOT_FOUND;
2522 }
2523
2524 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2525 {
2526     int index = FindRegisteredDataType(typeName);
2527     if ( index == wxNOT_FOUND )
2528     {
2529         // check whether this is one of the standard ones, in which case
2530         // register it "on the fly"
2531 #if wxUSE_TEXTCTRL
2532         if ( typeName == wxGRID_VALUE_STRING )
2533         {
2534             RegisterDataType(wxGRID_VALUE_STRING,
2535                              new wxGridCellStringRenderer,
2536                              new wxGridCellTextEditor);
2537         } else
2538 #endif // wxUSE_TEXTCTRL
2539 #if wxUSE_CHECKBOX
2540         if ( typeName == wxGRID_VALUE_BOOL )
2541         {
2542             RegisterDataType(wxGRID_VALUE_BOOL,
2543                              new wxGridCellBoolRenderer,
2544                              new wxGridCellBoolEditor);
2545         } else
2546 #endif // wxUSE_CHECKBOX
2547 #if wxUSE_TEXTCTRL
2548         if ( typeName == wxGRID_VALUE_NUMBER )
2549         {
2550             RegisterDataType(wxGRID_VALUE_NUMBER,
2551                              new wxGridCellNumberRenderer,
2552                              new wxGridCellNumberEditor);
2553         }
2554         else if ( typeName == wxGRID_VALUE_FLOAT )
2555         {
2556             RegisterDataType(wxGRID_VALUE_FLOAT,
2557                              new wxGridCellFloatRenderer,
2558                              new wxGridCellFloatEditor);
2559         } else
2560 #endif // wxUSE_TEXTCTRL
2561 #if wxUSE_COMBOBOX
2562         if ( typeName == wxGRID_VALUE_CHOICE )
2563         {
2564             RegisterDataType(wxGRID_VALUE_CHOICE,
2565                              new wxGridCellStringRenderer,
2566                              new wxGridCellChoiceEditor);
2567         } else
2568 #endif // wxUSE_COMBOBOX
2569         {
2570             return wxNOT_FOUND;
2571         }
2572
2573         // we get here only if just added the entry for this type, so return
2574         // the last index
2575         index = m_typeinfo.GetCount() - 1;
2576     }
2577
2578     return index;
2579 }
2580
2581 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2582 {
2583     int index = FindDataType(typeName);
2584     if ( index == wxNOT_FOUND )
2585     {
2586         // the first part of the typename is the "real" type, anything after ':'
2587         // are the parameters for the renderer
2588         index = FindDataType(typeName.BeforeFirst(_T(':')));
2589         if ( index == wxNOT_FOUND )
2590         {
2591             return wxNOT_FOUND;
2592         }
2593
2594         wxGridCellRenderer *renderer = GetRenderer(index);
2595         wxGridCellRenderer *rendererOld = renderer;
2596         renderer = renderer->Clone();
2597         rendererOld->DecRef();
2598
2599         wxGridCellEditor *editor = GetEditor(index);
2600         wxGridCellEditor *editorOld = editor;
2601         editor = editor->Clone();
2602         editorOld->DecRef();
2603
2604         // do it even if there are no parameters to reset them to defaults
2605         wxString params = typeName.AfterFirst(_T(':'));
2606         renderer->SetParameters(params);
2607         editor->SetParameters(params);
2608
2609         // register the new typename
2610         RegisterDataType(typeName, renderer, editor);
2611
2612         // we just registered it, it's the last one
2613         index = m_typeinfo.GetCount() - 1;
2614     }
2615
2616     return index;
2617 }
2618
2619 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2620 {
2621     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
2622     if (renderer)
2623         renderer->IncRef();
2624     return renderer;
2625 }
2626
2627 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
2628 {
2629     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
2630     if (editor)
2631         editor->IncRef();
2632     return editor;
2633 }
2634
2635 // ----------------------------------------------------------------------------
2636 // wxGridTableBase
2637 // ----------------------------------------------------------------------------
2638
2639 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2640
2641
2642 wxGridTableBase::wxGridTableBase()
2643 {
2644     m_view = (wxGrid *) NULL;
2645     m_attrProvider = (wxGridCellAttrProvider *) NULL;
2646 }
2647
2648 wxGridTableBase::~wxGridTableBase()
2649 {
2650     delete m_attrProvider;
2651 }
2652
2653 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2654 {
2655     delete m_attrProvider;
2656     m_attrProvider = attrProvider;
2657 }
2658
2659 bool wxGridTableBase::CanHaveAttributes()
2660 {
2661     if ( ! GetAttrProvider() )
2662     {
2663         // use the default attr provider by default
2664         SetAttrProvider(new wxGridCellAttrProvider);
2665     }
2666     return TRUE;
2667 }
2668
2669 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind  kind)
2670 {
2671     if ( m_attrProvider )
2672         return m_attrProvider->GetAttr(row, col, kind);
2673     else
2674         return (wxGridCellAttr *)NULL;
2675 }
2676
2677 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
2678 {
2679     if ( m_attrProvider )
2680     {
2681         attr->SetKind(wxGridCellAttr::Cell);
2682         m_attrProvider->SetAttr(attr, row, col);
2683     }
2684     else
2685     {
2686         // as we take ownership of the pointer and don't store it, we must
2687         // free it now
2688         wxSafeDecRef(attr);
2689     }
2690 }
2691
2692 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2693 {
2694     if ( m_attrProvider )
2695     {
2696         attr->SetKind(wxGridCellAttr::Row);
2697         m_attrProvider->SetRowAttr(attr, row);
2698     }
2699     else
2700     {
2701         // as we take ownership of the pointer and don't store it, we must
2702         // free it now
2703         wxSafeDecRef(attr);
2704     }
2705 }
2706
2707 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2708 {
2709     if ( m_attrProvider )
2710     {
2711         attr->SetKind(wxGridCellAttr::Col);
2712         m_attrProvider->SetColAttr(attr, col);
2713     }
2714     else
2715     {
2716         // as we take ownership of the pointer and don't store it, we must
2717         // free it now
2718         wxSafeDecRef(attr);
2719     }
2720 }
2721
2722 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
2723                                   size_t WXUNUSED(numRows) )
2724 {
2725     wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2726
2727     return FALSE;
2728 }
2729
2730 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
2731 {
2732     wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2733
2734     return FALSE;
2735 }
2736
2737 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
2738                                   size_t WXUNUSED(numRows) )
2739 {
2740     wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2741
2742     return FALSE;
2743 }
2744
2745 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
2746                                   size_t WXUNUSED(numCols) )
2747 {
2748     wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2749
2750     return FALSE;
2751 }
2752
2753 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
2754 {
2755     wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2756
2757     return FALSE;
2758 }
2759
2760 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
2761                                   size_t WXUNUSED(numCols) )
2762 {
2763     wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2764
2765     return FALSE;
2766 }
2767
2768
2769 wxString wxGridTableBase::GetRowLabelValue( int row )
2770 {
2771     wxString s;
2772     s << row + 1; // RD: Starting the rows at zero confuses users, no matter
2773                   //     how much it makes sense to us geeks.
2774     return s;
2775 }
2776
2777 wxString wxGridTableBase::GetColLabelValue( int col )
2778 {
2779     // default col labels are:
2780     //   cols 0 to 25   : A-Z
2781     //   cols 26 to 675 : AA-ZZ
2782     //   etc.
2783
2784     wxString s;
2785     unsigned int i, n;
2786     for ( n = 1; ; n++ )
2787     {
2788         s += (_T('A') + (wxChar)( col%26 ));
2789         col = col/26 - 1;
2790         if ( col < 0 ) break;
2791     }
2792
2793     // reverse the string...
2794     wxString s2;
2795     for ( i = 0;  i < n;  i++ )
2796     {
2797         s2 += s[n-i-1];
2798     }
2799
2800     return s2;
2801 }
2802
2803
2804 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
2805 {
2806     return wxGRID_VALUE_STRING;
2807 }
2808
2809 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
2810                                      const wxString& typeName )
2811 {
2812     return typeName == wxGRID_VALUE_STRING;
2813 }
2814
2815 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
2816 {
2817     return CanGetValueAs(row, col, typeName);
2818 }
2819
2820 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
2821 {
2822     return 0;
2823 }
2824
2825 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
2826 {
2827     return 0.0;
2828 }
2829
2830 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
2831 {
2832     return FALSE;
2833 }
2834
2835 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
2836                                       long WXUNUSED(value) )
2837 {
2838 }
2839
2840 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
2841                                         double WXUNUSED(value) )
2842 {
2843 }
2844
2845 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
2846                                       bool WXUNUSED(value) )
2847 {
2848 }
2849
2850
2851 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2852                                          const wxString& WXUNUSED(typeName) )
2853 {
2854     return NULL;
2855 }
2856
2857 void  wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2858                                          const wxString& WXUNUSED(typeName),
2859                                          void* WXUNUSED(value) )
2860 {
2861 }
2862
2863 //////////////////////////////////////////////////////////////////////
2864 //
2865 // Message class for the grid table to send requests and notifications
2866 // to the grid view
2867 //
2868
2869 wxGridTableMessage::wxGridTableMessage()
2870 {
2871     m_table = (wxGridTableBase *) NULL;
2872     m_id = -1;
2873     m_comInt1 = -1;
2874     m_comInt2 = -1;
2875 }
2876
2877 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
2878                                         int commandInt1, int commandInt2 )
2879 {
2880     m_table = table;
2881     m_id = id;
2882     m_comInt1 = commandInt1;
2883     m_comInt2 = commandInt2;
2884 }
2885
2886
2887
2888 //////////////////////////////////////////////////////////////////////
2889 //
2890 // A basic grid table for string data. An object of this class will
2891 // created by wxGrid if you don't specify an alternative table class.
2892 //
2893
2894 WX_DEFINE_OBJARRAY(wxGridStringArray)
2895
2896 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
2897
2898 wxGridStringTable::wxGridStringTable()
2899         : wxGridTableBase()
2900 {
2901 }
2902
2903 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
2904         : wxGridTableBase()
2905 {
2906     int row, col;
2907
2908     m_data.Alloc( numRows );
2909
2910     wxArrayString sa;
2911     sa.Alloc( numCols );
2912     for ( col = 0;  col < numCols;  col++ )
2913     {
2914         sa.Add( wxEmptyString );
2915     }
2916
2917     for ( row = 0;  row < numRows;  row++ )
2918     {
2919         m_data.Add( sa );
2920     }
2921 }
2922
2923 wxGridStringTable::~wxGridStringTable()
2924 {
2925 }
2926
2927 int wxGridStringTable::GetNumberRows()
2928 {
2929     return m_data.GetCount();
2930 }
2931
2932 int wxGridStringTable::GetNumberCols()
2933 {
2934     if ( m_data.GetCount() > 0 )
2935         return m_data[0].GetCount();
2936     else
2937         return 0;
2938 }
2939
2940 wxString wxGridStringTable::GetValue( int row, int col )
2941 {
2942     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2943                   _T("invalid row or column index in wxGridStringTable") );
2944
2945     return m_data[row][col];
2946 }
2947
2948 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
2949 {
2950     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2951                   _T("invalid row or column index in wxGridStringTable") );
2952
2953     m_data[row][col] = value;
2954 }
2955
2956 bool wxGridStringTable::IsEmptyCell( int row, int col )
2957 {
2958     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2959                   _T("invalid row or column index in wxGridStringTable") );
2960
2961     return (m_data[row][col] == wxEmptyString);
2962 }
2963
2964 void wxGridStringTable::Clear()
2965 {
2966     int row, col;
2967     int numRows, numCols;
2968
2969     numRows = m_data.GetCount();
2970     if ( numRows > 0 )
2971     {
2972         numCols = m_data[0].GetCount();
2973
2974         for ( row = 0;  row < numRows;  row++ )
2975         {
2976             for ( col = 0;  col < numCols;  col++ )
2977             {
2978                 m_data[row][col] = wxEmptyString;
2979             }
2980         }
2981     }
2982 }
2983
2984
2985 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
2986 {
2987     size_t row, col;
2988
2989     size_t curNumRows = m_data.GetCount();
2990     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2991                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2992
2993     if ( pos >= curNumRows )
2994     {
2995         return AppendRows( numRows );
2996     }
2997
2998     wxArrayString sa;
2999     sa.Alloc( curNumCols );
3000     for ( col = 0;  col < curNumCols;  col++ )
3001     {
3002         sa.Add( wxEmptyString );
3003     }
3004
3005     for ( row = pos;  row < pos + numRows;  row++ )
3006     {
3007         m_data.Insert( sa, row );
3008     }
3009     if ( GetView() )
3010     {
3011         wxGridTableMessage msg( this,
3012                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
3013                                 pos,
3014                                 numRows );
3015
3016         GetView()->ProcessTableMessage( msg );
3017     }
3018
3019     return TRUE;
3020 }
3021
3022 bool wxGridStringTable::AppendRows( size_t numRows )
3023 {
3024     size_t row, col;
3025
3026     size_t curNumRows = m_data.GetCount();
3027     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3028                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3029
3030     wxArrayString sa;
3031     if ( curNumCols > 0 )
3032     {
3033         sa.Alloc( curNumCols );
3034         for ( col = 0;  col < curNumCols;  col++ )
3035         {
3036             sa.Add( wxEmptyString );
3037         }
3038     }
3039
3040     for ( row = 0;  row < numRows;  row++ )
3041     {
3042         m_data.Add( sa );
3043     }
3044
3045     if ( GetView() )
3046     {
3047         wxGridTableMessage msg( this,
3048                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
3049                                 numRows );
3050
3051         GetView()->ProcessTableMessage( msg );
3052     }
3053
3054     return TRUE;
3055 }
3056
3057 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
3058 {
3059     size_t n;
3060
3061     size_t curNumRows = m_data.GetCount();
3062
3063     if ( pos >= curNumRows )
3064     {
3065         wxString errmsg;
3066         errmsg.Printf(wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
3067                       pos, numRows, curNumRows );
3068         wxFAIL_MSG( errmsg );
3069         return FALSE;
3070     }
3071
3072     if ( numRows > curNumRows - pos )
3073     {
3074         numRows = curNumRows - pos;
3075     }
3076
3077     if ( numRows >= curNumRows )
3078     {
3079         m_data.Empty();  // don't release memory just yet
3080     }
3081     else
3082     {
3083         for ( n = 0;  n < numRows;  n++ )
3084         {
3085             m_data.RemoveAt( pos );
3086         }
3087     }
3088     if ( GetView() )
3089     {
3090         wxGridTableMessage msg( this,
3091                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
3092                                 pos,
3093                                 numRows );
3094
3095         GetView()->ProcessTableMessage( msg );
3096     }
3097
3098     return TRUE;
3099 }
3100
3101 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
3102 {
3103     size_t row, col;
3104
3105     size_t curNumRows = m_data.GetCount();
3106     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3107                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3108
3109     if ( pos >= curNumCols )
3110     {
3111         return AppendCols( numCols );
3112     }
3113
3114     for ( row = 0;  row < curNumRows;  row++ )
3115     {
3116         for ( col = pos;  col < pos + numCols;  col++ )
3117         {
3118             m_data[row].Insert( wxEmptyString, col );
3119         }
3120     }
3121     if ( GetView() )
3122     {
3123         wxGridTableMessage msg( this,
3124                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
3125                                 pos,
3126                                 numCols );
3127
3128         GetView()->ProcessTableMessage( msg );
3129     }
3130
3131     return TRUE;
3132 }
3133
3134 bool wxGridStringTable::AppendCols( size_t numCols )
3135 {
3136     size_t row, n;
3137
3138     size_t curNumRows = m_data.GetCount();
3139 #if 0
3140     if ( !curNumRows )
3141     {
3142         // TODO: something better than this ?
3143         //
3144         wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3145         return FALSE;
3146     }
3147 #endif
3148
3149     for ( row = 0;  row < curNumRows;  row++ )
3150     {
3151         for ( n = 0;  n < numCols;  n++ )
3152         {
3153             m_data[row].Add( wxEmptyString );
3154         }
3155     }
3156
3157     if ( GetView() )
3158     {
3159         wxGridTableMessage msg( this,
3160                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
3161                                 numCols );
3162
3163         GetView()->ProcessTableMessage( msg );
3164     }
3165
3166     return TRUE;
3167 }
3168
3169 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
3170 {
3171     size_t row, n;
3172
3173     size_t curNumRows = m_data.GetCount();
3174     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3175                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3176
3177     if ( pos >= curNumCols )
3178     {
3179         wxString errmsg;
3180         errmsg.Printf( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
3181                         pos, numCols, curNumCols );
3182         wxFAIL_MSG( errmsg );
3183         return FALSE;
3184     }
3185
3186     if ( numCols > curNumCols - pos )
3187     {
3188         numCols = curNumCols - pos;
3189     }
3190
3191     for ( row = 0;  row < curNumRows;  row++ )
3192     {
3193         if ( numCols >= curNumCols )
3194         {
3195             m_data[row].Clear();
3196         }
3197         else
3198         {
3199             for ( n = 0;  n < numCols;  n++ )
3200             {
3201                 m_data[row].RemoveAt( pos );
3202             }
3203         }
3204     }
3205     if ( GetView() )
3206     {
3207         wxGridTableMessage msg( this,
3208                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
3209                                 pos,
3210                                 numCols );
3211
3212         GetView()->ProcessTableMessage( msg );
3213     }
3214
3215     return TRUE;
3216 }
3217
3218 wxString wxGridStringTable::GetRowLabelValue( int row )
3219 {
3220     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3221     {
3222         // using default label
3223         //
3224         return wxGridTableBase::GetRowLabelValue( row );
3225     }
3226     else
3227     {
3228         return m_rowLabels[ row ];
3229     }
3230 }
3231
3232 wxString wxGridStringTable::GetColLabelValue( int col )
3233 {
3234     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3235     {
3236         // using default label
3237         //
3238         return wxGridTableBase::GetColLabelValue( col );
3239     }
3240     else
3241     {
3242         return m_colLabels[ col ];
3243     }
3244 }
3245
3246 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3247 {
3248     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3249     {
3250         int n = m_rowLabels.GetCount();
3251         int i;
3252         for ( i = n;  i <= row;  i++ )
3253         {
3254             m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3255         }
3256     }
3257
3258     m_rowLabels[row] = value;
3259 }
3260
3261 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3262 {
3263     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3264     {
3265         int n = m_colLabels.GetCount();
3266         int i;
3267         for ( i = n;  i <= col;  i++ )
3268         {
3269             m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3270         }
3271     }
3272
3273     m_colLabels[col] = value;
3274 }
3275
3276
3277
3278 //////////////////////////////////////////////////////////////////////
3279 //////////////////////////////////////////////////////////////////////
3280
3281 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3282
3283 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
3284     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3285     EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)
3286     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3287     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3288     EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3289 END_EVENT_TABLE()
3290
3291 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3292                                             wxWindowID id,
3293                                             const wxPoint &pos, const wxSize &size )
3294   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3295 {
3296     m_owner = parent;
3297 }
3298
3299 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3300 {
3301     wxPaintDC dc(this);
3302
3303     // NO - don't do this because it will set both the x and y origin
3304     // coords to match the parent scrolled window and we just want to
3305     // set the y coord  - MB
3306     //
3307     // m_owner->PrepareDC( dc );
3308
3309     int x, y;
3310     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3311     dc.SetDeviceOrigin( 0, -y );
3312
3313     wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3314     m_owner->DrawRowLabels( dc , rows );
3315 }
3316
3317
3318 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3319 {
3320     m_owner->ProcessRowLabelMouseEvent( event );
3321 }
3322
3323
3324 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
3325 {
3326     m_owner->GetEventHandler()->ProcessEvent(event);
3327 }
3328
3329
3330 // This seems to be required for wxMotif otherwise the mouse
3331 // cursor must be in the cell edit control to get key events
3332 //
3333 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3334 {
3335     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3336 }
3337
3338 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3339 {
3340     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3341 }
3342
3343
3344
3345 //////////////////////////////////////////////////////////////////////
3346
3347 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3348
3349 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
3350     EVT_PAINT( wxGridColLabelWindow::OnPaint )
3351     EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)
3352     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3353     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3354     EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3355 END_EVENT_TABLE()
3356
3357 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3358                                             wxWindowID id,
3359                                             const wxPoint &pos, const wxSize &size )
3360   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3361 {
3362     m_owner = parent;
3363 }
3364
3365 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3366 {
3367     wxPaintDC dc(this);
3368
3369     // NO - don't do this because it will set both the x and y origin
3370     // coords to match the parent scrolled window and we just want to
3371     // set the x coord  - MB
3372     //
3373     // m_owner->PrepareDC( dc );
3374
3375     int x, y;
3376     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3377     dc.SetDeviceOrigin( -x, 0 );
3378
3379     wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3380     m_owner->DrawColLabels( dc , cols );
3381 }
3382
3383
3384 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3385 {
3386     m_owner->ProcessColLabelMouseEvent( event );
3387 }
3388
3389 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
3390 {
3391     m_owner->GetEventHandler()->ProcessEvent(event);
3392 }
3393
3394
3395 // This seems to be required for wxMotif otherwise the mouse
3396 // cursor must be in the cell edit control to get key events
3397 //
3398 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3399 {
3400     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3401 }
3402
3403 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3404 {
3405     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3406 }
3407
3408
3409
3410 //////////////////////////////////////////////////////////////////////
3411
3412 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3413
3414 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
3415     EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)
3416     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3417     EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
3418     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3419     EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3420 END_EVENT_TABLE()
3421
3422 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3423                                                   wxWindowID id,
3424                                                   const wxPoint &pos, const wxSize &size )
3425   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3426 {
3427     m_owner = parent;
3428 }
3429
3430 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3431 {
3432     wxPaintDC dc(this);
3433
3434     int client_height = 0;
3435     int client_width = 0;
3436     GetClientSize( &client_width, &client_height );
3437
3438     dc.SetPen( *wxBLACK_PEN );
3439     dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
3440     dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
3441
3442     dc.SetPen( *wxWHITE_PEN );
3443     dc.DrawLine( 0, 0, client_width, 0 );
3444     dc.DrawLine( 0, 0, 0, client_height );
3445 }
3446
3447
3448 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3449 {
3450     m_owner->ProcessCornerLabelMouseEvent( event );
3451 }
3452
3453
3454 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
3455 {
3456     m_owner->GetEventHandler()->ProcessEvent(event);
3457 }
3458
3459 // This seems to be required for wxMotif otherwise the mouse
3460 // cursor must be in the cell edit control to get key events
3461 //
3462 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3463 {
3464     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3465 }
3466
3467 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
3468 {
3469     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3470 }
3471
3472
3473
3474 //////////////////////////////////////////////////////////////////////
3475
3476 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
3477
3478 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
3479     EVT_PAINT( wxGridWindow::OnPaint )
3480     EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)
3481     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
3482     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
3483     EVT_KEY_UP( wxGridWindow::OnKeyUp )
3484     EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
3485 END_EVENT_TABLE()
3486
3487 wxGridWindow::wxGridWindow( wxGrid *parent,
3488                             wxGridRowLabelWindow *rowLblWin,
3489                             wxGridColLabelWindow *colLblWin,
3490                             wxWindowID id, const wxPoint &pos, const wxSize &size )
3491         : wxPanel( parent, id, pos, size, wxWANTS_CHARS, "grid window" )
3492 {
3493     m_owner = parent;
3494     m_rowLabelWin = rowLblWin;
3495     m_colLabelWin = colLblWin;
3496     SetBackgroundColour(_T("WHITE"));
3497 }
3498
3499
3500 wxGridWindow::~wxGridWindow()
3501 {
3502 }
3503
3504
3505 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3506 {
3507     wxPaintDC dc( this );
3508     m_owner->PrepareDC( dc );
3509     wxRegion reg = GetUpdateRegion();
3510     wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
3511     m_owner->DrawGridCellArea( dc , DirtyCells);
3512 #if WXGRID_DRAW_LINES
3513     m_owner->DrawAllGridLines( dc, reg );
3514 #endif
3515     m_owner->DrawGridSpace( dc );
3516     m_owner->DrawHighlight( dc , DirtyCells );
3517 }
3518
3519
3520 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3521 {
3522     wxPanel::ScrollWindow( dx, dy, rect );
3523     m_rowLabelWin->ScrollWindow( 0, dy, rect );
3524     m_colLabelWin->ScrollWindow( dx, 0, rect );
3525 }
3526
3527
3528 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3529 {
3530     m_owner->ProcessGridCellMouseEvent( event );
3531 }
3532
3533 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
3534 {
3535     m_owner->GetEventHandler()->ProcessEvent(event);
3536 }
3537
3538 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3539 // cursor must be in the cell edit control to get key events
3540 //
3541 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3542 {
3543     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3544 }
3545
3546 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
3547 {
3548     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
3549 }
3550
3551 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
3552 {
3553 }
3554
3555
3556 //////////////////////////////////////////////////////////////////////
3557
3558
3559 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3560
3561 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
3562     EVT_PAINT( wxGrid::OnPaint )
3563     EVT_SIZE( wxGrid::OnSize )
3564     EVT_KEY_DOWN( wxGrid::OnKeyDown )
3565     EVT_KEY_UP( wxGrid::OnKeyUp )
3566     EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
3567 END_EVENT_TABLE()
3568
3569 wxGrid::wxGrid( wxWindow *parent,
3570                  wxWindowID id,
3571                  const wxPoint& pos,
3572                  const wxSize& size,
3573                  long style,
3574                  const wxString& name )
3575   : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
3576     m_colMinWidths(GRID_HASH_SIZE),
3577     m_rowMinHeights(GRID_HASH_SIZE)
3578 {
3579     Create();
3580 }
3581
3582
3583 wxGrid::~wxGrid()
3584 {
3585     // Must do this or ~wxScrollHelper will pop the wrong event handler
3586     SetTargetWindow(this);
3587     ClearAttrCache();
3588     wxSafeDecRef(m_defaultCellAttr);
3589
3590 #ifdef DEBUG_ATTR_CACHE
3591     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
3592     wxPrintf(_T("wxGrid attribute cache statistics: "
3593                 "total: %u, hits: %u (%u%%)\n"),
3594              total, gs_nAttrCacheHits,
3595              total ? (gs_nAttrCacheHits*100) / total : 0);
3596 #endif
3597
3598     if (m_ownTable)
3599         delete m_table;
3600
3601     delete m_typeRegistry;
3602     delete m_selection;
3603 }
3604
3605
3606 //
3607 // ----- internal init and update functions
3608 //
3609
3610 void wxGrid::Create()
3611 {
3612     m_created = FALSE;    // set to TRUE by CreateGrid
3613
3614     m_table        = (wxGridTableBase *) NULL;
3615     m_ownTable     = FALSE;
3616
3617     m_cellEditCtrlEnabled = FALSE;
3618
3619     m_defaultCellAttr = new wxGridCellAttr;
3620     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
3621
3622     // Set default cell attributes
3623     m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
3624     m_defaultCellAttr->SetFont(GetFont());
3625     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
3626     m_defaultCellAttr->SetTextColour(
3627         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
3628     m_defaultCellAttr->SetBackgroundColour(
3629         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
3630     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3631     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
3632
3633
3634     m_numRows = 0;
3635     m_numCols = 0;
3636     m_currentCellCoords = wxGridNoCellCoords;
3637
3638     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3639     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3640
3641     // create the type registry
3642     m_typeRegistry = new wxGridTypeRegistry;
3643     m_selection = 0;
3644     // subwindow components that make up the wxGrid
3645     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3646                                                     -1,
3647                                                     wxDefaultPosition,
3648                                                     wxDefaultSize );
3649
3650     m_rowLabelWin = new wxGridRowLabelWindow( this,
3651                                               -1,
3652                                               wxDefaultPosition,
3653                                               wxDefaultSize );
3654
3655     m_colLabelWin = new wxGridColLabelWindow( this,
3656                                               -1,
3657                                               wxDefaultPosition,
3658                                               wxDefaultSize );
3659
3660     m_gridWin = new wxGridWindow( this,
3661                                   m_rowLabelWin,
3662                                   m_colLabelWin,
3663                                   -1,
3664                                   wxDefaultPosition,
3665                                   wxDefaultSize );
3666
3667     SetTargetWindow( m_gridWin );
3668
3669     Init();
3670 }
3671
3672
3673 bool wxGrid::CreateGrid( int numRows, int numCols,
3674                          wxGrid::wxGridSelectionModes selmode )
3675 {
3676     wxCHECK_MSG( !m_created,
3677                  FALSE,
3678                  wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3679
3680     m_numRows = numRows;
3681     m_numCols = numCols;
3682
3683     m_table = new wxGridStringTable( m_numRows, m_numCols );
3684     m_table->SetView( this );
3685     m_ownTable = TRUE;
3686     m_selection = new wxGridSelection( this, selmode );
3687
3688     CalcDimensions();
3689
3690     m_created = TRUE;
3691
3692     return m_created;
3693 }
3694
3695 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3696 {
3697     wxCHECK_RET( m_created,
3698                  wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3699
3700     m_selection->SetSelectionMode( selmode );
3701 }
3702
3703 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3704                        wxGrid::wxGridSelectionModes selmode )
3705 {
3706     if ( m_created )
3707     {
3708         // RD: Actually, this should probably be allowed.  I think it would be
3709         // nice to be able to switch multiple Tables in and out of a single
3710         // View at runtime.  Is there anything in the implmentation that would
3711         // prevent this?
3712
3713         // At least, you now have to cope with m_selection
3714         wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3715         return FALSE;
3716     }
3717     else
3718     {
3719         m_numRows = table->GetNumberRows();
3720         m_numCols = table->GetNumberCols();
3721
3722         m_table = table;
3723         m_table->SetView( this );
3724         if (takeOwnership)
3725             m_ownTable = TRUE;
3726         m_selection = new wxGridSelection( this, selmode );
3727
3728         CalcDimensions();
3729
3730         m_created = TRUE;
3731     }
3732
3733     return m_created;
3734 }
3735
3736
3737 void wxGrid::Init()
3738 {
3739     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3740     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3741
3742     if ( m_rowLabelWin )
3743     {
3744         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
3745     }
3746     else
3747     {
3748         m_labelBackgroundColour = wxColour( _T("WHITE") );
3749     }
3750
3751     m_labelTextColour = wxColour( _T("BLACK") );
3752
3753     // init attr cache
3754     m_attrCache.row = -1;
3755
3756     // TODO: something better than this ?
3757     //
3758     m_labelFont = this->GetFont();
3759     m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
3760
3761     m_rowLabelHorizAlign = wxALIGN_LEFT;
3762     m_rowLabelVertAlign  = wxALIGN_CENTRE;
3763
3764     m_colLabelHorizAlign = wxALIGN_CENTRE;
3765     m_colLabelVertAlign  = wxALIGN_TOP;
3766
3767     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
3768     m_defaultRowHeight = m_gridWin->GetCharHeight();
3769
3770 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
3771     m_defaultRowHeight += 8;
3772 #else
3773     m_defaultRowHeight += 4;
3774 #endif
3775
3776     m_gridLineColour = wxColour( 128, 128, 255 );
3777     m_gridLinesEnabled = TRUE;
3778     m_cellHighlightColour = m_gridLineColour;
3779     m_cellHighlightPenWidth = 2;
3780     m_cellHighlightROPenWidth = 1;
3781
3782     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
3783     m_winCapture = (wxWindow *)NULL;
3784     m_canDragRowSize = TRUE;
3785     m_canDragColSize = TRUE;
3786     m_canDragGridSize = TRUE;
3787     m_dragLastPos  = -1;
3788     m_dragRowOrCol = -1;
3789     m_isDragging = FALSE;
3790     m_startDragPos = wxDefaultPosition;
3791
3792     m_waitForSlowClick = FALSE;
3793
3794     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
3795     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
3796
3797     m_currentCellCoords = wxGridNoCellCoords;
3798
3799     m_selectingTopLeft = wxGridNoCellCoords;
3800     m_selectingBottomRight = wxGridNoCellCoords;
3801     m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
3802     m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
3803
3804     m_editable = TRUE;  // default for whole grid
3805
3806     m_inOnKeyDown = FALSE;
3807     m_batchCount = 0;
3808
3809     m_extraWidth =
3810     m_extraHeight = 50;
3811 }
3812
3813 // ----------------------------------------------------------------------------
3814 // the idea is to call these functions only when necessary because they create
3815 // quite big arrays which eat memory mostly unnecessary - in particular, if
3816 // default widths/heights are used for all rows/columns, we may not use these
3817 // arrays at all
3818 //
3819 // with some extra code, it should be possible to only store the
3820 // widths/heights different from default ones but this will be done later...
3821 // ----------------------------------------------------------------------------
3822
3823 void wxGrid::InitRowHeights()
3824 {
3825     m_rowHeights.Empty();
3826     m_rowBottoms.Empty();
3827
3828     m_rowHeights.Alloc( m_numRows );
3829     m_rowBottoms.Alloc( m_numRows );
3830
3831     int rowBottom = 0;
3832     for ( int i = 0;  i < m_numRows;  i++ )
3833     {
3834         m_rowHeights.Add( m_defaultRowHeight );
3835         rowBottom += m_defaultRowHeight;
3836         m_rowBottoms.Add( rowBottom );
3837     }
3838 }
3839
3840 void wxGrid::InitColWidths()
3841 {
3842     m_colWidths.Empty();
3843     m_colRights.Empty();
3844
3845     m_colWidths.Alloc( m_numCols );
3846     m_colRights.Alloc( m_numCols );
3847     int colRight = 0;
3848     for ( int i = 0;  i < m_numCols;  i++ )
3849     {
3850         m_colWidths.Add( m_defaultColWidth );
3851         colRight += m_defaultColWidth;
3852         m_colRights.Add( colRight );
3853     }
3854 }
3855
3856 int wxGrid::GetColWidth(int col) const
3857 {
3858     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
3859 }
3860
3861 int wxGrid::GetColLeft(int col) const
3862 {
3863     return m_colRights.IsEmpty() ? col * m_defaultColWidth
3864                                  : m_colRights[col] - m_colWidths[col];
3865 }
3866
3867 int wxGrid::GetColRight(int col) const
3868 {
3869     return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
3870                                  : m_colRights[col];
3871 }
3872
3873 int wxGrid::GetRowHeight(int row) const
3874 {
3875     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
3876 }
3877
3878 int wxGrid::GetRowTop(int row) const
3879 {
3880     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
3881                                   : m_rowBottoms[row] - m_rowHeights[row];
3882 }
3883
3884 int wxGrid::GetRowBottom(int row) const
3885 {
3886     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
3887                                   : m_rowBottoms[row];
3888 }
3889
3890 void wxGrid::CalcDimensions()
3891 {
3892     int cw, ch;
3893     GetClientSize( &cw, &ch );
3894
3895     if ( m_colLabelWin->IsShown() )
3896         cw -= m_rowLabelWidth;
3897     if ( m_rowLabelWin->IsShown() )
3898         ch -= m_colLabelHeight;
3899
3900     // grid total size
3901     int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
3902     int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
3903
3904     // preserve (more or less) the previous position
3905     int x, y;
3906     GetViewStart( &x, &y );
3907
3908     // maybe we don't need scrollbars at all?
3909     //
3910     // also adjust the position to be valid for the new scroll rangs
3911     if ( w <= cw )
3912     {
3913         w = x = 0;
3914     }
3915     else
3916     {
3917         if ( x >= w )
3918             x = w - 1;
3919     }
3920
3921     if ( h <= ch )
3922     {
3923         h = y = 0;
3924     }
3925     else
3926     {
3927         if ( y >= h )
3928             y = h - 1;
3929     }
3930
3931     // do set scrollbar parameters
3932     SetScrollbars( GRID_SCROLL_LINE_X, GRID_SCROLL_LINE_Y,
3933                    GetScrollX(w), GetScrollY(h), x, y,
3934                    GetBatchCount() != 0);
3935 }
3936
3937
3938 void wxGrid::CalcWindowSizes()
3939 {
3940     int cw, ch;
3941     GetClientSize( &cw, &ch );
3942
3943     if ( m_cornerLabelWin->IsShown() )
3944         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
3945
3946     if ( m_colLabelWin->IsShown() )
3947         m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
3948
3949     if ( m_rowLabelWin->IsShown() )
3950         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
3951
3952     if ( m_gridWin->IsShown() )
3953         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
3954 }
3955
3956
3957 // this is called when the grid table sends a message to say that it
3958 // has been redimensioned
3959 //
3960 bool wxGrid::Redimension( wxGridTableMessage& msg )
3961 {
3962     int i;
3963     bool result = FALSE;
3964
3965 #if 0
3966     // if we were using the default widths/heights so far, we must change them
3967     // now
3968     if ( m_colWidths.IsEmpty() )
3969     {
3970         InitColWidths();
3971     }
3972
3973     if ( m_rowHeights.IsEmpty() )
3974     {
3975         InitRowHeights();
3976     }
3977 #endif
3978
3979     switch ( msg.GetId() )
3980     {
3981         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
3982         {
3983             size_t pos = msg.GetCommandInt();
3984             int numRows = msg.GetCommandInt2();
3985
3986             m_numRows += numRows;
3987
3988             if ( !m_rowHeights.IsEmpty() )
3989             {
3990                 for ( i = 0;  i < numRows;  i++ )
3991                 {
3992                     m_rowHeights.Insert( m_defaultRowHeight, pos );
3993                     m_rowBottoms.Insert( 0, pos );
3994                 }
3995
3996                 int bottom = 0;
3997                 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
3998
3999                 for ( i = pos;  i < m_numRows;  i++ )
4000                 {
4001                     bottom += m_rowHeights[i];
4002                     m_rowBottoms[i] = bottom;
4003                 }
4004             }
4005             if ( m_currentCellCoords == wxGridNoCellCoords )
4006             {
4007                 // if we have just inserted cols into an empty grid the current
4008                 // cell will be undefined...
4009                 //
4010                 SetCurrentCell( 0, 0 );
4011             }
4012             m_selection->UpdateRows( pos, numRows );
4013             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4014             if (attrProvider)
4015                 attrProvider->UpdateAttrRows( pos, numRows );
4016
4017             if ( !GetBatchCount() )
4018             {
4019                 CalcDimensions();
4020                 m_rowLabelWin->Refresh();
4021             }
4022         }
4023         result = TRUE;
4024         break;
4025
4026         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4027         {
4028             int numRows = msg.GetCommandInt();
4029             int oldNumRows = m_numRows;
4030             m_numRows += numRows;
4031
4032             if ( !m_rowHeights.IsEmpty() )
4033             {
4034                 for ( i = 0;  i < numRows;  i++ )
4035                 {
4036                     m_rowHeights.Add( m_defaultRowHeight );
4037                     m_rowBottoms.Add( 0 );
4038                 }
4039
4040                 int bottom = 0;
4041                 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
4042
4043                 for ( i = oldNumRows;  i < m_numRows;  i++ )
4044                 {
4045                     bottom += m_rowHeights[i];
4046                     m_rowBottoms[i] = bottom;
4047                 }
4048             }
4049             if ( m_currentCellCoords == wxGridNoCellCoords )
4050             {
4051                 // if we have just inserted cols into an empty grid the current
4052                 // cell will be undefined...
4053                 //
4054                 SetCurrentCell( 0, 0 );
4055             }
4056             if ( !GetBatchCount() )
4057             {
4058                 CalcDimensions();
4059                 m_rowLabelWin->Refresh();
4060             }
4061         }
4062         result = TRUE;
4063         break;
4064
4065         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4066         {
4067             size_t pos = msg.GetCommandInt();
4068             int numRows = msg.GetCommandInt2();
4069             m_numRows -= numRows;
4070
4071             if ( !m_rowHeights.IsEmpty() )
4072             {
4073                 for ( i = 0;  i < numRows;  i++ )
4074                 {
4075                     m_rowHeights.RemoveAt( pos );
4076                     m_rowBottoms.RemoveAt( pos );
4077                 }
4078
4079                 int h = 0;
4080                 for ( i = 0;  i < m_numRows;  i++ )
4081                 {
4082                     h += m_rowHeights[i];
4083                     m_rowBottoms[i] = h;
4084                 }
4085             }
4086             if ( !m_numRows )
4087             {
4088                 m_currentCellCoords = wxGridNoCellCoords;
4089             }
4090             else
4091             {
4092                 if ( m_currentCellCoords.GetRow() >= m_numRows )
4093                     m_currentCellCoords.Set( 0, 0 );
4094             }
4095             m_selection->UpdateRows( pos, -((int)numRows) );
4096             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4097             if (attrProvider) {
4098                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4099 // ifdef'd out following patch from Paul Gammans
4100 #if 0
4101                 // No need to touch column attributes, unless we
4102                 // removed _all_ rows, in this case, we remove
4103                 // all column attributes.
4104                 // I hate to do this here, but the
4105                 // needed data is not available inside UpdateAttrRows.
4106                 if ( !GetNumberRows() )
4107                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4108 #endif
4109             }
4110             if ( !GetBatchCount() )
4111             {
4112                 CalcDimensions();
4113                 m_rowLabelWin->Refresh();
4114             }
4115         }
4116         result = TRUE;
4117         break;
4118
4119         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4120         {
4121             size_t pos = msg.GetCommandInt();
4122             int numCols = msg.GetCommandInt2();
4123             m_numCols += numCols;
4124
4125             if ( !m_colWidths.IsEmpty() )
4126             {
4127                 for ( i = 0;  i < numCols;  i++ )
4128                 {
4129                     m_colWidths.Insert( m_defaultColWidth, pos );
4130                     m_colRights.Insert( 0, pos );
4131                 }
4132
4133                 int right = 0;
4134                 if ( pos > 0 ) right = m_colRights[pos-1];
4135
4136                 for ( i = pos;  i < m_numCols;  i++ )
4137                 {
4138                     right += m_colWidths[i];
4139                     m_colRights[i] = right;
4140                 }
4141             }
4142             if ( m_currentCellCoords == wxGridNoCellCoords )
4143             {
4144                 // if we have just inserted cols into an empty grid the current
4145                 // cell will be undefined...
4146                 //
4147                 SetCurrentCell( 0, 0 );
4148             }
4149             m_selection->UpdateCols( pos, numCols );
4150             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4151             if (attrProvider)
4152                 attrProvider->UpdateAttrCols( pos, numCols );
4153             if ( !GetBatchCount() )
4154             {
4155                 CalcDimensions();
4156                 m_colLabelWin->Refresh();
4157             }
4158
4159         }
4160         result = TRUE;
4161         break;
4162
4163         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4164         {
4165             int numCols = msg.GetCommandInt();
4166             int oldNumCols = m_numCols;
4167             m_numCols += numCols;
4168             if ( !m_colWidths.IsEmpty() )
4169             {
4170                 for ( i = 0;  i < numCols;  i++ )
4171                 {
4172                     m_colWidths.Add( m_defaultColWidth );
4173                     m_colRights.Add( 0 );
4174                 }
4175
4176                 int right = 0;
4177                 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
4178
4179                 for ( i = oldNumCols;  i < m_numCols;  i++ )
4180                 {
4181                     right += m_colWidths[i];
4182                     m_colRights[i] = right;
4183                 }
4184             }
4185             if ( m_currentCellCoords == wxGridNoCellCoords )
4186             {
4187                 // if we have just inserted cols into an empty grid the current
4188                 // cell will be undefined...
4189                 //
4190                 SetCurrentCell( 0, 0 );
4191             }
4192             if ( !GetBatchCount() )
4193             {
4194                 CalcDimensions();
4195                 m_colLabelWin->Refresh();
4196             }
4197         }
4198         result = TRUE;
4199         break;
4200
4201         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4202         {
4203             size_t pos = msg.GetCommandInt();
4204             int numCols = msg.GetCommandInt2();
4205             m_numCols -= numCols;
4206
4207             if ( !m_colWidths.IsEmpty() )
4208             {
4209                 for ( i = 0;  i < numCols;  i++ )
4210                 {
4211                     m_colWidths.RemoveAt( pos );
4212                     m_colRights.RemoveAt( pos );
4213                 }
4214
4215                 int w = 0;
4216                 for ( i = 0;  i < m_numCols;  i++ )
4217                 {
4218                     w += m_colWidths[i];
4219                     m_colRights[i] = w;
4220                 }
4221             }
4222             if ( !m_numCols )
4223             {
4224                 m_currentCellCoords = wxGridNoCellCoords;
4225             }
4226             else
4227             {
4228                 if ( m_currentCellCoords.GetCol() >= m_numCols )
4229                   m_currentCellCoords.Set( 0, 0 );
4230             }
4231             m_selection->UpdateCols( pos, -((int)numCols) );
4232             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4233             if (attrProvider) {
4234                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
4235 // ifdef'd out following patch from Paul Gammans
4236 #if 0
4237                 // No need to touch row attributes, unless we
4238                 // removed _all_ columns, in this case, we remove
4239                 // all row attributes.
4240                 // I hate to do this here, but the
4241                 // needed data is not available inside UpdateAttrCols.
4242                 if ( !GetNumberCols() )
4243                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
4244 #endif
4245             }
4246             if ( !GetBatchCount() )
4247             {
4248                 CalcDimensions();
4249                 m_colLabelWin->Refresh();
4250             }
4251         }
4252         result = TRUE;
4253         break;
4254     }
4255
4256     if (result && !GetBatchCount() )
4257         m_gridWin->Refresh();
4258     return result;
4259 }
4260
4261
4262 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
4263 {
4264     wxRegionIterator iter( reg );
4265     wxRect r;
4266
4267     wxArrayInt  rowlabels;
4268
4269     int top, bottom;
4270     while ( iter )
4271     {
4272         r = iter.GetRect();
4273
4274         // TODO: remove this when we can...
4275         // There is a bug in wxMotif that gives garbage update
4276         // rectangles if you jump-scroll a long way by clicking the
4277         // scrollbar with middle button.  This is a work-around
4278         //
4279 #if defined(__WXMOTIF__)
4280         int cw, ch;
4281         m_gridWin->GetClientSize( &cw, &ch );
4282         if ( r.GetTop() > ch ) r.SetTop( 0 );
4283         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4284 #endif
4285
4286         // logical bounds of update region
4287         //
4288         int dummy;
4289         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4290         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4291
4292         // find the row labels within these bounds
4293         //
4294         int row;
4295         for ( row = 0;  row < m_numRows;  row++ )
4296         {
4297             if ( GetRowBottom(row) < top )
4298                 continue;
4299
4300             if ( GetRowTop(row) > bottom )
4301                 break;
4302
4303             rowlabels.Add( row );
4304         }
4305
4306         iter++ ;
4307     }
4308
4309     return rowlabels;
4310 }
4311
4312
4313 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4314 {
4315     wxRegionIterator iter( reg );
4316     wxRect r;
4317
4318     wxArrayInt colLabels;
4319
4320     int left, right;
4321     while ( iter )
4322     {
4323         r = iter.GetRect();
4324
4325         // TODO: remove this when we can...
4326         // There is a bug in wxMotif that gives garbage update
4327         // rectangles if you jump-scroll a long way by clicking the
4328         // scrollbar with middle button.  This is a work-around
4329         //
4330 #if defined(__WXMOTIF__)
4331         int cw, ch;
4332         m_gridWin->GetClientSize( &cw, &ch );
4333         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4334         r.SetRight( wxMin( r.GetRight(), cw ) );
4335 #endif
4336
4337         // logical bounds of update region
4338         //
4339         int dummy;
4340         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4341         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4342
4343         // find the cells within these bounds
4344         //
4345         int col;
4346         for ( col = 0;  col < m_numCols;  col++ )
4347         {
4348             if ( GetColRight(col) < left )
4349                 continue;
4350
4351             if ( GetColLeft(col) > right )
4352                 break;
4353
4354             colLabels.Add( col );
4355         }
4356
4357         iter++ ;
4358     }
4359     return colLabels;
4360 }
4361
4362
4363 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
4364 {
4365     wxRegionIterator iter( reg );
4366     wxRect r;
4367
4368     wxGridCellCoordsArray  cellsExposed;
4369
4370     int left, top, right, bottom;
4371     while ( iter )
4372     {
4373         r = iter.GetRect();
4374
4375         // TODO: remove this when we can...
4376         // There is a bug in wxMotif that gives garbage update
4377         // rectangles if you jump-scroll a long way by clicking the
4378         // scrollbar with middle button.  This is a work-around
4379         //
4380 #if defined(__WXMOTIF__)
4381         int cw, ch;
4382         m_gridWin->GetClientSize( &cw, &ch );
4383         if ( r.GetTop() > ch ) r.SetTop( 0 );
4384         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4385         r.SetRight( wxMin( r.GetRight(), cw ) );
4386         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4387 #endif
4388
4389         // logical bounds of update region
4390         //
4391         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4392         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4393
4394         // find the cells within these bounds
4395         //
4396         int row, col;
4397         for ( row = 0;  row < m_numRows;  row++ )
4398         {
4399             if ( GetRowBottom(row) <= top )
4400                 continue;
4401
4402             if ( GetRowTop(row) > bottom )
4403                 break;
4404
4405
4406             for ( col = 0;  col < m_numCols;  col++ )
4407             {
4408                 if ( GetColRight(col) <= left )
4409                     continue;
4410
4411                 if ( GetColLeft(col) > right )
4412                     break;
4413
4414                 cellsExposed.Add( wxGridCellCoords( row, col ) );
4415             }
4416         }
4417
4418         iter++;
4419     }
4420
4421     return cellsExposed;
4422 }
4423
4424
4425 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4426 {
4427     int x, y, row;
4428     wxPoint pos( event.GetPosition() );
4429     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4430
4431     if ( event.Dragging() )
4432     {
4433         m_isDragging = TRUE;
4434
4435         if ( event.LeftIsDown() )
4436         {
4437             switch( m_cursorMode )
4438             {
4439                 case WXGRID_CURSOR_RESIZE_ROW:
4440                 {
4441                     int cw, ch, left, dummy;
4442                     m_gridWin->GetClientSize( &cw, &ch );
4443                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
4444
4445                     wxClientDC dc( m_gridWin );
4446                     PrepareDC( dc );
4447                     y = wxMax( y,
4448                                GetRowTop(m_dragRowOrCol) +
4449                                GetRowMinimalHeight(m_dragRowOrCol) );
4450                     dc.SetLogicalFunction(wxINVERT);
4451                     if ( m_dragLastPos >= 0 )
4452                     {
4453                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4454                     }
4455                     dc.DrawLine( left, y, left+cw, y );
4456                     m_dragLastPos = y;
4457                 }
4458                 break;
4459
4460                 case WXGRID_CURSOR_SELECT_ROW:
4461                     if ( (row = YToRow( y )) >= 0 )
4462                     {
4463                         m_selection->SelectRow( row,
4464                                                 event.ControlDown(),
4465                                                 event.ShiftDown(),
4466                                                 event.AltDown(),
4467                                                 event.MetaDown() );
4468                     }
4469
4470                 // default label to suppress warnings about "enumeration value
4471                 // 'xxx' not handled in switch
4472                 default:
4473                     break;
4474             }
4475         }
4476         return;
4477     }
4478
4479     m_isDragging = FALSE;
4480
4481
4482     // ------------ Entering or leaving the window
4483     //
4484     if ( event.Entering() || event.Leaving() )
4485     {
4486         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4487     }
4488
4489
4490     // ------------ Left button pressed
4491     //
4492     else if ( event.LeftDown() )
4493     {
4494         // don't send a label click event for a hit on the
4495         // edge of the row label - this is probably the user
4496         // wanting to resize the row
4497         //
4498         if ( YToEdgeOfRow(y) < 0 )
4499         {
4500             row = YToRow(y);
4501             if ( row >= 0  &&
4502                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4503             {
4504                 if ( !event.ShiftDown() && !event.ControlDown() )
4505                     ClearSelection();
4506                 if ( event.ShiftDown() )
4507                     m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4508                                               0,
4509                                               row,
4510                                               GetNumberCols() - 1,
4511                                               event.ControlDown(),
4512                                               event.ShiftDown(),
4513                                               event.AltDown(),
4514                                               event.MetaDown() );
4515                 else
4516                     m_selection->SelectRow( row,
4517                                             event.ControlDown(),
4518                                             event.ShiftDown(),
4519                                             event.AltDown(),
4520                                             event.MetaDown() );
4521                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4522             }
4523         }
4524         else
4525         {
4526             // starting to drag-resize a row
4527             //
4528             if ( CanDragRowSize() )
4529                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4530         }
4531     }
4532
4533
4534     // ------------ Left double click
4535     //
4536     else if (event.LeftDClick() )
4537     {
4538         if ( YToEdgeOfRow(y) < 0 )
4539         {
4540             row = YToRow(y);
4541             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
4542         }
4543     }
4544
4545
4546     // ------------ Left button released
4547     //
4548     else if ( event.LeftUp() )
4549     {
4550         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4551         {
4552             DoEndDragResizeRow();
4553
4554             // Note: we are ending the event *after* doing
4555             // default processing in this case
4556             //
4557             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4558         }
4559
4560         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4561         m_dragLastPos = -1;
4562     }
4563
4564
4565     // ------------ Right button down
4566     //
4567     else if ( event.RightDown() )
4568     {
4569         row = YToRow(y);
4570         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4571         {
4572             // no default action at the moment
4573         }
4574     }
4575
4576
4577     // ------------ Right double click
4578     //
4579     else if ( event.RightDClick() )
4580     {
4581         row = YToRow(y);
4582         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4583         {
4584             // no default action at the moment
4585         }
4586     }
4587
4588
4589     // ------------ No buttons down and mouse moving
4590     //
4591     else if ( event.Moving() )
4592     {
4593         m_dragRowOrCol = YToEdgeOfRow( y );
4594         if ( m_dragRowOrCol >= 0 )
4595         {
4596             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4597             {
4598                 // don't capture the mouse yet
4599                 if ( CanDragRowSize() )
4600                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4601             }
4602         }
4603         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4604         {
4605             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4606         }
4607     }
4608 }
4609
4610
4611 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4612 {
4613     int x, y, col;
4614     wxPoint pos( event.GetPosition() );
4615     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4616
4617     if ( event.Dragging() )
4618     {
4619         m_isDragging = TRUE;
4620
4621         if ( event.LeftIsDown() )
4622         {
4623             switch( m_cursorMode )
4624             {
4625                 case WXGRID_CURSOR_RESIZE_COL:
4626                 {
4627                     int cw, ch, dummy, top;
4628                     m_gridWin->GetClientSize( &cw, &ch );
4629                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
4630
4631                     wxClientDC dc( m_gridWin );
4632                     PrepareDC( dc );
4633
4634                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4635                                   GetColMinimalWidth(m_dragRowOrCol));
4636                     dc.SetLogicalFunction(wxINVERT);
4637                     if ( m_dragLastPos >= 0 )
4638                     {
4639                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4640                     }
4641                     dc.DrawLine( x, top, x, top+ch );
4642                     m_dragLastPos = x;
4643                 }
4644                 break;
4645
4646                 case WXGRID_CURSOR_SELECT_COL:
4647                     if ( (col = XToCol( x )) >= 0 )
4648                     {
4649                         m_selection->SelectCol( col,
4650                                                 event.ControlDown(),
4651                                                 event.ShiftDown(),
4652                                                 event.AltDown(),
4653                                                 event.MetaDown() );
4654                     }
4655
4656                 // default label to suppress warnings about "enumeration value
4657                 // 'xxx' not handled in switch
4658                 default:
4659                     break;
4660             }
4661         }
4662         return;
4663     }
4664
4665     m_isDragging = FALSE;
4666
4667
4668     // ------------ Entering or leaving the window
4669     //
4670     if ( event.Entering() || event.Leaving() )
4671     {
4672         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4673     }
4674
4675
4676     // ------------ Left button pressed
4677     //
4678     else if ( event.LeftDown() )
4679     {
4680         // don't send a label click event for a hit on the
4681         // edge of the col label - this is probably the user
4682         // wanting to resize the col
4683         //
4684         if ( XToEdgeOfCol(x) < 0 )
4685         {
4686             col = XToCol(x);
4687             if ( col >= 0  &&
4688                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
4689             {
4690                 if ( !event.ShiftDown() && !event.ControlDown() )
4691                     ClearSelection();
4692                 if ( event.ShiftDown() )
4693                     m_selection->SelectBlock( 0,
4694                                               m_currentCellCoords.GetCol(),
4695                                               GetNumberRows() - 1, col,
4696                                               event.ControlDown(),
4697                                               event.ShiftDown(),
4698                                               event.AltDown(),
4699                                               event.MetaDown() );
4700                 else
4701                     m_selection->SelectCol( col,
4702                                             event.ControlDown(),
4703                                             event.ShiftDown(),
4704                                             event.AltDown(),
4705                                             event.MetaDown() );
4706                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
4707             }
4708         }
4709         else
4710         {
4711             // starting to drag-resize a col
4712             //
4713             if ( CanDragColSize() )
4714                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
4715         }
4716     }
4717
4718
4719     // ------------ Left double click
4720     //
4721     if ( event.LeftDClick() )
4722     {
4723         if ( XToEdgeOfCol(x) < 0 )
4724         {
4725             col = XToCol(x);
4726             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
4727         }
4728     }
4729
4730
4731     // ------------ Left button released
4732     //
4733     else if ( event.LeftUp() )
4734     {
4735         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4736         {
4737             DoEndDragResizeCol();
4738
4739             // Note: we are ending the event *after* doing
4740             // default processing in this case
4741             //
4742             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
4743         }
4744
4745         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4746         m_dragLastPos  = -1;
4747     }
4748
4749
4750     // ------------ Right button down
4751     //
4752     else if ( event.RightDown() )
4753     {
4754         col = XToCol(x);
4755         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
4756         {
4757             // no default action at the moment
4758         }
4759     }
4760
4761
4762     // ------------ Right double click
4763     //
4764     else if ( event.RightDClick() )
4765     {
4766         col = XToCol(x);
4767         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
4768         {
4769             // no default action at the moment
4770         }
4771     }
4772
4773
4774     // ------------ No buttons down and mouse moving
4775     //
4776     else if ( event.Moving() )
4777     {
4778         m_dragRowOrCol = XToEdgeOfCol( x );
4779         if ( m_dragRowOrCol >= 0 )
4780         {
4781             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4782             {
4783                 // don't capture the cursor yet
4784                 if ( CanDragColSize() )
4785                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
4786             }
4787         }
4788         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4789         {
4790             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
4791         }
4792     }
4793 }
4794
4795
4796 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
4797 {
4798     if ( event.LeftDown() )
4799     {
4800         // indicate corner label by having both row and
4801         // col args == -1
4802         //
4803         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
4804         {
4805             SelectAll();
4806         }
4807     }
4808
4809     else if ( event.LeftDClick() )
4810     {
4811         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
4812     }
4813
4814     else if ( event.RightDown() )
4815     {
4816         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
4817         {
4818             // no default action at the moment
4819         }
4820     }
4821
4822     else if ( event.RightDClick() )
4823     {
4824         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
4825         {
4826             // no default action at the moment
4827         }
4828     }
4829 }
4830
4831 void wxGrid::ChangeCursorMode(CursorMode mode,
4832                               wxWindow *win,
4833                               bool captureMouse)
4834 {
4835 #ifdef __WXDEBUG__
4836     static const wxChar *cursorModes[] =
4837     {
4838         _T("SELECT_CELL"),
4839         _T("RESIZE_ROW"),
4840         _T("RESIZE_COL"),
4841         _T("SELECT_ROW"),
4842         _T("SELECT_COL")
4843     };
4844
4845     wxLogTrace(_T("grid"),
4846                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
4847                win == m_colLabelWin ? _T("colLabelWin")
4848                                     : win ? _T("rowLabelWin")
4849                                           : _T("gridWin"),
4850                cursorModes[m_cursorMode], cursorModes[mode]);
4851 #endif // __WXDEBUG__
4852
4853     if ( mode == m_cursorMode &&
4854          win == m_winCapture &&
4855          captureMouse == (m_winCapture != NULL))
4856         return;
4857
4858     if ( !win )
4859     {
4860         // by default use the grid itself
4861         win = m_gridWin;
4862     }
4863
4864     if ( m_winCapture )
4865     {
4866         m_winCapture->ReleaseMouse();
4867         m_winCapture = (wxWindow *)NULL;
4868     }
4869
4870     m_cursorMode = mode;
4871
4872     switch ( m_cursorMode )
4873     {
4874         case WXGRID_CURSOR_RESIZE_ROW:
4875             win->SetCursor( m_rowResizeCursor );
4876             break;
4877
4878         case WXGRID_CURSOR_RESIZE_COL:
4879             win->SetCursor( m_colResizeCursor );
4880             break;
4881
4882         default:
4883             win->SetCursor( *wxSTANDARD_CURSOR );
4884     }
4885
4886     // we need to capture mouse when resizing
4887     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
4888                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
4889
4890     if ( captureMouse && resize )
4891     {
4892         win->CaptureMouse();
4893         m_winCapture = win;
4894     }
4895 }
4896
4897 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
4898 {
4899     int x, y;
4900     wxPoint pos( event.GetPosition() );
4901     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4902
4903     wxGridCellCoords coords;
4904     XYToCell( x, y, coords );
4905
4906     if ( event.Dragging() )
4907     {
4908         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4909
4910         // Don't start doing anything until the mouse has been drug at
4911         // least 3 pixels in any direction...
4912         if (! m_isDragging)
4913         {
4914             if (m_startDragPos == wxDefaultPosition)
4915             {
4916                 m_startDragPos = pos;
4917                 return;
4918             }
4919             if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
4920                 return;
4921         }
4922
4923         m_isDragging = TRUE;
4924         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4925         {
4926             // Hide the edit control, so it
4927             // won't interfer with drag-shrinking.
4928             if ( IsCellEditControlShown() )
4929             {
4930                 HideCellEditControl();
4931                 SaveEditControlValue();
4932             }
4933
4934             // Have we captured the mouse yet?
4935             if (! m_winCapture)
4936             {
4937                 m_winCapture = m_gridWin;
4938                 m_winCapture->CaptureMouse();
4939             }
4940
4941             if ( coords != wxGridNoCellCoords )
4942             {
4943                 if ( event.ControlDown() )
4944                 {
4945                     if ( m_selectingKeyboard == wxGridNoCellCoords)
4946                         m_selectingKeyboard = coords;
4947                     HighlightBlock ( m_selectingKeyboard, coords );
4948                 }
4949                 else
4950                 {
4951                     if ( !IsSelection() )
4952                     {
4953                         HighlightBlock( coords, coords );
4954                     }
4955                     else
4956                     {
4957                         HighlightBlock( m_currentCellCoords, coords );
4958                     }
4959                 }
4960
4961                 if (! IsVisible(coords))
4962                 {
4963                     MakeCellVisible(coords);
4964                     // TODO: need to introduce a delay or something here.  The
4965                     // scrolling is way to fast, at least on MSW - also on GTK.
4966                 }
4967             }
4968         }
4969         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4970         {
4971             int cw, ch, left, dummy;
4972             m_gridWin->GetClientSize( &cw, &ch );
4973             CalcUnscrolledPosition( 0, 0, &left, &dummy );
4974
4975             wxClientDC dc( m_gridWin );
4976             PrepareDC( dc );
4977             y = wxMax( y, GetRowTop(m_dragRowOrCol) +
4978                           GetRowMinimalHeight(m_dragRowOrCol) );
4979             dc.SetLogicalFunction(wxINVERT);
4980             if ( m_dragLastPos >= 0 )
4981             {
4982                 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4983             }
4984             dc.DrawLine( left, y, left+cw, y );
4985             m_dragLastPos = y;
4986         }
4987         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4988         {
4989             int cw, ch, dummy, top;
4990             m_gridWin->GetClientSize( &cw, &ch );
4991             CalcUnscrolledPosition( 0, 0, &dummy, &top );
4992
4993             wxClientDC dc( m_gridWin );
4994             PrepareDC( dc );
4995             x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4996                           GetColMinimalWidth(m_dragRowOrCol) );
4997             dc.SetLogicalFunction(wxINVERT);
4998             if ( m_dragLastPos >= 0 )
4999             {
5000                 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5001             }
5002             dc.DrawLine( x, top, x, top+ch );
5003             m_dragLastPos = x;
5004         }
5005
5006         return;
5007     }
5008
5009     m_isDragging = FALSE;
5010     m_startDragPos = wxDefaultPosition;
5011
5012     // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5013     //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5014     //     wxGTK
5015 #if 0
5016     if ( event.Entering() || event.Leaving() )
5017     {
5018         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5019         m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
5020     }
5021     else
5022 #endif // 0
5023
5024     // ------------ Left button pressed
5025     //
5026     if ( event.LeftDown() && coords != wxGridNoCellCoords )
5027     {
5028         if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
5029                        coords.GetRow(),
5030                        coords.GetCol(),
5031                        event ) )
5032         {
5033             if ( !event.ControlDown() )
5034                 ClearSelection();
5035             if ( event.ShiftDown() )
5036             {
5037                 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5038                                           m_currentCellCoords.GetCol(),
5039                                           coords.GetRow(),
5040                                           coords.GetCol(),
5041                                           event.ControlDown(),
5042                                           event.ShiftDown(),
5043                                           event.AltDown(),
5044                                           event.MetaDown() );
5045             }
5046             else if ( XToEdgeOfCol(x) < 0  &&
5047                       YToEdgeOfRow(y) < 0 )
5048             {
5049                 DisableCellEditControl();
5050                 MakeCellVisible( coords );
5051
5052                 // if this is the second click on this cell then start
5053                 // the edit control
5054                 if ( m_waitForSlowClick &&
5055                      (coords == m_currentCellCoords) &&
5056                      CanEnableCellControl())
5057                 {
5058                     EnableCellEditControl();
5059
5060                     wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5061                     wxGridCellEditor *editor = attr->GetEditor(this,
5062                                                                coords.GetRow(),
5063                                                                coords.GetCol());
5064                     editor->StartingClick();
5065                     editor->DecRef();
5066                     attr->DecRef();
5067
5068                     m_waitForSlowClick = FALSE;
5069                 }
5070                 else
5071                 {
5072                     if ( event.ControlDown() )
5073                     {
5074                         m_selection->ToggleCellSelection( coords.GetRow(),
5075                                                           coords.GetCol(),
5076                                                           event.ControlDown(),
5077                                                           event.ShiftDown(),
5078                                                           event.AltDown(),
5079                                                           event.MetaDown() );
5080                         m_selectingTopLeft = wxGridNoCellCoords;
5081                         m_selectingBottomRight = wxGridNoCellCoords;
5082                         m_selectingKeyboard = coords;
5083                     }
5084                     else
5085                     {
5086                         SetCurrentCell( coords );
5087                         if ( m_selection->GetSelectionMode()
5088                              != wxGrid::wxGridSelectCells)
5089                             HighlightBlock( coords, coords );
5090                     }
5091                     m_waitForSlowClick = TRUE;
5092                 }
5093             }
5094         }
5095     }
5096
5097
5098     // ------------ Left double click
5099     //
5100     else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
5101     {
5102         DisableCellEditControl();
5103
5104         if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
5105         {
5106             SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
5107                        coords.GetRow(),
5108                        coords.GetCol(),
5109                        event );
5110         }
5111     }
5112
5113
5114     // ------------ Left button released
5115     //
5116     else if ( event.LeftUp() )
5117     {
5118         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5119         {
5120             if ( m_selectingTopLeft != wxGridNoCellCoords &&
5121                  m_selectingBottomRight != wxGridNoCellCoords )
5122             {
5123                 if (m_winCapture)
5124                 {
5125                     m_winCapture->ReleaseMouse();
5126                     m_winCapture = NULL;
5127                 }
5128                 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5129                                           m_selectingTopLeft.GetCol(),
5130                                           m_selectingBottomRight.GetRow(),
5131                                           m_selectingBottomRight.GetCol(),
5132                                           event.ControlDown(),
5133                                           event.ShiftDown(),
5134                                           event.AltDown(),
5135                                           event.MetaDown() );
5136                 m_selectingTopLeft = wxGridNoCellCoords;
5137                 m_selectingBottomRight = wxGridNoCellCoords;
5138             }
5139
5140             // Show the edit control, if it has been hidden for
5141             // drag-shrinking.
5142             ShowCellEditControl();
5143         }
5144         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5145         {
5146             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5147             DoEndDragResizeRow();
5148
5149             // Note: we are ending the event *after* doing
5150             // default processing in this case
5151             //
5152             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5153         }
5154         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5155         {
5156             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5157             DoEndDragResizeCol();
5158
5159             // Note: we are ending the event *after* doing
5160             // default processing in this case
5161             //
5162             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5163         }
5164
5165         m_dragLastPos = -1;
5166     }
5167
5168
5169     // ------------ Right button down
5170     //
5171     else if ( event.RightDown() && coords != wxGridNoCellCoords )
5172     {
5173         DisableCellEditControl();
5174         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
5175                          coords.GetRow(),
5176                          coords.GetCol(),
5177                          event ) )
5178         {
5179             // no default action at the moment
5180         }
5181     }
5182
5183
5184     // ------------ Right double click
5185     //
5186     else if ( event.RightDClick() && coords != wxGridNoCellCoords )
5187     {
5188         DisableCellEditControl();
5189         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
5190                          coords.GetRow(),
5191                          coords.GetCol(),
5192                          event ) )
5193         {
5194             // no default action at the moment
5195         }
5196     }
5197
5198     // ------------ Moving and no button action
5199     //
5200     else if ( event.Moving() && !event.IsButton() )
5201     {
5202         int dragRow = YToEdgeOfRow( y );
5203         int dragCol = XToEdgeOfCol( x );
5204
5205         // Dragging on the corner of a cell to resize in both
5206         // directions is not implemented yet...
5207         //
5208         if ( dragRow >= 0  &&  dragCol >= 0 )
5209         {
5210             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5211             return;
5212         }
5213
5214         if ( dragRow >= 0 )
5215         {
5216             m_dragRowOrCol = dragRow;
5217
5218             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5219             {
5220                 if ( CanDragRowSize() && CanDragGridSize() )
5221                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
5222             }
5223
5224             if ( dragCol >= 0 )
5225             {
5226                 m_dragRowOrCol = dragCol;
5227             }
5228
5229             return;
5230         }
5231
5232         if ( dragCol >= 0 )
5233         {
5234             m_dragRowOrCol = dragCol;
5235
5236             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5237             {
5238                 if ( CanDragColSize() && CanDragGridSize() )
5239                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
5240             }
5241
5242             return;
5243         }
5244
5245         // Neither on a row or col edge
5246         //
5247         if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5248         {
5249             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5250         }
5251     }
5252 }
5253
5254
5255 void wxGrid::DoEndDragResizeRow()
5256 {
5257     if ( m_dragLastPos >= 0 )
5258     {
5259         // erase the last line and resize the row
5260         //
5261         int cw, ch, left, dummy;
5262         m_gridWin->GetClientSize( &cw, &ch );
5263         CalcUnscrolledPosition( 0, 0, &left, &dummy );
5264
5265         wxClientDC dc( m_gridWin );
5266         PrepareDC( dc );
5267         dc.SetLogicalFunction( wxINVERT );
5268         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5269         HideCellEditControl();
5270         SaveEditControlValue();
5271
5272         int rowTop = GetRowTop(m_dragRowOrCol);
5273         SetRowSize( m_dragRowOrCol,
5274                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
5275
5276         if ( !GetBatchCount() )
5277         {
5278             // Only needed to get the correct rect.y:
5279             wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5280             rect.x = 0;
5281             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5282             rect.width = m_rowLabelWidth;
5283             rect.height = ch - rect.y;
5284             m_rowLabelWin->Refresh( TRUE, &rect );
5285             rect.width = cw;
5286             m_gridWin->Refresh( FALSE, &rect );
5287         }
5288
5289         ShowCellEditControl();
5290     }
5291 }
5292
5293
5294 void wxGrid::DoEndDragResizeCol()
5295 {
5296     if ( m_dragLastPos >= 0 )
5297     {
5298         // erase the last line and resize the col
5299         //
5300         int cw, ch, dummy, top;
5301         m_gridWin->GetClientSize( &cw, &ch );
5302         CalcUnscrolledPosition( 0, 0, &dummy, &top );
5303
5304         wxClientDC dc( m_gridWin );
5305         PrepareDC( dc );
5306         dc.SetLogicalFunction( wxINVERT );
5307         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5308         HideCellEditControl();
5309         SaveEditControlValue();
5310
5311         int colLeft = GetColLeft(m_dragRowOrCol);
5312         SetColSize( m_dragRowOrCol,
5313                     wxMax( m_dragLastPos - colLeft,
5314                            GetColMinimalWidth(m_dragRowOrCol) ) );
5315
5316         if ( !GetBatchCount() )
5317         {
5318             // Only needed to get the correct rect.x:
5319             wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5320             rect.y = 0;
5321             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5322             rect.width = cw - rect.x;
5323             rect.height = m_colLabelHeight;
5324             m_colLabelWin->Refresh( TRUE, &rect );
5325             rect.height = ch;
5326             m_gridWin->Refresh( FALSE, &rect );
5327         }
5328
5329         ShowCellEditControl();
5330     }
5331 }
5332
5333
5334
5335 //
5336 // ------ interaction with data model
5337 //
5338 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5339 {
5340     switch ( msg.GetId() )
5341     {
5342         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5343             return GetModelValues();
5344
5345         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5346             return SetModelValues();
5347
5348         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5349         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5350         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5351         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5352         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5353         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5354             return Redimension( msg );
5355
5356         default:
5357             return FALSE;
5358     }
5359 }
5360
5361
5362
5363 // The behaviour of this function depends on the grid table class
5364 // Clear() function.  For the default wxGridStringTable class the
5365 // behavious is to replace all cell contents with wxEmptyString but
5366 // not to change the number of rows or cols.
5367 //
5368 void wxGrid::ClearGrid()
5369 {
5370     if ( m_table )
5371     {
5372         if (IsCellEditControlEnabled())
5373             DisableCellEditControl();
5374
5375         m_table->Clear();
5376         if ( !GetBatchCount() ) m_gridWin->Refresh();
5377     }
5378 }
5379
5380
5381 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5382 {
5383     // TODO: something with updateLabels flag
5384
5385     if ( !m_created )
5386     {
5387         wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5388         return FALSE;
5389     }
5390
5391     if ( m_table )
5392     {
5393         if (IsCellEditControlEnabled())
5394             DisableCellEditControl();
5395
5396         return m_table->InsertRows( pos, numRows );
5397
5398         // the table will have sent the results of the insert row
5399         // operation to this view object as a grid table message
5400     }
5401     return FALSE;
5402 }
5403
5404
5405 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5406 {
5407     // TODO: something with updateLabels flag
5408
5409     if ( !m_created )
5410     {
5411         wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5412         return FALSE;
5413     }
5414
5415     return ( m_table && m_table->AppendRows( numRows ) );
5416     // the table will have sent the results of the append row
5417     // operation to this view object as a grid table message
5418 }
5419
5420
5421 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5422 {
5423     // TODO: something with updateLabels flag
5424
5425     if ( !m_created )
5426     {
5427         wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5428         return FALSE;
5429     }
5430
5431     if ( m_table )
5432     {
5433         if (IsCellEditControlEnabled())
5434             DisableCellEditControl();
5435
5436         return (m_table->DeleteRows( pos, numRows ));
5437         // the table will have sent the results of the delete row
5438         // operation to this view object as a grid table message
5439     }
5440     return FALSE;
5441 }
5442
5443
5444 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5445 {
5446     // TODO: something with updateLabels flag
5447
5448     if ( !m_created )
5449     {
5450         wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5451         return FALSE;
5452     }
5453
5454     if ( m_table )
5455     {
5456         if (IsCellEditControlEnabled())
5457             DisableCellEditControl();
5458
5459         return m_table->InsertCols( pos, numCols );
5460         // the table will have sent the results of the insert col
5461         // operation to this view object as a grid table message
5462     }
5463     return FALSE;
5464 }
5465
5466
5467 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5468 {
5469     // TODO: something with updateLabels flag
5470
5471     if ( !m_created )
5472     {
5473         wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5474         return FALSE;
5475     }
5476
5477     return ( m_table && m_table->AppendCols( numCols ) );
5478     // the table will have sent the results of the append col
5479     // operation to this view object as a grid table message
5480 }
5481
5482
5483 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5484 {
5485     // TODO: something with updateLabels flag
5486
5487     if ( !m_created )
5488     {
5489         wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5490         return FALSE;
5491     }
5492
5493     if ( m_table )
5494     {
5495         if (IsCellEditControlEnabled())
5496             DisableCellEditControl();
5497
5498         return ( m_table->DeleteCols( pos, numCols ) );
5499         // the table will have sent the results of the delete col
5500         // operation to this view object as a grid table message
5501     }
5502     return FALSE;
5503 }
5504
5505
5506
5507 //
5508 // ----- event handlers
5509 //
5510
5511 // Generate a grid event based on a mouse event and
5512 // return the result of ProcessEvent()
5513 //
5514 int wxGrid::SendEvent( const wxEventType type,
5515                         int row, int col,
5516                         wxMouseEvent& mouseEv )
5517 {
5518    bool claimed;
5519    bool vetoed= FALSE;
5520
5521    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5522    {
5523        int rowOrCol = (row == -1 ? col : row);
5524
5525        wxGridSizeEvent gridEvt( GetId(),
5526                type,
5527                this,
5528                rowOrCol,
5529                mouseEv.GetX() + GetRowLabelSize(),
5530                mouseEv.GetY() + GetColLabelSize(),
5531                mouseEv.ControlDown(),
5532                mouseEv.ShiftDown(),
5533                mouseEv.AltDown(),
5534                mouseEv.MetaDown() );
5535
5536        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5537        vetoed = !gridEvt.IsAllowed();
5538    }
5539    else if ( type == wxEVT_GRID_RANGE_SELECT )
5540    {
5541        // Right now, it should _never_ end up here!
5542        wxGridRangeSelectEvent gridEvt( GetId(),
5543                type,
5544                this,
5545                m_selectingTopLeft,
5546                m_selectingBottomRight,
5547                TRUE,
5548                mouseEv.ControlDown(),
5549                mouseEv.ShiftDown(),
5550                mouseEv.AltDown(),
5551                mouseEv.MetaDown() );
5552
5553        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5554        vetoed = !gridEvt.IsAllowed();
5555    }
5556    else
5557    {
5558        wxGridEvent gridEvt( GetId(),
5559                type,
5560                this,
5561                row, col,
5562                mouseEv.GetX() + GetRowLabelSize(),
5563                mouseEv.GetY() + GetColLabelSize(),
5564                FALSE,
5565                mouseEv.ControlDown(),
5566                mouseEv.ShiftDown(),
5567                mouseEv.AltDown(),
5568                mouseEv.MetaDown() );
5569        claimed = GetEventHandler()->ProcessEvent(gridEvt);
5570        vetoed = !gridEvt.IsAllowed();
5571    }
5572
5573    // A Veto'd event may not be `claimed' so test this first
5574    if (vetoed) return -1;
5575    return claimed ? 1 : 0;
5576 }
5577
5578
5579 // Generate a grid event of specified type and return the result
5580 // of ProcessEvent().
5581 //
5582 int wxGrid::SendEvent( const wxEventType type,
5583                         int row, int col )
5584 {
5585    bool claimed;
5586    bool vetoed= FALSE;
5587
5588     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5589     {
5590         int rowOrCol = (row == -1 ? col : row);
5591
5592         wxGridSizeEvent gridEvt( GetId(),
5593                                  type,
5594                                  this,
5595                                  rowOrCol );
5596
5597         claimed = GetEventHandler()->ProcessEvent(gridEvt);
5598         vetoed  = !gridEvt.IsAllowed();
5599     }
5600     else
5601     {
5602         wxGridEvent gridEvt( GetId(),
5603                              type,
5604                              this,
5605                              row, col );
5606
5607         claimed = GetEventHandler()->ProcessEvent(gridEvt);
5608         vetoed  = !gridEvt.IsAllowed();
5609      }
5610
5611     // A Veto'd event may not be `claimed' so test this first
5612     if (vetoed) return -1;
5613     return claimed ? 1 : 0;
5614 }
5615
5616
5617 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
5618 {
5619     wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
5620 }
5621
5622
5623 void wxGrid::OnSize( wxSizeEvent& event )
5624 {
5625     // position the child windows
5626     CalcWindowSizes();
5627
5628     // don't call CalcDimensions() from here, the base class handles the size
5629     // changes itself
5630     event.Skip();
5631 }
5632
5633
5634 void wxGrid::OnKeyDown( wxKeyEvent& event )
5635 {
5636     if ( m_inOnKeyDown )
5637     {
5638         // shouldn't be here - we are going round in circles...
5639         //
5640         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
5641     }
5642
5643     m_inOnKeyDown = TRUE;
5644
5645     // propagate the event up and see if it gets processed
5646     //
5647     wxWindow *parent = GetParent();
5648     wxKeyEvent keyEvt( event );
5649     keyEvt.SetEventObject( parent );
5650
5651     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
5652     {
5653
5654         // try local handlers
5655         //
5656         switch ( event.KeyCode() )
5657         {
5658             case WXK_UP:
5659                 if ( event.ControlDown() )
5660                 {
5661                     MoveCursorUpBlock( event.ShiftDown() );
5662                 }
5663                 else
5664                 {
5665                     MoveCursorUp( event.ShiftDown() );
5666                 }
5667                 break;
5668
5669             case WXK_DOWN:
5670                 if ( event.ControlDown() )
5671                 {
5672                     MoveCursorDownBlock( event.ShiftDown() );
5673                 }
5674                 else
5675                 {
5676                     MoveCursorDown( event.ShiftDown() );
5677                 }
5678                 break;
5679
5680             case WXK_LEFT:
5681                 if ( event.ControlDown() )
5682                 {
5683                     MoveCursorLeftBlock( event.ShiftDown() );
5684                 }
5685                 else
5686                 {
5687                     MoveCursorLeft( event.ShiftDown() );
5688                 }
5689                 break;
5690
5691             case WXK_RIGHT:
5692                 if ( event.ControlDown() )
5693                 {
5694                     MoveCursorRightBlock( event.ShiftDown() );
5695                 }
5696                 else
5697                 {
5698                     MoveCursorRight( event.ShiftDown() );
5699                 }
5700                 break;
5701
5702             case WXK_RETURN:
5703             case WXK_NUMPAD_ENTER:
5704                 if ( event.ControlDown() )
5705                 {
5706                     event.Skip();  // to let the edit control have the return
5707                 }
5708                 else
5709                 {
5710                     if ( GetGridCursorRow() < GetNumberRows()-1 )
5711                     {
5712                         MoveCursorDown( event.ShiftDown() );
5713                     }
5714                     else
5715                     {
5716                         // at the bottom of a column
5717                         HideCellEditControl();
5718                         SaveEditControlValue();
5719                     }
5720                 }
5721                 break;
5722
5723             case WXK_ESCAPE:
5724                 ClearSelection();
5725                 break;
5726
5727             case WXK_TAB:
5728                 if (event.ShiftDown())
5729                 {
5730                     if ( GetGridCursorCol() > 0 )
5731                     {
5732                         MoveCursorLeft( FALSE );
5733                     }
5734                     else
5735                     {
5736                         // at left of grid
5737                         HideCellEditControl();
5738                         SaveEditControlValue();
5739                     }
5740                 }
5741                 else
5742                 {
5743                     if ( GetGridCursorCol() < GetNumberCols()-1 )
5744                     {
5745                         MoveCursorRight( FALSE );
5746                     }
5747                     else
5748                     {
5749                         // at right of grid
5750                         HideCellEditControl();
5751                         SaveEditControlValue();
5752                     }
5753                 }
5754                 break;
5755
5756             case WXK_HOME:
5757                 if ( event.ControlDown() )
5758                 {
5759                     MakeCellVisible( 0, 0 );
5760                     SetCurrentCell( 0, 0 );
5761                 }
5762                 else
5763                 {
5764                     event.Skip();
5765                 }
5766                 break;
5767
5768             case WXK_END:
5769                 if ( event.ControlDown() )
5770                 {
5771                     MakeCellVisible( m_numRows-1, m_numCols-1 );
5772                     SetCurrentCell( m_numRows-1, m_numCols-1 );
5773                 }
5774                 else
5775                 {
5776                     event.Skip();
5777                 }
5778                 break;
5779
5780             case WXK_PRIOR:
5781                 MovePageUp();
5782                 break;
5783
5784             case WXK_NEXT:
5785                 MovePageDown();
5786                 break;
5787
5788             case WXK_SPACE:
5789                 if ( event.ControlDown() )
5790                 {
5791                     m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
5792                                                       m_currentCellCoords.GetCol(),
5793                                                       event.ControlDown(),
5794                                                       event.ShiftDown(),
5795                                                       event.AltDown(),
5796                                                       event.MetaDown() );
5797                     break;
5798                 }
5799                 if ( !IsEditable() )
5800                 {
5801                     MoveCursorRight( FALSE );
5802                     break;
5803                 }
5804                 // Otherwise fall through to default
5805
5806             default:
5807                 // is it possible to edit the current cell at all?
5808                 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5809                 {
5810                     // yes, now check whether the cells editor accepts the key
5811                     int row = m_currentCellCoords.GetRow();
5812                     int col = m_currentCellCoords.GetCol();
5813                     wxGridCellAttr* attr = GetCellAttr(row, col);
5814                     wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5815
5816                     // <F2> is special and will always start editing, for
5817                     // other keys - ask the editor itself
5818                     if ( (event.KeyCode() == WXK_F2 && !event.HasModifiers())
5819                          || editor->IsAcceptedKey(event) )
5820                     {
5821                         EnableCellEditControl();
5822                         editor->StartingKey(event);
5823                     }
5824                     else
5825                     {
5826                         event.Skip();
5827                     }
5828
5829                     editor->DecRef();
5830                     attr->DecRef();
5831                 }
5832                 else
5833                 {
5834                     // let others process char events with modifiers or all
5835                     // char events for readonly cells
5836                     event.Skip();
5837                 }
5838                 break;
5839         }
5840     }
5841
5842     m_inOnKeyDown = FALSE;
5843 }
5844
5845 void wxGrid::OnKeyUp( wxKeyEvent& event )
5846 {
5847     // try local handlers
5848     //
5849     if ( event.KeyCode() == WXK_SHIFT )
5850     {
5851         if ( m_selectingTopLeft != wxGridNoCellCoords &&
5852              m_selectingBottomRight != wxGridNoCellCoords )
5853             m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5854                                       m_selectingTopLeft.GetCol(),
5855                                       m_selectingBottomRight.GetRow(),
5856                                       m_selectingBottomRight.GetCol(),
5857                                       event.ControlDown(),
5858                                       TRUE,
5859                                       event.AltDown(),
5860                                       event.MetaDown() );
5861         m_selectingTopLeft = wxGridNoCellCoords;
5862         m_selectingBottomRight = wxGridNoCellCoords;
5863         m_selectingKeyboard = wxGridNoCellCoords;
5864     }
5865 }
5866
5867 void wxGrid::OnEraseBackground(wxEraseEvent&)
5868 {
5869 }
5870
5871 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
5872 {
5873     if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
5874     {
5875         // the event has been intercepted - do nothing
5876         return;
5877     }
5878
5879     wxClientDC dc(m_gridWin);
5880     PrepareDC(dc);
5881
5882     if ( m_currentCellCoords != wxGridNoCellCoords )
5883     {
5884         HideCellEditControl();
5885         DisableCellEditControl();
5886
5887         if ( IsVisible( m_currentCellCoords, FALSE ) )
5888         {
5889             wxRect r;
5890             r = BlockToDeviceRect(m_currentCellCoords, coords);
5891             if ( !m_gridLinesEnabled )
5892             {
5893                 r.x--;
5894                 r.y--;
5895                 r.width++;
5896                 r.height++;
5897             }
5898
5899              wxGridCellCoordsArray cells = CalcCellsExposed( r );
5900
5901             // Otherwise refresh redraws the highlight!
5902             m_currentCellCoords = coords;
5903
5904             DrawGridCellArea(dc,cells);
5905             DrawAllGridLines( dc, r );
5906         }
5907     }
5908
5909     m_currentCellCoords = coords;
5910
5911     wxGridCellAttr* attr = GetCellAttr(coords);
5912     DrawCellHighlight(dc, attr);
5913     attr->DecRef();
5914 }
5915
5916
5917 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
5918 {
5919     int temp;
5920     wxGridCellCoords updateTopLeft, updateBottomRight;
5921
5922     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
5923     {
5924         leftCol = 0;
5925         rightCol = GetNumberCols() - 1;
5926     }
5927     else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
5928     {
5929         topRow = 0;
5930         bottomRow = GetNumberRows() - 1;
5931     }
5932     if ( topRow > bottomRow )
5933     {
5934         temp = topRow;
5935         topRow = bottomRow;
5936         bottomRow = temp;
5937     }
5938
5939     if ( leftCol > rightCol )
5940     {
5941         temp = leftCol;
5942         leftCol = rightCol;
5943         rightCol = temp;
5944     }
5945
5946     updateTopLeft = wxGridCellCoords( topRow, leftCol );
5947     updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
5948
5949     if ( m_selectingTopLeft != updateTopLeft ||
5950          m_selectingBottomRight != updateBottomRight )
5951     {
5952         // Compute two optimal update rectangles:
5953         // Either one rectangle is a real subset of the
5954         // other, or they are (almost) disjoint!
5955         wxRect  rect[4];
5956         bool    need_refresh[4];
5957         need_refresh[0] =
5958         need_refresh[1] =
5959         need_refresh[2] =
5960         need_refresh[3] = FALSE;
5961         int     i;
5962
5963         // Store intermediate values
5964         wxCoord oldLeft   = m_selectingTopLeft.GetCol();
5965         wxCoord oldTop    = m_selectingTopLeft.GetRow();
5966         wxCoord oldRight  = m_selectingBottomRight.GetCol();
5967         wxCoord oldBottom = m_selectingBottomRight.GetRow();
5968
5969         // Determine the outer/inner coordinates.
5970         if (oldLeft > leftCol)
5971         {
5972             temp = oldLeft;
5973             oldLeft = leftCol;
5974             leftCol = temp;
5975         }
5976         if (oldTop > topRow )
5977         {
5978             temp = oldTop;
5979             oldTop = topRow;
5980             topRow = temp;
5981         }
5982         if (oldRight < rightCol )
5983         {
5984             temp = oldRight;
5985             oldRight = rightCol;
5986             rightCol = temp;
5987         }
5988         if (oldBottom < bottomRow)
5989         {
5990             temp = oldBottom;
5991             oldBottom = bottomRow;
5992             bottomRow = temp;
5993         }
5994
5995         // Now, either the stuff marked old is the outer
5996         // rectangle or we don't have a situation where one
5997         // is contained in the other.
5998
5999         if ( oldLeft < leftCol )
6000         {
6001             need_refresh[0] = TRUE;
6002             rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6003                                                             oldLeft ),
6004                                          wxGridCellCoords ( oldBottom,
6005                                                             leftCol - 1 ) );
6006         }
6007
6008         if ( oldTop  < topRow )
6009         {
6010             need_refresh[1] = TRUE;
6011             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6012                                                             leftCol ),
6013                                          wxGridCellCoords ( topRow - 1,
6014                                                             rightCol ) );
6015         }
6016
6017         if ( oldRight > rightCol )
6018         {
6019             need_refresh[2] = TRUE;
6020             rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6021                                                             rightCol + 1 ),
6022                                          wxGridCellCoords ( oldBottom,
6023                                                             oldRight ) );
6024         }
6025
6026         if ( oldBottom > bottomRow )
6027         {
6028             need_refresh[3] = TRUE;
6029             rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6030                                                             leftCol ),
6031                                          wxGridCellCoords ( oldBottom,
6032                                                             rightCol ) );
6033         }
6034
6035
6036         // Change Selection
6037         m_selectingTopLeft = updateTopLeft;
6038         m_selectingBottomRight = updateBottomRight;
6039
6040         // various Refresh() calls
6041         for (i = 0; i < 4; i++ )
6042             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6043                 m_gridWin->Refresh( FALSE, &(rect[i]) );
6044     }
6045
6046     // never generate an event as it will be generated from
6047     // wxGridSelection::SelectBlock!
6048     // (old comment from when this was the body of SelectBlock)
6049 }
6050
6051 //
6052 // ------ functions to get/send data (see also public functions)
6053 //
6054
6055 bool wxGrid::GetModelValues()
6056 {
6057     if ( m_table )
6058     {
6059         // all we need to do is repaint the grid
6060         //
6061         m_gridWin->Refresh();
6062         return TRUE;
6063     }
6064
6065     return FALSE;
6066 }
6067
6068
6069 bool wxGrid::SetModelValues()
6070 {
6071     int row, col;
6072
6073     if ( m_table )
6074     {
6075         for ( row = 0;  row < m_numRows;  row++ )
6076         {
6077             for ( col = 0;  col < m_numCols;  col++ )
6078             {
6079                 m_table->SetValue( row, col, GetCellValue(row, col) );
6080             }
6081         }
6082
6083         return TRUE;
6084     }
6085
6086     return FALSE;
6087 }
6088
6089
6090
6091 // Note - this function only draws cells that are in the list of
6092 // exposed cells (usually set from the update region by
6093 // CalcExposedCells)
6094 //
6095 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6096 {
6097     if ( !m_numRows || !m_numCols ) return;
6098
6099     size_t i;
6100     size_t numCells = cells.GetCount();
6101
6102     for ( i = 0;  i < numCells;  i++ )
6103     {
6104         DrawCell( dc, cells[i] );
6105     }
6106 }
6107
6108
6109 void wxGrid::DrawGridSpace( wxDC& dc )
6110 {
6111   int cw, ch;
6112   m_gridWin->GetClientSize( &cw, &ch );
6113
6114   int right, bottom;
6115   CalcUnscrolledPosition( cw, ch, &right, &bottom );
6116
6117   int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6118   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6119
6120   if ( right > rightCol || bottom > bottomRow )
6121   {
6122       int left, top;
6123       CalcUnscrolledPosition( 0, 0, &left, &top );
6124
6125       dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6126       dc.SetPen( *wxTRANSPARENT_PEN );
6127
6128       if ( right > rightCol )
6129       {
6130           dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6131       }
6132
6133       if ( bottom > bottomRow )
6134       {
6135           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6136       }
6137   }
6138 }
6139
6140
6141 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6142 {
6143     int row = coords.GetRow();
6144     int col = coords.GetCol();
6145
6146     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6147         return;
6148
6149     // we draw the cell border ourselves
6150 #if !WXGRID_DRAW_LINES
6151     if ( m_gridLinesEnabled )
6152         DrawCellBorder( dc, coords );
6153 #endif
6154
6155     wxGridCellAttr* attr = GetCellAttr(row, col);
6156
6157     bool isCurrent = coords == m_currentCellCoords;
6158
6159     wxRect rect = CellToRect( row, col );
6160
6161     // if the editor is shown, we should use it and not the renderer
6162     // Note: However, only if it is really _shown_, i.e. not hidden!
6163     if ( isCurrent && IsCellEditControlShown() )
6164     {
6165         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6166         editor->PaintBackground(rect, attr);
6167         editor->DecRef();
6168     }
6169     else
6170     {
6171         // but all the rest is drawn by the cell renderer and hence may be
6172         // customized
6173         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6174         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6175         renderer->DecRef();
6176     }
6177
6178     attr->DecRef();
6179 }
6180
6181 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6182 {
6183     int row = m_currentCellCoords.GetRow();
6184     int col = m_currentCellCoords.GetCol();
6185
6186     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6187         return;
6188
6189     wxRect rect = CellToRect(row, col);
6190
6191     // hmmm... what could we do here to show that the cell is disabled?
6192     // for now, I just draw a thinner border than for the other ones, but
6193     // it doesn't look really good
6194
6195     int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6196
6197     if (penWidth > 0) {
6198
6199         // The center of th drawn line is where the position/width/height of
6200         // the rectangle is actually at, (on wxMSW atr least,) so we will
6201         // reduce the size of the rectangle to compensate for the thickness of
6202         // the line.  If this is too strange on non wxMSW platforms then
6203         // please #ifdef this appropriately.
6204         rect.x += penWidth/2;
6205         rect.y += penWidth/2;
6206         rect.width -= penWidth-1;
6207         rect.height -= penWidth-1;
6208
6209
6210         // Now draw the rectangle
6211         dc.SetPen(wxPen(m_cellHighlightColour, penWidth, wxSOLID));
6212         dc.SetBrush(*wxTRANSPARENT_BRUSH);
6213         dc.DrawRectangle(rect);
6214     }
6215
6216 #if 0
6217         // VZ: my experiments with 3d borders...
6218
6219         // how to properly set colours for arbitrary bg?
6220         wxCoord x1 = rect.x,
6221                 y1 = rect.y,
6222                 x2 = rect.x + rect.width -1,
6223                 y2 = rect.y + rect.height -1;
6224
6225         dc.SetPen(*wxWHITE_PEN);
6226         dc.DrawLine(x1, y1, x2, y1);
6227         dc.DrawLine(x1, y1, x1, y2);
6228
6229         dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
6230         dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
6231
6232         dc.SetPen(*wxBLACK_PEN);
6233         dc.DrawLine(x1, y2, x2, y2);
6234         dc.DrawLine(x2, y1, x2, y2+1);
6235 #endif // 0
6236 }
6237
6238
6239 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
6240 {
6241     int row = coords.GetRow();
6242     int col = coords.GetCol();
6243     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6244         return;
6245
6246     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6247
6248     // right hand border
6249     //
6250     dc.DrawLine( GetColRight(col), GetRowTop(row),
6251                  GetColRight(col), GetRowBottom(row) );
6252
6253     // bottom border
6254     //
6255     dc.DrawLine( GetColLeft(col), GetRowBottom(row),
6256                  GetColRight(col), GetRowBottom(row) );
6257 }
6258
6259 void wxGrid::DrawHighlight(wxDC& dc,const  wxGridCellCoordsArray& cells)
6260 {
6261     // This if block was previously in wxGrid::OnPaint but that doesn't
6262     // seem to get called under wxGTK - MB
6263     //
6264     if ( m_currentCellCoords == wxGridNoCellCoords  &&
6265          m_numRows && m_numCols )
6266     {
6267         m_currentCellCoords.Set(0, 0);
6268     }
6269
6270     if ( IsCellEditControlShown() )
6271     {
6272         // don't show highlight when the edit control is shown
6273         return;
6274     }
6275
6276     // if the active cell was repainted, repaint its highlight too because it
6277     // might have been damaged by the grid lines
6278     size_t count = cells.GetCount();
6279     for ( size_t n = 0; n < count; n++ )
6280     {
6281         if ( cells[n] == m_currentCellCoords )
6282         {
6283             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6284             DrawCellHighlight(dc, attr);
6285             attr->DecRef();
6286
6287             break;
6288         }
6289     }
6290 }
6291
6292 // TODO: remove this ???
6293 // This is used to redraw all grid lines e.g. when the grid line colour
6294 // has been changed
6295 //
6296 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
6297 {
6298     if ( !m_gridLinesEnabled ||
6299          !m_numRows ||
6300          !m_numCols ) return;
6301
6302     int top, bottom, left, right;
6303
6304 #if 0  //#ifndef __WXGTK__
6305     if (reg.IsEmpty())
6306     {
6307       int cw, ch;
6308       m_gridWin->GetClientSize(&cw, &ch);
6309
6310       // virtual coords of visible area
6311       //
6312       CalcUnscrolledPosition( 0, 0, &left, &top );
6313       CalcUnscrolledPosition( cw, ch, &right, &bottom );
6314     }
6315     else
6316     {
6317       wxCoord x, y, w, h;
6318       reg.GetBox(x, y, w, h);
6319       CalcUnscrolledPosition( x, y, &left, &top );
6320       CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
6321     }
6322 #else
6323       int cw, ch;
6324       m_gridWin->GetClientSize(&cw, &ch);
6325       CalcUnscrolledPosition( 0, 0, &left, &top );
6326       CalcUnscrolledPosition( cw, ch, &right, &bottom );
6327 #endif
6328
6329     // avoid drawing grid lines past the last row and col
6330     //
6331     right = wxMin( right, GetColRight(m_numCols - 1) );
6332     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
6333
6334     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6335
6336     // horizontal grid lines
6337     //
6338     int i;
6339     for ( i = 0; i < m_numRows; i++ )
6340     {
6341         int bot = GetRowBottom(i) - 1;
6342
6343         if ( bot > bottom )
6344         {
6345             break;
6346         }
6347
6348         if ( bot >= top )
6349         {
6350             dc.DrawLine( left, bot, right, bot );
6351         }
6352     }
6353
6354
6355     // vertical grid lines
6356     //
6357     for ( i = 0; i < m_numCols; i++ )
6358     {
6359         int colRight = GetColRight(i) - 1;
6360         if ( colRight > right )
6361         {
6362             break;
6363         }
6364
6365         if ( colRight >= left )
6366         {
6367             dc.DrawLine( colRight, top, colRight, bottom );
6368         }
6369     }
6370 }
6371
6372
6373 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
6374 {
6375     if ( !m_numRows ) return;
6376
6377     size_t i;
6378     size_t numLabels = rows.GetCount();
6379
6380     for ( i = 0;  i < numLabels;  i++ )
6381     {
6382         DrawRowLabel( dc, rows[i] );
6383     }
6384 }
6385
6386
6387 void wxGrid::DrawRowLabel( wxDC& dc, int row )
6388 {
6389     if ( GetRowHeight(row) <= 0 )
6390         return;
6391
6392     int rowTop = GetRowTop(row),
6393         rowBottom = GetRowBottom(row) - 1;
6394
6395     dc.SetPen( *wxBLACK_PEN );
6396     dc.DrawLine( m_rowLabelWidth-1, rowTop,
6397                  m_rowLabelWidth-1, rowBottom );
6398
6399     dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
6400
6401     dc.SetPen( *wxWHITE_PEN );
6402     dc.DrawLine( 0, rowTop, 0, rowBottom );
6403     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
6404
6405     dc.SetBackgroundMode( wxTRANSPARENT );
6406     dc.SetTextForeground( GetLabelTextColour() );
6407     dc.SetFont( GetLabelFont() );
6408
6409     int hAlign, vAlign;
6410     GetRowLabelAlignment( &hAlign, &vAlign );
6411
6412     wxRect rect;
6413     rect.SetX( 2 );
6414     rect.SetY( GetRowTop(row) + 2 );
6415     rect.SetWidth( m_rowLabelWidth - 4 );
6416     rect.SetHeight( GetRowHeight(row) - 4 );
6417     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
6418 }
6419
6420
6421 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
6422 {
6423     if ( !m_numCols ) return;
6424
6425     size_t i;
6426     size_t numLabels = cols.GetCount();
6427
6428     for ( i = 0;  i < numLabels;  i++ )
6429     {
6430         DrawColLabel( dc, cols[i] );
6431     }
6432 }
6433
6434
6435 void wxGrid::DrawColLabel( wxDC& dc, int col )
6436 {
6437     if ( GetColWidth(col) <= 0 )
6438         return;
6439
6440     int colLeft = GetColLeft(col),
6441         colRight = GetColRight(col) - 1;
6442
6443     dc.SetPen( *wxBLACK_PEN );
6444     dc.DrawLine( colRight, 0,
6445                  colRight, m_colLabelHeight-1 );
6446
6447     dc.DrawLine( colLeft, m_colLabelHeight-1,
6448                  colRight, m_colLabelHeight-1 );
6449
6450     dc.SetPen( *wxWHITE_PEN );
6451     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
6452     dc.DrawLine( colLeft, 0, colRight, 0 );
6453
6454     dc.SetBackgroundMode( wxTRANSPARENT );
6455     dc.SetTextForeground( GetLabelTextColour() );
6456     dc.SetFont( GetLabelFont() );
6457
6458     dc.SetBackgroundMode( wxTRANSPARENT );
6459     dc.SetTextForeground( GetLabelTextColour() );
6460     dc.SetFont( GetLabelFont() );
6461
6462     int hAlign, vAlign;
6463     GetColLabelAlignment( &hAlign, &vAlign );
6464
6465     wxRect rect;
6466     rect.SetX( colLeft + 2 );
6467     rect.SetY( 2 );
6468     rect.SetWidth( GetColWidth(col) - 4 );
6469     rect.SetHeight( m_colLabelHeight - 4 );
6470     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
6471 }
6472
6473 void wxGrid::DrawTextRectangle( wxDC& dc,
6474                                 const wxString& value,
6475                                 const wxRect& rect,
6476                                 int horizAlign,
6477                                 int vertAlign )
6478 {
6479     wxArrayString lines;
6480
6481     dc.SetClippingRegion( rect );
6482     StringToLines( value, lines );
6483
6484
6485     //Forward to new API.
6486     DrawTextRectangle(  dc,
6487                         lines,
6488                         rect,
6489                         horizAlign,
6490                         vertAlign );
6491
6492 }
6493
6494 void wxGrid::DrawTextRectangle( wxDC& dc,
6495                                 const wxArrayString& lines,
6496                                 const wxRect& rect,
6497                                 int horizAlign,
6498                                 int vertAlign )
6499 {
6500     long textWidth, textHeight;
6501     long lineWidth, lineHeight;
6502
6503     if ( lines.GetCount() )
6504     {
6505         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
6506         dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
6507
6508         float x, y;
6509         switch ( horizAlign )
6510         {
6511             case wxALIGN_RIGHT:
6512                 x = rect.x + (rect.width - textWidth - 1);
6513                 break;
6514
6515             case wxALIGN_CENTRE:
6516                 x = rect.x + ((rect.width - textWidth)/2);
6517                 break;
6518
6519             case wxALIGN_LEFT:
6520             default:
6521                 x = rect.x + 1;
6522                 break;
6523         }
6524
6525         switch ( vertAlign )
6526         {
6527             case wxALIGN_BOTTOM:
6528                 y = rect.y + (rect.height - textHeight - 1);
6529                 break;
6530
6531             case wxALIGN_CENTRE:
6532                 y = rect.y + ((rect.height - textHeight)/2);
6533                 break;
6534
6535             case wxALIGN_TOP:
6536             default:
6537                 y = rect.y + 1;
6538                 break;
6539         }
6540
6541         for ( size_t i = 0;  i < lines.GetCount();  i++ )
6542         {
6543             dc.DrawText( lines[i], (int)x, (int)y );
6544             y += lineHeight;
6545         }
6546     }
6547
6548     dc.DestroyClippingRegion();
6549 }
6550
6551
6552 // Split multi line text up into an array of strings.  Any existing
6553 // contents of the string array are preserved.
6554 //
6555 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
6556 {
6557     int startPos = 0;
6558     int pos;
6559     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
6560     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
6561
6562     while ( startPos < (int)tVal.Length() )
6563     {
6564         pos = tVal.Mid(startPos).Find( eol );
6565         if ( pos < 0 )
6566         {
6567             break;
6568         }
6569         else if ( pos == 0 )
6570         {
6571             lines.Add( wxEmptyString );
6572         }
6573         else
6574         {
6575             lines.Add( value.Mid(startPos, pos) );
6576         }
6577         startPos += pos+1;
6578     }
6579     if ( startPos < (int)value.Length() )
6580     {
6581         lines.Add( value.Mid( startPos ) );
6582     }
6583 }
6584
6585
6586 void wxGrid::GetTextBoxSize( wxDC& dc,
6587                              const wxArrayString& lines,
6588                              long *width, long *height )
6589 {
6590     long w = 0;
6591     long h = 0;
6592     long lineW, lineH;
6593
6594     size_t i;
6595     for ( i = 0;  i < lines.GetCount();  i++ )
6596     {
6597         dc.GetTextExtent( lines[i], &lineW, &lineH );
6598         w = wxMax( w, lineW );
6599         h += lineH;
6600     }
6601
6602     *width = w;
6603     *height = h;
6604 }
6605
6606 //
6607 // ------ Batch processing.
6608 //
6609 void wxGrid::EndBatch()
6610 {
6611     if ( m_batchCount > 0 )
6612     {
6613         m_batchCount--;
6614         if ( !m_batchCount )
6615         {
6616             CalcDimensions();
6617             m_rowLabelWin->Refresh();
6618             m_colLabelWin->Refresh();
6619             m_cornerLabelWin->Refresh();
6620             m_gridWin->Refresh();
6621         }
6622     }
6623 }
6624
6625 // Use this, rather than wxWindow::Refresh(), to force an immediate
6626 // repainting of the grid. Has no effect if you are already inside a
6627 // BeginBatch / EndBatch block.
6628 //
6629 void wxGrid::ForceRefresh()
6630 {
6631     BeginBatch();
6632     EndBatch();
6633 }
6634
6635
6636 //
6637 // ------ Edit control functions
6638 //
6639
6640
6641 void wxGrid::EnableEditing( bool edit )
6642 {
6643     // TODO: improve this ?
6644     //
6645     if ( edit != m_editable )
6646     {
6647         if(!edit) EnableCellEditControl(edit);
6648         m_editable = edit;
6649     }
6650 }
6651
6652
6653 void wxGrid::EnableCellEditControl( bool enable )
6654 {
6655     if (! m_editable)
6656         return;
6657
6658     if ( m_currentCellCoords == wxGridNoCellCoords )
6659         SetCurrentCell( 0, 0 );
6660
6661     if ( enable != m_cellEditCtrlEnabled )
6662     {
6663         if ( enable )
6664         {
6665             if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
6666                 return;
6667
6668             // this should be checked by the caller!
6669             wxASSERT_MSG( CanEnableCellControl(),
6670                           _T("can't enable editing for this cell!") );
6671
6672             // do it before ShowCellEditControl()
6673             m_cellEditCtrlEnabled = enable;
6674
6675             ShowCellEditControl();
6676         }
6677         else
6678         {
6679             //FIXME:add veto support
6680             SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
6681
6682             HideCellEditControl();
6683             SaveEditControlValue();
6684
6685             // do it after HideCellEditControl()
6686             m_cellEditCtrlEnabled = enable;
6687         }
6688     }
6689 }
6690
6691 bool wxGrid::IsCurrentCellReadOnly() const
6692 {
6693     // const_cast
6694     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
6695     bool readonly = attr->IsReadOnly();
6696     attr->DecRef();
6697
6698     return readonly;
6699 }
6700
6701 bool wxGrid::CanEnableCellControl() const
6702 {
6703     return m_editable && !IsCurrentCellReadOnly();
6704 }
6705
6706 bool wxGrid::IsCellEditControlEnabled() const
6707 {
6708     // the cell edit control might be disable for all cells or just for the
6709     // current one if it's read only
6710     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
6711 }
6712
6713 bool wxGrid::IsCellEditControlShown() const
6714 {
6715     bool isShown = FALSE;
6716
6717     if ( m_cellEditCtrlEnabled )
6718     {
6719         int row = m_currentCellCoords.GetRow();
6720         int col = m_currentCellCoords.GetCol();
6721         wxGridCellAttr* attr = GetCellAttr(row, col);
6722         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
6723         attr->DecRef();
6724
6725         if ( editor )
6726         {
6727             if ( editor->IsCreated() )
6728             {
6729                 isShown = editor->GetControl()->IsShown();
6730             }
6731
6732             editor->DecRef();
6733         }
6734     }
6735
6736     return isShown;
6737 }
6738
6739 void wxGrid::ShowCellEditControl()
6740 {
6741     if ( IsCellEditControlEnabled() )
6742     {
6743         if ( !IsVisible( m_currentCellCoords ) )
6744         {
6745             m_cellEditCtrlEnabled = FALSE;
6746             return;
6747         }
6748         else
6749         {
6750             wxRect rect = CellToRect( m_currentCellCoords );
6751             int row = m_currentCellCoords.GetRow();
6752             int col = m_currentCellCoords.GetCol();
6753
6754             // convert to scrolled coords
6755             //
6756             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6757
6758             // done in PaintBackground()
6759 #if 0
6760             // erase the highlight and the cell contents because the editor
6761             // might not cover the entire cell
6762             wxClientDC dc( m_gridWin );
6763             PrepareDC( dc );
6764             dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
6765             dc.SetPen(*wxTRANSPARENT_PEN);
6766             dc.DrawRectangle(rect);
6767 #endif // 0
6768
6769             // cell is shifted by one pixel
6770             rect.x--;
6771             rect.y--;
6772
6773             wxGridCellAttr* attr = GetCellAttr(row, col);
6774             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6775             if ( !editor->IsCreated() )
6776             {
6777                 editor->Create(m_gridWin, -1,
6778                                new wxGridCellEditorEvtHandler(this, editor));
6779
6780                 wxGridEditorCreatedEvent evt(GetId(),
6781                                              wxEVT_GRID_EDITOR_CREATED,
6782                                              this,
6783                                              row,
6784                                              col,
6785                                              editor->GetControl());
6786                 GetEventHandler()->ProcessEvent(evt);
6787             }
6788
6789             editor->Show( TRUE, attr );
6790
6791             editor->SetSize( rect );
6792
6793             editor->BeginEdit(row, col, this);
6794
6795             editor->DecRef();
6796             attr->DecRef();
6797          }
6798     }
6799 }
6800
6801
6802 void wxGrid::HideCellEditControl()
6803 {
6804     if ( IsCellEditControlEnabled() )
6805     {
6806         int row = m_currentCellCoords.GetRow();
6807         int col = m_currentCellCoords.GetCol();
6808
6809         wxGridCellAttr* attr = GetCellAttr(row, col);
6810         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6811         editor->Show( FALSE );
6812         editor->DecRef();
6813         attr->DecRef();
6814         m_gridWin->SetFocus();
6815         wxRect rect( CellToRect( row, col ) );
6816         m_gridWin->Refresh( FALSE, &rect );
6817     }
6818 }
6819
6820
6821 void wxGrid::SaveEditControlValue()
6822 {
6823     if ( IsCellEditControlEnabled() )
6824     {
6825         int row = m_currentCellCoords.GetRow();
6826         int col = m_currentCellCoords.GetCol();
6827
6828         wxString oldval = GetCellValue(row,col);
6829
6830         wxGridCellAttr* attr = GetCellAttr(row, col);
6831         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6832         bool changed = editor->EndEdit(row, col, this);
6833
6834         editor->DecRef();
6835         attr->DecRef();
6836
6837         if (changed)
6838         {
6839             if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
6840                        m_currentCellCoords.GetRow(),
6841                        m_currentCellCoords.GetCol() ) < 0 ) {
6842
6843                 // Event has been vetoed, set the data back.
6844                 SetCellValue(row,col,oldval);
6845             }
6846         }
6847     }
6848 }
6849
6850
6851 //
6852 // ------ Grid location functions
6853 //  Note that all of these functions work with the logical coordinates of
6854 //  grid cells and labels so you will need to convert from device
6855 //  coordinates for mouse events etc.
6856 //
6857
6858 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
6859 {
6860     int row = YToRow(y);
6861     int col = XToCol(x);
6862
6863     if ( row == -1  ||  col == -1 )
6864     {
6865         coords = wxGridNoCellCoords;
6866     }
6867     else
6868     {
6869         coords.Set( row, col );
6870     }
6871 }
6872
6873
6874 int wxGrid::YToRow( int y )
6875 {
6876     int i;
6877
6878     for ( i = 0;  i < m_numRows;  i++ )
6879     {
6880         if ( y < GetRowBottom(i) )
6881             return i;
6882     }
6883
6884     return -1;
6885 }
6886
6887
6888 int wxGrid::XToCol( int x )
6889 {
6890     int i;
6891
6892     for ( i = 0;  i < m_numCols;  i++ )
6893     {
6894         if ( x < GetColRight(i) )
6895             return i;
6896     }
6897
6898     return -1;
6899 }
6900
6901
6902 // return the row number that that the y coord is near the edge of, or
6903 // -1 if not near an edge
6904 //
6905 int wxGrid::YToEdgeOfRow( int y )
6906 {
6907     int i, d;
6908
6909     for ( i = 0;  i < m_numRows;  i++ )
6910     {
6911         if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
6912         {
6913             d = abs( y - GetRowBottom(i) );
6914             if ( d < WXGRID_LABEL_EDGE_ZONE )
6915                 return i;
6916         }
6917     }
6918
6919     return -1;
6920 }
6921
6922
6923 // return the col number that that the x coord is near the edge of, or
6924 // -1 if not near an edge
6925 //
6926 int wxGrid::XToEdgeOfCol( int x )
6927 {
6928     int i, d;
6929
6930     for ( i = 0;  i < m_numCols;  i++ )
6931     {
6932         if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
6933         {
6934             d = abs( x - GetColRight(i) );
6935             if ( d < WXGRID_LABEL_EDGE_ZONE )
6936                 return i;
6937         }
6938     }
6939
6940     return -1;
6941 }
6942
6943
6944 wxRect wxGrid::CellToRect( int row, int col )
6945 {
6946     wxRect rect( -1, -1, -1, -1 );
6947
6948     if ( row >= 0  &&  row < m_numRows  &&
6949          col >= 0  &&  col < m_numCols )
6950     {
6951         rect.x = GetColLeft(col);
6952         rect.y = GetRowTop(row);
6953         rect.width = GetColWidth(col);
6954         rect.height = GetRowHeight(row);
6955     }
6956
6957     // if grid lines are enabled, then the area of the cell is a bit smaller
6958     if (m_gridLinesEnabled) {
6959         rect.width -= 1;
6960         rect.height -= 1;
6961     }
6962     return rect;
6963 }
6964
6965
6966 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
6967 {
6968     // get the cell rectangle in logical coords
6969     //
6970     wxRect r( CellToRect( row, col ) );
6971
6972     // convert to device coords
6973     //
6974     int left, top, right, bottom;
6975     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6976     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6977
6978     // check against the client area of the grid window
6979     //
6980     int cw, ch;
6981     m_gridWin->GetClientSize( &cw, &ch );
6982
6983     if ( wholeCellVisible )
6984     {
6985         // is the cell wholly visible ?
6986         //
6987         return ( left >= 0  &&  right <= cw  &&
6988                  top >= 0  &&  bottom <= ch );
6989     }
6990     else
6991     {
6992         // is the cell partly visible ?
6993         //
6994         return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
6995                  ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6996     }
6997 }
6998
6999
7000 // make the specified cell location visible by doing a minimal amount
7001 // of scrolling
7002 //
7003 void wxGrid::MakeCellVisible( int row, int col )
7004 {
7005
7006     int i;
7007     int xpos = -1, ypos = -1;
7008
7009     if ( row >= 0  &&  row < m_numRows  &&
7010          col >= 0  &&  col < m_numCols )
7011     {
7012         // get the cell rectangle in logical coords
7013         //
7014         wxRect r( CellToRect( row, col ) );
7015
7016         // convert to device coords
7017         //
7018         int left, top, right, bottom;
7019         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7020         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7021
7022         int cw, ch;
7023         m_gridWin->GetClientSize( &cw, &ch );
7024
7025         if ( top < 0 )
7026         {
7027             ypos = r.GetTop();
7028         }
7029         else if ( bottom > ch )
7030         {
7031             int h = r.GetHeight();
7032             ypos = r.GetTop();
7033             for ( i = row-1;  i >= 0;  i-- )
7034             {
7035                 int rowHeight = GetRowHeight(i);
7036                 if ( h + rowHeight > ch )
7037                     break;
7038
7039                 h += rowHeight;
7040                 ypos -= rowHeight;
7041             }
7042
7043             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7044             // have rounding errors (this is important, because if we do, we
7045             // might not scroll at all and some cells won't be redrawn)
7046             //
7047             // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7048             // scroll unit...
7049             ypos += GRID_SCROLL_LINE_Y;
7050         }
7051
7052         if ( left < 0 )
7053         {
7054             xpos = r.GetLeft();
7055         }
7056         else if ( right > cw )
7057         {
7058             int w = r.GetWidth();
7059             xpos = r.GetLeft();
7060             for ( i = col-1;  i >= 0;  i-- )
7061             {
7062                 int colWidth = GetColWidth(i);
7063                 if ( w + colWidth > cw )
7064                     break;
7065
7066                 w += colWidth;
7067                 xpos -= colWidth;
7068             }
7069
7070             // see comment for ypos above
7071             xpos += GRID_SCROLL_LINE_X;
7072         }
7073
7074         if ( xpos != -1  ||  ypos != -1 )
7075         {
7076             if ( xpos != -1 )
7077                 xpos /= GRID_SCROLL_LINE_X;
7078             if ( ypos != -1 )
7079                 ypos /= GRID_SCROLL_LINE_Y;
7080             Scroll( xpos, ypos );
7081             AdjustScrollbars();
7082         }
7083     }
7084 }
7085
7086
7087 //
7088 // ------ Grid cursor movement functions
7089 //
7090
7091 bool wxGrid::MoveCursorUp( bool expandSelection )
7092 {
7093     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7094          m_currentCellCoords.GetRow() >= 0 )
7095     {
7096         if ( expandSelection)
7097         {
7098             if ( m_selectingKeyboard == wxGridNoCellCoords )
7099                 m_selectingKeyboard = m_currentCellCoords;
7100             if ( m_selectingKeyboard.GetRow() > 0 )
7101             {
7102                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
7103                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7104                                  m_selectingKeyboard.GetCol() );
7105                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7106             }
7107         }
7108         else if ( m_currentCellCoords.GetRow() > 0 )
7109         {
7110             ClearSelection();
7111             MakeCellVisible( m_currentCellCoords.GetRow() - 1,
7112                              m_currentCellCoords.GetCol() );
7113             SetCurrentCell( m_currentCellCoords.GetRow() - 1,
7114                             m_currentCellCoords.GetCol() );
7115         }
7116         else
7117             return FALSE;
7118         return TRUE;
7119     }
7120
7121     return FALSE;
7122 }
7123
7124
7125 bool wxGrid::MoveCursorDown( bool expandSelection )
7126 {
7127     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7128          m_currentCellCoords.GetRow() < m_numRows )
7129     {
7130         if ( expandSelection )
7131         {
7132             if ( m_selectingKeyboard == wxGridNoCellCoords )
7133                 m_selectingKeyboard = m_currentCellCoords;
7134             if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
7135             {
7136                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
7137                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7138                         m_selectingKeyboard.GetCol() );
7139                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7140             }
7141         }
7142         else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
7143         {
7144             ClearSelection();
7145             MakeCellVisible( m_currentCellCoords.GetRow() + 1,
7146                              m_currentCellCoords.GetCol() );
7147             SetCurrentCell( m_currentCellCoords.GetRow() + 1,
7148                             m_currentCellCoords.GetCol() );
7149         }
7150         else
7151             return FALSE;
7152         return TRUE;
7153     }
7154
7155     return FALSE;
7156 }
7157
7158
7159 bool wxGrid::MoveCursorLeft( bool expandSelection )
7160 {
7161     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7162          m_currentCellCoords.GetCol() >= 0 )
7163     {
7164         if ( expandSelection )
7165         {
7166             if ( m_selectingKeyboard == wxGridNoCellCoords )
7167                 m_selectingKeyboard = m_currentCellCoords;
7168             if ( m_selectingKeyboard.GetCol() > 0 )
7169             {
7170                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
7171                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7172                         m_selectingKeyboard.GetCol() );
7173                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7174             }
7175         }
7176         else if ( m_currentCellCoords.GetCol() > 0 )
7177         {
7178             ClearSelection();
7179             MakeCellVisible( m_currentCellCoords.GetRow(),
7180                              m_currentCellCoords.GetCol() - 1 );
7181             SetCurrentCell( m_currentCellCoords.GetRow(),
7182                             m_currentCellCoords.GetCol() - 1 );
7183         }
7184         else
7185             return FALSE;
7186         return TRUE;
7187     }
7188
7189     return FALSE;
7190 }
7191
7192
7193 bool wxGrid::MoveCursorRight( bool expandSelection )
7194 {
7195     if ( m_currentCellCoords != wxGridNoCellCoords  &&
7196          m_currentCellCoords.GetCol() < m_numCols )
7197     {
7198         if ( expandSelection )
7199         {
7200             if ( m_selectingKeyboard == wxGridNoCellCoords )
7201                 m_selectingKeyboard = m_currentCellCoords;
7202             if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
7203             {
7204                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
7205                 MakeCellVisible( m_selectingKeyboard.GetRow(),
7206                         m_selectingKeyboard.GetCol() );
7207                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7208             }
7209         }
7210         else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
7211         {
7212             ClearSelection();
7213             MakeCellVisible( m_currentCellCoords.GetRow(),
7214                              m_currentCellCoords.GetCol() + 1 );
7215             SetCurrentCell( m_currentCellCoords.GetRow(),
7216                             m_currentCellCoords.GetCol() + 1 );
7217         }
7218         else
7219             return FALSE;
7220         return TRUE;
7221     }
7222
7223     return FALSE;
7224 }
7225
7226
7227 bool wxGrid::MovePageUp()
7228 {
7229     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7230
7231     int row = m_currentCellCoords.GetRow();
7232     if ( row > 0 )
7233     {
7234         int cw, ch;
7235         m_gridWin->GetClientSize( &cw, &ch );
7236
7237         int y = GetRowTop(row);
7238         int newRow = YToRow( y - ch + 1 );
7239         if ( newRow == -1 )
7240         {
7241             newRow = 0;
7242         }
7243         else if ( newRow == row )
7244         {
7245             newRow = row - 1;
7246         }
7247
7248         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7249         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7250
7251         return TRUE;
7252     }
7253
7254     return FALSE;
7255 }
7256
7257 bool wxGrid::MovePageDown()
7258 {
7259     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
7260
7261     int row = m_currentCellCoords.GetRow();
7262     if ( row < m_numRows )
7263     {
7264         int cw, ch;
7265         m_gridWin->GetClientSize( &cw, &ch );
7266
7267         int y = GetRowTop(row);
7268         int newRow = YToRow( y + ch );
7269         if ( newRow == -1 )
7270         {
7271             newRow = m_numRows - 1;
7272         }
7273         else if ( newRow == row )
7274         {
7275             newRow = row + 1;
7276         }
7277
7278         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
7279         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
7280
7281         return TRUE;
7282     }
7283
7284     return FALSE;
7285 }
7286
7287 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
7288 {
7289     if ( m_table &&
7290          m_currentCellCoords != wxGridNoCellCoords  &&
7291          m_currentCellCoords.GetRow() > 0 )
7292     {
7293         int row = m_currentCellCoords.GetRow();
7294         int col = m_currentCellCoords.GetCol();
7295
7296         if ( m_table->IsEmptyCell(row, col) )
7297         {
7298             // starting in an empty cell: find the next block of
7299             // non-empty cells
7300             //
7301             while ( row > 0 )
7302             {
7303                 row-- ;
7304                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7305             }
7306         }
7307         else if ( m_table->IsEmptyCell(row-1, col) )
7308         {
7309             // starting at the top of a block: find the next block
7310             //
7311             row--;
7312             while ( row > 0 )
7313             {
7314                 row-- ;
7315                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7316             }
7317         }
7318         else
7319         {
7320             // starting within a block: find the top of the block
7321             //
7322             while ( row > 0 )
7323             {
7324                 row-- ;
7325                 if ( m_table->IsEmptyCell(row, col) )
7326                 {
7327                     row++ ;
7328                     break;
7329                 }
7330             }
7331         }
7332
7333         MakeCellVisible( row, col );
7334         if ( expandSelection )
7335         {
7336             m_selectingKeyboard = wxGridCellCoords( row, col );
7337             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7338         }
7339         else
7340         {
7341             ClearSelection();
7342             SetCurrentCell( row, col );
7343         }
7344         return TRUE;
7345     }
7346
7347     return FALSE;
7348 }
7349
7350 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
7351 {
7352     if ( m_table &&
7353          m_currentCellCoords != wxGridNoCellCoords  &&
7354          m_currentCellCoords.GetRow() < m_numRows-1 )
7355     {
7356         int row = m_currentCellCoords.GetRow();
7357         int col = m_currentCellCoords.GetCol();
7358
7359         if ( m_table->IsEmptyCell(row, col) )
7360         {
7361             // starting in an empty cell: find the next block of
7362             // non-empty cells
7363             //
7364             while ( row < m_numRows-1 )
7365             {
7366                 row++ ;
7367                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7368             }
7369         }
7370         else if ( m_table->IsEmptyCell(row+1, col) )
7371         {
7372             // starting at the bottom of a block: find the next block
7373             //
7374             row++;
7375             while ( row < m_numRows-1 )
7376             {
7377                 row++ ;
7378                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7379             }
7380         }
7381         else
7382         {
7383             // starting within a block: find the bottom of the block
7384             //
7385             while ( row < m_numRows-1 )
7386             {
7387                 row++ ;
7388                 if ( m_table->IsEmptyCell(row, col) )
7389                 {
7390                     row-- ;
7391                     break;
7392                 }
7393             }
7394         }
7395
7396         MakeCellVisible( row, col );
7397         if ( expandSelection )
7398         {
7399             m_selectingKeyboard = wxGridCellCoords( row, col );
7400             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7401         }
7402         else
7403         {
7404             ClearSelection();
7405             SetCurrentCell( row, col );
7406         }
7407
7408         return TRUE;
7409     }
7410
7411     return FALSE;
7412 }
7413
7414 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
7415 {
7416     if ( m_table &&
7417          m_currentCellCoords != wxGridNoCellCoords  &&
7418          m_currentCellCoords.GetCol() > 0 )
7419     {
7420         int row = m_currentCellCoords.GetRow();
7421         int col = m_currentCellCoords.GetCol();
7422
7423         if ( m_table->IsEmptyCell(row, col) )
7424         {
7425             // starting in an empty cell: find the next block of
7426             // non-empty cells
7427             //
7428             while ( col > 0 )
7429             {
7430                 col-- ;
7431                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7432             }
7433         }
7434         else if ( m_table->IsEmptyCell(row, col-1) )
7435         {
7436             // starting at the left of a block: find the next block
7437             //
7438             col--;
7439             while ( col > 0 )
7440             {
7441                 col-- ;
7442                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7443             }
7444         }
7445         else
7446         {
7447             // starting within a block: find the left of the block
7448             //
7449             while ( col > 0 )
7450             {
7451                 col-- ;
7452                 if ( m_table->IsEmptyCell(row, col) )
7453                 {
7454                     col++ ;
7455                     break;
7456                 }
7457             }
7458         }
7459
7460         MakeCellVisible( row, col );
7461         if ( expandSelection )
7462         {
7463             m_selectingKeyboard = wxGridCellCoords( row, col );
7464             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7465         }
7466         else
7467         {
7468             ClearSelection();
7469             SetCurrentCell( row, col );
7470         }
7471
7472         return TRUE;
7473     }
7474
7475     return FALSE;
7476 }
7477
7478 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
7479 {
7480     if ( m_table &&
7481          m_currentCellCoords != wxGridNoCellCoords  &&
7482          m_currentCellCoords.GetCol() < m_numCols-1 )
7483     {
7484         int row = m_currentCellCoords.GetRow();
7485         int col = m_currentCellCoords.GetCol();
7486
7487         if ( m_table->IsEmptyCell(row, col) )
7488         {
7489             // starting in an empty cell: find the next block of
7490             // non-empty cells
7491             //
7492             while ( col < m_numCols-1 )
7493             {
7494                 col++ ;
7495                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7496             }
7497         }
7498         else if ( m_table->IsEmptyCell(row, col+1) )
7499         {
7500             // starting at the right of a block: find the next block
7501             //
7502             col++;
7503             while ( col < m_numCols-1 )
7504             {
7505                 col++ ;
7506                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7507             }
7508         }
7509         else
7510         {
7511             // starting within a block: find the right of the block
7512             //
7513             while ( col < m_numCols-1 )
7514             {
7515                 col++ ;
7516                 if ( m_table->IsEmptyCell(row, col) )
7517                 {
7518                     col-- ;
7519                     break;
7520                 }
7521             }
7522         }
7523
7524         MakeCellVisible( row, col );
7525         if ( expandSelection )
7526         {
7527             m_selectingKeyboard = wxGridCellCoords( row, col );
7528             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7529         }
7530         else
7531         {
7532             ClearSelection();
7533             SetCurrentCell( row, col );
7534         }
7535
7536         return TRUE;
7537     }
7538
7539     return FALSE;
7540 }
7541
7542
7543
7544 //
7545 // ------ Label values and formatting
7546 //
7547
7548 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
7549 {
7550     *horiz = m_rowLabelHorizAlign;
7551     *vert  = m_rowLabelVertAlign;
7552 }
7553
7554 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
7555 {
7556     *horiz = m_colLabelHorizAlign;
7557     *vert  = m_colLabelVertAlign;
7558 }
7559
7560 wxString wxGrid::GetRowLabelValue( int row )
7561 {
7562     if ( m_table )
7563     {
7564         return m_table->GetRowLabelValue( row );
7565     }
7566     else
7567     {
7568         wxString s;
7569         s << row;
7570         return s;
7571     }
7572 }
7573
7574 wxString wxGrid::GetColLabelValue( int col )
7575 {
7576     if ( m_table )
7577     {
7578         return m_table->GetColLabelValue( col );
7579     }
7580     else
7581     {
7582         wxString s;
7583         s << col;
7584         return s;
7585     }
7586 }
7587
7588
7589 void wxGrid::SetRowLabelSize( int width )
7590 {
7591     width = wxMax( width, 0 );
7592     if ( width != m_rowLabelWidth )
7593     {
7594         if ( width == 0 )
7595         {
7596             m_rowLabelWin->Show( FALSE );
7597             m_cornerLabelWin->Show( FALSE );
7598         }
7599         else if ( m_rowLabelWidth == 0 )
7600         {
7601             m_rowLabelWin->Show( TRUE );
7602             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
7603         }
7604
7605         m_rowLabelWidth = width;
7606         CalcWindowSizes();
7607         Refresh( TRUE );
7608     }
7609 }
7610
7611
7612 void wxGrid::SetColLabelSize( int height )
7613 {
7614     height = wxMax( height, 0 );
7615     if ( height != m_colLabelHeight )
7616     {
7617         if ( height == 0 )
7618         {
7619             m_colLabelWin->Show( FALSE );
7620             m_cornerLabelWin->Show( FALSE );
7621         }
7622         else if ( m_colLabelHeight == 0 )
7623         {
7624             m_colLabelWin->Show( TRUE );
7625             if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
7626         }
7627
7628         m_colLabelHeight = height;
7629         CalcWindowSizes();
7630         Refresh( TRUE );
7631     }
7632 }
7633
7634
7635 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
7636 {
7637     if ( m_labelBackgroundColour != colour )
7638     {
7639         m_labelBackgroundColour = colour;
7640         m_rowLabelWin->SetBackgroundColour( colour );
7641         m_colLabelWin->SetBackgroundColour( colour );
7642         m_cornerLabelWin->SetBackgroundColour( colour );
7643
7644         if ( !GetBatchCount() )
7645         {
7646             m_rowLabelWin->Refresh();
7647             m_colLabelWin->Refresh();
7648             m_cornerLabelWin->Refresh();
7649         }
7650     }
7651 }
7652
7653 void wxGrid::SetLabelTextColour( const wxColour& colour )
7654 {
7655     if ( m_labelTextColour != colour )
7656     {
7657         m_labelTextColour = colour;
7658         if ( !GetBatchCount() )
7659         {
7660             m_rowLabelWin->Refresh();
7661             m_colLabelWin->Refresh();
7662         }
7663     }
7664 }
7665
7666 void wxGrid::SetLabelFont( const wxFont& font )
7667 {
7668     m_labelFont = font;
7669     if ( !GetBatchCount() )
7670     {
7671         m_rowLabelWin->Refresh();
7672         m_colLabelWin->Refresh();
7673     }
7674 }
7675
7676 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
7677 {
7678     // allow old (incorrect) defs to be used
7679     switch ( horiz )
7680     {
7681         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7682         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7683         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7684     }
7685
7686     switch ( vert )
7687     {
7688         case wxTOP:    vert = wxALIGN_TOP;    break;
7689         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7690         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7691     }
7692
7693     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7694     {
7695         m_rowLabelHorizAlign = horiz;
7696     }
7697
7698     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7699     {
7700         m_rowLabelVertAlign = vert;
7701     }
7702
7703     if ( !GetBatchCount() )
7704     {
7705         m_rowLabelWin->Refresh();
7706     }
7707 }
7708
7709 void wxGrid::SetColLabelAlignment( int horiz, int vert )
7710 {
7711     // allow old (incorrect) defs to be used
7712     switch ( horiz )
7713     {
7714         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7715         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7716         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7717     }
7718
7719     switch ( vert )
7720     {
7721         case wxTOP:    vert = wxALIGN_TOP;    break;
7722         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7723         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7724     }
7725
7726     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7727     {
7728         m_colLabelHorizAlign = horiz;
7729     }
7730
7731     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7732     {
7733         m_colLabelVertAlign = vert;
7734     }
7735
7736     if ( !GetBatchCount() )
7737     {
7738         m_colLabelWin->Refresh();
7739     }
7740 }
7741
7742 void wxGrid::SetRowLabelValue( int row, const wxString& s )
7743 {
7744     if ( m_table )
7745     {
7746         m_table->SetRowLabelValue( row, s );
7747         if ( !GetBatchCount() )
7748         {
7749             wxRect rect = CellToRect( row, 0);
7750             if ( rect.height > 0 )
7751             {
7752                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
7753                 rect.x = 0;
7754                 rect.width = m_rowLabelWidth;
7755                 m_rowLabelWin->Refresh( TRUE, &rect );
7756             }
7757         }
7758     }
7759 }
7760
7761 void wxGrid::SetColLabelValue( int col, const wxString& s )
7762 {
7763     if ( m_table )
7764     {
7765         m_table->SetColLabelValue( col, s );
7766         if ( !GetBatchCount() )
7767         {
7768             wxRect rect = CellToRect( 0, col );
7769             if ( rect.width > 0 )
7770             {
7771                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
7772                 rect.y = 0;
7773                 rect.height = m_colLabelHeight;
7774                 m_colLabelWin->Refresh( TRUE, &rect );
7775             }
7776         }
7777     }
7778 }
7779
7780 void wxGrid::SetGridLineColour( const wxColour& colour )
7781 {
7782     if ( m_gridLineColour != colour )
7783     {
7784         m_gridLineColour = colour;
7785
7786         wxClientDC dc( m_gridWin );
7787         PrepareDC( dc );
7788         DrawAllGridLines( dc, wxRegion() );
7789     }
7790 }
7791
7792
7793 void wxGrid::SetCellHighlightColour( const wxColour& colour )
7794 {
7795     if ( m_cellHighlightColour != colour )
7796     {
7797         m_cellHighlightColour = colour;
7798
7799         wxClientDC dc( m_gridWin );
7800         PrepareDC( dc );
7801         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7802         DrawCellHighlight(dc, attr);
7803         attr->DecRef();
7804     }
7805 }
7806
7807 void wxGrid::SetCellHighlightPenWidth(int width)
7808 {
7809     if (m_cellHighlightPenWidth != width) {
7810         m_cellHighlightPenWidth = width;
7811
7812         // Just redrawing the cell highlight is not enough since that won't
7813         // make any visible change if the the thickness is getting smaller.
7814         int row = m_currentCellCoords.GetRow();
7815         int col = m_currentCellCoords.GetCol();
7816         if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7817             return;
7818         wxRect rect = CellToRect(row, col);
7819         m_gridWin->Refresh(TRUE, &rect);
7820     }
7821 }
7822
7823 void wxGrid::SetCellHighlightROPenWidth(int width)
7824 {
7825     if (m_cellHighlightROPenWidth != width) {
7826         m_cellHighlightROPenWidth = width;
7827
7828         // Just redrawing the cell highlight is not enough since that won't
7829         // make any visible change if the the thickness is getting smaller.
7830         int row = m_currentCellCoords.GetRow();
7831         int col = m_currentCellCoords.GetCol();
7832         if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7833             return;
7834         wxRect rect = CellToRect(row, col);
7835         m_gridWin->Refresh(TRUE, &rect);
7836     }
7837 }
7838
7839 void wxGrid::EnableGridLines( bool enable )
7840 {
7841     if ( enable != m_gridLinesEnabled )
7842     {
7843         m_gridLinesEnabled = enable;
7844
7845         if ( !GetBatchCount() )
7846         {
7847             if ( enable )
7848             {
7849                 wxClientDC dc( m_gridWin );
7850                 PrepareDC( dc );
7851                 DrawAllGridLines( dc, wxRegion() );
7852             }
7853             else
7854             {
7855                 m_gridWin->Refresh();
7856             }
7857         }
7858     }
7859 }
7860
7861
7862 int wxGrid::GetDefaultRowSize()
7863 {
7864     return m_defaultRowHeight;
7865 }
7866
7867 int wxGrid::GetRowSize( int row )
7868 {
7869     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
7870
7871     return GetRowHeight(row);
7872 }
7873
7874 int wxGrid::GetDefaultColSize()
7875 {
7876     return m_defaultColWidth;
7877 }
7878
7879 int wxGrid::GetColSize( int col )
7880 {
7881     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
7882
7883     return GetColWidth(col);
7884 }
7885
7886 // ============================================================================
7887 // access to the grid attributes: each of them has a default value in the grid
7888 // itself and may be overidden on a per-cell basis
7889 // ============================================================================
7890
7891 // ----------------------------------------------------------------------------
7892 // setting default attributes
7893 // ----------------------------------------------------------------------------
7894
7895 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7896 {
7897     m_defaultCellAttr->SetBackgroundColour(col);
7898 #ifdef __WXGTK__
7899     m_gridWin->SetBackgroundColour(col);
7900 #endif
7901 }
7902
7903 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7904 {
7905     m_defaultCellAttr->SetTextColour(col);
7906 }
7907
7908 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7909 {
7910     m_defaultCellAttr->SetAlignment(horiz, vert);
7911 }
7912
7913 void wxGrid::SetDefaultCellFont( const wxFont& font )
7914 {
7915     m_defaultCellAttr->SetFont(font);
7916 }
7917
7918 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7919 {
7920     m_defaultCellAttr->SetRenderer(renderer);
7921 }
7922
7923 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7924 {
7925     m_defaultCellAttr->SetEditor(editor);
7926 }
7927
7928 // ----------------------------------------------------------------------------
7929 // access to the default attrbiutes
7930 // ----------------------------------------------------------------------------
7931
7932 wxColour wxGrid::GetDefaultCellBackgroundColour()
7933 {
7934     return m_defaultCellAttr->GetBackgroundColour();
7935 }
7936
7937 wxColour wxGrid::GetDefaultCellTextColour()
7938 {
7939     return m_defaultCellAttr->GetTextColour();
7940 }
7941
7942 wxFont wxGrid::GetDefaultCellFont()
7943 {
7944     return m_defaultCellAttr->GetFont();
7945 }
7946
7947 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
7948 {
7949     m_defaultCellAttr->GetAlignment(horiz, vert);
7950 }
7951
7952 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7953 {
7954     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7955 }
7956
7957 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7958 {
7959     return m_defaultCellAttr->GetEditor(NULL,0,0);
7960 }
7961
7962 // ----------------------------------------------------------------------------
7963 // access to cell attributes
7964 // ----------------------------------------------------------------------------
7965
7966 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
7967 {
7968     wxGridCellAttr *attr = GetCellAttr(row, col);
7969     wxColour colour = attr->GetBackgroundColour();
7970     attr->DecRef();
7971     return colour;
7972 }
7973
7974 wxColour wxGrid::GetCellTextColour( int row, int col )
7975 {
7976     wxGridCellAttr *attr = GetCellAttr(row, col);
7977     wxColour colour = attr->GetTextColour();
7978     attr->DecRef();
7979     return colour;
7980 }
7981
7982 wxFont wxGrid::GetCellFont( int row, int col )
7983 {
7984     wxGridCellAttr *attr = GetCellAttr(row, col);
7985     wxFont font = attr->GetFont();
7986     attr->DecRef();
7987     return font;
7988 }
7989
7990 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
7991 {
7992     wxGridCellAttr *attr = GetCellAttr(row, col);
7993     attr->GetAlignment(horiz, vert);
7994     attr->DecRef();
7995 }
7996
7997 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
7998 {
7999     wxGridCellAttr* attr = GetCellAttr(row, col);
8000     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8001     attr->DecRef();
8002
8003     return renderer;
8004 }
8005
8006 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
8007 {
8008     wxGridCellAttr* attr = GetCellAttr(row, col);
8009     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8010     attr->DecRef();
8011
8012     return editor;
8013 }
8014
8015 bool wxGrid::IsReadOnly(int row, int col) const
8016 {
8017     wxGridCellAttr* attr = GetCellAttr(row, col);
8018     bool isReadOnly = attr->IsReadOnly();
8019     attr->DecRef();
8020     return isReadOnly;
8021 }
8022
8023 // ----------------------------------------------------------------------------
8024 // attribute support: cache, automatic provider creation, ...
8025 // ----------------------------------------------------------------------------
8026
8027 bool wxGrid::CanHaveAttributes()
8028 {
8029     if ( !m_table )
8030     {
8031         return FALSE;
8032     }
8033
8034     return m_table->CanHaveAttributes();
8035 }
8036
8037 void wxGrid::ClearAttrCache()
8038 {
8039     if ( m_attrCache.row != -1 )
8040     {
8041         wxSafeDecRef(m_attrCache.attr);
8042         m_attrCache.attr = NULL;
8043         m_attrCache.row = -1;
8044     }
8045 }
8046
8047 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
8048 {
8049     wxGrid *self = (wxGrid *)this;  // const_cast
8050
8051     self->ClearAttrCache();
8052     self->m_attrCache.row = row;
8053     self->m_attrCache.col = col;
8054     self->m_attrCache.attr = attr;
8055     wxSafeIncRef(attr);
8056 }
8057
8058 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
8059 {
8060     if ( row == m_attrCache.row && col == m_attrCache.col )
8061     {
8062         *attr = m_attrCache.attr;
8063         wxSafeIncRef(m_attrCache.attr);
8064
8065 #ifdef DEBUG_ATTR_CACHE
8066         gs_nAttrCacheHits++;
8067 #endif
8068
8069         return TRUE;
8070     }
8071     else
8072     {
8073 #ifdef DEBUG_ATTR_CACHE
8074         gs_nAttrCacheMisses++;
8075 #endif
8076         return FALSE;
8077     }
8078 }
8079
8080 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
8081 {
8082     wxGridCellAttr *attr;
8083     if ( !LookupAttr(row, col, &attr) )
8084     {
8085         attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any) : (wxGridCellAttr *)NULL;
8086         CacheAttr(row, col, attr);
8087     }
8088     if (attr)
8089     {
8090         attr->SetDefAttr(m_defaultCellAttr);
8091     }
8092     else
8093     {
8094         attr = m_defaultCellAttr;
8095         attr->IncRef();
8096     }
8097
8098     return attr;
8099 }
8100
8101 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
8102 {
8103     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8104         wxASSERT_MSG( m_table,
8105                       _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8106
8107     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell );
8108         if ( !attr )
8109         {
8110             attr = new wxGridCellAttr;
8111
8112             // artificially inc the ref count to match DecRef() in caller
8113             attr->IncRef();
8114             m_table->SetAttr(attr, row, col);
8115         }
8116     attr->SetDefAttr(m_defaultCellAttr);
8117     return attr;
8118 }
8119
8120 // ----------------------------------------------------------------------------
8121 // setting column attributes (wrappers around SetColAttr)
8122 // ----------------------------------------------------------------------------
8123
8124 void wxGrid::SetColFormatBool(int col)
8125 {
8126     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
8127 }
8128
8129 void wxGrid::SetColFormatNumber(int col)
8130 {
8131     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
8132 }
8133
8134 void wxGrid::SetColFormatFloat(int col, int width, int precision)
8135 {
8136     wxString typeName = wxGRID_VALUE_FLOAT;
8137     if ( (width != -1) || (precision != -1) )
8138     {
8139         typeName << _T(':') << width << _T(',') << precision;
8140     }
8141
8142     SetColFormatCustom(col, typeName);
8143 }
8144
8145 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
8146 {
8147     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8148
8149     attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
8150     if(!attr)
8151         attr = new wxGridCellAttr;
8152     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
8153     attr->SetRenderer(renderer);
8154
8155     SetColAttr(col, attr);
8156
8157 }
8158
8159 // ----------------------------------------------------------------------------
8160 // setting cell attributes: this is forwarded to the table
8161 // ----------------------------------------------------------------------------
8162
8163 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
8164 {
8165     if ( CanHaveAttributes() )
8166     {
8167         m_table->SetRowAttr(attr, row);
8168         ClearAttrCache();
8169     }
8170     else
8171     {
8172         wxSafeDecRef(attr);
8173     }
8174 }
8175
8176 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
8177 {
8178     if ( CanHaveAttributes() )
8179     {
8180         m_table->SetColAttr(attr, col);
8181         ClearAttrCache();
8182     }
8183     else
8184     {
8185         wxSafeDecRef(attr);
8186     }
8187 }
8188
8189 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
8190 {
8191     if ( CanHaveAttributes() )
8192     {
8193         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8194         attr->SetBackgroundColour(colour);
8195         attr->DecRef();
8196     }
8197 }
8198
8199 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
8200 {
8201     if ( CanHaveAttributes() )
8202     {
8203         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8204         attr->SetTextColour(colour);
8205         attr->DecRef();
8206     }
8207 }
8208
8209 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
8210 {
8211     if ( CanHaveAttributes() )
8212     {
8213         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8214         attr->SetFont(font);
8215         attr->DecRef();
8216     }
8217 }
8218
8219 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
8220 {
8221     if ( CanHaveAttributes() )
8222     {
8223         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8224         attr->SetAlignment(horiz, vert);
8225         attr->DecRef();
8226     }
8227 }
8228
8229 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
8230 {
8231     if ( CanHaveAttributes() )
8232     {
8233         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8234         attr->SetRenderer(renderer);
8235         attr->DecRef();
8236     }
8237 }
8238
8239 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
8240 {
8241     if ( CanHaveAttributes() )
8242     {
8243         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8244         attr->SetEditor(editor);
8245         attr->DecRef();
8246     }
8247 }
8248
8249 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
8250 {
8251     if ( CanHaveAttributes() )
8252     {
8253         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
8254         attr->SetReadOnly(isReadOnly);
8255         attr->DecRef();
8256     }
8257 }
8258
8259 // ----------------------------------------------------------------------------
8260 // Data type registration
8261 // ----------------------------------------------------------------------------
8262
8263 void wxGrid::RegisterDataType(const wxString& typeName,
8264                               wxGridCellRenderer* renderer,
8265                               wxGridCellEditor* editor)
8266 {
8267     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
8268 }
8269
8270
8271 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
8272 {
8273     wxString typeName = m_table->GetTypeName(row, col);
8274     return GetDefaultEditorForType(typeName);
8275 }
8276
8277 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
8278 {
8279     wxString typeName = m_table->GetTypeName(row, col);
8280     return GetDefaultRendererForType(typeName);
8281 }
8282
8283 wxGridCellEditor*
8284 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
8285 {
8286     int index = m_typeRegistry->FindOrCloneDataType(typeName);
8287     if ( index == wxNOT_FOUND )
8288     {
8289         wxFAIL_MSG(wxT("Unknown data type name"));
8290
8291         return NULL;
8292     }
8293
8294     return m_typeRegistry->GetEditor(index);
8295 }
8296
8297 wxGridCellRenderer*
8298 wxGrid::GetDefaultRendererForType(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->GetRenderer(index);
8309 }
8310
8311
8312 // ----------------------------------------------------------------------------
8313 // row/col size
8314 // ----------------------------------------------------------------------------
8315
8316 void wxGrid::EnableDragRowSize( bool enable )
8317 {
8318     m_canDragRowSize = enable;
8319 }
8320
8321
8322 void wxGrid::EnableDragColSize( bool enable )
8323 {
8324     m_canDragColSize = enable;
8325 }
8326
8327 void wxGrid::EnableDragGridSize( bool enable )
8328 {
8329     m_canDragGridSize = enable;
8330 }
8331
8332
8333 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
8334 {
8335     m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
8336
8337     if ( resizeExistingRows )
8338     {
8339         InitRowHeights();
8340         if ( !GetBatchCount() )
8341             CalcDimensions();
8342     }
8343 }
8344
8345 void wxGrid::SetRowSize( int row, int height )
8346 {
8347     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
8348
8349     if ( m_rowHeights.IsEmpty() )
8350     {
8351         // need to really create the array
8352         InitRowHeights();
8353     }
8354
8355     int h = wxMax( 0, height );
8356     int diff = h - m_rowHeights[row];
8357
8358     m_rowHeights[row] = h;
8359     int i;
8360     for ( i = row;  i < m_numRows;  i++ )
8361     {
8362         m_rowBottoms[i] += diff;
8363     }
8364     if ( !GetBatchCount() )
8365         CalcDimensions();
8366 }
8367
8368 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
8369 {
8370     m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
8371
8372     if ( resizeExistingCols )
8373     {
8374         InitColWidths();
8375         if ( !GetBatchCount() )
8376             CalcDimensions();
8377     }
8378 }
8379
8380 void wxGrid::SetColSize( int col, int width )
8381 {
8382     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
8383
8384     // should we check that it's bigger than GetColMinimalWidth(col) here?
8385
8386     if ( m_colWidths.IsEmpty() )
8387     {
8388         // need to really create the array
8389         InitColWidths();
8390     }
8391
8392     int w = wxMax( 0, width );
8393     int diff = w - m_colWidths[col];
8394     m_colWidths[col] = w;
8395
8396     int i;
8397     for ( i = col;  i < m_numCols;  i++ )
8398     {
8399         m_colRights[i] += diff;
8400     }
8401     if ( !GetBatchCount() )
8402         CalcDimensions();
8403 }
8404
8405
8406 void wxGrid::SetColMinimalWidth( int col, int width )
8407 {
8408     m_colMinWidths.Put(col, width);
8409 }
8410
8411 void wxGrid::SetRowMinimalHeight( int row, int width )
8412 {
8413     m_rowMinHeights.Put(row, width);
8414 }
8415
8416 int wxGrid::GetColMinimalWidth(int col) const
8417 {
8418     long value = m_colMinWidths.Get(col);
8419     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
8420 }
8421
8422 int wxGrid::GetRowMinimalHeight(int row) const
8423 {
8424     long value = m_rowMinHeights.Get(row);
8425     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
8426 }
8427
8428 // ----------------------------------------------------------------------------
8429 // auto sizing
8430 // ----------------------------------------------------------------------------
8431
8432 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
8433 {
8434     wxClientDC dc(m_gridWin);
8435
8436     // init both of them to avoid compiler warnings, even if weo nly need one
8437     int row = -1,
8438         col = -1;
8439     if ( column )
8440         col = colOrRow;
8441     else
8442         row = colOrRow;
8443
8444     wxCoord extent, extentMax = 0;
8445     int max = column ? m_numRows : m_numCols;
8446     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
8447     {
8448         if ( column )
8449             row = rowOrCol;
8450         else
8451             col = rowOrCol;
8452
8453         wxGridCellAttr* attr = GetCellAttr(row, col);
8454         wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8455         if ( renderer )
8456         {
8457             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
8458             extent = column ? size.x : size.y;
8459             if ( extent > extentMax )
8460             {
8461                 extentMax = extent;
8462             }
8463
8464             renderer->DecRef();
8465         }
8466
8467         attr->DecRef();
8468     }
8469
8470     // now also compare with the column label extent
8471     wxCoord w, h;
8472     dc.SetFont( GetLabelFont() );
8473
8474     if ( column )
8475         dc.GetTextExtent( GetColLabelValue(col), &w, &h );
8476     else
8477         dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
8478
8479     extent = column ? w : h;
8480     if ( extent > extentMax )
8481     {
8482         extentMax = extent;
8483     }
8484
8485     if ( !extentMax )
8486     {
8487         // empty column - give default extent (notice that if extentMax is less
8488         // than default extent but != 0, it's ok)
8489         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
8490     }
8491     else
8492     {
8493         if ( column )
8494         {
8495             // leave some space around text
8496             extentMax += 10;
8497         }
8498         else
8499         {
8500             extentMax += 6;
8501         }
8502     }
8503
8504     if ( column )
8505     {
8506         SetColSize(col, extentMax);
8507         if ( !GetBatchCount() )
8508         {
8509             int cw, ch, dummy;
8510             m_gridWin->GetClientSize( &cw, &ch );
8511             wxRect rect ( CellToRect( 0, col ) );
8512             rect.y = 0;
8513             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
8514             rect.width = cw - rect.x;
8515             rect.height = m_colLabelHeight;
8516             m_colLabelWin->Refresh( TRUE, &rect );
8517         }
8518     }
8519     else
8520     {
8521         SetRowSize(row, extentMax);
8522         if ( !GetBatchCount() )
8523         {
8524             int cw, ch, dummy;
8525             m_gridWin->GetClientSize( &cw, &ch );
8526             wxRect rect ( CellToRect( row, 0 ) );
8527             rect.x = 0;
8528             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8529             rect.width = m_rowLabelWidth;
8530             rect.height = ch - rect.y;
8531             m_rowLabelWin->Refresh( TRUE, &rect );
8532         }
8533     }
8534     if ( setAsMin )
8535     {
8536         if ( column )
8537             SetColMinimalWidth(col, extentMax);
8538         else
8539             SetRowMinimalHeight(row, extentMax);
8540     }
8541 }
8542
8543 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8544 {
8545     int width = m_rowLabelWidth;
8546
8547     if ( !calcOnly )
8548         BeginBatch();
8549
8550     for ( int col = 0; col < m_numCols; col++ )
8551     {
8552         if ( !calcOnly )
8553         {
8554             AutoSizeColumn(col, setAsMin);
8555         }
8556
8557         width += GetColWidth(col);
8558     }
8559
8560     if ( !calcOnly )
8561         EndBatch();
8562
8563     return width;
8564 }
8565
8566 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8567 {
8568     int height = m_colLabelHeight;
8569
8570     if ( !calcOnly )
8571         BeginBatch();
8572
8573     for ( int row = 0; row < m_numRows; row++ )
8574     {
8575         if ( !calcOnly )
8576         {
8577             AutoSizeRow(row, setAsMin);
8578         }
8579
8580         height += GetRowHeight(row);
8581     }
8582
8583     if ( !calcOnly )
8584         EndBatch();
8585
8586     return height;
8587 }
8588
8589 void wxGrid::AutoSize()
8590 {
8591     BeginBatch();
8592
8593     wxSize size(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
8594
8595     // round up the size to a multiple of scroll step - this ensures that we
8596     // won't get the scrollbars if we're sized exactly to this width
8597     wxSize sizeFit(GetScrollX(size.x) * GRID_SCROLL_LINE_X,
8598                    GetScrollY(size.y) * GRID_SCROLL_LINE_Y);
8599
8600     // distribute the extra space between teh columns/rows to avoid having
8601     // extra white space
8602     wxCoord diff = sizeFit.x - size.x;
8603     if ( diff )
8604     {
8605         // try to resize the columns uniformly
8606         wxCoord diffPerCol = diff / m_numCols;
8607         if ( diffPerCol )
8608         {
8609             for ( int col = 0; col < m_numCols; col++ )
8610             {
8611                 SetColSize(col, GetColWidth(col) + diffPerCol);
8612             }
8613         }
8614
8615         // add remaining amount to the last columns
8616         diff -= diffPerCol * m_numCols;
8617         if ( diff )
8618         {
8619             for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
8620             {
8621                 SetColSize(col, GetColWidth(col) + 1);
8622             }
8623         }
8624     }
8625
8626     // same for rows
8627     diff = sizeFit.y - size.y;
8628     if ( diff )
8629     {
8630         // try to resize the columns uniformly
8631         wxCoord diffPerRow = diff / m_numRows;
8632         if ( diffPerRow )
8633         {
8634             for ( int row = 0; row < m_numRows; row++ )
8635             {
8636                 SetRowSize(row, GetRowHeight(row) + diffPerRow);
8637             }
8638         }
8639
8640         // add remaining amount to the last rows
8641         diff -= diffPerRow * m_numRows;
8642         if ( diff )
8643         {
8644             for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
8645             {
8646                 SetRowSize(row, GetRowHeight(row) + 1);
8647             }
8648         }
8649     }
8650
8651     EndBatch();
8652
8653     SetClientSize(sizeFit);
8654 }
8655
8656 wxSize wxGrid::DoGetBestSize() const
8657 {
8658     // don't set sizes, only calculate them
8659     wxGrid *self = (wxGrid *)this;  // const_cast
8660
8661     return wxSize(self->SetOrCalcColumnSizes(TRUE),
8662                   self->SetOrCalcRowSizes(TRUE));
8663 }
8664
8665 void wxGrid::Fit()
8666 {
8667     AutoSize();
8668 }
8669
8670
8671 wxPen& wxGrid::GetDividerPen() const
8672 {
8673     return wxNullPen;
8674 }
8675
8676 // ----------------------------------------------------------------------------
8677 // cell value accessor functions
8678 // ----------------------------------------------------------------------------
8679
8680 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8681 {
8682     if ( m_table )
8683     {
8684         m_table->SetValue( row, col, s );
8685         if ( !GetBatchCount() )
8686         {
8687             wxClientDC dc( m_gridWin );
8688             PrepareDC( dc );
8689             DrawCell( dc, wxGridCellCoords(row, col) );
8690         }
8691
8692         if ( m_currentCellCoords.GetRow() == row &&
8693              m_currentCellCoords.GetCol() == col &&
8694              IsCellEditControlShown())
8695              // Note: If we are using IsCellEditControlEnabled,
8696              // this interacts badly with calling SetCellValue from
8697              // an EVT_GRID_CELL_CHANGE handler.
8698         {
8699             HideCellEditControl();
8700             ShowCellEditControl(); // will reread data from table
8701         }
8702     }
8703 }
8704
8705
8706 //
8707 // ------ Block, row and col selection
8708 //
8709
8710 void wxGrid::SelectRow( int row, bool addToSelected )
8711 {
8712     if ( IsSelection() && !addToSelected )
8713         ClearSelection();
8714
8715     m_selection->SelectRow( row, FALSE, addToSelected );
8716 }
8717
8718
8719 void wxGrid::SelectCol( int col, bool addToSelected )
8720 {
8721     if ( IsSelection() && !addToSelected )
8722         ClearSelection();
8723
8724     m_selection->SelectCol( col, FALSE, addToSelected );
8725 }
8726
8727
8728 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
8729                           bool addToSelected )
8730 {
8731     if ( IsSelection() && !addToSelected )
8732         ClearSelection();
8733
8734     m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
8735                               FALSE, addToSelected );
8736 }
8737
8738
8739 void wxGrid::SelectAll()
8740 {
8741     if ( m_numRows > 0 && m_numCols > 0 )
8742         m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
8743 }
8744
8745 //
8746 // ------ Cell, row and col deselection
8747 //
8748
8749 void wxGrid::DeselectRow( int row )
8750 {
8751     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
8752     {
8753         if ( m_selection->IsInSelection(row, 0 ) )
8754             m_selection->ToggleCellSelection( row, 0);
8755     }
8756     else
8757     {
8758         int nCols = GetNumberCols();
8759         for ( int i = 0; i < nCols ; i++ )
8760         {
8761             if ( m_selection->IsInSelection(row, i ) )
8762                 m_selection->ToggleCellSelection( row, i);
8763         }
8764     }
8765 }
8766
8767 void wxGrid::DeselectCol( int col )
8768 {
8769     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
8770     {
8771         if ( m_selection->IsInSelection(0, col ) )
8772             m_selection->ToggleCellSelection( 0, col);
8773     }
8774     else
8775     {
8776         int nRows = GetNumberRows();
8777         for ( int i = 0; i < nRows ; i++ )
8778         {
8779             if ( m_selection->IsInSelection(i, col ) )
8780                 m_selection->ToggleCellSelection(i, col);
8781         }
8782     }
8783 }
8784
8785 void wxGrid::DeselectCell( int row, int col )
8786 {
8787     if ( m_selection->IsInSelection(row, col) )
8788         m_selection->ToggleCellSelection(row, col);
8789 }
8790
8791 bool wxGrid::IsSelection()
8792 {
8793     return ( m_selection->IsSelection() ||
8794              ( m_selectingTopLeft != wxGridNoCellCoords &&
8795                m_selectingBottomRight != wxGridNoCellCoords ) );
8796 }
8797
8798 bool wxGrid::IsInSelection( int row, int col )
8799 {
8800     return ( m_selection->IsInSelection( row, col ) ||
8801              ( row >= m_selectingTopLeft.GetRow() &&
8802                col >= m_selectingTopLeft.GetCol() &&
8803                row <= m_selectingBottomRight.GetRow() &&
8804                col <= m_selectingBottomRight.GetCol() ) );
8805 }
8806
8807 void wxGrid::ClearSelection()
8808 {
8809     m_selectingTopLeft = wxGridNoCellCoords;
8810     m_selectingBottomRight = wxGridNoCellCoords;
8811     m_selection->ClearSelection();
8812 }
8813
8814
8815 // This function returns the rectangle that encloses the given block
8816 // in device coords clipped to the client size of the grid window.
8817 //
8818 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
8819                                   const wxGridCellCoords &bottomRight )
8820 {
8821     wxRect rect( wxGridNoCellRect );
8822     wxRect cellRect;
8823
8824     cellRect = CellToRect( topLeft );
8825     if ( cellRect != wxGridNoCellRect )
8826     {
8827         rect = cellRect;
8828     }
8829     else
8830     {
8831         rect = wxRect( 0, 0, 0, 0 );
8832     }
8833
8834     cellRect = CellToRect( bottomRight );
8835     if ( cellRect != wxGridNoCellRect )
8836     {
8837         rect += cellRect;
8838     }
8839     else
8840     {
8841         return wxGridNoCellRect;
8842     }
8843
8844     // convert to scrolled coords
8845     //
8846     int left, top, right, bottom;
8847     CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
8848     CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
8849
8850     int cw, ch;
8851     m_gridWin->GetClientSize( &cw, &ch );
8852
8853     if (right < 0 || bottom < 0 || left > cw || top > ch)
8854         return wxRect( 0, 0, 0, 0);
8855
8856     rect.SetLeft( wxMax(0, left) );
8857     rect.SetTop( wxMax(0, top) );
8858     rect.SetRight( wxMin(cw, right) );
8859     rect.SetBottom( wxMin(ch, bottom) );
8860
8861     return rect;
8862 }
8863
8864
8865
8866 //
8867 // ------ Grid event classes
8868 //
8869
8870 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8871
8872 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8873                           int row, int col, int x, int y, bool sel,
8874                           bool control, bool shift, bool alt, bool meta )
8875         : wxNotifyEvent( type, id )
8876 {
8877     m_row = row;
8878     m_col = col;
8879     m_x = x;
8880     m_y = y;
8881     m_selecting = sel;
8882     m_control = control;
8883     m_shift = shift;
8884     m_alt = alt;
8885     m_meta = meta;
8886
8887     SetEventObject(obj);
8888 }
8889
8890
8891 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8892
8893 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8894                                   int rowOrCol, int x, int y,
8895                                   bool control, bool shift, bool alt, bool meta )
8896         : wxNotifyEvent( type, id )
8897 {
8898     m_rowOrCol = rowOrCol;
8899     m_x = x;
8900     m_y = y;
8901     m_control = control;
8902     m_shift = shift;
8903     m_alt = alt;
8904     m_meta = meta;
8905
8906     SetEventObject(obj);
8907 }
8908
8909
8910 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8911
8912 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8913                                                const wxGridCellCoords& topLeft,
8914                                                const wxGridCellCoords& bottomRight,
8915                                                bool sel, bool control,
8916                                                bool shift, bool alt, bool meta )
8917         : wxNotifyEvent( type, id )
8918 {
8919     m_topLeft     = topLeft;
8920     m_bottomRight = bottomRight;
8921     m_selecting   = sel;
8922     m_control     = control;
8923     m_shift       = shift;
8924     m_alt         = alt;
8925     m_meta        = meta;
8926
8927     SetEventObject(obj);
8928 }
8929
8930
8931 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8932
8933 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8934                                                    wxObject* obj, int row,
8935                                                    int col, wxControl* ctrl)
8936     : wxCommandEvent(type, id)
8937 {
8938     SetEventObject(obj);
8939     m_row = row;
8940     m_col = col;
8941     m_ctrl = ctrl;
8942 }
8943
8944
8945 #endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
8946
8947 #endif // wxUSE_GRID
8948