src/generic/grid.cpp

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