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