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         if ( attr )
2755         {
2756             // add the attribute
2757             m_rowsOrCols.Add(rowOrCol);
2758             m_attrs.Add(attr);
2759         }
2760         // nothing to remove
2761     }
2762     else
2763     {
2764         size_t n = (size_t)i;
2765         if ( attr )
2766         {
2767             // change the attribute
2768             m_attrs[n]->DecRef();
2769             m_attrs[n] = attr;
2770         }
2771         else
2772         {
2773             // remove this attribute
2774             m_attrs[n]->DecRef();
2775             m_rowsOrCols.RemoveAt(n);
2776             m_attrs.RemoveAt(n);
2777         }
2778     }
2779 }
2780
2781 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2782 {
2783     size_t count = m_attrs.GetCount();
2784     for ( size_t n = 0; n < count; n++ )
2785     {
2786         int & rowOrCol = m_rowsOrCols[n];
2787         if ( (size_t)rowOrCol >= pos )
2788         {
2789             if ( numRowsOrCols > 0 )
2790             {
2791                 // If rows inserted, include row counter where necessary
2792                 rowOrCol += numRowsOrCols;
2793             }
2794             else if ( numRowsOrCols < 0)
2795             {
2796                 // If rows deleted, either decrement row counter (if row still exists)
2797                 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2798                     rowOrCol += numRowsOrCols;
2799                 else
2800                 {
2801                     m_rowsOrCols.RemoveAt(n);
2802                     m_attrs[n]->DecRef();
2803                     m_attrs.RemoveAt(n);
2804                     n--;
2805                     count--;
2806                 }
2807             }
2808         }
2809     }
2810 }
2811
2812 // ----------------------------------------------------------------------------
2813 // wxGridCellAttrProvider
2814 // ----------------------------------------------------------------------------
2815
2816 wxGridCellAttrProvider::wxGridCellAttrProvider()
2817 {
2818     m_data = (wxGridCellAttrProviderData *)NULL;
2819 }
2820
2821 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2822 {
2823     delete m_data;
2824 }
2825
2826 void wxGridCellAttrProvider::InitData()
2827 {
2828     m_data = new wxGridCellAttrProviderData;
2829 }
2830
2831 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
2832                                                 wxGridCellAttr::wxAttrKind  kind ) const
2833 {
2834     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2835     if ( m_data )
2836     {
2837         switch (kind)
2838         {
2839             case (wxGridCellAttr::Any):
2840                 // Get cached merge attributes.
2841                 // Currently not used as no cache implemented as not mutable
2842                 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2843                 if (!attr)
2844                 {
2845                     // Basically implement old version.
2846                     // Also check merge cache, so we don't have to re-merge every time..
2847                     wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
2848                     wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
2849                     wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
2850
2851                     if ((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol))
2852                     {
2853                         // Two or more are non NULL
2854                         attr = new wxGridCellAttr;
2855                         attr->SetKind(wxGridCellAttr::Merged);
2856
2857                         // Order is important..
2858                         if (attrcell)
2859                         {
2860                             attr->MergeWith(attrcell);
2861                             attrcell->DecRef();
2862                         }
2863                         if (attrcol)
2864                         {
2865                             attr->MergeWith(attrcol);
2866                             attrcol->DecRef();
2867                         }
2868                         if (attrrow)
2869                         {
2870                             attr->MergeWith(attrrow);
2871                             attrrow->DecRef();
2872                         }
2873
2874                         // store merge attr if cache implemented
2875                         //attr->IncRef();
2876                         //m_data->m_mergeAttr.SetAttr(attr, row, col);
2877                     }
2878                     else
2879                     {
2880                         // one or none is non null return it or null.
2881                         if (attrrow)
2882                             attr = attrrow;
2883                         if (attrcol)
2884                         {
2885                             if (attr)
2886                                 attr->DecRef();
2887                             attr = attrcol;
2888                         }
2889                         if (attrcell)
2890                         {
2891                             if (attr)
2892                                 attr->DecRef();
2893                             attr = attrcell;
2894                         }
2895                     }
2896                 }
2897                 break;
2898
2899             case (wxGridCellAttr::Cell):
2900                 attr = m_data->m_cellAttrs.GetAttr(row, col);
2901                 break;
2902
2903             case (wxGridCellAttr::Col):
2904                 attr = m_data->m_colAttrs.GetAttr(col);
2905                 break;
2906
2907             case (wxGridCellAttr::Row):
2908                 attr = m_data->m_rowAttrs.GetAttr(row);
2909                 break;
2910
2911             default:
2912                 // unused as yet...
2913                 // (wxGridCellAttr::Default):
2914                 // (wxGridCellAttr::Merged):
2915                 break;
2916         }
2917     }
2918
2919     return attr;
2920 }
2921
2922 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2923                                      int row, int col)
2924 {
2925     if ( !m_data )
2926         InitData();
2927
2928     m_data->m_cellAttrs.SetAttr(attr, row, col);
2929 }
2930
2931 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2932 {
2933     if ( !m_data )
2934         InitData();
2935
2936     m_data->m_rowAttrs.SetAttr(attr, row);
2937 }
2938
2939 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2940 {
2941     if ( !m_data )
2942         InitData();
2943
2944     m_data->m_colAttrs.SetAttr(attr, col);
2945 }
2946
2947 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2948 {
2949     if ( m_data )
2950     {
2951         m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2952
2953         m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2954     }
2955 }
2956
2957 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2958 {
2959     if ( m_data )
2960     {
2961         m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2962
2963         m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2964     }
2965 }
2966
2967 // ----------------------------------------------------------------------------
2968 // wxGridTypeRegistry
2969 // ----------------------------------------------------------------------------
2970
2971 wxGridTypeRegistry::~wxGridTypeRegistry()
2972 {
2973     size_t count = m_typeinfo.GetCount();
2974     for ( size_t i = 0; i < count; i++ )
2975         delete m_typeinfo[i];
2976 }
2977
2978 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2979                                           wxGridCellRenderer* renderer,
2980                                           wxGridCellEditor* editor)
2981 {
2982     wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2983
2984     // is it already registered?
2985     int loc = FindRegisteredDataType(typeName);
2986     if ( loc != wxNOT_FOUND )
2987     {
2988         delete m_typeinfo[loc];
2989         m_typeinfo[loc] = info;
2990     }
2991     else
2992     {
2993         m_typeinfo.Add(info);
2994     }
2995 }
2996
2997 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2998 {
2999     size_t count = m_typeinfo.GetCount();
3000     for ( size_t i = 0; i < count; i++ )
3001     {
3002         if ( typeName == m_typeinfo[i]->m_typeName )
3003         {
3004             return i;
3005         }
3006     }
3007
3008     return wxNOT_FOUND;
3009 }
3010
3011 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
3012 {
3013     int index = FindRegisteredDataType(typeName);
3014     if ( index == wxNOT_FOUND )
3015     {
3016         // check whether this is one of the standard ones, in which case
3017         // register it "on the fly"
3018 #if wxUSE_TEXTCTRL
3019         if ( typeName == wxGRID_VALUE_STRING )
3020         {
3021             RegisterDataType(wxGRID_VALUE_STRING,
3022                              new wxGridCellStringRenderer,
3023                              new wxGridCellTextEditor);
3024         }
3025         else
3026 #endif // wxUSE_TEXTCTRL
3027 #if wxUSE_CHECKBOX
3028         if ( typeName == wxGRID_VALUE_BOOL )
3029         {
3030             RegisterDataType(wxGRID_VALUE_BOOL,
3031                              new wxGridCellBoolRenderer,
3032                              new wxGridCellBoolEditor);
3033         }
3034         else
3035 #endif // wxUSE_CHECKBOX
3036 #if wxUSE_TEXTCTRL
3037         if ( typeName == wxGRID_VALUE_NUMBER )
3038         {
3039             RegisterDataType(wxGRID_VALUE_NUMBER,
3040                              new wxGridCellNumberRenderer,
3041                              new wxGridCellNumberEditor);
3042         }
3043         else if ( typeName == wxGRID_VALUE_FLOAT )
3044         {
3045             RegisterDataType(wxGRID_VALUE_FLOAT,
3046                              new wxGridCellFloatRenderer,
3047                              new wxGridCellFloatEditor);
3048         }
3049         else
3050 #endif // wxUSE_TEXTCTRL
3051 #if wxUSE_COMBOBOX
3052         if ( typeName == wxGRID_VALUE_CHOICE )
3053         {
3054             RegisterDataType(wxGRID_VALUE_CHOICE,
3055                              new wxGridCellStringRenderer,
3056                              new wxGridCellChoiceEditor);
3057         }
3058         else
3059 #endif // wxUSE_COMBOBOX
3060         {
3061             return wxNOT_FOUND;
3062         }
3063
3064         // we get here only if just added the entry for this type, so return
3065         // the last index
3066         index = m_typeinfo.GetCount() - 1;
3067     }
3068
3069     return index;
3070 }
3071
3072 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
3073 {
3074     int index = FindDataType(typeName);
3075     if ( index == wxNOT_FOUND )
3076     {
3077         // the first part of the typename is the "real" type, anything after ':'
3078         // are the parameters for the renderer
3079         index = FindDataType(typeName.BeforeFirst(_T(':')));
3080         if ( index == wxNOT_FOUND )
3081         {
3082             return wxNOT_FOUND;
3083         }
3084
3085         wxGridCellRenderer *renderer = GetRenderer(index);
3086         wxGridCellRenderer *rendererOld = renderer;
3087         renderer = renderer->Clone();
3088         rendererOld->DecRef();
3089
3090         wxGridCellEditor *editor = GetEditor(index);
3091         wxGridCellEditor *editorOld = editor;
3092         editor = editor->Clone();
3093         editorOld->DecRef();
3094
3095         // do it even if there are no parameters to reset them to defaults
3096         wxString params = typeName.AfterFirst(_T(':'));
3097         renderer->SetParameters(params);
3098         editor->SetParameters(params);
3099
3100         // register the new typename
3101         RegisterDataType(typeName, renderer, editor);
3102
3103         // we just registered it, it's the last one
3104         index = m_typeinfo.GetCount() - 1;
3105     }
3106
3107     return index;
3108 }
3109
3110 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
3111 {
3112     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
3113     if (renderer)
3114         renderer->IncRef();
3115
3116     return renderer;
3117 }
3118
3119 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
3120 {
3121     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
3122     if (editor)
3123         editor->IncRef();
3124
3125     return editor;
3126 }
3127
3128 // ----------------------------------------------------------------------------
3129 // wxGridTableBase
3130 // ----------------------------------------------------------------------------
3131
3132 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
3133
3134 wxGridTableBase::wxGridTableBase()
3135 {
3136     m_view = (wxGrid *) NULL;
3137     m_attrProvider = (wxGridCellAttrProvider *) NULL;
3138 }
3139
3140 wxGridTableBase::~wxGridTableBase()
3141 {
3142     delete m_attrProvider;
3143 }
3144
3145 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
3146 {
3147     delete m_attrProvider;
3148     m_attrProvider = attrProvider;
3149 }
3150
3151 bool wxGridTableBase::CanHaveAttributes()
3152 {
3153     if ( ! GetAttrProvider() )
3154     {
3155         // use the default attr provider by default
3156         SetAttrProvider(new wxGridCellAttrProvider);
3157     }
3158
3159     return true;
3160 }
3161
3162 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind  kind)
3163 {
3164     if ( m_attrProvider )
3165         return m_attrProvider->GetAttr(row, col, kind);
3166     else
3167         return (wxGridCellAttr *)NULL;
3168 }
3169
3170 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
3171 {
3172     if ( m_attrProvider )
3173     {
3174         attr->SetKind(wxGridCellAttr::Cell);
3175         m_attrProvider->SetAttr(attr, row, col);
3176     }
3177     else
3178     {
3179         // as we take ownership of the pointer and don't store it, we must
3180         // free it now
3181         wxSafeDecRef(attr);
3182     }
3183 }
3184
3185 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
3186 {
3187     if ( m_attrProvider )
3188     {
3189         attr->SetKind(wxGridCellAttr::Row);
3190         m_attrProvider->SetRowAttr(attr, row);
3191     }
3192     else
3193     {
3194         // as we take ownership of the pointer and don't store it, we must
3195         // free it now
3196         wxSafeDecRef(attr);
3197     }
3198 }
3199
3200 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
3201 {
3202     if ( m_attrProvider )
3203     {
3204         attr->SetKind(wxGridCellAttr::Col);
3205         m_attrProvider->SetColAttr(attr, col);
3206     }
3207     else
3208     {
3209         // as we take ownership of the pointer and don't store it, we must
3210         // free it now
3211         wxSafeDecRef(attr);
3212     }
3213 }
3214
3215 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
3216                                   size_t WXUNUSED(numRows) )
3217 {
3218     wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
3219
3220     return false;
3221 }
3222
3223 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
3224 {
3225     wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
3226
3227     return false;
3228 }
3229
3230 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
3231                                   size_t WXUNUSED(numRows) )
3232 {
3233     wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
3234
3235     return false;
3236 }
3237
3238 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
3239                                   size_t WXUNUSED(numCols) )
3240 {
3241     wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
3242
3243     return false;
3244 }
3245
3246 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
3247 {
3248     wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
3249
3250     return false;
3251 }
3252
3253 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
3254                                   size_t WXUNUSED(numCols) )
3255 {
3256     wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
3257
3258     return false;
3259 }
3260
3261 wxString wxGridTableBase::GetRowLabelValue( int row )
3262 {
3263     wxString s;
3264
3265     // RD: Starting the rows at zero confuses users,
3266     // no matter how much it makes sense to us geeks.
3267     s << row + 1;
3268
3269     return s;
3270 }
3271
3272 wxString wxGridTableBase::GetColLabelValue( int col )
3273 {
3274     // default col labels are:
3275     //   cols 0 to 25   : A-Z
3276     //   cols 26 to 675 : AA-ZZ
3277     //   etc.
3278
3279     wxString s;
3280     unsigned int i, n;
3281     for ( n = 1; ; n++ )
3282     {
3283         s += (wxChar) (_T('A') + (wxChar)(col % 26));
3284         col = col / 26 - 1;
3285         if ( col < 0 )
3286             break;
3287     }
3288
3289     // reverse the string...
3290     wxString s2;
3291     for ( i = 0; i < n; i++ )
3292     {
3293         s2 += s[n - i - 1];
3294     }
3295
3296     return s2;
3297 }
3298
3299 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
3300 {
3301     return wxGRID_VALUE_STRING;
3302 }
3303
3304 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
3305                                      const wxString& typeName )
3306 {
3307     return typeName == wxGRID_VALUE_STRING;
3308 }
3309
3310 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
3311 {
3312     return CanGetValueAs(row, col, typeName);
3313 }
3314
3315 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
3316 {
3317     return 0;
3318 }
3319
3320 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
3321 {
3322     return 0.0;
3323 }
3324
3325 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
3326 {
3327     return false;
3328 }
3329
3330 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
3331                                       long WXUNUSED(value) )
3332 {
3333 }
3334
3335 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
3336                                         double WXUNUSED(value) )
3337 {
3338 }
3339
3340 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
3341                                       bool WXUNUSED(value) )
3342 {
3343 }
3344
3345 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3346                                          const wxString& WXUNUSED(typeName) )
3347 {
3348     return NULL;
3349 }
3350
3351 void  wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
3352                                          const wxString& WXUNUSED(typeName),
3353                                          void* WXUNUSED(value) )
3354 {
3355 }
3356
3357 //////////////////////////////////////////////////////////////////////
3358 //
3359 // Message class for the grid table to send requests and notifications
3360 // to the grid view
3361 //
3362
3363 wxGridTableMessage::wxGridTableMessage()
3364 {
3365     m_table = (wxGridTableBase *) NULL;
3366     m_id = -1;
3367     m_comInt1 = -1;
3368     m_comInt2 = -1;
3369 }
3370
3371 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
3372                                         int commandInt1, int commandInt2 )
3373 {
3374     m_table = table;
3375     m_id = id;
3376     m_comInt1 = commandInt1;
3377     m_comInt2 = commandInt2;
3378 }
3379
3380 //////////////////////////////////////////////////////////////////////
3381 //
3382 // A basic grid table for string data. An object of this class will
3383 // created by wxGrid if you don't specify an alternative table class.
3384 //
3385
3386 WX_DEFINE_OBJARRAY(wxGridStringArray)
3387
3388 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
3389
3390 wxGridStringTable::wxGridStringTable()
3391         : wxGridTableBase()
3392 {
3393 }
3394
3395 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
3396         : wxGridTableBase()
3397 {
3398     m_data.Alloc( numRows );
3399
3400     wxArrayString sa;
3401     sa.Alloc( numCols );
3402     sa.Add( wxEmptyString, numCols );
3403
3404     m_data.Add( sa, numRows );
3405 }
3406
3407 wxGridStringTable::~wxGridStringTable()
3408 {
3409 }
3410
3411 int wxGridStringTable::GetNumberRows()
3412 {
3413     return m_data.GetCount();
3414 }
3415
3416 int wxGridStringTable::GetNumberCols()
3417 {
3418     if ( m_data.GetCount() > 0 )
3419         return m_data[0].GetCount();
3420     else
3421         return 0;
3422 }
3423
3424 wxString wxGridStringTable::GetValue( int row, int col )
3425 {
3426     wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3427                  wxEmptyString,
3428                  _T("invalid row or column index in wxGridStringTable") );
3429
3430     return m_data[row][col];
3431 }
3432
3433 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
3434 {
3435     wxCHECK_RET( (row < GetNumberRows()) && (col < GetNumberCols()),
3436                  _T("invalid row or column index in wxGridStringTable") );
3437
3438     m_data[row][col] = value;
3439 }
3440
3441 bool wxGridStringTable::IsEmptyCell( int row, int col )
3442 {
3443     wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
3444                  true,
3445                   _T("invalid row or column index in wxGridStringTable") );
3446
3447     return (m_data[row][col] == wxEmptyString);
3448 }
3449
3450 void wxGridStringTable::Clear()
3451 {
3452     int row, col;
3453     int numRows, numCols;
3454
3455     numRows = m_data.GetCount();
3456     if ( numRows > 0 )
3457     {
3458         numCols = m_data[0].GetCount();
3459
3460         for ( row = 0; row < numRows; row++ )
3461         {
3462             for ( col = 0; col < numCols; col++ )
3463             {
3464                 m_data[row][col] = wxEmptyString;
3465             }
3466         }
3467     }
3468 }
3469
3470 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
3471 {
3472     size_t curNumRows = m_data.GetCount();
3473     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3474                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3475
3476     if ( pos >= curNumRows )
3477     {
3478         return AppendRows( numRows );
3479     }
3480
3481     wxArrayString sa;
3482     sa.Alloc( curNumCols );
3483     sa.Add( wxEmptyString, curNumCols );
3484     m_data.Insert( sa, pos, numRows );
3485
3486     if ( GetView() )
3487     {
3488         wxGridTableMessage msg( this,
3489                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
3490                                 pos,
3491                                 numRows );
3492
3493         GetView()->ProcessTableMessage( msg );
3494     }
3495
3496     return true;
3497 }
3498
3499 bool wxGridStringTable::AppendRows( size_t numRows )
3500 {
3501     size_t curNumRows = m_data.GetCount();
3502     size_t curNumCols = ( curNumRows > 0
3503                          ? m_data[0].GetCount()
3504                          : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3505
3506     wxArrayString sa;
3507     if ( curNumCols > 0 )
3508     {
3509         sa.Alloc( curNumCols );
3510         sa.Add( wxEmptyString, curNumCols );
3511     }
3512
3513     m_data.Add( sa, numRows );
3514
3515     if ( GetView() )
3516     {
3517         wxGridTableMessage msg( this,
3518                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
3519                                 numRows );
3520
3521         GetView()->ProcessTableMessage( msg );
3522     }
3523
3524     return true;
3525 }
3526
3527 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
3528 {
3529     size_t curNumRows = m_data.GetCount();
3530
3531     if ( pos >= curNumRows )
3532     {
3533         wxFAIL_MSG( wxString::Format
3534                     (
3535                         wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3536                         (unsigned long)pos,
3537                         (unsigned long)numRows,
3538                         (unsigned long)curNumRows
3539                     ) );
3540
3541         return false;
3542     }
3543
3544     if ( numRows > curNumRows - pos )
3545     {
3546         numRows = curNumRows - pos;
3547     }
3548
3549     if ( numRows >= curNumRows )
3550     {
3551         m_data.Clear();
3552     }
3553     else
3554     {
3555         m_data.RemoveAt( pos, numRows );
3556     }
3557
3558     if ( GetView() )
3559     {
3560         wxGridTableMessage msg( this,
3561                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
3562                                 pos,
3563                                 numRows );
3564
3565         GetView()->ProcessTableMessage( msg );
3566     }
3567
3568     return true;
3569 }
3570
3571 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
3572 {
3573     size_t row, col;
3574
3575     size_t curNumRows = m_data.GetCount();
3576     size_t curNumCols = ( curNumRows > 0
3577                          ? m_data[0].GetCount()
3578                          : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3579
3580     if ( pos >= curNumCols )
3581     {
3582         return AppendCols( numCols );
3583     }
3584
3585     if ( !m_colLabels.IsEmpty() )
3586     {
3587         m_colLabels.Insert( wxEmptyString, pos, numCols );
3588
3589         size_t i;
3590         for ( i = pos; i < pos + numCols; i++ )
3591             m_colLabels[i] = wxGridTableBase::GetColLabelValue( i );
3592     }
3593
3594     for ( row = 0; row < curNumRows; row++ )
3595     {
3596         for ( col = pos; col < pos + numCols; col++ )
3597         {
3598             m_data[row].Insert( wxEmptyString, col );
3599         }
3600     }
3601
3602     if ( GetView() )
3603     {
3604         wxGridTableMessage msg( this,
3605                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
3606                                 pos,
3607                                 numCols );
3608
3609         GetView()->ProcessTableMessage( msg );
3610     }
3611
3612     return true;
3613 }
3614
3615 bool wxGridStringTable::AppendCols( size_t numCols )
3616 {
3617     size_t row;
3618
3619     size_t curNumRows = m_data.GetCount();
3620
3621 #if 0
3622     if ( !curNumRows )
3623     {
3624         // TODO: something better than this ?
3625         //
3626         wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3627         return false;
3628     }
3629 #endif
3630
3631     for ( row = 0; row < curNumRows; row++ )
3632     {
3633         m_data[row].Add( wxEmptyString, numCols );
3634     }
3635
3636     if ( GetView() )
3637     {
3638         wxGridTableMessage msg( this,
3639                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
3640                                 numCols );
3641
3642         GetView()->ProcessTableMessage( msg );
3643     }
3644
3645     return true;
3646 }
3647
3648 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
3649 {
3650     size_t row;
3651
3652     size_t curNumRows = m_data.GetCount();
3653     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
3654                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3655
3656     if ( pos >= curNumCols )
3657     {
3658         wxFAIL_MSG( wxString::Format
3659                     (
3660                         wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3661                         (unsigned long)pos,
3662                         (unsigned long)numCols,
3663                         (unsigned long)curNumCols
3664                     ) );
3665         return false;
3666     }
3667
3668     int colID;
3669     if ( GetView() )
3670         colID = GetView()->GetColAt( pos );
3671     else
3672         colID = pos;
3673
3674     if ( numCols > curNumCols - colID )
3675     {
3676         numCols = curNumCols - colID;
3677     }
3678
3679     if ( !m_colLabels.IsEmpty() )
3680     {
3681         // m_colLabels stores just as many elements as it needs, e.g. if only
3682         // the label of the first column had been set it would have only one
3683         // element and not numCols, so account for it
3684         int nToRm = m_colLabels.size() - colID;
3685         if ( nToRm > 0 )
3686             m_colLabels.RemoveAt( colID, nToRm );
3687     }
3688
3689     for ( row = 0; row < curNumRows; row++ )
3690     {
3691         if ( numCols >= curNumCols )
3692         {
3693             m_data[row].Clear();
3694         }
3695         else
3696         {
3697             m_data[row].RemoveAt( colID, numCols );
3698         }
3699     }
3700
3701     if ( GetView() )
3702     {
3703         wxGridTableMessage msg( this,
3704                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
3705                                 pos,
3706                                 numCols );
3707
3708         GetView()->ProcessTableMessage( msg );
3709     }
3710
3711     return true;
3712 }
3713
3714 wxString wxGridStringTable::GetRowLabelValue( int row )
3715 {
3716     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3717     {
3718         // using default label
3719         //
3720         return wxGridTableBase::GetRowLabelValue( row );
3721     }
3722     else
3723     {
3724         return m_rowLabels[row];
3725     }
3726 }
3727
3728 wxString wxGridStringTable::GetColLabelValue( int col )
3729 {
3730     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3731     {
3732         // using default label
3733         //
3734         return wxGridTableBase::GetColLabelValue( col );
3735     }
3736     else
3737     {
3738         return m_colLabels[col];
3739     }
3740 }
3741
3742 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3743 {
3744     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3745     {
3746         int n = m_rowLabels.GetCount();
3747         int i;
3748
3749         for ( i = n; i <= row; i++ )
3750         {
3751             m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3752         }
3753     }
3754
3755     m_rowLabels[row] = value;
3756 }
3757
3758 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3759 {
3760     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3761     {
3762         int n = m_colLabels.GetCount();
3763         int i;
3764
3765         for ( i = n; i <= col; i++ )
3766         {
3767             m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3768         }
3769     }
3770
3771     m_colLabels[col] = value;
3772 }
3773
3774
3775 //////////////////////////////////////////////////////////////////////
3776 //////////////////////////////////////////////////////////////////////
3777
3778 BEGIN_EVENT_TABLE(wxGridSubwindow, wxWindow)
3779     EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost)
3780 END_EVENT_TABLE()
3781
3782 void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
3783 {
3784     m_owner->CancelMouseCapture();
3785 }
3786
3787 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3788
3789 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxGridSubwindow )
3790     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3791     EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel )
3792     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3793     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3794     EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3795     EVT_CHAR( wxGridRowLabelWindow::OnChar )
3796 END_EVENT_TABLE()
3797
3798 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3799                                             wxWindowID id,
3800                                             const wxPoint &pos, const wxSize &size )
3801   : wxGridSubwindow(parent, id, pos, size)
3802 {
3803     m_owner = parent;
3804 }
3805
3806 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3807 {
3808     wxPaintDC dc(this);
3809
3810     // NO - don't do this because it will set both the x and y origin
3811     // coords to match the parent scrolled window and we just want to
3812     // set the y coord  - MB
3813     //
3814     // m_owner->PrepareDC( dc );
3815
3816     int x, y;
3817     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3818     wxPoint pt = dc.GetDeviceOrigin();
3819     dc.SetDeviceOrigin( pt.x, pt.y-y );
3820
3821     wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3822     m_owner->DrawRowLabels( dc, rows );
3823 }
3824
3825 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3826 {
3827     m_owner->ProcessRowLabelMouseEvent( event );
3828 }
3829
3830 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
3831 {
3832     m_owner->GetEventHandler()->ProcessEvent( event );
3833 }
3834
3835 // This seems to be required for wxMotif otherwise the mouse
3836 // cursor must be in the cell edit control to get key events
3837 //
3838 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3839 {
3840     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3841         event.Skip();
3842 }
3843
3844 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3845 {
3846     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3847         event.Skip();
3848 }
3849
3850 void wxGridRowLabelWindow::OnChar( wxKeyEvent& event )
3851 {
3852     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3853         event.Skip();
3854 }
3855
3856 //////////////////////////////////////////////////////////////////////
3857
3858 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3859
3860 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxGridSubwindow )
3861     EVT_PAINT( wxGridColLabelWindow::OnPaint )
3862     EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel )
3863     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3864     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3865     EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3866     EVT_CHAR( wxGridColLabelWindow::OnChar )
3867 END_EVENT_TABLE()
3868
3869 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3870                                             wxWindowID id,
3871                                             const wxPoint &pos, const wxSize &size )
3872   : wxGridSubwindow(parent, id, pos, size)
3873 {
3874     m_owner = parent;
3875 }
3876
3877 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3878 {
3879     wxPaintDC dc(this);
3880
3881     // NO - don't do this because it will set both the x and y origin
3882     // coords to match the parent scrolled window and we just want to
3883     // set the x coord  - MB
3884     //
3885     // m_owner->PrepareDC( dc );
3886
3887     int x, y;
3888     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3889     wxPoint pt = dc.GetDeviceOrigin();
3890     if (GetLayoutDirection() == wxLayout_RightToLeft)
3891         dc.SetDeviceOrigin( pt.x+x, pt.y );
3892     else
3893         dc.SetDeviceOrigin( pt.x-x, pt.y );
3894
3895     wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3896     m_owner->DrawColLabels( dc, cols );
3897 }
3898
3899 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3900 {
3901     m_owner->ProcessColLabelMouseEvent( event );
3902 }
3903
3904 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
3905 {
3906     m_owner->GetEventHandler()->ProcessEvent( event );
3907 }
3908
3909 // This seems to be required for wxMotif otherwise the mouse
3910 // cursor must be in the cell edit control to get key events
3911 //
3912 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3913 {
3914     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3915         event.Skip();
3916 }
3917
3918 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3919 {
3920     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3921         event.Skip();
3922 }
3923
3924 void wxGridColLabelWindow::OnChar( wxKeyEvent& event )
3925 {
3926     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3927         event.Skip();
3928 }
3929
3930 //////////////////////////////////////////////////////////////////////
3931
3932 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3933
3934 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxGridSubwindow )
3935     EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel )
3936     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3937     EVT_PAINT( wxGridCornerLabelWindow::OnPaint )
3938     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3939     EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3940     EVT_CHAR( wxGridCornerLabelWindow::OnChar )
3941 END_EVENT_TABLE()
3942
3943 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3944                                                   wxWindowID id,
3945                                                   const wxPoint &pos, const wxSize &size )
3946   : wxGridSubwindow(parent, id, pos, size)
3947 {
3948     m_owner = parent;
3949 }
3950
3951 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3952 {
3953     wxPaintDC dc(this);
3954
3955     int client_height = 0;
3956     int client_width = 0;
3957     GetClientSize( &client_width, &client_height );
3958
3959     // VZ: any reason for this ifdef? (FIXME)
3960 #if 0
3961 def __WXGTK__
3962     wxRect rect;
3963     rect.SetX( 1 );
3964     rect.SetY( 1 );
3965     rect.SetWidth( client_width - 2 );
3966     rect.SetHeight( client_height - 2 );
3967
3968     wxRendererNative::Get().DrawHeaderButton( this, dc, rect, 0 );
3969 #else // !__WXGTK__
3970     dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID) );
3971     dc.DrawLine( client_width - 1, client_height - 1, client_width - 1, 0 );
3972     dc.DrawLine( client_width - 1, client_height - 1, 0, client_height - 1 );
3973     dc.DrawLine( 0, 0, client_width, 0 );
3974     dc.DrawLine( 0, 0, 0, client_height );
3975
3976     dc.SetPen( *wxWHITE_PEN );
3977     dc.DrawLine( 1, 1, client_width - 1, 1 );
3978     dc.DrawLine( 1, 1, 1, client_height - 1 );
3979 #endif
3980 }
3981
3982 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3983 {
3984     m_owner->ProcessCornerLabelMouseEvent( event );
3985 }
3986
3987 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
3988 {
3989     m_owner->GetEventHandler()->ProcessEvent(event);
3990 }
3991
3992 // This seems to be required for wxMotif otherwise the mouse
3993 // cursor must be in the cell edit control to get key events
3994 //
3995 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3996 {
3997     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
3998         event.Skip();
3999 }
4000
4001 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
4002 {
4003     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4004         event.Skip();
4005 }
4006
4007 void wxGridCornerLabelWindow::OnChar( wxKeyEvent& event )
4008 {
4009     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4010         event.Skip();
4011 }
4012
4013 //////////////////////////////////////////////////////////////////////
4014
4015 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxWindow )
4016
4017 BEGIN_EVENT_TABLE( wxGridWindow, wxGridSubwindow )
4018     EVT_PAINT( wxGridWindow::OnPaint )
4019     EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel )
4020     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
4021     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
4022     EVT_KEY_UP( wxGridWindow::OnKeyUp )
4023     EVT_CHAR( wxGridWindow::OnChar )
4024     EVT_SET_FOCUS( wxGridWindow::OnFocus )
4025     EVT_KILL_FOCUS( wxGridWindow::OnFocus )
4026     EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
4027 END_EVENT_TABLE()
4028
4029 wxGridWindow::wxGridWindow( wxGrid *parent,
4030                             wxGridRowLabelWindow *rowLblWin,
4031                             wxGridColLabelWindow *colLblWin,
4032                             wxWindowID id,
4033                             const wxPoint &pos,
4034                             const wxSize &size )
4035             : wxGridSubwindow(parent, id, pos, size,
4036                               wxCLIP_CHILDREN, wxT("grid window") )
4037 {
4038     m_owner = parent;
4039     m_rowLabelWin = rowLblWin;
4040     m_colLabelWin = colLblWin;
4041 }
4042
4043 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
4044 {
4045     wxPaintDC dc( this );
4046     m_owner->PrepareDC( dc );
4047     wxRegion reg = GetUpdateRegion();
4048     wxGridCellCoordsArray dirtyCells = m_owner->CalcCellsExposed( reg );
4049     m_owner->DrawGridCellArea( dc, dirtyCells );
4050
4051 #if WXGRID_DRAW_LINES
4052     m_owner->DrawAllGridLines( dc, reg );
4053 #endif
4054
4055     m_owner->DrawGridSpace( dc );
4056     m_owner->DrawHighlight( dc, dirtyCells );
4057 }
4058
4059 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
4060 {
4061     wxWindow::ScrollWindow( dx, dy, rect );
4062     m_rowLabelWin->ScrollWindow( 0, dy, rect );
4063     m_colLabelWin->ScrollWindow( dx, 0, rect );
4064 }
4065
4066 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
4067 {
4068     if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
4069         SetFocus();
4070
4071     m_owner->ProcessGridCellMouseEvent( event );
4072 }
4073
4074 void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
4075 {
4076     m_owner->GetEventHandler()->ProcessEvent( event );
4077 }
4078
4079 // This seems to be required for wxMotif/wxGTK otherwise the mouse
4080 // cursor must be in the cell edit control to get key events
4081 //
4082 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
4083 {
4084     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4085         event.Skip();
4086 }
4087
4088 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
4089 {
4090     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4091         event.Skip();
4092 }
4093
4094 void wxGridWindow::OnChar( wxKeyEvent& event )
4095 {
4096     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4097         event.Skip();
4098 }
4099
4100 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
4101 {
4102 }
4103
4104 void wxGridWindow::OnFocus(wxFocusEvent& event)
4105 {
4106     if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
4107         event.Skip();
4108 }
4109
4110 //////////////////////////////////////////////////////////////////////
4111
4112 // Internal Helper function for computing row or column from some
4113 // (unscrolled) coordinate value, using either
4114 // m_defaultRowHeight/m_defaultColWidth or binary search on array
4115 // of m_rowBottoms/m_ColRights to speed up the search!
4116
4117 // Internal helper macros for simpler use of that function
4118
4119 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
4120                            const wxArrayInt& BorderArray, int nMax,
4121                            bool clipToMinMax);
4122
4123 #define internalXToCol(x) XToCol(x, true)
4124 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
4125                                           m_minAcceptableRowHeight, \
4126                                           m_rowBottoms, m_numRows, true)
4127
4128 /////////////////////////////////////////////////////////////////////
4129
4130 #if wxUSE_EXTENDED_RTTI
4131 WX_DEFINE_FLAGS( wxGridStyle )
4132
4133 wxBEGIN_FLAGS( wxGridStyle )
4134     // new style border flags, we put them first to
4135     // use them for streaming out
4136     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
4137     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
4138     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
4139     wxFLAGS_MEMBER(wxBORDER_RAISED)
4140     wxFLAGS_MEMBER(wxBORDER_STATIC)
4141     wxFLAGS_MEMBER(wxBORDER_NONE)
4142
4143     // old style border flags
4144     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
4145     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
4146     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
4147     wxFLAGS_MEMBER(wxRAISED_BORDER)
4148     wxFLAGS_MEMBER(wxSTATIC_BORDER)
4149     wxFLAGS_MEMBER(wxBORDER)
4150
4151     // standard window styles
4152     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
4153     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
4154     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
4155     wxFLAGS_MEMBER(wxWANTS_CHARS)
4156     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
4157     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB)
4158     wxFLAGS_MEMBER(wxVSCROLL)
4159     wxFLAGS_MEMBER(wxHSCROLL)
4160
4161 wxEND_FLAGS( wxGridStyle )
4162
4163 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow,"wx/grid.h")
4164
4165 wxBEGIN_PROPERTIES_TABLE(wxGrid)
4166     wxHIDE_PROPERTY( Children )
4167     wxPROPERTY_FLAGS( WindowStyle , wxGridStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
4168 wxEND_PROPERTIES_TABLE()
4169
4170 wxBEGIN_HANDLERS_TABLE(wxGrid)
4171 wxEND_HANDLERS_TABLE()
4172
4173 wxCONSTRUCTOR_5( wxGrid , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
4174
4175 /*
4176  TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
4177 */
4178 #else
4179 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
4180 #endif
4181
4182 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
4183     EVT_PAINT( wxGrid::OnPaint )
4184     EVT_SIZE( wxGrid::OnSize )
4185     EVT_KEY_DOWN( wxGrid::OnKeyDown )
4186     EVT_KEY_UP( wxGrid::OnKeyUp )
4187     EVT_CHAR ( wxGrid::OnChar )
4188     EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
4189 END_EVENT_TABLE()
4190
4191 wxGrid::wxGrid()
4192 {
4193     // in order to make sure that a size event is not
4194     // trigerred in a unfinished state
4195     m_cornerLabelWin = NULL;
4196     m_rowLabelWin = NULL;
4197     m_colLabelWin = NULL;
4198     m_gridWin = NULL;
4199 }
4200
4201 wxGrid::wxGrid( wxWindow *parent,
4202                  wxWindowID id,
4203                  const wxPoint& pos,
4204                  const wxSize& size,
4205                  long style,
4206                  const wxString& name )
4207   : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
4208     m_colMinWidths(GRID_HASH_SIZE),
4209     m_rowMinHeights(GRID_HASH_SIZE)
4210 {
4211     Create();
4212     SetInitialSize(size);
4213 }
4214
4215 bool wxGrid::Create(wxWindow *parent, wxWindowID id,
4216                           const wxPoint& pos, const wxSize& size,
4217                           long style, const wxString& name)
4218 {
4219     if (!wxScrolledWindow::Create(parent, id, pos, size,
4220                                   style | wxWANTS_CHARS, name))
4221         return false;
4222
4223     m_colMinWidths = wxLongToLongHashMap(GRID_HASH_SIZE);
4224     m_rowMinHeights = wxLongToLongHashMap(GRID_HASH_SIZE);
4225
4226     Create();
4227     SetInitialSize(size);
4228     CalcDimensions();
4229
4230     return true;
4231 }
4232
4233 wxGrid::~wxGrid()
4234 {
4235     // Must do this or ~wxScrollHelper will pop the wrong event handler
4236     SetTargetWindow(this);
4237     ClearAttrCache();
4238     wxSafeDecRef(m_defaultCellAttr);
4239
4240 #ifdef DEBUG_ATTR_CACHE
4241     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
4242     wxPrintf(_T("wxGrid attribute cache statistics: "
4243                 "total: %u, hits: %u (%u%%)\n"),
4244              total, gs_nAttrCacheHits,
4245              total ? (gs_nAttrCacheHits*100) / total : 0);
4246 #endif
4247
4248     // if we own the table, just delete it, otherwise at least don't leave it
4249     // with dangling view pointer
4250     if ( m_ownTable )
4251         delete m_table;
4252     else if ( m_table && m_table->GetView() == this )
4253         m_table->SetView(NULL);
4254
4255     delete m_typeRegistry;
4256     delete m_selection;
4257 }
4258
4259 //
4260 // ----- internal init and update functions
4261 //
4262
4263 // NOTE: If using the default visual attributes works everywhere then this can
4264 // be removed as well as the #else cases below.
4265 #define _USE_VISATTR 0
4266
4267 void wxGrid::Create()
4268 {
4269     // set to true by CreateGrid
4270     m_created = false;
4271
4272     // create the type registry
4273     m_typeRegistry = new wxGridTypeRegistry;
4274     m_selection = NULL;
4275
4276     m_table = (wxGridTableBase *) NULL;
4277     m_ownTable = false;
4278
4279     m_cellEditCtrlEnabled = false;
4280
4281     m_defaultCellAttr = new wxGridCellAttr();
4282
4283     // Set default cell attributes
4284     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
4285     m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
4286     m_defaultCellAttr->SetFont(GetFont());
4287     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
4288     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
4289     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
4290
4291 #if _USE_VISATTR
4292     wxVisualAttributes gva = wxListBox::GetClassDefaultAttributes();
4293     wxVisualAttributes lva = wxPanel::GetClassDefaultAttributes();
4294
4295     m_defaultCellAttr->SetTextColour(gva.colFg);
4296     m_defaultCellAttr->SetBackgroundColour(gva.colBg);
4297
4298 #else
4299     m_defaultCellAttr->SetTextColour(
4300         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
4301     m_defaultCellAttr->SetBackgroundColour(
4302         wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
4303 #endif
4304
4305     m_numRows = 0;
4306     m_numCols = 0;
4307     m_currentCellCoords = wxGridNoCellCoords;
4308
4309     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
4310     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
4311
4312     // subwindow components that make up the wxGrid
4313     m_rowLabelWin = new wxGridRowLabelWindow( this,
4314                                               wxID_ANY,
4315                                               wxDefaultPosition,
4316                                               wxDefaultSize );
4317
4318     m_colLabelWin = new wxGridColLabelWindow( this,
4319                                               wxID_ANY,
4320                                               wxDefaultPosition,
4321                                               wxDefaultSize );
4322
4323     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
4324                                                     wxID_ANY,
4325                                                     wxDefaultPosition,
4326                                                     wxDefaultSize );
4327
4328     m_gridWin = new wxGridWindow( this,
4329                                   m_rowLabelWin,
4330                                   m_colLabelWin,
4331                                   wxID_ANY,
4332                                   wxDefaultPosition,
4333                                   wxDefaultSize );
4334
4335     SetTargetWindow( m_gridWin );
4336
4337 #if _USE_VISATTR
4338     wxColour gfg = gva.colFg;
4339     wxColour gbg = gva.colBg;
4340     wxColour lfg = lva.colFg;
4341     wxColour lbg = lva.colBg;
4342 #else
4343     wxColour gfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
4344     wxColour gbg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
4345     wxColour lfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
4346     wxColour lbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
4347 #endif
4348
4349     m_cornerLabelWin->SetOwnForegroundColour(lfg);
4350     m_cornerLabelWin->SetOwnBackgroundColour(lbg);
4351     m_rowLabelWin->SetOwnForegroundColour(lfg);
4352     m_rowLabelWin->SetOwnBackgroundColour(lbg);
4353     m_colLabelWin->SetOwnForegroundColour(lfg);
4354     m_colLabelWin->SetOwnBackgroundColour(lbg);
4355
4356     m_gridWin->SetOwnForegroundColour(gfg);
4357     m_gridWin->SetOwnBackgroundColour(gbg);
4358
4359     Init();
4360 }
4361
4362 bool wxGrid::CreateGrid( int numRows, int numCols,
4363                          wxGrid::wxGridSelectionModes selmode )
4364 {
4365     wxCHECK_MSG( !m_created,
4366                  false,
4367                  wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
4368
4369     m_numRows = numRows;
4370     m_numCols = numCols;
4371
4372     m_table = new wxGridStringTable( m_numRows, m_numCols );
4373     m_table->SetView( this );
4374     m_ownTable = true;
4375     m_selection = new wxGridSelection( this, selmode );
4376
4377     CalcDimensions();
4378
4379     m_created = true;
4380
4381     return m_created;
4382 }
4383
4384 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
4385 {
4386     wxCHECK_RET( m_created,
4387                  wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
4388
4389     m_selection->SetSelectionMode( selmode );
4390 }
4391
4392 wxGrid::wxGridSelectionModes wxGrid::GetSelectionMode() const
4393 {
4394     wxCHECK_MSG( m_created, wxGrid::wxGridSelectCells,
4395                  wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
4396
4397     return m_selection->GetSelectionMode();
4398 }
4399
4400 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
4401                        wxGrid::wxGridSelectionModes selmode )
4402 {
4403     bool checkSelection = false;
4404     if ( m_created )
4405     {
4406         // stop all processing
4407         m_created = false;
4408
4409         if (m_table)
4410         {
4411             m_table->SetView(0);
4412             if( m_ownTable )
4413                 delete m_table;
4414             m_table = NULL;
4415         }
4416
4417         delete m_selection;
4418         m_selection = NULL;
4419
4420         m_ownTable = false;
4421         m_numRows = 0;
4422         m_numCols = 0;
4423         checkSelection = true;
4424
4425         // kill row and column size arrays
4426         m_colWidths.Empty();
4427         m_colRights.Empty();
4428         m_rowHeights.Empty();
4429         m_rowBottoms.Empty();
4430     }
4431
4432     if (table)
4433     {
4434         m_numRows = table->GetNumberRows();
4435         m_numCols = table->GetNumberCols();
4436
4437         m_table = table;
4438         m_table->SetView( this );
4439         m_ownTable = takeOwnership;
4440         m_selection = new wxGridSelection( this, selmode );
4441         if (checkSelection)
4442         {
4443             // If the newly set table is smaller than the
4444             // original one current cell and selection regions
4445             // might be invalid,
4446             m_selectingKeyboard = wxGridNoCellCoords;
4447             m_currentCellCoords =
4448               wxGridCellCoords(wxMin(m_numRows, m_currentCellCoords.GetRow()),
4449                                wxMin(m_numCols, m_currentCellCoords.GetCol()));
4450             if (m_selectingTopLeft.GetRow() >= m_numRows ||
4451                 m_selectingTopLeft.GetCol() >= m_numCols)
4452             {
4453                 m_selectingTopLeft = wxGridNoCellCoords;
4454                 m_selectingBottomRight = wxGridNoCellCoords;
4455             }
4456             else
4457                 m_selectingBottomRight =
4458                   wxGridCellCoords(wxMin(m_numRows,
4459                                          m_selectingBottomRight.GetRow()),
4460                                    wxMin(m_numCols,
4461                                          m_selectingBottomRight.GetCol()));
4462         }
4463         CalcDimensions();
4464
4465         m_created = true;
4466     }
4467
4468     return m_created;
4469 }
4470
4471 void wxGrid::Init()
4472 {
4473     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
4474     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
4475
4476     if ( m_rowLabelWin )
4477     {
4478         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
4479     }
4480     else
4481     {
4482         m_labelBackgroundColour = *wxWHITE;
4483     }
4484
4485     m_labelTextColour = *wxBLACK;
4486
4487     // init attr cache
4488     m_attrCache.row = -1;
4489     m_attrCache.col = -1;
4490     m_attrCache.attr = NULL;
4491
4492     // TODO: something better than this ?
4493     //
4494     m_labelFont = this->GetFont();
4495     m_labelFont.SetWeight( wxBOLD );
4496
4497     m_rowLabelHorizAlign = wxALIGN_CENTRE;
4498     m_rowLabelVertAlign  = wxALIGN_CENTRE;
4499
4500     m_colLabelHorizAlign = wxALIGN_CENTRE;
4501     m_colLabelVertAlign  = wxALIGN_CENTRE;
4502     m_colLabelTextOrientation = wxHORIZONTAL;
4503
4504     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
4505     m_defaultRowHeight = m_gridWin->GetCharHeight();
4506
4507     m_minAcceptableColWidth  = WXGRID_MIN_COL_WIDTH;
4508     m_minAcceptableRowHeight = WXGRID_MIN_ROW_HEIGHT;
4509
4510 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
4511     m_defaultRowHeight += 8;
4512 #else
4513     m_defaultRowHeight += 4;
4514 #endif
4515
4516     m_gridLineColour = wxColour( 192,192,192 );
4517     m_gridLinesEnabled = true;
4518     m_cellHighlightColour = *wxBLACK;
4519     m_cellHighlightPenWidth = 2;
4520     m_cellHighlightROPenWidth = 1;
4521
4522     m_canDragColMove = false;
4523
4524     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
4525     m_winCapture = (wxWindow *)NULL;
4526     m_canDragRowSize = true;
4527     m_canDragColSize = true;
4528     m_canDragGridSize = true;
4529     m_canDragCell = false;
4530     m_dragLastPos  = -1;
4531     m_dragRowOrCol = -1;
4532     m_isDragging = false;
4533     m_startDragPos = wxDefaultPosition;
4534
4535     m_waitForSlowClick = false;
4536
4537     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
4538     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
4539
4540     m_currentCellCoords = wxGridNoCellCoords;
4541
4542     ClearSelection();
4543
4544     m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
4545     m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
4546
4547     m_editable = true;  // default for whole grid
4548
4549     m_inOnKeyDown = false;
4550     m_batchCount = 0;
4551
4552     m_extraWidth =
4553     m_extraHeight = 0;
4554
4555     m_scrollLineX = GRID_SCROLL_LINE_X;
4556     m_scrollLineY = GRID_SCROLL_LINE_Y;
4557 }
4558
4559 // ----------------------------------------------------------------------------
4560 // the idea is to call these functions only when necessary because they create
4561 // quite big arrays which eat memory mostly unnecessary - in particular, if
4562 // default widths/heights are used for all rows/columns, we may not use these
4563 // arrays at all
4564 //
4565 // with some extra code, it should be possible to only store the widths/heights
4566 // different from default ones (resulting in space savings for huge grids) but
4567 // this is not done currently
4568 // ----------------------------------------------------------------------------
4569
4570 void wxGrid::InitRowHeights()
4571 {
4572     m_rowHeights.Empty();
4573     m_rowBottoms.Empty();
4574
4575     m_rowHeights.Alloc( m_numRows );
4576     m_rowBottoms.Alloc( m_numRows );
4577
4578     m_rowHeights.Add( m_defaultRowHeight, m_numRows );
4579
4580     int rowBottom = 0;
4581     for ( int i = 0; i < m_numRows; i++ )
4582     {
4583         rowBottom += m_defaultRowHeight;
4584         m_rowBottoms.Add( rowBottom );
4585     }
4586 }
4587
4588 void wxGrid::InitColWidths()
4589 {
4590     m_colWidths.Empty();
4591     m_colRights.Empty();
4592
4593     m_colWidths.Alloc( m_numCols );
4594     m_colRights.Alloc( m_numCols );
4595
4596     m_colWidths.Add( m_defaultColWidth, m_numCols );
4597
4598     int colRight = 0;
4599     for ( int i = 0; i < m_numCols; i++ )
4600     {
4601         colRight = ( GetColPos( i ) + 1 ) * m_defaultColWidth;
4602         m_colRights.Add( colRight );
4603     }
4604 }
4605
4606 int wxGrid::GetColWidth(int col) const
4607 {
4608     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
4609 }
4610
4611 int wxGrid::GetColLeft(int col) const
4612 {
4613     return m_colRights.IsEmpty() ? GetColPos( col ) * m_defaultColWidth
4614                                  : m_colRights[col] - m_colWidths[col];
4615 }
4616
4617 int wxGrid::GetColRight(int col) const
4618 {
4619     return m_colRights.IsEmpty() ? (GetColPos( col ) + 1) * m_defaultColWidth
4620                                  : m_colRights[col];
4621 }
4622
4623 int wxGrid::GetRowHeight(int row) const
4624 {
4625     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
4626 }
4627
4628 int wxGrid::GetRowTop(int row) const
4629 {
4630     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
4631                                   : m_rowBottoms[row] - m_rowHeights[row];
4632 }
4633
4634 int wxGrid::GetRowBottom(int row) const
4635 {
4636     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
4637                                   : m_rowBottoms[row];
4638 }
4639
4640 void wxGrid::CalcDimensions()
4641 {
4642     // compute the size of the scrollable area
4643     int w = m_numCols > 0 ? GetColRight(GetColAt(m_numCols - 1)) : 0;
4644     int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
4645
4646     w += m_extraWidth;
4647     h += m_extraHeight;
4648
4649     // take into account editor if shown
4650     if ( IsCellEditControlShown() )
4651     {
4652         int w2, h2;
4653         int r = m_currentCellCoords.GetRow();
4654         int c = m_currentCellCoords.GetCol();
4655         int x = GetColLeft(c);
4656         int y = GetRowTop(r);
4657
4658         // how big is the editor
4659         wxGridCellAttr* attr = GetCellAttr(r, c);
4660         wxGridCellEditor* editor = attr->GetEditor(this, r, c);
4661         editor->GetControl()->GetSize(&w2, &h2);
4662         w2 += x;
4663         h2 += y;
4664         if ( w2 > w )
4665             w = w2;
4666         if ( h2 > h )
4667             h = h2;
4668         editor->DecRef();
4669         attr->DecRef();
4670     }
4671
4672     // preserve (more or less) the previous position
4673     int x, y;
4674     GetViewStart( &x, &y );
4675
4676     // ensure the position is valid for the new scroll ranges
4677     if ( x >= w )
4678         x = wxMax( w - 1, 0 );
4679     if ( y >= h )
4680         y = wxMax( h - 1, 0 );
4681
4682     // do set scrollbar parameters
4683     SetScrollbars( m_scrollLineX, m_scrollLineY,
4684                    GetScrollX(w), GetScrollY(h),
4685                    x, y,
4686                    GetBatchCount() != 0);
4687
4688     // if our OnSize() hadn't been called (it would if we have scrollbars), we
4689     // still must reposition the children
4690     CalcWindowSizes();
4691 }
4692
4693 void wxGrid::CalcWindowSizes()
4694 {
4695     // escape if the window is has not been fully created yet
4696
4697     if ( m_cornerLabelWin == NULL )
4698         return;
4699
4700     int cw, ch;
4701     GetClientSize( &cw, &ch );
4702
4703     // this block of code tries to work around the following problem: the grid
4704     // could have been just resized to have enough space to show the full grid
4705     // window contents without the scrollbars, but its client size could be
4706     // not big enough because the grid has the scrollbars right now and so the
4707     // scrollbars would remain even though we don't need them any more
4708     //
4709     // to prevent this from happening, check if we have enough space for
4710     // everything without the scrollbars and explicitly disable them then
4711     wxSize size = GetSize() - GetWindowBorderSize();
4712     if ( size != wxSize(cw, ch) )
4713     {
4714         // check if we have enough space for grid window after accounting for
4715         // the fixed size elements
4716         size.x -= m_rowLabelWidth;
4717         size.y -= m_colLabelHeight;
4718
4719         const wxSize vsize = m_gridWin->GetVirtualSize();
4720
4721         if ( size.x >= vsize.x && size.y >= vsize.y )
4722         {
4723             // yes, we do, so remove the scrollbars and use the new client size
4724             // (which should be the same as full window size - borders now)
4725             SetScrollbars(0, 0, 0, 0);
4726             GetClientSize(&cw, &ch);
4727         }
4728     }
4729
4730     if ( m_cornerLabelWin && m_cornerLabelWin->IsShown() )
4731         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
4732
4733     if ( m_colLabelWin && m_colLabelWin->IsShown() )
4734         m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw - m_rowLabelWidth, m_colLabelHeight );
4735
4736     if ( m_rowLabelWin && m_rowLabelWin->IsShown() )
4737         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch - m_colLabelHeight );
4738
4739     if ( m_gridWin && m_gridWin->IsShown() )
4740         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw - m_rowLabelWidth, ch - m_colLabelHeight );
4741 }
4742
4743 // this is called when the grid table sends a message
4744 // to indicate that it has been redimensioned
4745 //
4746 bool wxGrid::Redimension( wxGridTableMessage& msg )
4747 {
4748     int i;
4749     bool result = false;
4750
4751     // Clear the attribute cache as the attribute might refer to a different
4752     // cell than stored in the cache after adding/removing rows/columns.
4753     ClearAttrCache();
4754
4755     // By the same reasoning, the editor should be dismissed if columns are
4756     // added or removed. And for consistency, it should IMHO always be
4757     // removed, not only if the cell "underneath" it actually changes.
4758     // For now, I intentionally do not save the editor's content as the
4759     // cell it might want to save that stuff to might no longer exist.
4760     HideCellEditControl();
4761
4762 #if 0
4763     // if we were using the default widths/heights so far, we must change them
4764     // now
4765     if ( m_colWidths.IsEmpty() )
4766     {
4767         InitColWidths();
4768     }
4769
4770     if ( m_rowHeights.IsEmpty() )
4771     {
4772         InitRowHeights();
4773     }
4774 #endif
4775
4776     switch ( msg.GetId() )
4777     {
4778         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4779         {
4780             size_t pos = msg.GetCommandInt();
4781             int numRows = msg.GetCommandInt2();
4782
4783             m_numRows += numRows;
4784
4785             if ( !m_rowHeights.IsEmpty() )
4786             {
4787                 m_rowHeights.Insert( m_defaultRowHeight, pos, numRows );
4788                 m_rowBottoms.Insert( 0, pos, numRows );
4789
4790                 int bottom = 0;
4791                 if ( pos > 0 )
4792                     bottom = m_rowBottoms[pos - 1];
4793
4794                 for ( i = pos; i < m_numRows; i++ )
4795                 {
4796                     bottom += m_rowHeights[i];
4797                     m_rowBottoms[i] = bottom;
4798                 }
4799             }
4800
4801             if ( m_currentCellCoords == wxGridNoCellCoords )
4802             {
4803                 // if we have just inserted cols into an empty grid the current
4804                 // cell will be undefined...
4805                 //
4806                 SetCurrentCell( 0, 0 );
4807             }
4808
4809             if ( m_selection )
4810                 m_selection->UpdateRows( pos, numRows );
4811             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4812             if (attrProvider)
4813                 attrProvider->UpdateAttrRows( pos, numRows );
4814
4815             if ( !GetBatchCount() )
4816             {
4817                 CalcDimensions();
4818                 m_rowLabelWin->Refresh();
4819             }
4820         }
4821         result = true;
4822         break;
4823
4824         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4825         {
4826             int numRows = msg.GetCommandInt();
4827             int oldNumRows = m_numRows;
4828             m_numRows += numRows;
4829
4830             if ( !m_rowHeights.IsEmpty() )
4831             {
4832                 m_rowHeights.Add( m_defaultRowHeight, numRows );
4833                 m_rowBottoms.Add( 0, numRows );
4834
4835                 int bottom = 0;
4836                 if ( oldNumRows > 0 )
4837                     bottom = m_rowBottoms[oldNumRows - 1];
4838
4839                 for ( i = oldNumRows; i < m_numRows; i++ )
4840                 {
4841                     bottom += m_rowHeights[i];
4842                     m_rowBottoms[i] = bottom;
4843                 }
4844             }
4845
4846             if ( m_currentCellCoords == wxGridNoCellCoords )
4847             {
4848                 // if we have just inserted cols into an empty grid the current
4849                 // cell will be undefined...
4850                 //
4851                 SetCurrentCell( 0, 0 );
4852             }
4853
4854             if ( !GetBatchCount() )
4855             {
4856                 CalcDimensions();
4857                 m_rowLabelWin->Refresh();
4858             }
4859         }
4860         result = true;
4861         break;
4862
4863         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4864         {
4865             size_t pos = msg.GetCommandInt();
4866             int numRows = msg.GetCommandInt2();
4867             m_numRows -= numRows;
4868
4869             if ( !m_rowHeights.IsEmpty() )
4870             {
4871                 m_rowHeights.RemoveAt( pos, numRows );
4872                 m_rowBottoms.RemoveAt( pos, numRows );
4873
4874                 int h = 0;
4875                 for ( i = 0; i < m_numRows; i++ )
4876                 {
4877                     h += m_rowHeights[i];
4878                     m_rowBottoms[i] = h;
4879                 }
4880             }
4881
4882             if ( !m_numRows )
4883             {
4884                 m_currentCellCoords = wxGridNoCellCoords;
4885             }
4886             else
4887             {
4888                 if ( m_currentCellCoords.GetRow() >= m_numRows )
4889                     m_currentCellCoords.Set( 0, 0 );
4890             }
4891
4892             if ( m_selection )
4893                 m_selection->UpdateRows( pos, -((int)numRows) );
4894             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4895             if (attrProvider)
4896             {
4897                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4898
4899 // ifdef'd out following patch from Paul Gammans
4900 #if 0
4901                 // No need to touch column attributes, unless we
4902                 // removed _all_ rows, in this case, we remove
4903                 // all column attributes.
4904                 // I hate to do this here, but the
4905                 // needed data is not available inside UpdateAttrRows.
4906                 if ( !GetNumberRows() )
4907                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4908 #endif
4909             }
4910
4911             if ( !GetBatchCount() )
4912             {
4913                 CalcDimensions();
4914                 m_rowLabelWin->Refresh();
4915             }
4916         }
4917         result = true;
4918         break;
4919
4920         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4921         {
4922             size_t pos = msg.GetCommandInt();
4923             int numCols = msg.GetCommandInt2();
4924             m_numCols += numCols;
4925
4926             if ( !m_colAt.IsEmpty() )
4927             {
4928                 //Shift the column IDs
4929                 int i;
4930                 for ( i = 0; i < m_numCols - numCols; i++ )
4931                 {
4932                     if ( m_colAt[i] >= (int)pos )
4933                         m_colAt[i] += numCols;
4934                 }
4935
4936                 m_colAt.Insert( pos, pos, numCols );
4937
4938                 //Set the new columns' positions
4939                 for ( i = pos + 1; i < (int)pos + numCols; i++ )
4940                 {
4941                     m_colAt[i] = i;
4942                 }
4943             }
4944
4945             if ( !m_colWidths.IsEmpty() )
4946             {
4947                 m_colWidths.Insert( m_defaultColWidth, pos, numCols );
4948                 m_colRights.Insert( 0, pos, numCols );
4949
4950                 int right = 0;
4951                 if ( pos > 0 )
4952                     right = m_colRights[GetColAt( pos - 1 )];
4953
4954                 int colPos;
4955                 for ( colPos = pos; colPos < m_numCols; colPos++ )
4956                 {
4957                     i = GetColAt( colPos );
4958
4959                     right += m_colWidths[i];
4960                     m_colRights[i] = right;
4961                 }
4962             }
4963
4964             if ( m_currentCellCoords == wxGridNoCellCoords )
4965             {
4966                 // if we have just inserted cols into an empty grid the current
4967                 // cell will be undefined...
4968                 //
4969                 SetCurrentCell( 0, 0 );
4970             }
4971
4972             if ( m_selection )
4973                 m_selection->UpdateCols( pos, numCols );
4974             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4975             if (attrProvider)
4976                 attrProvider->UpdateAttrCols( pos, numCols );
4977             if ( !GetBatchCount() )
4978             {
4979                 CalcDimensions();
4980                 m_colLabelWin->Refresh();
4981             }
4982         }
4983         result = true;
4984         break;
4985
4986         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4987         {
4988             int numCols = msg.GetCommandInt();
4989             int oldNumCols = m_numCols;
4990             m_numCols += numCols;
4991
4992             if ( !m_colAt.IsEmpty() )
4993             {
4994                 m_colAt.Add( 0, numCols );
4995
4996                 //Set the new columns' positions
4997                 int i;
4998                 for ( i = oldNumCols; i < m_numCols; i++ )
4999                 {
5000                     m_colAt[i] = i;
5001                 }
5002             }
5003
5004             if ( !m_colWidths.IsEmpty() )
5005             {
5006                 m_colWidths.Add( m_defaultColWidth, numCols );
5007                 m_colRights.Add( 0, numCols );
5008
5009                 int right = 0;
5010                 if ( oldNumCols > 0 )
5011                     right = m_colRights[GetColAt( oldNumCols - 1 )];
5012
5013                 int colPos;
5014                 for ( colPos = oldNumCols; colPos < m_numCols; colPos++ )
5015                 {
5016                     i = GetColAt( colPos );
5017
5018                     right += m_colWidths[i];
5019                     m_colRights[i] = right;
5020                 }
5021             }
5022
5023             if ( m_currentCellCoords == wxGridNoCellCoords )
5024             {
5025                 // if we have just inserted cols into an empty grid the current
5026                 // cell will be undefined...
5027                 //
5028                 SetCurrentCell( 0, 0 );
5029             }
5030             if ( !GetBatchCount() )
5031             {
5032                 CalcDimensions();
5033                 m_colLabelWin->Refresh();
5034             }
5035         }
5036         result = true;
5037         break;
5038
5039         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5040         {
5041             size_t pos = msg.GetCommandInt();
5042             int numCols = msg.GetCommandInt2();
5043             m_numCols -= numCols;
5044
5045             if ( !m_colAt.IsEmpty() )
5046             {
5047                 int colID = GetColAt( pos );
5048
5049                 m_colAt.RemoveAt( pos, numCols );
5050
5051                 //Shift the column IDs
5052                 int colPos;
5053                 for ( colPos = 0; colPos < m_numCols; colPos++ )
5054                 {
5055                     if ( m_colAt[colPos] > colID )
5056                         m_colAt[colPos] -= numCols;
5057                 }
5058             }
5059
5060             if ( !m_colWidths.IsEmpty() )
5061             {
5062                 m_colWidths.RemoveAt( pos, numCols );
5063                 m_colRights.RemoveAt( pos, numCols );
5064
5065                 int w = 0;
5066                 int colPos;
5067                 for ( colPos = 0; colPos < m_numCols; colPos++ )
5068                 {
5069                     i = GetColAt( colPos );
5070
5071                     w += m_colWidths[i];
5072                     m_colRights[i] = w;
5073                 }
5074             }
5075
5076             if ( !m_numCols )
5077             {
5078                 m_currentCellCoords = wxGridNoCellCoords;
5079             }
5080             else
5081             {
5082                 if ( m_currentCellCoords.GetCol() >= m_numCols )
5083                   m_currentCellCoords.Set( 0, 0 );
5084             }
5085
5086             if ( m_selection )
5087                 m_selection->UpdateCols( pos, -((int)numCols) );
5088             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
5089             if (attrProvider)
5090             {
5091                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
5092
5093 // ifdef'd out following patch from Paul Gammans
5094 #if 0
5095                 // No need to touch row attributes, unless we
5096                 // removed _all_ columns, in this case, we remove
5097                 // all row attributes.
5098                 // I hate to do this here, but the
5099                 // needed data is not available inside UpdateAttrCols.
5100                 if ( !GetNumberCols() )
5101                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
5102 #endif
5103             }
5104
5105             if ( !GetBatchCount() )
5106             {
5107                 CalcDimensions();
5108                 m_colLabelWin->Refresh();
5109             }
5110         }
5111         result = true;
5112         break;
5113     }
5114
5115     if (result && !GetBatchCount() )
5116         m_gridWin->Refresh();
5117
5118     return result;
5119 }
5120
5121 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg ) const
5122 {
5123     wxRegionIterator iter( reg );
5124     wxRect r;
5125
5126     wxArrayInt  rowlabels;
5127
5128     int top, bottom;
5129     while ( iter )
5130     {
5131         r = iter.GetRect();
5132
5133         // TODO: remove this when we can...
5134         // There is a bug in wxMotif that gives garbage update
5135         // rectangles if you jump-scroll a long way by clicking the
5136         // scrollbar with middle button.  This is a work-around
5137         //
5138 #if defined(__WXMOTIF__)
5139         int cw, ch;
5140         m_gridWin->GetClientSize( &cw, &ch );
5141         if ( r.GetTop() > ch )
5142             r.SetTop( 0 );
5143         r.SetBottom( wxMin( r.GetBottom(), ch ) );
5144 #endif
5145
5146         // logical bounds of update region
5147         //
5148         int dummy;
5149         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
5150         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
5151
5152         // find the row labels within these bounds
5153         //
5154         int row;
5155         for ( row = internalYToRow(top); row < m_numRows; row++ )
5156         {
5157             if ( GetRowBottom(row) < top )
5158                 continue;
5159
5160             if ( GetRowTop(row) > bottom )
5161                 break;
5162
5163             rowlabels.Add( row );
5164         }
5165
5166         ++iter;
5167     }
5168
5169     return rowlabels;
5170 }
5171
5172 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg ) const
5173 {
5174     wxRegionIterator iter( reg );
5175     wxRect r;
5176
5177     wxArrayInt colLabels;
5178
5179     int left, right;
5180     while ( iter )
5181     {
5182         r = iter.GetRect();
5183
5184         // TODO: remove this when we can...
5185         // There is a bug in wxMotif that gives garbage update
5186         // rectangles if you jump-scroll a long way by clicking the
5187         // scrollbar with middle button.  This is a work-around
5188         //
5189 #if defined(__WXMOTIF__)
5190         int cw, ch;
5191         m_gridWin->GetClientSize( &cw, &ch );
5192         if ( r.GetLeft() > cw )
5193             r.SetLeft( 0 );
5194         r.SetRight( wxMin( r.GetRight(), cw ) );
5195 #endif
5196
5197         // logical bounds of update region
5198         //
5199         int dummy;
5200         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
5201         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
5202
5203         // find the cells within these bounds
5204         //
5205         int col;
5206         int colPos;
5207         for ( colPos = GetColPos( internalXToCol(left) ); colPos < m_numCols; colPos++ )
5208         {
5209             col = GetColAt( colPos );
5210
5211             if ( GetColRight(col) < left )
5212                 continue;
5213
5214             if ( GetColLeft(col) > right )
5215                 break;
5216
5217             colLabels.Add( col );
5218         }
5219
5220         ++iter;
5221     }
5222
5223     return colLabels;
5224 }
5225
5226 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg ) const
5227 {
5228     wxRegionIterator iter( reg );
5229     wxRect r;
5230
5231     wxGridCellCoordsArray  cellsExposed;
5232
5233     int left, top, right, bottom;
5234     while ( iter )
5235     {
5236         r = iter.GetRect();
5237
5238         // TODO: remove this when we can...
5239         // There is a bug in wxMotif that gives garbage update
5240         // rectangles if you jump-scroll a long way by clicking the
5241         // scrollbar with middle button.  This is a work-around
5242         //
5243 #if defined(__WXMOTIF__)
5244         int cw, ch;
5245         m_gridWin->GetClientSize( &cw, &ch );
5246         if ( r.GetTop() > ch ) r.SetTop( 0 );
5247         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
5248         r.SetRight( wxMin( r.GetRight(), cw ) );
5249         r.SetBottom( wxMin( r.GetBottom(), ch ) );
5250 #endif
5251
5252         // logical bounds of update region
5253         //
5254         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
5255         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
5256
5257         // find the cells within these bounds
5258         //
5259         int row, col;
5260         for ( row = internalYToRow(top); row < m_numRows; row++ )
5261         {
5262             if ( GetRowBottom(row) <= top )
5263                 continue;
5264
5265             if ( GetRowTop(row) > bottom )
5266                 break;
5267
5268             int colPos;
5269             for ( colPos = GetColPos( internalXToCol(left) ); colPos < m_numCols; colPos++ )
5270             {
5271                 col = GetColAt( colPos );
5272
5273                 if ( GetColRight(col) <= left )
5274                     continue;
5275
5276                 if ( GetColLeft(col) > right )
5277                     break;
5278
5279                 cellsExposed.Add( wxGridCellCoords( row, col ) );
5280             }
5281         }
5282
5283         ++iter;
5284     }
5285
5286     return cellsExposed;
5287 }
5288
5289
5290 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
5291 {
5292     int x, y, row;
5293     wxPoint pos( event.GetPosition() );
5294     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5295
5296     if ( event.Dragging() )
5297     {
5298         if (!m_isDragging)
5299         {
5300             m_isDragging = true;
5301             m_rowLabelWin->CaptureMouse();
5302         }
5303
5304         if ( event.LeftIsDown() )
5305         {
5306             switch ( m_cursorMode )
5307             {
5308                 case WXGRID_CURSOR_RESIZE_ROW:
5309                 {
5310                     int cw, ch, left, dummy;
5311                     m_gridWin->GetClientSize( &cw, &ch );
5312                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
5313
5314                     wxClientDC dc( m_gridWin );
5315                     PrepareDC( dc );
5316                     y = wxMax( y,
5317                                GetRowTop(m_dragRowOrCol) +
5318                                GetRowMinimalHeight(m_dragRowOrCol) );
5319                     dc.SetLogicalFunction(wxINVERT);
5320                     if ( m_dragLastPos >= 0 )
5321                     {
5322                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5323                     }
5324                     dc.DrawLine( left, y, left+cw, y );
5325                     m_dragLastPos = y;
5326                 }
5327                 break;
5328
5329                 case WXGRID_CURSOR_SELECT_ROW:
5330                 {
5331                     if ( (row = YToRow( y )) >= 0 )
5332                     {
5333                         if ( m_selection )
5334                         {
5335                             m_selection->SelectRow( row,
5336                                                     event.ControlDown(),
5337                                                     event.ShiftDown(),
5338                                                     event.AltDown(),
5339                                                     event.MetaDown() );
5340                         }
5341                     }
5342                 }
5343                 break;
5344
5345                 // default label to suppress warnings about "enumeration value
5346                 // 'xxx' not handled in switch
5347                 default:
5348                     break;
5349             }
5350         }
5351         return;
5352     }
5353
5354     if ( m_isDragging && (event.Entering() || event.Leaving()) )
5355         return;
5356
5357     if (m_isDragging)
5358     {
5359         if (m_rowLabelWin->HasCapture())
5360             m_rowLabelWin->ReleaseMouse();
5361         m_isDragging = false;
5362     }
5363
5364     // ------------ Entering or leaving the window
5365     //
5366     if ( event.Entering() || event.Leaving() )
5367     {
5368         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
5369     }
5370
5371     // ------------ Left button pressed
5372     //
5373     else if ( event.LeftDown() )
5374     {
5375         // don't send a label click event for a hit on the
5376         // edge of the row label - this is probably the user
5377         // wanting to resize the row
5378         //
5379         if ( YToEdgeOfRow(y) < 0 )
5380         {
5381             row = YToRow(y);
5382             if ( row >= 0 &&
5383                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
5384             {
5385                 if ( !event.ShiftDown() && !event.CmdDown() )
5386                     ClearSelection();
5387                 if ( m_selection )
5388                 {
5389                     if ( event.ShiftDown() )
5390                     {
5391                         m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5392                                                   0,
5393                                                   row,
5394                                                   GetNumberCols() - 1,
5395                                                   event.ControlDown(),
5396                                                   event.ShiftDown(),
5397                                                   event.AltDown(),
5398                                                   event.MetaDown() );
5399                     }
5400                     else
5401                     {
5402                         m_selection->SelectRow( row,
5403                                                 event.ControlDown(),
5404                                                 event.ShiftDown(),
5405                                                 event.AltDown(),
5406                                                 event.MetaDown() );
5407                     }
5408                 }
5409
5410                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
5411             }
5412         }
5413         else
5414         {
5415             // starting to drag-resize a row
5416             if ( CanDragRowSize() )
5417                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
5418         }
5419     }
5420
5421     // ------------ Left double click
5422     //
5423     else if (event.LeftDClick() )
5424     {
5425         row = YToEdgeOfRow(y);
5426         if ( row < 0 )
5427         {
5428             row = YToRow(y);
5429             if ( row >=0 &&
5430                  !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event ) )
5431             {
5432                 // no default action at the moment
5433             }
5434         }
5435         else
5436         {
5437             // adjust row height depending on label text
5438             AutoSizeRowLabelSize( row );
5439
5440             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5441             m_dragLastPos = -1;
5442         }
5443     }
5444
5445     // ------------ Left button released
5446     //
5447     else if ( event.LeftUp() )
5448     {
5449         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5450         {
5451             DoEndDragResizeRow();
5452
5453             // Note: we are ending the event *after* doing
5454             // default processing in this case
5455             //
5456             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5457         }
5458
5459         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
5460         m_dragLastPos = -1;
5461     }
5462
5463     // ------------ Right button down
5464     //
5465     else if ( event.RightDown() )
5466     {
5467         row = YToRow(y);
5468         if ( row >=0 &&
5469              !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
5470         {
5471             // no default action at the moment
5472         }
5473     }
5474
5475     // ------------ Right double click
5476     //
5477     else if ( event.RightDClick() )
5478     {
5479         row = YToRow(y);
5480         if ( row >= 0 &&
5481              !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
5482         {
5483             // no default action at the moment
5484         }
5485     }
5486
5487     // ------------ No buttons down and mouse moving
5488     //
5489     else if ( event.Moving() )
5490     {
5491         m_dragRowOrCol = YToEdgeOfRow( y );
5492         if ( m_dragRowOrCol >= 0 )
5493         {
5494             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5495             {
5496                 // don't capture the mouse yet
5497                 if ( CanDragRowSize() )
5498                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, false);
5499             }
5500         }
5501         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5502         {
5503             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, false);
5504         }
5505     }
5506 }
5507
5508 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
5509 {
5510     int x, y, col;
5511     wxPoint pos( event.GetPosition() );
5512     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5513
5514     if ( event.Dragging() )
5515     {
5516         if (!m_isDragging)
5517         {
5518             m_isDragging = true;
5519             m_colLabelWin->CaptureMouse();
5520
5521             if ( m_cursorMode == WXGRID_CURSOR_MOVE_COL )
5522                 m_dragRowOrCol = XToCol( x );
5523         }
5524
5525         if ( event.LeftIsDown() )
5526         {
5527             switch ( m_cursorMode )
5528             {
5529                 case WXGRID_CURSOR_RESIZE_COL:
5530                 {
5531                     int cw, ch, dummy, top;
5532                     m_gridWin->GetClientSize( &cw, &ch );
5533                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
5534
5535                     wxClientDC dc( m_gridWin );
5536                     PrepareDC( dc );
5537
5538                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5539                                   GetColMinimalWidth(m_dragRowOrCol));
5540                     dc.SetLogicalFunction(wxINVERT);
5541                     if ( m_dragLastPos >= 0 )
5542                     {
5543                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top + ch );
5544                     }
5545                     dc.DrawLine( x, top, x, top + ch );
5546                     m_dragLastPos = x;
5547                 }
5548                 break;
5549
5550                 case WXGRID_CURSOR_SELECT_COL:
5551                 {
5552                     if ( (col = XToCol( x )) >= 0 )
5553                     {
5554                         if ( m_selection )
5555                         {
5556                             m_selection->SelectCol( col,
5557                                                     event.ControlDown(),
5558                                                     event.ShiftDown(),
5559                                                     event.AltDown(),
5560                                                     event.MetaDown() );
5561                         }
5562                     }
5563                 }
5564                 break;
5565
5566                 case WXGRID_CURSOR_MOVE_COL:
5567                 {
5568                     if ( x < 0 )
5569                         m_moveToCol = GetColAt( 0 );
5570                     else
5571                         m_moveToCol = XToCol( x );
5572
5573                     int markerX;
5574
5575                     if ( m_moveToCol < 0 )
5576                         markerX = GetColRight( GetColAt( m_numCols - 1 ) );
5577                     else
5578                         markerX = GetColLeft( m_moveToCol );
5579
5580                     if ( markerX != m_dragLastPos )
5581                     {
5582                         wxClientDC dc( m_colLabelWin );
5583
5584                         int cw, ch;
5585                         m_colLabelWin->GetClientSize( &cw, &ch );
5586
5587                         markerX++;
5588
5589                         //Clean up the last indicator
5590                         if ( m_dragLastPos >= 0 )
5591                         {
5592                             wxPen pen( m_colLabelWin->GetBackgroundColour(), 2 );
5593                             dc.SetPen(pen);
5594                             dc.DrawLine( m_dragLastPos + 1, 0, m_dragLastPos + 1, ch );
5595                             dc.SetPen(wxNullPen);
5596
5597                             if ( XToCol( m_dragLastPos ) != -1 )
5598                                 DrawColLabel( dc, XToCol( m_dragLastPos ) );
5599                         }
5600
5601                         //Moving to the same place? Don't draw a marker
5602                         if ( (m_moveToCol == m_dragRowOrCol)
5603                           || (GetColPos( m_moveToCol ) == GetColPos( m_dragRowOrCol ) + 1)
5604                           || (m_moveToCol < 0 && m_dragRowOrCol == GetColAt( m_numCols - 1 )))
5605                         {
5606                             m_dragLastPos = -1;
5607                             return;
5608                         }
5609
5610                         //Draw the marker
5611                         wxPen pen( *wxBLUE, 2 );
5612                         dc.SetPen(pen);
5613
5614                         dc.DrawLine( markerX, 0, markerX, ch );
5615
5616                         dc.SetPen(wxNullPen);
5617
5618                         m_dragLastPos = markerX - 1;
5619                     }
5620                 }
5621                 break;
5622
5623                 // default label to suppress warnings about "enumeration value
5624                 // 'xxx' not handled in switch
5625                 default:
5626                     break;
5627             }
5628         }
5629         return;
5630     }
5631
5632     if ( m_isDragging && (event.Entering() || event.Leaving()) )
5633         return;
5634
5635     if (m_isDragging)
5636     {
5637         if (m_colLabelWin->HasCapture())
5638             m_colLabelWin->ReleaseMouse();
5639         m_isDragging = false;
5640     }
5641
5642     // ------------ Entering or leaving the window
5643     //
5644     if ( event.Entering() || event.Leaving() )
5645     {
5646         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5647     }
5648
5649     // ------------ Left button pressed
5650     //
5651     else if ( event.LeftDown() )
5652     {
5653         // don't send a label click event for a hit on the
5654         // edge of the col label - this is probably the user
5655         // wanting to resize the col
5656         //
5657         if ( XToEdgeOfCol(x) < 0 )
5658         {
5659             col = XToCol(x);
5660             if ( col >= 0 &&
5661                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
5662             {
5663                 if ( m_canDragColMove )
5664                 {
5665                     //Show button as pressed
5666                     wxClientDC dc( m_colLabelWin );
5667                     int colLeft = GetColLeft( col );
5668                     int colRight = GetColRight( col ) - 1;
5669                     dc.SetPen( wxPen( m_colLabelWin->GetBackgroundColour(), 1 ) );
5670                     dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
5671                     dc.DrawLine( colLeft, 1, colRight, 1 );
5672
5673                     ChangeCursorMode(WXGRID_CURSOR_MOVE_COL, m_colLabelWin);
5674                 }
5675                 else
5676                 {
5677                     if ( !event.ShiftDown() && !event.CmdDown() )
5678                         ClearSelection();
5679                     if ( m_selection )
5680                     {
5681                         if ( event.ShiftDown() )
5682                         {
5683                             m_selection->SelectBlock( 0,
5684                                                       m_currentCellCoords.GetCol(),
5685                                                       GetNumberRows() - 1, col,
5686                                                       event.ControlDown(),
5687                                                       event.ShiftDown(),
5688                                                       event.AltDown(),
5689                                                       event.MetaDown() );
5690                         }
5691                         else
5692                         {
5693                             m_selection->SelectCol( col,
5694                                                     event.ControlDown(),
5695                                                     event.ShiftDown(),
5696                                                     event.AltDown(),
5697                                                     event.MetaDown() );
5698                         }
5699                     }
5700
5701                     ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
5702                 }
5703             }
5704         }
5705         else
5706         {
5707             // starting to drag-resize a col
5708             //
5709             if ( CanDragColSize() )
5710                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
5711         }
5712     }
5713
5714     // ------------ Left double click
5715     //
5716     if ( event.LeftDClick() )
5717     {
5718         col = XToEdgeOfCol(x);
5719         if ( col < 0 )
5720         {
5721             col = XToCol(x);
5722             if ( col >= 0 &&
5723                  ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event ) )
5724             {
5725                 // no default action at the moment
5726             }
5727         }
5728         else
5729         {
5730             // adjust column width depending on label text
5731             AutoSizeColLabelSize( col );
5732
5733             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5734             m_dragLastPos = -1;
5735         }
5736     }
5737
5738     // ------------ Left button released
5739     //
5740     else if ( event.LeftUp() )
5741     {
5742         switch ( m_cursorMode )
5743         {
5744             case WXGRID_CURSOR_RESIZE_COL:
5745                 DoEndDragResizeCol();
5746
5747                 // Note: we are ending the event *after* doing
5748                 // default processing in this case
5749                 //
5750                 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5751                 break;
5752
5753             case WXGRID_CURSOR_MOVE_COL:
5754                 DoEndDragMoveCol();
5755
5756                 SendEvent( wxEVT_GRID_COL_MOVE, -1, m_dragRowOrCol, event );
5757                 break;
5758
5759             case WXGRID_CURSOR_SELECT_COL:
5760             case WXGRID_CURSOR_SELECT_CELL:
5761             case WXGRID_CURSOR_RESIZE_ROW:
5762             case WXGRID_CURSOR_SELECT_ROW:
5763                 // nothing to do (?)
5764                 break;
5765         }
5766
5767         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5768         m_dragLastPos = -1;
5769     }
5770
5771     // ------------ Right button down
5772     //
5773     else if ( event.RightDown() )
5774     {
5775         col = XToCol(x);
5776         if ( col >= 0 &&
5777              !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
5778         {
5779             // no default action at the moment
5780         }
5781     }
5782
5783     // ------------ Right double click
5784     //
5785     else if ( event.RightDClick() )
5786     {
5787         col = XToCol(x);
5788         if ( col >= 0 &&
5789              !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
5790         {
5791             // no default action at the moment
5792         }
5793     }
5794
5795     // ------------ No buttons down and mouse moving
5796     //
5797     else if ( event.Moving() )
5798     {
5799         m_dragRowOrCol = XToEdgeOfCol( x );
5800         if ( m_dragRowOrCol >= 0 )
5801         {
5802             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5803             {
5804                 // don't capture the cursor yet
5805                 if ( CanDragColSize() )
5806                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, false);
5807             }
5808         }
5809         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5810         {
5811             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, false);
5812         }
5813     }
5814 }
5815
5816 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
5817 {
5818     if ( event.LeftDown() )
5819     {
5820         // indicate corner label by having both row and
5821         // col args == -1
5822         //
5823         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
5824         {
5825             SelectAll();
5826         }
5827     }
5828     else if ( event.LeftDClick() )
5829     {
5830         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
5831     }
5832     else if ( event.RightDown() )
5833     {
5834         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
5835         {
5836             // no default action at the moment
5837         }
5838     }
5839     else if ( event.RightDClick() )
5840     {
5841         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
5842         {
5843             // no default action at the moment
5844         }
5845     }
5846 }
5847
5848 void wxGrid::CancelMouseCapture()
5849 {
5850     // cancel operation currently in progress, whatever it is
5851     if ( m_winCapture )
5852     {
5853         m_isDragging = false;
5854         m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
5855         m_winCapture->SetCursor( *wxSTANDARD_CURSOR );
5856         m_winCapture = NULL;
5857
5858         // remove traces of whatever we drew on screen
5859         Refresh();
5860     }
5861 }
5862
5863 void wxGrid::ChangeCursorMode(CursorMode mode,
5864                               wxWindow *win,
5865                               bool captureMouse)
5866 {
5867 #ifdef __WXDEBUG__
5868     static const wxChar *cursorModes[] =
5869     {
5870         _T("SELECT_CELL"),
5871         _T("RESIZE_ROW"),
5872         _T("RESIZE_COL"),
5873         _T("SELECT_ROW"),
5874         _T("SELECT_COL"),
5875         _T("MOVE_COL"),
5876     };
5877
5878     wxLogTrace(_T("grid"),
5879                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5880                win == m_colLabelWin ? _T("colLabelWin")
5881                                     : win ? _T("rowLabelWin")
5882                                           : _T("gridWin"),
5883                cursorModes[m_cursorMode], cursorModes[mode]);
5884 #endif
5885
5886     if ( mode == m_cursorMode &&
5887          win == m_winCapture &&
5888          captureMouse == (m_winCapture != NULL))
5889         return;
5890
5891     if ( !win )
5892     {
5893         // by default use the grid itself
5894         win = m_gridWin;
5895     }
5896
5897     if ( m_winCapture )
5898     {
5899         if (m_winCapture->HasCapture())
5900             m_winCapture->ReleaseMouse();
5901         m_winCapture = (wxWindow *)NULL;
5902     }
5903
5904     m_cursorMode = mode;
5905
5906     switch ( m_cursorMode )
5907     {
5908         case WXGRID_CURSOR_RESIZE_ROW:
5909             win->SetCursor( m_rowResizeCursor );
5910             break;
5911
5912         case WXGRID_CURSOR_RESIZE_COL:
5913             win->SetCursor( m_colResizeCursor );
5914             break;
5915
5916         case WXGRID_CURSOR_MOVE_COL:
5917             win->SetCursor( wxCursor(wxCURSOR_HAND) );
5918             break;
5919
5920         default:
5921             win->SetCursor( *wxSTANDARD_CURSOR );
5922             break;
5923     }
5924
5925     // we need to capture mouse when resizing
5926     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
5927                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
5928
5929     if ( captureMouse && resize )
5930     {
5931         win->CaptureMouse();
5932         m_winCapture = win;
5933     }
5934 }
5935
5936 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
5937 {
5938     int x, y;
5939     wxPoint pos( event.GetPosition() );
5940     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5941
5942     wxGridCellCoords coords;
5943     XYToCell( x, y, coords );
5944
5945     int cell_rows, cell_cols;
5946     bool isFirstDrag = !m_isDragging;
5947     GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
5948     if ((cell_rows < 0) || (cell_cols < 0))
5949     {
5950         coords.SetRow(coords.GetRow() + cell_rows);
5951         coords.SetCol(coords.GetCol() + cell_cols);
5952     }
5953
5954     if ( event.Dragging() )
5955     {
5956         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5957
5958         // Don't start doing anything until the mouse has been dragged at
5959         // least 3 pixels in any direction...
5960         if (! m_isDragging)
5961         {
5962             if (m_startDragPos == wxDefaultPosition)
5963             {
5964                 m_startDragPos = pos;
5965                 return;
5966             }
5967             if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
5968                 return;
5969         }
5970
5971         m_isDragging = true;
5972         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5973         {
5974             // Hide the edit control, so it
5975             // won't interfere with drag-shrinking.
5976             if ( IsCellEditControlShown() )
5977             {
5978                 HideCellEditControl();
5979                 SaveEditControlValue();
5980             }
5981
5982             if ( coords != wxGridNoCellCoords )
5983             {
5984                 if ( event.CmdDown() )
5985                 {
5986                     if ( m_selectingKeyboard == wxGridNoCellCoords)
5987                         m_selectingKeyboard = coords;
5988                     HighlightBlock( m_selectingKeyboard, coords );
5989                 }
5990                 else if ( CanDragCell() )
5991                 {
5992                     if ( isFirstDrag )
5993                     {
5994                         if ( m_selectingKeyboard == wxGridNoCellCoords)
5995                             m_selectingKeyboard = coords;
5996
5997                         SendEvent( wxEVT_GRID_CELL_BEGIN_DRAG,
5998                                    coords.GetRow(),
5999                                    coords.GetCol(),
6000                                    event );
6001                         return;
6002                     }
6003                 }
6004                 else
6005                 {
6006                     if ( !IsSelection() )
6007                     {
6008                         HighlightBlock( coords, coords );
6009                     }
6010                     else
6011                     {
6012                         HighlightBlock( m_currentCellCoords, coords );
6013                     }
6014                 }
6015
6016                 if (! IsVisible(coords))
6017                 {
6018                     MakeCellVisible(coords);
6019                     // TODO: need to introduce a delay or something here.  The
6020                     // scrolling is way to fast, at least on MSW - also on GTK.
6021                 }
6022             }
6023             // Have we captured the mouse yet?
6024             if (! m_winCapture)
6025             {
6026                 m_winCapture = m_gridWin;
6027                 m_winCapture->CaptureMouse();
6028             }
6029
6030
6031         }
6032         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
6033         {
6034             int cw, ch, left, dummy;
6035             m_gridWin->GetClientSize( &cw, &ch );
6036             CalcUnscrolledPosition( 0, 0, &left, &dummy );
6037
6038             wxClientDC dc( m_gridWin );
6039             PrepareDC( dc );
6040             y = wxMax( y, GetRowTop(m_dragRowOrCol) +
6041                           GetRowMinimalHeight(m_dragRowOrCol) );
6042             dc.SetLogicalFunction(wxINVERT);
6043             if ( m_dragLastPos >= 0 )
6044             {
6045                 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
6046             }
6047             dc.DrawLine( left, y, left+cw, y );
6048             m_dragLastPos = y;
6049         }
6050         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
6051         {
6052             int cw, ch, dummy, top;
6053             m_gridWin->GetClientSize( &cw, &ch );
6054             CalcUnscrolledPosition( 0, 0, &dummy, &top );
6055
6056             wxClientDC dc( m_gridWin );
6057             PrepareDC( dc );
6058             x = wxMax( x, GetColLeft(m_dragRowOrCol) +
6059                           GetColMinimalWidth(m_dragRowOrCol) );
6060             dc.SetLogicalFunction(wxINVERT);
6061             if ( m_dragLastPos >= 0 )
6062             {
6063                 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top + ch );
6064             }
6065             dc.DrawLine( x, top, x, top + ch );
6066             m_dragLastPos = x;
6067         }
6068
6069         return;
6070     }
6071
6072     m_isDragging = false;
6073     m_startDragPos = wxDefaultPosition;
6074
6075     // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
6076     //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
6077     //     wxGTK
6078 #if 0
6079     if ( event.Entering() || event.Leaving() )
6080     {
6081         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6082         m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
6083     }
6084     else
6085 #endif // 0
6086
6087     // ------------ Left button pressed
6088     //
6089     if ( event.LeftDown() && coords != wxGridNoCellCoords )
6090     {
6091         if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
6092                        coords.GetRow(),
6093                        coords.GetCol(),
6094                        event ) )
6095         {
6096             if ( !event.CmdDown() )
6097                 ClearSelection();
6098             if ( event.ShiftDown() )
6099             {
6100                 if ( m_selection )
6101                 {
6102                     m_selection->SelectBlock( m_currentCellCoords.GetRow(),
6103                                               m_currentCellCoords.GetCol(),
6104                                               coords.GetRow(),
6105                                               coords.GetCol(),
6106                                               event.ControlDown(),
6107                                               event.ShiftDown(),
6108                                               event.AltDown(),
6109                                               event.MetaDown() );
6110                 }
6111             }
6112             else if ( XToEdgeOfCol(x) < 0 &&
6113                       YToEdgeOfRow(y) < 0 )
6114             {
6115                 DisableCellEditControl();
6116                 MakeCellVisible( coords );
6117
6118                 if ( event.CmdDown() )
6119                 {
6120                     if ( m_selection )
6121                     {
6122                         m_selection->ToggleCellSelection( coords.GetRow(),
6123                                                           coords.GetCol(),
6124                                                           event.ControlDown(),
6125                                                           event.ShiftDown(),
6126                                                           event.AltDown(),
6127                                                           event.MetaDown() );
6128                     }
6129                     m_selectingTopLeft = wxGridNoCellCoords;
6130                     m_selectingBottomRight = wxGridNoCellCoords;
6131                     m_selectingKeyboard = coords;
6132                 }
6133                 else
6134                 {
6135                     m_waitForSlowClick = m_currentCellCoords == coords && coords != wxGridNoCellCoords;
6136                     SetCurrentCell( coords );
6137                     if ( m_selection )
6138                     {
6139                         if ( m_selection->GetSelectionMode() !=
6140                                 wxGrid::wxGridSelectCells )
6141                         {
6142                             HighlightBlock( coords, coords );
6143                         }
6144                     }
6145                 }
6146             }
6147         }
6148     }
6149
6150     // ------------ Left double click
6151     //
6152     else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
6153     {
6154         DisableCellEditControl();
6155
6156         if ( XToEdgeOfCol(x) < 0 && YToEdgeOfRow(y) < 0 )
6157         {
6158             if ( !SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
6159                              coords.GetRow(),
6160                              coords.GetCol(),
6161                              event ) )
6162             {
6163                 // we want double click to select a cell and start editing
6164                 // (i.e. to behave in same way as sequence of two slow clicks):
6165                 m_waitForSlowClick = true;
6166             }
6167         }
6168     }
6169
6170     // ------------ Left button released
6171     //
6172     else if ( event.LeftUp() )
6173     {
6174         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6175         {
6176             if (m_winCapture)
6177             {
6178                 if (m_winCapture->HasCapture())
6179                     m_winCapture->ReleaseMouse();
6180                 m_winCapture = NULL;
6181             }
6182
6183             if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
6184             {
6185                 ClearSelection();
6186                 EnableCellEditControl();
6187
6188                 wxGridCellAttr *attr = GetCellAttr(coords);
6189                 wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
6190                 editor->StartingClick();
6191                 editor->DecRef();
6192                 attr->DecRef();
6193
6194                 m_waitForSlowClick = false;
6195             }
6196             else if ( m_selectingTopLeft != wxGridNoCellCoords &&
6197                  m_selectingBottomRight != wxGridNoCellCoords )
6198             {
6199                 if ( m_selection )
6200                 {
6201                     m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
6202                                               m_selectingTopLeft.GetCol(),
6203                                               m_selectingBottomRight.GetRow(),
6204                                               m_selectingBottomRight.GetCol(),
6205                                               event.ControlDown(),
6206                                               event.ShiftDown(),
6207                                               event.AltDown(),
6208                                               event.MetaDown() );
6209                 }
6210
6211                 m_selectingTopLeft = wxGridNoCellCoords;
6212                 m_selectingBottomRight = wxGridNoCellCoords;
6213
6214                 // Show the edit control, if it has been hidden for
6215                 // drag-shrinking.
6216                 ShowCellEditControl();
6217             }
6218         }
6219         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
6220         {
6221             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6222             DoEndDragResizeRow();
6223
6224             // Note: we are ending the event *after* doing
6225             // default processing in this case
6226             //
6227             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
6228         }
6229         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
6230         {
6231             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6232             DoEndDragResizeCol();
6233
6234             // Note: we are ending the event *after* doing
6235             // default processing in this case
6236             //
6237             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
6238         }
6239
6240         m_dragLastPos = -1;
6241     }
6242
6243     // ------------ Right button down
6244     //
6245     else if ( event.RightDown() && coords != wxGridNoCellCoords )
6246     {
6247         DisableCellEditControl();
6248         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
6249                          coords.GetRow(),
6250                          coords.GetCol(),
6251                          event ) )
6252         {
6253             // no default action at the moment
6254         }
6255     }
6256
6257     // ------------ Right double click
6258     //
6259     else if ( event.RightDClick() && coords != wxGridNoCellCoords )
6260     {
6261         DisableCellEditControl();
6262         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
6263                          coords.GetRow(),
6264                          coords.GetCol(),
6265                          event ) )
6266         {
6267             // no default action at the moment
6268         }
6269     }
6270
6271     // ------------ Moving and no button action
6272     //
6273     else if ( event.Moving() && !event.IsButton() )
6274     {
6275         if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
6276         {
6277             // out of grid cell area
6278             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6279             return;
6280         }
6281
6282         int dragRow = YToEdgeOfRow( y );
6283         int dragCol = XToEdgeOfCol( x );
6284
6285         // Dragging on the corner of a cell to resize in both
6286         // directions is not implemented yet...
6287         //
6288         if ( dragRow >= 0 && dragCol >= 0 )
6289         {
6290             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6291             return;
6292         }
6293
6294         if ( dragRow >= 0 )
6295         {
6296             m_dragRowOrCol = dragRow;
6297
6298             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6299             {
6300                 if ( CanDragRowSize() && CanDragGridSize() )
6301                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
6302             }
6303         }
6304         else if ( dragCol >= 0 )
6305         {
6306             m_dragRowOrCol = dragCol;
6307
6308             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
6309             {
6310                 if ( CanDragColSize() && CanDragGridSize() )
6311                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
6312             }
6313         }
6314         else // Neither on a row or col edge
6315         {
6316             if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
6317             {
6318                 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
6319             }
6320         }
6321     }
6322 }
6323
6324 void wxGrid::DoEndDragResizeRow()
6325 {
6326     if ( m_dragLastPos >= 0 )
6327     {
6328         // erase the last line and resize the row
6329         //
6330         int cw, ch, left, dummy;
6331         m_gridWin->GetClientSize( &cw, &ch );
6332         CalcUnscrolledPosition( 0, 0, &left, &dummy );
6333
6334         wxClientDC dc( m_gridWin );
6335         PrepareDC( dc );
6336         dc.SetLogicalFunction( wxINVERT );
6337         dc.DrawLine( left, m_dragLastPos, left + cw, m_dragLastPos );
6338         HideCellEditControl();
6339         SaveEditControlValue();
6340
6341         int rowTop = GetRowTop(m_dragRowOrCol);
6342         SetRowSize( m_dragRowOrCol,
6343                     wxMax( m_dragLastPos - rowTop, m_minAcceptableRowHeight ) );
6344
6345         if ( !GetBatchCount() )
6346         {
6347             // Only needed to get the correct rect.y:
6348             wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
6349             rect.x = 0;
6350             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
6351             rect.width = m_rowLabelWidth;
6352             rect.height = ch - rect.y;
6353             m_rowLabelWin->Refresh( true, &rect );
6354             rect.width = cw;
6355
6356             // if there is a multicell block, paint all of it
6357             if (m_table)
6358             {
6359                 int i, cell_rows, cell_cols, subtract_rows = 0;
6360                 int leftCol = XToCol(left);
6361                 int rightCol = internalXToCol(left + cw);
6362                 if (leftCol >= 0)
6363                 {
6364                     for (i=leftCol; i<rightCol; i++)
6365                     {
6366                         GetCellSize(m_dragRowOrCol, i, &cell_rows, &cell_cols);
6367                         if (cell_rows < subtract_rows)
6368                             subtract_rows = cell_rows;
6369                     }
6370                     rect.y = GetRowTop(m_dragRowOrCol + subtract_rows);
6371                     CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
6372                     rect.height = ch - rect.y;
6373                 }
6374             }
6375             m_gridWin->Refresh( false, &rect );
6376         }
6377
6378         ShowCellEditControl();
6379     }
6380 }
6381
6382
6383 void wxGrid::DoEndDragResizeCol()
6384 {
6385     if ( m_dragLastPos >= 0 )
6386     {
6387         // erase the last line and resize the col
6388         //
6389         int cw, ch, dummy, top;
6390         m_gridWin->GetClientSize( &cw, &ch );
6391         CalcUnscrolledPosition( 0, 0, &dummy, &top );
6392
6393         wxClientDC dc( m_gridWin );
6394         PrepareDC( dc );
6395         dc.SetLogicalFunction( wxINVERT );
6396         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top + ch );
6397         HideCellEditControl();
6398         SaveEditControlValue();
6399
6400         int colLeft = GetColLeft(m_dragRowOrCol);
6401         SetColSize( m_dragRowOrCol,
6402                     wxMax( m_dragLastPos - colLeft,
6403                            GetColMinimalWidth(m_dragRowOrCol) ) );
6404
6405         if ( !GetBatchCount() )
6406         {
6407             // Only needed to get the correct rect.x:
6408             wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
6409             rect.y = 0;
6410             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
6411             rect.width = cw - rect.x;
6412             rect.height = m_colLabelHeight;
6413             m_colLabelWin->Refresh( true, &rect );
6414             rect.height = ch;
6415
6416             // if there is a multicell block, paint all of it
6417             if (m_table)
6418             {
6419                 int i, cell_rows, cell_cols, subtract_cols = 0;
6420                 int topRow = YToRow(top);
6421                 int bottomRow = internalYToRow(top + cw);
6422                 if (topRow >= 0)
6423                 {
6424                     for (i=topRow; i<bottomRow; i++)
6425                     {
6426                         GetCellSize(i, m_dragRowOrCol, &cell_rows, &cell_cols);
6427                         if (cell_cols < subtract_cols)
6428                             subtract_cols = cell_cols;
6429                     }
6430
6431                     rect.x = GetColLeft(m_dragRowOrCol + subtract_cols);
6432                     CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
6433                     rect.width = cw - rect.x;
6434                 }
6435             }
6436
6437             m_gridWin->Refresh( false, &rect );
6438         }
6439
6440         ShowCellEditControl();
6441     }
6442 }
6443
6444 void wxGrid::DoEndDragMoveCol()
6445 {
6446     //The user clicked on the column but didn't actually drag
6447     if ( m_dragLastPos < 0 )
6448     {
6449         m_colLabelWin->Refresh();   //Do this to "unpress" the column
6450         return;
6451     }
6452
6453     int newPos;
6454     if ( m_moveToCol == -1 )
6455         newPos = m_numCols - 1;
6456     else
6457     {
6458         newPos = GetColPos( m_moveToCol );
6459         if ( newPos > GetColPos( m_dragRowOrCol ) )
6460             newPos--;
6461     }
6462
6463     SetColPos( m_dragRowOrCol, newPos );
6464 }
6465
6466 void wxGrid::SetColPos( int colID, int newPos )
6467 {
6468     if ( m_colAt.IsEmpty() )
6469     {
6470         m_colAt.Alloc( m_numCols );
6471
6472         int i;
6473         for ( i = 0; i < m_numCols; i++ )
6474         {
6475             m_colAt.Add( i );
6476         }
6477     }
6478
6479     int oldPos = GetColPos( colID );
6480
6481     //Reshuffle the m_colAt array
6482     if ( newPos > oldPos )
6483     {
6484         int i;
6485         for ( i = oldPos; i < newPos; i++ )
6486         {
6487             m_colAt[i] = m_colAt[i+1];
6488         }
6489     }
6490     else
6491     {
6492         int i;
6493         for ( i = oldPos; i > newPos; i-- )
6494         {
6495             m_colAt[i] = m_colAt[i-1];
6496         }
6497     }
6498
6499     m_colAt[newPos] = colID;
6500
6501     //Recalculate the column rights
6502     if ( !m_colWidths.IsEmpty() )
6503     {
6504         int colRight = 0;
6505         int colPos;
6506         for ( colPos = 0; colPos < m_numCols; colPos++ )
6507         {
6508             int colID = GetColAt( colPos );
6509
6510             colRight += m_colWidths[colID];
6511             m_colRights[colID] = colRight;
6512         }
6513     }
6514
6515     m_colLabelWin->Refresh();
6516     m_gridWin->Refresh();
6517 }
6518
6519
6520
6521 void wxGrid::EnableDragColMove( bool enable )
6522 {
6523     if ( m_canDragColMove == enable )
6524         return;
6525
6526     m_canDragColMove = enable;
6527
6528     if ( !m_canDragColMove )
6529     {
6530         m_colAt.Clear();
6531
6532         //Recalculate the column rights
6533         if ( !m_colWidths.IsEmpty() )
6534         {
6535             int colRight = 0;
6536             int colPos;
6537             for ( colPos = 0; colPos < m_numCols; colPos++ )
6538             {
6539                 colRight += m_colWidths[colPos];
6540                 m_colRights[colPos] = colRight;
6541             }
6542         }
6543
6544         m_colLabelWin->Refresh();
6545         m_gridWin->Refresh();
6546     }
6547 }
6548
6549
6550 //
6551 // ------ interaction with data model
6552 //
6553 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
6554 {
6555     switch ( msg.GetId() )
6556     {
6557         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
6558             return GetModelValues();
6559
6560         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
6561             return SetModelValues();
6562
6563         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
6564         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
6565         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
6566         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
6567         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
6568         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
6569             return Redimension( msg );
6570
6571         default:
6572             return false;
6573     }
6574 }
6575
6576 // The behaviour of this function depends on the grid table class
6577 // Clear() function. For the default wxGridStringTable class the
6578 // behavious is to replace all cell contents with wxEmptyString but
6579 // not to change the number of rows or cols.
6580 //
6581 void wxGrid::ClearGrid()
6582 {
6583     if ( m_table )
6584     {
6585         if (IsCellEditControlEnabled())
6586             DisableCellEditControl();
6587
6588         m_table->Clear();
6589         if (!GetBatchCount())
6590             m_gridWin->Refresh();
6591     }
6592 }
6593
6594 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
6595 {
6596     // TODO: something with updateLabels flag
6597
6598     if ( !m_created )
6599     {
6600         wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
6601         return false;
6602     }
6603
6604     if ( m_table )
6605     {
6606         if (IsCellEditControlEnabled())
6607             DisableCellEditControl();
6608
6609         bool done = m_table->InsertRows( pos, numRows );
6610         return done;
6611
6612         // the table will have sent the results of the insert row
6613         // operation to this view object as a grid table message
6614     }
6615
6616     return false;
6617 }
6618
6619 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
6620 {
6621     // TODO: something with updateLabels flag
6622
6623     if ( !m_created )
6624     {
6625         wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
6626         return false;
6627     }
6628
6629     if ( m_table )
6630     {
6631         bool done = m_table && m_table->AppendRows( numRows );
6632         return done;
6633
6634         // the table will have sent the results of the append row
6635         // operation to this view object as a grid table message
6636     }
6637
6638     return false;
6639 }
6640
6641 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
6642 {
6643     // TODO: something with updateLabels flag
6644
6645     if ( !m_created )
6646     {
6647         wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
6648         return false;
6649     }
6650
6651     if ( m_table )
6652     {
6653         if (IsCellEditControlEnabled())
6654             DisableCellEditControl();
6655
6656         bool done = m_table->DeleteRows( pos, numRows );
6657         return done;
6658         // the table will have sent the results of the delete row
6659         // operation to this view object as a grid table message
6660     }
6661
6662     return false;
6663 }
6664
6665 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
6666 {
6667     // TODO: something with updateLabels flag
6668
6669     if ( !m_created )
6670     {
6671         wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
6672         return false;
6673     }
6674
6675     if ( m_table )
6676     {
6677         if (IsCellEditControlEnabled())
6678             DisableCellEditControl();
6679
6680         bool done = m_table->InsertCols( pos, numCols );
6681         return done;
6682         // the table will have sent the results of the insert col
6683         // operation to this view object as a grid table message
6684     }
6685
6686     return false;
6687 }
6688
6689 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
6690 {
6691     // TODO: something with updateLabels flag
6692
6693     if ( !m_created )
6694     {
6695         wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
6696         return false;
6697     }
6698
6699     if ( m_table )
6700     {
6701         bool done = m_table->AppendCols( numCols );
6702         return done;
6703         // the table will have sent the results of the append col
6704         // operation to this view object as a grid table message
6705     }
6706
6707     return false;
6708 }
6709
6710 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
6711 {
6712     // TODO: something with updateLabels flag
6713
6714     if ( !m_created )
6715     {
6716         wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
6717         return false;
6718     }
6719
6720     if ( m_table )
6721     {
6722         if (IsCellEditControlEnabled())
6723             DisableCellEditControl();
6724
6725         bool done = m_table->DeleteCols( pos, numCols );
6726         return done;
6727         // the table will have sent the results of the delete col
6728         // operation to this view object as a grid table message
6729     }
6730
6731     return false;
6732 }
6733
6734 //
6735 // ----- event handlers
6736 //
6737
6738 // Generate a grid event based on a mouse event and
6739 // return the result of ProcessEvent()
6740 //
6741 int wxGrid::SendEvent( const wxEventType type,
6742                         int row, int col,
6743                         wxMouseEvent& mouseEv )
6744 {
6745    bool claimed, vetoed;
6746
6747    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6748    {
6749        int rowOrCol = (row == -1 ? col : row);
6750
6751        wxGridSizeEvent gridEvt( GetId(),
6752                type,
6753                this,
6754                rowOrCol,
6755                mouseEv.GetX() + GetRowLabelSize(),
6756                mouseEv.GetY() + GetColLabelSize(),
6757                mouseEv.ControlDown(),
6758                mouseEv.ShiftDown(),
6759                mouseEv.AltDown(),
6760                mouseEv.MetaDown() );
6761
6762        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6763        vetoed = !gridEvt.IsAllowed();
6764    }
6765    else if ( type == wxEVT_GRID_RANGE_SELECT )
6766    {
6767        // Right now, it should _never_ end up here!
6768        wxGridRangeSelectEvent gridEvt( GetId(),
6769                type,
6770                this,
6771                m_selectingTopLeft,
6772                m_selectingBottomRight,
6773                true,
6774                mouseEv.ControlDown(),
6775                mouseEv.ShiftDown(),
6776                mouseEv.AltDown(),
6777                mouseEv.MetaDown() );
6778
6779        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6780        vetoed = !gridEvt.IsAllowed();
6781    }
6782    else if ( type == wxEVT_GRID_LABEL_LEFT_CLICK ||
6783              type == wxEVT_GRID_LABEL_LEFT_DCLICK ||
6784              type == wxEVT_GRID_LABEL_RIGHT_CLICK ||
6785              type == wxEVT_GRID_LABEL_RIGHT_DCLICK )
6786    {
6787        wxPoint pos = mouseEv.GetPosition();
6788
6789        if ( mouseEv.GetEventObject() == GetGridRowLabelWindow() )
6790            pos.y += GetColLabelSize();
6791        if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
6792            pos.x += GetRowLabelSize();
6793
6794        wxGridEvent gridEvt( GetId(),
6795                type,
6796                this,
6797                row, col,
6798                pos.x,
6799                pos.y,
6800                false,
6801                mouseEv.ControlDown(),
6802                mouseEv.ShiftDown(),
6803                mouseEv.AltDown(),
6804                mouseEv.MetaDown() );
6805        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6806        vetoed = !gridEvt.IsAllowed();
6807    }
6808    else
6809    {
6810        wxGridEvent gridEvt( GetId(),
6811                type,
6812                this,
6813                row, col,
6814                mouseEv.GetX() + GetRowLabelSize(),
6815                mouseEv.GetY() + GetColLabelSize(),
6816                false,
6817                mouseEv.ControlDown(),
6818                mouseEv.ShiftDown(),
6819                mouseEv.AltDown(),
6820                mouseEv.MetaDown() );
6821        claimed = GetEventHandler()->ProcessEvent(gridEvt);
6822        vetoed = !gridEvt.IsAllowed();
6823    }
6824
6825    // A Veto'd event may not be `claimed' so test this first
6826    if (vetoed)
6827        return -1;
6828
6829    return claimed ? 1 : 0;
6830 }
6831
6832 // Generate a grid event of specified type and return the result
6833 // of ProcessEvent().
6834 //
6835 int wxGrid::SendEvent( const wxEventType type,
6836                         int row, int col )
6837 {
6838    bool claimed, vetoed;
6839
6840     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
6841     {
6842         int rowOrCol = (row == -1 ? col : row);
6843
6844         wxGridSizeEvent gridEvt( GetId(), type, this, rowOrCol );
6845
6846         claimed = GetEventHandler()->ProcessEvent(gridEvt);
6847         vetoed  = !gridEvt.IsAllowed();
6848     }
6849     else
6850     {
6851         wxGridEvent gridEvt( GetId(), type, this, row, col );
6852
6853         claimed = GetEventHandler()->ProcessEvent(gridEvt);
6854         vetoed  = !gridEvt.IsAllowed();
6855      }
6856
6857     // A Veto'd event may not be `claimed' so test this first
6858     if (vetoed)
6859         return -1;
6860
6861     return claimed ? 1 : 0;
6862 }
6863
6864 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
6865 {
6866     // needed to prevent zillions of paint events on MSW
6867     wxPaintDC dc(this);
6868 }
6869
6870 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
6871 {
6872     // Don't do anything if between Begin/EndBatch...
6873     // EndBatch() will do all this on the last nested one anyway.
6874     if (! GetBatchCount())
6875     {
6876         // Refresh to get correct scrolled position:
6877         wxScrolledWindow::Refresh(eraseb, rect);
6878
6879         if (rect)
6880         {
6881             int rect_x, rect_y, rectWidth, rectHeight;
6882             int width_label, width_cell, height_label, height_cell;
6883             int x, y;
6884
6885             // Copy rectangle can get scroll offsets..
6886             rect_x = rect->GetX();
6887             rect_y = rect->GetY();
6888             rectWidth = rect->GetWidth();
6889             rectHeight = rect->GetHeight();
6890
6891             width_label = m_rowLabelWidth - rect_x;
6892             if (width_label > rectWidth)
6893                 width_label = rectWidth;
6894
6895             height_label = m_colLabelHeight - rect_y;
6896             if (height_label > rectHeight)
6897                 height_label = rectHeight;
6898
6899             if (rect_x > m_rowLabelWidth)
6900             {
6901                 x = rect_x - m_rowLabelWidth;
6902                 width_cell = rectWidth;
6903             }
6904             else
6905             {
6906                 x = 0;
6907                 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
6908             }
6909
6910             if (rect_y > m_colLabelHeight)
6911             {
6912                 y = rect_y - m_colLabelHeight;
6913                 height_cell = rectHeight;
6914             }
6915             else
6916             {
6917                 y = 0;
6918                 height_cell = rectHeight - (m_colLabelHeight - rect_y);
6919             }
6920
6921             // Paint corner label part intersecting rect.
6922             if ( width_label > 0 && height_label > 0 )
6923             {
6924                 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
6925                 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
6926             }
6927
6928             // Paint col labels part intersecting rect.
6929             if ( width_cell > 0 && height_label > 0 )
6930             {
6931                 wxRect anotherrect(x, rect_y, width_cell, height_label);
6932                 m_colLabelWin->Refresh(eraseb, &anotherrect);
6933             }
6934
6935             // Paint row labels part intersecting rect.
6936             if ( width_label > 0 && height_cell > 0 )
6937             {
6938                 wxRect anotherrect(rect_x, y, width_label, height_cell);
6939                 m_rowLabelWin->Refresh(eraseb, &anotherrect);
6940             }
6941
6942             // Paint cell area part intersecting rect.
6943             if ( width_cell > 0 && height_cell > 0 )
6944             {
6945                 wxRect anotherrect(x, y, width_cell, height_cell);
6946                 m_gridWin->Refresh(eraseb, &anotherrect);
6947             }
6948         }
6949         else
6950         {
6951             m_cornerLabelWin->Refresh(eraseb, NULL);
6952             m_colLabelWin->Refresh(eraseb, NULL);
6953             m_rowLabelWin->Refresh(eraseb, NULL);
6954             m_gridWin->Refresh(eraseb, NULL);
6955         }
6956     }
6957 }
6958
6959 void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
6960 {
6961     if (m_targetWindow != this) // check whether initialisation has been done
6962     {
6963         // update our children window positions and scrollbars
6964         CalcDimensions();
6965     }
6966 }
6967
6968 void wxGrid::OnKeyDown( wxKeyEvent& event )
6969 {
6970     if ( m_inOnKeyDown )
6971     {
6972         // shouldn't be here - we are going round in circles...
6973         //
6974         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6975     }
6976
6977     m_inOnKeyDown = true;
6978
6979     // propagate the event up and see if it gets processed
6980     wxWindow *parent = GetParent();
6981     wxKeyEvent keyEvt( event );
6982     keyEvt.SetEventObject( parent );
6983
6984     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
6985     {
6986         if (GetLayoutDirection() == wxLayout_RightToLeft)
6987         {
6988             if (event.GetKeyCode() == WXK_RIGHT)
6989                 event.m_keyCode = WXK_LEFT;
6990             else if (event.GetKeyCode() == WXK_LEFT)
6991                 event.m_keyCode = WXK_RIGHT;
6992         }
6993
6994         // try local handlers
6995         switch ( event.GetKeyCode() )
6996         {
6997             case WXK_UP:
6998                 if ( event.ControlDown() )
6999                     MoveCursorUpBlock( event.ShiftDown() );
7000                 else
7001                     MoveCursorUp( event.ShiftDown() );
7002                 break;
7003
7004             case WXK_DOWN:
7005                 if ( event.ControlDown() )
7006                     MoveCursorDownBlock( event.ShiftDown() );
7007                 else
7008                     MoveCursorDown( event.ShiftDown() );
7009                 break;
7010
7011             case WXK_LEFT:
7012                 if ( event.ControlDown() )
7013                     MoveCursorLeftBlock( event.ShiftDown() );
7014                 else
7015                     MoveCursorLeft( event.ShiftDown() );
7016                 break;
7017
7018             case WXK_RIGHT:
7019                 if ( event.ControlDown() )
7020                     MoveCursorRightBlock( event.ShiftDown() );
7021                 else
7022                     MoveCursorRight( event.ShiftDown() );
7023                 break;
7024
7025             case WXK_RETURN:
7026             case WXK_NUMPAD_ENTER:
7027                 if ( event.ControlDown() )
7028                 {
7029                     event.Skip();  // to let the edit control have the return
7030                 }
7031                 else
7032                 {
7033                     if ( GetGridCursorRow() < GetNumberRows()-1 )
7034                     {
7035                         MoveCursorDown( event.ShiftDown() );
7036                     }
7037                     else
7038                     {
7039                         // at the bottom of a column
7040                         DisableCellEditControl();
7041                     }
7042                 }
7043                 break;
7044
7045             case WXK_ESCAPE:
7046                 ClearSelection();
7047                 break;
7048
7049             case WXK_TAB:
7050                 if (event.ShiftDown())
7051                 {
7052                     if ( GetGridCursorCol() > 0 )
7053                     {
7054                         MoveCursorLeft( false );
7055                     }
7056                     else
7057                     {
7058                         // at left of grid
7059                         DisableCellEditControl();
7060                     }
7061                 }
7062                 else
7063                 {
7064                     if ( GetGridCursorCol() < GetNumberCols() - 1 )
7065                     {
7066                         MoveCursorRight( false );
7067                     }
7068                     else
7069                     {
7070                         // at right of grid
7071                         DisableCellEditControl();
7072                     }
7073                 }
7074                 break;
7075
7076             case WXK_HOME:
7077                 if ( event.ControlDown() )
7078                 {
7079                     MakeCellVisible( 0, 0 );
7080                     SetCurrentCell( 0, 0 );
7081                 }
7082                 else
7083                 {
7084                     event.Skip();
7085                 }
7086                 break;
7087
7088             case WXK_END:
7089                 if ( event.ControlDown() )
7090                 {
7091                     MakeCellVisible( m_numRows - 1, m_numCols - 1 );
7092                     SetCurrentCell( m_numRows - 1, m_numCols - 1 );
7093                 }
7094                 else
7095                 {
7096                     event.Skip();
7097                 }
7098                 break;
7099
7100             case WXK_PAGEUP:
7101                 MovePageUp();
7102                 break;
7103
7104             case WXK_PAGEDOWN:
7105                 MovePageDown();
7106                 break;
7107
7108             case WXK_SPACE:
7109                 if ( event.ControlDown() )
7110                 {
7111                     if ( m_selection )
7112                     {
7113                         m_selection->ToggleCellSelection(
7114                             m_currentCellCoords.GetRow(),
7115                             m_currentCellCoords.GetCol(),
7116                             event.ControlDown(),
7117                             event.ShiftDown(),
7118                             event.AltDown(),
7119                             event.MetaDown() );
7120                     }
7121                     break;
7122                 }
7123
7124                 if ( !IsEditable() )
7125                     MoveCursorRight( false );
7126                 else
7127                     event.Skip();
7128                 break;
7129
7130             default:
7131                 event.Skip();
7132                 break;
7133         }
7134     }
7135
7136     m_inOnKeyDown = false;
7137 }
7138
7139 void wxGrid::OnKeyUp( wxKeyEvent& event )
7140 {
7141     // try local handlers
7142     //
7143     if ( event.GetKeyCode() == WXK_SHIFT )
7144     {
7145         if ( m_selectingTopLeft != wxGridNoCellCoords &&
7146              m_selectingBottomRight != wxGridNoCellCoords )
7147         {
7148             if ( m_selection )
7149             {
7150                 m_selection->SelectBlock(
7151                     m_selectingTopLeft.GetRow(),
7152                     m_selectingTopLeft.GetCol(),
7153                     m_selectingBottomRight.GetRow(),
7154                     m_selectingBottomRight.GetCol(),
7155                     event.ControlDown(),
7156                     true,
7157                     event.AltDown(),
7158                     event.MetaDown() );
7159             }
7160         }
7161
7162         m_selectingTopLeft = wxGridNoCellCoords;
7163         m_selectingBottomRight = wxGridNoCellCoords;
7164         m_selectingKeyboard = wxGridNoCellCoords;
7165     }
7166 }
7167
7168 void wxGrid::OnChar( wxKeyEvent& event )
7169 {
7170     // is it possible to edit the current cell at all?
7171     if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
7172     {
7173         // yes, now check whether the cells editor accepts the key
7174         int row = m_currentCellCoords.GetRow();
7175         int col = m_currentCellCoords.GetCol();
7176         wxGridCellAttr *attr = GetCellAttr(row, col);
7177         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7178
7179         // <F2> is special and will always start editing, for
7180         // other keys - ask the editor itself
7181         if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
7182              || editor->IsAcceptedKey(event) )
7183         {
7184             // ensure cell is visble
7185             MakeCellVisible(row, col);
7186             EnableCellEditControl();
7187
7188             // a problem can arise if the cell is not completely
7189             // visible (even after calling MakeCellVisible the
7190             // control is not created and calling StartingKey will
7191             // crash the app
7192             if ( event.GetKeyCode() != WXK_F2 && editor->IsCreated() && m_cellEditCtrlEnabled )
7193                 editor->StartingKey(event);
7194         }
7195         else
7196         {
7197             event.Skip();
7198         }
7199
7200         editor->DecRef();
7201         attr->DecRef();
7202     }
7203     else
7204     {
7205         event.Skip();
7206     }
7207 }
7208
7209 void wxGrid::OnEraseBackground(wxEraseEvent&)
7210 {
7211 }
7212
7213 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
7214 {
7215     if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
7216     {
7217         // the event has been intercepted - do nothing
7218         return;
7219     }
7220
7221 #if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
7222     wxClientDC dc( m_gridWin );
7223     PrepareDC( dc );
7224 #endif
7225
7226     if ( m_currentCellCoords != wxGridNoCellCoords )
7227     {
7228         DisableCellEditControl();
7229
7230         if ( IsVisible( m_currentCellCoords, false ) )
7231         {
7232             wxRect r;
7233             r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
7234             if ( !m_gridLinesEnabled )
7235             {
7236                 r.x--;
7237                 r.y--;
7238                 r.width++;
7239                 r.height++;
7240             }
7241
7242             wxGridCellCoordsArray cells = CalcCellsExposed( r );
7243
7244             // Otherwise refresh redraws the highlight!
7245             m_currentCellCoords = coords;
7246
7247 #if defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
7248             m_gridWin->Refresh(true /*, & r */);
7249 #else
7250             DrawGridCellArea( dc, cells );
7251             DrawAllGridLines( dc, r );
7252 #endif
7253         }
7254     }
7255
7256     m_currentCellCoords = coords;
7257
7258     wxGridCellAttr *attr = GetCellAttr( coords );
7259 #if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
7260     DrawCellHighlight( dc, attr );
7261 #endif
7262     attr->DecRef();
7263 }
7264
7265 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
7266 {
7267     int temp;
7268     wxGridCellCoords updateTopLeft, updateBottomRight;
7269
7270     if ( m_selection )
7271     {
7272         if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
7273         {
7274             leftCol = 0;
7275             rightCol = GetNumberCols() - 1;
7276         }
7277         else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
7278         {
7279             topRow = 0;
7280             bottomRow = GetNumberRows() - 1;
7281         }
7282     }
7283
7284     if ( topRow > bottomRow )
7285     {
7286         temp = topRow;
7287         topRow = bottomRow;
7288         bottomRow = temp;
7289     }
7290
7291     if ( leftCol > rightCol )
7292     {
7293         temp = leftCol;
7294         leftCol = rightCol;
7295         rightCol = temp;
7296     }
7297
7298     updateTopLeft = wxGridCellCoords( topRow, leftCol );
7299     updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
7300
7301     // First the case that we selected a completely new area
7302     if ( m_selectingTopLeft == wxGridNoCellCoords ||
7303          m_selectingBottomRight == wxGridNoCellCoords )
7304     {
7305         wxRect rect;
7306         rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
7307                                   wxGridCellCoords ( bottomRow, rightCol ) );
7308         m_gridWin->Refresh( false, &rect );
7309     }
7310
7311     // Now handle changing an existing selection area.
7312     else if ( m_selectingTopLeft != updateTopLeft ||
7313               m_selectingBottomRight != updateBottomRight )
7314     {
7315         // Compute two optimal update rectangles:
7316         // Either one rectangle is a real subset of the
7317         // other, or they are (almost) disjoint!
7318         wxRect  rect[4];
7319         bool    need_refresh[4];
7320         need_refresh[0] =
7321         need_refresh[1] =
7322         need_refresh[2] =
7323         need_refresh[3] = false;
7324         int     i;
7325
7326         // Store intermediate values
7327         wxCoord oldLeft = m_selectingTopLeft.GetCol();
7328         wxCoord oldTop = m_selectingTopLeft.GetRow();
7329         wxCoord oldRight = m_selectingBottomRight.GetCol();
7330         wxCoord oldBottom = m_selectingBottomRight.GetRow();
7331
7332         // Determine the outer/inner coordinates.
7333         if (oldLeft > leftCol)
7334         {
7335             temp = oldLeft;
7336             oldLeft = leftCol;
7337             leftCol = temp;
7338         }
7339         if (oldTop > topRow )
7340         {
7341             temp = oldTop;
7342             oldTop = topRow;
7343             topRow = temp;
7344         }
7345         if (oldRight < rightCol )
7346         {
7347             temp = oldRight;
7348             oldRight = rightCol;
7349             rightCol = temp;
7350         }
7351         if (oldBottom < bottomRow)
7352         {
7353             temp = oldBottom;
7354             oldBottom = bottomRow;
7355             bottomRow = temp;
7356         }
7357
7358         // Now, either the stuff marked old is the outer
7359         // rectangle or we don't have a situation where one
7360         // is contained in the other.
7361
7362         if ( oldLeft < leftCol )
7363         {
7364             // Refresh the newly selected or deselected
7365             // area to the left of the old or new selection.
7366             need_refresh[0] = true;
7367             rect[0] = BlockToDeviceRect(
7368                 wxGridCellCoords( oldTop,  oldLeft ),
7369                 wxGridCellCoords( oldBottom, leftCol - 1 ) );
7370         }
7371
7372         if ( oldTop < topRow )
7373         {
7374             // Refresh the newly selected or deselected
7375             // area above the old or new selection.
7376             need_refresh[1] = true;
7377             rect[1] = BlockToDeviceRect(
7378                 wxGridCellCoords( oldTop, leftCol ),
7379                 wxGridCellCoords( topRow - 1, rightCol ) );
7380         }
7381
7382         if ( oldRight > rightCol )
7383         {
7384             // Refresh the newly selected or deselected
7385             // area to the right of the old or new selection.
7386             need_refresh[2] = true;
7387             rect[2] = BlockToDeviceRect(
7388                 wxGridCellCoords( oldTop, rightCol + 1 ),
7389                 wxGridCellCoords( oldBottom, oldRight ) );
7390         }
7391
7392         if ( oldBottom > bottomRow )
7393         {
7394             // Refresh the newly selected or deselected
7395             // area below the old or new selection.
7396             need_refresh[3] = true;
7397             rect[3] = BlockToDeviceRect(
7398                 wxGridCellCoords( bottomRow + 1, leftCol ),
7399                 wxGridCellCoords( oldBottom, rightCol ) );
7400         }
7401
7402         // various Refresh() calls
7403         for (i = 0; i < 4; i++ )
7404             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
7405                 m_gridWin->Refresh( false, &(rect[i]) );
7406     }
7407
7408     // change selection
7409     m_selectingTopLeft = updateTopLeft;
7410     m_selectingBottomRight = updateBottomRight;
7411 }
7412
7413 //
7414 // ------ functions to get/send data (see also public functions)
7415 //
7416
7417 bool wxGrid::GetModelValues()
7418 {
7419     // Hide the editor, so it won't hide a changed value.
7420     HideCellEditControl();
7421
7422     if ( m_table )
7423     {
7424         // all we need to do is repaint the grid
7425         //
7426         m_gridWin->Refresh();
7427         return true;
7428     }
7429
7430     return false;
7431 }
7432
7433 bool wxGrid::SetModelValues()
7434 {
7435     int row, col;
7436
7437     // Disable the editor, so it won't hide a changed value.
7438     // Do we also want to save the current value of the editor first?
7439     // I think so ...
7440     DisableCellEditControl();
7441
7442     if ( m_table )
7443     {
7444         for ( row = 0; row < m_numRows; row++ )
7445         {
7446             for ( col = 0; col < m_numCols; col++ )
7447             {
7448                 m_table->SetValue( row, col, GetCellValue(row, col) );
7449             }
7450         }
7451
7452         return true;
7453     }
7454
7455     return false;
7456 }
7457
7458 // Note - this function only draws cells that are in the list of
7459 // exposed cells (usually set from the update region by
7460 // CalcExposedCells)
7461 //
7462 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
7463 {
7464     if ( !m_numRows || !m_numCols )
7465         return;
7466
7467     int i, numCells = cells.GetCount();
7468     int row, col, cell_rows, cell_cols;
7469     wxGridCellCoordsArray redrawCells;
7470
7471     for ( i = numCells - 1; i >= 0; i-- )
7472     {
7473         row = cells[i].GetRow();
7474         col = cells[i].GetCol();
7475         GetCellSize( row, col, &cell_rows, &cell_cols );
7476
7477         // If this cell is part of a multicell block, find owner for repaint
7478         if ( cell_rows <= 0 || cell_cols <= 0 )
7479         {
7480             wxGridCellCoords cell( row + cell_rows, col + cell_cols );
7481             bool marked = false;
7482             for ( int j = 0; j < numCells; j++ )
7483             {
7484                 if ( cell == cells[j] )
7485                 {
7486                     marked = true;
7487                     break;
7488                 }
7489             }
7490
7491             if (!marked)
7492             {
7493                 int count = redrawCells.GetCount();
7494                 for (int j = 0; j < count; j++)
7495                 {
7496                     if ( cell == redrawCells[j] )
7497                     {
7498                         marked = true;
7499                         break;
7500                     }
7501                 }
7502
7503                 if (!marked)
7504                     redrawCells.Add( cell );
7505             }
7506
7507             // don't bother drawing this cell
7508             continue;
7509         }
7510
7511         // If this cell is empty, find cell to left that might want to overflow
7512         if (m_table && m_table->IsEmptyCell(row, col))
7513         {
7514             for ( int l = 0; l < cell_rows; l++ )
7515             {
7516                 // find a cell in this row to leave already marked for repaint
7517                 int left = col;
7518                 for (int k = 0; k < int(redrawCells.GetCount()); k++)
7519                     if ((redrawCells[k].GetCol() < left) &&
7520                         (redrawCells[k].GetRow() == row))
7521                     {
7522                         left = redrawCells[k].GetCol();
7523                     }
7524
7525                 if (left == col)
7526                     left = 0; // oh well
7527
7528                 for (int j = col - 1; j >= left; j--)
7529                 {
7530                     if (!m_table->IsEmptyCell(row + l, j))
7531                     {
7532                         if (GetCellOverflow(row + l, j))
7533                         {
7534                             wxGridCellCoords cell(row + l, j);
7535                             bool marked = false;
7536
7537                             for (int k = 0; k < numCells; k++)
7538                             {
7539                                 if ( cell == cells[k] )
7540                                 {
7541                                     marked = true;
7542                                     break;
7543                                 }
7544                             }
7545
7546                             if (!marked)
7547                             {
7548                                 int count = redrawCells.GetCount();
7549                                 for (int k = 0; k < count; k++)
7550                                 {
7551                                     if ( cell == redrawCells[k] )
7552                                     {
7553                                         marked = true;
7554                                         break;
7555                                     }
7556                                 }
7557                                 if (!marked)
7558                                     redrawCells.Add( cell );
7559                             }
7560                         }
7561                         break;
7562                     }
7563                 }
7564             }
7565         }
7566
7567         DrawCell( dc, cells[i] );
7568     }
7569
7570     numCells = redrawCells.GetCount();
7571
7572     for ( i = numCells - 1; i >= 0; i-- )
7573     {
7574         DrawCell( dc, redrawCells[i] );
7575     }
7576 }
7577
7578 void wxGrid::DrawGridSpace( wxDC& dc )
7579 {
7580   int cw, ch;
7581   m_gridWin->GetClientSize( &cw, &ch );
7582
7583   int right, bottom;
7584   CalcUnscrolledPosition( cw, ch, &right, &bottom );
7585
7586   int rightCol = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) : 0;
7587   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
7588
7589   if ( right > rightCol || bottom > bottomRow )
7590   {
7591       int left, top;
7592       CalcUnscrolledPosition( 0, 0, &left, &top );
7593
7594       dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
7595       dc.SetPen( *wxTRANSPARENT_PEN );
7596
7597       if ( right > rightCol )
7598       {
7599           dc.DrawRectangle( rightCol, top, right - rightCol, ch );
7600       }
7601
7602       if ( bottom > bottomRow )
7603       {
7604           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow );
7605       }
7606   }
7607 }
7608
7609 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
7610 {
7611     int row = coords.GetRow();
7612     int col = coords.GetCol();
7613
7614     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7615         return;
7616
7617     // we draw the cell border ourselves
7618 #if !WXGRID_DRAW_LINES
7619     if ( m_gridLinesEnabled )
7620         DrawCellBorder( dc, coords );
7621 #endif
7622
7623     wxGridCellAttr* attr = GetCellAttr(row, col);
7624
7625     bool isCurrent = coords == m_currentCellCoords;
7626
7627     wxRect rect = CellToRect( row, col );
7628
7629     // if the editor is shown, we should use it and not the renderer
7630     // Note: However, only if it is really _shown_, i.e. not hidden!
7631     if ( isCurrent && IsCellEditControlShown() )
7632     {
7633         // NB: this "#if..." is temporary and fixes a problem where the
7634         // edit control is erased by this code after being rendered.
7635         // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
7636         // implicitly, causing this out-of order render.
7637 #if !defined(__WXMAC__)
7638         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7639         editor->PaintBackground(rect, attr);
7640         editor->DecRef();
7641 #endif
7642     }
7643     else
7644     {
7645         // but all the rest is drawn by the cell renderer and hence may be customized
7646         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
7647         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
7648         renderer->DecRef();
7649     }
7650
7651     attr->DecRef();
7652 }
7653
7654 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
7655 {
7656     int row = m_currentCellCoords.GetRow();
7657     int col = m_currentCellCoords.GetCol();
7658
7659     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7660         return;
7661
7662     wxRect rect = CellToRect(row, col);
7663
7664     // hmmm... what could we do here to show that the cell is disabled?
7665     // for now, I just draw a thinner border than for the other ones, but
7666     // it doesn't look really good
7667
7668     int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
7669
7670     if (penWidth > 0)
7671     {
7672         // The center of the drawn line is where the position/width/height of
7673         // the rectangle is actually at (on wxMSW at least), so the
7674         // size of the rectangle is reduced to compensate for the thickness of
7675         // the line. If this is too strange on non-wxMSW platforms then
7676         // please #ifdef this appropriately.
7677         rect.x += penWidth / 2;
7678         rect.y += penWidth / 2;
7679         rect.width -= penWidth - 1;
7680         rect.height -= penWidth - 1;
7681
7682         // Now draw the rectangle
7683         // use the cellHighlightColour if the cell is inside a selection, this
7684         // will ensure the cell is always visible.
7685         dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground : m_cellHighlightColour, penWidth, wxSOLID));
7686         dc.SetBrush(*wxTRANSPARENT_BRUSH);
7687         dc.DrawRectangle(rect);
7688     }
7689
7690 #if 0
7691         // VZ: my experiments with 3D borders...
7692
7693         // how to properly set colours for arbitrary bg?
7694         wxCoord x1 = rect.x,
7695                 y1 = rect.y,
7696                 x2 = rect.x + rect.width - 1,
7697                 y2 = rect.y + rect.height - 1;
7698
7699         dc.SetPen(*wxWHITE_PEN);
7700         dc.DrawLine(x1, y1, x2, y1);
7701         dc.DrawLine(x1, y1, x1, y2);
7702
7703         dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
7704         dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2);
7705
7706         dc.SetPen(*wxBLACK_PEN);
7707         dc.DrawLine(x1, y2, x2, y2);
7708         dc.DrawLine(x2, y1, x2, y2 + 1);
7709 #endif
7710 }
7711
7712 wxPen wxGrid::GetDefaultGridLinePen()
7713 {
7714     return wxPen(GetGridLineColour(), 1, wxSOLID);
7715 }
7716
7717 wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
7718 {
7719     return GetDefaultGridLinePen();
7720 }
7721
7722 wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
7723 {
7724     return GetDefaultGridLinePen();
7725 }
7726
7727 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
7728 {
7729     int row = coords.GetRow();
7730     int col = coords.GetCol();
7731     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7732         return;
7733
7734
7735     wxRect rect = CellToRect( row, col );
7736
7737     // right hand border
7738     dc.SetPen( GetColGridLinePen(col) );
7739     dc.DrawLine( rect.x + rect.width, rect.y,
7740                  rect.x + rect.width, rect.y + rect.height + 1 );
7741
7742     // bottom border
7743     dc.SetPen( GetRowGridLinePen(row) );
7744     dc.DrawLine( rect.x, rect.y + rect.height,
7745                  rect.x + rect.width, rect.y + rect.height);
7746 }
7747
7748 void wxGrid::DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells)
7749 {
7750     // This if block was previously in wxGrid::OnPaint but that doesn't
7751     // seem to get called under wxGTK - MB
7752     //
7753     if ( m_currentCellCoords == wxGridNoCellCoords &&
7754          m_numRows && m_numCols )
7755     {
7756         m_currentCellCoords.Set(0, 0);
7757     }
7758
7759     if ( IsCellEditControlShown() )
7760     {
7761         // don't show highlight when the edit control is shown
7762         return;
7763     }
7764
7765     // if the active cell was repainted, repaint its highlight too because it
7766     // might have been damaged by the grid lines
7767     size_t count = cells.GetCount();
7768     for ( size_t n = 0; n < count; n++ )
7769     {
7770         if ( cells[n] == m_currentCellCoords )
7771         {
7772             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7773             DrawCellHighlight(dc, attr);
7774             attr->DecRef();
7775
7776             break;
7777         }
7778     }
7779 }
7780
7781 // TODO: remove this ???
7782 // This is used to redraw all grid lines e.g. when the grid line colour
7783 // has been changed
7784 //
7785 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
7786 {
7787 #if !WXGRID_DRAW_LINES
7788     return;
7789 #endif
7790
7791     if ( !m_gridLinesEnabled || !m_numRows || !m_numCols )
7792          return;
7793
7794     int top, bottom, left, right;
7795
7796 #if 0  //#ifndef __WXGTK__
7797     if (reg.IsEmpty())
7798     {
7799       int cw, ch;
7800       m_gridWin->GetClientSize(&cw, &ch);
7801
7802       // virtual coords of visible area
7803       //
7804       CalcUnscrolledPosition( 0, 0, &left, &top );
7805       CalcUnscrolledPosition( cw, ch, &right, &bottom );
7806     }
7807     else
7808     {
7809       wxCoord x, y, w, h;
7810       reg.GetBox(x, y, w, h);
7811       CalcUnscrolledPosition( x, y, &left, &top );
7812       CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
7813     }
7814 #else
7815       int cw, ch;
7816       m_gridWin->GetClientSize(&cw, &ch);
7817       CalcUnscrolledPosition( 0, 0, &left, &top );
7818       CalcUnscrolledPosition( cw, ch, &right, &bottom );
7819 #endif
7820
7821     // avoid drawing grid lines past the last row and col
7822     //
7823     right = wxMin( right, GetColRight(GetColAt( m_numCols - 1 )) );
7824     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
7825
7826     // no gridlines inside multicells, clip them out
7827     int leftCol = GetColPos( internalXToCol(left) );
7828     int topRow = internalYToRow(top);
7829     int rightCol = GetColPos( internalXToCol(right) );
7830     int bottomRow = internalYToRow(bottom);
7831
7832 #if !defined(__WXMAC__) || wxMAC_USE_CORE_GRAPHICS
7833     wxRegion clippedcells(0, 0, cw, ch);
7834
7835     int i, j, cell_rows, cell_cols;
7836     wxRect rect;
7837
7838     for (j=topRow; j<=bottomRow; j++)
7839     {
7840         int colPos;
7841         for (colPos=leftCol; colPos<=rightCol; colPos++)
7842         {
7843             i = GetColAt( colPos );
7844
7845             GetCellSize( j, i, &cell_rows, &cell_cols );
7846             if ((cell_rows > 1) || (cell_cols > 1))
7847             {
7848                 rect = CellToRect(j,i);
7849                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7850                 clippedcells.Subtract(rect);
7851             }
7852             else if ((cell_rows < 0) || (cell_cols < 0))
7853             {
7854                 rect = CellToRect(j + cell_rows, i + cell_cols);
7855                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7856                 clippedcells.Subtract(rect);
7857             }
7858         }
7859     }
7860 #else
7861     wxRegion clippedcells( left, top, right - left, bottom - top );
7862
7863     int i, j, cell_rows, cell_cols;
7864     wxRect rect;
7865
7866     for (j=topRow; j<=bottomRow; j++)
7867     {
7868         for (i=leftCol; i<=rightCol; i++)
7869         {
7870             GetCellSize( j, i, &cell_rows, &cell_cols );
7871             if ((cell_rows > 1) || (cell_cols > 1))
7872             {
7873                 rect = CellToRect(j, i);
7874                 clippedcells.Subtract(rect);
7875             }
7876             else if ((cell_rows < 0) || (cell_cols < 0))
7877             {
7878                 rect = CellToRect(j + cell_rows, i + cell_cols);
7879                 clippedcells.Subtract(rect);
7880             }
7881         }
7882     }
7883 #endif
7884
7885     dc.SetClippingRegion( clippedcells );
7886
7887
7888     // horizontal grid lines
7889     //
7890     // already declared above - int i;
7891     for ( i = internalYToRow(top); i < m_numRows; i++ )
7892     {
7893         int bot = GetRowBottom(i) - 1;
7894
7895         if ( bot > bottom )
7896         {
7897             break;
7898         }
7899
7900         if ( bot >= top )
7901         {
7902             dc.SetPen( GetRowGridLinePen(i) );
7903             dc.DrawLine( left, bot, right, bot );
7904         }
7905     }
7906
7907     // vertical grid lines
7908     //
7909     int colPos;
7910     for ( colPos = leftCol; colPos < m_numCols; colPos++ )
7911     {
7912         i = GetColAt( colPos );
7913
7914         int colRight = GetColRight(i);
7915 #ifdef __WXGTK__
7916         if (GetLayoutDirection() != wxLayout_RightToLeft)
7917 #endif
7918             colRight--;
7919
7920         if ( colRight > right )
7921         {
7922             break;
7923         }
7924
7925         if ( colRight >= left )
7926         {
7927             dc.SetPen( GetColGridLinePen(i) );
7928             dc.DrawLine( colRight, top, colRight, bottom );
7929         }
7930     }
7931
7932     dc.DestroyClippingRegion();
7933 }
7934
7935 void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
7936 {
7937     if ( !m_numRows )
7938         return;
7939
7940     size_t i;
7941     size_t numLabels = rows.GetCount();
7942
7943     for ( i = 0; i < numLabels; i++ )
7944     {
7945         DrawRowLabel( dc, rows[i] );
7946     }
7947 }
7948
7949 void wxGrid::DrawRowLabel( wxDC& dc, int row )
7950 {
7951     if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
7952         return;
7953
7954     wxRect rect;
7955
7956 #if 0
7957 def __WXGTK20__
7958     rect.SetX( 1 );
7959     rect.SetY( GetRowTop(row) + 1 );
7960     rect.SetWidth( m_rowLabelWidth - 2 );
7961     rect.SetHeight( GetRowHeight(row) - 2 );
7962
7963     CalcScrolledPosition( 0, rect.y, NULL, &rect.y );
7964
7965     wxWindowDC *win_dc = (wxWindowDC*) &dc;
7966
7967     wxRendererNative::Get().DrawHeaderButton( win_dc->m_owner, dc, rect, 0 );
7968 #else
7969     int rowTop = GetRowTop(row),
7970         rowBottom = GetRowBottom(row) - 1;
7971
7972     dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID) );
7973     dc.DrawLine( m_rowLabelWidth - 1, rowTop, m_rowLabelWidth - 1, rowBottom );
7974     dc.DrawLine( 0, rowTop, 0, rowBottom );
7975     dc.DrawLine( 0, rowBottom, m_rowLabelWidth, rowBottom );
7976
7977     dc.SetPen( *wxWHITE_PEN );
7978     dc.DrawLine( 1, rowTop, 1, rowBottom );
7979     dc.DrawLine( 1, rowTop, m_rowLabelWidth - 1, rowTop );
7980 #endif
7981
7982     dc.SetBackgroundMode( wxTRANSPARENT );
7983     dc.SetTextForeground( GetLabelTextColour() );
7984     dc.SetFont( GetLabelFont() );
7985
7986     int hAlign, vAlign;
7987     GetRowLabelAlignment( &hAlign, &vAlign );
7988
7989     rect.SetX( 2 );
7990     rect.SetY( GetRowTop(row) + 2 );
7991     rect.SetWidth( m_rowLabelWidth - 4 );
7992     rect.SetHeight( GetRowHeight(row) - 4 );
7993     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
7994 }
7995
7996 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
7997 {
7998     if ( !m_numCols )
7999         return;
8000
8001     size_t i;
8002     size_t numLabels = cols.GetCount();
8003
8004     for ( i = 0; i < numLabels; i++ )
8005     {
8006         DrawColLabel( dc, cols[i] );
8007     }
8008 }
8009
8010 void wxGrid::DrawColLabel( wxDC& dc, int col )
8011 {
8012     if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
8013         return;
8014
8015     int colLeft = GetColLeft(col);
8016
8017     wxRect rect;
8018
8019 #if 0
8020 def __WXGTK20__
8021     rect.SetX( colLeft + 1 );
8022     rect.SetY( 1 );
8023     rect.SetWidth( GetColWidth(col) - 2 );
8024     rect.SetHeight( m_colLabelHeight - 2 );
8025
8026     wxWindowDC *win_dc = (wxWindowDC*) &dc;
8027
8028     wxRendererNative::Get().DrawHeaderButton( win_dc->m_owner, dc, rect, 0 );
8029 #else
8030     int colRight = GetColRight(col) - 1;
8031
8032     dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID) );
8033     dc.DrawLine( colRight, 0, colRight, m_colLabelHeight - 1 );
8034     dc.DrawLine( colLeft, 0, colRight, 0 );
8035     dc.DrawLine( colLeft, m_colLabelHeight - 1,
8036                  colRight + 1, m_colLabelHeight - 1 );
8037
8038     dc.SetPen( *wxWHITE_PEN );
8039     dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight - 1 );
8040     dc.DrawLine( colLeft, 1, colRight, 1 );
8041 #endif
8042
8043     dc.SetBackgroundMode( wxTRANSPARENT );
8044     dc.SetTextForeground( GetLabelTextColour() );
8045     dc.SetFont( GetLabelFont() );
8046
8047     int hAlign, vAlign, orient;
8048     GetColLabelAlignment( &hAlign, &vAlign );
8049     orient = GetColLabelTextOrientation();
8050
8051     rect.SetX( colLeft + 2 );
8052     rect.SetY( 2 );
8053     rect.SetWidth( GetColWidth(col) - 4 );
8054     rect.SetHeight( m_colLabelHeight - 4 );
8055     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign, orient );
8056 }
8057
8058 void wxGrid::DrawTextRectangle( wxDC& dc,
8059                                 const wxString& value,
8060                                 const wxRect& rect,
8061                                 int horizAlign,
8062                                 int vertAlign,
8063                                 int textOrientation )
8064 {
8065     wxArrayString lines;
8066
8067     StringToLines( value, lines );
8068
8069     // Forward to new API.
8070     DrawTextRectangle( dc,
8071         lines,
8072         rect,
8073         horizAlign,
8074         vertAlign,
8075         textOrientation );
8076 }
8077
8078 // VZ: this should be replaced with wxDC::DrawLabel() to which we just have to
8079 //     add textOrientation support
8080 void wxGrid::DrawTextRectangle(wxDC& dc,
8081                                const wxArrayString& lines,
8082                                const wxRect& rect,
8083                                int horizAlign,
8084                                int vertAlign,
8085                                int textOrientation)
8086 {
8087     if ( lines.empty() )
8088         return;
8089
8090     wxDCClipper clip(dc, rect);
8091
8092     long textWidth,
8093          textHeight;
8094
8095     if ( textOrientation == wxHORIZONTAL )
8096         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
8097     else
8098         GetTextBoxSize( dc, lines, &textHeight, &textWidth );
8099
8100     int x = 0,
8101         y = 0;
8102     switch ( vertAlign )
8103     {
8104         case wxALIGN_BOTTOM:
8105             if ( textOrientation == wxHORIZONTAL )
8106                 y = rect.y + (rect.height - textHeight - 1);
8107             else
8108                 x = rect.x + rect.width - textWidth;
8109             break;
8110
8111         case wxALIGN_CENTRE:
8112             if ( textOrientation == wxHORIZONTAL )
8113                 y = rect.y + ((rect.height - textHeight) / 2);
8114             else
8115                 x = rect.x + ((rect.width - textWidth) / 2);
8116             break;
8117
8118         case wxALIGN_TOP:
8119         default:
8120             if ( textOrientation == wxHORIZONTAL )
8121                 y = rect.y + 1;
8122             else
8123                 x = rect.x + 1;
8124             break;
8125     }
8126
8127     // Align each line of a multi-line label
8128     size_t nLines = lines.GetCount();
8129     for ( size_t l = 0; l < nLines; l++ )
8130     {
8131         const wxString& line = lines[l];
8132
8133         if ( line.empty() )
8134         {
8135             *(textOrientation == wxHORIZONTAL ? &y : &x) += dc.GetCharHeight();
8136             continue;
8137         }
8138
8139         wxCoord lineWidth = 0,
8140              lineHeight = 0;
8141         dc.GetTextExtent(line, &lineWidth, &lineHeight);
8142
8143         switch ( horizAlign )
8144         {
8145             case wxALIGN_RIGHT:
8146                 if ( textOrientation == wxHORIZONTAL )
8147                     x = rect.x + (rect.width - lineWidth - 1);
8148                 else
8149                     y = rect.y + lineWidth + 1;
8150                 break;
8151
8152             case wxALIGN_CENTRE:
8153                 if ( textOrientation == wxHORIZONTAL )
8154                     x = rect.x + ((rect.width - lineWidth) / 2);
8155                 else
8156                     y = rect.y + rect.height - ((rect.height - lineWidth) / 2);
8157                 break;
8158
8159             case wxALIGN_LEFT:
8160             default:
8161                 if ( textOrientation == wxHORIZONTAL )
8162                     x = rect.x + 1;
8163                 else
8164                     y = rect.y + rect.height - 1;
8165                 break;
8166         }
8167
8168         if ( textOrientation == wxHORIZONTAL )
8169         {
8170             dc.DrawText( line, x, y );
8171             y += lineHeight;
8172         }
8173         else
8174         {
8175             dc.DrawRotatedText( line, x, y, 90.0 );
8176             x += lineHeight;
8177         }
8178     }
8179 }
8180
8181 // Split multi-line text up into an array of strings.
8182 // Any existing contents of the string array are preserved.
8183 //
8184 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
8185 {
8186     int startPos = 0;
8187     int pos;
8188     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
8189     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
8190
8191     while ( startPos < (int)tVal.length() )
8192     {
8193         pos = tVal.Mid(startPos).Find( eol );
8194         if ( pos < 0 )
8195         {
8196             break;
8197         }
8198         else if ( pos == 0 )
8199         {
8200             lines.Add( wxEmptyString );
8201         }
8202         else
8203         {
8204             lines.Add( value.Mid(startPos, pos) );
8205         }
8206
8207         startPos += pos + 1;
8208     }
8209
8210     if ( startPos < (int)value.length() )
8211     {
8212         lines.Add( value.Mid( startPos ) );
8213     }
8214 }
8215
8216 void wxGrid::GetTextBoxSize( const wxDC& dc,
8217                              const wxArrayString& lines,
8218                              long *width, long *height ) const
8219 {
8220     wxCoord w = 0;
8221     wxCoord h = 0;
8222     wxCoord lineW = 0, lineH = 0;
8223
8224     size_t i;
8225     for ( i = 0; i < lines.GetCount(); i++ )
8226     {
8227         dc.GetTextExtent( lines[i], &lineW, &lineH );
8228         w = wxMax( w, lineW );
8229         h += lineH;
8230     }
8231
8232     *width = w;
8233     *height = h;
8234 }
8235
8236 //
8237 // ------ Batch processing.
8238 //
8239 void wxGrid::EndBatch()
8240 {
8241     if ( m_batchCount > 0 )
8242     {
8243         m_batchCount--;
8244         if ( !m_batchCount )
8245         {
8246             CalcDimensions();
8247             m_rowLabelWin->Refresh();
8248             m_colLabelWin->Refresh();
8249             m_cornerLabelWin->Refresh();
8250             m_gridWin->Refresh();
8251         }
8252     }
8253 }
8254
8255 // Use this, rather than wxWindow::Refresh(), to force an immediate
8256 // repainting of the grid. Has no effect if you are already inside a
8257 // BeginBatch / EndBatch block.
8258 //
8259 void wxGrid::ForceRefresh()
8260 {
8261     BeginBatch();
8262     EndBatch();
8263 }
8264
8265 bool wxGrid::Enable(bool enable)
8266 {
8267     if ( !wxScrolledWindow::Enable(enable) )
8268         return false;
8269
8270     // redraw in the new state
8271     m_gridWin->Refresh();
8272
8273     return true;
8274 }
8275
8276 //
8277 // ------ Edit control functions
8278 //
8279
8280 void wxGrid::EnableEditing( bool edit )
8281 {
8282     // TODO: improve this ?
8283     //
8284     if ( edit != m_editable )
8285     {
8286         if (!edit)
8287             EnableCellEditControl(edit);
8288         m_editable = edit;
8289     }
8290 }
8291
8292 void wxGrid::EnableCellEditControl( bool enable )
8293 {
8294     if (! m_editable)
8295         return;
8296
8297     if ( enable != m_cellEditCtrlEnabled )
8298     {
8299         if ( enable )
8300         {
8301             if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
8302                 return;
8303
8304             // this should be checked by the caller!
8305             wxASSERT_MSG( CanEnableCellControl(), _T("can't enable editing for this cell!") );
8306
8307             // do it before ShowCellEditControl()
8308             m_cellEditCtrlEnabled = enable;
8309
8310             ShowCellEditControl();
8311         }
8312         else
8313         {
8314             //FIXME:add veto support
8315             SendEvent( wxEVT_GRID_EDITOR_HIDDEN );
8316
8317             HideCellEditControl();
8318             SaveEditControlValue();
8319
8320             // do it after HideCellEditControl()
8321             m_cellEditCtrlEnabled = enable;
8322         }
8323     }
8324 }
8325
8326 bool wxGrid::IsCurrentCellReadOnly() const
8327 {
8328     // const_cast
8329     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
8330     bool readonly = attr->IsReadOnly();
8331     attr->DecRef();
8332
8333     return readonly;
8334 }
8335
8336 bool wxGrid::CanEnableCellControl() const
8337 {
8338     return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
8339         !IsCurrentCellReadOnly();
8340 }
8341
8342 bool wxGrid::IsCellEditControlEnabled() const
8343 {
8344     // the cell edit control might be disable for all cells or just for the
8345     // current one if it's read only
8346     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
8347 }
8348
8349 bool wxGrid::IsCellEditControlShown() const
8350 {
8351     bool isShown = false;
8352
8353     if ( m_cellEditCtrlEnabled )
8354     {
8355         int row = m_currentCellCoords.GetRow();
8356         int col = m_currentCellCoords.GetCol();
8357         wxGridCellAttr* attr = GetCellAttr(row, col);
8358         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
8359         attr->DecRef();
8360
8361         if ( editor )
8362         {
8363             if ( editor->IsCreated() )
8364             {
8365                 isShown = editor->GetControl()->IsShown();
8366             }
8367
8368             editor->DecRef();
8369         }
8370     }
8371
8372     return isShown;
8373 }
8374
8375 void wxGrid::ShowCellEditControl()
8376 {
8377     if ( IsCellEditControlEnabled() )
8378     {
8379         if ( !IsVisible( m_currentCellCoords, false ) )
8380         {
8381             m_cellEditCtrlEnabled = false;
8382             return;
8383         }
8384         else
8385         {
8386             wxRect rect = CellToRect( m_currentCellCoords );
8387             int row = m_currentCellCoords.GetRow();
8388             int col = m_currentCellCoords.GetCol();
8389
8390             // if this is part of a multicell, find owner (topleft)
8391             int cell_rows, cell_cols;
8392             GetCellSize( row, col, &cell_rows, &cell_cols );
8393             if ( cell_rows <= 0 || cell_cols <= 0 )
8394             {
8395                 row += cell_rows;
8396                 col += cell_cols;
8397                 m_currentCellCoords.SetRow( row );
8398                 m_currentCellCoords.SetCol( col );
8399             }
8400
8401             // erase the highlight and the cell contents because the editor
8402             // might not cover the entire cell
8403             wxClientDC dc( m_gridWin );
8404             PrepareDC( dc );
8405             wxGridCellAttr* attr = GetCellAttr(row, col);
8406             dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
8407             dc.SetPen(*wxTRANSPARENT_PEN);
8408             dc.DrawRectangle(rect);
8409
8410             // convert to scrolled coords
8411             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
8412
8413             int nXMove = 0;
8414             if (rect.x < 0)
8415                 nXMove = rect.x;
8416
8417             // cell is shifted by one pixel
8418             // However, don't allow x or y to become negative
8419             // since the SetSize() method interprets that as
8420             // "don't change."
8421             if (rect.x > 0)
8422                 rect.x--;
8423             if (rect.y > 0)
8424                 rect.y--;
8425
8426             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8427             if ( !editor->IsCreated() )
8428             {
8429                 editor->Create(m_gridWin, wxID_ANY,
8430                                new wxGridCellEditorEvtHandler(this, editor));
8431
8432                 wxGridEditorCreatedEvent evt(GetId(),
8433                                              wxEVT_GRID_EDITOR_CREATED,
8434                                              this,
8435                                              row,
8436                                              col,
8437                                              editor->GetControl());
8438                 GetEventHandler()->ProcessEvent(evt);
8439             }
8440
8441             // resize editor to overflow into righthand cells if allowed
8442             int maxWidth = rect.width;
8443             wxString value = GetCellValue(row, col);
8444             if ( (value != wxEmptyString) && (attr->GetOverflow()) )
8445             {
8446                 int y;
8447                 GetTextExtent(value, &maxWidth, &y, NULL, NULL, &attr->GetFont());
8448                 if (maxWidth < rect.width)
8449                     maxWidth = rect.width;
8450             }
8451
8452             int client_right = m_gridWin->GetClientSize().GetWidth();
8453             if (rect.x + maxWidth > client_right)
8454                 maxWidth = client_right - rect.x;
8455
8456             if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
8457             {
8458                 GetCellSize( row, col, &cell_rows, &cell_cols );
8459                 // may have changed earlier
8460                 for (int i = col + cell_cols; i < m_numCols; i++)
8461                 {
8462                     int c_rows, c_cols;
8463                     GetCellSize( row, i, &c_rows, &c_cols );
8464
8465                     // looks weird going over a multicell
8466                     if (m_table->IsEmptyCell( row, i ) &&
8467                             (rect.width < maxWidth) && (c_rows == 1))
8468                     {
8469                         rect.width += GetColWidth( i );
8470                     }
8471                     else
8472                         break;
8473                 }
8474
8475                 if (rect.GetRight() > client_right)
8476                     rect.SetRight( client_right - 1 );
8477             }
8478
8479             editor->SetCellAttr( attr );
8480             editor->SetSize( rect );
8481             if (nXMove != 0)
8482                 editor->GetControl()->Move(
8483                     editor->GetControl()->GetPosition().x + nXMove,
8484                     editor->GetControl()->GetPosition().y );
8485             editor->Show( true, attr );
8486
8487             // recalc dimensions in case we need to
8488             // expand the scrolled window to account for editor
8489             CalcDimensions();
8490
8491             editor->BeginEdit(row, col, this);
8492             editor->SetCellAttr(NULL);
8493
8494             editor->DecRef();
8495             attr->DecRef();
8496         }
8497     }
8498 }
8499
8500 void wxGrid::HideCellEditControl()
8501 {
8502     if ( IsCellEditControlEnabled() )
8503     {
8504         int row = m_currentCellCoords.GetRow();
8505         int col = m_currentCellCoords.GetCol();
8506
8507         wxGridCellAttr *attr = GetCellAttr(row, col);
8508         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
8509         editor->Show( false );
8510         editor->DecRef();
8511         attr->DecRef();
8512
8513         m_gridWin->SetFocus();
8514
8515         // refresh whole row to the right
8516         wxRect rect( CellToRect(row, col) );
8517         CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
8518         rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
8519
8520 #ifdef __WXMAC__
8521         // ensure that the pixels under the focus ring get refreshed as well
8522         rect.Inflate(10, 10);
8523 #endif
8524
8525         m_gridWin->Refresh( false, &rect );
8526     }
8527 }
8528
8529 void wxGrid::SaveEditControlValue()
8530 {
8531     if ( IsCellEditControlEnabled() )
8532     {
8533         int row = m_currentCellCoords.GetRow();
8534         int col = m_currentCellCoords.GetCol();
8535
8536         wxString oldval = GetCellValue(row, col);
8537
8538         wxGridCellAttr* attr = GetCellAttr(row, col);
8539         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8540         bool changed = editor->EndEdit(row, col, this);
8541
8542         editor->DecRef();
8543         attr->DecRef();
8544
8545         if (changed)
8546         {
8547             if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
8548                        m_currentCellCoords.GetRow(),
8549                        m_currentCellCoords.GetCol() ) < 0 )
8550             {
8551                 // Event has been vetoed, set the data back.
8552                 SetCellValue(row, col, oldval);
8553             }
8554         }
8555     }
8556 }
8557
8558 //
8559 // ------ Grid location functions
8560 //  Note that all of these functions work with the logical coordinates of
8561 //  grid cells and labels so you will need to convert from device
8562 //  coordinates for mouse events etc.
8563 //
8564
8565 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords ) const
8566 {
8567     int row = YToRow(y);
8568     int col = XToCol(x);
8569
8570     if ( row == -1 || col == -1 )
8571     {
8572         coords = wxGridNoCellCoords;
8573     }
8574     else
8575     {
8576         coords.Set( row, col );
8577     }
8578 }
8579
8580 // Internal Helper function for computing row or column from some
8581 // (unscrolled) coordinate value, using either
8582 // m_defaultRowHeight/m_defaultColWidth or binary search on array
8583 // of m_rowBottoms/m_ColRights to speed up the search!
8584
8585 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
8586                            const wxArrayInt& BorderArray, int nMax,
8587                            bool clipToMinMax)
8588 {
8589     if (coord < 0)
8590         return clipToMinMax && (nMax > 0) ? 0 : -1;
8591
8592     if (!defaultDist)
8593         defaultDist = 1;
8594
8595     size_t i_max = coord / defaultDist,
8596            i_min = 0;
8597
8598     if (BorderArray.IsEmpty())
8599     {
8600         if ((int) i_max < nMax)
8601             return i_max;
8602         return clipToMinMax ? nMax - 1 : -1;
8603     }
8604
8605     if ( i_max >= BorderArray.GetCount())
8606     {
8607         i_max = BorderArray.GetCount() - 1;
8608     }
8609     else
8610     {
8611         if ( coord >= BorderArray[i_max])
8612         {
8613             i_min = i_max;
8614             if (minDist)
8615                 i_max = coord / minDist;
8616             else
8617                 i_max =  BorderArray.GetCount() - 1;
8618         }
8619
8620         if ( i_max >= BorderArray.GetCount())
8621             i_max = BorderArray.GetCount() - 1;
8622     }
8623
8624     if ( coord >= BorderArray[i_max])
8625         return clipToMinMax ? (int)i_max : -1;
8626     if ( coord < BorderArray[0] )
8627         return 0;
8628
8629     while ( i_max - i_min > 0 )
8630     {
8631         wxCHECK_MSG(BorderArray[i_min] <= coord && coord < BorderArray[i_max],
8632                     0, _T("wxGrid: internal error in CoordToRowOrCol"));
8633         if (coord >=  BorderArray[ i_max - 1])
8634             return i_max;
8635         else
8636             i_max--;
8637         int median = i_min + (i_max - i_min + 1) / 2;
8638         if (coord < BorderArray[median])
8639             i_max = median;
8640         else
8641             i_min = median;
8642     }
8643
8644     return i_max;
8645 }
8646
8647 int wxGrid::YToRow( int y ) const
8648 {
8649     return CoordToRowOrCol(y, m_defaultRowHeight,
8650                            m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
8651 }
8652
8653 int wxGrid::XToCol( int x, bool clipToMinMax ) const
8654 {
8655     if (x < 0)
8656         return clipToMinMax && (m_numCols > 0) ? GetColAt( 0 ) : -1;
8657
8658     wxASSERT_MSG(m_defaultColWidth > 0, wxT("Default column width can not be zero"));
8659
8660     int maxPos = x / m_defaultColWidth;
8661     int minPos = 0;
8662
8663     if (m_colRights.IsEmpty())
8664     {
8665         if(maxPos < m_numCols)
8666             return GetColAt( maxPos );
8667         return clipToMinMax ? GetColAt( m_numCols - 1 ) : -1;
8668     }
8669
8670     if ( maxPos >= m_numCols)
8671         maxPos = m_numCols - 1;
8672     else
8673     {
8674         if ( x >= m_colRights[GetColAt( maxPos )])
8675         {
8676             minPos = maxPos;
8677             if (m_minAcceptableColWidth)
8678                 maxPos = x / m_minAcceptableColWidth;
8679             else
8680                 maxPos =  m_numCols - 1;
8681         }
8682         if ( maxPos >= m_numCols)
8683             maxPos = m_numCols - 1;
8684     }
8685
8686     //X is beyond the last column
8687     if ( x >= m_colRights[GetColAt( maxPos )])
8688         return clipToMinMax ? GetColAt( maxPos ) : -1;
8689
8690     //X is before the first column
8691     if ( x < m_colRights[GetColAt( 0 )] )
8692         return GetColAt( 0 );
8693
8694     //Perform a binary search
8695     while ( maxPos - minPos > 0 )
8696     {
8697         wxCHECK_MSG(m_colRights[GetColAt( minPos )] <= x && x < m_colRights[GetColAt( maxPos )],
8698                     0, _T("wxGrid: internal error in XToCol"));
8699
8700         if (x >=  m_colRights[GetColAt( maxPos - 1 )])
8701             return GetColAt( maxPos );
8702         else
8703             maxPos--;
8704         int median = minPos + (maxPos - minPos + 1) / 2;
8705         if (x < m_colRights[GetColAt( median )])
8706             maxPos = median;
8707         else
8708             minPos = median;
8709     }
8710     return GetColAt( maxPos );
8711 }
8712
8713 // return the row number that that the y coord is near
8714 //  the edge of, or -1 if not near an edge.
8715 // coords can only possibly be near an edge if
8716 //    (a) the row/column is large enough to still allow for an "inner" area
8717 //        that is _not_ nead the edge (i.e., if the height/width is smaller
8718 //        than WXGRID_LABEL_EDGE_ZONE, coords are _never_ considered to be
8719 //        near the edge).
8720 //   and
8721 //    (b) resizing rows/columns (the thing for which edge detection is
8722 //        relevant at all) is enabled.
8723 //
8724 int wxGrid::YToEdgeOfRow( int y ) const
8725 {
8726     int i;
8727     i = internalYToRow(y);
8728
8729     if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE && CanDragRowSize() )
8730     {
8731         // We know that we are in row i, test whether we are
8732         // close enough to lower or upper border, respectively.
8733         if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
8734             return i;
8735         else if ( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
8736             return i - 1;
8737     }
8738
8739     return -1;
8740 }
8741
8742 // return the col number that that the x coord is near the edge of, or
8743 // -1 if not near an edge
8744 // See comment at YToEdgeOfRow for conditions on edge detection.
8745 //
8746 int wxGrid::XToEdgeOfCol( int x ) const
8747 {
8748     int i;
8749     i = internalXToCol(x);
8750
8751     if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE && CanDragColSize() )
8752     {
8753         // We know that we are in column i; test whether we are
8754         // close enough to right or left border, respectively.
8755         if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
8756             return i;
8757         else if ( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
8758             return i - 1;
8759     }
8760
8761     return -1;
8762 }
8763
8764 wxRect wxGrid::CellToRect( int row, int col ) const
8765 {
8766     wxRect rect( -1, -1, -1, -1 );
8767
8768     if ( row >= 0 && row < m_numRows &&
8769          col >= 0 && col < m_numCols )
8770     {
8771         int i, cell_rows, cell_cols;
8772         rect.width = rect.height = 0;
8773         GetCellSize( row, col, &cell_rows, &cell_cols );
8774         // if negative then find multicell owner
8775         if (cell_rows < 0)
8776             row += cell_rows;
8777         if (cell_cols < 0)
8778              col += cell_cols;
8779         GetCellSize( row, col, &cell_rows, &cell_cols );
8780
8781         rect.x = GetColLeft(col);
8782         rect.y = GetRowTop(row);
8783         for (i=col; i < col + cell_cols; i++)
8784             rect.width += GetColWidth(i);
8785         for (i=row; i < row + cell_rows; i++)
8786             rect.height += GetRowHeight(i);
8787     }
8788
8789     // if grid lines are enabled, then the area of the cell is a bit smaller
8790     if (m_gridLinesEnabled)
8791     {
8792         rect.width -= 1;
8793         rect.height -= 1;
8794     }
8795
8796     return rect;
8797 }
8798
8799 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
8800 {
8801     // get the cell rectangle in logical coords
8802     //
8803     wxRect r( CellToRect( row, col ) );
8804
8805     // convert to device coords
8806     //
8807     int left, top, right, bottom;
8808     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8809     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8810
8811     // check against the client area of the grid window
8812     int cw, ch;
8813     m_gridWin->GetClientSize( &cw, &ch );
8814
8815     if ( wholeCellVisible )
8816     {
8817         // is the cell wholly visible ?
8818         return ( left >= 0 && right <= cw &&
8819                  top >= 0 && bottom <= ch );
8820     }
8821     else
8822     {
8823         // is the cell partly visible ?
8824         //
8825         return ( ((left >= 0 && left < cw) || (right > 0 && right <= cw)) &&
8826                  ((top >= 0 && top < ch) || (bottom > 0 && bottom <= ch)) );
8827     }
8828 }
8829
8830 // make the specified cell location visible by doing a minimal amount
8831 // of scrolling
8832 //
8833 void wxGrid::MakeCellVisible( int row, int col )
8834 {
8835     int i;
8836     int xpos = -1, ypos = -1;
8837
8838     if ( row >= 0 && row < m_numRows &&
8839          col >= 0 && col < m_numCols )
8840     {
8841         // get the cell rectangle in logical coords
8842         wxRect r( CellToRect( row, col ) );
8843
8844         // convert to device coords
8845         int left, top, right, bottom;
8846         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
8847         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
8848
8849         int cw, ch;
8850         m_gridWin->GetClientSize( &cw, &ch );
8851
8852         if ( top < 0 )
8853         {
8854             ypos = r.GetTop();
8855         }
8856         else if ( bottom > ch )
8857         {
8858             int h = r.GetHeight();
8859             ypos = r.GetTop();
8860             for ( i = row - 1; i >= 0; i-- )
8861             {
8862                 int rowHeight = GetRowHeight(i);
8863                 if ( h + rowHeight > ch )
8864                     break;
8865
8866                 h += rowHeight;
8867                 ypos -= rowHeight;
8868             }
8869
8870             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
8871             // have rounding errors (this is important, because if we do,
8872             // we might not scroll at all and some cells won't be redrawn)
8873             //
8874             // Sometimes GRID_SCROLL_LINE / 2 is not enough,
8875             // so just add a full scroll unit...
8876             ypos += m_scrollLineY;
8877         }
8878
8879         // special handling for wide cells - show always left part of the cell!
8880         // Otherwise, e.g. when stepping from row to row, it would jump between
8881         // left and right part of the cell on every step!
8882 //      if ( left < 0 )
8883         if ( left < 0 || (right - left) >= cw )
8884         {
8885             xpos = r.GetLeft();
8886         }
8887         else if ( right > cw )
8888         {
8889             // position the view so that the cell is on the right
8890             int x0, y0;
8891             CalcUnscrolledPosition(0, 0, &x0, &y0);
8892             xpos = x0 + (right - cw);
8893
8894             // see comment for ypos above
8895             xpos += m_scrollLineX;
8896         }
8897
8898         if ( xpos != -1 || ypos != -1 )
8899         {
8900             if ( xpos != -1 )
8901                 xpos /= m_scrollLineX;
8902             if ( ypos != -1 )
8903                 ypos /= m_scrollLineY;
8904             Scroll( xpos, ypos );
8905             AdjustScrollbars();
8906         }
8907     }
8908 }
8909
8910 //
8911 // ------ Grid cursor movement functions
8912 //
8913
8914 bool wxGrid::MoveCursorUp( bool expandSelection )
8915 {
8916     if ( m_currentCellCoords != wxGridNoCellCoords &&
8917          m_currentCellCoords.GetRow() >= 0 )
8918     {
8919         if ( expandSelection )
8920         {
8921             if ( m_selectingKeyboard == wxGridNoCellCoords )
8922                 m_selectingKeyboard = m_currentCellCoords;
8923             if ( m_selectingKeyboard.GetRow() > 0 )
8924             {
8925                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
8926                 MakeCellVisible( m_selectingKeyboard.GetRow(),
8927                                  m_selectingKeyboard.GetCol() );
8928                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8929             }
8930         }
8931         else if ( m_currentCellCoords.GetRow() > 0 )
8932         {
8933             int row = m_currentCellCoords.GetRow() - 1;
8934             int col = m_currentCellCoords.GetCol();
8935             ClearSelection();
8936             MakeCellVisible( row, col );
8937             SetCurrentCell( row, col );
8938         }
8939         else
8940             return false;
8941
8942         return true;
8943     }
8944
8945     return false;
8946 }
8947
8948 bool wxGrid::MoveCursorDown( bool expandSelection )
8949 {
8950     if ( m_currentCellCoords != wxGridNoCellCoords &&
8951          m_currentCellCoords.GetRow() < m_numRows )
8952     {
8953         if ( expandSelection )
8954         {
8955             if ( m_selectingKeyboard == wxGridNoCellCoords )
8956                 m_selectingKeyboard = m_currentCellCoords;
8957             if ( m_selectingKeyboard.GetRow() < m_numRows - 1 )
8958             {
8959                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
8960                 MakeCellVisible( m_selectingKeyboard.GetRow(),
8961                         m_selectingKeyboard.GetCol() );
8962                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8963             }
8964         }
8965         else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
8966         {
8967             int row = m_currentCellCoords.GetRow() + 1;
8968             int col = m_currentCellCoords.GetCol();
8969             ClearSelection();
8970             MakeCellVisible( row, col );
8971             SetCurrentCell( row, col );
8972         }
8973         else
8974             return false;
8975
8976         return true;
8977     }
8978
8979     return false;
8980 }
8981
8982 bool wxGrid::MoveCursorLeft( bool expandSelection )
8983 {
8984     if ( m_currentCellCoords != wxGridNoCellCoords &&
8985          m_currentCellCoords.GetCol() >= 0 )
8986     {
8987         if ( expandSelection )
8988         {
8989             if ( m_selectingKeyboard == wxGridNoCellCoords )
8990                 m_selectingKeyboard = m_currentCellCoords;
8991             if ( m_selectingKeyboard.GetCol() > 0 )
8992             {
8993                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
8994                 MakeCellVisible( m_selectingKeyboard.GetRow(),
8995                         m_selectingKeyboard.GetCol() );
8996                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8997             }
8998         }
8999         else if ( GetColPos( m_currentCellCoords.GetCol() ) > 0 )
9000         {
9001             int row = m_currentCellCoords.GetRow();
9002             int col = GetColAt( GetColPos( m_currentCellCoords.GetCol() ) - 1 );
9003             ClearSelection();
9004
9005             MakeCellVisible( row, col );
9006             SetCurrentCell( row, col );
9007         }
9008         else
9009             return false;
9010
9011         return true;
9012     }
9013
9014     return false;
9015 }
9016
9017 bool wxGrid::MoveCursorRight( bool expandSelection )
9018 {
9019     if ( m_currentCellCoords != wxGridNoCellCoords &&
9020          m_currentCellCoords.GetCol() < m_numCols )
9021     {
9022         if ( expandSelection )
9023         {
9024             if ( m_selectingKeyboard == wxGridNoCellCoords )
9025                 m_selectingKeyboard = m_currentCellCoords;
9026             if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
9027             {
9028                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
9029                 MakeCellVisible( m_selectingKeyboard.GetRow(),
9030                         m_selectingKeyboard.GetCol() );
9031                 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
9032             }
9033         }
9034         else if ( GetColPos( m_currentCellCoords.GetCol() ) < m_numCols - 1 )
9035         {
9036             int row = m_currentCellCoords.GetRow();
9037             int col = GetColAt( GetColPos( m_currentCellCoords.GetCol() ) + 1 );
9038             ClearSelection();
9039
9040             MakeCellVisible( row, col );
9041             SetCurrentCell( row, col );
9042         }
9043         else
9044             return false;
9045
9046         return true;
9047     }
9048
9049     return false;
9050 }
9051
9052 bool wxGrid::MovePageUp()
9053 {
9054     if ( m_currentCellCoords == wxGridNoCellCoords )
9055         return false;
9056
9057     int row = m_currentCellCoords.GetRow();
9058     if ( row > 0 )
9059     {
9060         int cw, ch;
9061         m_gridWin->GetClientSize( &cw, &ch );
9062
9063         int y = GetRowTop(row);
9064         int newRow = internalYToRow( y - ch + 1 );
9065
9066         if ( newRow == row )
9067         {
9068             // row > 0, so newRow can never be less than 0 here.
9069             newRow = row - 1;
9070         }
9071
9072         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
9073         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
9074
9075         return true;
9076     }
9077
9078     return false;
9079 }
9080
9081 bool wxGrid::MovePageDown()
9082 {
9083     if ( m_currentCellCoords == wxGridNoCellCoords )
9084         return false;
9085
9086     int row = m_currentCellCoords.GetRow();
9087     if ( (row + 1) < m_numRows )
9088     {
9089         int cw, ch;
9090         m_gridWin->GetClientSize( &cw, &ch );
9091
9092         int y = GetRowTop(row);
9093         int newRow = internalYToRow( y + ch );
9094         if ( newRow == row )
9095         {
9096             // row < m_numRows, so newRow can't overflow here.
9097             newRow = row + 1;
9098         }
9099
9100         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
9101         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
9102
9103         return true;
9104     }
9105
9106     return false;
9107 }
9108
9109 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
9110 {
9111     if ( m_table &&
9112          m_currentCellCoords != wxGridNoCellCoords &&
9113          m_currentCellCoords.GetRow() > 0 )
9114     {
9115         int row = m_currentCellCoords.GetRow();
9116         int col = m_currentCellCoords.GetCol();
9117
9118         if ( m_table->IsEmptyCell(row, col) )
9119         {
9120             // starting in an empty cell: find the next block of
9121             // non-empty cells
9122             //
9123             while ( row > 0 )
9124             {
9125                 row--;
9126                 if ( !(m_table->IsEmptyCell(row, col)) )
9127                     break;
9128             }
9129         }
9130         else if ( m_table->IsEmptyCell(row - 1, col) )
9131         {
9132             // starting at the top of a block: find the next block
9133             //
9134             row--;
9135             while ( row > 0 )
9136             {
9137                 row--;
9138                 if ( !(m_table->IsEmptyCell(row, col)) )
9139                     break;
9140             }
9141         }
9142         else
9143         {
9144             // starting within a block: find the top of the block
9145             //
9146             while ( row > 0 )
9147             {
9148                 row--;
9149                 if ( m_table->IsEmptyCell(row, col) )
9150                 {
9151                     row++;
9152                     break;
9153                 }
9154             }
9155         }
9156
9157         MakeCellVisible( row, col );
9158         if ( expandSelection )
9159         {
9160             m_selectingKeyboard = wxGridCellCoords( row, col );
9161             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
9162         }
9163         else
9164         {
9165             ClearSelection();
9166             SetCurrentCell( row, col );
9167         }
9168
9169         return true;
9170     }
9171
9172     return false;
9173 }
9174
9175 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
9176 {
9177     if ( m_table &&
9178          m_currentCellCoords != wxGridNoCellCoords &&
9179          m_currentCellCoords.GetRow() < m_numRows - 1 )
9180     {
9181         int row = m_currentCellCoords.GetRow();
9182         int col = m_currentCellCoords.GetCol();
9183
9184         if ( m_table->IsEmptyCell(row, col) )
9185         {
9186             // starting in an empty cell: find the next block of
9187             // non-empty cells
9188             //
9189             while ( row < m_numRows - 1 )
9190             {
9191                 row++;
9192                 if ( !(m_table->IsEmptyCell(row, col)) )
9193                     break;
9194             }
9195         }
9196         else if ( m_table->IsEmptyCell(row + 1, col) )
9197         {
9198             // starting at the bottom of a block: find the next block
9199             //
9200             row++;
9201             while ( row < m_numRows - 1 )
9202             {
9203                 row++;
9204                 if ( !(m_table->IsEmptyCell(row, col)) )
9205                     break;
9206             }
9207         }
9208         else
9209         {
9210             // starting within a block: find the bottom of the block
9211             //
9212             while ( row < m_numRows - 1 )
9213             {
9214                 row++;
9215                 if ( m_table->IsEmptyCell(row, col) )
9216                 {
9217                     row--;
9218                     break;
9219                 }
9220             }
9221         }
9222
9223         MakeCellVisible( row, col );
9224         if ( expandSelection )
9225         {
9226             m_selectingKeyboard = wxGridCellCoords( row, col );
9227             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
9228         }
9229         else
9230         {
9231             ClearSelection();
9232             SetCurrentCell( row, col );
9233         }
9234
9235         return true;
9236     }
9237
9238     return false;
9239 }
9240
9241 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
9242 {
9243     if ( m_table &&
9244          m_currentCellCoords != wxGridNoCellCoords &&
9245          m_currentCellCoords.GetCol() > 0 )
9246     {
9247         int row = m_currentCellCoords.GetRow();
9248         int col = m_currentCellCoords.GetCol();
9249
9250         if ( m_table->IsEmptyCell(row, col) )
9251         {
9252             // starting in an empty cell: find the next block of
9253             // non-empty cells
9254             //
9255             while ( col > 0 )
9256             {
9257                 col--;
9258                 if ( !(m_table->IsEmptyCell(row, col)) )
9259                     break;
9260             }
9261         }
9262         else if ( m_table->IsEmptyCell(row, col - 1) )
9263         {
9264             // starting at the left of a block: find the next block
9265             //
9266             col--;
9267             while ( col > 0 )
9268             {
9269                 col--;
9270                 if ( !(m_table->IsEmptyCell(row, col)) )
9271                     break;
9272             }
9273         }
9274         else
9275         {
9276             // starting within a block: find the left of the block
9277             //
9278             while ( col > 0 )
9279             {
9280                 col--;
9281                 if ( m_table->IsEmptyCell(row, col) )
9282                 {
9283                     col++;
9284                     break;
9285                 }
9286             }
9287         }
9288
9289         MakeCellVisible( row, col );
9290         if ( expandSelection )
9291         {
9292             m_selectingKeyboard = wxGridCellCoords( row, col );
9293             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
9294         }
9295         else
9296         {
9297             ClearSelection();
9298             SetCurrentCell( row, col );
9299         }
9300
9301         return true;
9302     }
9303
9304     return false;
9305 }
9306
9307 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
9308 {
9309     if ( m_table &&
9310          m_currentCellCoords != wxGridNoCellCoords &&
9311          m_currentCellCoords.GetCol() < m_numCols - 1 )
9312     {
9313         int row = m_currentCellCoords.GetRow();
9314         int col = m_currentCellCoords.GetCol();
9315
9316         if ( m_table->IsEmptyCell(row, col) )
9317         {
9318             // starting in an empty cell: find the next block of
9319             // non-empty cells
9320             //
9321             while ( col < m_numCols - 1 )
9322             {
9323                 col++;
9324                 if ( !(m_table->IsEmptyCell(row, col)) )
9325                     break;
9326             }
9327         }
9328         else if ( m_table->IsEmptyCell(row, col + 1) )
9329         {
9330             // starting at the right of a block: find the next block
9331             //
9332             col++;
9333             while ( col < m_numCols - 1 )
9334             {
9335                 col++;
9336                 if ( !(m_table->IsEmptyCell(row, col)) )
9337                     break;
9338             }
9339         }
9340         else
9341         {
9342             // starting within a block: find the right of the block
9343             //
9344             while ( col < m_numCols - 1 )
9345             {
9346                 col++;
9347                 if ( m_table->IsEmptyCell(row, col) )
9348                 {
9349                     col--;
9350                     break;
9351                 }
9352             }
9353         }
9354
9355         MakeCellVisible( row, col );
9356         if ( expandSelection )
9357         {
9358             m_selectingKeyboard = wxGridCellCoords( row, col );
9359             HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
9360         }
9361         else
9362         {
9363             ClearSelection();
9364             SetCurrentCell( row, col );
9365         }
9366
9367         return true;
9368     }
9369
9370     return false;
9371 }
9372
9373 //
9374 // ------ Label values and formatting
9375 //
9376
9377 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
9378 {
9379     if ( horiz )
9380         *horiz = m_rowLabelHorizAlign;
9381     if ( vert )
9382         *vert  = m_rowLabelVertAlign;
9383 }
9384
9385 void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
9386 {
9387     if ( horiz )
9388         *horiz = m_colLabelHorizAlign;
9389     if ( vert )
9390         *vert  = m_colLabelVertAlign;
9391 }
9392
9393 int wxGrid::GetColLabelTextOrientation() const
9394 {
9395     return m_colLabelTextOrientation;
9396 }
9397
9398 wxString wxGrid::GetRowLabelValue( int row ) const
9399 {
9400     if ( m_table )
9401     {
9402         return m_table->GetRowLabelValue( row );
9403     }
9404     else
9405     {
9406         wxString s;
9407         s << row;
9408         return s;
9409     }
9410 }
9411
9412 wxString wxGrid::GetColLabelValue( int col ) const
9413 {
9414     if ( m_table )
9415     {
9416         return m_table->GetColLabelValue( col );
9417     }
9418     else
9419     {
9420         wxString s;
9421         s << col;
9422         return s;
9423     }
9424 }
9425
9426 void wxGrid::SetRowLabelSize( int width )
9427 {
9428     wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
9429
9430     if ( width == wxGRID_AUTOSIZE )
9431     {
9432         width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
9433     }
9434
9435     if ( width != m_rowLabelWidth )
9436     {
9437         if ( width == 0 )
9438         {
9439             m_rowLabelWin->Show( false );
9440             m_cornerLabelWin->Show( false );
9441         }
9442         else if ( m_rowLabelWidth == 0 )
9443         {
9444             m_rowLabelWin->Show( true );
9445             if ( m_colLabelHeight > 0 )
9446                 m_cornerLabelWin->Show( true );
9447         }
9448
9449         m_rowLabelWidth = width;
9450         CalcWindowSizes();
9451         wxScrolledWindow::Refresh( true );
9452     }
9453 }
9454
9455 void wxGrid::SetColLabelSize( int height )
9456 {
9457     wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
9458
9459     if ( height == wxGRID_AUTOSIZE )
9460     {
9461         height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
9462     }
9463
9464     if ( height != m_colLabelHeight )
9465     {
9466         if ( height == 0 )
9467         {
9468             m_colLabelWin->Show( false );
9469             m_cornerLabelWin->Show( false );
9470         }
9471         else if ( m_colLabelHeight == 0 )
9472         {
9473             m_colLabelWin->Show( true );
9474             if ( m_rowLabelWidth > 0 )
9475                 m_cornerLabelWin->Show( true );
9476         }
9477
9478         m_colLabelHeight = height;
9479         CalcWindowSizes();
9480         wxScrolledWindow::Refresh( true );
9481     }
9482 }
9483
9484 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
9485 {
9486     if ( m_labelBackgroundColour != colour )
9487     {
9488         m_labelBackgroundColour = colour;
9489         m_rowLabelWin->SetBackgroundColour( colour );
9490         m_colLabelWin->SetBackgroundColour( colour );
9491         m_cornerLabelWin->SetBackgroundColour( colour );
9492
9493         if ( !GetBatchCount() )
9494         {
9495             m_rowLabelWin->Refresh();
9496             m_colLabelWin->Refresh();
9497             m_cornerLabelWin->Refresh();
9498         }
9499     }
9500 }
9501
9502 void wxGrid::SetLabelTextColour( const wxColour& colour )
9503 {
9504     if ( m_labelTextColour != colour )
9505     {
9506         m_labelTextColour = colour;
9507         if ( !GetBatchCount() )
9508         {
9509             m_rowLabelWin->Refresh();
9510             m_colLabelWin->Refresh();
9511         }
9512     }
9513 }
9514
9515 void wxGrid::SetLabelFont( const wxFont& font )
9516 {
9517     m_labelFont = font;
9518     if ( !GetBatchCount() )
9519     {
9520         m_rowLabelWin->Refresh();
9521         m_colLabelWin->Refresh();
9522     }
9523 }
9524
9525 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
9526 {
9527     // allow old (incorrect) defs to be used
9528     switch ( horiz )
9529     {
9530         case wxLEFT:   horiz = wxALIGN_LEFT; break;
9531         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
9532         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
9533     }
9534
9535     switch ( vert )
9536     {
9537         case wxTOP:    vert = wxALIGN_TOP;    break;
9538         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
9539         case wxCENTRE: vert = wxALIGN_CENTRE; break;
9540     }
9541
9542     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
9543     {
9544         m_rowLabelHorizAlign = horiz;
9545     }
9546
9547     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
9548     {
9549         m_rowLabelVertAlign = vert;
9550     }
9551
9552     if ( !GetBatchCount() )
9553     {
9554         m_rowLabelWin->Refresh();
9555     }
9556 }
9557
9558 void wxGrid::SetColLabelAlignment( int horiz, int vert )
9559 {
9560     // allow old (incorrect) defs to be used
9561     switch ( horiz )
9562     {
9563         case wxLEFT:   horiz = wxALIGN_LEFT; break;
9564         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
9565         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
9566     }
9567
9568     switch ( vert )
9569     {
9570         case wxTOP:    vert = wxALIGN_TOP;    break;
9571         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
9572         case wxCENTRE: vert = wxALIGN_CENTRE; break;
9573     }
9574
9575     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
9576     {
9577         m_colLabelHorizAlign = horiz;
9578     }
9579
9580     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
9581     {
9582         m_colLabelVertAlign = vert;
9583     }
9584
9585     if ( !GetBatchCount() )
9586     {
9587         m_colLabelWin->Refresh();
9588     }
9589 }
9590
9591 // Note: under MSW, the default column label font must be changed because it
9592 //       does not support vertical printing
9593 //
9594 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
9595 //                      pGrid->SetLabelFont(font);
9596 //                      pGrid->SetColLabelTextOrientation(wxVERTICAL);
9597 //
9598 void wxGrid::SetColLabelTextOrientation( int textOrientation )
9599 {
9600     if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
9601         m_colLabelTextOrientation = textOrientation;
9602
9603     if ( !GetBatchCount() )
9604         m_colLabelWin->Refresh();
9605 }
9606
9607 void wxGrid::SetRowLabelValue( int row, const wxString& s )
9608 {
9609     if ( m_table )
9610     {
9611         m_table->SetRowLabelValue( row, s );
9612         if ( !GetBatchCount() )
9613         {
9614             wxRect rect = CellToRect( row, 0 );
9615             if ( rect.height > 0 )
9616             {
9617                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
9618                 rect.x = 0;
9619                 rect.width = m_rowLabelWidth;
9620                 m_rowLabelWin->Refresh( true, &rect );
9621             }
9622         }
9623     }
9624 }
9625
9626 void wxGrid::SetColLabelValue( int col, const wxString& s )
9627 {
9628     if ( m_table )
9629     {
9630         m_table->SetColLabelValue( col, s );
9631         if ( !GetBatchCount() )
9632         {
9633             wxRect rect = CellToRect( 0, col );
9634             if ( rect.width > 0 )
9635             {
9636                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
9637                 rect.y = 0;
9638                 rect.height = m_colLabelHeight;
9639                 m_colLabelWin->Refresh( true, &rect );
9640             }
9641         }
9642     }
9643 }
9644
9645 void wxGrid::SetGridLineColour( const wxColour& colour )
9646 {
9647     if ( m_gridLineColour != colour )
9648     {
9649         m_gridLineColour = colour;
9650
9651         wxClientDC dc( m_gridWin );
9652         PrepareDC( dc );
9653         DrawAllGridLines( dc, wxRegion() );
9654     }
9655 }
9656
9657 void wxGrid::SetCellHighlightColour( const wxColour& colour )
9658 {
9659     if ( m_cellHighlightColour != colour )
9660     {
9661         m_cellHighlightColour = colour;
9662
9663         wxClientDC dc( m_gridWin );
9664         PrepareDC( dc );
9665         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
9666         DrawCellHighlight(dc, attr);
9667         attr->DecRef();
9668     }
9669 }
9670
9671 void wxGrid::SetCellHighlightPenWidth(int width)
9672 {
9673     if (m_cellHighlightPenWidth != width)
9674     {
9675         m_cellHighlightPenWidth = width;
9676
9677         // Just redrawing the cell highlight is not enough since that won't
9678         // make any visible change if the the thickness is getting smaller.
9679         int row = m_currentCellCoords.GetRow();
9680         int col = m_currentCellCoords.GetCol();
9681         if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
9682             return;
9683
9684         wxRect rect = CellToRect(row, col);
9685         m_gridWin->Refresh(true, &rect);
9686     }
9687 }
9688
9689 void wxGrid::SetCellHighlightROPenWidth(int width)
9690 {
9691     if (m_cellHighlightROPenWidth != width)
9692     {
9693         m_cellHighlightROPenWidth = width;
9694
9695         // Just redrawing the cell highlight is not enough since that won't
9696         // make any visible change if the the thickness is getting smaller.
9697         int row = m_currentCellCoords.GetRow();
9698         int col = m_currentCellCoords.GetCol();
9699         if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
9700             return;
9701
9702         wxRect rect = CellToRect(row, col);
9703         m_gridWin->Refresh(true, &rect);
9704     }
9705 }
9706
9707 void wxGrid::EnableGridLines( bool enable )
9708 {
9709     if ( enable != m_gridLinesEnabled )
9710     {
9711         m_gridLinesEnabled = enable;
9712
9713         if ( !GetBatchCount() )
9714         {
9715             if ( enable )
9716             {
9717                 wxClientDC dc( m_gridWin );
9718                 PrepareDC( dc );
9719                 DrawAllGridLines( dc, wxRegion() );
9720             }
9721             else
9722             {
9723                 m_gridWin->Refresh();
9724             }
9725         }
9726     }
9727 }
9728
9729 int wxGrid::GetDefaultRowSize() const
9730 {
9731     return m_defaultRowHeight;
9732 }
9733
9734 int wxGrid::GetRowSize( int row ) const
9735 {
9736     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
9737
9738     return GetRowHeight(row);
9739 }
9740
9741 int wxGrid::GetDefaultColSize() const
9742 {
9743     return m_defaultColWidth;
9744 }
9745
9746 int wxGrid::GetColSize( int col ) const
9747 {
9748     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
9749
9750     return GetColWidth(col);
9751 }
9752
9753 // ============================================================================
9754 // access to the grid attributes: each of them has a default value in the grid
9755 // itself and may be overidden on a per-cell basis
9756 // ============================================================================
9757
9758 // ----------------------------------------------------------------------------
9759 // setting default attributes
9760 // ----------------------------------------------------------------------------
9761
9762 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
9763 {
9764     m_defaultCellAttr->SetBackgroundColour(col);
9765 #ifdef __WXGTK__
9766     m_gridWin->SetBackgroundColour(col);
9767 #endif
9768 }
9769
9770 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
9771 {
9772     m_defaultCellAttr->SetTextColour(col);
9773 }
9774
9775 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
9776 {
9777     m_defaultCellAttr->SetAlignment(horiz, vert);
9778 }
9779
9780 void wxGrid::SetDefaultCellOverflow( bool allow )
9781 {
9782     m_defaultCellAttr->SetOverflow(allow);
9783 }
9784
9785 void wxGrid::SetDefaultCellFont( const wxFont& font )
9786 {
9787     m_defaultCellAttr->SetFont(font);
9788 }
9789
9790 // For editors and renderers the type registry takes precedence over the
9791 // default attr, so we need to register the new editor/renderer for the string
9792 // data type in order to make setting a default editor/renderer appear to
9793 // work correctly.
9794
9795 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
9796 {
9797     RegisterDataType(wxGRID_VALUE_STRING,
9798                      renderer,
9799                      GetDefaultEditorForType(wxGRID_VALUE_STRING));
9800 }
9801
9802 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
9803 {
9804     RegisterDataType(wxGRID_VALUE_STRING,
9805                      GetDefaultRendererForType(wxGRID_VALUE_STRING),
9806                      editor);
9807 }
9808
9809 // ----------------------------------------------------------------------------
9810 // access to the default attributes
9811 // ----------------------------------------------------------------------------
9812
9813 wxColour wxGrid::GetDefaultCellBackgroundColour() const
9814 {
9815     return m_defaultCellAttr->GetBackgroundColour();
9816 }
9817
9818 wxColour wxGrid::GetDefaultCellTextColour() const
9819 {
9820     return m_defaultCellAttr->GetTextColour();
9821 }
9822
9823 wxFont wxGrid::GetDefaultCellFont() const
9824 {
9825     return m_defaultCellAttr->GetFont();
9826 }
9827
9828 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
9829 {
9830     m_defaultCellAttr->GetAlignment(horiz, vert);
9831 }
9832
9833 bool wxGrid::GetDefaultCellOverflow() const
9834 {
9835     return m_defaultCellAttr->GetOverflow();
9836 }
9837
9838 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
9839 {
9840     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
9841 }
9842
9843 wxGridCellEditor *wxGrid::GetDefaultEditor() const
9844 {
9845     return m_defaultCellAttr->GetEditor(NULL, 0, 0);
9846 }
9847
9848 // ----------------------------------------------------------------------------
9849 // access to cell attributes
9850 // ----------------------------------------------------------------------------
9851
9852 wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
9853 {
9854     wxGridCellAttr *attr = GetCellAttr(row, col);
9855     wxColour colour = attr->GetBackgroundColour();
9856     attr->DecRef();
9857
9858     return colour;
9859 }
9860
9861 wxColour wxGrid::GetCellTextColour( int row, int col ) const
9862 {
9863     wxGridCellAttr *attr = GetCellAttr(row, col);
9864     wxColour colour = attr->GetTextColour();
9865     attr->DecRef();
9866
9867     return colour;
9868 }
9869
9870 wxFont wxGrid::GetCellFont( int row, int col ) const
9871 {
9872     wxGridCellAttr *attr = GetCellAttr(row, col);
9873     wxFont font = attr->GetFont();
9874     attr->DecRef();
9875
9876     return font;
9877 }
9878
9879 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
9880 {
9881     wxGridCellAttr *attr = GetCellAttr(row, col);
9882     attr->GetAlignment(horiz, vert);
9883     attr->DecRef();
9884 }
9885
9886 bool wxGrid::GetCellOverflow( int row, int col ) const
9887 {
9888     wxGridCellAttr *attr = GetCellAttr(row, col);
9889     bool allow = attr->GetOverflow();
9890     attr->DecRef();
9891
9892     return allow;
9893 }
9894
9895 void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
9896 {
9897     wxGridCellAttr *attr = GetCellAttr(row, col);
9898     attr->GetSize( num_rows, num_cols );
9899     attr->DecRef();
9900 }
9901
9902 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
9903 {
9904     wxGridCellAttr* attr = GetCellAttr(row, col);
9905     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9906     attr->DecRef();
9907
9908     return renderer;
9909 }
9910
9911 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
9912 {
9913     wxGridCellAttr* attr = GetCellAttr(row, col);
9914     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
9915     attr->DecRef();
9916
9917     return editor;
9918 }
9919
9920 bool wxGrid::IsReadOnly(int row, int col) const
9921 {
9922     wxGridCellAttr* attr = GetCellAttr(row, col);
9923     bool isReadOnly = attr->IsReadOnly();
9924     attr->DecRef();
9925
9926     return isReadOnly;
9927 }
9928
9929 // ----------------------------------------------------------------------------
9930 // attribute support: cache, automatic provider creation, ...
9931 // ----------------------------------------------------------------------------
9932
9933 bool wxGrid::CanHaveAttributes() const
9934 {
9935     if ( !m_table )
9936     {
9937         return false;
9938     }
9939
9940     return m_table->CanHaveAttributes();
9941 }
9942
9943 void wxGrid::ClearAttrCache()
9944 {
9945     if ( m_attrCache.row != -1 )
9946     {
9947         wxSafeDecRef(m_attrCache.attr);
9948         m_attrCache.attr = NULL;
9949         m_attrCache.row = -1;
9950     }
9951 }
9952
9953 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
9954 {
9955     if ( attr != NULL )
9956     {
9957         wxGrid *self = (wxGrid *)this;  // const_cast
9958
9959         self->ClearAttrCache();
9960         self->m_attrCache.row = row;
9961         self->m_attrCache.col = col;
9962         self->m_attrCache.attr = attr;
9963         wxSafeIncRef(attr);
9964     }
9965 }
9966
9967 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
9968 {
9969     if ( row == m_attrCache.row && col == m_attrCache.col )
9970     {
9971         *attr = m_attrCache.attr;
9972         wxSafeIncRef(m_attrCache.attr);
9973
9974 #ifdef DEBUG_ATTR_CACHE
9975         gs_nAttrCacheHits++;
9976 #endif
9977
9978         return true;
9979     }
9980     else
9981     {
9982 #ifdef DEBUG_ATTR_CACHE
9983         gs_nAttrCacheMisses++;
9984 #endif
9985
9986         return false;
9987     }
9988 }
9989
9990 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
9991 {
9992     wxGridCellAttr *attr = NULL;
9993     // Additional test to avoid looking at the cache e.g. for
9994     // wxNoCellCoords, as this will confuse memory management.
9995     if ( row >= 0 )
9996     {
9997         if ( !LookupAttr(row, col, &attr) )
9998         {
9999             attr = m_table ? m_table->GetAttr(row, col, wxGridCellAttr::Any)
10000                            : (wxGridCellAttr *)NULL;
10001             CacheAttr(row, col, attr);
10002         }
10003     }
10004
10005     if (attr)
10006     {
10007         attr->SetDefAttr(m_defaultCellAttr);
10008     }
10009     else
10010     {
10011         attr = m_defaultCellAttr;
10012         attr->IncRef();
10013     }
10014
10015     return attr;
10016 }
10017
10018 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
10019 {
10020     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
10021     bool canHave = ((wxGrid*)this)->CanHaveAttributes();
10022
10023     wxCHECK_MSG( canHave, attr, _T("Cell attributes not allowed"));
10024     wxCHECK_MSG( m_table, attr, _T("must have a table") );
10025
10026     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
10027     if ( !attr )
10028     {
10029         attr = new wxGridCellAttr(m_defaultCellAttr);
10030
10031         // artificially inc the ref count to match DecRef() in caller
10032         attr->IncRef();
10033         m_table->SetAttr(attr, row, col);
10034     }
10035
10036     return attr;
10037 }
10038
10039 // ----------------------------------------------------------------------------
10040 // setting column attributes (wrappers around SetColAttr)
10041 // ----------------------------------------------------------------------------
10042
10043 void wxGrid::SetColFormatBool(int col)
10044 {
10045     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
10046 }
10047
10048 void wxGrid::SetColFormatNumber(int col)
10049 {
10050     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
10051 }
10052
10053 void wxGrid::SetColFormatFloat(int col, int width, int precision)
10054 {
10055     wxString typeName = wxGRID_VALUE_FLOAT;
10056     if ( (width != -1) || (precision != -1) )
10057     {
10058         typeName << _T(':') << width << _T(',') << precision;
10059     }
10060
10061     SetColFormatCustom(col, typeName);
10062 }
10063
10064 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
10065 {
10066     wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
10067     if (!attr)
10068         attr = new wxGridCellAttr;
10069     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
10070     attr->SetRenderer(renderer);
10071
10072     SetColAttr(col, attr);
10073
10074 }
10075
10076 // ----------------------------------------------------------------------------
10077 // setting cell attributes: this is forwarded to the table
10078 // ----------------------------------------------------------------------------
10079
10080 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
10081 {
10082     if ( CanHaveAttributes() )
10083     {
10084         m_table->SetAttr(attr, row, col);
10085         ClearAttrCache();
10086     }
10087     else
10088     {
10089         wxSafeDecRef(attr);
10090     }
10091 }
10092
10093 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
10094 {
10095     if ( CanHaveAttributes() )
10096     {
10097         m_table->SetRowAttr(attr, row);
10098         ClearAttrCache();
10099     }
10100     else
10101     {
10102         wxSafeDecRef(attr);
10103     }
10104 }
10105
10106 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
10107 {
10108     if ( CanHaveAttributes() )
10109     {
10110         m_table->SetColAttr(attr, col);
10111         ClearAttrCache();
10112     }
10113     else
10114     {
10115         wxSafeDecRef(attr);
10116     }
10117 }
10118
10119 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
10120 {
10121     if ( CanHaveAttributes() )
10122     {
10123         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10124         attr->SetBackgroundColour(colour);
10125         attr->DecRef();
10126     }
10127 }
10128
10129 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
10130 {
10131     if ( CanHaveAttributes() )
10132     {
10133         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10134         attr->SetTextColour(colour);
10135         attr->DecRef();
10136     }
10137 }
10138
10139 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
10140 {
10141     if ( CanHaveAttributes() )
10142     {
10143         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10144         attr->SetFont(font);
10145         attr->DecRef();
10146     }
10147 }
10148
10149 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
10150 {
10151     if ( CanHaveAttributes() )
10152     {
10153         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10154         attr->SetAlignment(horiz, vert);
10155         attr->DecRef();
10156     }
10157 }
10158
10159 void wxGrid::SetCellOverflow( int row, int col, bool allow )
10160 {
10161     if ( CanHaveAttributes() )
10162     {
10163         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10164         attr->SetOverflow(allow);
10165         attr->DecRef();
10166     }
10167 }
10168
10169 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
10170 {
10171     if ( CanHaveAttributes() )
10172     {
10173         int cell_rows, cell_cols;
10174
10175         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10176         attr->GetSize(&cell_rows, &cell_cols);
10177         attr->SetSize(num_rows, num_cols);
10178         attr->DecRef();
10179
10180         // Cannot set the size of a cell to 0 or negative values
10181         // While it is perfectly legal to do that, this function cannot
10182         // handle all the possibilies, do it by hand by getting the CellAttr.
10183         // You can only set the size of a cell to 1,1 or greater with this fn
10184         wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
10185                       wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
10186         wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
10187                       wxT("wxGrid::SetCellSize setting cell size to < 1"));
10188
10189         // if this was already a multicell then "turn off" the other cells first
10190         if ((cell_rows > 1) || (cell_rows > 1))
10191         {
10192             int i, j;
10193             for (j=row; j < row + cell_rows; j++)
10194             {
10195                 for (i=col; i < col + cell_cols; i++)
10196                 {
10197                     if ((i != col) || (j != row))
10198                     {
10199                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
10200                         attr_stub->SetSize( 1, 1 );
10201                         attr_stub->DecRef();
10202                     }
10203                 }
10204             }
10205         }
10206
10207         // mark the cells that will be covered by this cell to
10208         // negative or zero values to point back at this cell
10209         if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
10210         {
10211             int i, j;
10212             for (j=row; j < row + num_rows; j++)
10213             {
10214                 for (i=col; i < col + num_cols; i++)
10215                 {
10216                     if ((i != col) || (j != row))
10217                     {
10218                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
10219                         attr_stub->SetSize( row - j, col - i );
10220                         attr_stub->DecRef();
10221                     }
10222                 }
10223             }
10224         }
10225     }
10226 }
10227
10228 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
10229 {
10230     if ( CanHaveAttributes() )
10231     {
10232         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10233         attr->SetRenderer(renderer);
10234         attr->DecRef();
10235     }
10236 }
10237
10238 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
10239 {
10240     if ( CanHaveAttributes() )
10241     {
10242         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10243         attr->SetEditor(editor);
10244         attr->DecRef();
10245     }
10246 }
10247
10248 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
10249 {
10250     if ( CanHaveAttributes() )
10251     {
10252         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
10253         attr->SetReadOnly(isReadOnly);
10254         attr->DecRef();
10255     }
10256 }
10257
10258 // ----------------------------------------------------------------------------
10259 // Data type registration
10260 // ----------------------------------------------------------------------------
10261
10262 void wxGrid::RegisterDataType(const wxString& typeName,
10263                               wxGridCellRenderer* renderer,
10264                               wxGridCellEditor* editor)
10265 {
10266     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
10267 }
10268
10269
10270 wxGridCellEditor * wxGrid::GetDefaultEditorForCell(int row, int col) const
10271 {
10272     wxString typeName = m_table->GetTypeName(row, col);
10273     return GetDefaultEditorForType(typeName);
10274 }
10275
10276 wxGridCellRenderer * wxGrid::GetDefaultRendererForCell(int row, int col) const
10277 {
10278     wxString typeName = m_table->GetTypeName(row, col);
10279     return GetDefaultRendererForType(typeName);
10280 }
10281
10282 wxGridCellEditor * wxGrid::GetDefaultEditorForType(const wxString& typeName) const
10283 {
10284     int index = m_typeRegistry->FindOrCloneDataType(typeName);
10285     if ( index == wxNOT_FOUND )
10286     {
10287         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
10288
10289         return NULL;
10290     }
10291
10292     return m_typeRegistry->GetEditor(index);
10293 }
10294
10295 wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName) const
10296 {
10297     int index = m_typeRegistry->FindOrCloneDataType(typeName);
10298     if ( index == wxNOT_FOUND )
10299     {
10300         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
10301
10302         return NULL;
10303     }
10304
10305     return m_typeRegistry->GetRenderer(index);
10306 }
10307
10308 // ----------------------------------------------------------------------------
10309 // row/col size
10310 // ----------------------------------------------------------------------------
10311
10312 void wxGrid::EnableDragRowSize( bool enable )
10313 {
10314     m_canDragRowSize = enable;
10315 }
10316
10317 void wxGrid::EnableDragColSize( bool enable )
10318 {
10319     m_canDragColSize = enable;
10320 }
10321
10322 void wxGrid::EnableDragGridSize( bool enable )
10323 {
10324     m_canDragGridSize = enable;
10325 }
10326
10327 void wxGrid::EnableDragCell( bool enable )
10328 {
10329     m_canDragCell = enable;
10330 }
10331
10332 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
10333 {
10334     m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
10335
10336     if ( resizeExistingRows )
10337     {
10338         // since we are resizing all rows to the default row size,
10339         // we can simply clear the row heights and row bottoms
10340         // arrays (which also allows us to take advantage of
10341         // some speed optimisations)
10342         m_rowHeights.Empty();
10343         m_rowBottoms.Empty();
10344         if ( !GetBatchCount() )
10345             CalcDimensions();
10346     }
10347 }
10348
10349 void wxGrid::SetRowSize( int row, int height )
10350 {
10351     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
10352
10353     // See comment in SetColSize
10354     if ( height < GetRowMinimalAcceptableHeight())
10355         return;
10356
10357     if ( m_rowHeights.IsEmpty() )
10358     {
10359         // need to really create the array
10360         InitRowHeights();
10361     }
10362
10363     int h = wxMax( 0, height );
10364     int diff = h - m_rowHeights[row];
10365
10366     m_rowHeights[row] = h;
10367     for ( int i = row; i < m_numRows; i++ )
10368     {
10369         m_rowBottoms[i] += diff;
10370     }
10371
10372     if ( !GetBatchCount() )
10373         CalcDimensions();
10374 }
10375
10376 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
10377 {
10378     // we dont allow zero default column width
10379     m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
10380
10381     if ( resizeExistingCols )
10382     {
10383         // since we are resizing all columns to the default column size,
10384         // we can simply clear the col widths and col rights
10385         // arrays (which also allows us to take advantage of
10386         // some speed optimisations)
10387         m_colWidths.Empty();
10388         m_colRights.Empty();
10389         if ( !GetBatchCount() )
10390             CalcDimensions();
10391     }
10392 }
10393
10394 void wxGrid::SetColSize( int col, int width )
10395 {
10396     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
10397
10398     // should we check that it's bigger than GetColMinimalWidth(col) here?
10399     //                                                                 (VZ)
10400     // No, because it is reasonable to assume the library user know's
10401     // what he is doing. However we should test against the weaker
10402     // constraint of minimalAcceptableWidth, as this breaks rendering
10403     //
10404     // This test then fixes sf.net bug #645734
10405
10406     if ( width < GetColMinimalAcceptableWidth() )
10407         return;
10408
10409     if ( m_colWidths.IsEmpty() )
10410     {
10411         // need to really create the array
10412         InitColWidths();
10413     }
10414
10415     // if < 0 then calculate new width from label
10416     if ( width < 0 )
10417     {
10418         long w, h;
10419         wxArrayString lines;
10420         wxClientDC dc(m_colLabelWin);
10421         dc.SetFont(GetLabelFont());
10422         StringToLines(GetColLabelValue(col), lines);
10423         GetTextBoxSize(dc, lines, &w, &h);
10424         width = w + 6;
10425     }
10426
10427     int w = wxMax( 0, width );
10428     int diff = w - m_colWidths[col];
10429     m_colWidths[col] = w;
10430
10431     for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
10432     {
10433         m_colRights[GetColAt(colPos)] += diff;
10434     }
10435
10436     if ( !GetBatchCount() )
10437         CalcDimensions();
10438 }
10439
10440 void wxGrid::SetColMinimalWidth( int col, int width )
10441 {
10442     if (width > GetColMinimalAcceptableWidth())
10443     {
10444         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
10445         m_colMinWidths[key] = width;
10446     }
10447 }
10448
10449 void wxGrid::SetRowMinimalHeight( int row, int width )
10450 {
10451     if (width > GetRowMinimalAcceptableHeight())
10452     {
10453         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
10454         m_rowMinHeights[key] = width;
10455     }
10456 }
10457
10458 int wxGrid::GetColMinimalWidth(int col) const
10459 {
10460     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
10461     wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
10462
10463     return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
10464 }
10465
10466 int wxGrid::GetRowMinimalHeight(int row) const
10467 {
10468     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
10469     wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
10470
10471     return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
10472 }
10473
10474 void wxGrid::SetColMinimalAcceptableWidth( int width )
10475 {
10476     // We do allow a width of 0 since this gives us
10477     // an easy way to temporarily hiding columns.
10478     if ( width >= 0 )
10479         m_minAcceptableColWidth = width;
10480 }
10481
10482 void wxGrid::SetRowMinimalAcceptableHeight( int height )
10483 {
10484     // We do allow a height of 0 since this gives us
10485     // an easy way to temporarily hiding rows.
10486     if ( height >= 0 )
10487         m_minAcceptableRowHeight = height;
10488 }
10489
10490 int  wxGrid::GetColMinimalAcceptableWidth() const
10491 {
10492     return m_minAcceptableColWidth;
10493 }
10494
10495 int  wxGrid::GetRowMinimalAcceptableHeight() const
10496 {
10497     return m_minAcceptableRowHeight;
10498 }
10499
10500 // ----------------------------------------------------------------------------
10501 // auto sizing
10502 // ----------------------------------------------------------------------------
10503
10504 void
10505 wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
10506 {
10507     const bool column = direction == wxGRID_COLUMN;
10508
10509     wxClientDC dc(m_gridWin);
10510
10511     // cancel editing of cell
10512     HideCellEditControl();
10513     SaveEditControlValue();
10514
10515     // init both of them to avoid compiler warnings, even if we only need one
10516     int row = -1,
10517         col = -1;
10518     if ( column )
10519         col = colOrRow;
10520     else
10521         row = colOrRow;
10522
10523     wxCoord extent, extentMax = 0;
10524     int max = column ? m_numRows : m_numCols;
10525     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
10526     {
10527         if ( column )
10528             row = rowOrCol;
10529         else
10530             col = rowOrCol;
10531
10532         wxGridCellAttr *attr = GetCellAttr(row, col);
10533         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
10534         if ( renderer )
10535         {
10536             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
10537             extent = column ? size.x : size.y;
10538             if ( extent > extentMax )
10539                 extentMax = extent;
10540
10541             renderer->DecRef();
10542         }
10543
10544         attr->DecRef();
10545     }
10546
10547     // now also compare with the column label extent
10548     wxCoord w, h;
10549     dc.SetFont( GetLabelFont() );
10550
10551     if ( column )
10552     {
10553         dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
10554         if ( GetColLabelTextOrientation() == wxVERTICAL )
10555             w = h;
10556     }
10557     else
10558         dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
10559
10560     extent = column ? w : h;
10561     if ( extent > extentMax )
10562         extentMax = extent;
10563
10564     if ( !extentMax )
10565     {
10566         // empty column - give default extent (notice that if extentMax is less
10567         // than default extent but != 0, it's OK)
10568         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
10569     }
10570     else
10571     {
10572         if ( column )
10573             // leave some space around text
10574             extentMax += 10;
10575         else
10576             extentMax += 6;
10577     }
10578
10579     if ( column )
10580     {
10581         SetColSize( col, extentMax );
10582         if ( !GetBatchCount() )
10583         {
10584             int cw, ch, dummy;
10585             m_gridWin->GetClientSize( &cw, &ch );
10586             wxRect rect ( CellToRect( 0, col ) );
10587             rect.y = 0;
10588             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
10589             rect.width = cw - rect.x;
10590             rect.height = m_colLabelHeight;
10591             m_colLabelWin->Refresh( true, &rect );
10592         }
10593     }
10594     else
10595     {
10596         SetRowSize(row, extentMax);
10597         if ( !GetBatchCount() )
10598         {
10599             int cw, ch, dummy;
10600             m_gridWin->GetClientSize( &cw, &ch );
10601             wxRect rect( CellToRect( row, 0 ) );
10602             rect.x = 0;
10603             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
10604             rect.width = m_rowLabelWidth;
10605             rect.height = ch - rect.y;
10606             m_rowLabelWin->Refresh( true, &rect );
10607         }
10608     }
10609
10610     if ( setAsMin )
10611     {
10612         if ( column )
10613             SetColMinimalWidth(col, extentMax);
10614         else
10615             SetRowMinimalHeight(row, extentMax);
10616     }
10617 }
10618
10619 wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
10620 {
10621     // calculate size for the rows or columns?
10622     const bool calcRows = direction == wxGRID_ROW;
10623
10624     wxClientDC dc(calcRows ? GetGridRowLabelWindow()
10625                            : GetGridColLabelWindow());
10626     dc.SetFont(GetLabelFont());
10627
10628     // which dimension should we take into account for calculations?
10629     //
10630     // for columns, the text can be only horizontal so it's easy but for rows
10631     // we also have to take into account the text orientation
10632     const bool
10633         useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
10634
10635     wxArrayString lines;
10636     wxCoord extentMax = 0;
10637
10638     const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
10639     for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
10640     {
10641         lines.Clear();
10642
10643         wxString label = calcRows ? GetRowLabelValue(rowOrCol)
10644                                   : GetColLabelValue(rowOrCol);
10645         StringToLines(label, lines);
10646
10647         long w, h;
10648         GetTextBoxSize(dc, lines, &w, &h);
10649
10650         const wxCoord extent = useWidth ? w : h;
10651         if ( extent > extentMax )
10652             extentMax = extent;
10653     }
10654
10655     if ( !extentMax )
10656     {
10657         // empty column - give default extent (notice that if extentMax is less
10658         // than default extent but != 0, it's OK)
10659         extentMax = calcRows ? GetDefaultRowLabelSize()
10660                              : GetDefaultColLabelSize();
10661     }
10662
10663     // leave some space around text (taken from AutoSizeColOrRow)
10664     if ( calcRows )
10665         extentMax += 10;
10666     else
10667         extentMax += 6;
10668
10669     return extentMax;
10670 }
10671
10672 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
10673 {
10674     int width = m_rowLabelWidth;
10675
10676     wxGridUpdateLocker locker;
10677     if(!calcOnly)
10678         locker.Create(this);
10679
10680     for ( int col = 0; col < m_numCols; col++ )
10681     {
10682         if ( !calcOnly )
10683             AutoSizeColumn(col, setAsMin);
10684
10685         width += GetColWidth(col);
10686     }
10687
10688     return width;
10689 }
10690
10691 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
10692 {
10693     int height = m_colLabelHeight;
10694
10695     wxGridUpdateLocker locker;
10696     if(!calcOnly)
10697         locker.Create(this);
10698
10699     for ( int row = 0; row < m_numRows; row++ )
10700     {
10701         if ( !calcOnly )
10702             AutoSizeRow(row, setAsMin);
10703
10704         height += GetRowHeight(row);
10705     }
10706
10707     return height;
10708 }
10709
10710 void wxGrid::AutoSize()
10711 {
10712     wxGridUpdateLocker locker(this);
10713
10714     // we need to round up the size of the scrollable area to a multiple of
10715     // scroll step to ensure that we don't get the scrollbars when we're sized
10716     // exactly to fit our contents
10717     wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
10718                 SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
10719     wxSize sizeFit(GetScrollX(size.x) * GetScrollLineX(),
10720                    GetScrollY(size.y) * GetScrollLineY());
10721
10722     // distribute the extra space between the columns/rows to avoid having
10723     // extra white space
10724     wxCoord diff = sizeFit.x - size.x;
10725     if ( diff && m_numCols )
10726     {
10727         // try to resize the columns uniformly
10728         wxCoord diffPerCol = diff / m_numCols;
10729         if ( diffPerCol )
10730         {
10731             for ( int col = 0; col < m_numCols; col++ )
10732             {
10733                 SetColSize(col, GetColWidth(col) + diffPerCol);
10734             }
10735         }
10736
10737         // add remaining amount to the last columns
10738         diff -= diffPerCol * m_numCols;
10739         if ( diff )
10740         {
10741             for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
10742             {
10743                 SetColSize(col, GetColWidth(col) + 1);
10744             }
10745         }
10746     }
10747
10748     // same for rows
10749     diff = sizeFit.y - size.y;
10750     if ( diff && m_numRows )
10751     {
10752         // try to resize the columns uniformly
10753         wxCoord diffPerRow = diff / m_numRows;
10754         if ( diffPerRow )
10755         {
10756             for ( int row = 0; row < m_numRows; row++ )
10757             {
10758                 SetRowSize(row, GetRowHeight(row) + diffPerRow);
10759             }
10760         }
10761
10762         // add remaining amount to the last rows
10763         diff -= diffPerRow * m_numRows;
10764         if ( diff )
10765         {
10766             for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
10767             {
10768                 SetRowSize(row, GetRowHeight(row) + 1);
10769             }
10770         }
10771     }
10772
10773     // we know that we're not going to have scrollbars so disable them now to
10774     // avoid trouble in SetClientSize() which can otherwise set the correct
10775     // client size but also leave space for (not needed any more) scrollbars
10776     SetScrollbars(0, 0, 0, 0, 0, 0, true);
10777     SetClientSize(sizeFit.x + m_rowLabelWidth, sizeFit.y + m_colLabelHeight);
10778 }
10779
10780 void wxGrid::AutoSizeRowLabelSize( int row )
10781 {
10782     wxArrayString lines;
10783     long w, h;
10784
10785     // Hide the edit control, so it
10786     // won't interfere with drag-shrinking.
10787     if ( IsCellEditControlShown() )
10788     {
10789         HideCellEditControl();
10790         SaveEditControlValue();
10791     }
10792
10793     // autosize row height depending on label text
10794     StringToLines( GetRowLabelValue( row ), lines );
10795     wxClientDC dc( m_rowLabelWin );
10796     GetTextBoxSize( dc, lines, &w, &h );
10797     if ( h < m_defaultRowHeight )
10798         h = m_defaultRowHeight;
10799     SetRowSize(row, h);
10800     ForceRefresh();
10801 }
10802
10803 void wxGrid::AutoSizeColLabelSize( int col )
10804 {
10805     wxArrayString lines;
10806     long w, h;
10807
10808     // Hide the edit control, so it
10809     // won't interfere with drag-shrinking.
10810     if ( IsCellEditControlShown() )
10811     {
10812         HideCellEditControl();
10813         SaveEditControlValue();
10814     }
10815
10816     // autosize column width depending on label text
10817     StringToLines( GetColLabelValue( col ), lines );
10818     wxClientDC dc( m_colLabelWin );
10819     if ( GetColLabelTextOrientation() == wxHORIZONTAL )
10820         GetTextBoxSize( dc, lines, &w, &h );
10821     else
10822         GetTextBoxSize( dc, lines, &h, &w );
10823     if ( w < m_defaultColWidth )
10824         w = m_defaultColWidth;
10825     SetColSize(col, w);
10826     ForceRefresh();
10827 }
10828
10829 wxSize wxGrid::DoGetBestSize() const
10830 {
10831     wxGrid *self = (wxGrid *)this;  // const_cast
10832
10833     // we do the same as in AutoSize() here with the exception that we don't
10834     // change the column/row sizes, only calculate them
10835     wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
10836                 self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
10837     wxSize sizeFit(GetScrollX(size.x) * GetScrollLineX(),
10838                    GetScrollY(size.y) * GetScrollLineY());
10839
10840     // NOTE: This size should be cached, but first we need to add calls to
10841     // InvalidateBestSize everywhere that could change the results of this
10842     // calculation.
10843     // CacheBestSize(size);
10844
10845     return wxSize(sizeFit.x + m_rowLabelWidth, sizeFit.y + m_colLabelHeight)
10846             + GetWindowBorderSize();
10847 }
10848
10849 void wxGrid::Fit()
10850 {
10851     AutoSize();
10852 }
10853
10854 wxPen& wxGrid::GetDividerPen() const
10855 {
10856     return wxNullPen;
10857 }
10858
10859 // ----------------------------------------------------------------------------
10860 // cell value accessor functions
10861 // ----------------------------------------------------------------------------
10862
10863 void wxGrid::SetCellValue( int row, int col, const wxString& s )
10864 {
10865     if ( m_table )
10866     {
10867         m_table->SetValue( row, col, s );
10868         if ( !GetBatchCount() )
10869         {
10870             int dummy;
10871             wxRect rect( CellToRect( row, col ) );
10872             rect.x = 0;
10873             rect.width = m_gridWin->GetClientSize().GetWidth();
10874             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
10875             m_gridWin->Refresh( false, &rect );
10876         }
10877
10878         if ( m_currentCellCoords.GetRow() == row &&
10879              m_currentCellCoords.GetCol() == col &&
10880              IsCellEditControlShown())
10881              // Note: If we are using IsCellEditControlEnabled,
10882              // this interacts badly with calling SetCellValue from
10883              // an EVT_GRID_CELL_CHANGE handler.
10884         {
10885             HideCellEditControl();
10886             ShowCellEditControl(); // will reread data from table
10887         }
10888     }
10889 }
10890
10891 // ----------------------------------------------------------------------------
10892 // block, row and column selection
10893 // ----------------------------------------------------------------------------
10894
10895 void wxGrid::SelectRow( int row, bool addToSelected )
10896 {
10897     if ( IsSelection() && !addToSelected )
10898         ClearSelection();
10899
10900     if ( m_selection )
10901         m_selection->SelectRow( row, false, addToSelected );
10902 }
10903
10904 void wxGrid::SelectCol( int col, bool addToSelected )
10905 {
10906     if ( IsSelection() && !addToSelected )
10907         ClearSelection();
10908
10909     if ( m_selection )
10910         m_selection->SelectCol( col, false, addToSelected );
10911 }
10912
10913 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
10914                           bool addToSelected )
10915 {
10916     if ( IsSelection() && !addToSelected )
10917         ClearSelection();
10918
10919     if ( m_selection )
10920         m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
10921                                   false, addToSelected );
10922 }
10923
10924 void wxGrid::SelectAll()
10925 {
10926     if ( m_numRows > 0 && m_numCols > 0 )
10927     {
10928         if ( m_selection )
10929             m_selection->SelectBlock( 0, 0, m_numRows - 1, m_numCols - 1 );
10930     }
10931 }
10932
10933 // ----------------------------------------------------------------------------
10934 // cell, row and col deselection
10935 // ----------------------------------------------------------------------------
10936
10937 void wxGrid::DeselectRow( int row )
10938 {
10939     if ( !m_selection )
10940         return;
10941
10942     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
10943     {
10944         if ( m_selection->IsInSelection(row, 0 ) )
10945             m_selection->ToggleCellSelection(row, 0);
10946     }
10947     else
10948     {
10949         int nCols = GetNumberCols();
10950         for ( int i = 0; i < nCols; i++ )
10951         {
10952             if ( m_selection->IsInSelection(row, i ) )
10953                 m_selection->ToggleCellSelection(row, i);
10954         }
10955     }
10956 }
10957
10958 void wxGrid::DeselectCol( int col )
10959 {
10960     if ( !m_selection )
10961         return;
10962
10963     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
10964     {
10965         if ( m_selection->IsInSelection(0, col ) )
10966             m_selection->ToggleCellSelection(0, col);
10967     }
10968     else
10969     {
10970         int nRows = GetNumberRows();
10971         for ( int i = 0; i < nRows; i++ )
10972         {
10973             if ( m_selection->IsInSelection(i, col ) )
10974                 m_selection->ToggleCellSelection(i, col);
10975         }
10976     }
10977 }
10978
10979 void wxGrid::DeselectCell( int row, int col )
10980 {
10981     if ( m_selection && m_selection->IsInSelection(row, col) )
10982         m_selection->ToggleCellSelection(row, col);
10983 }
10984
10985 bool wxGrid::IsSelection() const
10986 {
10987     return ( m_selection && (m_selection->IsSelection() ||
10988              ( m_selectingTopLeft != wxGridNoCellCoords &&
10989                m_selectingBottomRight != wxGridNoCellCoords) ) );
10990 }
10991
10992 bool wxGrid::IsInSelection( int row, int col ) const
10993 {
10994     return ( m_selection && (m_selection->IsInSelection( row, col ) ||
10995              ( row >= m_selectingTopLeft.GetRow() &&
10996                col >= m_selectingTopLeft.GetCol() &&
10997                row <= m_selectingBottomRight.GetRow() &&
10998                col <= m_selectingBottomRight.GetCol() )) );
10999 }
11000
11001 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
11002 {
11003     if (!m_selection)
11004     {
11005         wxGridCellCoordsArray a;
11006         return a;
11007     }
11008
11009     return m_selection->m_cellSelection;
11010 }
11011
11012 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
11013 {
11014     if (!m_selection)
11015     {
11016         wxGridCellCoordsArray a;
11017         return a;
11018     }
11019
11020     return m_selection->m_blockSelectionTopLeft;
11021 }
11022
11023 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
11024 {
11025     if (!m_selection)
11026     {
11027         wxGridCellCoordsArray a;
11028         return a;
11029     }
11030
11031     return m_selection->m_blockSelectionBottomRight;
11032 }
11033
11034 wxArrayInt wxGrid::GetSelectedRows() const
11035 {
11036     if (!m_selection)
11037     {
11038         wxArrayInt a;
11039         return a;
11040     }
11041
11042     return m_selection->m_rowSelection;
11043 }
11044
11045 wxArrayInt wxGrid::GetSelectedCols() const
11046 {
11047     if (!m_selection)
11048     {
11049         wxArrayInt a;
11050         return a;
11051     }
11052
11053     return m_selection->m_colSelection;
11054 }
11055
11056 void wxGrid::ClearSelection()
11057 {
11058     m_selectingTopLeft =
11059     m_selectingBottomRight =
11060     m_selectingKeyboard = wxGridNoCellCoords;
11061     if ( m_selection )
11062         m_selection->ClearSelection();
11063 }
11064
11065 // This function returns the rectangle that encloses the given block
11066 // in device coords clipped to the client size of the grid window.
11067 //
11068 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
11069                                   const wxGridCellCoords &bottomRight ) const
11070 {
11071     wxRect rect( wxGridNoCellRect );
11072     wxRect cellRect;
11073
11074     cellRect = CellToRect( topLeft );
11075     if ( cellRect != wxGridNoCellRect )
11076     {
11077         rect = cellRect;
11078     }
11079     else
11080     {
11081         rect = wxRect(0, 0, 0, 0);
11082     }
11083
11084     cellRect = CellToRect( bottomRight );
11085     if ( cellRect != wxGridNoCellRect )
11086     {
11087         rect += cellRect;
11088     }
11089     else
11090     {
11091         return wxGridNoCellRect;
11092     }
11093
11094     int i, j;
11095     int left = rect.GetLeft();
11096     int top = rect.GetTop();
11097     int right = rect.GetRight();
11098     int bottom = rect.GetBottom();
11099
11100     int leftCol = topLeft.GetCol();
11101     int topRow = topLeft.GetRow();
11102     int rightCol = bottomRight.GetCol();
11103     int bottomRow = bottomRight.GetRow();
11104
11105     if (left > right)
11106     {
11107         i = left;
11108         left = right;
11109         right = i;
11110         i = leftCol;
11111         leftCol = rightCol;
11112         rightCol = i;
11113     }
11114
11115     if (top > bottom)
11116     {
11117         i = top;
11118         top = bottom;
11119         bottom = i;
11120         i = topRow;
11121         topRow = bottomRow;
11122         bottomRow = i;
11123     }
11124
11125     for ( j = topRow; j <= bottomRow; j++ )
11126     {
11127         for ( i = leftCol; i <= rightCol; i++ )
11128         {
11129             if ((j == topRow) || (j == bottomRow) || (i == leftCol) || (i == rightCol))
11130             {
11131                 cellRect = CellToRect( j, i );
11132
11133                 if (cellRect.x < left)
11134                     left = cellRect.x;
11135                 if (cellRect.y < top)
11136                     top = cellRect.y;
11137                 if (cellRect.x + cellRect.width > right)
11138                     right = cellRect.x + cellRect.width;
11139                 if (cellRect.y + cellRect.height > bottom)
11140                     bottom = cellRect.y + cellRect.height;
11141             }
11142             else
11143             {
11144                 i = rightCol; // jump over inner cells.
11145             }
11146         }
11147     }
11148
11149     // convert to scrolled coords
11150     //
11151     CalcScrolledPosition( left, top, &left, &top );
11152     CalcScrolledPosition( right, bottom, &right, &bottom );
11153
11154     int cw, ch;
11155     m_gridWin->GetClientSize( &cw, &ch );
11156
11157     if (right < 0 || bottom < 0 || left > cw || top > ch)
11158         return wxRect(0,0,0,0);
11159
11160     rect.SetLeft( wxMax(0, left) );
11161     rect.SetTop( wxMax(0, top) );
11162     rect.SetRight( wxMin(cw, right) );
11163     rect.SetBottom( wxMin(ch, bottom) );
11164
11165     return rect;
11166 }
11167
11168 // ----------------------------------------------------------------------------
11169 // grid event classes
11170 // ----------------------------------------------------------------------------
11171
11172 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
11173
11174 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
11175                           int row, int col, int x, int y, bool sel,
11176                           bool control, bool shift, bool alt, bool meta )
11177         : wxNotifyEvent( type, id )
11178 {
11179     m_row = row;
11180     m_col = col;
11181     m_x = x;
11182     m_y = y;
11183     m_selecting = sel;
11184     m_control = control;
11185     m_shift = shift;
11186     m_alt = alt;
11187     m_meta = meta;
11188
11189     SetEventObject(obj);
11190 }
11191
11192
11193 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
11194
11195 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
11196                                   int rowOrCol, int x, int y,
11197                                   bool control, bool shift, bool alt, bool meta )
11198         : wxNotifyEvent( type, id )
11199 {
11200     m_rowOrCol = rowOrCol;
11201     m_x = x;
11202     m_y = y;
11203     m_control = control;
11204     m_shift = shift;
11205     m_alt = alt;
11206     m_meta = meta;
11207
11208     SetEventObject(obj);
11209 }
11210
11211
11212 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
11213
11214 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
11215                                                const wxGridCellCoords& topLeft,
11216                                                const wxGridCellCoords& bottomRight,
11217                                                bool sel, bool control,
11218                                                bool shift, bool alt, bool meta )
11219         : wxNotifyEvent( type, id )
11220 {
11221     m_topLeft = topLeft;
11222     m_bottomRight = bottomRight;
11223     m_selecting = sel;
11224     m_control = control;
11225     m_shift = shift;
11226     m_alt = alt;
11227     m_meta = meta;
11228
11229     SetEventObject(obj);
11230 }
11231
11232
11233 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
11234
11235 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
11236                                                    wxObject* obj, int row,
11237                                                    int col, wxControl* ctrl)
11238     : wxCommandEvent(type, id)
11239 {
11240     SetEventObject(obj);
11241     m_row = row;
11242     m_col = col;
11243     m_ctrl = ctrl;
11244 }
11245
11246 #endif // wxUSE_GRID