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