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->DrawAllGridLines( dc, reg );
4353
4354     m_owner->DrawGridSpace( dc );
4355     m_owner->DrawHighlight( dc, dirtyCells );
4356 }
4357
4358 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
4359 {
4360     wxWindow::ScrollWindow( dx, dy, rect );
4361     m_rowLabelWin->ScrollWindow( 0, dy, rect );
4362     m_colLabelWin->ScrollWindow( dx, 0, rect );
4363 }
4364
4365 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
4366 {
4367     if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
4368         SetFocus();
4369
4370     m_owner->ProcessGridCellMouseEvent( event );
4371 }
4372
4373 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
4374 {
4375     m_owner->GetEventHandler()->ProcessEvent( event );
4376 }
4377
4378 // This seems to be required for wxMotif/wxGTK otherwise the mouse
4379 // cursor must be in the cell edit control to get key events
4380 //
4381 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
4382 {
4383     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4384         event.Skip();
4385 }
4386
4387 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
4388 {
4389     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4390         event.Skip();
4391 }
4392
4393 void wxGridWindow::OnChar( wxKeyEvent& event )
4394 {
4395     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4396         event.Skip();
4397 }
4398
4399 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
4400 {
4401 }
4402
4403 void wxGridWindow::OnFocus(wxFocusEvent& event)
4404 {
4405     // and if we have any selection, it has to be repainted, because it
4406     // uses different colour when the grid is not focused:
4407     if ( m_owner->IsSelection() )
4408     {
4409         Refresh();
4410     }
4411     else
4412     {
4413         // NB: Note that this code is in "else" branch only because the other
4414         //     branch refreshes everything and so there's no point in calling
4415         //     Refresh() again, *not* because it should only be done if
4416         //     !IsSelection(). If the above code is ever optimized to refresh
4417         //     only selected area, this needs to be moved out of the "else"
4418         //     branch so that it's always executed.
4419
4420         // current cell cursor {dis,re}appears on focus change:
4421         const wxGridCellCoords cursorCoords(m_owner->GetGridCursorRow(),
4422                                             m_owner->GetGridCursorCol());
4423         const wxRect cursor =
4424             m_owner->BlockToDeviceRect(cursorCoords, cursorCoords);
4425         Refresh(true, &cursor);
4426     }
4427
4428     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4429         event.Skip();
4430 }
4431
4432 #define internalXToCol(x) XToCol(x, true)
4433 #define internalYToRow(y) YToRow(y, true)
4434
4435 /////////////////////////////////////////////////////////////////////
4436
4437 #if wxUSE_EXTENDED_RTTI
4438 WX_DEFINE_FLAGS( wxGridStyle )
4439
4440 wxBEGIN_FLAGS( wxGridStyle )
4441     // new style border flags, we put them first to
4442     // use them for streaming out
4443     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
4444     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
4445     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
4446     wxFLAGS_MEMBER(wxBORDER_RAISED)
4447     wxFLAGS_MEMBER(wxBORDER_STATIC)
4448     wxFLAGS_MEMBER(wxBORDER_NONE)
4449
4450     // old style border flags
4451     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
4452     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
4453     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
4454     wxFLAGS_MEMBER(wxRAISED_BORDER)
4455     wxFLAGS_MEMBER(wxSTATIC_BORDER)
4456     wxFLAGS_MEMBER(wxBORDER)
4457
4458     // standard window styles
4459     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
4460     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
4461     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
4462     wxFLAGS_MEMBER(wxWANTS_CHARS)
4463     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
4464     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB)
4465     wxFLAGS_MEMBER(wxVSCROLL)
4466     wxFLAGS_MEMBER(wxHSCROLL)
4467
4468 wxEND_FLAGS( wxGridStyle )
4469
4470 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow,"wx/grid.h")
4471
4472 wxBEGIN_PROPERTIES_TABLE(wxGrid)
4473     wxHIDE_PROPERTY( Children )
4474     wxPROPERTY_FLAGS( WindowStyle , wxGridStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
4475 wxEND_PROPERTIES_TABLE()
4476
4477 wxBEGIN_HANDLERS_TABLE(wxGrid)
4478 wxEND_HANDLERS_TABLE()
4479
4480 wxCONSTRUCTOR_5( wxGrid , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
4481
4482 /*
4483  TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
4484 */
4485 #else
4486 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
4487 #endif
4488
4489 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
4490     EVT_PAINT( wxGrid::OnPaint )
4491     EVT_SIZE( wxGrid::OnSize )
4492     EVT_KEY_DOWN( wxGrid::OnKeyDown )
4493     EVT_KEY_UP( wxGrid::OnKeyUp )
4494     EVT_CHAR ( wxGrid::OnChar )
4495     EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
4496 END_EVENT_TABLE()
4497
4498 wxGrid::wxGrid()
4499 {
4500     InitVars();
4501 }
4502
4503 wxGrid::wxGrid( wxWindow *parent,
4504                  wxWindowID id,
4505                  const wxPoint& pos,
4506                  const wxSize& size,
4507                  long style,
4508                  const wxString& name )
4509 {
4510     InitVars();
4511     Create(parent, id, pos, size, style, name);
4512 }
4513
4514 bool wxGrid::Create(wxWindow *parent, wxWindowID id,
4515                           const wxPoint& pos, const wxSize& size,
4516                           long style, const wxString& name)
4517 {
4518     if (!wxScrolledWindow::Create(parent, id, pos, size,
4519                                   style | wxWANTS_CHARS, name))
4520         return false;
4521
4522     m_colMinWidths = wxLongToLongHashMap(GRID_HASH_SIZE);
4523     m_rowMinHeights = wxLongToLongHashMap(GRID_HASH_SIZE);
4524
4525     Create();
4526     SetInitialSize(size);
4527     SetScrollRate(m_scrollLineX, m_scrollLineY);
4528     CalcDimensions();
4529
4530     return true;
4531 }
4532
4533 wxGrid::~wxGrid()
4534 {
4535     // Ensure that the editor control is destroyed before the grid is,
4536     // otherwise we crash later when the editor tries to do something with the
4537     // half destroyed grid
4538     HideCellEditControl();
4539
4540     // Must do this or ~wxScrollHelper will pop the wrong event handler
4541     SetTargetWindow(this);
4542     ClearAttrCache();
4543     wxSafeDecRef(m_defaultCellAttr);
4544
4545 #ifdef DEBUG_ATTR_CACHE
4546     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
4547     wxPrintf(_T("wxGrid attribute cache statistics: "
4548                 "total: %u, hits: %u (%u%%)\n"),
4549              total, gs_nAttrCacheHits,
4550              total ? (gs_nAttrCacheHits*100) / total : 0);
4551 #endif
4552
4553     // if we own the table, just delete it, otherwise at least don't leave it
4554     // with dangling view pointer
4555     if ( m_ownTable )
4556         delete m_table;
4557     else if ( m_table && m_table->GetView() == this )
4558         m_table->SetView(NULL);
4559
4560     delete m_typeRegistry;
4561     delete m_selection;
4562 }
4563
4564 //
4565 // ----- internal init and update functions
4566 //
4567
4568 // NOTE: If using the default visual attributes works everywhere then this can
4569 // be removed as well as the #else cases below.
4570 #define _USE_VISATTR 0
4571
4572 void wxGrid::Create()
4573 {
4574     // create the type registry
4575     m_typeRegistry = new wxGridTypeRegistry;
4576
4577     m_cellEditCtrlEnabled = false;
4578
4579     m_defaultCellAttr = new wxGridCellAttr();
4580
4581     // Set default cell attributes
4582     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
4583     m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
4584     m_defaultCellAttr->SetFont(GetFont());
4585     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
4586     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
4587     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
4588
4589 #if _USE_VISATTR
4590     wxVisualAttributes gva = wxListBox::GetClassDefaultAttributes();
4591     wxVisualAttributes lva = wxPanel::GetClassDefaultAttributes();
4592
4593     m_defaultCellAttr->SetTextColour(gva.colFg);
4594     m_defaultCellAttr->SetBackgroundColour(gva.colBg);
4595
4596 #else
4597     m_defaultCellAttr->SetTextColour(
4598         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
4599     m_defaultCellAttr->SetBackgroundColour(
4600         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
4601 #endif
4602
4603     m_numRows = 0;
4604     m_numCols = 0;
4605     m_currentCellCoords = wxGridNoCellCoords;
4606
4607     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
4608     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
4609
4610     // subwindow components that make up the wxGrid
4611     m_rowLabelWin = new wxGridRowLabelWindow( this,
4612                                               wxID_ANY,
4613                                               wxDefaultPosition,
4614                                               wxDefaultSize );
4615
4616     m_colLabelWin = new wxGridColLabelWindow( this,
4617                                               wxID_ANY,
4618                                               wxDefaultPosition,
4619                                               wxDefaultSize );
4620
4621     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
4622                                                     wxID_ANY,
4623                                                     wxDefaultPosition,
4624                                                     wxDefaultSize );
4625
4626     m_gridWin = new wxGridWindow( this,
4627                                   m_rowLabelWin,
4628                                   m_colLabelWin,
4629                                   wxID_ANY,
4630                                   wxDefaultPosition,
4631                                   wxDefaultSize );
4632
4633     SetTargetWindow( m_gridWin );
4634
4635 #if _USE_VISATTR
4636     wxColour gfg = gva.colFg;
4637     wxColour gbg = gva.colBg;
4638     wxColour lfg = lva.colFg;
4639     wxColour lbg = lva.colBg;
4640 #else
4641     wxColour gfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
4642     wxColour gbg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
4643     wxColour lfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
4644     wxColour lbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
4645 #endif
4646
4647     m_cornerLabelWin->SetOwnForegroundColour(lfg);
4648     m_cornerLabelWin->SetOwnBackgroundColour(lbg);
4649     m_rowLabelWin->SetOwnForegroundColour(lfg);
4650     m_rowLabelWin->SetOwnBackgroundColour(lbg);
4651     m_colLabelWin->SetOwnForegroundColour(lfg);
4652     m_colLabelWin->SetOwnBackgroundColour(lbg);
4653
4654     m_gridWin->SetOwnForegroundColour(gfg);
4655     m_gridWin->SetOwnBackgroundColour(gbg);
4656
4657     Init();
4658 }
4659
4660 bool wxGrid::CreateGrid( int numRows, int numCols,
4661                          wxGridSelectionModes selmode )
4662 {
4663     wxCHECK_MSG( !m_created,
4664                  false,
4665                  wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
4666
4667     return SetTable(new wxGridStringTable(numRows, numCols), true, selmode);
4668 }
4669
4670 void wxGrid::SetSelectionMode(wxGridSelectionModes selmode)
4671 {
4672     wxCHECK_RET( m_created,
4673                  wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
4674
4675     m_selection->SetSelectionMode( selmode );
4676 }
4677
4678 wxGrid::wxGridSelectionModes wxGrid::GetSelectionMode() const
4679 {
4680     wxCHECK_MSG( m_created, wxGridSelectCells,
4681                  wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
4682
4683     return m_selection->GetSelectionMode();
4684 }
4685
4686 bool
4687 wxGrid::SetTable(wxGridTableBase *table,
4688                  bool takeOwnership,
4689                  wxGrid::wxGridSelectionModes selmode )
4690 {
4691     bool checkSelection = false;
4692     if ( m_created )
4693     {
4694         // stop all processing
4695         m_created = false;
4696
4697         if (m_table)
4698         {
4699             m_table->SetView(0);
4700             if( m_ownTable )
4701                 delete m_table;
4702             m_table = NULL;
4703         }
4704
4705         delete m_selection;
4706         m_selection = NULL;
4707
4708         m_ownTable = false;
4709         m_numRows = 0;
4710         m_numCols = 0;
4711         checkSelection = true;
4712
4713         // kill row and column size arrays
4714         m_colWidths.Empty();
4715         m_colRights.Empty();
4716         m_rowHeights.Empty();
4717         m_rowBottoms.Empty();
4718     }
4719
4720     if (table)
4721     {
4722         m_numRows = table->GetNumberRows();
4723         m_numCols = table->GetNumberCols();
4724
4725         m_table = table;
4726         m_table->SetView( this );
4727         m_ownTable = takeOwnership;
4728         m_selection = new wxGridSelection( this, selmode );
4729         if (checkSelection)
4730         {
4731             // If the newly set table is smaller than the
4732             // original one current cell and selection regions
4733             // might be invalid,
4734             m_selectedBlockCorner = wxGridNoCellCoords;
4735             m_currentCellCoords =
4736               wxGridCellCoords(wxMin(m_numRows, m_currentCellCoords.GetRow()),
4737                                wxMin(m_numCols, m_currentCellCoords.GetCol()));
4738             if (m_selectedBlockTopLeft.GetRow() >= m_numRows ||
4739                 m_selectedBlockTopLeft.GetCol() >= m_numCols)
4740             {
4741                 m_selectedBlockTopLeft = wxGridNoCellCoords;
4742                 m_selectedBlockBottomRight = wxGridNoCellCoords;
4743             }
4744             else
4745                 m_selectedBlockBottomRight =
4746                   wxGridCellCoords(wxMin(m_numRows,
4747                                          m_selectedBlockBottomRight.GetRow()),
4748                                    wxMin(m_numCols,
4749                                          m_selectedBlockBottomRight.GetCol()));
4750         }
4751         CalcDimensions();
4752
4753         m_created = true;
4754     }
4755
4756     return m_created;
4757 }
4758
4759 void wxGrid::InitVars()
4760 {
4761     m_created = false;
4762
4763     m_cornerLabelWin = NULL;
4764     m_rowLabelWin = NULL;
4765     m_colLabelWin = NULL;
4766     m_gridWin = NULL;
4767
4768     m_table = NULL;
4769     m_ownTable = false;
4770
4771     m_selection = NULL;
4772     m_defaultCellAttr = NULL;
4773     m_typeRegistry = NULL;
4774     m_winCapture = NULL;
4775 }
4776
4777 void wxGrid::Init()
4778 {
4779     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
4780     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
4781
4782     if ( m_rowLabelWin )
4783     {
4784         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
4785     }
4786     else
4787     {
4788         m_labelBackgroundColour = *wxWHITE;
4789     }
4790
4791     m_labelTextColour = *wxBLACK;
4792
4793     // init attr cache
4794     m_attrCache.row = -1;
4795     m_attrCache.col = -1;
4796     m_attrCache.attr = NULL;
4797
4798     m_labelFont = GetFont();
4799     m_labelFont.SetWeight( wxBOLD );
4800
4801     m_rowLabelHorizAlign = wxALIGN_CENTRE;
4802     m_rowLabelVertAlign  = wxALIGN_CENTRE;
4803
4804     m_colLabelHorizAlign = wxALIGN_CENTRE;
4805     m_colLabelVertAlign  = wxALIGN_CENTRE;
4806     m_colLabelTextOrientation = wxHORIZONTAL;
4807
4808     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
4809     m_defaultRowHeight = m_gridWin->GetCharHeight();
4810
4811     m_minAcceptableColWidth  = WXGRID_MIN_COL_WIDTH;
4812     m_minAcceptableRowHeight = WXGRID_MIN_ROW_HEIGHT;
4813
4814 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
4815     m_defaultRowHeight += 8;
4816 #else
4817     m_defaultRowHeight += 4;
4818 #endif
4819
4820     m_gridLineColour = wxColour( 192,192,192 );
4821     m_gridLinesEnabled = true;
4822     m_cellHighlightColour = *wxBLACK;
4823     m_cellHighlightPenWidth = 2;
4824     m_cellHighlightROPenWidth = 1;
4825
4826     m_canDragColMove = false;
4827
4828     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
4829     m_winCapture = NULL;
4830     m_canDragRowSize = true;
4831     m_canDragColSize = true;
4832     m_canDragGridSize = true;
4833     m_canDragCell = false;
4834     m_dragLastPos  = -1;
4835     m_dragRowOrCol = -1;
4836     m_isDragging = false;
4837     m_startDragPos = wxDefaultPosition;
4838     m_nativeColumnLabels = false;
4839
4840     m_waitForSlowClick = false;
4841
4842     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
4843     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
4844
4845     m_currentCellCoords = wxGridNoCellCoords;
4846
4847     ClearSelection();
4848
4849     m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
4850     m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
4851
4852     m_editable = true;  // default for whole grid
4853
4854     m_inOnKeyDown = false;
4855     m_batchCount = 0;
4856
4857     m_extraWidth =
4858     m_extraHeight = 0;
4859
4860     m_scrollLineX = GRID_SCROLL_LINE_X;
4861     m_scrollLineY = GRID_SCROLL_LINE_Y;
4862 }
4863
4864 // ----------------------------------------------------------------------------
4865 // the idea is to call these functions only when necessary because they create
4866 // quite big arrays which eat memory mostly unnecessary - in particular, if
4867 // default widths/heights are used for all rows/columns, we may not use these
4868 // arrays at all
4869 //
4870 // with some extra code, it should be possible to only store the widths/heights
4871 // different from default ones (resulting in space savings for huge grids) but
4872 // this is not done currently
4873 // ----------------------------------------------------------------------------
4874
4875 void wxGrid::InitRowHeights()
4876 {
4877     m_rowHeights.Empty();
4878     m_rowBottoms.Empty();
4879
4880     m_rowHeights.Alloc( m_numRows );
4881     m_rowBottoms.Alloc( m_numRows );
4882
4883     m_rowHeights.Add( m_defaultRowHeight, m_numRows );
4884
4885     int rowBottom = 0;
4886     for ( int i = 0; i < m_numRows; i++ )
4887     {
4888         rowBottom += m_defaultRowHeight;
4889         m_rowBottoms.Add( rowBottom );
4890     }
4891 }
4892
4893 void wxGrid::InitColWidths()
4894 {
4895     m_colWidths.Empty();
4896     m_colRights.Empty();
4897
4898     m_colWidths.Alloc( m_numCols );
4899     m_colRights.Alloc( m_numCols );
4900
4901     m_colWidths.Add( m_defaultColWidth, m_numCols );
4902
4903     int colRight = 0;
4904     for ( int i = 0; i < m_numCols; i++ )
4905     {
4906         colRight = ( GetColPos( i ) + 1 ) * m_defaultColWidth;
4907         m_colRights.Add( colRight );
4908     }
4909 }
4910
4911 int wxGrid::GetColWidth(int col) const
4912 {
4913     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
4914 }
4915
4916 int wxGrid::GetColLeft(int col) const
4917 {
4918     return m_colRights.IsEmpty() ? GetColPos( col ) * m_defaultColWidth
4919                                  : m_colRights[col] - m_colWidths[col];
4920 }
4921
4922 int wxGrid::GetColRight(int col) const
4923 {
4924     return m_colRights.IsEmpty() ? (GetColPos( col ) + 1) * m_defaultColWidth
4925                                  : m_colRights[col];
4926 }
4927
4928 int wxGrid::GetRowHeight(int row) const
4929 {
4930     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
4931 }
4932
4933 int wxGrid::GetRowTop(int row) const
4934 {
4935     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
4936                                   : m_rowBottoms[row] - m_rowHeights[row];
4937 }
4938
4939 int wxGrid::GetRowBottom(int row) const
4940 {
4941     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
4942                                   : m_rowBottoms[row];
4943 }
4944
4945 void wxGrid::CalcDimensions()
4946 {
4947     // compute the size of the scrollable area
4948     int w = m_numCols > 0 ? GetColRight(GetColAt(m_numCols - 1)) : 0;
4949     int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
4950
4951     w += m_extraWidth;
4952     h += m_extraHeight;
4953
4954     // take into account editor if shown
4955     if ( IsCellEditControlShown() )
4956     {
4957         int w2, h2;
4958         int r = m_currentCellCoords.GetRow();
4959         int c = m_currentCellCoords.GetCol();
4960         int x = GetColLeft(c);
4961         int y = GetRowTop(r);
4962
4963         // how big is the editor
4964         wxGridCellAttr* attr = GetCellAttr(r, c);
4965         wxGridCellEditor* editor = attr->GetEditor(this, r, c);
4966         editor->GetControl()->GetSize(&w2, &h2);
4967         w2 += x;
4968         h2 += y;
4969         if ( w2 > w )
4970             w = w2;
4971         if ( h2 > h )
4972             h = h2;
4973         editor->DecRef();
4974         attr->DecRef();
4975     }
4976
4977     // preserve (more or less) the previous position
4978     int x, y;
4979     GetViewStart( &x, &y );
4980
4981     // ensure the position is valid for the new scroll ranges
4982     if ( x >= w )
4983         x = wxMax( w - 1, 0 );
4984     if ( y >= h )
4985         y = wxMax( h - 1, 0 );
4986
4987     // update the virtual size and refresh the scrollbars to reflect it
4988     m_gridWin->SetVirtualSize(w, h);
4989     Scroll(x, y);
4990     AdjustScrollbars();
4991
4992     // if our OnSize() hadn't been called (it would if we have scrollbars), we
4993     // still must reposition the children
4994     CalcWindowSizes();
4995 }
4996
4997 wxSize wxGrid::GetSizeAvailableForScrollTarget(const wxSize& size)
4998 {
4999     wxSize sizeGridWin(size);
5000     sizeGridWin.x -= m_rowLabelWidth;
5001     sizeGridWin.y -= m_colLabelHeight;
5002
5003     return sizeGridWin;
5004 }
5005
5006 void wxGrid::CalcWindowSizes()
5007 {
5008     // escape if the window is has not been fully created yet
5009
5010     if ( m_cornerLabelWin == NULL )
5011         return;
5012
5013     int cw, ch;
5014     GetClientSize( &cw, &ch );
5015
5016     // the grid may be too small to have enough space for the labels yet, don't
5017     // size the windows to negative sizes in this case
5018     int gw = cw - m_rowLabelWidth;
5019     int gh = ch - m_colLabelHeight;
5020     if (gw < 0)
5021         gw = 0;
5022     if (gh < 0)
5023         gh = 0;
5024
5025     if ( m_cornerLabelWin && m_cornerLabelWin->IsShown() )
5026         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
5027
5028     if ( m_colLabelWin && m_colLabelWin->IsShown() )
5029         m_colLabelWin->SetSize( m_rowLabelWidth, 0, gw, m_colLabelHeight );
5030
5031     if ( m_rowLabelWin && m_rowLabelWin->IsShown() )
5032         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, gh );
5033
5034     if ( m_gridWin && m_gridWin->IsShown() )
5035         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, gw, gh );
5036 }
5037
5038 // this is called when the grid table sends a message
5039 // to indicate that it has been redimensioned
5040 //
5041 bool wxGrid::Redimension( wxGridTableMessage& msg )
5042 {
5043     int i;
5044     bool result = false;
5045
5046     // Clear the attribute cache as the attribute might refer to a different
5047     // cell than stored in the cache after adding/removing rows/columns.
5048     ClearAttrCache();
5049
5050     // By the same reasoning, the editor should be dismissed if columns are
5051     // added or removed. And for consistency, it should IMHO always be
5052     // removed, not only if the cell "underneath" it actually changes.
5053     // For now, I intentionally do not save the editor's content as the
5054     // cell it might want to save that stuff to might no longer exist.
5055     HideCellEditControl();
5056
5057 #if 0
5058     // if we were using the default widths/heights so far, we must change them
5059     // now
5060     if ( m_colWidths.IsEmpty() )
5061     {
5062         InitColWidths();
5063     }
5064
5065     if ( m_rowHeights.IsEmpty() )
5066     {
5067         InitRowHeights();
5068     }
5069 #endif
5070
5071     switch ( msg.GetId() )
5072     {
5073         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5074         {
5075             size_t pos = msg.GetCommandInt();
5076             int numRows = msg.GetCommandInt2();
5077
5078             m_numRows += numRows;
5079
5080             if ( !m_rowHeights.IsEmpty() )
5081             {
5082                 m_rowHeights.Insert( m_defaultRowHeight, pos, numRows );
5083                 m_rowBottoms.Insert( 0, pos, numRows );
5084
5085                 int bottom = 0;
5086                 if ( pos > 0 )
5087                     bottom = m_rowBottoms[pos - 1];
5088
5089                 for ( i = pos; i < m_numRows; i++ )
5090                 {
5091                     bottom += m_rowHeights[i];
5092                     m_rowBottoms[i] = bottom;
5093                 }
5094             }
5095
5096             if ( m_currentCellCoords == wxGridNoCellCoords )
5097             {
5098                 // if we have just inserted cols into an empty grid the current
5099                 // cell will be undefined...
5100                 //
5101                 SetCurrentCell( 0, 0 );
5102             }
5103
5104             if ( m_selection )
5105                 m_selection->UpdateRows( pos, numRows );
5106             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
5107             if (attrProvider)
5108                 attrProvider->UpdateAttrRows( pos, numRows );
5109
5110             if ( !GetBatchCount() )
5111             {
5112                 CalcDimensions();
5113                 m_rowLabelWin->Refresh();
5114             }
5115         }
5116         result = true;
5117         break;
5118
5119         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5120         {
5121             int numRows = msg.GetCommandInt();
5122             int oldNumRows = m_numRows;
5123             m_numRows += numRows;
5124
5125             if ( !m_rowHeights.IsEmpty() )
5126             {
5127                 m_rowHeights.Add( m_defaultRowHeight, numRows );
5128                 m_rowBottoms.Add( 0, numRows );
5129
5130                 int bottom = 0;
5131                 if ( oldNumRows > 0 )
5132                     bottom = m_rowBottoms[oldNumRows - 1];
5133
5134                 for ( i = oldNumRows; i < m_numRows; i++ )
5135                 {
5136                     bottom += m_rowHeights[i];
5137                     m_rowBottoms[i] = bottom;
5138                 }
5139             }
5140
5141             if ( m_currentCellCoords == wxGridNoCellCoords )
5142             {
5143                 // if we have just inserted cols into an empty grid the current
5144                 // cell will be undefined...
5145                 //
5146                 SetCurrentCell( 0, 0 );
5147             }
5148
5149             if ( !GetBatchCount() )
5150             {
5151                 CalcDimensions();
5152                 m_rowLabelWin->Refresh();
5153             }
5154         }
5155         result = true;
5156         break;
5157
5158         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5159         {
5160             size_t pos = msg.GetCommandInt();
5161             int numRows = msg.GetCommandInt2();
5162             m_numRows -= numRows;
5163
5164             if ( !m_rowHeights.IsEmpty() )
5165             {
5166                 m_rowHeights.RemoveAt( pos, numRows );
5167                 m_rowBottoms.RemoveAt( pos, numRows );
5168
5169                 int h = 0;
5170                 for ( i = 0; i < m_numRows; i++ )
5171                 {
5172                     h += m_rowHeights[i];
5173                     m_rowBottoms[i] = h;
5174                 }
5175             }
5176
5177             if ( !m_numRows )
5178             {
5179                 m_currentCellCoords = wxGridNoCellCoords;
5180             }
5181             else
5182             {
5183                 if ( m_currentCellCoords.GetRow() >= m_numRows )
5184                     m_currentCellCoords.Set( 0, 0 );
5185             }
5186
5187             if ( m_selection )
5188                 m_selection->UpdateRows( pos, -((int)numRows) );
5189             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
5190             if (attrProvider)
5191             {
5192                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
5193
5194 // ifdef'd out following patch from Paul Gammans
5195 #if 0
5196                 // No need to touch column attributes, unless we
5197                 // removed _all_ rows, in this case, we remove
5198                 // all column attributes.
5199                 // I hate to do this here, but the
5200                 // needed data is not available inside UpdateAttrRows.
5201                 if ( !GetNumberRows() )
5202                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
5203 #endif
5204             }
5205
5206             if ( !GetBatchCount() )
5207             {
5208                 CalcDimensions();
5209                 m_rowLabelWin->Refresh();
5210             }
5211         }
5212         result = true;
5213         break;
5214
5215         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5216         {
5217             size_t pos = msg.GetCommandInt();
5218             int numCols = msg.GetCommandInt2();
5219             m_numCols += numCols;
5220
5221             if ( !m_colAt.IsEmpty() )
5222             {
5223                 //Shift the column IDs
5224                 int i;
5225                 for ( i = 0; i < m_numCols - numCols; i++ )
5226                 {
5227                     if ( m_colAt[i] >= (int)pos )
5228                         m_colAt[i] += numCols;
5229                 }
5230
5231                 m_colAt.Insert( pos, pos, numCols );
5232
5233                 //Set the new columns' positions
5234                 for ( i = pos + 1; i < (int)pos + numCols; i++ )
5235                 {
5236                     m_colAt[i] = i;
5237                 }
5238             }
5239
5240             if ( !m_colWidths.IsEmpty() )
5241             {
5242                 m_colWidths.Insert( m_defaultColWidth, pos, numCols );
5243                 m_colRights.Insert( 0, pos, numCols );
5244
5245                 int right = 0;
5246                 if ( pos > 0 )
5247                     right = m_colRights[GetColAt( pos - 1 )];
5248
5249                 int colPos;
5250                 for ( colPos = pos; colPos < m_numCols; colPos++ )
5251                 {
5252                     i = GetColAt( colPos );
5253
5254                     right += m_colWidths[i];
5255                     m_colRights[i] = right;
5256                 }
5257             }
5258
5259             if ( m_currentCellCoords == wxGridNoCellCoords )
5260             {
5261                 // if we have just inserted cols into an empty grid the current
5262                 // cell will be undefined...
5263                 //
5264                 SetCurrentCell( 0, 0 );
5265             }
5266
5267             if ( m_selection )
5268                 m_selection->UpdateCols( pos, numCols );
5269             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
5270             if (attrProvider)
5271                 attrProvider->UpdateAttrCols( pos, numCols );
5272             if ( !GetBatchCount() )
5273             {
5274                 CalcDimensions();
5275                 m_colLabelWin->Refresh();
5276             }
5277         }
5278         result = true;
5279         break;
5280
5281         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5282         {
5283             int numCols = msg.GetCommandInt();
5284             int oldNumCols = m_numCols;
5285             m_numCols += numCols;
5286
5287             if ( !m_colAt.IsEmpty() )
5288             {
5289                 m_colAt.Add( 0, numCols );
5290
5291                 //Set the new columns' positions
5292                 int i;
5293                 for ( i = oldNumCols; i < m_numCols; i++ )
5294                 {
5295                     m_colAt[i] = i;
5296                 }
5297             }
5298
5299             if ( !m_colWidths.IsEmpty() )
5300             {
5301                 m_colWidths.Add( m_defaultColWidth, numCols );
5302                 m_colRights.Add( 0, numCols );
5303
5304                 int right = 0;
5305                 if ( oldNumCols > 0 )
5306                     right = m_colRights[GetColAt( oldNumCols - 1 )];
5307
5308                 int colPos;
5309                 for ( colPos = oldNumCols; colPos < m_numCols; colPos++ )
5310                 {
5311                     i = GetColAt( colPos );
5312
5313                     right += m_colWidths[i];
5314                     m_colRights[i] = right;
5315                 }
5316             }
5317
5318             if ( m_currentCellCoords == wxGridNoCellCoords )
5319             {
5320                 // if we have just inserted cols into an empty grid the current
5321                 // cell will be undefined...
5322                 //
5323                 SetCurrentCell( 0, 0 );
5324             }
5325             if ( !GetBatchCount() )
5326             {
5327                 CalcDimensions();
5328                 m_colLabelWin->Refresh();
5329             }
5330         }
5331         result = true;
5332         break;
5333
5334         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5335         {
5336             size_t pos = msg.GetCommandInt();
5337             int numCols = msg.GetCommandInt2();
5338             m_numCols -= numCols;
5339
5340             if ( !m_colAt.IsEmpty() )
5341             {
5342                 int colID = GetColAt( pos );
5343
5344                 m_colAt.RemoveAt( pos, numCols );
5345
5346                 //Shift the column IDs
5347                 int colPos;
5348                 for ( colPos = 0; colPos < m_numCols; colPos++ )
5349                 {
5350                     if ( m_colAt[colPos] > colID )
5351                         m_colAt[colPos] -= numCols;
5352                 }
5353             }
5354
5355             if ( !m_colWidths.IsEmpty() )
5356             {
5357                 m_colWidths.RemoveAt( pos, numCols );
5358                 m_colRights.RemoveAt( pos, numCols );
5359
5360                 int w = 0;
5361                 int colPos;
5362                 for ( colPos = 0; colPos < m_numCols; colPos++ )
5363                 {
5364                     i = GetColAt( colPos );
5365
5366                     w += m_colWidths[i];
5367                     m_colRights[i] = w;
5368                 }
5369             }
5370
5371             if ( !m_numCols )
5372             {
5373                 m_currentCellCoords = wxGridNoCellCoords;
5374             }
5375             else
5376             {
5377                 if ( m_currentCellCoords.GetCol() >= m_numCols )
5378                   m_currentCellCoords.Set( 0, 0 );
5379             }
5380
5381             if ( m_selection )
5382                 m_selection->UpdateCols( pos, -((int)numCols) );
5383             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
5384             if (attrProvider)
5385             {
5386                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
5387
5388 // ifdef'd out following patch from Paul Gammans
5389 #if 0
5390                 // No need to touch row attributes, unless we
5391                 // removed _all_ columns, in this case, we remove
5392                 // all row attributes.
5393                 // I hate to do this here, but the
5394                 // needed data is not available inside UpdateAttrCols.
5395                 if ( !GetNumberCols() )
5396                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
5397 #endif
5398             }
5399
5400             if ( !GetBatchCount() )
5401             {
5402                 CalcDimensions();
5403                 m_colLabelWin->Refresh();
5404             }
5405         }
5406         result = true;
5407         break;
5408     }
5409
5410     if (result && !GetBatchCount() )
5411         m_gridWin->Refresh();
5412
5413     return result;
5414 }
5415
5416 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg ) const
5417 {
5418     wxRegionIterator iter( reg );
5419     wxRect r;
5420
5421     wxArrayInt  rowlabels;
5422
5423     int top, bottom;
5424     while ( iter )
5425     {
5426         r = iter.GetRect();
5427
5428         // TODO: remove this when we can...
5429         // There is a bug in wxMotif that gives garbage update
5430         // rectangles if you jump-scroll a long way by clicking the
5431         // scrollbar with middle button.  This is a work-around
5432         //
5433 #if defined(__WXMOTIF__)
5434         int cw, ch;
5435         m_gridWin->GetClientSize( &cw, &ch );
5436         if ( r.GetTop() > ch )
5437             r.SetTop( 0 );
5438         r.SetBottom( wxMin( r.GetBottom(), ch ) );
5439 #endif
5440
5441         // logical bounds of update region
5442         //
5443         int dummy;
5444         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
5445         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
5446
5447         // find the row labels within these bounds
5448         //
5449         int row;
5450         for ( row = internalYToRow(top); row < m_numRows; row++ )
5451         {
5452             if ( GetRowBottom(row) < top )
5453                 continue;
5454
5455             if ( GetRowTop(row) > bottom )
5456                 break;
5457
5458             rowlabels.Add( row );
5459         }
5460
5461         ++iter;
5462     }
5463
5464     return rowlabels;
5465 }
5466
5467 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg ) const
5468 {
5469     wxRegionIterator iter( reg );
5470     wxRect r;
5471
5472     wxArrayInt colLabels;
5473
5474     int left, right;
5475     while ( iter )
5476     {
5477         r = iter.GetRect();
5478
5479         // TODO: remove this when we can...
5480         // There is a bug in wxMotif that gives garbage update
5481         // rectangles if you jump-scroll a long way by clicking the
5482         // scrollbar with middle button.  This is a work-around
5483         //
5484 #if defined(__WXMOTIF__)
5485         int cw, ch;
5486         m_gridWin->GetClientSize( &cw, &ch );
5487         if ( r.GetLeft() > cw )
5488             r.SetLeft( 0 );
5489         r.SetRight( wxMin( r.GetRight(), cw ) );
5490 #endif
5491
5492         // logical bounds of update region
5493         //
5494         int dummy;
5495         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
5496         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
5497
5498         // find the cells within these bounds
5499         //
5500         int col;
5501         int colPos;
5502         for ( colPos = GetColPos( internalXToCol(left) ); colPos < m_numCols; colPos++ )
5503         {
5504             col = GetColAt( colPos );
5505
5506             if ( GetColRight(col) < left )
5507                 continue;
5508
5509             if ( GetColLeft(col) > right )
5510                 break;
5511
5512             colLabels.Add( col );
5513         }
5514
5515         ++iter;
5516     }
5517
5518     return colLabels;
5519 }
5520
5521 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg ) const
5522 {
5523     wxRegionIterator iter( reg );
5524     wxRect r;
5525
5526     wxGridCellCoordsArray  cellsExposed;
5527
5528     int left, top, right, bottom;
5529     while ( iter )
5530     {
5531         r = iter.GetRect();
5532
5533         // TODO: remove this when we can...
5534         // There is a bug in wxMotif that gives garbage update
5535         // rectangles if you jump-scroll a long way by clicking the
5536         // scrollbar with middle button.  This is a work-around
5537         //
5538 #if defined(__WXMOTIF__)
5539         int cw, ch;
5540         m_gridWin->GetClientSize( &cw, &ch );
5541         if ( r.GetTop() > ch ) r.SetTop( 0 );
5542         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
5543         r.SetRight( wxMin( r.GetRight(), cw ) );
5544         r.SetBottom( wxMin( r.GetBottom(), ch ) );
5545 #endif
5546
5547         // logical bounds of update region
5548         //
5549         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
5550         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
5551
5552         // find the cells within these bounds
5553         //
5554         int row, col;
5555         for ( row = internalYToRow(top); row < m_numRows; row++ )
5556         {
5557             if ( GetRowBottom(row) <= top )
5558                 continue;
5559
5560             if ( GetRowTop(row) > bottom )
5561                 break;
5562
5563             int colPos;
5564             for ( colPos = GetColPos( internalXToCol(left) ); colPos < m_numCols; colPos++ )
5565             {
5566                 col = GetColAt( colPos );
5567
5568                 if ( GetColRight(col) <= left )
5569                     continue;
5570
5571                 if ( GetColLeft(col) > right )
5572                     break;
5573
5574                 cellsExposed.Add( wxGridCellCoords( row, col ) );
5575             }
5576         }
5577
5578         ++iter;
5579     }
5580
5581     return cellsExposed;
5582 }
5583
5584
5585 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
5586 {
5587     int x, y, row;
5588     wxPoint pos( event.GetPosition() );
5589     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5590
5591     if ( event.Dragging() )
5592     {
5593         if (!m_isDragging)
5594         {
5595             m_isDragging = true;
5596             m_rowLabelWin->CaptureMouse();
5597         }
5598
5599         if ( event.LeftIsDown() )
5600         {
5601             switch ( m_cursorMode )
5602             {
5603                 case WXGRID_CURSOR_RESIZE_ROW:
5604                 {
5605                     int cw, ch, left, dummy;
5606                     m_gridWin->GetClientSize( &cw, &ch );
5607                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
5608
5609                     wxClientDC dc( m_gridWin );
5610                     PrepareDC( dc );
5611                     y = wxMax( y,
5612                                GetRowTop(m_dragRowOrCol) +
5613                                GetRowMinimalHeight(m_dragRowOrCol) );
5614                     dc.SetLogicalFunction(wxINVERT);
5615                     if ( m_dragLastPos >= 0 )
5616                     {
5617                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5618                     }
5619                     dc.DrawLine( left, y, left+cw, y );
5620                     m_dragLastPos = y;
5621                 }
5622                 break;
5623
5624                 case WXGRID_CURSOR_SELECT_ROW:
5625                 {
5626                     if ( (row = YToRow( y )) >= 0 )
5627                     {
5628                         if ( m_selection )
5629                             m_selection->SelectRow(row, event);
5630                     }
5631                 }
5632                 break;
5633
5634                 // default label to suppress warnings about "enumeration value
5635                 // 'xxx' not handled in switch
5636                 default:
5637                     break;
5638             }
5639         }
5640         return;
5641     }
5642
5643     if ( m_isDragging && (event.Entering() || event.Leaving()) )
5644         return;
5645
5646     if (m_isDragging)
5647     {
5648         if (m_rowLabelWin->HasCapture())
5649             m_rowLabelWin->ReleaseMouse();
5650         m_isDragging = false;
5651     }
5652
5653     // ------------ Entering or leaving the window
5654     //
5655     if ( event.Entering() || event.Leaving() )
5656     {
5657         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
5658     }
5659
5660     // ------------ Left button pressed
5661     //
5662     else if ( event.LeftDown() )
5663     {
5664         // don't send a label click event for a hit on the
5665         // edge of the row label - this is probably the user
5666         // wanting to resize the row
5667         //
5668         if ( YToEdgeOfRow(y) < 0 )
5669         {
5670             row = YToRow(y);
5671             if ( row >= 0 &&
5672                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
5673             {
5674                 if ( !event.ShiftDown() && !event.CmdDown() )
5675                     ClearSelection();
5676                 if ( m_selection )
5677                 {
5678                     if ( event.ShiftDown() )
5679                     {
5680                         m_selection->SelectBlock
5681                                      (
5682                                         m_currentCellCoords.GetRow(), 0,
5683                                         row, GetNumberCols() - 1,
5684                                         event
5685                                      );
5686                     }
5687                     else
5688                     {
5689                         m_selection->SelectRow(row, event);
5690                     }
5691                 }
5692
5693                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
5694             }
5695         }
5696         else
5697         {
5698             // starting to drag-resize a row
5699             if ( CanDragRowSize() )
5700                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
5701         }
5702     }
5703
5704     // ------------ Left double click
5705     //
5706     else if (event.LeftDClick() )
5707     {
5708         row = YToEdgeOfRow(y);
5709         if ( row < 0 )
5710         {
5711             row = YToRow(y);
5712             if ( row >=0 &&
5713                  !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event ) )
5714             {
5715                 // no default action at the moment
5716             }
5717         }
5718         else
5719         {
5720             // adjust row height depending on label text
5721             AutoSizeRowLabelSize( row );
5722
5723             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5724             m_dragLastPos = -1;
5725         }
5726     }
5727
5728     // ------------ Left button released
5729     //
5730     else if ( event.LeftUp() )
5731     {
5732         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5733         {
5734             DoEndDragResizeRow();
5735
5736             // Note: we are ending the event *after* doing
5737             // default processing in this case
5738             //
5739             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5740         }
5741
5742         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
5743         m_dragLastPos = -1;
5744     }
5745
5746     // ------------ Right button down
5747     //
5748     else if ( event.RightDown() )
5749     {
5750         row = YToRow(y);
5751         if ( row >=0 &&
5752              !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
5753         {
5754             // no default action at the moment
5755         }
5756     }
5757
5758     // ------------ Right double click
5759     //
5760     else if ( event.RightDClick() )
5761     {
5762         row = YToRow(y);
5763         if ( row >= 0 &&
5764              !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
5765         {
5766             // no default action at the moment
5767         }
5768     }
5769
5770     // ------------ No buttons down and mouse moving
5771     //
5772     else if ( event.Moving() )
5773     {
5774         m_dragRowOrCol = YToEdgeOfRow( y );
5775         if ( m_dragRowOrCol >= 0 )
5776         {
5777             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5778             {
5779                 // don't capture the mouse yet
5780                 if ( CanDragRowSize() )
5781                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, false);
5782             }
5783         }
5784         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5785         {
5786             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, false);
5787         }
5788     }
5789 }
5790
5791 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
5792 {
5793     int x, y, col;
5794     wxPoint pos( event.GetPosition() );
5795     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5796
5797     if ( event.Dragging() )
5798     {
5799         if (!m_isDragging)
5800         {
5801             m_isDragging = true;
5802             m_colLabelWin->CaptureMouse();
5803
5804             if ( m_cursorMode == WXGRID_CURSOR_MOVE_COL )
5805                 m_dragRowOrCol = XToCol( x );
5806         }
5807
5808         if ( event.LeftIsDown() )
5809         {
5810             switch ( m_cursorMode )
5811             {
5812                 case WXGRID_CURSOR_RESIZE_COL:
5813                 {
5814                     int cw, ch, dummy, top;
5815                     m_gridWin->GetClientSize( &cw, &ch );
5816                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
5817
5818                     wxClientDC dc( m_gridWin );
5819                     PrepareDC( dc );
5820
5821                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5822                                   GetColMinimalWidth(m_dragRowOrCol));
5823                     dc.SetLogicalFunction(wxINVERT);
5824                     if ( m_dragLastPos >= 0 )
5825                     {
5826                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top + ch );
5827                     }
5828                     dc.DrawLine( x, top, x, top + ch );
5829                     m_dragLastPos = x;
5830                 }
5831                 break;
5832
5833                 case WXGRID_CURSOR_SELECT_COL:
5834                 {
5835                     if ( (col = XToCol( x )) >= 0 )
5836                     {
5837                         if ( m_selection )
5838                             m_selection->SelectCol(col, event);
5839                     }
5840                 }
5841                 break;
5842
5843                 case WXGRID_CURSOR_MOVE_COL:
5844                 {
5845                     if ( x < 0 )
5846                         m_moveToCol = GetColAt( 0 );
5847                     else
5848                         m_moveToCol = XToCol( x );
5849
5850                     int markerX;
5851
5852                     if ( m_moveToCol < 0 )
5853                         markerX = GetColRight( GetColAt( m_numCols - 1 ) );
5854                     else if ( x >= (GetColLeft( m_moveToCol ) + (GetColWidth(m_moveToCol) / 2)) )
5855                     {
5856                         m_moveToCol = GetColAt( GetColPos( m_moveToCol ) + 1 );
5857                         if ( m_moveToCol < 0 )
5858                             markerX = GetColRight( GetColAt( m_numCols - 1 ) );
5859                         else
5860                             markerX = GetColLeft( m_moveToCol );
5861                     }
5862                     else
5863                         markerX = GetColLeft( m_moveToCol );
5864
5865                     if ( markerX != m_dragLastPos )
5866                     {
5867                         wxClientDC dc( m_colLabelWin );
5868                         DoPrepareDC(dc);
5869
5870                         int cw, ch;
5871                         m_colLabelWin->GetClientSize( &cw, &ch );
5872
5873                         markerX++;
5874
5875                         //Clean up the last indicator
5876                         if ( m_dragLastPos >= 0 )
5877                         {
5878                             wxPen pen( m_colLabelWin->GetBackgroundColour(), 2 );
5879                             dc.SetPen(pen);
5880                             dc.DrawLine( m_dragLastPos + 1, 0, m_dragLastPos + 1, ch );
5881                             dc.SetPen(wxNullPen);
5882
5883                             if ( XToCol( m_dragLastPos ) != -1 )
5884                                 DrawColLabel( dc, XToCol( m_dragLastPos ) );
5885                         }
5886
5887                         const wxColour *color;
5888                         //Moving to the same place? Don't draw a marker
5889                         if ( (m_moveToCol == m_dragRowOrCol)
5890                           || (GetColPos( m_moveToCol ) == GetColPos( m_dragRowOrCol ) + 1)
5891                           || (m_moveToCol < 0 && m_dragRowOrCol == GetColAt( m_numCols - 1 )))
5892                             color = wxLIGHT_GREY;
5893                         else
5894                             color = wxBLUE;
5895
5896                         //Draw the marker
5897                         wxPen pen( *color, 2 );
5898                         dc.SetPen(pen);
5899
5900                         dc.DrawLine( markerX, 0, markerX, ch );
5901
5902                         dc.SetPen(wxNullPen);
5903
5904                         m_dragLastPos = markerX - 1;
5905                     }
5906                 }
5907                 break;
5908
5909                 // default label to suppress warnings about "enumeration value
5910                 // 'xxx' not handled in switch
5911                 default:
5912                     break;
5913             }
5914         }
5915         return;
5916     }
5917
5918     if ( m_isDragging && (event.Entering() || event.Leaving()) )
5919         return;
5920
5921     if (m_isDragging)
5922     {
5923         if (m_colLabelWin->HasCapture())
5924             m_colLabelWin->ReleaseMouse();
5925         m_isDragging = false;
5926     }
5927
5928     // ------------ Entering or leaving the window
5929     //
5930     if ( event.Entering() || event.Leaving() )
5931     {
5932         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5933     }
5934
5935     // ------------ Left button pressed
5936     //
5937     else if ( event.LeftDown() )
5938     {
5939         // don't send a label click event for a hit on the
5940         // edge of the col label - this is probably the user
5941         // wanting to resize the col
5942         //
5943         if ( XToEdgeOfCol(x) < 0 )
5944         {
5945             col = XToCol(x);
5946             if ( col >= 0 &&
5947                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
5948             {
5949                 if ( m_canDragColMove )
5950                 {
5951                     //Show button as pressed
5952                     wxClientDC dc( m_colLabelWin );
5953                     int colLeft = GetColLeft( col );
5954                     int colRight = GetColRight( col ) - 1;
5955                     dc.SetPen( wxPen( m_colLabelWin->GetBackgroundColour(), 1 ) );
5956                     dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
5957                     dc.DrawLine( colLeft, 1, colRight, 1 );
5958
5959                     ChangeCursorMode(WXGRID_CURSOR_MOVE_COL, m_colLabelWin);
5960                 }
5961                 else
5962                 {
5963                     if ( !event.ShiftDown() && !event.CmdDown() )
5964                         ClearSelection();
5965                     if ( m_selection )
5966                     {
5967                         if ( event.ShiftDown() )
5968                         {
5969                             m_selection->SelectBlock
5970                                          (
5971                                             0, m_currentCellCoords.GetCol(),
5972                                             GetNumberRows() - 1, col,
5973                                             event
5974                                          );
5975                         }
5976                         else
5977                         {
5978                             m_selection->SelectCol(col, event);
5979                         }
5980                     }
5981
5982                     ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
5983                 }
5984             }
5985         }
5986         else
5987         {
5988             // starting to drag-resize a col
5989             //
5990             if ( CanDragColSize() )
5991                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
5992         }
5993     }
5994
5995     // ------------ Left double click
5996     //
5997     if ( event.LeftDClick() )
5998     {
5999         col = XToEdgeOfCol(x);
6000         if ( col < 0 )
6001         {
6002             col = XToCol(x);
6003             if ( col >= 0 &&
6004                  ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event ) )
6005             {
6006                 // no default action at the moment
6007             }
6008         }
6009         else
6010         {
6011             // adjust column width depending on label text
6012             AutoSizeColLabelSize( col );
6013
6014             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
6015             m_dragLastPos = -1;
6016         }
6017     }
6018
6019     // ------------ Left button released
6020     //
6021     else if ( event.LeftUp() )
6022     {
6023         switch ( m_cursorMode )
6024         {
6025             case WXGRID_CURSOR_RESIZE_COL:
6026                 DoEndDragResizeCol();
6027
6028                 // Note: we are ending the event *after* doing
6029                 // default processing in this case
6030                 //
6031                 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
6032                 break;
6033
6034             case WXGRID_CURSOR_MOVE_COL:
6035                 DoEndDragMoveCol();
6036
6037                 SendEvent( wxEVT_GRID_COL_MOVE, -1, m_dragRowOrCol, event );
6038                 break;
6039
6040             case WXGRID_CURSOR_SELECT_COL:
6041             case WXGRID_CURSOR_SELECT_CELL:
6042             case WXGRID_CURSOR_RESIZE_ROW:
6043             case WXGRID_CURSOR_SELECT_ROW:
6044                 // nothing to do (?)
6045                 break;
6046         }
6047
6048         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
6049         m_dragLastPos = -1;
6050     }
6051
6052     // ------------ Right button down
6053     //
6054     else if ( event.RightDown() )
6055     {
6056         col = XToCol(x);
6057         if ( col >= 0 &&
6058              !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
6059         {
6060             // no default action at the moment
6061         }
6062     }
6063
6064     // ------------ Right double click
6065     //
6066     else if ( event.RightDClick() )
6067     {
6068         col = XToCol(x);
6069         if ( col >= 0 &&
6070              !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
6071         {
6072             // no default action at the moment
6073         }
6074     }
6075
6076     // ------------ No buttons down and mouse moving
6077     //
6078     else if ( event.Moving() )
6079     {
6080         m_dragRowOrCol = XToEdgeOfCol( x );
6081         if ( m_dragRowOrCol >= 0 )
6082         {
6083             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6084             {
6085                 // don't capture the cursor yet
6086                 if ( CanDragColSize() )
6087                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, false);
6088             }
6089         }
6090         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
6091         {
6092             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, false);
6093         }
6094     }
6095 }
6096
6097 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
6098 {
6099     if ( event.LeftDown() )
6100     {
6101         // indicate corner label by having both row and
6102         // col args == -1
6103         //
6104         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
6105         {
6106             SelectAll();
6107         }
6108     }
6109     else if ( event.LeftDClick() )
6110     {
6111         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
6112     }
6113     else if ( event.RightDown() )
6114     {
6115         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
6116         {
6117             // no default action at the moment
6118         }
6119     }
6120     else if ( event.RightDClick() )
6121     {
6122         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
6123         {
6124             // no default action at the moment
6125         }
6126     }
6127 }
6128
6129 void wxGrid::CancelMouseCapture()
6130 {
6131     // cancel operation currently in progress, whatever it is
6132     if ( m_winCapture )
6133     {
6134         m_isDragging = false;
6135         m_startDragPos = wxDefaultPosition;
6136
6137         m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
6138         m_winCapture->SetCursor( *wxSTANDARD_CURSOR );
6139         m_winCapture = NULL;
6140
6141         // remove traces of whatever we drew on screen
6142         Refresh();
6143     }
6144 }
6145
6146 void wxGrid::ChangeCursorMode(CursorMode mode,
6147                               wxWindow *win,
6148                               bool captureMouse)
6149 {
6150 #ifdef __WXDEBUG__
6151     static const wxChar *cursorModes[] =
6152     {
6153         _T("SELECT_CELL"),
6154         _T("RESIZE_ROW"),
6155         _T("RESIZE_COL"),
6156         _T("SELECT_ROW"),
6157         _T("SELECT_COL"),
6158         _T("MOVE_COL"),
6159     };
6160
6161     wxLogTrace(_T("grid"),
6162                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
6163                win == m_colLabelWin ? _T("colLabelWin")
6164                                     : win ? _T("rowLabelWin")
6165                                           : _T("gridWin"),
6166                cursorModes[m_cursorMode], cursorModes[mode]);
6167 #endif
6168
6169     if ( mode == m_cursorMode &&
6170          win == m_winCapture &&
6171          captureMouse == (m_winCapture != NULL))
6172         return;
6173
6174     if ( !win )
6175     {
6176         // by default use the grid itself
6177         win = m_gridWin;
6178     }
6179
6180     if ( m_winCapture )
6181     {
6182         if (m_winCapture->HasCapture())
6183             m_winCapture->ReleaseMouse();
6184         m_winCapture = NULL;
6185     }
6186
6187     m_cursorMode = mode;
6188
6189     switch ( m_cursorMode )
6190     {
6191         case WXGRID_CURSOR_RESIZE_ROW:
6192             win->SetCursor( m_rowResizeCursor );
6193             break;
6194
6195         case WXGRID_CURSOR_RESIZE_COL:
6196             win->SetCursor( m_colResizeCursor );
6197             break;
6198
6199         case WXGRID_CURSOR_MOVE_COL:
6200             win->SetCursor( wxCursor(wxCURSOR_HAND) );
6201             break;
6202
6203         default:
6204             win->SetCursor( *wxSTANDARD_CURSOR );
6205             break;
6206     }
6207
6208     // we need to capture mouse when resizing
6209     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
6210                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
6211
6212     if ( captureMouse && resize )
6213     {
6214         win->CaptureMouse();
6215         m_winCapture = win;
6216     }
6217 }
6218
6219 // ----------------------------------------------------------------------------
6220 // grid mouse event processing
6221 // ----------------------------------------------------------------------------
6222
6223 void
6224 wxGrid::DoGridCellDrag(wxMouseEvent& event,
6225                        const wxGridCellCoords& coords,
6226                        bool isFirstDrag)
6227 {
6228     if ( coords == wxGridNoCellCoords )
6229         return; // we're outside any valid cell
6230
6231     // Hide the edit control, so it won't interfere with drag-shrinking.
6232     if ( IsCellEditControlShown() )
6233     {
6234         HideCellEditControl();
6235         SaveEditControlValue();
6236     }
6237
6238     switch ( event.GetModifiers() )
6239     {
6240         case wxMOD_CMD:
6241             if ( m_selectedBlockCorner == wxGridNoCellCoords)
6242                 m_selectedBlockCorner = coords;
6243             UpdateBlockBeingSelected(m_selectedBlockCorner, coords);
6244             break;
6245
6246         case wxMOD_NONE:
6247             if ( CanDragCell() )
6248             {
6249                 if ( isFirstDrag )
6250                 {
6251                     if ( m_selectedBlockCorner == wxGridNoCellCoords)
6252                         m_selectedBlockCorner = coords;
6253
6254                     SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event);
6255                     return;
6256                 }
6257             }
6258
6259             UpdateBlockBeingSelected(m_currentCellCoords, coords);
6260             break;
6261
6262         default:
6263             // we don't handle the other key modifiers
6264             event.Skip();
6265     }
6266 }
6267
6268 void wxGrid::DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper)
6269 {
6270     wxClientDC dc(m_gridWin);
6271     PrepareDC(dc);
6272     dc.SetLogicalFunction(wxINVERT);
6273
6274     const wxRect rectWin(CalcUnscrolledPosition(wxPoint(0, 0)),
6275                          m_gridWin->GetClientSize());
6276
6277     // erase the previously drawn line, if any
6278     if ( m_dragLastPos >= 0 )
6279         oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
6280
6281     // we need the vertical position for rows and horizontal for columns here
6282     m_dragLastPos = oper.Dual().Select(CalcUnscrolledPosition(event.GetPosition()));
6283
6284     // don't allow resizing beneath the minimal size
6285     const int posMin = oper.GetLineStartPos(this, m_dragRowOrCol) +
6286                         oper.GetMinimalLineSize(this, m_dragRowOrCol);
6287     if ( m_dragLastPos < posMin )
6288         m_dragLastPos = posMin;
6289
6290     // and draw it at the new position
6291     oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
6292 }
6293
6294 void wxGrid::DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords)
6295 {
6296     if ( !m_isDragging )
6297     {
6298         // Don't start doing anything until the mouse has been dragged far
6299         // enough
6300         const wxPoint& pt = event.GetPosition();
6301         if ( m_startDragPos == wxDefaultPosition )
6302         {
6303             m_startDragPos = pt;
6304             return;
6305         }
6306
6307         if ( abs(m_startDragPos.x - pt.x) <= DRAG_SENSITIVITY &&
6308                 abs(m_startDragPos.y - pt.y) <= DRAG_SENSITIVITY )
6309             return;
6310     }
6311
6312     const bool isFirstDrag = !m_isDragging;
6313     m_isDragging = true;
6314
6315     switch ( m_cursorMode )
6316     {
6317         case WXGRID_CURSOR_SELECT_CELL:
6318             DoGridCellDrag(event, coords, isFirstDrag);
6319             break;
6320
6321         case WXGRID_CURSOR_RESIZE_ROW:
6322             DoGridLineDrag(event, wxGridRowOperations());
6323             break;
6324
6325         case WXGRID_CURSOR_RESIZE_COL:
6326             DoGridLineDrag(event, wxGridColumnOperations());
6327             break;
6328
6329         default:
6330             event.Skip();
6331     }
6332
6333     if ( isFirstDrag )
6334     {
6335         m_winCapture = m_gridWin;
6336         m_winCapture->CaptureMouse();
6337     }
6338 }
6339
6340 void
6341 wxGrid::DoGridCellLeftDown(wxMouseEvent& event,
6342                            const wxGridCellCoords& coords,
6343                            const wxPoint& pos)
6344 {
6345     if ( SendEvent(wxEVT_GRID_CELL_LEFT_CLICK, coords, event) )
6346     {
6347         // event handled by user code, no need to do anything here
6348         return;
6349     }
6350
6351     if ( !event.CmdDown() )
6352         ClearSelection();
6353
6354     if ( event.ShiftDown() )
6355     {
6356         if ( m_selection )
6357         {
6358             m_selection->SelectBlock(m_currentCellCoords, coords, event);
6359             m_selectedBlockCorner = coords;
6360         }
6361     }
6362     else if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
6363     {
6364         DisableCellEditControl();
6365         MakeCellVisible( coords );
6366
6367         if ( event.CmdDown() )
6368         {
6369             if ( m_selection )
6370             {
6371                 m_selection->ToggleCellSelection(coords, event);
6372             }
6373
6374             m_selectedBlockTopLeft = wxGridNoCellCoords;
6375             m_selectedBlockBottomRight = wxGridNoCellCoords;
6376             m_selectedBlockCorner = coords;
6377         }
6378         else
6379         {
6380             m_waitForSlowClick = m_currentCellCoords == coords &&
6381                                         coords != wxGridNoCellCoords;
6382             SetCurrentCell( coords );
6383         }
6384     }
6385 }
6386
6387 void
6388 wxGrid::DoGridCellLeftDClick(wxMouseEvent& event,
6389                              const wxGridCellCoords& coords,
6390                              const wxPoint& pos)
6391 {
6392     if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
6393     {
6394         if ( !SendEvent(wxEVT_GRID_CELL_LEFT_DCLICK, coords, event) )
6395         {
6396             // we want double click to select a cell and start editing
6397             // (i.e. to behave in same way as sequence of two slow clicks):
6398             m_waitForSlowClick = true;
6399         }
6400     }
6401 }
6402
6403 void
6404 wxGrid::DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords)
6405 {
6406     if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6407     {
6408         if (m_winCapture)
6409         {
6410             if (m_winCapture->HasCapture())
6411                 m_winCapture->ReleaseMouse();
6412             m_winCapture = NULL;
6413         }
6414
6415         if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
6416         {
6417             ClearSelection();
6418             EnableCellEditControl();
6419
6420             wxGridCellAttr *attr = GetCellAttr(coords);
6421             wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
6422             editor->StartingClick();
6423             editor->DecRef();
6424             attr->DecRef();
6425
6426             m_waitForSlowClick = false;
6427         }
6428         else if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
6429              m_selectedBlockBottomRight != wxGridNoCellCoords )
6430         {
6431             if ( m_selection )
6432             {
6433                 m_selection->SelectBlock( m_selectedBlockTopLeft,
6434                                           m_selectedBlockBottomRight,
6435                                           event );
6436             }
6437
6438             m_selectedBlockTopLeft = wxGridNoCellCoords;
6439             m_selectedBlockBottomRight = wxGridNoCellCoords;
6440
6441             // Show the edit control, if it has been hidden for
6442             // drag-shrinking.
6443             ShowCellEditControl();
6444         }
6445     }
6446     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
6447     {
6448         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6449         DoEndDragResizeRow();
6450
6451         // Note: we are ending the event *after* doing
6452         // default processing in this case
6453         //
6454         SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
6455     }
6456     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
6457     {
6458         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6459         DoEndDragResizeCol();
6460
6461         // Note: we are ending the event *after* doing
6462         // default processing in this case
6463         //
6464         SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
6465     }
6466
6467     m_dragLastPos = -1;
6468 }
6469
6470 void
6471 wxGrid::DoGridMouseMoveEvent(wxMouseEvent& WXUNUSED(event),
6472                              const wxGridCellCoords& coords,
6473                              const wxPoint& pos)
6474 {
6475     if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
6476     {
6477         // out of grid cell area
6478         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6479         return;
6480     }
6481
6482     int dragRow = YToEdgeOfRow( pos.y );
6483     int dragCol = XToEdgeOfCol( pos.x );
6484
6485     // Dragging on the corner of a cell to resize in both
6486     // directions is not implemented yet...
6487     //
6488     if ( dragRow >= 0 && dragCol >= 0 )
6489     {
6490         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6491         return;
6492     }
6493
6494     if ( dragRow >= 0 )
6495     {
6496         m_dragRowOrCol = dragRow;
6497
6498         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6499         {
6500             if ( CanDragRowSize() && CanDragGridSize() )
6501                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);
6502         }
6503     }
6504     else if ( dragCol >= 0 )
6505     {
6506         m_dragRowOrCol = dragCol;
6507
6508         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6509         {
6510             if ( CanDragColSize() && CanDragGridSize() )
6511                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);
6512         }
6513     }
6514     else // Neither on a row or col edge
6515     {
6516         if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
6517         {
6518             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6519         }
6520     }
6521 }
6522
6523 void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
6524 {
6525     const wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
6526
6527     // coordinates of the cell under mouse
6528     wxGridCellCoords coords = XYToCell(pos);
6529
6530     int cell_rows, cell_cols;
6531     GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
6532     if ( (cell_rows < 0) || (cell_cols < 0) )
6533     {
6534         coords.SetRow(coords.GetRow() + cell_rows);
6535         coords.SetCol(coords.GetCol() + cell_cols);
6536     }
6537
6538     if ( event.Dragging() )
6539     {
6540         if ( event.LeftIsDown() )
6541             DoGridDragEvent(event, coords);
6542         else
6543             event.Skip();
6544         return;
6545     }
6546
6547     m_isDragging = false;
6548     m_startDragPos = wxDefaultPosition;
6549
6550     // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
6551     //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
6552     //     wxGTK
6553 #if 0
6554     if ( event.Entering() || event.Leaving() )
6555     {
6556         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6557         m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
6558     }
6559 #endif // 0
6560
6561     // deal with various button presses
6562     if ( event.IsButton() )
6563     {
6564         if ( coords != wxGridNoCellCoords )
6565         {
6566             DisableCellEditControl();
6567
6568             if ( event.LeftDown() )
6569                 DoGridCellLeftDown(event, coords, pos);
6570             else if ( event.LeftDClick() )
6571                 DoGridCellLeftDClick(event, coords, pos);
6572             else if ( event.RightDown() )
6573                 SendEvent(wxEVT_GRID_CELL_RIGHT_CLICK, coords, event);
6574             else if ( event.RightDClick() )
6575                 SendEvent(wxEVT_GRID_CELL_RIGHT_DCLICK, coords, event);
6576         }
6577
6578         // this one should be called even if we're not over any cell
6579         if ( event.LeftUp() )
6580         {
6581             DoGridCellLeftUp(event, coords);
6582         }
6583     }
6584     else if ( event.Moving() )
6585     {
6586         DoGridMouseMoveEvent(event, coords, pos);
6587     }
6588     else // unknown mouse event?
6589     {
6590         event.Skip();
6591     }
6592 }
6593
6594 void wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
6595 {
6596     if ( m_dragLastPos == -1 )
6597         return;
6598
6599     const wxGridOperations& doper = oper.Dual();
6600
6601     const wxSize size = m_gridWin->GetClientSize();
6602
6603     const wxPoint ptOrigin = CalcUnscrolledPosition(wxPoint(0, 0));
6604
6605     // erase the last line we drew
6606     wxClientDC dc(m_gridWin);
6607     PrepareDC(dc);
6608     dc.SetLogicalFunction(wxINVERT);
6609
6610     const int posLineStart = oper.Select(ptOrigin);
6611     const int posLineEnd = oper.Select(ptOrigin) + oper.Select(size);
6612
6613     oper.DrawParallelLine(dc, posLineStart, posLineEnd, m_dragLastPos);
6614
6615     // temporarily hide the edit control before resizing
6616     HideCellEditControl();
6617     SaveEditControlValue();
6618
6619     // do resize the line
6620     const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);
6621     oper.SetLineSize(this, m_dragRowOrCol,
6622                      wxMax(m_dragLastPos - lineStart,
6623                            oper.GetMinimalLineSize(this, m_dragRowOrCol)));
6624
6625     // refresh now if we're not frozen
6626     if ( !GetBatchCount() )
6627     {
6628         // we need to refresh everything beyond the resized line in the header
6629         // window
6630
6631         // get the position from which to refresh in the other direction
6632         wxRect rect(CellToRect(oper.MakeCoords(m_dragRowOrCol, 0)));
6633         rect.SetPosition(CalcScrolledPosition(rect.GetPosition()));
6634
6635         // we only need the ordinate (for rows) or abscissa (for columns) here,
6636         // and need to cover the entire window in the other direction
6637         oper.Select(rect) = 0;
6638
6639         wxRect rectHeader(rect.GetPosition(),
6640                           oper.MakeSize
6641                                (
6642                                     oper.GetHeaderWindowSize(this),
6643                                     doper.Select(size) - doper.Select(rect)
6644                                ));
6645
6646         oper.GetHeaderWindow(this)->Refresh(true, &rectHeader);
6647
6648
6649         // also refresh the grid window: extend the rectangle
6650         if ( m_table )
6651         {
6652             oper.SelectSize(rect) = oper.Select(size);
6653
6654             int subtractLines = 0;
6655             const int lineStart = oper.PosToLine(this, posLineStart);
6656             if ( lineStart >= 0 )
6657             {
6658                 // ensure that if we have a multi-cell block we redraw all of
6659                 // it by increasing the refresh area to cover it entirely if a
6660                 // part of it is affected
6661                 const int lineEnd = oper.PosToLine(this, posLineEnd, true);
6662                 for ( int line = lineStart; line < lineEnd; line++ )
6663                 {
6664                     int cellLines = oper.Select(
6665                         GetCellSize(oper.MakeCoords(m_dragRowOrCol, line)));
6666                     if ( cellLines < subtractLines )
6667                         subtractLines = cellLines;
6668                 }
6669             }
6670
6671             int startPos =
6672                 oper.GetLineStartPos(this, m_dragRowOrCol + subtractLines);
6673             startPos = doper.CalcScrolledPosition(this, startPos);
6674
6675             doper.Select(rect) = startPos;
6676             doper.SelectSize(rect) = doper.Select(size) - startPos;
6677
6678             m_gridWin->Refresh(false, &rect);
6679         }
6680     }
6681
6682     // show the edit control back again
6683     ShowCellEditControl();
6684 }
6685
6686 void wxGrid::DoEndDragResizeRow()
6687 {
6688     DoEndDragResizeLine(wxGridRowOperations());
6689 }
6690
6691 void wxGrid::DoEndDragResizeCol()
6692 {
6693     DoEndDragResizeLine(wxGridColumnOperations());
6694 }
6695
6696 void wxGrid::DoEndDragMoveCol()
6697 {
6698     //The user clicked on the column but didn't actually drag
6699     if ( m_dragLastPos < 0 )
6700     {
6701         m_colLabelWin->Refresh();   //Do this to "unpress" the column
6702         return;
6703     }
6704
6705     int newPos;
6706     if ( m_moveToCol == -1 )
6707         newPos = m_numCols - 1;
6708     else
6709     {
6710         newPos = GetColPos( m_moveToCol );
6711         if ( newPos > GetColPos( m_dragRowOrCol ) )
6712             newPos--;
6713     }
6714
6715     SetColPos( m_dragRowOrCol, newPos );
6716 }
6717
6718 void wxGrid::SetColPos( int colID, int newPos )
6719 {
6720     if ( m_colAt.IsEmpty() )
6721     {
6722         m_colAt.Alloc( m_numCols );
6723
6724         int i;
6725         for ( i = 0; i < m_numCols; i++ )
6726         {
6727             m_colAt.Add( i );
6728         }
6729     }
6730
6731     int oldPos = GetColPos( colID );
6732
6733     //Reshuffle the m_colAt array
6734     if ( newPos > oldPos )
6735     {
6736         int i;
6737         for ( i = oldPos; i < newPos; i++ )
6738         {
6739             m_colAt[i] = m_colAt[i+1];
6740         }
6741     }
6742     else
6743     {
6744         int i;
6745         for ( i = oldPos; i > newPos; i-- )
6746         {
6747             m_colAt[i] = m_colAt[i-1];
6748         }
6749     }
6750
6751     m_colAt[newPos] = colID;
6752
6753     //Recalculate the column rights
6754     if ( !m_colWidths.IsEmpty() )
6755     {
6756         int colRight = 0;
6757         int colPos;
6758         for ( colPos = 0; colPos < m_numCols; colPos++ )
6759         {
6760             int colID = GetColAt( colPos );
6761
6762             colRight += m_colWidths[colID];
6763             m_colRights[colID] = colRight;
6764         }
6765     }
6766
6767     m_colLabelWin->Refresh();
6768     m_gridWin->Refresh();
6769 }
6770
6771
6772
6773 void wxGrid::EnableDragColMove( bool enable )
6774 {
6775     if ( m_canDragColMove == enable )
6776         return;
6777
6778     m_canDragColMove = enable;
6779
6780     if ( !m_canDragColMove )
6781     {
6782         m_colAt.Clear();
6783
6784         //Recalculate the column rights
6785         if ( !m_colWidths.IsEmpty() )
6786         {
6787             int colRight = 0;
6788             int colPos;
6789             for ( colPos = 0; colPos < m_numCols; colPos++ )
6790             {
6791                 colRight += m_colWidths[colPos];
6792                 m_colRights[colPos] = colRight;
6793             }
6794         }
6795
6796         m_colLabelWin->Refresh();
6797         m_gridWin->Refresh();
6798     }
6799 }
6800
6801
6802 //
6803 // ------ interaction with data model
6804 //
6805 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
6806 {
6807     switch ( msg.GetId() )
6808     {
6809         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
6810             return GetModelValues();
6811
6812         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
6813             return SetModelValues();
6814
6815         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
6816         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
6817         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
6818         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
6819         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
6820         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
6821             return Redimension( msg );
6822
6823         default:
6824             return false;
6825     }
6826 }
6827
6828 // The behaviour of this function depends on the grid table class
6829 // Clear() function. For the default wxGridStringTable class the
6830 // behaviour is to replace all cell contents with wxEmptyString but
6831 // not to change the number of rows or cols.
6832 //
6833 void wxGrid::ClearGrid()
6834 {
6835     if ( m_table )
6836     {
6837         if (IsCellEditControlEnabled())
6838             DisableCellEditControl();
6839
6840         m_table->Clear();
6841         if (!GetBatchCount())
6842             m_gridWin->Refresh();
6843     }
6844 }
6845
6846 bool
6847 wxGrid::DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
6848                       int pos, int num, bool WXUNUSED(updateLabels) )
6849 {
6850     wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
6851
6852     if ( !m_table )
6853         return false;
6854
6855     if ( IsCellEditControlEnabled() )
6856         DisableCellEditControl();
6857
6858     return (m_table->*funcModify)(pos, num);
6859
6860     // the table will have sent the results of the insert row
6861     // operation to this view object as a grid table message
6862 }
6863
6864 bool
6865 wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
6866                       int num, bool WXUNUSED(updateLabels))
6867 {
6868     wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
6869
6870     if ( !m_table )
6871         return false;
6872
6873     return (m_table->*funcAppend)(num);
6874 }
6875
6876 //
6877 // ----- event handlers
6878 //
6879
6880 // Generate a grid event based on a mouse event and return:
6881 //  -1 if the event was vetoed
6882 //  +1 if the event was processed (but not vetoed)
6883 //   0 if the event wasn't handled
6884 int
6885 wxGrid::SendEvent(const wxEventType type,
6886                   int row, int col,
6887                   wxMouseEvent& mouseEv)
6888 {
6889    bool claimed, vetoed;
6890
6891    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6892    {
6893        int rowOrCol = (row == -1 ? col : row);
6894
6895        wxGridSizeEvent gridEvt( GetId(),
6896                type,
6897                this,
6898                rowOrCol,
6899                mouseEv.GetX() + GetRowLabelSize(),
6900                mouseEv.GetY() + GetColLabelSize(),
6901                mouseEv);
6902
6903        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6904        vetoed = !gridEvt.IsAllowed();
6905    }
6906    else if ( type == wxEVT_GRID_RANGE_SELECT )
6907    {
6908        // Right now, it should _never_ end up here!
6909        wxGridRangeSelectEvent gridEvt( GetId(),
6910                type,
6911                this,
6912                m_selectedBlockTopLeft,
6913                m_selectedBlockBottomRight,
6914                true,
6915                mouseEv);
6916
6917        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6918        vetoed = !gridEvt.IsAllowed();
6919    }
6920    else if ( type == wxEVT_GRID_LABEL_LEFT_CLICK ||
6921              type == wxEVT_GRID_LABEL_LEFT_DCLICK ||
6922              type == wxEVT_GRID_LABEL_RIGHT_CLICK ||
6923              type == wxEVT_GRID_LABEL_RIGHT_DCLICK )
6924    {
6925        wxPoint pos = mouseEv.GetPosition();
6926
6927        if ( mouseEv.GetEventObject() == GetGridRowLabelWindow() )
6928            pos.y += GetColLabelSize();
6929        if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
6930            pos.x += GetRowLabelSize();
6931
6932        wxGridEvent gridEvt( GetId(),
6933                type,
6934                this,
6935                row, col,
6936                pos.x,
6937                pos.y,
6938                false,
6939                mouseEv);
6940        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6941        vetoed = !gridEvt.IsAllowed();
6942    }
6943    else
6944    {
6945        wxGridEvent gridEvt( GetId(),
6946                type,
6947                this,
6948                row, col,
6949                mouseEv.GetX() + GetRowLabelSize(),
6950                mouseEv.GetY() + GetColLabelSize(),
6951                false,
6952                mouseEv);
6953        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6954        vetoed = !gridEvt.IsAllowed();
6955    }
6956
6957    // A Veto'd event may not be `claimed' so test this first
6958    if (vetoed)
6959        return -1;
6960
6961    return claimed ? 1 : 0;
6962 }
6963
6964 // Generate a grid event of specified type, return value same as above
6965 //
6966 int wxGrid::SendEvent(const wxEventType type, int row, int col)
6967 {
6968    bool claimed, vetoed;
6969
6970     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6971     {
6972         int rowOrCol = (row == -1 ? col : row);
6973
6974         wxGridSizeEvent gridEvt( GetId(), type, this, rowOrCol );
6975
6976         claimed = GetEventHandler()->ProcessEvent(gridEvt);
6977         vetoed  = !gridEvt.IsAllowed();
6978     }
6979     else
6980     {
6981         wxGridEvent gridEvt( GetId(), type, this, row, col );
6982
6983         claimed = GetEventHandler()->ProcessEvent(gridEvt);
6984         vetoed  = !gridEvt.IsAllowed();
6985      }
6986
6987     // A Veto'd event may not be `claimed' so test this first
6988     if (vetoed)
6989         return -1;
6990
6991     return claimed ? 1 : 0;
6992 }
6993
6994 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
6995 {
6996     // needed to prevent zillions of paint events on MSW
6997     wxPaintDC dc(this);
6998 }
6999
7000 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
7001 {
7002     // Don't do anything if between Begin/EndBatch...
7003     // EndBatch() will do all this on the last nested one anyway.
7004     if ( m_created && !GetBatchCount() )
7005     {
7006         // Refresh to get correct scrolled position:
7007         wxScrolledWindow::Refresh(eraseb, rect);
7008
7009         if (rect)
7010         {
7011             int rect_x, rect_y, rectWidth, rectHeight;
7012             int width_label, width_cell, height_label, height_cell;
7013             int x, y;
7014
7015             // Copy rectangle can get scroll offsets..
7016             rect_x = rect->GetX();
7017             rect_y = rect->GetY();
7018             rectWidth = rect->GetWidth();
7019             rectHeight = rect->GetHeight();
7020
7021             width_label = m_rowLabelWidth - rect_x;
7022             if (width_label > rectWidth)
7023                 width_label = rectWidth;
7024
7025             height_label = m_colLabelHeight - rect_y;
7026             if (height_label > rectHeight)
7027                 height_label = rectHeight;
7028
7029             if (rect_x > m_rowLabelWidth)
7030             {
7031                 x = rect_x - m_rowLabelWidth;
7032                 width_cell = rectWidth;
7033             }
7034             else
7035             {
7036                 x = 0;
7037                 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
7038             }
7039
7040             if (rect_y > m_colLabelHeight)
7041             {
7042                 y = rect_y - m_colLabelHeight;
7043                 height_cell = rectHeight;
7044             }
7045             else
7046             {
7047                 y = 0;
7048                 height_cell = rectHeight - (m_colLabelHeight - rect_y);
7049             }
7050
7051             // Paint corner label part intersecting rect.
7052             if ( width_label > 0 && height_label > 0 )
7053             {
7054                 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
7055                 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
7056             }
7057
7058             // Paint col labels part intersecting rect.
7059             if ( width_cell > 0 && height_label > 0 )
7060             {
7061                 wxRect anotherrect(x, rect_y, width_cell, height_label);
7062                 m_colLabelWin->Refresh(eraseb, &anotherrect);
7063             }
7064
7065             // Paint row labels part intersecting rect.
7066             if ( width_label > 0 && height_cell > 0 )
7067             {
7068                 wxRect anotherrect(rect_x, y, width_label, height_cell);
7069                 m_rowLabelWin->Refresh(eraseb, &anotherrect);
7070             }
7071
7072             // Paint cell area part intersecting rect.
7073             if ( width_cell > 0 && height_cell > 0 )
7074             {
7075                 wxRect anotherrect(x, y, width_cell, height_cell);
7076                 m_gridWin->Refresh(eraseb, &anotherrect);
7077             }
7078         }
7079         else
7080         {
7081             m_cornerLabelWin->Refresh(eraseb, NULL);
7082             m_colLabelWin->Refresh(eraseb, NULL);
7083             m_rowLabelWin->Refresh(eraseb, NULL);
7084             m_gridWin->Refresh(eraseb, NULL);
7085         }
7086     }
7087 }
7088
7089 void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
7090 {
7091     if (m_targetWindow != this) // check whether initialisation has been done
7092     {
7093         // reposition our children windows
7094         CalcWindowSizes();
7095     }
7096 }
7097
7098 void wxGrid::OnKeyDown( wxKeyEvent& event )
7099 {
7100     if ( m_inOnKeyDown )
7101     {
7102         // shouldn't be here - we are going round in circles...
7103         //
7104         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
7105     }
7106
7107     m_inOnKeyDown = true;
7108
7109     // propagate the event up and see if it gets processed
7110     wxWindow *parent = GetParent();
7111     wxKeyEvent keyEvt( event );
7112     keyEvt.SetEventObject( parent );
7113
7114     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
7115     {
7116         if (GetLayoutDirection() == wxLayout_RightToLeft)
7117         {
7118             if (event.GetKeyCode() == WXK_RIGHT)
7119                 event.m_keyCode = WXK_LEFT;
7120             else if (event.GetKeyCode() == WXK_LEFT)
7121                 event.m_keyCode = WXK_RIGHT;
7122         }
7123
7124         // try local handlers
7125         switch ( event.GetKeyCode() )
7126         {
7127             case WXK_UP:
7128                 if ( event.ControlDown() )
7129                     MoveCursorUpBlock( event.ShiftDown() );
7130                 else
7131                     MoveCursorUp( event.ShiftDown() );
7132                 break;
7133
7134             case WXK_DOWN:
7135                 if ( event.ControlDown() )
7136                     MoveCursorDownBlock( event.ShiftDown() );
7137                 else
7138                     MoveCursorDown( event.ShiftDown() );
7139                 break;
7140
7141             case WXK_LEFT:
7142                 if ( event.ControlDown() )
7143                     MoveCursorLeftBlock( event.ShiftDown() );
7144                 else
7145                     MoveCursorLeft( event.ShiftDown() );
7146                 break;
7147
7148             case WXK_RIGHT:
7149                 if ( event.ControlDown() )
7150                     MoveCursorRightBlock( event.ShiftDown() );
7151                 else
7152                     MoveCursorRight( event.ShiftDown() );
7153                 break;
7154
7155             case WXK_RETURN:
7156             case WXK_NUMPAD_ENTER:
7157                 if ( event.ControlDown() )
7158                 {
7159                     event.Skip();  // to let the edit control have the return
7160                 }
7161                 else
7162                 {
7163                     if ( GetGridCursorRow() < GetNumberRows()-1 )
7164                     {
7165                         MoveCursorDown( event.ShiftDown() );
7166                     }
7167                     else
7168                     {
7169                         // at the bottom of a column
7170                         DisableCellEditControl();
7171                     }
7172                 }
7173                 break;
7174
7175             case WXK_ESCAPE:
7176                 ClearSelection();
7177                 break;
7178
7179             case WXK_TAB:
7180                 if (event.ShiftDown())
7181                 {
7182                     if ( GetGridCursorCol() > 0 )
7183                     {
7184                         MoveCursorLeft( false );
7185                     }
7186                     else
7187                     {
7188                         // at left of grid
7189                         DisableCellEditControl();
7190                     }
7191                 }
7192                 else
7193                 {
7194                     if ( GetGridCursorCol() < GetNumberCols() - 1 )
7195                     {
7196                         MoveCursorRight( false );
7197                     }
7198                     else
7199                     {
7200                         // at right of grid
7201                         DisableCellEditControl();
7202                     }
7203                 }
7204                 break;
7205
7206             case WXK_HOME:
7207                 if ( event.ControlDown() )
7208                 {
7209                     GoToCell(0, 0);
7210                 }
7211                 else
7212                 {
7213                     event.Skip();
7214                 }
7215                 break;
7216
7217             case WXK_END:
7218                 if ( event.ControlDown() )
7219                 {
7220                     GoToCell(m_numRows - 1, m_numCols - 1);
7221                 }
7222                 else
7223                 {
7224                     event.Skip();
7225                 }
7226                 break;
7227
7228             case WXK_PAGEUP:
7229                 MovePageUp();
7230                 break;
7231
7232             case WXK_PAGEDOWN:
7233                 MovePageDown();
7234                 break;
7235
7236             case WXK_SPACE:
7237                 // Ctrl-Space selects the current column, Shift-Space -- the
7238                 // current row and Ctrl-Shift-Space -- everything
7239                 switch ( m_selection ? event.GetModifiers() : wxMOD_NONE )
7240                 {
7241                     case wxMOD_CONTROL:
7242                         m_selection->SelectCol(m_currentCellCoords.GetCol());
7243                         break;
7244
7245                     case wxMOD_SHIFT:
7246                         m_selection->SelectRow(m_currentCellCoords.GetRow());
7247                         break;
7248
7249                     case wxMOD_CONTROL | wxMOD_SHIFT:
7250                         m_selection->SelectBlock(0, 0,
7251                                                  m_numRows - 1, m_numCols - 1);
7252                         break;
7253
7254                     case wxMOD_NONE:
7255                         if ( !IsEditable() )
7256                         {
7257                             MoveCursorRight(false);
7258                             break;
7259                         }
7260                         //else: fall through
7261
7262                     default:
7263                         event.Skip();
7264                 }
7265                 break;
7266
7267             default:
7268                 event.Skip();
7269                 break;
7270         }
7271     }
7272
7273     m_inOnKeyDown = false;
7274 }
7275
7276 void wxGrid::OnKeyUp( wxKeyEvent& event )
7277 {
7278     // try local handlers
7279     //
7280     if ( event.GetKeyCode() == WXK_SHIFT )
7281     {
7282         if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
7283              m_selectedBlockBottomRight != wxGridNoCellCoords )
7284         {
7285             if ( m_selection )
7286             {
7287                 m_selection->SelectBlock(
7288                     m_selectedBlockTopLeft,
7289                     m_selectedBlockBottomRight,
7290                     event);
7291             }
7292         }
7293
7294         m_selectedBlockTopLeft = wxGridNoCellCoords;
7295         m_selectedBlockBottomRight = wxGridNoCellCoords;
7296         m_selectedBlockCorner = wxGridNoCellCoords;
7297     }
7298 }
7299
7300 void wxGrid::OnChar( wxKeyEvent& event )
7301 {
7302     // is it possible to edit the current cell at all?
7303     if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
7304     {
7305         // yes, now check whether the cells editor accepts the key
7306         int row = m_currentCellCoords.GetRow();
7307         int col = m_currentCellCoords.GetCol();
7308         wxGridCellAttr *attr = GetCellAttr(row, col);
7309         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7310
7311         // <F2> is special and will always start editing, for
7312         // other keys - ask the editor itself
7313         if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
7314              || editor->IsAcceptedKey(event) )
7315         {
7316             // ensure cell is visble
7317             MakeCellVisible(row, col);
7318             EnableCellEditControl();
7319
7320             // a problem can arise if the cell is not completely
7321             // visible (even after calling MakeCellVisible the
7322             // control is not created and calling StartingKey will
7323             // crash the app
7324             if ( event.GetKeyCode() != WXK_F2 && editor->IsCreated() && m_cellEditCtrlEnabled )
7325                 editor->StartingKey(event);
7326         }
7327         else
7328         {
7329             event.Skip();
7330         }
7331
7332         editor->DecRef();
7333         attr->DecRef();
7334     }
7335     else
7336     {
7337         event.Skip();
7338     }
7339 }
7340
7341 void wxGrid::OnEraseBackground(wxEraseEvent&)
7342 {
7343 }
7344
7345 bool wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
7346 {
7347     if ( SendEvent(wxEVT_GRID_SELECT_CELL, coords) == -1 )
7348     {
7349         // the event has been vetoed - do nothing
7350         return false;
7351     }
7352
7353 #if !defined(__WXMAC__)
7354     wxClientDC dc( m_gridWin );
7355     PrepareDC( dc );
7356 #endif
7357
7358     if ( m_currentCellCoords != wxGridNoCellCoords )
7359     {
7360         DisableCellEditControl();
7361
7362         if ( IsVisible( m_currentCellCoords, false ) )
7363         {
7364             wxRect r;
7365             r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
7366             if ( !m_gridLinesEnabled )
7367             {
7368                 r.x--;
7369                 r.y--;
7370                 r.width++;
7371                 r.height++;
7372             }
7373
7374             wxGridCellCoordsArray cells = CalcCellsExposed( r );
7375
7376             // Otherwise refresh redraws the highlight!
7377             m_currentCellCoords = coords;
7378
7379 #if defined(__WXMAC__)
7380             m_gridWin->Refresh(true /*, & r */);
7381 #else
7382             DrawGridCellArea( dc, cells );
7383             DrawAllGridLines( dc, r );
7384 #endif
7385         }
7386     }
7387
7388     m_currentCellCoords = coords;
7389
7390     wxGridCellAttr *attr = GetCellAttr( coords );
7391 #if !defined(__WXMAC__)
7392     DrawCellHighlight( dc, attr );
7393 #endif
7394     attr->DecRef();
7395
7396     return true;
7397 }
7398
7399 void
7400 wxGrid::UpdateBlockBeingSelected(int topRow, int leftCol,
7401                                  int bottomRow, int rightCol)
7402 {
7403     if ( m_selection )
7404     {
7405         switch ( m_selection->GetSelectionMode() )
7406         {
7407             default:
7408                 wxFAIL_MSG( "unknown selection mode" );
7409                 // fall through
7410
7411             case wxGridSelectCells:
7412                 // arbitrary blocks selection allowed so just use the cell
7413                 // coordinates as is
7414                 break;
7415
7416             case wxGridSelectRows:
7417                 // only full rows selection allowd, ensure that we do select
7418                 // full rows
7419                 leftCol = 0;
7420                 rightCol = GetNumberCols() - 1;
7421                 break;
7422
7423             case wxGridSelectColumns:
7424                 // same as above but for columns
7425                 topRow = 0;
7426                 bottomRow = GetNumberRows() - 1;
7427                 break;
7428
7429             case wxGridSelectRowsOrColumns:
7430                 // in this mode we can select only full rows or full columns so
7431                 // it doesn't make sense to select blocks at all (and we can't
7432                 // extend the block because there is no preferred direction, we
7433                 // could only extend it to cover the entire grid but this is
7434                 // not useful)
7435                 return;
7436         }
7437     }
7438
7439     m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
7440     MakeCellVisible(m_selectedBlockCorner);
7441
7442     EnsureFirstLessThanSecond(topRow, bottomRow);
7443     EnsureFirstLessThanSecond(leftCol, rightCol);
7444
7445     wxGridCellCoords updateTopLeft = wxGridCellCoords(topRow, leftCol),
7446                      updateBottomRight = wxGridCellCoords(bottomRow, rightCol);
7447
7448     // First the case that we selected a completely new area
7449     if ( m_selectedBlockTopLeft == wxGridNoCellCoords ||
7450          m_selectedBlockBottomRight == wxGridNoCellCoords )
7451     {
7452         wxRect rect;
7453         rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
7454                                   wxGridCellCoords ( bottomRow, rightCol ) );
7455         m_gridWin->Refresh( false, &rect );
7456     }
7457
7458     // Now handle changing an existing selection area.
7459     else if ( m_selectedBlockTopLeft != updateTopLeft ||
7460               m_selectedBlockBottomRight != updateBottomRight )
7461     {
7462         // Compute two optimal update rectangles:
7463         // Either one rectangle is a real subset of the
7464         // other, or they are (almost) disjoint!
7465         wxRect  rect[4];
7466         bool    need_refresh[4];
7467         need_refresh[0] =
7468         need_refresh[1] =
7469         need_refresh[2] =
7470         need_refresh[3] = false;
7471         int     i;
7472
7473         // Store intermediate values
7474         wxCoord oldLeft = m_selectedBlockTopLeft.GetCol();
7475         wxCoord oldTop = m_selectedBlockTopLeft.GetRow();
7476         wxCoord oldRight = m_selectedBlockBottomRight.GetCol();
7477         wxCoord oldBottom = m_selectedBlockBottomRight.GetRow();
7478
7479         // Determine the outer/inner coordinates.
7480         EnsureFirstLessThanSecond(oldLeft, leftCol);
7481         EnsureFirstLessThanSecond(oldTop, topRow);
7482         EnsureFirstLessThanSecond(rightCol, oldRight);
7483         EnsureFirstLessThanSecond(bottomRow, oldBottom);
7484
7485         // Now, either the stuff marked old is the outer
7486         // rectangle or we don't have a situation where one
7487         // is contained in the other.
7488
7489         if ( oldLeft < leftCol )
7490         {
7491             // Refresh the newly selected or deselected
7492             // area to the left of the old or new selection.
7493             need_refresh[0] = true;
7494             rect[0] = BlockToDeviceRect(
7495                 wxGridCellCoords( oldTop,  oldLeft ),
7496                 wxGridCellCoords( oldBottom, leftCol - 1 ) );
7497         }
7498
7499         if ( oldTop < topRow )
7500         {
7501             // Refresh the newly selected or deselected
7502             // area above the old or new selection.
7503             need_refresh[1] = true;
7504             rect[1] = BlockToDeviceRect(
7505                 wxGridCellCoords( oldTop, leftCol ),
7506                 wxGridCellCoords( topRow - 1, rightCol ) );
7507         }
7508
7509         if ( oldRight > rightCol )
7510         {
7511             // Refresh the newly selected or deselected
7512             // area to the right of the old or new selection.
7513             need_refresh[2] = true;
7514             rect[2] = BlockToDeviceRect(
7515                 wxGridCellCoords( oldTop, rightCol + 1 ),
7516                 wxGridCellCoords( oldBottom, oldRight ) );
7517         }
7518
7519         if ( oldBottom > bottomRow )
7520         {
7521             // Refresh the newly selected or deselected
7522             // area below the old or new selection.
7523             need_refresh[3] = true;
7524             rect[3] = BlockToDeviceRect(
7525                 wxGridCellCoords( bottomRow + 1, leftCol ),
7526                 wxGridCellCoords( oldBottom, rightCol ) );
7527         }
7528
7529         // various Refresh() calls
7530         for (i = 0; i < 4; i++ )
7531             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
7532                 m_gridWin->Refresh( false, &(rect[i]) );
7533     }
7534
7535     // change selection
7536     m_selectedBlockTopLeft = updateTopLeft;
7537     m_selectedBlockBottomRight = updateBottomRight;
7538 }
7539
7540 //
7541 // ------ functions to get/send data (see also public functions)
7542 //
7543
7544 bool wxGrid::GetModelValues()
7545 {
7546     // Hide the editor, so it won't hide a changed value.
7547     HideCellEditControl();
7548
7549     if ( m_table )
7550     {
7551         // all we need to do is repaint the grid
7552         //
7553         m_gridWin->Refresh();
7554         return true;
7555     }
7556
7557     return false;
7558 }
7559
7560 bool wxGrid::SetModelValues()
7561 {
7562     int row, col;
7563
7564     // Disable the editor, so it won't hide a changed value.
7565     // Do we also want to save the current value of the editor first?
7566     // I think so ...
7567     DisableCellEditControl();
7568
7569     if ( m_table )
7570     {
7571         for ( row = 0; row < m_numRows; row++ )
7572         {
7573             for ( col = 0; col < m_numCols; col++ )
7574             {
7575                 m_table->SetValue( row, col, GetCellValue(row, col) );
7576             }
7577         }
7578
7579         return true;
7580     }
7581
7582     return false;
7583 }
7584
7585 // Note - this function only draws cells that are in the list of
7586 // exposed cells (usually set from the update region by
7587 // CalcExposedCells)
7588 //
7589 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
7590 {
7591     if ( !m_numRows || !m_numCols )
7592         return;
7593
7594     int i, numCells = cells.GetCount();
7595     int row, col, cell_rows, cell_cols;
7596     wxGridCellCoordsArray redrawCells;
7597
7598     for ( i = numCells - 1; i >= 0; i-- )
7599     {
7600         row = cells[i].GetRow();
7601         col = cells[i].GetCol();
7602         GetCellSize( row, col, &cell_rows, &cell_cols );
7603
7604         // If this cell is part of a multicell block, find owner for repaint
7605         if ( cell_rows <= 0 || cell_cols <= 0 )
7606         {
7607             wxGridCellCoords cell( row + cell_rows, col + cell_cols );
7608             bool marked = false;
7609             for ( int j = 0; j < numCells; j++ )
7610             {
7611                 if ( cell == cells[j] )
7612                 {
7613                     marked = true;
7614                     break;
7615                 }
7616             }
7617
7618             if (!marked)
7619             {
7620                 int count = redrawCells.GetCount();
7621                 for (int j = 0; j < count; j++)
7622                 {
7623                     if ( cell == redrawCells[j] )
7624                     {
7625                         marked = true;
7626                         break;
7627                     }
7628                 }
7629
7630                 if (!marked)
7631                     redrawCells.Add( cell );
7632             }
7633
7634             // don't bother drawing this cell
7635             continue;
7636         }
7637
7638         // If this cell is empty, find cell to left that might want to overflow
7639         if (m_table && m_table->IsEmptyCell(row, col))
7640         {
7641             for ( int l = 0; l < cell_rows; l++ )
7642             {
7643                 // find a cell in this row to leave already marked for repaint
7644                 int left = col;
7645                 for (int k = 0; k < int(redrawCells.GetCount()); k++)
7646                     if ((redrawCells[k].GetCol() < left) &&
7647                         (redrawCells[k].GetRow() == row))
7648                     {
7649                         left = redrawCells[k].GetCol();
7650                     }
7651
7652                 if (left == col)
7653                     left = 0; // oh well
7654
7655                 for (int j = col - 1; j >= left; j--)
7656                 {
7657                     if (!m_table->IsEmptyCell(row + l, j))
7658                     {
7659                         if (GetCellOverflow(row + l, j))
7660                         {
7661                             wxGridCellCoords cell(row + l, j);
7662                             bool marked = false;
7663
7664                             for (int k = 0; k < numCells; k++)
7665                             {
7666                                 if ( cell == cells[k] )
7667                                 {
7668                                     marked = true;
7669                                     break;
7670                                 }
7671                             }
7672
7673                             if (!marked)
7674                             {
7675                                 int count = redrawCells.GetCount();
7676                                 for (int k = 0; k < count; k++)
7677                                 {
7678                                     if ( cell == redrawCells[k] )
7679                                     {
7680                                         marked = true;
7681                                         break;
7682                                     }
7683                                 }
7684                                 if (!marked)
7685                                     redrawCells.Add( cell );
7686                             }
7687                         }
7688                         break;
7689                     }
7690                 }
7691             }
7692         }
7693
7694         DrawCell( dc, cells[i] );
7695     }
7696
7697     numCells = redrawCells.GetCount();
7698
7699     for ( i = numCells - 1; i >= 0; i-- )
7700     {
7701         DrawCell( dc, redrawCells[i] );
7702     }
7703 }
7704
7705 void wxGrid::DrawGridSpace( wxDC& dc )
7706 {
7707   int cw, ch;
7708   m_gridWin->GetClientSize( &cw, &ch );
7709
7710   int right, bottom;
7711   CalcUnscrolledPosition( cw, ch, &right, &bottom );
7712
7713   int rightCol = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) : 0;
7714   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
7715
7716   if ( right > rightCol || bottom > bottomRow )
7717   {
7718       int left, top;
7719       CalcUnscrolledPosition( 0, 0, &left, &top );
7720
7721       dc.SetBrush(GetDefaultCellBackgroundColour());
7722       dc.SetPen( *wxTRANSPARENT_PEN );
7723
7724       if ( right > rightCol )
7725       {
7726           dc.DrawRectangle( rightCol, top, right - rightCol, ch );
7727       }
7728
7729       if ( bottom > bottomRow )
7730       {
7731           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow );
7732       }
7733   }
7734 }
7735
7736 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
7737 {
7738     int row = coords.GetRow();
7739     int col = coords.GetCol();
7740
7741     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7742         return;
7743
7744     // we draw the cell border ourselves
7745     wxGridCellAttr* attr = GetCellAttr(row, col);
7746
7747     bool isCurrent = coords == m_currentCellCoords;
7748
7749     wxRect rect = CellToRect( row, col );
7750
7751     // if the editor is shown, we should use it and not the renderer
7752     // Note: However, only if it is really _shown_, i.e. not hidden!
7753     if ( isCurrent && IsCellEditControlShown() )
7754     {
7755         // NB: this "#if..." is temporary and fixes a problem where the
7756         // edit control is erased by this code after being rendered.
7757         // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
7758         // implicitly, causing this out-of order render.
7759 #if !defined(__WXMAC__)
7760         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7761         editor->PaintBackground(rect, attr);
7762         editor->DecRef();
7763 #endif
7764     }
7765     else
7766     {
7767         // but all the rest is drawn by the cell renderer and hence may be customized
7768         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
7769         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
7770         renderer->DecRef();
7771     }
7772
7773     attr->DecRef();
7774 }
7775
7776 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
7777 {
7778     // don't show highlight when the grid doesn't have focus
7779     if ( !HasFocus() )
7780         return;
7781
7782     int row = m_currentCellCoords.GetRow();
7783     int col = m_currentCellCoords.GetCol();
7784
7785     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7786         return;
7787
7788     wxRect rect = CellToRect(row, col);
7789
7790     // hmmm... what could we do here to show that the cell is disabled?
7791     // for now, I just draw a thinner border than for the other ones, but
7792     // it doesn't look really good
7793
7794     int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
7795
7796     if (penWidth > 0)
7797     {
7798         // The center of the drawn line is where the position/width/height of
7799         // the rectangle is actually at (on wxMSW at least), so the
7800         // size of the rectangle is reduced to compensate for the thickness of
7801         // the line. If this is too strange on non-wxMSW platforms then
7802         // please #ifdef this appropriately.
7803         rect.x += penWidth / 2;
7804         rect.y += penWidth / 2;
7805         rect.width -= penWidth - 1;
7806         rect.height -= penWidth - 1;
7807
7808         // Now draw the rectangle
7809         // use the cellHighlightColour if the cell is inside a selection, this
7810         // will ensure the cell is always visible.
7811         dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground
7812                                                : m_cellHighlightColour,
7813                         penWidth));
7814         dc.SetBrush(*wxTRANSPARENT_BRUSH);
7815         dc.DrawRectangle(rect);
7816     }
7817 }
7818
7819 wxPen wxGrid::GetDefaultGridLinePen()
7820 {
7821     return wxPen(GetGridLineColour());
7822 }
7823
7824 wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
7825 {
7826     return GetDefaultGridLinePen();
7827 }
7828
7829 wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
7830 {
7831     return GetDefaultGridLinePen();
7832 }
7833
7834 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
7835 {
7836     int row = coords.GetRow();
7837     int col = coords.GetCol();
7838     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7839         return;
7840
7841
7842     wxRect rect = CellToRect( row, col );
7843
7844     // right hand border
7845     dc.SetPen( GetColGridLinePen(col) );
7846     dc.DrawLine( rect.x + rect.width, rect.y,
7847                  rect.x + rect.width, rect.y + rect.height + 1 );
7848
7849     // bottom border
7850     dc.SetPen( GetRowGridLinePen(row) );
7851     dc.DrawLine( rect.x, rect.y + rect.height,
7852                  rect.x + rect.width, rect.y + rect.height);
7853 }
7854
7855 void wxGrid::DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells)
7856 {
7857     // This if block was previously in wxGrid::OnPaint but that doesn't
7858     // seem to get called under wxGTK - MB
7859     //
7860     if ( m_currentCellCoords == wxGridNoCellCoords &&
7861          m_numRows && m_numCols )
7862     {
7863         m_currentCellCoords.Set(0, 0);
7864     }
7865
7866     if ( IsCellEditControlShown() )
7867     {
7868         // don't show highlight when the edit control is shown
7869         return;
7870     }
7871
7872     // if the active cell was repainted, repaint its highlight too because it
7873     // might have been damaged by the grid lines
7874     size_t count = cells.GetCount();
7875     for ( size_t n = 0; n < count; n++ )
7876     {
7877         wxGridCellCoords cell = cells[n];
7878
7879         // If we are using attributes, then we may have just exposed another
7880         // cell in a partially-visible merged cluster of cells. If the "anchor"
7881         // (upper left) cell of this merged cluster is the cell indicated by
7882         // m_currentCellCoords, then we need to refresh the cell highlight even
7883         // though the "anchor" itself is not part of our update segment.
7884         if ( CanHaveAttributes() )
7885         {
7886             int rows = 0,
7887                 cols = 0;
7888             GetCellSize(cell.GetRow(), cell.GetCol(), &rows, &cols);
7889
7890             if ( rows < 0 )
7891                 cell.SetRow(cell.GetRow() + rows);
7892
7893             if ( cols < 0 )
7894                 cell.SetCol(cell.GetCol() + cols);
7895         }
7896
7897         if ( cell == m_currentCellCoords )
7898         {
7899             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7900             DrawCellHighlight(dc, attr);
7901             attr->DecRef();
7902
7903             break;
7904         }
7905     }
7906 }
7907
7908 // This is used to redraw all grid lines e.g. when the grid line colour
7909 // has been changed
7910 //
7911 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
7912 {
7913     if ( !m_gridLinesEnabled || !m_numRows || !m_numCols )
7914          return;
7915
7916     int top, bottom, left, right;
7917
7918     int cw, ch;
7919     m_gridWin->GetClientSize(&cw, &ch);
7920     CalcUnscrolledPosition( 0, 0, &left, &top );
7921     CalcUnscrolledPosition( cw, ch, &right, &bottom );
7922
7923     // avoid drawing grid lines past the last row and col
7924     //
7925     right = wxMin( right, GetColRight(GetColAt( m_numCols - 1 )) );
7926     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
7927
7928     // no gridlines inside multicells, clip them out
7929     int leftCol = GetColPos( internalXToCol(left) );
7930     int topRow = internalYToRow(top);
7931     int rightCol = GetColPos( internalXToCol(right) );
7932     int bottomRow = internalYToRow(bottom);
7933
7934     wxRegion clippedcells(0, 0, cw, ch);
7935
7936     int cell_rows, cell_cols;
7937     wxRect rect;
7938
7939     for ( int j = topRow; j <= bottomRow; j++ )
7940     {
7941         for ( int colPos = leftCol; colPos <= rightCol; colPos++ )
7942         {
7943             int i = GetColAt( colPos );
7944
7945             GetCellSize( j, i, &cell_rows, &cell_cols );
7946             if ((cell_rows > 1) || (cell_cols > 1))
7947             {
7948                 rect = CellToRect(j,i);
7949                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7950                 clippedcells.Subtract(rect);
7951             }
7952             else if ((cell_rows < 0) || (cell_cols < 0))
7953             {
7954                 rect = CellToRect(j + cell_rows, i + cell_cols);
7955                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7956                 clippedcells.Subtract(rect);
7957             }
7958         }
7959     }
7960
7961     dc.SetDeviceClippingRegion( clippedcells );
7962
7963
7964     // horizontal grid lines
7965     for ( int i = internalYToRow(top); i < m_numRows; i++ )
7966     {
7967         int bot = GetRowBottom(i) - 1;
7968
7969         if ( bot > bottom )
7970             break;
7971
7972         if ( bot >= top )
7973         {
7974             dc.SetPen( GetRowGridLinePen(i) );
7975             dc.DrawLine( left, bot, right, bot );
7976         }
7977     }
7978
7979     // vertical grid lines
7980     for ( int colPos = leftCol; colPos < m_numCols; colPos++ )
7981     {
7982         int i = GetColAt( colPos );
7983
7984         int colRight = GetColRight(i);
7985 #ifdef __WXGTK__
7986         if (GetLayoutDirection() != wxLayout_RightToLeft)
7987 #endif
7988             colRight--;
7989
7990         if ( colRight > right )
7991             break;
7992
7993         if ( colRight >= left )
7994         {
7995             dc.SetPen( GetColGridLinePen(i) );
7996             dc.DrawLine( colRight, top, colRight, bottom );
7997         }
7998     }
7999
8000     dc.DestroyClippingRegion();
8001 }
8002
8003 void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
8004 {
8005     if ( !m_numRows )
8006         return;
8007
8008     const size_t numLabels = rows.GetCount();
8009     for ( size_t i = 0; i < numLabels; i++ )
8010     {
8011         DrawRowLabel( dc, rows[i] );
8012     }
8013 }
8014
8015 void wxGrid::DrawRowLabel( wxDC& dc, int row )
8016 {
8017     if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
8018         return;
8019
8020     wxRect rect;
8021
8022     int rowTop = GetRowTop(row),
8023         rowBottom = GetRowBottom(row) - 1;
8024
8025     dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
8026     dc.DrawLine( m_rowLabelWidth - 1, rowTop, m_rowLabelWidth - 1, rowBottom );
8027     dc.DrawLine( 0, rowTop, 0, rowBottom );
8028     dc.DrawLine( 0, rowBottom, m_rowLabelWidth, rowBottom );
8029
8030     dc.SetPen( *wxWHITE_PEN );
8031     dc.DrawLine( 1, rowTop, 1, rowBottom );
8032     dc.DrawLine( 1, rowTop, m_rowLabelWidth - 1, rowTop );
8033
8034     dc.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT );
8035     dc.SetTextForeground( GetLabelTextColour() );
8036     dc.SetFont( GetLabelFont() );
8037
8038     int hAlign, vAlign;
8039     GetRowLabelAlignment( &hAlign, &vAlign );
8040
8041     rect.SetX( 2 );
8042     rect.SetY( GetRowTop(row) + 2 );
8043     rect.SetWidth( m_rowLabelWidth - 4 );
8044     rect.SetHeight( GetRowHeight(row) - 4 );
8045     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
8046 }
8047
8048 void wxGrid::SetUseNativeColLabels( bool native )
8049 {
8050     m_nativeColumnLabels = native;
8051     if (native)
8052     {
8053         int height = wxRendererNative::Get().GetHeaderButtonHeight( this );
8054         SetColLabelSize( height );
8055     }
8056
8057     m_colLabelWin->Refresh();
8058     m_cornerLabelWin->Refresh();
8059 }
8060
8061 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
8062 {
8063     if ( !m_numCols )
8064         return;
8065
8066     const size_t numLabels = cols.GetCount();
8067     for ( size_t i = 0; i < numLabels; i++ )
8068     {
8069         DrawColLabel( dc, cols[i] );
8070     }
8071 }
8072
8073 void wxGrid::DrawCornerLabel(wxDC& dc)
8074 {
8075     if ( m_nativeColumnLabels )
8076     {
8077         wxRect rect(wxSize(m_rowLabelWidth, m_colLabelHeight));
8078         rect.Deflate(1);
8079
8080         wxRendererNative::Get().DrawHeaderButton(m_cornerLabelWin, dc, rect, 0);
8081     }
8082     else
8083     {
8084         dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
8085         dc.DrawLine( m_rowLabelWidth - 1, m_colLabelHeight - 1,
8086                      m_rowLabelWidth - 1, 0 );
8087         dc.DrawLine( m_rowLabelWidth - 1, m_colLabelHeight - 1,
8088                      0, m_colLabelHeight - 1 );
8089         dc.DrawLine( 0, 0, m_rowLabelWidth, 0 );
8090         dc.DrawLine( 0, 0, 0, m_colLabelHeight );
8091
8092         dc.SetPen( *wxWHITE_PEN );
8093         dc.DrawLine( 1, 1, m_rowLabelWidth - 1, 1 );
8094         dc.DrawLine( 1, 1, 1, m_colLabelHeight - 1 );
8095     }
8096 }
8097
8098 void wxGrid::DrawColLabel(wxDC& dc, int col)
8099 {
8100     if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
8101         return;
8102
8103     int colLeft = GetColLeft(col);
8104
8105     wxRect rect(colLeft, 0, GetColWidth(col), m_colLabelHeight);
8106
8107     if ( m_nativeColumnLabels )
8108     {
8109         wxRendererNative::Get().DrawHeaderButton(m_colLabelWin, dc, rect, 0);
8110     }
8111     else
8112     {
8113         int colRight = GetColRight(col) - 1;
8114
8115         dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
8116         dc.DrawLine( colRight, 0,
8117                      colRight, m_colLabelHeight - 1 );
8118         dc.DrawLine( colLeft, 0,
8119                      colRight, 0 );
8120         dc.DrawLine( colLeft, m_colLabelHeight - 1,
8121                      colRight + 1, m_colLabelHeight - 1 );
8122
8123         dc.SetPen( *wxWHITE_PEN );
8124         dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight - 1 );
8125         dc.DrawLine( colLeft, 1, colRight, 1 );
8126     }
8127
8128     dc.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT );
8129     dc.SetTextForeground( GetLabelTextColour() );
8130     dc.SetFont( GetLabelFont() );
8131
8132     int hAlign, vAlign;
8133     GetColLabelAlignment( &hAlign, &vAlign );
8134     const int orient = GetColLabelTextOrientation();
8135
8136     rect.Deflate(2);
8137     DrawTextRectangle(dc, GetColLabelValue(col), rect, hAlign, vAlign, orient);
8138 }
8139
8140 // TODO: these 2 functions should be replaced with wxDC::DrawLabel() to which
8141 //       we just have to add textOrientation support
8142 void wxGrid::DrawTextRectangle( wxDC& dc,
8143                                 const wxString& value,
8144                                 const wxRect& rect,
8145                                 int horizAlign,
8146                                 int vertAlign,
8147                                 int textOrientation )
8148 {
8149     wxArrayString lines;
8150
8151     StringToLines( value, lines );
8152
8153     DrawTextRectangle(dc, lines, rect, horizAlign, vertAlign, textOrientation);
8154 }
8155
8156 void wxGrid::DrawTextRectangle(wxDC& dc,
8157                                const wxArrayString& lines,
8158                                const wxRect& rect,
8159                                int horizAlign,
8160                                int vertAlign,
8161                                int textOrientation)
8162 {
8163     if ( lines.empty() )
8164         return;
8165
8166     wxDCClipper clip(dc, rect);
8167
8168     long textWidth,
8169          textHeight;
8170
8171     if ( textOrientation == wxHORIZONTAL )
8172         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
8173     else
8174         GetTextBoxSize( dc, lines, &textHeight, &textWidth );
8175
8176     int x = 0,
8177         y = 0;
8178     switch ( vertAlign )
8179     {
8180         case wxALIGN_BOTTOM:
8181             if ( textOrientation == wxHORIZONTAL )
8182                 y = rect.y + (rect.height - textHeight - 1);
8183             else
8184                 x = rect.x + rect.width - textWidth;
8185             break;
8186
8187         case wxALIGN_CENTRE:
8188             if ( textOrientation == wxHORIZONTAL )
8189                 y = rect.y + ((rect.height - textHeight) / 2);
8190             else
8191                 x = rect.x + ((rect.width - textWidth) / 2);
8192             break;
8193
8194         case wxALIGN_TOP:
8195         default:
8196             if ( textOrientation == wxHORIZONTAL )
8197                 y = rect.y + 1;
8198             else
8199                 x = rect.x + 1;
8200             break;
8201     }
8202
8203     // Align each line of a multi-line label
8204     size_t nLines = lines.GetCount();
8205     for ( size_t l = 0; l < nLines; l++ )
8206     {
8207         const wxString& line = lines[l];
8208
8209         if ( line.empty() )
8210         {
8211             *(textOrientation == wxHORIZONTAL ? &y : &x) += dc.GetCharHeight();
8212             continue;
8213         }
8214
8215         wxCoord lineWidth = 0,
8216              lineHeight = 0;
8217         dc.GetTextExtent(line, &lineWidth, &lineHeight);
8218
8219         switch ( horizAlign )
8220         {
8221             case wxALIGN_RIGHT:
8222                 if ( textOrientation == wxHORIZONTAL )
8223                     x = rect.x + (rect.width - lineWidth - 1);
8224                 else
8225                     y = rect.y + lineWidth + 1;
8226                 break;
8227
8228             case wxALIGN_CENTRE:
8229                 if ( textOrientation == wxHORIZONTAL )
8230                     x = rect.x + ((rect.width - lineWidth) / 2);
8231                 else
8232                     y = rect.y + rect.height - ((rect.height - lineWidth) / 2);
8233                 break;
8234
8235             case wxALIGN_LEFT:
8236             default:
8237                 if ( textOrientation == wxHORIZONTAL )
8238                     x = rect.x + 1;
8239                 else
8240                     y = rect.y + rect.height - 1;
8241                 break;
8242         }
8243
8244         if ( textOrientation == wxHORIZONTAL )
8245         {
8246             dc.DrawText( line, x, y );
8247             y += lineHeight;
8248         }
8249         else
8250         {
8251             dc.DrawRotatedText( line, x, y, 90.0 );
8252             x += lineHeight;
8253         }
8254     }
8255 }
8256
8257 // Split multi-line text up into an array of strings.
8258 // Any existing contents of the string array are preserved.
8259 //
8260 // TODO: refactor wxTextFile::Read() and reuse the same code from here
8261 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
8262 {
8263     int startPos = 0;
8264     int pos;
8265     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
8266     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
8267
8268     while ( startPos < (int)tVal.length() )
8269     {
8270         pos = tVal.Mid(startPos).Find( eol );
8271         if ( pos < 0 )
8272         {
8273             break;
8274         }
8275         else if ( pos == 0 )
8276         {
8277             lines.Add( wxEmptyString );
8278         }
8279         else
8280         {
8281             lines.Add( tVal.Mid(startPos, pos) );
8282         }
8283
8284         startPos += pos + 1;
8285     }
8286
8287     if ( startPos < (int)tVal.length() )
8288     {
8289         lines.Add( tVal.Mid( startPos ) );
8290     }
8291 }
8292
8293 void wxGrid::GetTextBoxSize( const wxDC& dc,
8294                              const wxArrayString& lines,
8295                              long *width, long *height ) const
8296 {
8297     wxCoord w = 0;
8298     wxCoord h = 0;
8299     wxCoord lineW = 0, lineH = 0;
8300
8301     size_t i;
8302     for ( i = 0; i < lines.GetCount(); i++ )
8303     {
8304         dc.GetTextExtent( lines[i], &lineW, &lineH );
8305         w = wxMax( w, lineW );
8306         h += lineH;
8307     }
8308
8309     *width = w;
8310     *height = h;
8311 }
8312
8313 //
8314 // ------ Batch processing.
8315 //
8316 void wxGrid::EndBatch()
8317 {
8318     if ( m_batchCount > 0 )
8319     {
8320         m_batchCount--;
8321         if ( !m_batchCount )
8322         {
8323             CalcDimensions();
8324             m_rowLabelWin->Refresh();
8325             m_colLabelWin->Refresh();
8326             m_cornerLabelWin->Refresh();
8327             m_gridWin->Refresh();
8328         }
8329     }
8330 }
8331
8332 // Use this, rather than wxWindow::Refresh(), to force an immediate
8333 // repainting of the grid. Has no effect if you are already inside a
8334 // BeginBatch / EndBatch block.
8335 //
8336 void wxGrid::ForceRefresh()
8337 {
8338     BeginBatch();
8339     EndBatch();
8340 }
8341
8342 bool wxGrid::Enable(bool enable)
8343 {
8344     if ( !wxScrolledWindow::Enable(enable) )
8345         return false;
8346
8347     // redraw in the new state
8348     m_gridWin->Refresh();
8349
8350     return true;
8351 }
8352
8353 //
8354 // ------ Edit control functions
8355 //
8356
8357 void wxGrid::EnableEditing( bool edit )
8358 {
8359     if ( edit != m_editable )
8360     {
8361         if (!edit)
8362             EnableCellEditControl(edit);
8363         m_editable = edit;
8364     }
8365 }
8366
8367 void wxGrid::EnableCellEditControl( bool enable )
8368 {
8369     if (! m_editable)
8370         return;
8371
8372     if ( enable != m_cellEditCtrlEnabled )
8373     {
8374         if ( enable )
8375         {
8376             if ( SendEvent(wxEVT_GRID_EDITOR_SHOWN) == -1 )
8377                 return;
8378
8379             // this should be checked by the caller!
8380             wxASSERT_MSG( CanEnableCellControl(), _T("can't enable editing for this cell!") );
8381
8382             // do it before ShowCellEditControl()
8383             m_cellEditCtrlEnabled = enable;
8384
8385             ShowCellEditControl();
8386         }
8387         else
8388         {
8389             //FIXME:add veto support
8390             SendEvent(wxEVT_GRID_EDITOR_HIDDEN);
8391
8392             HideCellEditControl();
8393             SaveEditControlValue();
8394
8395             // do it after HideCellEditControl()
8396             m_cellEditCtrlEnabled = enable;
8397         }
8398     }
8399 }
8400
8401 bool wxGrid::IsCurrentCellReadOnly() const
8402 {
8403     // const_cast
8404     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
8405     bool readonly = attr->IsReadOnly();
8406     attr->DecRef();
8407
8408     return readonly;
8409 }
8410
8411 bool wxGrid::CanEnableCellControl() const
8412 {
8413     return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
8414         !IsCurrentCellReadOnly();
8415 }
8416
8417 bool wxGrid::IsCellEditControlEnabled() const
8418 {
8419     // the cell edit control might be disable for all cells or just for the
8420     // current one if it's read only
8421     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
8422 }
8423
8424 bool wxGrid::IsCellEditControlShown() const
8425 {
8426     bool isShown = false;
8427
8428     if ( m_cellEditCtrlEnabled )
8429     {
8430         int row = m_currentCellCoords.GetRow();
8431         int col = m_currentCellCoords.GetCol();
8432         wxGridCellAttr* attr = GetCellAttr(row, col);
8433         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
8434         attr->DecRef();
8435
8436         if ( editor )
8437         {
8438             if ( editor->IsCreated() )
8439             {
8440                 isShown = editor->GetControl()->IsShown();
8441             }
8442
8443             editor->DecRef();
8444         }
8445     }
8446
8447     return isShown;
8448 }
8449
8450 void wxGrid::ShowCellEditControl()
8451 {
8452     if ( IsCellEditControlEnabled() )
8453     {
8454         if ( !IsVisible( m_currentCellCoords, false ) )
8455         {
8456             m_cellEditCtrlEnabled = false;
8457             return;
8458         }
8459         else
8460         {
8461             wxRect rect = CellToRect( m_currentCellCoords );
8462             int row = m_currentCellCoords.GetRow();
8463             int col = m_currentCellCoords.GetCol();
8464
8465             // if this is part of a multicell, find owner (topleft)
8466             int cell_rows, cell_cols;
8467             GetCellSize( row, col, &cell_rows, &cell_cols );
8468             if ( cell_rows <= 0 || cell_cols <= 0 )
8469             {
8470                 row += cell_rows;
8471                 col += cell_cols;
8472                 m_currentCellCoords.SetRow( row );
8473                 m_currentCellCoords.SetCol( col );
8474             }
8475
8476             // erase the highlight and the cell contents because the editor
8477             // might not cover the entire cell
8478             wxClientDC dc( m_gridWin );
8479             PrepareDC( dc );
8480             wxGridCellAttr* attr = GetCellAttr(row, col);
8481             dc.SetBrush(wxBrush(attr->GetBackgroundColour()));
8482             dc.SetPen(*wxTRANSPARENT_PEN);
8483             dc.DrawRectangle(rect);
8484
8485             // convert to scrolled coords
8486             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
8487
8488             int nXMove = 0;
8489             if (rect.x < 0)
8490                 nXMove = rect.x;
8491
8492             // cell is shifted by one pixel
8493             // However, don't allow x or y to become negative
8494             // since the SetSize() method interprets that as
8495             // "don't change."
8496             if (rect.x > 0)
8497                 rect.x--;
8498             if (rect.y > 0)
8499                 rect.y--;
8500
8501             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8502             if ( !editor->IsCreated() )
8503             {
8504                 editor->Create(m_gridWin, wxID_ANY,
8505                                new wxGridCellEditorEvtHandler(this, editor));
8506
8507                 wxGridEditorCreatedEvent evt(GetId(),
8508                                              wxEVT_GRID_EDITOR_CREATED,
8509                                              this,
8510                                              row,
8511                                              col,
8512                                              editor->GetControl());
8513                 GetEventHandler()->ProcessEvent(evt);
8514             }
8515
8516             // resize editor to overflow into righthand cells if allowed
8517             int maxWidth = rect.width;
8518             wxString value = GetCellValue(row, col);
8519             if ( (value != wxEmptyString) && (attr->GetOverflow()) )
8520             {
8521                 int y;
8522                 GetTextExtent(value, &maxWidth, &y, NULL, NULL, &attr->GetFont());
8523                 if (maxWidth < rect.width)
8524                     maxWidth = rect.width;
8525             }
8526
8527             int client_right = m_gridWin->GetClientSize().GetWidth();
8528             if (rect.x + maxWidth > client_right)
8529                 maxWidth = client_right - rect.x;
8530
8531             if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
8532             {
8533                 GetCellSize( row, col, &cell_rows, &cell_cols );
8534                 // may have changed earlier
8535                 for (int i = col + cell_cols; i < m_numCols; i++)
8536                 {
8537                     int c_rows, c_cols;
8538                     GetCellSize( row, i, &c_rows, &c_cols );
8539
8540                     // looks weird going over a multicell
8541                     if (m_table->IsEmptyCell( row, i ) &&
8542                             (rect.width < maxWidth) && (c_rows == 1))
8543                     {
8544                         rect.width += GetColWidth( i );
8545                     }
8546                     else
8547                         break;
8548                 }
8549
8550                 if (rect.GetRight() > client_right)
8551                     rect.SetRight( client_right - 1 );
8552             }
8553
8554             editor->SetCellAttr( attr );
8555             editor->SetSize( rect );
8556             if (nXMove != 0)
8557                 editor->GetControl()->Move(
8558                     editor->GetControl()->GetPosition().x + nXMove,
8559                     editor->GetControl()->GetPosition().y );
8560             editor->Show( true, attr );
8561
8562             // recalc dimensions in case we need to
8563             // expand the scrolled window to account for editor
8564             CalcDimensions();
8565
8566             editor->BeginEdit(row, col, this);
8567             editor->SetCellAttr(NULL);
8568
8569             editor->DecRef();
8570             attr->DecRef();
8571         }
8572     }
8573 }
8574
8575 void wxGrid::HideCellEditControl()
8576 {
8577     if ( IsCellEditControlEnabled() )
8578     {
8579         int row = m_currentCellCoords.GetRow();
8580         int col = m_currentCellCoords.GetCol();
8581
8582         wxGridCellAttr *attr = GetCellAttr(row, col);
8583         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
8584         const bool editorHadFocus = editor->GetControl()->HasFocus();
8585         editor->Show( false );
8586         editor->DecRef();
8587         attr->DecRef();
8588
8589         // return the focus to the grid itself if the editor had it
8590         //
8591         // note that we must not do this unconditionally to avoid stealing
8592         // focus from the window which just received it if we are hiding the
8593         // editor precisely because we lost focus
8594         if ( editorHadFocus )
8595             m_gridWin->SetFocus();
8596
8597         // refresh whole row to the right
8598         wxRect rect( CellToRect(row, col) );
8599         CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
8600         rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
8601
8602 #ifdef __WXMAC__
8603         // ensure that the pixels under the focus ring get refreshed as well
8604         rect.Inflate(10, 10);
8605 #endif
8606
8607         m_gridWin->Refresh( false, &rect );
8608     }
8609 }
8610
8611 void wxGrid::SaveEditControlValue()
8612 {
8613     if ( IsCellEditControlEnabled() )
8614     {
8615         int row = m_currentCellCoords.GetRow();
8616         int col = m_currentCellCoords.GetCol();
8617
8618         wxString oldval = GetCellValue(row, col);
8619
8620         wxGridCellAttr* attr = GetCellAttr(row, col);
8621         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8622         bool changed = editor->EndEdit(row, col, this);
8623
8624         editor->DecRef();
8625         attr->DecRef();
8626
8627         if (changed)
8628         {
8629             if ( SendEvent(wxEVT_GRID_CELL_CHANGE) == -1 )
8630             {
8631                 // Event has been vetoed, set the data back.
8632                 SetCellValue(row, col, oldval);
8633             }
8634         }
8635     }
8636 }
8637
8638 //
8639 // ------ Grid location functions
8640 //  Note that all of these functions work with the logical coordinates of
8641 //  grid cells and labels so you will need to convert from device
8642 //  coordinates for mouse events etc.
8643 //
8644
8645 wxGridCellCoords wxGrid::XYToCell(int x, int y) const
8646 {
8647     int row = YToRow(y);
8648     int col = XToCol(x);
8649
8650     return row == -1 || col == -1 ? wxGridNoCellCoords
8651                                   : wxGridCellCoords(row, col);
8652 }
8653
8654 // compute row or column from some (unscrolled) coordinate value, using either
8655 // m_defaultRowHeight/m_defaultColWidth or binary search on array of
8656 // m_rowBottoms/m_colRights to do it quickly (linear search shouldn't be used
8657 // for large grids)
8658 int
8659 wxGrid::PosToLine(int coord,
8660                   bool clipToMinMax,
8661                   const wxGridOperations& oper) const
8662 {
8663     const int numLines = oper.GetNumberOfLines(this);
8664
8665     if ( coord < 0 )
8666         return clipToMinMax && numLines > 0 ? oper.GetLineAt(this, 0) : -1;
8667
8668     const int defaultLineSize = oper.GetDefaultLineSize(this);
8669     wxCHECK_MSG( defaultLineSize, -1, "can't have 0 default line size" );
8670
8671     int maxPos = coord / defaultLineSize,
8672         minPos = 0;
8673
8674     // check for the simplest case: if we have no explicit line sizes
8675     // configured, then we already know the line this position falls in
8676     const wxArrayInt& lineEnds = oper.GetLineEnds(this);
8677     if ( lineEnds.empty() )
8678     {
8679         if ( maxPos < numLines )
8680             return maxPos;
8681
8682         return clipToMinMax ? numLines - 1 : -1;
8683     }
8684
8685
8686     // adjust maxPos before starting the binary search
8687     if ( maxPos >= numLines )
8688     {
8689         maxPos = numLines  - 1;
8690     }
8691     else
8692     {
8693         if ( coord >= lineEnds[oper.GetLineAt(this, maxPos)])
8694         {
8695             minPos = maxPos;
8696             const int minDist = oper.GetMinimalAcceptableLineSize(this);
8697             if ( minDist )
8698                 maxPos = coord / minDist;
8699             else
8700                 maxPos = numLines - 1;
8701         }
8702
8703         if ( maxPos >= numLines )
8704             maxPos = numLines  - 1;
8705     }
8706
8707     // check if the position is beyond the last column
8708     const int lineAtMaxPos = oper.GetLineAt(this, maxPos);
8709     if ( coord >= lineEnds[lineAtMaxPos] )
8710         return clipToMinMax ? lineAtMaxPos : -1;
8711
8712     // or before the first one
8713     const int lineAt0 = oper.GetLineAt(this, 0);
8714     if ( coord < lineEnds[lineAt0] )
8715         return lineAt0;
8716
8717
8718     // finally do perform the binary search
8719     while ( minPos < maxPos )
8720     {
8721         wxCHECK_MSG( lineEnds[oper.GetLineAt(this, minPos)] <= coord &&
8722                         coord < lineEnds[oper.GetLineAt(this, maxPos)],
8723                      -1,
8724                      "wxGrid: internal error in PosToLine()" );
8725
8726         if ( coord >= lineEnds[oper.GetLineAt(this, maxPos - 1)] )
8727             return oper.GetLineAt(this, maxPos);
8728         else
8729             maxPos--;
8730
8731         const int median = minPos + (maxPos - minPos + 1) / 2;
8732         if ( coord < lineEnds[oper.GetLineAt(this, median)] )
8733             maxPos = median;
8734         else
8735             minPos = median;
8736     }
8737
8738     return oper.GetLineAt(this, maxPos);
8739 }
8740
8741 int wxGrid::YToRow(int y, bool clipToMinMax) const
8742 {
8743     return PosToLine(y, clipToMinMax, wxGridRowOperations());
8744 }
8745
8746 int wxGrid::XToCol(int x, bool clipToMinMax) const
8747 {
8748     return PosToLine(x, clipToMinMax, wxGridColumnOperations());
8749 }
8750
8751 // return the row number that that the y coord is near the edge of, or -1 if
8752 // not near an edge.
8753 //
8754 // coords can only possibly be near an edge if
8755 //    (a) the row/column is large enough to still allow for an "inner" area
8756 //        that is _not_ near the edge (i.e., if the height/width is smaller
8757 //        than WXGRID_LABEL_EDGE_ZONE, coords are _never_ considered to be
8758 //        near the edge).
8759 //   and
8760 //    (b) resizing rows/columns (the thing for which edge detection is
8761 //        relevant at all) is enabled.
8762 //
8763 int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
8764 {
8765     if ( !oper.CanResizeLines(this) )
8766         return -1;
8767
8768     const int line = oper.PosToLine(this, pos, true);
8769
8770     if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )
8771     {
8772         // We know that we are in this line, test whether we are close enough
8773         // to start or end border, respectively.
8774         if ( abs(oper.GetLineEndPos(this, line) - pos) < WXGRID_LABEL_EDGE_ZONE )
8775             return line;
8776         else if ( line > 0 &&
8777                     pos - oper.GetLineStartPos(this,
8778                                                line) < WXGRID_LABEL_EDGE_ZONE )
8779             return line - 1;
8780     }
8781
8782     return -1;
8783 }
8784
8785 int wxGrid::YToEdgeOfRow(int y) const
8786 {
8787     return PosToEdgeOfLine(y, wxGridRowOperations());
8788 }
8789
8790 int wxGrid::XToEdgeOfCol(int x) const
8791 {
8792     return PosToEdgeOfLine(x, wxGridColumnOperations());
8793 }
8794
8795 wxRect wxGrid::CellToRect( int row, int col ) const
8796 {
8797     wxRect rect( -1, -1, -1, -1 );
8798
8799     if ( row >= 0 && row < m_numRows &&
8800          col >= 0 && col < m_numCols )
8801     {
8802         int i, cell_rows, cell_cols;
8803         rect.width = rect.height = 0;
8804         GetCellSize( row, col, &cell_rows, &cell_cols );
8805         // if negative then find multicell owner
8806         if (cell_rows < 0)
8807             row += cell_rows;
8808         if (cell_cols < 0)
8809              col += cell_cols;
8810         GetCellSize( row, col, &cell_rows, &cell_cols );
8811
8812         rect.x = GetColLeft(col);
8813         rect.y = GetRowTop(row);
8814         for (i=col; i < col + cell_cols; i++)
8815             rect.width += GetColWidth(i);
8816         for (i=row; i < row + cell_rows; i++)
8817             rect.height += GetRowHeight(i);
8818     }
8819
8820     // if grid lines are enabled, then the area of the cell is a bit smaller
8821     if (m_gridLinesEnabled)
8822     {
8823         rect.width -= 1;
8824         rect.height -= 1;
8825     }
8826
8827     return rect;
8828 }
8829
8830 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
8831 {
8832     // get the cell rectangle in logical coords
8833     //
8834     wxRect r( CellToRect( row, col ) );
8835
8836     // convert to device coords
8837     //
8838     int left, top, right, bottom;
8839     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8840     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8841
8842     // check against the client area of the grid window
8843     int cw, ch;
8844     m_gridWin->GetClientSize( &cw, &ch );
8845
8846     if ( wholeCellVisible )
8847     {
8848         // is the cell wholly visible ?
8849         return ( left >= 0 && right <= cw &&
8850                  top >= 0 && bottom <= ch );
8851     }
8852     else
8853     {
8854         // is the cell partly visible ?
8855         //
8856         return ( ((left >= 0 && left < cw) || (right > 0 && right <= cw)) &&
8857                  ((top >= 0 && top < ch) || (bottom > 0 && bottom <= ch)) );
8858     }
8859 }
8860
8861 // make the specified cell location visible by doing a minimal amount
8862 // of scrolling
8863 //
8864 void wxGrid::MakeCellVisible( int row, int col )
8865 {
8866     int i;
8867     int xpos = -1, ypos = -1;
8868
8869     if ( row >= 0 && row < m_numRows &&
8870          col >= 0 && col < m_numCols )
8871     {
8872         // get the cell rectangle in logical coords
8873         wxRect r( CellToRect( row, col ) );
8874
8875         // convert to device coords
8876         int left, top, right, bottom;
8877         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8878         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8879
8880         int cw, ch;
8881         m_gridWin->GetClientSize( &cw, &ch );
8882
8883         if ( top < 0 )
8884         {
8885             ypos = r.GetTop();
8886         }
8887         else if ( bottom > ch )
8888         {
8889             int h = r.GetHeight();
8890             ypos = r.GetTop();
8891             for ( i = row - 1; i >= 0; i-- )
8892             {
8893                 int rowHeight = GetRowHeight(i);
8894                 if ( h + rowHeight > ch )
8895                     break;
8896
8897                 h += rowHeight;
8898                 ypos -= rowHeight;
8899             }
8900
8901             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
8902             // have rounding errors (this is important, because if we do,
8903             // we might not scroll at all and some cells won't be redrawn)
8904             //
8905             // Sometimes GRID_SCROLL_LINE / 2 is not enough,
8906             // so just add a full scroll unit...
8907             ypos += m_scrollLineY;
8908         }
8909
8910         // special handling for wide cells - show always left part of the cell!
8911         // Otherwise, e.g. when stepping from row to row, it would jump between
8912         // left and right part of the cell on every step!
8913 //      if ( left < 0 )
8914         if ( left < 0 || (right - left) >= cw )
8915         {
8916             xpos = r.GetLeft();
8917         }
8918         else if ( right > cw )
8919         {
8920             // position the view so that the cell is on the right
8921             int x0, y0;
8922             CalcUnscrolledPosition(0, 0, &x0, &y0);
8923             xpos = x0 + (right - cw);
8924
8925             // see comment for ypos above
8926             xpos += m_scrollLineX;
8927         }
8928
8929         if ( xpos != -1 || ypos != -1 )
8930         {
8931             if ( xpos != -1 )
8932                 xpos /= m_scrollLineX;
8933             if ( ypos != -1 )
8934                 ypos /= m_scrollLineY;
8935             Scroll( xpos, ypos );
8936             AdjustScrollbars();
8937         }
8938     }
8939 }
8940
8941 //
8942 // ------ Grid cursor movement functions
8943 //
8944
8945 bool
8946 wxGrid::DoMoveCursor(bool expandSelection,
8947                      const wxGridDirectionOperations& diroper)
8948 {
8949     if ( m_currentCellCoords == wxGridNoCellCoords )
8950         return false;
8951
8952     if ( expandSelection )
8953     {
8954         wxGridCellCoords coords = m_selectedBlockCorner;
8955         if ( coords == wxGridNoCellCoords )
8956             coords = m_currentCellCoords;
8957
8958         if ( diroper.IsAtBoundary(coords) )
8959             return false;
8960
8961         diroper.Advance(coords);
8962
8963         UpdateBlockBeingSelected(m_currentCellCoords, coords);
8964     }
8965     else // don't expand selection
8966     {
8967         ClearSelection();
8968
8969         if ( diroper.IsAtBoundary(m_currentCellCoords) )
8970             return false;
8971
8972         wxGridCellCoords coords = m_currentCellCoords;
8973         diroper.Advance(coords);
8974
8975         GoToCell(coords);
8976     }
8977
8978     return true;
8979 }
8980
8981 bool wxGrid::MoveCursorUp(bool expandSelection)
8982 {
8983     return DoMoveCursor(expandSelection,
8984                         wxGridBackwardOperations(this, wxGridRowOperations()));
8985 }
8986
8987 bool wxGrid::MoveCursorDown(bool expandSelection)
8988 {
8989     return DoMoveCursor(expandSelection,
8990                         wxGridForwardOperations(this, wxGridRowOperations()));
8991 }
8992
8993 bool wxGrid::MoveCursorLeft(bool expandSelection)
8994 {
8995     return DoMoveCursor(expandSelection,
8996                         wxGridBackwardOperations(this, wxGridColumnOperations()));
8997 }
8998
8999 bool wxGrid::MoveCursorRight(bool expandSelection)
9000 {
9001     return DoMoveCursor(expandSelection,
9002                         wxGridForwardOperations(this, wxGridColumnOperations()));
9003 }
9004
9005 bool wxGrid::DoMoveCursorByPage(const wxGridDirectionOperations& diroper)
9006 {
9007     if ( m_currentCellCoords == wxGridNoCellCoords )
9008         return false;
9009
9010     if ( diroper.IsAtBoundary(m_currentCellCoords) )
9011         return false;
9012
9013     const int oldRow = m_currentCellCoords.GetRow();
9014     int newRow = diroper.MoveByPixelDistance(oldRow, m_gridWin->GetClientSize().y);
9015     if ( newRow == oldRow )
9016     {
9017         wxGridCellCoords coords(m_currentCellCoords);
9018         diroper.Advance(coords);
9019         newRow = coords.GetRow();
9020     }
9021
9022     GoToCell(newRow, m_currentCellCoords.GetCol());
9023
9024     return true;
9025 }
9026
9027 bool wxGrid::MovePageUp()
9028 {
9029     return DoMoveCursorByPage(
9030                 wxGridBackwardOperations(this, wxGridRowOperations()));
9031 }
9032
9033 bool wxGrid::MovePageDown()
9034 {
9035     return DoMoveCursorByPage(
9036                 wxGridForwardOperations(this, wxGridColumnOperations()));
9037 }
9038
9039 // helper of DoMoveCursorByBlock(): advance the cell coordinates using diroper
9040 // until we find a non-empty cell or reach the grid end
9041 void
9042 wxGrid::AdvanceToNextNonEmpty(wxGridCellCoords& coords,
9043                               const wxGridDirectionOperations& diroper)
9044 {
9045     while ( !diroper.IsAtBoundary(coords) )
9046     {
9047         diroper.Advance(coords);
9048         if ( !m_table->IsEmpty(coords) )
9049             break;
9050     }
9051 }
9052
9053 bool
9054 wxGrid::DoMoveCursorByBlock(bool expandSelection,
9055                             const wxGridDirectionOperations& diroper)
9056 {
9057     if ( !m_table || m_currentCellCoords == wxGridNoCellCoords )
9058         return false;
9059
9060     if ( diroper.IsAtBoundary(m_currentCellCoords) )
9061         return false;
9062
9063     wxGridCellCoords coords(m_currentCellCoords);
9064     if ( m_table->IsEmpty(coords) )
9065     {
9066         // we are in an empty cell: find the next block of non-empty cells
9067         AdvanceToNextNonEmpty(coords, diroper);
9068     }
9069     else // current cell is not empty
9070     {
9071         diroper.Advance(coords);
9072         if ( m_table->IsEmpty(coords) )
9073         {
9074             // we started at the end of a block, find the next one
9075             AdvanceToNextNonEmpty(coords, diroper);
9076         }
9077         else // we're in a middle of a block
9078         {
9079             // go to the end of it, i.e. find the last cell before the next
9080             // empty one
9081             while ( !diroper.IsAtBoundary(coords) )
9082             {
9083                 wxGridCellCoords coordsNext(coords);
9084                 diroper.Advance(coordsNext);
9085                 if ( m_table->IsEmpty(coordsNext) )
9086                     break;
9087
9088                 coords = coordsNext;
9089             }
9090         }
9091     }
9092
9093     if ( expandSelection )
9094     {
9095         UpdateBlockBeingSelected(m_currentCellCoords, coords);
9096     }
9097     else
9098     {
9099         ClearSelection();
9100         GoToCell(coords);
9101     }
9102
9103     return true;
9104 }
9105
9106 bool wxGrid::MoveCursorUpBlock(bool expandSelection)
9107 {
9108     return DoMoveCursorByBlock(
9109                 expandSelection,
9110                 wxGridBackwardOperations(this, wxGridRowOperations())
9111            );
9112 }
9113
9114 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
9115 {
9116     return DoMoveCursorByBlock(
9117                 expandSelection,
9118                 wxGridForwardOperations(this, wxGridRowOperations())
9119            );
9120 }
9121
9122 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
9123 {
9124     return DoMoveCursorByBlock(
9125                 expandSelection,
9126                 wxGridBackwardOperations(this, wxGridColumnOperations())
9127            );
9128 }
9129
9130 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
9131 {
9132     return DoMoveCursorByBlock(
9133                 expandSelection,
9134                 wxGridForwardOperations(this, wxGridColumnOperations())
9135            );
9136 }
9137
9138 //
9139 // ------ Label values and formatting
9140 //
9141
9142 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
9143 {
9144     if ( horiz )
9145         *horiz = m_rowLabelHorizAlign;
9146     if ( vert )
9147         *vert  = m_rowLabelVertAlign;
9148 }
9149
9150 void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
9151 {
9152     if ( horiz )
9153         *horiz = m_colLabelHorizAlign;
9154     if ( vert )
9155         *vert  = m_colLabelVertAlign;
9156 }
9157
9158 int wxGrid::GetColLabelTextOrientation() const
9159 {
9160     return m_colLabelTextOrientation;
9161 }
9162
9163 wxString wxGrid::GetRowLabelValue( int row ) const
9164 {
9165     if ( m_table )
9166     {
9167         return m_table->GetRowLabelValue( row );
9168     }
9169     else
9170     {
9171         wxString s;
9172         s << row;
9173         return s;
9174     }
9175 }
9176
9177 wxString wxGrid::GetColLabelValue( int col ) const
9178 {
9179     if ( m_table )
9180     {
9181         return m_table->GetColLabelValue( col );
9182     }
9183     else
9184     {
9185         wxString s;
9186         s << col;
9187         return s;
9188     }
9189 }
9190
9191 void wxGrid::SetRowLabelSize( int width )
9192 {
9193     wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
9194
9195     if ( width == wxGRID_AUTOSIZE )
9196     {
9197         width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
9198     }
9199
9200     if ( width != m_rowLabelWidth )
9201     {
9202         if ( width == 0 )
9203         {
9204             m_rowLabelWin->Show( false );
9205             m_cornerLabelWin->Show( false );
9206         }
9207         else if ( m_rowLabelWidth == 0 )
9208         {
9209             m_rowLabelWin->Show( true );
9210             if ( m_colLabelHeight > 0 )
9211                 m_cornerLabelWin->Show( true );
9212         }
9213
9214         m_rowLabelWidth = width;
9215         CalcWindowSizes();
9216         wxScrolledWindow::Refresh( true );
9217     }
9218 }
9219
9220 void wxGrid::SetColLabelSize( int height )
9221 {
9222     wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
9223
9224     if ( height == wxGRID_AUTOSIZE )
9225     {
9226         height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
9227     }
9228
9229     if ( height != m_colLabelHeight )
9230     {
9231         if ( height == 0 )
9232         {
9233             m_colLabelWin->Show( false );
9234             m_cornerLabelWin->Show( false );
9235         }
9236         else if ( m_colLabelHeight == 0 )
9237         {
9238             m_colLabelWin->Show( true );
9239             if ( m_rowLabelWidth > 0 )
9240                 m_cornerLabelWin->Show( true );
9241         }
9242
9243         m_colLabelHeight = height;
9244         CalcWindowSizes();
9245         wxScrolledWindow::Refresh( true );
9246     }
9247 }
9248
9249 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
9250 {
9251     if ( m_labelBackgroundColour != colour )
9252     {
9253         m_labelBackgroundColour = colour;
9254         m_rowLabelWin->SetBackgroundColour( colour );
9255         m_colLabelWin->SetBackgroundColour( colour );
9256         m_cornerLabelWin->SetBackgroundColour( colour );
9257
9258         if ( !GetBatchCount() )
9259         {
9260             m_rowLabelWin->Refresh();
9261             m_colLabelWin->Refresh();
9262             m_cornerLabelWin->Refresh();
9263         }
9264     }
9265 }
9266
9267 void wxGrid::SetLabelTextColour( const wxColour& colour )
9268 {
9269     if ( m_labelTextColour != colour )
9270     {
9271         m_labelTextColour = colour;
9272         if ( !GetBatchCount() )
9273         {
9274             m_rowLabelWin->Refresh();
9275             m_colLabelWin->Refresh();
9276         }
9277     }
9278 }
9279
9280 void wxGrid::SetLabelFont( const wxFont& font )
9281 {
9282     m_labelFont = font;
9283     if ( !GetBatchCount() )
9284     {
9285         m_rowLabelWin->Refresh();
9286         m_colLabelWin->Refresh();
9287     }
9288 }
9289
9290 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
9291 {
9292     // allow old (incorrect) defs to be used
9293     switch ( horiz )
9294     {
9295         case wxLEFT:   horiz = wxALIGN_LEFT; break;
9296         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
9297         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
9298     }
9299
9300     switch ( vert )
9301     {
9302         case wxTOP:    vert = wxALIGN_TOP;    break;
9303         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
9304         case wxCENTRE: vert = wxALIGN_CENTRE; break;
9305     }
9306
9307     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
9308     {
9309         m_rowLabelHorizAlign = horiz;
9310     }
9311
9312     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
9313     {
9314         m_rowLabelVertAlign = vert;
9315     }
9316
9317     if ( !GetBatchCount() )
9318     {
9319         m_rowLabelWin->Refresh();
9320     }
9321 }
9322
9323 void wxGrid::SetColLabelAlignment( int horiz, int vert )
9324 {
9325     // allow old (incorrect) defs to be used
9326     switch ( horiz )
9327     {
9328         case wxLEFT:   horiz = wxALIGN_LEFT; break;
9329         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
9330         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
9331     }
9332
9333     switch ( vert )
9334     {
9335         case wxTOP:    vert = wxALIGN_TOP;    break;
9336         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
9337         case wxCENTRE: vert = wxALIGN_CENTRE; break;
9338     }
9339
9340     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
9341     {
9342         m_colLabelHorizAlign = horiz;
9343     }
9344
9345     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
9346     {
9347         m_colLabelVertAlign = vert;
9348     }
9349
9350     if ( !GetBatchCount() )
9351     {
9352         m_colLabelWin->Refresh();
9353     }
9354 }
9355
9356 // Note: under MSW, the default column label font must be changed because it
9357 //       does not support vertical printing
9358 //
9359 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
9360 //                      pGrid->SetLabelFont(font);
9361 //                      pGrid->SetColLabelTextOrientation(wxVERTICAL);
9362 //
9363 void wxGrid::SetColLabelTextOrientation( int textOrientation )
9364 {
9365     if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
9366         m_colLabelTextOrientation = textOrientation;
9367
9368     if ( !GetBatchCount() )
9369         m_colLabelWin->Refresh();
9370 }
9371
9372 void wxGrid::SetRowLabelValue( int row, const wxString& s )
9373 {
9374     if ( m_table )
9375     {
9376         m_table->SetRowLabelValue( row, s );
9377         if ( !GetBatchCount() )
9378         {
9379             wxRect rect = CellToRect( row, 0 );
9380             if ( rect.height > 0 )
9381             {
9382                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
9383                 rect.x = 0;
9384                 rect.width = m_rowLabelWidth;
9385                 m_rowLabelWin->Refresh( true, &rect );
9386             }
9387         }
9388     }
9389 }
9390
9391 void wxGrid::SetColLabelValue( int col, const wxString& s )
9392 {
9393     if ( m_table )
9394     {
9395         m_table->SetColLabelValue( col, s );
9396         if ( !GetBatchCount() )
9397         {
9398             wxRect rect = CellToRect( 0, col );
9399             if ( rect.width > 0 )
9400             {
9401                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
9402                 rect.y = 0;
9403                 rect.height = m_colLabelHeight;
9404                 m_colLabelWin->Refresh( true, &rect );
9405             }
9406         }
9407     }
9408 }
9409
9410 void wxGrid::SetGridLineColour( const wxColour& colour )
9411 {
9412     if ( m_gridLineColour != colour )
9413     {
9414         m_gridLineColour = colour;
9415
9416         wxClientDC dc( m_gridWin );
9417         PrepareDC( dc );
9418         DrawAllGridLines( dc, wxRegion() );
9419     }
9420 }
9421
9422 void wxGrid::SetCellHighlightColour( const wxColour& colour )
9423 {
9424     if ( m_cellHighlightColour != colour )
9425     {
9426         m_cellHighlightColour = colour;
9427
9428         wxClientDC dc( m_gridWin );
9429         PrepareDC( dc );
9430         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
9431         DrawCellHighlight(dc, attr);
9432         attr->DecRef();
9433     }
9434 }
9435
9436 void wxGrid::SetCellHighlightPenWidth(int width)
9437 {
9438     if (m_cellHighlightPenWidth != width)
9439     {
9440         m_cellHighlightPenWidth = width;
9441
9442         // Just redrawing the cell highlight is not enough since that won't
9443         // make any visible change if the the thickness is getting smaller.
9444         int row = m_currentCellCoords.GetRow();
9445         int col = m_currentCellCoords.GetCol();
9446         if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
9447             return;
9448
9449         wxRect rect = CellToRect(row, col);
9450         m_gridWin->Refresh(true, &rect);
9451     }
9452 }
9453
9454 void wxGrid::SetCellHighlightROPenWidth(int width)
9455 {
9456     if (m_cellHighlightROPenWidth != width)
9457     {
9458         m_cellHighlightROPenWidth = 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 ||
9465                 GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
9466             return;
9467
9468         wxRect rect = CellToRect(row, col);
9469         m_gridWin->Refresh(true, &rect);
9470     }
9471 }
9472
9473 void wxGrid::EnableGridLines( bool enable )
9474 {
9475     if ( enable != m_gridLinesEnabled )
9476     {
9477         m_gridLinesEnabled = enable;
9478
9479         if ( !GetBatchCount() )
9480         {
9481             if ( enable )
9482             {
9483                 wxClientDC dc( m_gridWin );
9484                 PrepareDC( dc );
9485                 DrawAllGridLines( dc, wxRegion() );
9486             }
9487             else
9488             {
9489                 m_gridWin->Refresh();
9490             }
9491         }
9492     }
9493 }
9494
9495 int wxGrid::GetDefaultRowSize() const
9496 {
9497     return m_defaultRowHeight;
9498 }
9499
9500 int wxGrid::GetRowSize( int row ) const
9501 {
9502     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
9503
9504     return GetRowHeight(row);
9505 }
9506
9507 int wxGrid::GetDefaultColSize() const
9508 {
9509     return m_defaultColWidth;
9510 }
9511
9512 int wxGrid::GetColSize( int col ) const
9513 {
9514     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
9515
9516     return GetColWidth(col);
9517 }
9518
9519 // ============================================================================
9520 // access to the grid attributes: each of them has a default value in the grid
9521 // itself and may be overidden on a per-cell basis
9522 // ============================================================================
9523
9524 // ----------------------------------------------------------------------------
9525 // setting default attributes
9526 // ----------------------------------------------------------------------------
9527
9528 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
9529 {
9530     m_defaultCellAttr->SetBackgroundColour(col);
9531 #ifdef __WXGTK__
9532     m_gridWin->SetBackgroundColour(col);
9533 #endif
9534 }
9535
9536 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
9537 {
9538     m_defaultCellAttr->SetTextColour(col);
9539 }
9540
9541 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
9542 {
9543     m_defaultCellAttr->SetAlignment(horiz, vert);
9544 }
9545
9546 void wxGrid::SetDefaultCellOverflow( bool allow )
9547 {
9548     m_defaultCellAttr->SetOverflow(allow);
9549 }
9550
9551 void wxGrid::SetDefaultCellFont( const wxFont& font )
9552 {
9553     m_defaultCellAttr->SetFont(font);
9554 }
9555
9556 // For editors and renderers the type registry takes precedence over the
9557 // default attr, so we need to register the new editor/renderer for the string
9558 // data type in order to make setting a default editor/renderer appear to
9559 // work correctly.
9560
9561 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
9562 {
9563     RegisterDataType(wxGRID_VALUE_STRING,
9564                      renderer,
9565                      GetDefaultEditorForType(wxGRID_VALUE_STRING));
9566 }
9567
9568 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
9569 {
9570     RegisterDataType(wxGRID_VALUE_STRING,
9571                      GetDefaultRendererForType(wxGRID_VALUE_STRING),
9572                      editor);
9573 }
9574
9575 // ----------------------------------------------------------------------------
9576 // access to the default attributes
9577 // ----------------------------------------------------------------------------
9578
9579 wxColour wxGrid::GetDefaultCellBackgroundColour() const
9580 {
9581     return m_defaultCellAttr->GetBackgroundColour();
9582 }
9583
9584 wxColour wxGrid::GetDefaultCellTextColour() const
9585 {
9586     return m_defaultCellAttr->GetTextColour();
9587 }
9588
9589 wxFont wxGrid::GetDefaultCellFont() const
9590 {
9591     return m_defaultCellAttr->GetFont();
9592 }
9593
9594 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
9595 {
9596     m_defaultCellAttr->GetAlignment(horiz, vert);
9597 }
9598
9599 bool wxGrid::GetDefaultCellOverflow() const
9600 {
9601     return m_defaultCellAttr->GetOverflow();
9602 }
9603
9604 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
9605 {
9606     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
9607 }
9608
9609 wxGridCellEditor *wxGrid::GetDefaultEditor() const
9610 {
9611     return m_defaultCellAttr->GetEditor(NULL, 0, 0);
9612 }
9613
9614 // ----------------------------------------------------------------------------
9615 // access to cell attributes
9616 // ----------------------------------------------------------------------------
9617
9618 wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
9619 {
9620     wxGridCellAttr *attr = GetCellAttr(row, col);
9621     wxColour colour = attr->GetBackgroundColour();
9622     attr->DecRef();
9623
9624     return colour;
9625 }
9626
9627 wxColour wxGrid::GetCellTextColour( int row, int col ) const
9628 {
9629     wxGridCellAttr *attr = GetCellAttr(row, col);
9630     wxColour colour = attr->GetTextColour();
9631     attr->DecRef();
9632
9633     return colour;
9634 }
9635
9636 wxFont wxGrid::GetCellFont( int row, int col ) const
9637 {
9638     wxGridCellAttr *attr = GetCellAttr(row, col);
9639     wxFont font = attr->GetFont();
9640     attr->DecRef();
9641
9642     return font;
9643 }
9644
9645 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
9646 {
9647     wxGridCellAttr *attr = GetCellAttr(row, col);
9648     attr->GetAlignment(horiz, vert);
9649     attr->DecRef();
9650 }
9651
9652 bool wxGrid::GetCellOverflow( int row, int col ) const
9653 {
9654     wxGridCellAttr *attr = GetCellAttr(row, col);
9655     bool allow = attr->GetOverflow();
9656     attr->DecRef();
9657
9658     return allow;
9659 }
9660
9661 void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
9662 {
9663     wxGridCellAttr *attr = GetCellAttr(row, col);
9664     attr->GetSize( num_rows, num_cols );
9665     attr->DecRef();
9666 }
9667
9668 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
9669 {
9670     wxGridCellAttr* attr = GetCellAttr(row, col);
9671     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9672     attr->DecRef();
9673
9674     return renderer;
9675 }
9676
9677 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
9678 {
9679     wxGridCellAttr* attr = GetCellAttr(row, col);
9680     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
9681     attr->DecRef();
9682
9683     return editor;
9684 }
9685
9686 bool wxGrid::IsReadOnly(int row, int col) const
9687 {
9688     wxGridCellAttr* attr = GetCellAttr(row, col);
9689     bool isReadOnly = attr->IsReadOnly();
9690     attr->DecRef();
9691
9692     return isReadOnly;
9693 }
9694
9695 // ----------------------------------------------------------------------------
9696 // attribute support: cache, automatic provider creation, ...
9697 // ----------------------------------------------------------------------------
9698
9699 bool wxGrid::CanHaveAttributes() const
9700 {
9701     if ( !m_table )
9702     {
9703         return false;
9704     }
9705
9706     return m_table->CanHaveAttributes();
9707 }
9708
9709 void wxGrid::ClearAttrCache()
9710 {
9711     if ( m_attrCache.row != -1 )
9712     {
9713         wxGridCellAttr *oldAttr = m_attrCache.attr;
9714         m_attrCache.attr = NULL;
9715         m_attrCache.row = -1;
9716         // wxSafeDecRec(...) might cause event processing that accesses
9717         // the cached attribute, if one exists (e.g. by deleting the
9718         // editor stored within the attribute). Therefore it is important
9719         // to invalidate the cache  before calling wxSafeDecRef!
9720         wxSafeDecRef(oldAttr);
9721     }
9722 }
9723
9724 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
9725 {
9726     if ( attr != NULL )
9727     {
9728         wxGrid *self = (wxGrid *)this;  // const_cast
9729
9730         self->ClearAttrCache();
9731         self->m_attrCache.row = row;
9732         self->m_attrCache.col = col;
9733         self->m_attrCache.attr = attr;
9734         wxSafeIncRef(attr);
9735     }
9736 }
9737
9738 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
9739 {
9740     if ( row == m_attrCache.row && col == m_attrCache.col )
9741     {
9742         *attr = m_attrCache.attr;
9743         wxSafeIncRef(m_attrCache.attr);
9744
9745 #ifdef DEBUG_ATTR_CACHE
9746         gs_nAttrCacheHits++;
9747 #endif
9748
9749         return true;
9750     }
9751     else
9752     {
9753 #ifdef DEBUG_ATTR_CACHE
9754         gs_nAttrCacheMisses++;
9755 #endif
9756
9757         return false;
9758     }
9759 }
9760
9761 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
9762 {
9763     wxGridCellAttr *attr = NULL;
9764     // Additional test to avoid looking at the cache e.g. for
9765     // wxNoCellCoords, as this will confuse memory management.
9766     if ( row >= 0 )
9767     {
9768         if ( !LookupAttr(row, col, &attr) )
9769         {
9770             attr = m_table ? m_table->GetAttr(row, col, wxGridCellAttr::Any)
9771                            : NULL;
9772             CacheAttr(row, col, attr);
9773         }
9774     }
9775
9776     if (attr)
9777     {
9778         attr->SetDefAttr(m_defaultCellAttr);
9779     }
9780     else
9781     {
9782         attr = m_defaultCellAttr;
9783         attr->IncRef();
9784     }
9785
9786     return attr;
9787 }
9788
9789 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
9790 {
9791     wxGridCellAttr *attr = NULL;
9792     bool canHave = ((wxGrid*)this)->CanHaveAttributes();
9793
9794     wxCHECK_MSG( canHave, attr, _T("Cell attributes not allowed"));
9795     wxCHECK_MSG( m_table, attr, _T("must have a table") );
9796
9797     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
9798     if ( !attr )
9799     {
9800         attr = new wxGridCellAttr(m_defaultCellAttr);
9801
9802         // artificially inc the ref count to match DecRef() in caller
9803         attr->IncRef();
9804         m_table->SetAttr(attr, row, col);
9805     }
9806
9807     return attr;
9808 }
9809
9810 // ----------------------------------------------------------------------------
9811 // setting column attributes (wrappers around SetColAttr)
9812 // ----------------------------------------------------------------------------
9813
9814 void wxGrid::SetColFormatBool(int col)
9815 {
9816     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
9817 }
9818
9819 void wxGrid::SetColFormatNumber(int col)
9820 {
9821     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
9822 }
9823
9824 void wxGrid::SetColFormatFloat(int col, int width, int precision)
9825 {
9826     wxString typeName = wxGRID_VALUE_FLOAT;
9827     if ( (width != -1) || (precision != -1) )
9828     {
9829         typeName << _T(':') << width << _T(',') << precision;
9830     }
9831
9832     SetColFormatCustom(col, typeName);
9833 }
9834
9835 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
9836 {
9837     wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
9838     if (!attr)
9839         attr = new wxGridCellAttr;
9840     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
9841     attr->SetRenderer(renderer);
9842     wxGridCellEditor *editor = GetDefaultEditorForType(typeName);
9843     attr->SetEditor(editor);
9844
9845     SetColAttr(col, attr);
9846
9847 }
9848
9849 // ----------------------------------------------------------------------------
9850 // setting cell attributes: this is forwarded to the table
9851 // ----------------------------------------------------------------------------
9852
9853 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
9854 {
9855     if ( CanHaveAttributes() )
9856     {
9857         m_table->SetAttr(attr, row, col);
9858         ClearAttrCache();
9859     }
9860     else
9861     {
9862         wxSafeDecRef(attr);
9863     }
9864 }
9865
9866 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
9867 {
9868     if ( CanHaveAttributes() )
9869     {
9870         m_table->SetRowAttr(attr, row);
9871         ClearAttrCache();
9872     }
9873     else
9874     {
9875         wxSafeDecRef(attr);
9876     }
9877 }
9878
9879 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
9880 {
9881     if ( CanHaveAttributes() )
9882     {
9883         m_table->SetColAttr(attr, col);
9884         ClearAttrCache();
9885     }
9886     else
9887     {
9888         wxSafeDecRef(attr);
9889     }
9890 }
9891
9892 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
9893 {
9894     if ( CanHaveAttributes() )
9895     {
9896         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9897         attr->SetBackgroundColour(colour);
9898         attr->DecRef();
9899     }
9900 }
9901
9902 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
9903 {
9904     if ( CanHaveAttributes() )
9905     {
9906         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9907         attr->SetTextColour(colour);
9908         attr->DecRef();
9909     }
9910 }
9911
9912 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
9913 {
9914     if ( CanHaveAttributes() )
9915     {
9916         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9917         attr->SetFont(font);
9918         attr->DecRef();
9919     }
9920 }
9921
9922 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
9923 {
9924     if ( CanHaveAttributes() )
9925     {
9926         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9927         attr->SetAlignment(horiz, vert);
9928         attr->DecRef();
9929     }
9930 }
9931
9932 void wxGrid::SetCellOverflow( int row, int col, bool allow )
9933 {
9934     if ( CanHaveAttributes() )
9935     {
9936         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9937         attr->SetOverflow(allow);
9938         attr->DecRef();
9939     }
9940 }
9941
9942 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
9943 {
9944     if ( CanHaveAttributes() )
9945     {
9946         int cell_rows, cell_cols;
9947
9948         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9949         attr->GetSize(&cell_rows, &cell_cols);
9950         attr->SetSize(num_rows, num_cols);
9951         attr->DecRef();
9952
9953         // Cannot set the size of a cell to 0 or negative values
9954         // While it is perfectly legal to do that, this function cannot
9955         // handle all the possibilies, do it by hand by getting the CellAttr.
9956         // You can only set the size of a cell to 1,1 or greater with this fn
9957         wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
9958                       wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9959         wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
9960                       wxT("wxGrid::SetCellSize setting cell size to < 1"));
9961
9962         // if this was already a multicell then "turn off" the other cells first
9963         if ((cell_rows > 1) || (cell_cols > 1))
9964         {
9965             int i, j;
9966             for (j=row; j < row + cell_rows; j++)
9967             {
9968                 for (i=col; i < col + cell_cols; i++)
9969                 {
9970                     if ((i != col) || (j != row))
9971                     {
9972                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9973                         attr_stub->SetSize( 1, 1 );
9974                         attr_stub->DecRef();
9975                     }
9976                 }
9977             }
9978         }
9979
9980         // mark the cells that will be covered by this cell to
9981         // negative or zero values to point back at this cell
9982         if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
9983         {
9984             int i, j;
9985             for (j=row; j < row + num_rows; j++)
9986             {
9987                 for (i=col; i < col + num_cols; i++)
9988                 {
9989                     if ((i != col) || (j != row))
9990                     {
9991                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9992                         attr_stub->SetSize( row - j, col - i );
9993                         attr_stub->DecRef();
9994                     }
9995                 }
9996             }
9997         }
9998     }
9999 }
10000
10001 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
10002 {
10003     if ( CanHaveAttributes() )
10004     {
10005         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10006         attr->SetRenderer(renderer);
10007         attr->DecRef();
10008     }
10009 }
10010
10011 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
10012 {
10013     if ( CanHaveAttributes() )
10014     {
10015         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10016         attr->SetEditor(editor);
10017         attr->DecRef();
10018     }
10019 }
10020
10021 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
10022 {
10023     if ( CanHaveAttributes() )
10024     {
10025         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10026         attr->SetReadOnly(isReadOnly);
10027         attr->DecRef();
10028     }
10029 }
10030
10031 // ----------------------------------------------------------------------------
10032 // Data type registration
10033 // ----------------------------------------------------------------------------
10034
10035 void wxGrid::RegisterDataType(const wxString& typeName,
10036                               wxGridCellRenderer* renderer,
10037                               wxGridCellEditor* editor)
10038 {
10039     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
10040 }
10041
10042
10043 wxGridCellEditor * wxGrid::GetDefaultEditorForCell(int row, int col) const
10044 {
10045     wxString typeName = m_table->GetTypeName(row, col);
10046     return GetDefaultEditorForType(typeName);
10047 }
10048
10049 wxGridCellRenderer * wxGrid::GetDefaultRendererForCell(int row, int col) const
10050 {
10051     wxString typeName = m_table->GetTypeName(row, col);
10052     return GetDefaultRendererForType(typeName);
10053 }
10054
10055 wxGridCellEditor * wxGrid::GetDefaultEditorForType(const wxString& typeName) const
10056 {
10057     int index = m_typeRegistry->FindOrCloneDataType(typeName);
10058     if ( index == wxNOT_FOUND )
10059     {
10060         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
10061
10062         return NULL;
10063     }
10064
10065     return m_typeRegistry->GetEditor(index);
10066 }
10067
10068 wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName) const
10069 {
10070     int index = m_typeRegistry->FindOrCloneDataType(typeName);
10071     if ( index == wxNOT_FOUND )
10072     {
10073         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
10074
10075         return NULL;
10076     }
10077
10078     return m_typeRegistry->GetRenderer(index);
10079 }
10080
10081 // ----------------------------------------------------------------------------
10082 // row/col size
10083 // ----------------------------------------------------------------------------
10084
10085 void wxGrid::EnableDragRowSize( bool enable )
10086 {
10087     m_canDragRowSize = enable;
10088 }
10089
10090 void wxGrid::EnableDragColSize( bool enable )
10091 {
10092     m_canDragColSize = enable;
10093 }
10094
10095 void wxGrid::EnableDragGridSize( bool enable )
10096 {
10097     m_canDragGridSize = enable;
10098 }
10099
10100 void wxGrid::EnableDragCell( bool enable )
10101 {
10102     m_canDragCell = enable;
10103 }
10104
10105 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
10106 {
10107     m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
10108
10109     if ( resizeExistingRows )
10110     {
10111         // since we are resizing all rows to the default row size,
10112         // we can simply clear the row heights and row bottoms
10113         // arrays (which also allows us to take advantage of
10114         // some speed optimisations)
10115         m_rowHeights.Empty();
10116         m_rowBottoms.Empty();
10117         if ( !GetBatchCount() )
10118             CalcDimensions();
10119     }
10120 }
10121
10122 void wxGrid::SetRowSize( int row, int height )
10123 {
10124     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
10125
10126     // if < 0 then calculate new height from label
10127     if ( height < 0 )
10128     {
10129         long w, h;
10130         wxArrayString lines;
10131         wxClientDC dc(m_rowLabelWin);
10132         dc.SetFont(GetLabelFont());
10133         StringToLines(GetRowLabelValue( row ), lines);
10134         GetTextBoxSize( dc, lines, &w, &h );
10135         //check that it is not less than the minimal height
10136         height = wxMax(h, GetRowMinimalAcceptableHeight());
10137     }
10138
10139     // See comment in SetColSize
10140     if ( height < GetRowMinimalAcceptableHeight())
10141         return;
10142
10143     if ( m_rowHeights.IsEmpty() )
10144     {
10145         // need to really create the array
10146         InitRowHeights();
10147     }
10148
10149     int h = wxMax( 0, height );
10150     int diff = h - m_rowHeights[row];
10151
10152     m_rowHeights[row] = h;
10153     for ( int i = row; i < m_numRows; i++ )
10154     {
10155         m_rowBottoms[i] += diff;
10156     }
10157
10158     if ( !GetBatchCount() )
10159         CalcDimensions();
10160 }
10161
10162 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
10163 {
10164     // we dont allow zero default column width
10165     m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
10166
10167     if ( resizeExistingCols )
10168     {
10169         // since we are resizing all columns to the default column size,
10170         // we can simply clear the col widths and col rights
10171         // arrays (which also allows us to take advantage of
10172         // some speed optimisations)
10173         m_colWidths.Empty();
10174         m_colRights.Empty();
10175         if ( !GetBatchCount() )
10176             CalcDimensions();
10177     }
10178 }
10179
10180 void wxGrid::SetColSize( int col, int width )
10181 {
10182     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
10183
10184     // if < 0 then calculate new width from label
10185     if ( width < 0 )
10186     {
10187         long w, h;
10188         wxArrayString lines;
10189         wxClientDC dc(m_colLabelWin);
10190         dc.SetFont(GetLabelFont());
10191         StringToLines(GetColLabelValue(col), lines);
10192         if ( GetColLabelTextOrientation() == wxHORIZONTAL )
10193             GetTextBoxSize( dc, lines, &w, &h );
10194         else
10195             GetTextBoxSize( dc, lines, &h, &w );
10196         width = w + 6;
10197         //check that it is not less than the minimal width
10198         width = wxMax(width, GetColMinimalAcceptableWidth());
10199     }
10200
10201     // should we check that it's bigger than GetColMinimalWidth(col) here?
10202     //                                                                 (VZ)
10203     // No, because it is reasonable to assume the library user know's
10204     // what he is doing. However we should test against the weaker
10205     // constraint of minimalAcceptableWidth, as this breaks rendering
10206     //
10207     // This test then fixes sf.net bug #645734
10208
10209     if ( width < GetColMinimalAcceptableWidth() )
10210         return;
10211
10212     if ( m_colWidths.IsEmpty() )
10213     {
10214         // need to really create the array
10215         InitColWidths();
10216     }
10217
10218     int w = wxMax( 0, width );
10219     int diff = w - m_colWidths[col];
10220     m_colWidths[col] = w;
10221
10222     for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
10223     {
10224         m_colRights[GetColAt(colPos)] += diff;
10225     }
10226
10227     if ( !GetBatchCount() )
10228         CalcDimensions();
10229 }
10230
10231 void wxGrid::SetColMinimalWidth( int col, int width )
10232 {
10233     if (width > GetColMinimalAcceptableWidth())
10234     {
10235         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
10236         m_colMinWidths[key] = width;
10237     }
10238 }
10239
10240 void wxGrid::SetRowMinimalHeight( int row, int width )
10241 {
10242     if (width > GetRowMinimalAcceptableHeight())
10243     {
10244         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
10245         m_rowMinHeights[key] = width;
10246     }
10247 }
10248
10249 int wxGrid::GetColMinimalWidth(int col) const
10250 {
10251     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
10252     wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
10253
10254     return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
10255 }
10256
10257 int wxGrid::GetRowMinimalHeight(int row) const
10258 {
10259     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
10260     wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
10261
10262     return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
10263 }
10264
10265 void wxGrid::SetColMinimalAcceptableWidth( int width )
10266 {
10267     // We do allow a width of 0 since this gives us
10268     // an easy way to temporarily hiding columns.
10269     if ( width >= 0 )
10270         m_minAcceptableColWidth = width;
10271 }
10272
10273 void wxGrid::SetRowMinimalAcceptableHeight( int height )
10274 {
10275     // We do allow a height of 0 since this gives us
10276     // an easy way to temporarily hiding rows.
10277     if ( height >= 0 )
10278         m_minAcceptableRowHeight = height;
10279 }
10280
10281 int  wxGrid::GetColMinimalAcceptableWidth() const
10282 {
10283     return m_minAcceptableColWidth;
10284 }
10285
10286 int  wxGrid::GetRowMinimalAcceptableHeight() const
10287 {
10288     return m_minAcceptableRowHeight;
10289 }
10290
10291 // ----------------------------------------------------------------------------
10292 // auto sizing
10293 // ----------------------------------------------------------------------------
10294
10295 void
10296 wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
10297 {
10298     const bool column = direction == wxGRID_COLUMN;
10299
10300     wxClientDC dc(m_gridWin);
10301
10302     // cancel editing of cell
10303     HideCellEditControl();
10304     SaveEditControlValue();
10305
10306     // init both of them to avoid compiler warnings, even if we only need one
10307     int row = -1,
10308         col = -1;
10309     if ( column )
10310         col = colOrRow;
10311     else
10312         row = colOrRow;
10313
10314     wxCoord extent, extentMax = 0;
10315     int max = column ? m_numRows : m_numCols;
10316     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
10317     {
10318         if ( column )
10319             row = rowOrCol;
10320         else
10321             col = rowOrCol;
10322
10323         wxGridCellAttr *attr = GetCellAttr(row, col);
10324         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
10325         if ( renderer )
10326         {
10327             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
10328             extent = column ? size.x : size.y;
10329             if ( extent > extentMax )
10330                 extentMax = extent;
10331
10332             renderer->DecRef();
10333         }
10334
10335         attr->DecRef();
10336     }
10337
10338     // now also compare with the column label extent
10339     wxCoord w, h;
10340     dc.SetFont( GetLabelFont() );
10341
10342     if ( column )
10343     {
10344         dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
10345         if ( GetColLabelTextOrientation() == wxVERTICAL )
10346             w = h;
10347     }
10348     else
10349         dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
10350
10351     extent = column ? w : h;
10352     if ( extent > extentMax )
10353         extentMax = extent;
10354
10355     if ( !extentMax )
10356     {
10357         // empty column - give default extent (notice that if extentMax is less
10358         // than default extent but != 0, it's OK)
10359         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
10360     }
10361     else
10362     {
10363         if ( column )
10364             // leave some space around text
10365             extentMax += 10;
10366         else
10367             extentMax += 6;
10368     }
10369
10370     if ( column )
10371     {
10372         // Ensure automatic width is not less than minimal width. See the
10373         // comment in SetColSize() for explanation of why this isn't done
10374         // in SetColSize().
10375         if ( !setAsMin )
10376             extentMax = wxMax(extentMax, GetColMinimalWidth(col));
10377
10378         SetColSize( col, extentMax );
10379         if ( !GetBatchCount() )
10380         {
10381             int cw, ch, dummy;
10382             m_gridWin->GetClientSize( &cw, &ch );
10383             wxRect rect ( CellToRect( 0, col ) );
10384             rect.y = 0;
10385             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
10386             rect.width = cw - rect.x;
10387             rect.height = m_colLabelHeight;
10388             m_colLabelWin->Refresh( true, &rect );
10389         }
10390     }
10391     else
10392     {
10393         // Ensure automatic width is not less than minimal height. See the
10394         // comment in SetColSize() for explanation of why this isn't done
10395         // in SetRowSize().
10396         if ( !setAsMin )
10397             extentMax = wxMax(extentMax, GetRowMinimalHeight(row));
10398
10399         SetRowSize(row, extentMax);
10400         if ( !GetBatchCount() )
10401         {
10402             int cw, ch, dummy;
10403             m_gridWin->GetClientSize( &cw, &ch );
10404             wxRect rect( CellToRect( row, 0 ) );
10405             rect.x = 0;
10406             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
10407             rect.width = m_rowLabelWidth;
10408             rect.height = ch - rect.y;
10409             m_rowLabelWin->Refresh( true, &rect );
10410         }
10411     }
10412
10413     if ( setAsMin )
10414     {
10415         if ( column )
10416             SetColMinimalWidth(col, extentMax);
10417         else
10418             SetRowMinimalHeight(row, extentMax);
10419     }
10420 }
10421
10422 wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
10423 {
10424     // calculate size for the rows or columns?
10425     const bool calcRows = direction == wxGRID_ROW;
10426
10427     wxClientDC dc(calcRows ? GetGridRowLabelWindow()
10428                            : GetGridColLabelWindow());
10429     dc.SetFont(GetLabelFont());
10430
10431     // which dimension should we take into account for calculations?
10432     //
10433     // for columns, the text can be only horizontal so it's easy but for rows
10434     // we also have to take into account the text orientation
10435     const bool
10436         useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
10437
10438     wxArrayString lines;
10439     wxCoord extentMax = 0;
10440
10441     const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
10442     for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
10443     {
10444         lines.Clear();
10445
10446         wxString label = calcRows ? GetRowLabelValue(rowOrCol)
10447                                   : GetColLabelValue(rowOrCol);
10448         StringToLines(label, lines);
10449
10450         long w, h;
10451         GetTextBoxSize(dc, lines, &w, &h);
10452
10453         const wxCoord extent = useWidth ? w : h;
10454         if ( extent > extentMax )
10455             extentMax = extent;
10456     }
10457
10458     if ( !extentMax )
10459     {
10460         // empty column - give default extent (notice that if extentMax is less
10461         // than default extent but != 0, it's OK)
10462         extentMax = calcRows ? GetDefaultRowLabelSize()
10463                              : GetDefaultColLabelSize();
10464     }
10465
10466     // leave some space around text (taken from AutoSizeColOrRow)
10467     if ( calcRows )
10468         extentMax += 10;
10469     else
10470         extentMax += 6;
10471
10472     return extentMax;
10473 }
10474
10475 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
10476 {
10477     int width = m_rowLabelWidth;
10478
10479     wxGridUpdateLocker locker;
10480     if(!calcOnly)
10481         locker.Create(this);
10482
10483     for ( int col = 0; col < m_numCols; col++ )
10484     {
10485         if ( !calcOnly )
10486             AutoSizeColumn(col, setAsMin);
10487
10488         width += GetColWidth(col);
10489     }
10490
10491     return width;
10492 }
10493
10494 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
10495 {
10496     int height = m_colLabelHeight;
10497
10498     wxGridUpdateLocker locker;
10499     if(!calcOnly)
10500         locker.Create(this);
10501
10502     for ( int row = 0; row < m_numRows; row++ )
10503     {
10504         if ( !calcOnly )
10505             AutoSizeRow(row, setAsMin);
10506
10507         height += GetRowHeight(row);
10508     }
10509
10510     return height;
10511 }
10512
10513 void wxGrid::AutoSize()
10514 {
10515     wxGridUpdateLocker locker(this);
10516
10517     wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
10518                 SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
10519
10520     // we know that we're not going to have scrollbars so disable them now to
10521     // avoid trouble in SetClientSize() which can otherwise set the correct
10522     // client size but also leave space for (not needed any more) scrollbars
10523     SetScrollbars(0, 0, 0, 0, 0, 0, true);
10524
10525     // restore the scroll rate parameters overwritten by SetScrollbars()
10526     SetScrollRate(m_scrollLineX, m_scrollLineY);
10527
10528     SetClientSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight);
10529 }
10530
10531 void wxGrid::AutoSizeRowLabelSize( int row )
10532 {
10533     // Hide the edit control, so it
10534     // won't interfere with drag-shrinking.
10535     if ( IsCellEditControlShown() )
10536     {
10537         HideCellEditControl();
10538         SaveEditControlValue();
10539     }
10540
10541     // autosize row height depending on label text
10542     SetRowSize(row, -1);
10543     ForceRefresh();
10544 }
10545
10546 void wxGrid::AutoSizeColLabelSize( int col )
10547 {
10548     // Hide the edit control, so it
10549     // won't interfere with drag-shrinking.
10550     if ( IsCellEditControlShown() )
10551     {
10552         HideCellEditControl();
10553         SaveEditControlValue();
10554     }
10555
10556     // autosize column width depending on label text
10557     SetColSize(col, -1);
10558     ForceRefresh();
10559 }
10560
10561 wxSize wxGrid::DoGetBestSize() const
10562 {
10563     wxGrid *self = (wxGrid *)this;  // const_cast
10564
10565     // we do the same as in AutoSize() here with the exception that we don't
10566     // change the column/row sizes, only calculate them
10567     wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
10568                 self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
10569
10570     // NOTE: This size should be cached, but first we need to add calls to
10571     // InvalidateBestSize everywhere that could change the results of this
10572     // calculation.
10573     // CacheBestSize(size);
10574
10575     return wxSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight)
10576             + GetWindowBorderSize();
10577 }
10578
10579 void wxGrid::Fit()
10580 {
10581     AutoSize();
10582 }
10583
10584 wxPen& wxGrid::GetDividerPen() const
10585 {
10586     return wxNullPen;
10587 }
10588
10589 // ----------------------------------------------------------------------------
10590 // cell value accessor functions
10591 // ----------------------------------------------------------------------------
10592
10593 void wxGrid::SetCellValue( int row, int col, const wxString& s )
10594 {
10595     if ( m_table )
10596     {
10597         m_table->SetValue( row, col, s );
10598         if ( !GetBatchCount() )
10599         {
10600             int dummy;
10601             wxRect rect( CellToRect( row, col ) );
10602             rect.x = 0;
10603             rect.width = m_gridWin->GetClientSize().GetWidth();
10604             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
10605             m_gridWin->Refresh( false, &rect );
10606         }
10607
10608         if ( m_currentCellCoords.GetRow() == row &&
10609              m_currentCellCoords.GetCol() == col &&
10610              IsCellEditControlShown())
10611              // Note: If we are using IsCellEditControlEnabled,
10612              // this interacts badly with calling SetCellValue from
10613              // an EVT_GRID_CELL_CHANGE handler.
10614         {
10615             HideCellEditControl();
10616             ShowCellEditControl(); // will reread data from table
10617         }
10618     }
10619 }
10620
10621 // ----------------------------------------------------------------------------
10622 // block, row and column selection
10623 // ----------------------------------------------------------------------------
10624
10625 void wxGrid::SelectRow( int row, bool addToSelected )
10626 {
10627     if ( !m_selection )
10628         return;
10629
10630     if ( !addToSelected )
10631         ClearSelection();
10632
10633     m_selection->SelectRow(row);
10634 }
10635
10636 void wxGrid::SelectCol( int col, bool addToSelected )
10637 {
10638     if ( !m_selection )
10639         return;
10640
10641     if ( !addToSelected )
10642         ClearSelection();
10643
10644     m_selection->SelectCol(col);
10645 }
10646
10647 void wxGrid::SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
10648                          bool addToSelected)
10649 {
10650     if ( !m_selection )
10651         return;
10652
10653     if ( !addToSelected )
10654         ClearSelection();
10655
10656     m_selection->SelectBlock(topRow, leftCol, bottomRow, rightCol);
10657 }
10658
10659 void wxGrid::SelectAll()
10660 {
10661     if ( m_numRows > 0 && m_numCols > 0 )
10662     {
10663         if ( m_selection )
10664             m_selection->SelectBlock( 0, 0, m_numRows - 1, m_numCols - 1 );
10665     }
10666 }
10667
10668 // ----------------------------------------------------------------------------
10669 // cell, row and col deselection
10670 // ----------------------------------------------------------------------------
10671
10672 void wxGrid::DeselectLine(int line, const wxGridOperations& oper)
10673 {
10674     if ( !m_selection )
10675         return;
10676
10677     const wxGridSelectionModes mode = m_selection->GetSelectionMode();
10678     if ( mode == oper.GetSelectionMode() )
10679     {
10680         const wxGridCellCoords c(oper.MakeCoords(line, 0));
10681         if ( m_selection->IsInSelection(c) )
10682             m_selection->ToggleCellSelection(c);
10683     }
10684     else if ( mode != oper.Dual().GetSelectionMode() )
10685     {
10686         const int nOther = oper.Dual().GetNumberOfLines(this);
10687         for ( int i = 0; i < nOther; i++ )
10688         {
10689             const wxGridCellCoords c(oper.MakeCoords(line, i));
10690             if ( m_selection->IsInSelection(c) )
10691                 m_selection->ToggleCellSelection(c);
10692         }
10693     }
10694     //else: can only select orthogonal lines so no lines in this direction
10695     //      could have been selected anyhow
10696 }
10697
10698 void wxGrid::DeselectRow(int row)
10699 {
10700     DeselectLine(row, wxGridRowOperations());
10701 }
10702
10703 void wxGrid::DeselectCol(int col)
10704 {
10705     DeselectLine(col, wxGridColumnOperations());
10706 }
10707
10708 void wxGrid::DeselectCell( int row, int col )
10709 {
10710     if ( m_selection && m_selection->IsInSelection(row, col) )
10711         m_selection->ToggleCellSelection(row, col);
10712 }
10713
10714 bool wxGrid::IsSelection() const
10715 {
10716     return ( m_selection && (m_selection->IsSelection() ||
10717              ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
10718                m_selectedBlockBottomRight != wxGridNoCellCoords) ) );
10719 }
10720
10721 bool wxGrid::IsInSelection( int row, int col ) const
10722 {
10723     return ( m_selection && (m_selection->IsInSelection( row, col ) ||
10724              ( row >= m_selectedBlockTopLeft.GetRow() &&
10725                col >= m_selectedBlockTopLeft.GetCol() &&
10726                row <= m_selectedBlockBottomRight.GetRow() &&
10727                col <= m_selectedBlockBottomRight.GetCol() )) );
10728 }
10729
10730 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
10731 {
10732     if (!m_selection)
10733     {
10734         wxGridCellCoordsArray a;
10735         return a;
10736     }
10737
10738     return m_selection->m_cellSelection;
10739 }
10740
10741 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
10742 {
10743     if (!m_selection)
10744     {
10745         wxGridCellCoordsArray a;
10746         return a;
10747     }
10748
10749     return m_selection->m_blockSelectionTopLeft;
10750 }
10751
10752 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
10753 {
10754     if (!m_selection)
10755     {
10756         wxGridCellCoordsArray a;
10757         return a;
10758     }
10759
10760     return m_selection->m_blockSelectionBottomRight;
10761 }
10762
10763 wxArrayInt wxGrid::GetSelectedRows() const
10764 {
10765     if (!m_selection)
10766     {
10767         wxArrayInt a;
10768         return a;
10769     }
10770
10771     return m_selection->m_rowSelection;
10772 }
10773
10774 wxArrayInt wxGrid::GetSelectedCols() const
10775 {
10776     if (!m_selection)
10777     {
10778         wxArrayInt a;
10779         return a;
10780     }
10781
10782     return m_selection->m_colSelection;
10783 }
10784
10785 void wxGrid::ClearSelection()
10786 {
10787     wxRect r1 = BlockToDeviceRect(m_selectedBlockTopLeft,
10788                                   m_selectedBlockBottomRight);
10789     wxRect r2 = BlockToDeviceRect(m_currentCellCoords,
10790                                   m_selectedBlockCorner);
10791
10792     m_selectedBlockTopLeft =
10793     m_selectedBlockBottomRight =
10794     m_selectedBlockCorner = wxGridNoCellCoords;
10795
10796     Refresh( false, &r1 );
10797     Refresh( false, &r2 );
10798
10799     if ( m_selection )
10800         m_selection->ClearSelection();
10801 }
10802
10803 // This function returns the rectangle that encloses the given block
10804 // in device coords clipped to the client size of the grid window.
10805 //
10806 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords& topLeft,
10807                                   const wxGridCellCoords& bottomRight ) const
10808 {
10809     wxRect resultRect;
10810     wxRect tempCellRect = CellToRect(topLeft);
10811     if ( tempCellRect != wxGridNoCellRect )
10812     {
10813         resultRect = tempCellRect;
10814     }
10815     else
10816     {
10817         resultRect = wxRect(0, 0, 0, 0);
10818     }
10819
10820     tempCellRect = CellToRect(bottomRight);
10821     if ( tempCellRect != wxGridNoCellRect )
10822     {
10823         resultRect += tempCellRect;
10824     }
10825     else
10826     {
10827         // If both inputs were "wxGridNoCellRect," then there's nothing to do.
10828         return wxGridNoCellRect;
10829     }
10830
10831     // Ensure that left/right and top/bottom pairs are in order.
10832     int left = resultRect.GetLeft();
10833     int top = resultRect.GetTop();
10834     int right = resultRect.GetRight();
10835     int bottom = resultRect.GetBottom();
10836
10837     int leftCol = topLeft.GetCol();
10838     int topRow = topLeft.GetRow();
10839     int rightCol = bottomRight.GetCol();
10840     int bottomRow = bottomRight.GetRow();
10841
10842     if (left > right)
10843     {
10844         int tmp = left;
10845         left = right;
10846         right = tmp;
10847
10848         tmp = leftCol;
10849         leftCol = rightCol;
10850         rightCol = tmp;
10851     }
10852
10853     if (top > bottom)
10854     {
10855         int tmp = top;
10856         top = bottom;
10857         bottom = tmp;
10858
10859         tmp = topRow;
10860         topRow = bottomRow;
10861         bottomRow = tmp;
10862     }
10863
10864     // The following loop is ONLY necessary to detect and handle merged cells.
10865     int cw, ch;
10866     m_gridWin->GetClientSize( &cw, &ch );
10867
10868     // Get the origin coordinates: notice that they will be negative if the
10869     // grid is scrolled downwards/to the right.
10870     int gridOriginX = 0;
10871     int gridOriginY = 0;
10872     CalcScrolledPosition(gridOriginX, gridOriginY, &gridOriginX, &gridOriginY);
10873
10874     int onScreenLeftmostCol = internalXToCol(-gridOriginX);
10875     int onScreenUppermostRow = internalYToRow(-gridOriginY);
10876
10877     int onScreenRightmostCol = internalXToCol(-gridOriginX + cw);
10878     int onScreenBottommostRow = internalYToRow(-gridOriginY + ch);
10879
10880     // Bound our loop so that we only examine the portion of the selected block
10881     // that is shown on screen. Therefore, we compare the Top-Left block values
10882     // to the Top-Left screen values, and the Bottom-Right block values to the
10883     // Bottom-Right screen values, choosing appropriately.
10884     const int visibleTopRow = wxMax(topRow, onScreenUppermostRow);
10885     const int visibleBottomRow = wxMin(bottomRow, onScreenBottommostRow);
10886     const int visibleLeftCol = wxMax(leftCol, onScreenLeftmostCol);
10887     const int visibleRightCol = wxMin(rightCol, onScreenRightmostCol);
10888
10889     for ( int j = visibleTopRow; j <= visibleBottomRow; j++ )
10890     {
10891         for ( int i = visibleLeftCol; i <= visibleRightCol; i++ )
10892         {
10893             if ( (j == visibleTopRow) || (j == visibleBottomRow) ||
10894                     (i == visibleLeftCol) || (i == visibleRightCol) )
10895             {
10896                 tempCellRect = CellToRect( j, i );
10897
10898                 if (tempCellRect.x < left)
10899                     left = tempCellRect.x;
10900                 if (tempCellRect.y < top)
10901                     top = tempCellRect.y;
10902                 if (tempCellRect.x + tempCellRect.width > right)
10903                     right = tempCellRect.x + tempCellRect.width;
10904                 if (tempCellRect.y + tempCellRect.height > bottom)
10905                     bottom = tempCellRect.y + tempCellRect.height;
10906             }
10907             else
10908             {
10909                 i = visibleRightCol; // jump over inner cells.
10910             }
10911         }
10912     }
10913
10914     // Convert to scrolled coords
10915     CalcScrolledPosition( left, top, &left, &top );
10916     CalcScrolledPosition( right, bottom, &right, &bottom );
10917
10918     if (right < 0 || bottom < 0 || left > cw || top > ch)
10919         return wxRect(0,0,0,0);
10920
10921     resultRect.SetLeft( wxMax(0, left) );
10922     resultRect.SetTop( wxMax(0, top) );
10923     resultRect.SetRight( wxMin(cw, right) );
10924     resultRect.SetBottom( wxMin(ch, bottom) );
10925
10926     return resultRect;
10927 }
10928
10929 // ----------------------------------------------------------------------------
10930 // drop target
10931 // ----------------------------------------------------------------------------
10932
10933 #if wxUSE_DRAG_AND_DROP
10934
10935 // this allow setting drop target directly on wxGrid
10936 void wxGrid::SetDropTarget(wxDropTarget *dropTarget)
10937 {
10938     GetGridWindow()->SetDropTarget(dropTarget);
10939 }
10940
10941 #endif // wxUSE_DRAG_AND_DROP
10942
10943 // ----------------------------------------------------------------------------
10944 // grid event classes
10945 // ----------------------------------------------------------------------------
10946
10947 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
10948
10949 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
10950                           int row, int col, int x, int y, bool sel,
10951                           bool control, bool shift, bool alt, bool meta )
10952         : wxNotifyEvent( type, id ),
10953           wxKeyboardState(control, shift, alt, meta)
10954 {
10955     Init(row, col, x, y, sel);
10956
10957     SetEventObject(obj);
10958 }
10959
10960 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
10961
10962 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
10963                                   int rowOrCol, int x, int y,
10964                                   bool control, bool shift, bool alt, bool meta )
10965         : wxNotifyEvent( type, id ),
10966           wxKeyboardState(control, shift, alt, meta)
10967 {
10968     Init(rowOrCol, x, y);
10969
10970     SetEventObject(obj);
10971 }
10972
10973
10974 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
10975
10976 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
10977                                                const wxGridCellCoords& topLeft,
10978                                                const wxGridCellCoords& bottomRight,
10979                                                bool sel, bool control,
10980                                                bool shift, bool alt, bool meta )
10981         : wxNotifyEvent( type, id ),
10982           wxKeyboardState(control, shift, alt, meta)
10983 {
10984     Init(topLeft, bottomRight, sel);
10985
10986     SetEventObject(obj);
10987 }
10988
10989
10990 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
10991
10992 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
10993                                                    wxObject* obj, int row,
10994                                                    int col, wxControl* ctrl)
10995     : wxCommandEvent(type, id)
10996 {
10997     SetEventObject(obj);
10998     m_row = row;
10999     m_col = col;
11000     m_ctrl = ctrl;
11001 }
11002
11003 #endif // wxUSE_GRID