src/generic/grid.cpp

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