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