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