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