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