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