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