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:
   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 #ifdef __GNUG__
  21     #pragma implementation "grid.h"
  22 #endif
  23
  24 // For compilers that support precompilatixon, includes "wx/wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #include "wx/defs.h"
  28
  29 #ifdef __BORLANDC__
  30     #pragma hdrstop
  31 #endif
  32
  33 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
  34 #include "gridg.cpp"
  35 #else
  36
  37 #ifndef WX_PRECOMP
  38     #include "wx/utils.h"
  39     #include "wx/dcclient.h"
  40     #include "wx/settings.h"
  41     #include "wx/log.h"
  42     #include "wx/textctrl.h"
  43     #include "wx/checkbox.h"
  44     #include "wx/combobox.h"
  45     #include "wx/valtext.h"
  46 #endif
  47
  48 #include "wx/textfile.h"
  49 #include "wx/spinctrl.h"
  50 #include "wx/tokenzr.h"
  51
  52 #include "wx/grid.h"
  53 #include "wx/generic/gridsel.h"
  54
  55 #if defined(__WXMOTIF__)
  56     #define WXUNUSED_MOTIF(identifier)  WXUNUSED(identifier)
  57 #else
  58     #define WXUNUSED_MOTIF(identifier)  identifier
  59 #endif
  60
  61 #if defined(__WXGTK__)
  62     #define WXUNUSED_GTK(identifier)    WXUNUSED(identifier)
  63 #else
  64     #define WXUNUSED_GTK(identifier)    identifier
  65 #endif
  66
  67 // Required for wxIs... functions
  68 #include <ctype.h>
  69
  70 // ----------------------------------------------------------------------------
  71 // array classes
  72 // ----------------------------------------------------------------------------
  73
  74 WX_DEFINE_EXPORTED_ARRAY(wxGridCellAttr *, wxArrayAttrs);
  75
  76 struct wxGridCellWithAttr
  77 {
  78     wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
  79         : coords(row, col), attr(attr_)
  80     {
  81     }
  82
  83     ~wxGridCellWithAttr()
  84     {
  85         attr->DecRef();
  86     }
  87
  88     wxGridCellCoords coords;
  89     wxGridCellAttr  *attr;
  90 };
  91
  92 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
  93
  94 #include "wx/arrimpl.cpp"
  95
  96 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
  97 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
  98
  99 // ----------------------------------------------------------------------------
 100 // private classes
 101 // ----------------------------------------------------------------------------
 102
 103 class WXDLLEXPORT wxGridRowLabelWindow : public wxWindow
 104 {
 105 public:
 106     wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
 107     wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
 108                           const wxPoint &pos, const wxSize &size );
 109
 110 private:
 111     wxGrid   *m_owner;
 112
 113     void OnPaint( wxPaintEvent& event );
 114     void OnMouseEvent( wxMouseEvent& event );
 115     void OnKeyDown( wxKeyEvent& event );
 116     void OnKeyUp( wxKeyEvent& );
 117
 118     DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
 119     DECLARE_EVENT_TABLE()
 120 };
 121
 122
 123 class WXDLLEXPORT wxGridColLabelWindow : public wxWindow
 124 {
 125 public:
 126     wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
 127     wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
 128                           const wxPoint &pos, const wxSize &size );
 129
 130 private:
 131     wxGrid   *m_owner;
 132
 133     void OnPaint( wxPaintEvent &event );
 134     void OnMouseEvent( wxMouseEvent& event );
 135     void OnKeyDown( wxKeyEvent& event );
 136     void OnKeyUp( wxKeyEvent& );
 137
 138     DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
 139     DECLARE_EVENT_TABLE()
 140 };
 141
 142
 143 class WXDLLEXPORT wxGridCornerLabelWindow : public wxWindow
 144 {
 145 public:
 146     wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
 147     wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
 148                              const wxPoint &pos, const wxSize &size );
 149
 150 private:
 151     wxGrid *m_owner;
 152
 153     void OnMouseEvent( wxMouseEvent& event );
 154     void OnKeyDown( wxKeyEvent& event );
 155     void OnKeyUp( wxKeyEvent& );
 156     void OnPaint( wxPaintEvent& event );
 157
 158     DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
 159     DECLARE_EVENT_TABLE()
 160 };
 161
 162 class WXDLLEXPORT wxGridWindow : public wxPanel
 163 {
 164 public:
 165     wxGridWindow()
 166     {
 167         m_owner = (wxGrid *)NULL;
 168         m_rowLabelWin = (wxGridRowLabelWindow *)NULL;
 169         m_colLabelWin = (wxGridColLabelWindow *)NULL;
 170     }
 171
 172     wxGridWindow( wxGrid *parent,
 173                   wxGridRowLabelWindow *rowLblWin,
 174                   wxGridColLabelWindow *colLblWin,
 175                   wxWindowID id, const wxPoint &pos, const wxSize &size );
 176     ~wxGridWindow();
 177
 178     void ScrollWindow( int dx, int dy, const wxRect *rect );
 179
 180 private:
 181     wxGrid                   *m_owner;
 182     wxGridRowLabelWindow     *m_rowLabelWin;
 183     wxGridColLabelWindow     *m_colLabelWin;
 184
 185     void OnPaint( wxPaintEvent &event );
 186     void OnMouseEvent( wxMouseEvent& event );
 187     void OnKeyDown( wxKeyEvent& );
 188     void OnKeyUp( wxKeyEvent& );
 189     void OnEraseBackground( wxEraseEvent& );
 190
 191
 192     DECLARE_DYNAMIC_CLASS(wxGridWindow)
 193     DECLARE_EVENT_TABLE()
 194 };
 195
 196
 197
 198 class wxGridCellEditorEvtHandler : public wxEvtHandler
 199 {
 200 public:
 201     wxGridCellEditorEvtHandler()
 202         : m_grid(0), m_editor(0)
 203         { }
 204     wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
 205         : m_grid(grid), m_editor(editor)
 206         { }
 207
 208     void OnKeyDown(wxKeyEvent& event);
 209     void OnChar(wxKeyEvent& event);
 210
 211 private:
 212     wxGrid*             m_grid;
 213     wxGridCellEditor*   m_editor;
 214     DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
 215     DECLARE_EVENT_TABLE()
 216 };
 217
 218
 219 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
 220 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
 221     EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
 222     EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
 223 END_EVENT_TABLE()
 224
 225
 226
 227 // ----------------------------------------------------------------------------
 228 // the internal data representation used by wxGridCellAttrProvider
 229 // ----------------------------------------------------------------------------
 230
 231 // this class stores attributes set for cells
 232 class WXDLLEXPORT wxGridCellAttrData
 233 {
 234 public:
 235     void SetAttr(wxGridCellAttr *attr, int row, int col);
 236     wxGridCellAttr *GetAttr(int row, int col) const;
 237     void UpdateAttrRows( size_t pos, int numRows );
 238     void UpdateAttrCols( size_t pos, int numCols );
 239
 240 private:
 241     // searches for the attr for given cell, returns wxNOT_FOUND if not found
 242     int FindIndex(int row, int col) const;
 243
 244     wxGridCellWithAttrArray m_attrs;
 245 };
 246
 247 // this class stores attributes set for rows or columns
 248 class WXDLLEXPORT wxGridRowOrColAttrData
 249 {
 250 public:
 251     // empty ctor to suppress warnings
 252     wxGridRowOrColAttrData() { }
 253     ~wxGridRowOrColAttrData();
 254
 255     void SetAttr(wxGridCellAttr *attr, int rowOrCol);
 256     wxGridCellAttr *GetAttr(int rowOrCol) const;
 257     void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
 258
 259 private:
 260     wxArrayInt m_rowsOrCols;
 261     wxArrayAttrs m_attrs;
 262 };
 263
 264 // NB: this is just a wrapper around 3 objects: one which stores cell
 265 //     attributes, and 2 others for row/col ones
 266 class WXDLLEXPORT wxGridCellAttrProviderData
 267 {
 268 public:
 269     wxGridCellAttrData m_cellAttrs;
 270     wxGridRowOrColAttrData m_rowAttrs,
 271                            m_colAttrs;
 272 };
 273
 274
 275 // ----------------------------------------------------------------------------
 276 // data structures used for the data type registry
 277 // ----------------------------------------------------------------------------
 278
 279 struct wxGridDataTypeInfo
 280 {
 281     wxGridDataTypeInfo(const wxString& typeName,
 282                        wxGridCellRenderer* renderer,
 283                        wxGridCellEditor* editor)
 284         : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
 285         { }
 286
 287     ~wxGridDataTypeInfo()
 288     {
 289         wxSafeDecRef(m_renderer);
 290         wxSafeDecRef(m_editor);
 291     }
 292
 293     wxString            m_typeName;
 294     wxGridCellRenderer* m_renderer;
 295     wxGridCellEditor*   m_editor;
 296 };
 297
 298
 299 WX_DEFINE_EXPORTED_ARRAY(wxGridDataTypeInfo*, wxGridDataTypeInfoArray);
 300
 301
 302 class WXDLLEXPORT wxGridTypeRegistry
 303 {
 304 public:
 305   wxGridTypeRegistry() {}
 306     ~wxGridTypeRegistry();
 307
 308     void RegisterDataType(const wxString& typeName,
 309                      wxGridCellRenderer* renderer,
 310                      wxGridCellEditor* editor);
 311
 312     // find one of already registered data types
 313     int FindRegisteredDataType(const wxString& typeName);
 314
 315     // try to FindRegisteredDataType(), if this fails and typeName is one of
 316     // standard typenames, register it and return its index
 317     int FindDataType(const wxString& typeName);
 318
 319     // try to FindDataType(), if it fails see if it is not one of already
 320     // registered data types with some params in which case clone the
 321     // registered data type and set params for it
 322     int FindOrCloneDataType(const wxString& typeName);
 323
 324     wxGridCellRenderer* GetRenderer(int index);
 325     wxGridCellEditor*   GetEditor(int index);
 326
 327 private:
 328     wxGridDataTypeInfoArray m_typeinfo;
 329 };
 330
 331 // ----------------------------------------------------------------------------
 332 // conditional compilation
 333 // ----------------------------------------------------------------------------
 334
 335 #ifndef WXGRID_DRAW_LINES
 336 #define WXGRID_DRAW_LINES 1
 337 #endif
 338
 339 // ----------------------------------------------------------------------------
 340 // globals
 341 // ----------------------------------------------------------------------------
 342
 343 //#define DEBUG_ATTR_CACHE
 344 #ifdef DEBUG_ATTR_CACHE
 345     static size_t gs_nAttrCacheHits = 0;
 346     static size_t gs_nAttrCacheMisses = 0;
 347 #endif // DEBUG_ATTR_CACHE
 348
 349 // ----------------------------------------------------------------------------
 350 // constants
 351 // ----------------------------------------------------------------------------
 352
 353 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 354 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 355
 356 // scroll line size
 357 // TODO: fixed so far - make configurable later (and also different for x/y)
 358 static const size_t GRID_SCROLL_LINE = 10;
 359
 360 // the size of hash tables used a bit everywhere (the max number of elements
 361 // in these hash tables is the number of rows/columns)
 362 static const int GRID_HASH_SIZE = 100;
 363
 364 // ============================================================================
 365 // implementation
 366 // ============================================================================
 367
 368 // ----------------------------------------------------------------------------
 369 // wxGridCellEditor
 370 // ----------------------------------------------------------------------------
 371
 372 wxGridCellEditor::wxGridCellEditor()
 373 {
 374     m_control = NULL;
 375 }
 376
 377
 378 wxGridCellEditor::~wxGridCellEditor()
 379 {
 380     Destroy();
 381 }
 382
 383 void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
 384                               wxWindowID WXUNUSED(id),
 385                               wxEvtHandler* evtHandler)
 386 {
 387     if ( evtHandler )
 388         m_control->PushEventHandler(evtHandler);
 389 }
 390
 391 void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
 392                                        wxGridCellAttr *attr)
 393 {
 394     // erase the background because we might not fill the cell
 395     wxClientDC dc(m_control->GetParent());
 396     dc.SetPen(*wxTRANSPARENT_PEN);
 397     dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
 398     dc.DrawRectangle(rectCell);
 399
 400     // redraw the control we just painted over
 401     m_control->Refresh();
 402 }
 403
 404 void wxGridCellEditor::Destroy()
 405 {
 406     if (m_control)
 407     {
 408         m_control->PopEventHandler(TRUE /* delete it*/);
 409
 410         m_control->Destroy();
 411         m_control = NULL;
 412     }
 413 }
 414
 415 void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
 416 {
 417     wxASSERT_MSG(m_control,
 418                  wxT("The wxGridCellEditor must be Created first!"));
 419     m_control->Show(show);
 420
 421     if ( show )
 422     {
 423         // set the colours/fonts if we have any
 424         if ( attr )
 425         {
 426             m_colFgOld = m_control->GetForegroundColour();
 427             m_control->SetForegroundColour(attr->GetTextColour());
 428
 429             m_colBgOld = m_control->GetBackgroundColour();
 430             m_control->SetBackgroundColour(attr->GetBackgroundColour());
 431
 432             m_fontOld = m_control->GetFont();
 433             m_control->SetFont(attr->GetFont());
 434
 435             // can't do anything more in the base class version, the other
 436             // attributes may only be used by the derived classes
 437         }
 438     }
 439     else
 440     {
 441         // restore the standard colours fonts
 442         if ( m_colFgOld.Ok() )
 443         {
 444             m_control->SetForegroundColour(m_colFgOld);
 445             m_colFgOld = wxNullColour;
 446         }
 447
 448         if ( m_colBgOld.Ok() )
 449         {
 450             m_control->SetBackgroundColour(m_colBgOld);
 451             m_colBgOld = wxNullColour;
 452         }
 453
 454         if ( m_fontOld.Ok() )
 455         {
 456             m_control->SetFont(m_fontOld);
 457             m_fontOld = wxNullFont;
 458         }
 459     }
 460 }
 461
 462 void wxGridCellEditor::SetSize(const wxRect& rect)
 463 {
 464     wxASSERT_MSG(m_control,
 465                  wxT("The wxGridCellEditor must be Created first!"));
 466     m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
 467 }
 468
 469 void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
 470 {
 471     event.Skip();
 472 }
 473
 474 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
 475 {
 476     // accept the simple key presses, not anything with Ctrl/Alt/Meta
 477     return !event.HasModifiers();
 478 }
 479
 480 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
 481 {
 482     event.Skip();
 483 }
 484
 485 void wxGridCellEditor::StartingClick()
 486 {
 487 }
 488
 489 // ----------------------------------------------------------------------------
 490 // wxGridCellTextEditor
 491 // ----------------------------------------------------------------------------
 492
 493 wxGridCellTextEditor::wxGridCellTextEditor()
 494 {
 495     m_maxChars = 0;
 496 }
 497
 498 void wxGridCellTextEditor::Create(wxWindow* parent,
 499                                   wxWindowID id,
 500                                   wxEvtHandler* evtHandler)
 501 {
 502     m_control = new wxTextCtrl(parent, id, wxEmptyString,
 503                                wxDefaultPosition, wxDefaultSize
 504 #if defined(__WXMSW__)
 505                                , wxTE_MULTILINE | wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
 506 #endif
 507                               );
 508
 509     // TODO: use m_maxChars
 510
 511     wxGridCellEditor::Create(parent, id, evtHandler);
 512 }
 513
 514 void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
 515                                            wxGridCellAttr * WXUNUSED(attr))
 516 {
 517     // as we fill the entire client area, don't do anything here to minimize
 518     // flicker
 519 }
 520
 521 void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
 522 {
 523     wxRect rect(rectOrig);
 524
 525     // Make the edit control large enough to allow for internal
 526     // margins
 527     //
 528     // TODO: remove this if the text ctrl sizing is improved esp. for
 529     // unix
 530     //
 531 #if defined(__WXGTK__)
 532     if (rect.x != 0)
 533     {
 534         rect.x += 1;
 535         rect.y += 1;
 536         rect.width -= 1;
 537         rect.height -= 1;
 538     }
 539 #else // !GTK
 540     int extra_x = ( rect.x > 2 )? 2 : 1;
 541
 542 // MB: treat MSW separately here otherwise the caret doesn't show
 543 // when the editor is in the first row.
 544 #if defined(__WXMSW__)
 545     int extra_y = 2;
 546 #else
 547     int extra_y = ( rect.y > 2 )? 2 : 1;
 548 #endif // MSW
 549
 550 #if defined(__WXMOTIF__)
 551     extra_x *= 2;
 552     extra_y *= 2;
 553 #endif
 554     rect.SetLeft( wxMax(0, rect.x - extra_x) );
 555     rect.SetTop( wxMax(0, rect.y - extra_y) );
 556     rect.SetRight( rect.GetRight() + 2*extra_x );
 557     rect.SetBottom( rect.GetBottom() + 2*extra_y );
 558 #endif // GTK/!GTK
 559
 560     wxGridCellEditor::SetSize(rect);
 561 }
 562
 563 void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
 564 {
 565     wxASSERT_MSG(m_control,
 566                  wxT("The wxGridCellEditor must be Created first!"));
 567
 568     m_startValue = grid->GetTable()->GetValue(row, col);
 569
 570     DoBeginEdit(m_startValue);
 571 }
 572
 573 void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
 574 {
 575     Text()->SetValue(startValue);
 576     Text()->SetInsertionPointEnd();
 577     Text()->SetFocus();
 578 }
 579
 580 bool wxGridCellTextEditor::EndEdit(int row, int col,
 581                                    wxGrid* grid)
 582 {
 583     wxASSERT_MSG(m_control,
 584                  wxT("The wxGridCellEditor must be Created first!"));
 585
 586     bool changed = FALSE;
 587     wxString value = Text()->GetValue();
 588     if (value != m_startValue)
 589         changed = TRUE;
 590
 591     if (changed)
 592         grid->GetTable()->SetValue(row, col, value);
 593
 594     m_startValue = wxEmptyString;
 595     Text()->SetValue(m_startValue);
 596
 597     return changed;
 598 }
 599
 600
 601 void wxGridCellTextEditor::Reset()
 602 {
 603     wxASSERT_MSG(m_control,
 604                  wxT("The wxGridCellEditor must be Created first!"));
 605
 606     DoReset(m_startValue);
 607 }
 608
 609 void wxGridCellTextEditor::DoReset(const wxString& startValue)
 610 {
 611     Text()->SetValue(startValue);
 612     Text()->SetInsertionPointEnd();
 613 }
 614
 615 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
 616 {
 617     if ( wxGridCellEditor::IsAcceptedKey(event) )
 618     {
 619         int keycode = event.GetKeyCode();
 620         switch ( keycode )
 621         {
 622             case WXK_NUMPAD0:
 623             case WXK_NUMPAD1:
 624             case WXK_NUMPAD2:
 625             case WXK_NUMPAD3:
 626             case WXK_NUMPAD4:
 627             case WXK_NUMPAD5:
 628             case WXK_NUMPAD6:
 629             case WXK_NUMPAD7:
 630             case WXK_NUMPAD8:
 631             case WXK_NUMPAD9:
 632             case WXK_MULTIPLY:
 633             case WXK_NUMPAD_MULTIPLY:
 634             case WXK_ADD:
 635             case WXK_NUMPAD_ADD:
 636             case WXK_SUBTRACT:
 637             case WXK_NUMPAD_SUBTRACT:
 638             case WXK_DECIMAL:
 639             case WXK_NUMPAD_DECIMAL:
 640             case WXK_DIVIDE:
 641             case WXK_NUMPAD_DIVIDE:
 642                 return TRUE;
 643
 644             default:
 645                 // accept 8 bit chars too if isprint() agrees
 646                 if ( (keycode < 255) && (isprint(keycode)) )
 647                     return TRUE;
 648         }
 649     }
 650
 651     return FALSE;
 652 }
 653
 654 void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
 655 {
 656     // we don't check for !HasModifiers() because IsAcceptedKey() did it
 657
 658     // insert the key in the control
 659     wxChar ch;
 660     int keycode = event.GetKeyCode();
 661     switch ( keycode )
 662     {
 663         case WXK_NUMPAD0:
 664         case WXK_NUMPAD1:
 665         case WXK_NUMPAD2:
 666         case WXK_NUMPAD3:
 667         case WXK_NUMPAD4:
 668         case WXK_NUMPAD5:
 669         case WXK_NUMPAD6:
 670         case WXK_NUMPAD7:
 671         case WXK_NUMPAD8:
 672         case WXK_NUMPAD9:
 673             ch = _T('0') + keycode - WXK_NUMPAD0;
 674             break;
 675
 676         case WXK_MULTIPLY:
 677         case WXK_NUMPAD_MULTIPLY:
 678             ch = _T('*');
 679             break;
 680
 681         case WXK_ADD:
 682         case WXK_NUMPAD_ADD:
 683             ch = _T('+');
 684             break;
 685
 686         case WXK_SUBTRACT:
 687         case WXK_NUMPAD_SUBTRACT:
 688             ch = _T('-');
 689             break;
 690
 691         case WXK_DECIMAL:
 692         case WXK_NUMPAD_DECIMAL:
 693             ch = _T('.');
 694             break;
 695
 696         case WXK_DIVIDE:
 697         case WXK_NUMPAD_DIVIDE:
 698             ch = _T('/');
 699             break;
 700
 701         default:
 702             if ( keycode < 256 && keycode >= 0 && isprint(keycode) )
 703             {
 704                 // FIXME this is not going to work for non letters...
 705                 if ( !event.ShiftDown() )
 706                 {
 707                     keycode = tolower(keycode);
 708                 }
 709
 710                 ch = (wxChar)keycode;
 711             }
 712             else
 713             {
 714                 ch = _T('\0');
 715             }
 716     }
 717
 718     if ( ch )
 719     {
 720         Text()->AppendText(ch);
 721     }
 722     else
 723     {
 724         event.Skip();
 725     }
 726 }
 727
 728 void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
 729                                          WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
 730 {
 731 #if defined(__WXMOTIF__) || defined(__WXGTK__)
 732     // wxMotif needs a little extra help...
 733     size_t pos = (size_t)( Text()->GetInsertionPoint() );
 734     wxString s( Text()->GetValue() );
 735     s = s.Left(pos) + "\n" + s.Mid(pos);
 736     Text()->SetValue(s);
 737     Text()->SetInsertionPoint( pos );
 738 #else
 739     // the other ports can handle a Return key press
 740     //
 741     event.Skip();
 742 #endif
 743 }
 744
 745 void wxGridCellTextEditor::SetParameters(const wxString& params)
 746 {
 747     if ( !params )
 748     {
 749         // reset to default
 750         m_maxChars = 0;
 751     }
 752     else
 753     {
 754         long tmp;
 755         if ( !params.ToLong(&tmp) )
 756         {
 757             wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str());
 758         }
 759         else
 760         {
 761             m_maxChars = (size_t)tmp;
 762         }
 763     }
 764 }
 765
 766 // ----------------------------------------------------------------------------
 767 // wxGridCellNumberEditor
 768 // ----------------------------------------------------------------------------
 769
 770 wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
 771 {
 772     m_min = min;
 773     m_max = max;
 774 }
 775
 776 void wxGridCellNumberEditor::Create(wxWindow* parent,
 777                                     wxWindowID id,
 778                                     wxEvtHandler* evtHandler)
 779 {
 780     if ( HasRange() )
 781     {
 782         // create a spin ctrl
 783         m_control = new wxSpinCtrl(parent, -1, wxEmptyString,
 784                                    wxDefaultPosition, wxDefaultSize,
 785                                    wxSP_ARROW_KEYS,
 786                                    m_min, m_max);
 787
 788         wxGridCellEditor::Create(parent, id, evtHandler);
 789     }
 790     else
 791     {
 792         // just a text control
 793         wxGridCellTextEditor::Create(parent, id, evtHandler);
 794
 795 #if wxUSE_VALIDATORS
 796         Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
 797 #endif // wxUSE_VALIDATORS
 798     }
 799 }
 800
 801 void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
 802 {
 803     // first get the value
 804     wxGridTableBase *table = grid->GetTable();
 805     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
 806     {
 807         m_valueOld = table->GetValueAsLong(row, col);
 808     }
 809     else
 810     {
 811         wxString sValue = table->GetValue(row, col);
 812         if (! sValue.ToLong(&m_valueOld))
 813         {
 814             wxFAIL_MSG( _T("this cell doesn't have numeric value") );
 815             return;
 816         }
 817     }
 818
 819     if ( HasRange() )
 820     {
 821         Spin()->SetValue((int)m_valueOld);
 822         Spin()->SetFocus();
 823     }
 824     else
 825     {
 826         DoBeginEdit(GetString());
 827     }
 828 }
 829
 830 bool wxGridCellNumberEditor::EndEdit(int row, int col,
 831                                      wxGrid* grid)
 832 {
 833     bool changed;
 834     long value;
 835
 836     if ( HasRange() )
 837     {
 838         value = Spin()->GetValue();
 839         changed = value != m_valueOld;
 840     }
 841     else
 842     {
 843         changed = Text()->GetValue().ToLong(&value) && (value != m_valueOld);
 844     }
 845
 846     if ( changed )
 847     {
 848         if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER))
 849             grid->GetTable()->SetValueAsLong(row, col, value);
 850         else
 851             grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%ld"), value));
 852     }
 853
 854     return changed;
 855 }
 856
 857 void wxGridCellNumberEditor::Reset()
 858 {
 859     if ( HasRange() )
 860     {
 861         Spin()->SetValue((int)m_valueOld);
 862     }
 863     else
 864     {
 865         DoReset(GetString());
 866     }
 867 }
 868
 869 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
 870 {
 871     if ( wxGridCellEditor::IsAcceptedKey(event) )
 872     {
 873         int keycode = event.GetKeyCode();
 874         switch ( keycode )
 875         {
 876             case WXK_NUMPAD0:
 877             case WXK_NUMPAD1:
 878             case WXK_NUMPAD2:
 879             case WXK_NUMPAD3:
 880             case WXK_NUMPAD4:
 881             case WXK_NUMPAD5:
 882             case WXK_NUMPAD6:
 883             case WXK_NUMPAD7:
 884             case WXK_NUMPAD8:
 885             case WXK_NUMPAD9:
 886             case WXK_ADD:
 887             case WXK_NUMPAD_ADD:
 888             case WXK_SUBTRACT:
 889             case WXK_NUMPAD_SUBTRACT:
 890             case WXK_UP:
 891             case WXK_DOWN:
 892                 return TRUE;
 893
 894             default:
 895                 if ( (keycode < 128) && isdigit(keycode) )
 896                     return TRUE;
 897         }
 898     }
 899
 900     return FALSE;
 901 }
 902
 903 void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
 904 {
 905     if ( !HasRange() )
 906     {
 907         int keycode = (int) event.KeyCode();
 908         if ( isdigit(keycode) || keycode == '+' || keycode == '-' )
 909         {
 910             wxGridCellTextEditor::StartingKey(event);
 911
 912             // skip Skip() below
 913             return;
 914         }
 915     }
 916
 917     event.Skip();
 918 }
 919
 920 void wxGridCellNumberEditor::SetParameters(const wxString& params)
 921 {
 922     if ( !params )
 923     {
 924         // reset to default
 925         m_min =
 926         m_max = -1;
 927     }
 928     else
 929     {
 930         long tmp;
 931         if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
 932         {
 933             m_min = (int)tmp;
 934
 935             if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
 936             {
 937                 m_max = (int)tmp;
 938
 939                 // skip the error message below
 940                 return;
 941             }
 942         }
 943
 944         wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
 945     }
 946 }
 947
 948 // ----------------------------------------------------------------------------
 949 // wxGridCellFloatEditor
 950 // ----------------------------------------------------------------------------
 951
 952 wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
 953 {
 954     m_width = width;
 955     m_precision = precision;
 956 }
 957
 958 void wxGridCellFloatEditor::Create(wxWindow* parent,
 959                                    wxWindowID id,
 960                                    wxEvtHandler* evtHandler)
 961 {
 962     wxGridCellTextEditor::Create(parent, id, evtHandler);
 963
 964 #if wxUSE_VALIDATORS
 965     Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
 966 #endif // wxUSE_VALIDATORS
 967 }
 968
 969 void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
 970 {
 971     // first get the value
 972     wxGridTableBase *table = grid->GetTable();
 973     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
 974     {
 975         m_valueOld = table->GetValueAsDouble(row, col);
 976     }
 977     else
 978     {
 979         wxString sValue = table->GetValue(row, col);
 980         if (! sValue.ToDouble(&m_valueOld))
 981         {
 982             wxFAIL_MSG( _T("this cell doesn't have float value") );
 983             return;
 984         }
 985     }
 986
 987     DoBeginEdit(GetString());
 988 }
 989
 990 bool wxGridCellFloatEditor::EndEdit(int row, int col,
 991                                      wxGrid* grid)
 992 {
 993     double value;
 994     if ( Text()->GetValue().ToDouble(&value) && (value != m_valueOld) )
 995     {
 996         if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
 997             grid->GetTable()->SetValueAsDouble(row, col, value);
 998         else
 999             grid->GetTable()->SetValue(row, col, wxString::Format(wxT("%f"), value));
1000
1001         return TRUE;
1002     }
1003     else
1004     {
1005         return FALSE;
1006     }
1007 }
1008
1009 void wxGridCellFloatEditor::Reset()
1010 {
1011     DoReset(GetString());
1012 }
1013
1014 void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
1015 {
1016     int keycode = (int)event.KeyCode();
1017     if ( isdigit(keycode) ||
1018          keycode == '+' || keycode == '-' || keycode == '.' )
1019     {
1020         wxGridCellTextEditor::StartingKey(event);
1021
1022         // skip Skip() below
1023         return;
1024     }
1025
1026     event.Skip();
1027 }
1028
1029 void wxGridCellFloatEditor::SetParameters(const wxString& params)
1030 {
1031     if ( !params )
1032     {
1033         // reset to default
1034         m_width =
1035         m_precision = -1;
1036     }
1037     else
1038     {
1039         long tmp;
1040         if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
1041         {
1042             m_width = (int)tmp;
1043
1044             if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
1045             {
1046                 m_precision = (int)tmp;
1047
1048                 // skip the error message below
1049                 return;
1050             }
1051         }
1052
1053         wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
1054     }
1055 }
1056
1057 wxString wxGridCellFloatEditor::GetString() const
1058 {
1059     wxString fmt;
1060     if ( m_width == -1 )
1061     {
1062         // default width/precision
1063         fmt = _T("%g");
1064     }
1065     else if ( m_precision == -1 )
1066     {
1067         // default precision
1068         fmt.Printf(_T("%%%d.g"), m_width);
1069     }
1070     else
1071     {
1072         fmt.Printf(_T("%%%d.%dg"), m_width, m_precision);
1073     }
1074
1075     return wxString::Format(fmt, m_valueOld);
1076 }
1077
1078 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
1079 {
1080     if ( wxGridCellEditor::IsAcceptedKey(event) )
1081     {
1082         int keycode = event.GetKeyCode();
1083         switch ( keycode )
1084         {
1085             case WXK_NUMPAD0:
1086             case WXK_NUMPAD1:
1087             case WXK_NUMPAD2:
1088             case WXK_NUMPAD3:
1089             case WXK_NUMPAD4:
1090             case WXK_NUMPAD5:
1091             case WXK_NUMPAD6:
1092             case WXK_NUMPAD7:
1093             case WXK_NUMPAD8:
1094             case WXK_NUMPAD9:
1095             case WXK_ADD:
1096             case WXK_NUMPAD_ADD:
1097             case WXK_SUBTRACT:
1098             case WXK_NUMPAD_SUBTRACT:
1099             case WXK_DECIMAL:
1100             case WXK_NUMPAD_DECIMAL:
1101                 return TRUE;
1102
1103             default:
1104                 // additionally accept 'e' as in '1e+6'
1105                 if ( (keycode < 128) &&
1106                      (isdigit(keycode) || tolower(keycode) == 'e') )
1107                     return TRUE;
1108         }
1109     }
1110
1111     return FALSE;
1112 }
1113
1114 // ----------------------------------------------------------------------------
1115 // wxGridCellBoolEditor
1116 // ----------------------------------------------------------------------------
1117
1118 void wxGridCellBoolEditor::Create(wxWindow* parent,
1119                                   wxWindowID id,
1120                                   wxEvtHandler* evtHandler)
1121 {
1122     m_control = new wxCheckBox(parent, id, wxEmptyString,
1123                                wxDefaultPosition, wxDefaultSize,
1124                                wxNO_BORDER);
1125
1126     wxGridCellEditor::Create(parent, id, evtHandler);
1127 }
1128
1129 void wxGridCellBoolEditor::SetSize(const wxRect& r)
1130 {
1131     bool resize = FALSE;
1132     wxSize size = m_control->GetSize();
1133     wxCoord minSize = wxMin(r.width, r.height);
1134
1135     // check if the checkbox is not too big/small for this cell
1136     wxSize sizeBest = m_control->GetBestSize();
1137     if ( !(size == sizeBest) )
1138     {
1139         // reset to default size if it had been made smaller
1140         size = sizeBest;
1141
1142         resize = TRUE;
1143     }
1144
1145     if ( size.x >= minSize || size.y >= minSize )
1146     {
1147         // leave 1 pixel margin
1148         size.x = size.y = minSize - 2;
1149
1150         resize = TRUE;
1151     }
1152
1153     if ( resize )
1154     {
1155         m_control->SetSize(size);
1156     }
1157
1158     // position it in the centre of the rectangle (TODO: support alignment?)
1159
1160 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1161     // the checkbox without label still has some space to the right in wxGTK,
1162     // so shift it to the right
1163     size.x -= 8;
1164 #elif defined(__WXMSW__)
1165     // here too, but in other way
1166     size.x += 1;
1167     size.y -= 2;
1168 #endif
1169
1170     m_control->Move(r.x + r.width/2 - size.x/2, r.y + r.height/2 - size.y/2);
1171 }
1172
1173 void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
1174 {
1175     m_control->Show(show);
1176
1177     if ( show )
1178     {
1179         wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
1180         CBox()->SetBackgroundColour(colBg);
1181     }
1182 }
1183
1184 void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
1185 {
1186     wxASSERT_MSG(m_control,
1187                  wxT("The wxGridCellEditor must be Created first!"));
1188
1189     if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1190         m_startValue = grid->GetTable()->GetValueAsBool(row, col);
1191     else
1192         m_startValue = !!grid->GetTable()->GetValue(row, col);
1193     CBox()->SetValue(m_startValue);
1194     CBox()->SetFocus();
1195 }
1196
1197 bool wxGridCellBoolEditor::EndEdit(int row, int col,
1198                                    wxGrid* grid)
1199 {
1200     wxASSERT_MSG(m_control,
1201                  wxT("The wxGridCellEditor must be Created first!"));
1202
1203     bool changed = FALSE;
1204     bool value = CBox()->GetValue();
1205     if ( value != m_startValue )
1206         changed = TRUE;
1207
1208     if ( changed )
1209     {
1210         if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
1211             grid->GetTable()->SetValueAsBool(row, col, value);
1212         else
1213             grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
1214     }
1215
1216     return changed;
1217 }
1218
1219 void wxGridCellBoolEditor::Reset()
1220 {
1221     wxASSERT_MSG(m_control,
1222                  wxT("The wxGridCellEditor must be Created first!"));
1223
1224     CBox()->SetValue(m_startValue);
1225 }
1226
1227 void wxGridCellBoolEditor::StartingClick()
1228 {
1229     CBox()->SetValue(!CBox()->GetValue());
1230 }
1231
1232 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
1233 {
1234     if ( wxGridCellEditor::IsAcceptedKey(event) )
1235     {
1236         int keycode = event.GetKeyCode();
1237         switch ( keycode )
1238         {
1239             case WXK_MULTIPLY:
1240             case WXK_NUMPAD_MULTIPLY:
1241             case WXK_ADD:
1242             case WXK_NUMPAD_ADD:
1243             case WXK_SUBTRACT:
1244             case WXK_NUMPAD_SUBTRACT:
1245             case WXK_SPACE:
1246             case '+':
1247             case '-':
1248                 return TRUE;
1249         }
1250     }
1251
1252     return FALSE;
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // wxGridCellChoiceEditor
1257 // ----------------------------------------------------------------------------
1258
1259 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
1260                                                const wxString choices[],
1261                                                bool allowOthers)
1262                       : m_allowOthers(allowOthers)
1263 {
1264     if ( count )
1265     {
1266         m_choices.Alloc(count);
1267         for ( size_t n = 0; n < count; n++ )
1268         {
1269             m_choices.Add(choices[n]);
1270         }
1271     }
1272 }
1273
1274 wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
1275 {
1276     wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
1277     editor->m_allowOthers = m_allowOthers;
1278     editor->m_choices = m_choices;
1279
1280     return editor;
1281 }
1282
1283 void wxGridCellChoiceEditor::Create(wxWindow* parent,
1284                                     wxWindowID id,
1285                                     wxEvtHandler* evtHandler)
1286 {
1287     size_t count = m_choices.GetCount();
1288     wxString *choices = new wxString[count];
1289     for ( size_t n = 0; n < count; n++ )
1290     {
1291         choices[n] = m_choices[n];
1292     }
1293
1294     m_control = new wxComboBox(parent, id, wxEmptyString,
1295                                wxDefaultPosition, wxDefaultSize,
1296                                count, choices,
1297                                m_allowOthers ? 0 : wxCB_READONLY);
1298
1299     delete [] choices;
1300
1301     wxGridCellEditor::Create(parent, id, evtHandler);
1302 }
1303
1304 void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
1305                                              wxGridCellAttr * attr)
1306 {
1307     // as we fill the entire client area, don't do anything here to minimize
1308     // flicker
1309
1310     // TODO: It doesn't actually fill the client area since the height of a
1311     // combo always defaults to the standard...  Until someone has time to
1312     // figure out the right rectangle to paint, just do it the normal way...
1313     wxGridCellEditor::PaintBackground(rectCell, attr);
1314 }
1315
1316 void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
1317 {
1318     wxASSERT_MSG(m_control,
1319                  wxT("The wxGridCellEditor must be Created first!"));
1320
1321     m_startValue = grid->GetTable()->GetValue(row, col);
1322
1323     Combo()->SetValue(m_startValue);
1324     size_t count = m_choices.GetCount();
1325     for (size_t i=0; i<count; i++)
1326     {
1327         if (m_startValue == m_choices[i])
1328         {
1329             Combo()->SetSelection(i);
1330             break;
1331         }
1332     }
1333     Combo()->SetInsertionPointEnd();
1334     Combo()->SetFocus();
1335 }
1336
1337 bool wxGridCellChoiceEditor::EndEdit(int row, int col,
1338                                      wxGrid* grid)
1339 {
1340     wxString value = Combo()->GetValue();
1341     bool changed = value != m_startValue;
1342
1343     if ( changed )
1344         grid->GetTable()->SetValue(row, col, value);
1345
1346     m_startValue = wxEmptyString;
1347     Combo()->SetValue(m_startValue);
1348
1349     return changed;
1350 }
1351
1352 void wxGridCellChoiceEditor::Reset()
1353 {
1354     Combo()->SetValue(m_startValue);
1355     Combo()->SetInsertionPointEnd();
1356 }
1357
1358 void wxGridCellChoiceEditor::SetParameters(const wxString& params)
1359 {
1360     if ( !params )
1361     {
1362         // what can we do?
1363         return;
1364     }
1365
1366     m_choices.Empty();
1367
1368     wxStringTokenizer tk(params, _T(','));
1369     while ( tk.HasMoreTokens() )
1370     {
1371         m_choices.Add(tk.GetNextToken());
1372     }
1373 }
1374
1375 // ----------------------------------------------------------------------------
1376 // wxGridCellEditorEvtHandler
1377 // ----------------------------------------------------------------------------
1378
1379 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
1380 {
1381     switch ( event.KeyCode() )
1382     {
1383         case WXK_ESCAPE:
1384             m_editor->Reset();
1385             m_grid->DisableCellEditControl();
1386             break;
1387
1388         case WXK_TAB:
1389             event.Skip( m_grid->ProcessEvent( event ) );
1390             break;
1391
1392         case WXK_RETURN:
1393             if (!m_grid->ProcessEvent(event))
1394                 m_editor->HandleReturn(event);
1395             break;
1396
1397
1398         default:
1399             event.Skip();
1400     }
1401 }
1402
1403 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
1404 {
1405     switch ( event.KeyCode() )
1406     {
1407         case WXK_ESCAPE:
1408         case WXK_TAB:
1409         case WXK_RETURN:
1410             break;
1411
1412         default:
1413             event.Skip();
1414     }
1415 }
1416
1417 // ----------------------------------------------------------------------------
1418 // wxGridCellWorker is an (almost) empty common base class for
1419 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1420 // ----------------------------------------------------------------------------
1421
1422 void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
1423 {
1424     // nothing to do
1425 }
1426
1427 wxGridCellWorker::~wxGridCellWorker()
1428 {
1429 }
1430
1431 // ============================================================================
1432 // renderer classes
1433 // ============================================================================
1434
1435 // ----------------------------------------------------------------------------
1436 // wxGridCellRenderer
1437 // ----------------------------------------------------------------------------
1438
1439 void wxGridCellRenderer::Draw(wxGrid& grid,
1440                               wxGridCellAttr& attr,
1441                               wxDC& dc,
1442                               const wxRect& rect,
1443                               int WXUNUSED(row), int WXUNUSED(col),
1444                               bool isSelected)
1445 {
1446     dc.SetBackgroundMode( wxSOLID );
1447
1448     if ( isSelected )
1449     {
1450         dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
1451     }
1452     else
1453     {
1454         dc.SetBrush( wxBrush(attr.GetBackgroundColour(), wxSOLID) );
1455     }
1456
1457     dc.SetPen( *wxTRANSPARENT_PEN );
1458     dc.DrawRectangle(rect);
1459 }
1460
1461 // ----------------------------------------------------------------------------
1462 // wxGridCellStringRenderer
1463 // ----------------------------------------------------------------------------
1464
1465 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
1466                                                      wxGridCellAttr& attr,
1467                                                      wxDC& dc,
1468                                                      bool isSelected)
1469 {
1470     dc.SetBackgroundMode( wxTRANSPARENT );
1471
1472     // TODO some special colours for attr.IsReadOnly() case?
1473
1474     if ( isSelected )
1475     {
1476         dc.SetTextBackground( grid.GetSelectionBackground() );
1477         dc.SetTextForeground( grid.GetSelectionForeground() );
1478     }
1479     else
1480     {
1481         dc.SetTextBackground( attr.GetBackgroundColour() );
1482         dc.SetTextForeground( attr.GetTextColour() );
1483     }
1484
1485     dc.SetFont( attr.GetFont() );
1486 }
1487
1488 wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
1489                                                wxDC& dc,
1490                                                const wxString& text)
1491 {
1492     wxCoord x = 0, y = 0, max_x = 0;
1493     dc.SetFont(attr.GetFont());
1494     wxStringTokenizer tk(text, _T('\n'));
1495     while ( tk.HasMoreTokens() )
1496     {
1497         dc.GetTextExtent(tk.GetNextToken(), &x, &y);
1498         max_x = wxMax(max_x, x);
1499     }
1500
1501     y *= 1 + text.Freq(wxT('\n')); // multiply by the number of lines.
1502
1503     return wxSize(max_x, y);
1504 }
1505
1506 wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
1507                                              wxGridCellAttr& attr,
1508                                              wxDC& dc,
1509                                              int row, int col)
1510 {
1511     return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
1512 }
1513
1514 void wxGridCellStringRenderer::Draw(wxGrid& grid,
1515                                     wxGridCellAttr& attr,
1516                                     wxDC& dc,
1517                                     const wxRect& rectCell,
1518                                     int row, int col,
1519                                     bool isSelected)
1520 {
1521     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1522
1523     // now we only have to draw the text
1524     SetTextColoursAndFont(grid, attr, dc, isSelected);
1525
1526     int hAlign, vAlign;
1527     attr.GetAlignment(&hAlign, &vAlign);
1528
1529     wxRect rect = rectCell;
1530     rect.Inflate(-1);
1531
1532     grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
1533                            rect, hAlign, vAlign);
1534 }
1535
1536 // ----------------------------------------------------------------------------
1537 // wxGridCellNumberRenderer
1538 // ----------------------------------------------------------------------------
1539
1540 wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
1541 {
1542     wxGridTableBase *table = grid.GetTable();
1543     wxString text;
1544     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
1545     {
1546         text.Printf(_T("%ld"), table->GetValueAsLong(row, col));
1547     }
1548     else
1549     {
1550         text = table->GetValue(row, col);
1551     }
1552
1553     return text;
1554 }
1555
1556 void wxGridCellNumberRenderer::Draw(wxGrid& grid,
1557                                     wxGridCellAttr& attr,
1558                                     wxDC& dc,
1559                                     const wxRect& rectCell,
1560                                     int row, int col,
1561                                     bool isSelected)
1562 {
1563     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1564
1565     SetTextColoursAndFont(grid, attr, dc, isSelected);
1566
1567     // draw the text right aligned by default
1568     int hAlign, vAlign;
1569     attr.GetAlignment(&hAlign, &vAlign);
1570     hAlign = wxALIGN_RIGHT;
1571
1572     wxRect rect = rectCell;
1573     rect.Inflate(-1);
1574
1575     grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1576 }
1577
1578 wxSize wxGridCellNumberRenderer::GetBestSize(wxGrid& grid,
1579                                              wxGridCellAttr& attr,
1580                                              wxDC& dc,
1581                                              int row, int col)
1582 {
1583     return DoGetBestSize(attr, dc, GetString(grid, row, col));
1584 }
1585
1586 // ----------------------------------------------------------------------------
1587 // wxGridCellFloatRenderer
1588 // ----------------------------------------------------------------------------
1589
1590 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width, int precision)
1591 {
1592     SetWidth(width);
1593     SetPrecision(precision);
1594 }
1595
1596 wxGridCellRenderer *wxGridCellFloatRenderer::Clone() const
1597 {
1598     wxGridCellFloatRenderer *renderer = new wxGridCellFloatRenderer;
1599     renderer->m_width = m_width;
1600     renderer->m_precision = m_precision;
1601     renderer->m_format = m_format;
1602
1603     return renderer;
1604 }
1605
1606 wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
1607 {
1608     wxGridTableBase *table = grid.GetTable();
1609
1610     bool hasDouble;
1611     double val;
1612     wxString text;
1613     if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
1614     {
1615         val = table->GetValueAsDouble(row, col);
1616         hasDouble = TRUE;
1617     }
1618     else
1619     {
1620         text = table->GetValue(row, col);
1621         hasDouble = text.ToDouble(&val);
1622     }
1623
1624     if ( hasDouble )
1625     {
1626         if ( !m_format )
1627         {
1628             if ( m_width == -1 )
1629             {
1630                 // default width/precision
1631                 m_format = _T("%f");
1632             }
1633             else if ( m_precision == -1 )
1634             {
1635                 // default precision
1636                 m_format.Printf(_T("%%%d.f"), m_width);
1637             }
1638             else
1639             {
1640                 m_format.Printf(_T("%%%d.%df"), m_width, m_precision);
1641             }
1642         }
1643
1644         text.Printf(m_format, val);
1645     }
1646     //else: text already contains the string
1647
1648     return text;
1649 }
1650
1651 void wxGridCellFloatRenderer::Draw(wxGrid& grid,
1652                                    wxGridCellAttr& attr,
1653                                    wxDC& dc,
1654                                    const wxRect& rectCell,
1655                                    int row, int col,
1656                                    bool isSelected)
1657 {
1658     wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
1659
1660     SetTextColoursAndFont(grid, attr, dc, isSelected);
1661
1662     // draw the text right aligned by default
1663     int hAlign, vAlign;
1664     attr.GetAlignment(&hAlign, &vAlign);
1665     hAlign = wxALIGN_RIGHT;
1666
1667     wxRect rect = rectCell;
1668     rect.Inflate(-1);
1669
1670     grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
1671 }
1672
1673 wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
1674                                             wxGridCellAttr& attr,
1675                                             wxDC& dc,
1676                                             int row, int col)
1677 {
1678     return DoGetBestSize(attr, dc, GetString(grid, row, col));
1679 }
1680
1681 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
1682 {
1683     bool ok = TRUE;
1684
1685     if ( !params )
1686     {
1687         // reset to defaults
1688         SetWidth(-1);
1689         SetPrecision(-1);
1690     }
1691     else
1692     {
1693         wxString tmp = params.BeforeFirst(_T(','));
1694         if ( !!tmp )
1695         {
1696             long width;
1697             if ( !tmp.ToLong(&width) )
1698             {
1699                 ok = FALSE;
1700             }
1701             else
1702             {
1703                 SetWidth((int)width);
1704
1705                 tmp = params.AfterFirst(_T(','));
1706                 if ( !!tmp )
1707                 {
1708                     long precision;
1709                     if ( !tmp.ToLong(&precision) )
1710                     {
1711                         ok = FALSE;
1712                     }
1713                     else
1714                     {
1715                         SetPrecision((int)precision);
1716                     }
1717                 }
1718             }
1719         }
1720
1721         if ( !ok )
1722         {
1723             wxLogDebug(_T("Invalid wxGridCellFloatRenderer parameter string '%s ignored"), params.c_str());
1724         }
1725     }
1726 }
1727
1728 // ----------------------------------------------------------------------------
1729 // wxGridCellBoolRenderer
1730 // ----------------------------------------------------------------------------
1731
1732 wxSize wxGridCellBoolRenderer::ms_sizeCheckMark;
1733
1734 // FIXME these checkbox size calculations are really ugly...
1735
1736 // between checkmark and box
1737 static const wxCoord wxGRID_CHECKMARK_MARGIN = 2;
1738
1739 wxSize wxGridCellBoolRenderer::GetBestSize(wxGrid& grid,
1740                                            wxGridCellAttr& WXUNUSED(attr),
1741                                            wxDC& WXUNUSED(dc),
1742                                            int WXUNUSED(row),
1743                                            int WXUNUSED(col))
1744 {
1745     // compute it only once (no locks for MT safeness in GUI thread...)
1746     if ( !ms_sizeCheckMark.x )
1747     {
1748         // get checkbox size
1749         wxCoord checkSize = 0;
1750         wxCheckBox *checkbox = new wxCheckBox(&grid, -1, wxEmptyString);
1751         wxSize size = checkbox->GetBestSize();
1752         checkSize = size.y + 2*wxGRID_CHECKMARK_MARGIN;
1753
1754         // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1755 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1756         checkSize -= size.y / 2;
1757 #endif
1758
1759         delete checkbox;
1760
1761         ms_sizeCheckMark.x = ms_sizeCheckMark.y = checkSize;
1762     }
1763
1764     return ms_sizeCheckMark;
1765 }
1766
1767 void wxGridCellBoolRenderer::Draw(wxGrid& grid,
1768                                   wxGridCellAttr& attr,
1769                                   wxDC& dc,
1770                                   const wxRect& rect,
1771                                   int row, int col,
1772                                   bool isSelected)
1773 {
1774     wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
1775
1776     // draw a check mark in the centre (ignoring alignment - TODO)
1777     wxSize size = GetBestSize(grid, attr, dc, row, col);
1778
1779     // don't draw outside the cell
1780     wxCoord minSize = wxMin(rect.width, rect.height);
1781     if ( size.x >= minSize || size.y >= minSize )
1782     {
1783         // and even leave (at least) 1 pixel margin
1784         size.x = size.y = minSize - 2;
1785     }
1786
1787     // draw a border around checkmark
1788     wxRect rectBorder;
1789     rectBorder.x = rect.x + rect.width/2 - size.x/2;
1790     rectBorder.y = rect.y + rect.height/2 - size.y/2;
1791     rectBorder.width = size.x;
1792     rectBorder.height = size.y;
1793
1794     bool value;
1795     if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
1796         value = grid.GetTable()->GetValueAsBool(row, col);
1797     else
1798         value = !!grid.GetTable()->GetValue(row, col);
1799
1800     if ( value )
1801     {
1802         wxRect rectMark = rectBorder;
1803 #ifdef __WXMSW__
1804         // MSW DrawCheckMark() is weird (and should probably be changed...)
1805         rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN/2);
1806         rectMark.x++;
1807         rectMark.y++;
1808 #else // !MSW
1809         rectMark.Inflate(-wxGRID_CHECKMARK_MARGIN);
1810 #endif // MSW/!MSW
1811
1812         dc.SetTextForeground(attr.GetTextColour());
1813         dc.DrawCheckMark(rectMark);
1814     }
1815
1816     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1817     dc.SetPen(wxPen(attr.GetTextColour(), 1, wxSOLID));
1818     dc.DrawRectangle(rectBorder);
1819 }
1820
1821 // ----------------------------------------------------------------------------
1822 // wxGridCellAttr
1823 // ----------------------------------------------------------------------------
1824
1825 wxGridCellAttr *wxGridCellAttr::Clone() const
1826 {
1827     wxGridCellAttr *attr = new wxGridCellAttr;
1828     if ( HasTextColour() )
1829         attr->SetTextColour(GetTextColour());
1830     if ( HasBackgroundColour() )
1831         attr->SetBackgroundColour(GetBackgroundColour());
1832     if ( HasFont() )
1833         attr->SetFont(GetFont());
1834     if ( HasAlignment() )
1835         attr->SetAlignment(m_hAlign, m_vAlign);
1836
1837     if ( m_renderer )
1838     {
1839         attr->SetRenderer(m_renderer);
1840         m_renderer->IncRef();
1841     }
1842     if ( m_editor )
1843     {
1844         attr->SetEditor(m_editor);
1845         m_editor->IncRef();
1846     }
1847
1848     if ( IsReadOnly() )
1849         attr->SetReadOnly();
1850
1851     attr->SetDefAttr(m_defGridAttr);
1852
1853     return attr;
1854 }
1855
1856 const wxColour& wxGridCellAttr::GetTextColour() const
1857 {
1858     if (HasTextColour())
1859     {
1860         return m_colText;
1861     }
1862     else if (m_defGridAttr != this)
1863     {
1864         return m_defGridAttr->GetTextColour();
1865     }
1866     else
1867     {
1868         wxFAIL_MSG(wxT("Missing default cell attribute"));
1869         return wxNullColour;
1870     }
1871 }
1872
1873
1874 const wxColour& wxGridCellAttr::GetBackgroundColour() const
1875 {
1876     if (HasBackgroundColour())
1877         return m_colBack;
1878     else if (m_defGridAttr != this)
1879         return m_defGridAttr->GetBackgroundColour();
1880     else
1881     {
1882         wxFAIL_MSG(wxT("Missing default cell attribute"));
1883         return wxNullColour;
1884     }
1885 }
1886
1887
1888 const wxFont& wxGridCellAttr::GetFont() const
1889 {
1890     if (HasFont())
1891         return m_font;
1892     else if (m_defGridAttr != this)
1893         return m_defGridAttr->GetFont();
1894     else
1895     {
1896         wxFAIL_MSG(wxT("Missing default cell attribute"));
1897         return wxNullFont;
1898     }
1899 }
1900
1901
1902 void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
1903 {
1904     if (HasAlignment())
1905     {
1906         if ( hAlign ) *hAlign = m_hAlign;
1907         if ( vAlign ) *vAlign = m_vAlign;
1908     }
1909     else if (m_defGridAttr != this)
1910         m_defGridAttr->GetAlignment(hAlign, vAlign);
1911     else
1912     {
1913         wxFAIL_MSG(wxT("Missing default cell attribute"));
1914     }
1915 }
1916
1917
1918 // GetRenderer and GetEditor use a slightly different decision path about
1919 // which attribute to use.  If a non-default attr object has one then it is
1920 // used, otherwise the default editor or renderer is fetched from the grid and
1921 // used.  It should be the default for the data type of the cell.  If it is
1922 // NULL (because the table has a type that the grid does not have in its
1923 // registry,) then the grid's default editor or renderer is used.
1924
1925 wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
1926 {
1927     wxGridCellRenderer* renderer = NULL;
1928
1929     if ( m_defGridAttr != this || grid == NULL )
1930     {
1931         renderer = m_renderer;      // use local attribute
1932         if ( renderer )
1933             renderer->IncRef();
1934     }
1935
1936     if ( !renderer && grid )        // get renderer for the data type
1937     {
1938         // GetDefaultRendererForCell() will do IncRef() for us
1939         renderer = grid->GetDefaultRendererForCell(row, col);
1940     }
1941
1942     if ( !renderer )
1943     {
1944         // if we still don't have one then use the grid default
1945         // (no need for IncRef() here neither)
1946         renderer = m_defGridAttr->GetRenderer(NULL,0,0);
1947     }
1948
1949     if ( !renderer)
1950     {
1951         wxFAIL_MSG(wxT("Missing default cell attribute"));
1952     }
1953
1954     return renderer;
1955 }
1956
1957 wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
1958 {
1959     wxGridCellEditor* editor = NULL;
1960
1961     if ( m_defGridAttr != this || grid == NULL )
1962     {
1963         editor = m_editor;      // use local attribute
1964         if ( editor )
1965             editor->IncRef();
1966     }
1967
1968     if ( !editor && grid )                   // get renderer for the data type
1969         editor = grid->GetDefaultEditorForCell(row, col);
1970
1971     if ( !editor )
1972         // if we still don't have one then use the grid default
1973         editor = m_defGridAttr->GetEditor(NULL,0,0);
1974
1975     if ( !editor )
1976     {
1977         wxFAIL_MSG(wxT("Missing default cell attribute"));
1978     }
1979
1980     return editor;
1981 }
1982
1983 // ----------------------------------------------------------------------------
1984 // wxGridCellAttrData
1985 // ----------------------------------------------------------------------------
1986
1987 void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
1988 {
1989     int n = FindIndex(row, col);
1990     if ( n == wxNOT_FOUND )
1991     {
1992         // add the attribute
1993         m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
1994     }
1995     else
1996     {
1997         if ( attr )
1998         {
1999             // change the attribute
2000             m_attrs[(size_t)n].attr = attr;
2001         }
2002         else
2003         {
2004             // remove this attribute
2005             m_attrs.RemoveAt((size_t)n);
2006         }
2007     }
2008 }
2009
2010 wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
2011 {
2012     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2013
2014     int n = FindIndex(row, col);
2015     if ( n != wxNOT_FOUND )
2016     {
2017         attr = m_attrs[(size_t)n].attr;
2018         attr->IncRef();
2019     }
2020
2021     return attr;
2022 }
2023
2024 void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
2025 {
2026     size_t count = m_attrs.GetCount();
2027     for ( size_t n = 0; n < count; n++ )
2028     {
2029         wxGridCellCoords& coords = m_attrs[n].coords;
2030         wxCoord row = coords.GetRow();
2031         if ((size_t)row >= pos)
2032         {
2033             if (numRows > 0)
2034             {
2035                 // If rows inserted, include row counter where necessary
2036                 coords.SetRow(row + numRows);
2037             }
2038             else if (numRows < 0)
2039             {
2040                 // If rows deleted ...
2041                 if ((size_t)row >= pos - numRows)
2042                 {
2043                     // ...either decrement row counter (if row still exists)...
2044                     coords.SetRow(row + numRows);
2045                 }
2046                 else
2047                 {
2048                     // ...or remove the attribute
2049                     m_attrs.RemoveAt((size_t)n);
2050                     n--; count--;
2051                 }
2052             }
2053         }
2054     }
2055 }
2056
2057 void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
2058 {
2059     size_t count = m_attrs.GetCount();
2060     for ( size_t n = 0; n < count; n++ )
2061     {
2062         wxGridCellCoords& coords = m_attrs[n].coords;
2063         wxCoord col = coords.GetCol();
2064         if ( (size_t)col >= pos )
2065         {
2066             if ( numCols > 0 )
2067             {
2068                 // If rows inserted, include row counter where necessary
2069                 coords.SetCol(col + numCols);
2070             }
2071             else if (numCols < 0)
2072             {
2073                 // If rows deleted ...
2074                 if ((size_t)col >= pos - numCols)
2075                 {
2076                     // ...either decrement row counter (if row still exists)...
2077                     coords.SetCol(col + numCols);
2078                 }
2079                 else
2080                 {
2081                     // ...or remove the attribute
2082                     m_attrs.RemoveAt((size_t)n);
2083                     n--; count--;
2084                 }
2085             }
2086         }
2087     }
2088 }
2089
2090 int wxGridCellAttrData::FindIndex(int row, int col) const
2091 {
2092     size_t count = m_attrs.GetCount();
2093     for ( size_t n = 0; n < count; n++ )
2094     {
2095         const wxGridCellCoords& coords = m_attrs[n].coords;
2096         if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
2097         {
2098             return n;
2099         }
2100     }
2101
2102     return wxNOT_FOUND;
2103 }
2104
2105 // ----------------------------------------------------------------------------
2106 // wxGridRowOrColAttrData
2107 // ----------------------------------------------------------------------------
2108
2109 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2110 {
2111     size_t count = m_attrs.Count();
2112     for ( size_t n = 0; n < count; n++ )
2113     {
2114         m_attrs[n]->DecRef();
2115     }
2116 }
2117
2118 wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
2119 {
2120     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2121
2122     int n = m_rowsOrCols.Index(rowOrCol);
2123     if ( n != wxNOT_FOUND )
2124     {
2125         attr = m_attrs[(size_t)n];
2126         attr->IncRef();
2127     }
2128
2129     return attr;
2130 }
2131
2132 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
2133 {
2134     int i = m_rowsOrCols.Index(rowOrCol);
2135     if ( i == wxNOT_FOUND )
2136     {
2137         // add the attribute
2138         m_rowsOrCols.Add(rowOrCol);
2139         m_attrs.Add(attr);
2140     }
2141     else
2142     {
2143         size_t n = (size_t)i;
2144         if ( attr )
2145         {
2146             // change the attribute
2147             m_attrs[n]->DecRef();
2148             m_attrs[n] = attr;
2149         }
2150         else
2151         {
2152             // remove this attribute
2153             m_attrs[n]->DecRef();
2154             m_rowsOrCols.RemoveAt(n);
2155             m_attrs.RemoveAt(n);
2156         }
2157     }
2158 }
2159
2160 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
2161 {
2162     size_t count = m_attrs.GetCount();
2163     for ( size_t n = 0; n < count; n++ )
2164     {
2165         int & rowOrCol = m_rowsOrCols[n];
2166         if ( (size_t)rowOrCol >= pos )
2167         {
2168             if ( numRowsOrCols > 0 )
2169             {
2170                 // If rows inserted, include row counter where necessary
2171                 rowOrCol += numRowsOrCols;
2172             }
2173             else if ( numRowsOrCols < 0)
2174             {
2175                 // If rows deleted, either decrement row counter (if row still exists)
2176                 if ((size_t)rowOrCol >= pos - numRowsOrCols)
2177                     rowOrCol += numRowsOrCols;
2178                 else
2179                 {
2180                     m_rowsOrCols.RemoveAt((size_t)n);
2181                     m_attrs.RemoveAt((size_t)n);
2182                     n--; count--;
2183                 }
2184             }
2185         }
2186     }
2187 }
2188
2189 // ----------------------------------------------------------------------------
2190 // wxGridCellAttrProvider
2191 // ----------------------------------------------------------------------------
2192
2193 wxGridCellAttrProvider::wxGridCellAttrProvider()
2194 {
2195     m_data = (wxGridCellAttrProviderData *)NULL;
2196 }
2197
2198 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2199 {
2200     delete m_data;
2201 }
2202
2203 void wxGridCellAttrProvider::InitData()
2204 {
2205     m_data = new wxGridCellAttrProviderData;
2206 }
2207
2208 wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
2209 {
2210     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
2211     if ( m_data )
2212     {
2213         // first look for the attribute of this specific cell
2214         attr = m_data->m_cellAttrs.GetAttr(row, col);
2215
2216         if ( !attr )
2217         {
2218             // then look for the col attr (col attributes are more common than
2219             // the row ones, hence they have priority)
2220             attr = m_data->m_colAttrs.GetAttr(col);
2221         }
2222
2223         if ( !attr )
2224         {
2225             // finally try the row attributes
2226             attr = m_data->m_rowAttrs.GetAttr(row);
2227         }
2228     }
2229
2230     return attr;
2231 }
2232
2233 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
2234                                      int row, int col)
2235 {
2236     if ( !m_data )
2237         InitData();
2238
2239     m_data->m_cellAttrs.SetAttr(attr, row, col);
2240 }
2241
2242 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
2243 {
2244     if ( !m_data )
2245         InitData();
2246
2247     m_data->m_rowAttrs.SetAttr(attr, row);
2248 }
2249
2250 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
2251 {
2252     if ( !m_data )
2253         InitData();
2254
2255     m_data->m_colAttrs.SetAttr(attr, col);
2256 }
2257
2258 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
2259 {
2260     if ( m_data )
2261     {
2262         m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
2263
2264         m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
2265     }
2266 }
2267
2268 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
2269 {
2270     if ( m_data )
2271     {
2272         m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
2273
2274         m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
2275     }
2276 }
2277
2278 // ----------------------------------------------------------------------------
2279 // wxGridTypeRegistry
2280 // ----------------------------------------------------------------------------
2281
2282 wxGridTypeRegistry::~wxGridTypeRegistry()
2283 {
2284     size_t count = m_typeinfo.Count();
2285     for ( size_t i = 0; i < count; i++ )
2286         delete m_typeinfo[i];
2287 }
2288
2289
2290 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
2291                                           wxGridCellRenderer* renderer,
2292                                           wxGridCellEditor* editor)
2293 {
2294     wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
2295
2296     // is it already registered?
2297     int loc = FindRegisteredDataType(typeName);
2298     if ( loc != wxNOT_FOUND )
2299     {
2300         delete m_typeinfo[loc];
2301         m_typeinfo[loc] = info;
2302     }
2303     else
2304     {
2305         m_typeinfo.Add(info);
2306     }
2307 }
2308
2309 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
2310 {
2311     size_t count = m_typeinfo.GetCount();
2312     for ( size_t i = 0; i < count; i++ )
2313     {
2314         if ( typeName == m_typeinfo[i]->m_typeName )
2315         {
2316             return i;
2317         }
2318     }
2319
2320     return wxNOT_FOUND;
2321 }
2322
2323 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
2324 {
2325     int index = FindRegisteredDataType(typeName);
2326     if ( index == wxNOT_FOUND )
2327     {
2328         // check whether this is one of the standard ones, in which case
2329         // register it "on the fly"
2330         if ( typeName == wxGRID_VALUE_STRING )
2331         {
2332             RegisterDataType(wxGRID_VALUE_STRING,
2333                              new wxGridCellStringRenderer,
2334                              new wxGridCellTextEditor);
2335         }
2336         else if ( typeName == wxGRID_VALUE_BOOL )
2337         {
2338             RegisterDataType(wxGRID_VALUE_BOOL,
2339                              new wxGridCellBoolRenderer,
2340                              new wxGridCellBoolEditor);
2341         }
2342         else if ( typeName == wxGRID_VALUE_NUMBER )
2343         {
2344             RegisterDataType(wxGRID_VALUE_NUMBER,
2345                              new wxGridCellNumberRenderer,
2346                              new wxGridCellNumberEditor);
2347         }
2348         else if ( typeName == wxGRID_VALUE_FLOAT )
2349         {
2350             RegisterDataType(wxGRID_VALUE_FLOAT,
2351                              new wxGridCellFloatRenderer,
2352                              new wxGridCellFloatEditor);
2353         }
2354         else if ( typeName == wxGRID_VALUE_CHOICE )
2355         {
2356             RegisterDataType(wxGRID_VALUE_CHOICE,
2357                              new wxGridCellStringRenderer,
2358                              new wxGridCellChoiceEditor);
2359         }
2360         else
2361         {
2362             return wxNOT_FOUND;
2363         }
2364
2365         // we get here only if just added the entry for this type, so return
2366         // the last index
2367         index = m_typeinfo.GetCount() - 1;
2368     }
2369
2370     return index;
2371 }
2372
2373 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
2374 {
2375     int index = FindDataType(typeName);
2376     if ( index == wxNOT_FOUND )
2377     {
2378         // the first part of the typename is the "real" type, anything after ':'
2379         // are the parameters for the renderer
2380         index = FindDataType(typeName.BeforeFirst(_T(':')));
2381         if ( index == wxNOT_FOUND )
2382         {
2383             return wxNOT_FOUND;
2384         }
2385
2386         wxGridCellRenderer *renderer = GetRenderer(index);
2387         wxGridCellRenderer *rendererOld = renderer;
2388         renderer = renderer->Clone();
2389         rendererOld->DecRef();
2390
2391         wxGridCellEditor *editor = GetEditor(index);
2392         wxGridCellEditor *editorOld = editor;
2393         editor = editor->Clone();
2394         editorOld->DecRef();
2395
2396         // do it even if there are no parameters to reset them to defaults
2397         wxString params = typeName.AfterFirst(_T(':'));
2398         renderer->SetParameters(params);
2399         editor->SetParameters(params);
2400
2401         // register the new typename
2402         RegisterDataType(typeName, renderer, editor);
2403
2404         // we just registered it, it's the last one
2405         index = m_typeinfo.GetCount() - 1;
2406     }
2407
2408     return index;
2409 }
2410
2411 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
2412 {
2413     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
2414     renderer->IncRef();
2415     return renderer;
2416 }
2417
2418 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
2419 {
2420     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
2421     editor->IncRef();
2422     return editor;
2423 }
2424
2425 // ----------------------------------------------------------------------------
2426 // wxGridTableBase
2427 // ----------------------------------------------------------------------------
2428
2429 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
2430
2431
2432 wxGridTableBase::wxGridTableBase()
2433 {
2434     m_view = (wxGrid *) NULL;
2435     m_attrProvider = (wxGridCellAttrProvider *) NULL;
2436 }
2437
2438 wxGridTableBase::~wxGridTableBase()
2439 {
2440     delete m_attrProvider;
2441 }
2442
2443 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
2444 {
2445     delete m_attrProvider;
2446     m_attrProvider = attrProvider;
2447 }
2448
2449 bool wxGridTableBase::CanHaveAttributes()
2450 {
2451     if ( ! GetAttrProvider() )
2452     {
2453         // use the default attr provider by default
2454         SetAttrProvider(new wxGridCellAttrProvider);
2455     }
2456     return TRUE;
2457 }
2458
2459 wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
2460 {
2461     if ( m_attrProvider )
2462         return m_attrProvider->GetAttr(row, col);
2463     else
2464         return (wxGridCellAttr *)NULL;
2465 }
2466
2467 void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
2468 {
2469     if ( m_attrProvider )
2470     {
2471         m_attrProvider->SetAttr(attr, row, col);
2472     }
2473     else
2474     {
2475         // as we take ownership of the pointer and don't store it, we must
2476         // free it now
2477         wxSafeDecRef(attr);
2478     }
2479 }
2480
2481 void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
2482 {
2483     if ( m_attrProvider )
2484     {
2485         m_attrProvider->SetRowAttr(attr, row);
2486     }
2487     else
2488     {
2489         // as we take ownership of the pointer and don't store it, we must
2490         // free it now
2491         wxSafeDecRef(attr);
2492     }
2493 }
2494
2495 void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
2496 {
2497     if ( m_attrProvider )
2498     {
2499         m_attrProvider->SetColAttr(attr, col);
2500     }
2501     else
2502     {
2503         // as we take ownership of the pointer and don't store it, we must
2504         // free it now
2505         wxSafeDecRef(attr);
2506     }
2507 }
2508
2509 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
2510                                   size_t WXUNUSED(numRows) )
2511 {
2512     wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2513
2514     return FALSE;
2515 }
2516
2517 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
2518 {
2519     wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2520
2521     return FALSE;
2522 }
2523
2524 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
2525                                   size_t WXUNUSED(numRows) )
2526 {
2527     wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2528
2529     return FALSE;
2530 }
2531
2532 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
2533                                   size_t WXUNUSED(numCols) )
2534 {
2535     wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2536
2537     return FALSE;
2538 }
2539
2540 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
2541 {
2542     wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2543
2544     return FALSE;
2545 }
2546
2547 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
2548                                   size_t WXUNUSED(numCols) )
2549 {
2550     wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2551
2552     return FALSE;
2553 }
2554
2555
2556 wxString wxGridTableBase::GetRowLabelValue( int row )
2557 {
2558     wxString s;
2559     s << row + 1; // RD: Starting the rows at zero confuses users, no matter
2560                   //     how much it makes sense to us geeks.
2561     return s;
2562 }
2563
2564 wxString wxGridTableBase::GetColLabelValue( int col )
2565 {
2566     // default col labels are:
2567     //   cols 0 to 25   : A-Z
2568     //   cols 26 to 675 : AA-ZZ
2569     //   etc.
2570
2571     wxString s;
2572     unsigned int i, n;
2573     for ( n = 1; ; n++ )
2574     {
2575         s += (_T('A') + (wxChar)( col%26 ));
2576         col = col/26 - 1;
2577         if ( col < 0 ) break;
2578     }
2579
2580     // reverse the string...
2581     wxString s2;
2582     for ( i = 0;  i < n;  i++ )
2583     {
2584         s2 += s[n-i-1];
2585     }
2586
2587     return s2;
2588 }
2589
2590
2591 wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
2592 {
2593     return wxGRID_VALUE_STRING;
2594 }
2595
2596 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
2597                                      const wxString& typeName )
2598 {
2599     return typeName == wxGRID_VALUE_STRING;
2600 }
2601
2602 bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
2603 {
2604     return CanGetValueAs(row, col, typeName);
2605 }
2606
2607 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
2608 {
2609     return 0;
2610 }
2611
2612 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
2613 {
2614     return 0.0;
2615 }
2616
2617 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
2618 {
2619     return FALSE;
2620 }
2621
2622 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
2623                                       long WXUNUSED(value) )
2624 {
2625 }
2626
2627 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
2628                                         double WXUNUSED(value) )
2629 {
2630 }
2631
2632 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
2633                                       bool WXUNUSED(value) )
2634 {
2635 }
2636
2637
2638 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2639                                          const wxString& WXUNUSED(typeName) )
2640 {
2641     return NULL;
2642 }
2643
2644 void  wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
2645                                          const wxString& WXUNUSED(typeName),
2646                                          void* WXUNUSED(value) )
2647 {
2648 }
2649
2650 //////////////////////////////////////////////////////////////////////
2651 //
2652 // Message class for the grid table to send requests and notifications
2653 // to the grid view
2654 //
2655
2656 wxGridTableMessage::wxGridTableMessage()
2657 {
2658     m_table = (wxGridTableBase *) NULL;
2659     m_id = -1;
2660     m_comInt1 = -1;
2661     m_comInt2 = -1;
2662 }
2663
2664 wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
2665                                         int commandInt1, int commandInt2 )
2666 {
2667     m_table = table;
2668     m_id = id;
2669     m_comInt1 = commandInt1;
2670     m_comInt2 = commandInt2;
2671 }
2672
2673
2674
2675 //////////////////////////////////////////////////////////////////////
2676 //
2677 // A basic grid table for string data. An object of this class will
2678 // created by wxGrid if you don't specify an alternative table class.
2679 //
2680
2681 WX_DEFINE_OBJARRAY(wxGridStringArray)
2682
2683 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
2684
2685 wxGridStringTable::wxGridStringTable()
2686         : wxGridTableBase()
2687 {
2688 }
2689
2690 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
2691         : wxGridTableBase()
2692 {
2693     int row, col;
2694
2695     m_data.Alloc( numRows );
2696
2697     wxArrayString sa;
2698     sa.Alloc( numCols );
2699     for ( col = 0;  col < numCols;  col++ )
2700     {
2701         sa.Add( wxEmptyString );
2702     }
2703
2704     for ( row = 0;  row < numRows;  row++ )
2705     {
2706         m_data.Add( sa );
2707     }
2708 }
2709
2710 wxGridStringTable::~wxGridStringTable()
2711 {
2712 }
2713
2714 int wxGridStringTable::GetNumberRows()
2715 {
2716     return m_data.GetCount();
2717 }
2718
2719 int wxGridStringTable::GetNumberCols()
2720 {
2721     if ( m_data.GetCount() > 0 )
2722         return m_data[0].GetCount();
2723     else
2724         return 0;
2725 }
2726
2727 wxString wxGridStringTable::GetValue( int row, int col )
2728 {
2729     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2730                   _T("invalid row or column index in wxGridStringTable") );
2731
2732     return m_data[row][col];
2733 }
2734
2735 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
2736 {
2737     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2738                   _T("invalid row or column index in wxGridStringTable") );
2739
2740     m_data[row][col] = value;
2741 }
2742
2743 bool wxGridStringTable::IsEmptyCell( int row, int col )
2744 {
2745     wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
2746                   _T("invalid row or column index in wxGridStringTable") );
2747
2748     return (m_data[row][col] == wxEmptyString);
2749 }
2750
2751 void wxGridStringTable::Clear()
2752 {
2753     int row, col;
2754     int numRows, numCols;
2755
2756     numRows = m_data.GetCount();
2757     if ( numRows > 0 )
2758     {
2759         numCols = m_data[0].GetCount();
2760
2761         for ( row = 0;  row < numRows;  row++ )
2762         {
2763             for ( col = 0;  col < numCols;  col++ )
2764             {
2765                 m_data[row][col] = wxEmptyString;
2766             }
2767         }
2768     }
2769 }
2770
2771
2772 bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
2773 {
2774     size_t row, col;
2775
2776     size_t curNumRows = m_data.GetCount();
2777     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2778                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2779
2780     if ( pos >= curNumRows )
2781     {
2782         return AppendRows( numRows );
2783     }
2784
2785     wxArrayString sa;
2786     sa.Alloc( curNumCols );
2787     for ( col = 0;  col < curNumCols;  col++ )
2788     {
2789         sa.Add( wxEmptyString );
2790     }
2791
2792     for ( row = pos;  row < pos + numRows;  row++ )
2793     {
2794         m_data.Insert( sa, row );
2795     }
2796     if ( GetView() )
2797     {
2798         wxGridTableMessage msg( this,
2799                                 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
2800                                 pos,
2801                                 numRows );
2802
2803         GetView()->ProcessTableMessage( msg );
2804     }
2805
2806     return TRUE;
2807 }
2808
2809 bool wxGridStringTable::AppendRows( size_t numRows )
2810 {
2811     size_t row, col;
2812
2813     size_t curNumRows = m_data.GetCount();
2814     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2815                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2816
2817     wxArrayString sa;
2818     if ( curNumCols > 0 )
2819     {
2820         sa.Alloc( curNumCols );
2821         for ( col = 0;  col < curNumCols;  col++ )
2822         {
2823             sa.Add( wxEmptyString );
2824         }
2825     }
2826
2827     for ( row = 0;  row < numRows;  row++ )
2828     {
2829         m_data.Add( sa );
2830     }
2831
2832     if ( GetView() )
2833     {
2834         wxGridTableMessage msg( this,
2835                                 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
2836                                 numRows );
2837
2838         GetView()->ProcessTableMessage( msg );
2839     }
2840
2841     return TRUE;
2842 }
2843
2844 bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
2845 {
2846     size_t n;
2847
2848     size_t curNumRows = m_data.GetCount();
2849
2850     if ( pos >= curNumRows )
2851     {
2852         wxString errmsg;
2853         errmsg.Printf(wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
2854                       pos, numRows, curNumRows );
2855         wxFAIL_MSG( errmsg );
2856         return FALSE;
2857     }
2858
2859     if ( numRows > curNumRows - pos )
2860     {
2861         numRows = curNumRows - pos;
2862     }
2863
2864     if ( numRows >= curNumRows )
2865     {
2866         m_data.Empty();  // don't release memory just yet
2867     }
2868     else
2869     {
2870         for ( n = 0;  n < numRows;  n++ )
2871         {
2872             m_data.Remove( pos );
2873         }
2874     }
2875     if ( GetView() )
2876     {
2877         wxGridTableMessage msg( this,
2878                                 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
2879                                 pos,
2880                                 numRows );
2881
2882         GetView()->ProcessTableMessage( msg );
2883     }
2884
2885     return TRUE;
2886 }
2887
2888 bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
2889 {
2890     size_t row, col;
2891
2892     size_t curNumRows = m_data.GetCount();
2893     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2894                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2895
2896     if ( pos >= curNumCols )
2897     {
2898         return AppendCols( numCols );
2899     }
2900
2901     for ( row = 0;  row < curNumRows;  row++ )
2902     {
2903         for ( col = pos;  col < pos + numCols;  col++ )
2904         {
2905             m_data[row].Insert( wxEmptyString, col );
2906         }
2907     }
2908     if ( GetView() )
2909     {
2910         wxGridTableMessage msg( this,
2911                                 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
2912                                 pos,
2913                                 numCols );
2914
2915         GetView()->ProcessTableMessage( msg );
2916     }
2917
2918     return TRUE;
2919 }
2920
2921 bool wxGridStringTable::AppendCols( size_t numCols )
2922 {
2923     size_t row, n;
2924
2925     size_t curNumRows = m_data.GetCount();
2926 #if 0
2927     if ( !curNumRows )
2928     {
2929         // TODO: something better than this ?
2930         //
2931         wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
2932         return FALSE;
2933     }
2934 #endif
2935
2936     for ( row = 0;  row < curNumRows;  row++ )
2937     {
2938         for ( n = 0;  n < numCols;  n++ )
2939         {
2940             m_data[row].Add( wxEmptyString );
2941         }
2942     }
2943
2944     if ( GetView() )
2945     {
2946         wxGridTableMessage msg( this,
2947                                 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
2948                                 numCols );
2949
2950         GetView()->ProcessTableMessage( msg );
2951     }
2952
2953     return TRUE;
2954 }
2955
2956 bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
2957 {
2958     size_t row, n;
2959
2960     size_t curNumRows = m_data.GetCount();
2961     size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
2962                           ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2963
2964     if ( pos >= curNumCols )
2965     {
2966         wxString errmsg;
2967         errmsg.Printf( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
2968                         pos, numCols, curNumCols );
2969         wxFAIL_MSG( errmsg );
2970         return FALSE;
2971     }
2972
2973     if ( numCols > curNumCols - pos )
2974     {
2975         numCols = curNumCols - pos;
2976     }
2977
2978     for ( row = 0;  row < curNumRows;  row++ )
2979     {
2980         if ( numCols >= curNumCols )
2981         {
2982             m_data[row].Clear();
2983         }
2984         else
2985         {
2986             for ( n = 0;  n < numCols;  n++ )
2987             {
2988                 m_data[row].Remove( pos );
2989             }
2990         }
2991     }
2992     if ( GetView() )
2993     {
2994         wxGridTableMessage msg( this,
2995                                 wxGRIDTABLE_NOTIFY_COLS_DELETED,
2996                                 pos,
2997                                 numCols );
2998
2999         GetView()->ProcessTableMessage( msg );
3000     }
3001
3002     return TRUE;
3003 }
3004
3005 wxString wxGridStringTable::GetRowLabelValue( int row )
3006 {
3007     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3008     {
3009         // using default label
3010         //
3011         return wxGridTableBase::GetRowLabelValue( row );
3012     }
3013     else
3014     {
3015         return m_rowLabels[ row ];
3016     }
3017 }
3018
3019 wxString wxGridStringTable::GetColLabelValue( int col )
3020 {
3021     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3022     {
3023         // using default label
3024         //
3025         return wxGridTableBase::GetColLabelValue( col );
3026     }
3027     else
3028     {
3029         return m_colLabels[ col ];
3030     }
3031 }
3032
3033 void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
3034 {
3035     if ( row > (int)(m_rowLabels.GetCount()) - 1 )
3036     {
3037         int n = m_rowLabels.GetCount();
3038         int i;
3039         for ( i = n;  i <= row;  i++ )
3040         {
3041             m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
3042         }
3043     }
3044
3045     m_rowLabels[row] = value;
3046 }
3047
3048 void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
3049 {
3050     if ( col > (int)(m_colLabels.GetCount()) - 1 )
3051     {
3052         int n = m_colLabels.GetCount();
3053         int i;
3054         for ( i = n;  i <= col;  i++ )
3055         {
3056             m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
3057         }
3058     }
3059
3060     m_colLabels[col] = value;
3061 }
3062
3063
3064
3065 //////////////////////////////////////////////////////////////////////
3066 //////////////////////////////////////////////////////////////////////
3067
3068 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
3069
3070 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
3071     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
3072     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
3073     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
3074     EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
3075 END_EVENT_TABLE()
3076
3077 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
3078                                             wxWindowID id,
3079                                             const wxPoint &pos, const wxSize &size )
3080   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3081 {
3082     m_owner = parent;
3083 }
3084
3085 void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3086 {
3087     wxPaintDC dc(this);
3088
3089     // NO - don't do this because it will set both the x and y origin
3090     // coords to match the parent scrolled window and we just want to
3091     // set the y coord  - MB
3092     //
3093     // m_owner->PrepareDC( dc );
3094
3095     int x, y;
3096     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3097     dc.SetDeviceOrigin( 0, -y );
3098
3099     m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
3100     m_owner->DrawRowLabels( dc );
3101 }
3102
3103
3104 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
3105 {
3106     m_owner->ProcessRowLabelMouseEvent( event );
3107 }
3108
3109
3110 // This seems to be required for wxMotif otherwise the mouse
3111 // cursor must be in the cell edit control to get key events
3112 //
3113 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
3114 {
3115     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3116 }
3117
3118 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
3119 {
3120     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3121 }
3122
3123
3124
3125 //////////////////////////////////////////////////////////////////////
3126
3127 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
3128
3129 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
3130     EVT_PAINT( wxGridColLabelWindow::OnPaint )
3131     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
3132     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
3133     EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
3134 END_EVENT_TABLE()
3135
3136 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
3137                                             wxWindowID id,
3138                                             const wxPoint &pos, const wxSize &size )
3139   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3140 {
3141     m_owner = parent;
3142 }
3143
3144 void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3145 {
3146     wxPaintDC dc(this);
3147
3148     // NO - don't do this because it will set both the x and y origin
3149     // coords to match the parent scrolled window and we just want to
3150     // set the x coord  - MB
3151     //
3152     // m_owner->PrepareDC( dc );
3153
3154     int x, y;
3155     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
3156     dc.SetDeviceOrigin( -x, 0 );
3157
3158     m_owner->CalcColLabelsExposed( GetUpdateRegion() );
3159     m_owner->DrawColLabels( dc );
3160 }
3161
3162
3163 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
3164 {
3165     m_owner->ProcessColLabelMouseEvent( event );
3166 }
3167
3168
3169 // This seems to be required for wxMotif otherwise the mouse
3170 // cursor must be in the cell edit control to get key events
3171 //
3172 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
3173 {
3174     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3175 }
3176
3177 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
3178 {
3179     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3180 }
3181
3182
3183
3184 //////////////////////////////////////////////////////////////////////
3185
3186 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
3187
3188 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
3189     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
3190     EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
3191     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
3192     EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp )
3193 END_EVENT_TABLE()
3194
3195 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
3196                                                   wxWindowID id,
3197                                                   const wxPoint &pos, const wxSize &size )
3198   : wxWindow( parent, id, pos, size, wxWANTS_CHARS )
3199 {
3200     m_owner = parent;
3201 }
3202
3203 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
3204 {
3205     wxPaintDC dc(this);
3206
3207     int client_height = 0;
3208     int client_width = 0;
3209     GetClientSize( &client_width, &client_height );
3210
3211     dc.SetPen( *wxBLACK_PEN );
3212     dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
3213     dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
3214
3215     dc.SetPen( *wxWHITE_PEN );
3216     dc.DrawLine( 0, 0, client_width, 0 );
3217     dc.DrawLine( 0, 0, 0, client_height );
3218 }
3219
3220
3221 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
3222 {
3223     m_owner->ProcessCornerLabelMouseEvent( event );
3224 }
3225
3226
3227 // This seems to be required for wxMotif otherwise the mouse
3228 // cursor must be in the cell edit control to get key events
3229 //
3230 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
3231 {
3232     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3233 }
3234
3235 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
3236 {
3237     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3238 }
3239
3240
3241
3242 //////////////////////////////////////////////////////////////////////
3243
3244 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
3245
3246 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
3247     EVT_PAINT( wxGridWindow::OnPaint )
3248     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
3249     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
3250     EVT_KEY_UP( wxGridWindow::OnKeyUp )
3251     EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
3252 END_EVENT_TABLE()
3253
3254 wxGridWindow::wxGridWindow( wxGrid *parent,
3255                             wxGridRowLabelWindow *rowLblWin,
3256                             wxGridColLabelWindow *colLblWin,
3257                             wxWindowID id, const wxPoint &pos, const wxSize &size )
3258         : wxPanel( parent, id, pos, size, wxWANTS_CHARS, "grid window" )
3259 {
3260     m_owner = parent;
3261     m_rowLabelWin = rowLblWin;
3262     m_colLabelWin = colLblWin;
3263     SetBackgroundColour( "WHITE" );
3264 }
3265
3266
3267 wxGridWindow::~wxGridWindow()
3268 {
3269 }
3270
3271
3272 void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3273 {
3274     wxPaintDC dc( this );
3275     m_owner->PrepareDC( dc );
3276     wxRegion reg = GetUpdateRegion();
3277     m_owner->CalcCellsExposed( reg );
3278     m_owner->DrawGridCellArea( dc );
3279 #if WXGRID_DRAW_LINES
3280     m_owner->DrawAllGridLines( dc, reg );
3281 #endif
3282     m_owner->DrawGridSpace( dc );
3283     m_owner->DrawHighlight( dc );
3284 }
3285
3286
3287 void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
3288 {
3289     wxPanel::ScrollWindow( dx, dy, rect );
3290     m_rowLabelWin->ScrollWindow( 0, dy, rect );
3291     m_colLabelWin->ScrollWindow( dx, 0, rect );
3292 }
3293
3294
3295 void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
3296 {
3297     m_owner->ProcessGridCellMouseEvent( event );
3298 }
3299
3300
3301 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3302 // cursor must be in the cell edit control to get key events
3303 //
3304 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
3305 {
3306     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3307 }
3308
3309 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
3310 {
3311     if ( !m_owner->ProcessEvent( event ) ) event.Skip();
3312 }
3313
3314 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
3315 {
3316 }
3317
3318
3319 //////////////////////////////////////////////////////////////////////
3320
3321
3322 IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
3323
3324 BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
3325     EVT_PAINT( wxGrid::OnPaint )
3326     EVT_SIZE( wxGrid::OnSize )
3327     EVT_KEY_DOWN( wxGrid::OnKeyDown )
3328     EVT_KEY_UP( wxGrid::OnKeyUp )
3329     EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
3330 END_EVENT_TABLE()
3331
3332 wxGrid::wxGrid( wxWindow *parent,
3333                  wxWindowID id,
3334                  const wxPoint& pos,
3335                  const wxSize& size,
3336                  long style,
3337                  const wxString& name )
3338   : wxScrolledWindow( parent, id, pos, size, (style | wxWANTS_CHARS), name ),
3339     m_colMinWidths(GRID_HASH_SIZE),
3340     m_rowMinHeights(GRID_HASH_SIZE)
3341 {
3342     Create();
3343 }
3344
3345
3346 wxGrid::~wxGrid()
3347 {
3348     ClearAttrCache();
3349     wxSafeDecRef(m_defaultCellAttr);
3350
3351 #ifdef DEBUG_ATTR_CACHE
3352     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
3353     wxPrintf(_T("wxGrid attribute cache statistics: "
3354                 "total: %u, hits: %u (%u%%)\n"),
3355              total, gs_nAttrCacheHits,
3356              total ? (gs_nAttrCacheHits*100) / total : 0);
3357 #endif
3358
3359     if (m_ownTable)
3360         delete m_table;
3361
3362     delete m_typeRegistry;
3363     delete m_selection;
3364 }
3365
3366
3367 //
3368 // ----- internal init and update functions
3369 //
3370
3371 void wxGrid::Create()
3372 {
3373     m_created = FALSE;    // set to TRUE by CreateGrid
3374
3375     m_table        = (wxGridTableBase *) NULL;
3376     m_ownTable     = FALSE;
3377
3378     m_cellEditCtrlEnabled = FALSE;
3379
3380     m_defaultCellAttr = new wxGridCellAttr;
3381     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
3382
3383     // Set default cell attributes
3384     m_defaultCellAttr->SetFont(GetFont());
3385     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
3386     m_defaultCellAttr->SetTextColour(
3387         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT));
3388     m_defaultCellAttr->SetBackgroundColour(
3389         wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
3390     m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
3391     m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
3392
3393
3394     m_numRows = 0;
3395     m_numCols = 0;
3396     m_currentCellCoords = wxGridNoCellCoords;
3397
3398     m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3399     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3400
3401     // create the type registry
3402     m_typeRegistry = new wxGridTypeRegistry;
3403     m_selection = 0;
3404     // subwindow components that make up the wxGrid
3405     m_cornerLabelWin = new wxGridCornerLabelWindow( this,
3406                                                     -1,
3407                                                     wxDefaultPosition,
3408                                                     wxDefaultSize );
3409
3410     m_rowLabelWin = new wxGridRowLabelWindow( this,
3411                                               -1,
3412                                               wxDefaultPosition,
3413                                               wxDefaultSize );
3414
3415     m_colLabelWin = new wxGridColLabelWindow( this,
3416                                               -1,
3417                                               wxDefaultPosition,
3418                                               wxDefaultSize );
3419
3420     m_gridWin = new wxGridWindow( this,
3421                                   m_rowLabelWin,
3422                                   m_colLabelWin,
3423                                   -1,
3424                                   wxDefaultPosition,
3425                                   wxDefaultSize );
3426
3427     SetTargetWindow( m_gridWin );
3428 }
3429
3430
3431 bool wxGrid::CreateGrid( int numRows, int numCols,
3432                          wxGrid::wxGridSelectionModes selmode )
3433 {
3434     wxCHECK_MSG( !m_created,
3435                  FALSE,
3436                  wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3437
3438     m_numRows = numRows;
3439     m_numCols = numCols;
3440
3441     m_table = new wxGridStringTable( m_numRows, m_numCols );
3442     m_table->SetView( this );
3443     m_ownTable = TRUE;
3444     m_selection = new wxGridSelection( this, selmode );
3445     Init();
3446     m_created = TRUE;
3447
3448     return m_created;
3449 }
3450
3451 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
3452 {
3453     if ( !m_created )
3454     {
3455         wxFAIL_MSG( wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3456     }
3457     else
3458         m_selection->SetSelectionMode( selmode );
3459 }
3460
3461 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
3462                        wxGrid::wxGridSelectionModes selmode )
3463 {
3464     if ( m_created )
3465     {
3466         // RD: Actually, this should probably be allowed.  I think it would be
3467         // nice to be able to switch multiple Tables in and out of a single
3468         // View at runtime.  Is there anything in the implmentation that would
3469         // prevent this?
3470
3471         // At least, you now have to cope with m_selection
3472         wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3473         return FALSE;
3474     }
3475     else
3476     {
3477         m_numRows = table->GetNumberRows();
3478         m_numCols = table->GetNumberCols();
3479
3480         m_table = table;
3481         m_table->SetView( this );
3482         if (takeOwnership)
3483             m_ownTable = TRUE;
3484         m_selection = new wxGridSelection( this, selmode );
3485         Init();
3486         m_created = TRUE;
3487     }
3488
3489     return m_created;
3490 }
3491
3492
3493 void wxGrid::Init()
3494 {
3495     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
3496     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
3497
3498     if ( m_rowLabelWin )
3499     {
3500         m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
3501     }
3502     else
3503     {
3504         m_labelBackgroundColour = wxColour( _T("WHITE") );
3505     }
3506
3507     m_labelTextColour = wxColour( _T("BLACK") );
3508
3509     // init attr cache
3510     m_attrCache.row = -1;
3511
3512     // TODO: something better than this ?
3513     //
3514     m_labelFont = this->GetFont();
3515     m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
3516
3517     m_rowLabelHorizAlign = wxALIGN_LEFT;
3518     m_rowLabelVertAlign  = wxALIGN_CENTRE;
3519
3520     m_colLabelHorizAlign = wxALIGN_CENTRE;
3521     m_colLabelVertAlign  = wxALIGN_TOP;
3522
3523     m_defaultColWidth  = WXGRID_DEFAULT_COL_WIDTH;
3524     m_defaultRowHeight = m_gridWin->GetCharHeight();
3525
3526 #if defined(__WXMOTIF__) || defined(__WXGTK__)  // see also text ctrl sizing in ShowCellEditControl()
3527     m_defaultRowHeight += 8;
3528 #else
3529     m_defaultRowHeight += 4;
3530 #endif
3531
3532     m_gridLineColour = wxColour( 128, 128, 255 );
3533     m_gridLinesEnabled = TRUE;
3534     m_cellHighlightColour = m_gridLineColour;
3535
3536     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
3537     m_winCapture = (wxWindow *)NULL;
3538     m_canDragRowSize = TRUE;
3539     m_canDragColSize = TRUE;
3540     m_canDragGridSize = TRUE;
3541     m_dragLastPos  = -1;
3542     m_dragRowOrCol = -1;
3543     m_isDragging = FALSE;
3544     m_startDragPos = wxDefaultPosition;
3545
3546     m_waitForSlowClick = FALSE;
3547
3548     m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
3549     m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
3550
3551     m_currentCellCoords = wxGridNoCellCoords;
3552
3553     m_selectingTopLeft = wxGridNoCellCoords;
3554     m_selectingBottomRight = wxGridNoCellCoords;
3555     m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
3556     m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
3557
3558     m_editable = TRUE;  // default for whole grid
3559
3560     m_inOnKeyDown = FALSE;
3561     m_batchCount = 0;
3562
3563     m_extraWidth =
3564     m_extraHeight = 50;
3565
3566     CalcDimensions();
3567 }
3568
3569 // ----------------------------------------------------------------------------
3570 // the idea is to call these functions only when necessary because they create
3571 // quite big arrays which eat memory mostly unnecessary - in particular, if
3572 // default widths/heights are used for all rows/columns, we may not use these
3573 // arrays at all
3574 //
3575 // with some extra code, it should be possible to only store the
3576 // widths/heights different from default ones but this will be done later...
3577 // ----------------------------------------------------------------------------
3578
3579 void wxGrid::InitRowHeights()
3580 {
3581     m_rowHeights.Empty();
3582     m_rowBottoms.Empty();
3583
3584     m_rowHeights.Alloc( m_numRows );
3585     m_rowBottoms.Alloc( m_numRows );
3586
3587     int rowBottom = 0;
3588     for ( int i = 0;  i < m_numRows;  i++ )
3589     {
3590         m_rowHeights.Add( m_defaultRowHeight );
3591         rowBottom += m_defaultRowHeight;
3592         m_rowBottoms.Add( rowBottom );
3593     }
3594 }
3595
3596 void wxGrid::InitColWidths()
3597 {
3598     m_colWidths.Empty();
3599     m_colRights.Empty();
3600
3601     m_colWidths.Alloc( m_numCols );
3602     m_colRights.Alloc( m_numCols );
3603     int colRight = 0;
3604     for ( int i = 0;  i < m_numCols;  i++ )
3605     {
3606         m_colWidths.Add( m_defaultColWidth );
3607         colRight += m_defaultColWidth;
3608         m_colRights.Add( colRight );
3609     }
3610 }
3611
3612 int wxGrid::GetColWidth(int col) const
3613 {
3614     return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
3615 }
3616
3617 int wxGrid::GetColLeft(int col) const
3618 {
3619     return m_colRights.IsEmpty() ? col * m_defaultColWidth
3620                                  : m_colRights[col] - m_colWidths[col];
3621 }
3622
3623 int wxGrid::GetColRight(int col) const
3624 {
3625     return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
3626                                  : m_colRights[col];
3627 }
3628
3629 int wxGrid::GetRowHeight(int row) const
3630 {
3631     return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
3632 }
3633
3634 int wxGrid::GetRowTop(int row) const
3635 {
3636     return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
3637                                   : m_rowBottoms[row] - m_rowHeights[row];
3638 }
3639
3640 int wxGrid::GetRowBottom(int row) const
3641 {
3642     return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
3643                                   : m_rowBottoms[row];
3644 }
3645
3646 void wxGrid::CalcDimensions()
3647 {
3648     int cw, ch;
3649     GetClientSize( &cw, &ch );
3650
3651     if ( m_numRows > 0  ||  m_numCols > 0 )
3652     {
3653         int right = m_numCols > 0 ? GetColRight( m_numCols-1 ) + m_extraWidth : 0;
3654         int bottom = m_numRows > 0 ? GetRowBottom( m_numRows-1 ) + m_extraHeight : 0;
3655
3656         // TODO: restore the scroll position that we had before sizing
3657         //
3658         int x, y;
3659         GetViewStart( &x, &y );
3660         SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
3661                        right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
3662                        x, y );
3663     }
3664 }
3665
3666
3667 void wxGrid::CalcWindowSizes()
3668 {
3669     int cw, ch;
3670     GetClientSize( &cw, &ch );
3671
3672     if ( m_cornerLabelWin->IsShown() )
3673         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
3674
3675     if ( m_colLabelWin->IsShown() )
3676         m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
3677
3678     if ( m_rowLabelWin->IsShown() )
3679         m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
3680
3681     if ( m_gridWin->IsShown() )
3682         m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
3683 }
3684
3685
3686 // this is called when the grid table sends a message to say that it
3687 // has been redimensioned
3688 //
3689 bool wxGrid::Redimension( wxGridTableMessage& msg )
3690 {
3691     int i;
3692     bool result = FALSE;
3693
3694 #if 0
3695     // if we were using the default widths/heights so far, we must change them
3696     // now
3697     if ( m_colWidths.IsEmpty() )
3698     {
3699         InitColWidths();
3700     }
3701
3702     if ( m_rowHeights.IsEmpty() )
3703     {
3704         InitRowHeights();
3705     }
3706 #endif
3707
3708     switch ( msg.GetId() )
3709     {
3710         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
3711         {
3712             size_t pos = msg.GetCommandInt();
3713             int numRows = msg.GetCommandInt2();
3714
3715             m_numRows += numRows;
3716
3717             if ( !m_rowHeights.IsEmpty() )
3718             {
3719                 for ( i = 0;  i < numRows;  i++ )
3720                 {
3721                     m_rowHeights.Insert( m_defaultRowHeight, pos );
3722                     m_rowBottoms.Insert( 0, pos );
3723                 }
3724
3725                 int bottom = 0;
3726                 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
3727
3728                 for ( i = pos;  i < m_numRows;  i++ )
3729                 {
3730                     bottom += m_rowHeights[i];
3731                     m_rowBottoms[i] = bottom;
3732                 }
3733             }
3734             if ( m_currentCellCoords == wxGridNoCellCoords )
3735             {
3736                 // if we have just inserted cols into an empty grid the current
3737                 // cell will be undefined...
3738                 //
3739                 SetCurrentCell( 0, 0 );
3740             }
3741             m_selection->UpdateRows( pos, numRows );
3742             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
3743             if (attrProvider)
3744                 attrProvider->UpdateAttrRows( pos, numRows );
3745
3746             if ( !GetBatchCount() )
3747             {
3748                 CalcDimensions();
3749                 m_rowLabelWin->Refresh();
3750             }
3751         }
3752         result = TRUE;
3753         break;
3754
3755         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
3756         {
3757             int numRows = msg.GetCommandInt();
3758             int oldNumRows = m_numRows;
3759             m_numRows += numRows;
3760
3761             if ( !m_rowHeights.IsEmpty() )
3762             {
3763                 for ( i = 0;  i < numRows;  i++ )
3764                 {
3765                     m_rowHeights.Add( m_defaultRowHeight );
3766                     m_rowBottoms.Add( 0 );
3767                 }
3768
3769                 int bottom = 0;
3770                 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
3771
3772                 for ( i = oldNumRows;  i < m_numRows;  i++ )
3773                 {
3774                     bottom += m_rowHeights[i];
3775                     m_rowBottoms[i] = bottom;
3776                 }
3777             }
3778             if ( m_currentCellCoords == wxGridNoCellCoords )
3779             {
3780                 // if we have just inserted cols into an empty grid the current
3781                 // cell will be undefined...
3782                 //
3783                 SetCurrentCell( 0, 0 );
3784             }
3785             if ( !GetBatchCount() )
3786             {
3787                 CalcDimensions();
3788                 m_rowLabelWin->Refresh();
3789             }
3790         }
3791         result = TRUE;
3792         break;
3793
3794         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
3795         {
3796             size_t pos = msg.GetCommandInt();
3797             int numRows = msg.GetCommandInt2();
3798             m_numRows -= numRows;
3799
3800             if ( !m_rowHeights.IsEmpty() )
3801             {
3802                 for ( i = 0;  i < numRows;  i++ )
3803                 {
3804                     m_rowHeights.Remove( pos );
3805                     m_rowBottoms.Remove( pos );
3806                 }
3807
3808                 int h = 0;
3809                 for ( i = 0;  i < m_numRows;  i++ )
3810                 {
3811                     h += m_rowHeights[i];
3812                     m_rowBottoms[i] = h;
3813                 }
3814             }
3815             if ( !m_numRows )
3816             {
3817                 m_currentCellCoords = wxGridNoCellCoords;
3818             }
3819             else
3820             {
3821                 if ( m_currentCellCoords.GetRow() >= m_numRows )
3822                     m_currentCellCoords.Set( 0, 0 );
3823             }
3824             m_selection->UpdateRows( pos, -((int)numRows) );
3825             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
3826             if (attrProvider) {
3827                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
3828 // ifdef'd out following patch from Paul Gammans
3829 #if 0
3830                 // removed _all_ rows, in this case, we remove
3831                 // all column attributes.
3832                 // I hate to do this here, but the
3833                 // needed data is not available inside UpdateAttrRows.
3834                 if ( !GetNumberRows() )
3835                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
3836 #endif
3837             }
3838             if ( !GetBatchCount() )
3839             {
3840                 CalcDimensions();
3841                 m_rowLabelWin->Refresh();
3842             }
3843         }
3844         result = TRUE;
3845         break;
3846
3847         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
3848         {
3849             size_t pos = msg.GetCommandInt();
3850             int numCols = msg.GetCommandInt2();
3851             m_numCols += numCols;
3852
3853             if ( !m_colWidths.IsEmpty() )
3854             {
3855                 for ( i = 0;  i < numCols;  i++ )
3856                 {
3857                     m_colWidths.Insert( m_defaultColWidth, pos );
3858                     m_colRights.Insert( 0, pos );
3859                 }
3860
3861                 int right = 0;
3862                 if ( pos > 0 ) right = m_colRights[pos-1];
3863
3864                 for ( i = pos;  i < m_numCols;  i++ )
3865                 {
3866                     right += m_colWidths[i];
3867                     m_colRights[i] = right;
3868                 }
3869             }
3870             if ( m_currentCellCoords == wxGridNoCellCoords )
3871             {
3872                 // if we have just inserted cols into an empty grid the current
3873                 // cell will be undefined...
3874                 //
3875                 SetCurrentCell( 0, 0 );
3876             }
3877             m_selection->UpdateCols( pos, numCols );
3878             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
3879             if (attrProvider)
3880                 attrProvider->UpdateAttrCols( pos, numCols );
3881             if ( !GetBatchCount() )
3882             {
3883                 CalcDimensions();
3884                 m_colLabelWin->Refresh();
3885             }
3886
3887         }
3888         result = TRUE;
3889         break;
3890
3891         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
3892         {
3893             int numCols = msg.GetCommandInt();
3894             int oldNumCols = m_numCols;
3895             m_numCols += numCols;
3896             if ( !m_colWidths.IsEmpty() )
3897             {
3898                 for ( i = 0;  i < numCols;  i++ )
3899                 {
3900                     m_colWidths.Add( m_defaultColWidth );
3901                     m_colRights.Add( 0 );
3902                 }
3903
3904                 int right = 0;
3905                 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
3906
3907                 for ( i = oldNumCols;  i < m_numCols;  i++ )
3908                 {
3909                     right += m_colWidths[i];
3910                     m_colRights[i] = right;
3911                 }
3912             }
3913             if ( m_currentCellCoords == wxGridNoCellCoords )
3914             {
3915                 // if we have just inserted cols into an empty grid the current
3916                 // cell will be undefined...
3917                 //
3918                 SetCurrentCell( 0, 0 );
3919             }
3920             if ( !GetBatchCount() )
3921             {
3922                 CalcDimensions();
3923                 m_colLabelWin->Refresh();
3924             }
3925         }
3926         result = TRUE;
3927         break;
3928
3929         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
3930         {
3931             size_t pos = msg.GetCommandInt();
3932             int numCols = msg.GetCommandInt2();
3933             m_numCols -= numCols;
3934
3935             if ( !m_colWidths.IsEmpty() )
3936             {
3937                 for ( i = 0;  i < numCols;  i++ )
3938                 {
3939                     m_colWidths.Remove( pos );
3940                     m_colRights.Remove( pos );
3941                 }
3942
3943                 int w = 0;
3944                 for ( i = 0;  i < m_numCols;  i++ )
3945                 {
3946                     w += m_colWidths[i];
3947                     m_colRights[i] = w;
3948                 }
3949             }
3950             if ( !m_numCols )
3951             {
3952                 m_currentCellCoords = wxGridNoCellCoords;
3953             }
3954             else
3955             {
3956                 if ( m_currentCellCoords.GetCol() >= m_numCols )
3957                   m_currentCellCoords.Set( 0, 0 );
3958             }
3959             m_selection->UpdateCols( pos, -((int)numCols) );
3960             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
3961             if (attrProvider) {
3962                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
3963 // ifdef'd out following patch from Paul Gammans
3964 #if 0
3965                 // No need to touch row attributes, unless we
3966                 // removed _all_ columns, in this case, we remove
3967                 // all row attributes.
3968                 // I hate to do this here, but the
3969                 // needed data is not available inside UpdateAttrCols.
3970                 if ( !GetNumberCols() )
3971                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
3972 #endif
3973             }
3974             if ( !GetBatchCount() )
3975             {
3976                 CalcDimensions();
3977                 m_colLabelWin->Refresh();
3978             }
3979             return TRUE;
3980         }
3981 #if 0
3982 // There is no path to this code !!!!!!
3983        result = TRUE;
3984         break;
3985 #endif
3986     }
3987
3988     if (result && !GetBatchCount() )
3989         m_gridWin->Refresh();
3990     return result;
3991 }
3992
3993
3994 void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
3995 {
3996     wxRegionIterator iter( reg );
3997     wxRect r;
3998
3999     m_rowLabelsExposed.Empty();
4000
4001     int top, bottom;
4002     while ( iter )
4003     {
4004         r = iter.GetRect();
4005
4006         // TODO: remove this when we can...
4007         // There is a bug in wxMotif that gives garbage update
4008         // rectangles if you jump-scroll a long way by clicking the
4009         // scrollbar with middle button.  This is a work-around
4010         //
4011 #if defined(__WXMOTIF__)
4012         int cw, ch;
4013         m_gridWin->GetClientSize( &cw, &ch );
4014         if ( r.GetTop() > ch ) r.SetTop( 0 );
4015         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4016 #endif
4017
4018         // logical bounds of update region
4019         //
4020         int dummy;
4021         CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4022         CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4023
4024         // find the row labels within these bounds
4025         //
4026         int row;
4027         for ( row = 0;  row < m_numRows;  row++ )
4028         {
4029             if ( GetRowBottom(row) < top )
4030                 continue;
4031
4032             if ( GetRowTop(row) > bottom )
4033                 break;
4034
4035             m_rowLabelsExposed.Add( row );
4036         }
4037
4038         iter++ ;
4039     }
4040 }
4041
4042
4043 void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4044 {
4045     wxRegionIterator iter( reg );
4046     wxRect r;
4047
4048     m_colLabelsExposed.Empty();
4049
4050     int left, right;
4051     while ( iter )
4052     {
4053         r = iter.GetRect();
4054
4055         // TODO: remove this when we can...
4056         // There is a bug in wxMotif that gives garbage update
4057         // rectangles if you jump-scroll a long way by clicking the
4058         // scrollbar with middle button.  This is a work-around
4059         //
4060 #if defined(__WXMOTIF__)
4061         int cw, ch;
4062         m_gridWin->GetClientSize( &cw, &ch );
4063         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4064         r.SetRight( wxMin( r.GetRight(), cw ) );
4065 #endif
4066
4067         // logical bounds of update region
4068         //
4069         int dummy;
4070         CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4071         CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4072
4073         // find the cells within these bounds
4074         //
4075         int col;
4076         for ( col = 0;  col < m_numCols;  col++ )
4077         {
4078             if ( GetColRight(col) < left )
4079                 continue;
4080
4081             if ( GetColLeft(col) > right )
4082                 break;
4083
4084             m_colLabelsExposed.Add( col );
4085         }
4086
4087         iter++ ;
4088     }
4089 }
4090
4091
4092 void wxGrid::CalcCellsExposed( const wxRegion& reg )
4093 {
4094     wxRegionIterator iter( reg );
4095     wxRect r;
4096
4097     m_cellsExposed.Empty();
4098     m_rowsExposed.Empty();
4099     m_colsExposed.Empty();
4100
4101     int left, top, right, bottom;
4102     while ( iter )
4103     {
4104         r = iter.GetRect();
4105
4106         // TODO: remove this when we can...
4107         // There is a bug in wxMotif that gives garbage update
4108         // rectangles if you jump-scroll a long way by clicking the
4109         // scrollbar with middle button.  This is a work-around
4110         //
4111 #if defined(__WXMOTIF__)
4112         int cw, ch;
4113         m_gridWin->GetClientSize( &cw, &ch );
4114         if ( r.GetTop() > ch ) r.SetTop( 0 );
4115         if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4116         r.SetRight( wxMin( r.GetRight(), cw ) );
4117         r.SetBottom( wxMin( r.GetBottom(), ch ) );
4118 #endif
4119
4120         // logical bounds of update region
4121         //
4122         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4123         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4124
4125         // find the cells within these bounds
4126         //
4127         int row, col;
4128         for ( row = 0;  row < m_numRows;  row++ )
4129         {
4130             if ( GetRowBottom(row) <= top )
4131                 continue;
4132
4133             if ( GetRowTop(row) > bottom )
4134                 break;
4135
4136             m_rowsExposed.Add( row );
4137
4138             for ( col = 0;  col < m_numCols;  col++ )
4139             {
4140                 if ( GetColRight(col) <= left )
4141                     continue;
4142
4143                 if ( GetColLeft(col) > right )
4144                     break;
4145
4146                 if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
4147                     m_colsExposed.Add( col );
4148                 m_cellsExposed.Add( wxGridCellCoords( row, col ) );
4149             }
4150         }
4151
4152         iter++;
4153     }
4154 }
4155
4156
4157 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4158 {
4159     int x, y, row;
4160     wxPoint pos( event.GetPosition() );
4161     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4162
4163     if ( event.Dragging() )
4164     {
4165         m_isDragging = TRUE;
4166
4167         if ( event.LeftIsDown() )
4168         {
4169             switch( m_cursorMode )
4170             {
4171                 case WXGRID_CURSOR_RESIZE_ROW:
4172                 {
4173                     int cw, ch, left, dummy;
4174                     m_gridWin->GetClientSize( &cw, &ch );
4175                     CalcUnscrolledPosition( 0, 0, &left, &dummy );
4176
4177                     wxClientDC dc( m_gridWin );
4178                     PrepareDC( dc );
4179                     y = wxMax( y,
4180                                GetRowTop(m_dragRowOrCol) +
4181                                GetRowMinimalHeight(m_dragRowOrCol) );
4182                     dc.SetLogicalFunction(wxINVERT);
4183                     if ( m_dragLastPos >= 0 )
4184                     {
4185                         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4186                     }
4187                     dc.DrawLine( left, y, left+cw, y );
4188                     m_dragLastPos = y;
4189                 }
4190                 break;
4191
4192                 case WXGRID_CURSOR_SELECT_ROW:
4193                     if ( (row = YToRow( y )) >= 0 )
4194                     {
4195                         m_selection->SelectRow( row,
4196                                                 event.ControlDown(),
4197                                                 event.ShiftDown(),
4198                                                 event.AltDown(),
4199                                                 event.MetaDown() );
4200                     }
4201
4202                 // default label to suppress warnings about "enumeration value
4203                 // 'xxx' not handled in switch
4204                 default:
4205                     break;
4206             }
4207         }
4208         return;
4209     }
4210
4211     m_isDragging = FALSE;
4212
4213
4214     // ------------ Entering or leaving the window
4215     //
4216     if ( event.Entering() || event.Leaving() )
4217     {
4218         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4219     }
4220
4221
4222     // ------------ Left button pressed
4223     //
4224     else if ( event.LeftDown() )
4225     {
4226         // don't send a label click event for a hit on the
4227         // edge of the row label - this is probably the user
4228         // wanting to resize the row
4229         //
4230         if ( YToEdgeOfRow(y) < 0 )
4231         {
4232             row = YToRow(y);
4233             if ( row >= 0  &&
4234                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4235             {
4236                 if ( !event.ShiftDown() && !event.ControlDown() )
4237                     ClearSelection();
4238                 if ( event.ShiftDown() )
4239                     m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4240                                               0,
4241                                               row,
4242                                               GetNumberCols() - 1,
4243                                               event.ControlDown(),
4244                                               event.ShiftDown(),
4245                                               event.AltDown(),
4246                                               event.MetaDown() );
4247                 else
4248                     m_selection->SelectRow( row,
4249                                             event.ControlDown(),
4250                                             event.ShiftDown(),
4251                                             event.AltDown(),
4252                                             event.MetaDown() );
4253                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4254             }
4255         }
4256         else
4257         {
4258             // starting to drag-resize a row
4259             //
4260             if ( CanDragRowSize() )
4261                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4262         }
4263     }
4264
4265
4266     // ------------ Left double click
4267     //
4268     else if (event.LeftDClick() )
4269     {
4270         if ( YToEdgeOfRow(y) < 0 )
4271         {
4272             row = YToRow(y);
4273             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event );
4274         }
4275     }
4276
4277
4278     // ------------ Left button released
4279     //
4280     else if ( event.LeftUp() )
4281     {
4282         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4283         {
4284             DoEndDragResizeRow();
4285
4286             // Note: we are ending the event *after* doing
4287             // default processing in this case
4288             //
4289             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4290         }
4291
4292         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4293         m_dragLastPos = -1;
4294     }
4295
4296
4297     // ------------ Right button down
4298     //
4299     else if ( event.RightDown() )
4300     {
4301         row = YToRow(y);
4302         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4303         {
4304             // no default action at the moment
4305         }
4306     }
4307
4308
4309     // ------------ Right double click
4310     //
4311     else if ( event.RightDClick() )
4312     {
4313         row = YToRow(y);
4314         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4315         {
4316             // no default action at the moment
4317         }
4318     }
4319
4320
4321     // ------------ No buttons down and mouse moving
4322     //
4323     else if ( event.Moving() )
4324     {
4325         m_dragRowOrCol = YToEdgeOfRow( y );
4326         if ( m_dragRowOrCol >= 0 )
4327         {
4328             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4329             {
4330                 // don't capture the mouse yet
4331                 if ( CanDragRowSize() )
4332                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4333             }
4334         }
4335         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4336         {
4337             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4338         }
4339     }
4340 }
4341
4342
4343 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4344 {
4345     int x, y, col;
4346     wxPoint pos( event.GetPosition() );
4347     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4348
4349     if ( event.Dragging() )
4350     {
4351         m_isDragging = TRUE;
4352
4353         if ( event.LeftIsDown() )
4354         {
4355             switch( m_cursorMode )
4356             {
4357                 case WXGRID_CURSOR_RESIZE_COL:
4358                 {
4359                     int cw, ch, dummy, top;
4360                     m_gridWin->GetClientSize( &cw, &ch );
4361                     CalcUnscrolledPosition( 0, 0, &dummy, &top );
4362
4363                     wxClientDC dc( m_gridWin );
4364                     PrepareDC( dc );
4365
4366                     x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4367                                   GetColMinimalWidth(m_dragRowOrCol));
4368                     dc.SetLogicalFunction(wxINVERT);
4369                     if ( m_dragLastPos >= 0 )
4370                     {
4371                         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4372                     }
4373                     dc.DrawLine( x, top, x, top+ch );
4374                     m_dragLastPos = x;
4375                 }
4376                 break;
4377
4378                 case WXGRID_CURSOR_SELECT_COL:
4379                     if ( (col = XToCol( x )) >= 0 )
4380                     {
4381                         m_selection->SelectCol( col,
4382                                                 event.ControlDown(),
4383                                                 event.ShiftDown(),
4384                                                 event.AltDown(),
4385                                                 event.MetaDown() );
4386                     }
4387
4388                 // default label to suppress warnings about "enumeration value
4389                 // 'xxx' not handled in switch
4390                 default:
4391                     break;
4392             }
4393         }
4394         return;
4395     }
4396
4397     m_isDragging = FALSE;
4398
4399
4400     // ------------ Entering or leaving the window
4401     //
4402     if ( event.Entering() || event.Leaving() )
4403     {
4404         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4405     }
4406
4407
4408     // ------------ Left button pressed
4409     //
4410     else if ( event.LeftDown() )
4411     {
4412         // don't send a label click event for a hit on the
4413         // edge of the col label - this is probably the user
4414         // wanting to resize the col
4415         //
4416         if ( XToEdgeOfCol(x) < 0 )
4417         {
4418             col = XToCol(x);
4419             if ( col >= 0  &&
4420                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
4421             {
4422                 if ( !event.ShiftDown() && !event.ControlDown() )
4423                     ClearSelection();
4424                 if ( event.ShiftDown() )
4425                     m_selection->SelectBlock( 0,
4426                                               m_currentCellCoords.GetCol(),
4427                                               GetNumberRows() - 1, col,
4428                                               event.ControlDown(),
4429                                               event.ShiftDown(),
4430                                               event.AltDown(),
4431                                               event.MetaDown() );
4432                 else
4433                     m_selection->SelectCol( col,
4434                                             event.ControlDown(),
4435                                             event.ShiftDown(),
4436                                             event.AltDown(),
4437                                             event.MetaDown() );
4438                 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
4439             }
4440         }
4441         else
4442         {
4443             // starting to drag-resize a col
4444             //
4445             if ( CanDragColSize() )
4446                 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
4447         }
4448     }
4449
4450
4451     // ------------ Left double click
4452     //
4453     if ( event.LeftDClick() )
4454     {
4455         if ( XToEdgeOfCol(x) < 0 )
4456         {
4457             col = XToCol(x);
4458             SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event );
4459         }
4460     }
4461
4462
4463     // ------------ Left button released
4464     //
4465     else if ( event.LeftUp() )
4466     {
4467         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4468         {
4469             DoEndDragResizeCol();
4470
4471             // Note: we are ending the event *after* doing
4472             // default processing in this case
4473             //
4474             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
4475         }
4476
4477         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4478         m_dragLastPos  = -1;
4479     }
4480
4481
4482     // ------------ Right button down
4483     //
4484     else if ( event.RightDown() )
4485     {
4486         col = XToCol(x);
4487         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
4488         {
4489             // no default action at the moment
4490         }
4491     }
4492
4493
4494     // ------------ Right double click
4495     //
4496     else if ( event.RightDClick() )
4497     {
4498         col = XToCol(x);
4499         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
4500         {
4501             // no default action at the moment
4502         }
4503     }
4504
4505
4506     // ------------ No buttons down and mouse moving
4507     //
4508     else if ( event.Moving() )
4509     {
4510         m_dragRowOrCol = XToEdgeOfCol( x );
4511         if ( m_dragRowOrCol >= 0 )
4512         {
4513             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4514             {
4515                 // don't capture the cursor yet
4516                 if ( CanDragColSize() )
4517                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
4518             }
4519         }
4520         else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4521         {
4522             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
4523         }
4524     }
4525 }
4526
4527
4528 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
4529 {
4530     if ( event.LeftDown() )
4531     {
4532         // indicate corner label by having both row and
4533         // col args == -1
4534         //
4535         if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
4536         {
4537             SelectAll();
4538         }
4539     }
4540
4541     else if ( event.LeftDClick() )
4542     {
4543         SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
4544     }
4545
4546     else if ( event.RightDown() )
4547     {
4548         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
4549         {
4550             // no default action at the moment
4551         }
4552     }
4553
4554     else if ( event.RightDClick() )
4555     {
4556         if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
4557         {
4558             // no default action at the moment
4559         }
4560     }
4561 }
4562
4563 void wxGrid::ChangeCursorMode(CursorMode mode,
4564                               wxWindow *win,
4565                               bool captureMouse)
4566 {
4567 #ifdef __WXDEBUG__
4568     static const wxChar *cursorModes[] =
4569     {
4570         _T("SELECT_CELL"),
4571         _T("RESIZE_ROW"),
4572         _T("RESIZE_COL"),
4573         _T("SELECT_ROW"),
4574         _T("SELECT_COL")
4575     };
4576
4577     wxLogTrace(_T("grid"),
4578                _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
4579                win == m_colLabelWin ? _T("colLabelWin")
4580                                     : win ? _T("rowLabelWin")
4581                                           : _T("gridWin"),
4582                cursorModes[m_cursorMode], cursorModes[mode]);
4583 #endif // __WXDEBUG__
4584
4585     if ( mode == m_cursorMode )
4586         return;
4587
4588     if ( !win )
4589     {
4590         // by default use the grid itself
4591         win = m_gridWin;
4592     }
4593
4594     if ( m_winCapture )
4595     {
4596         m_winCapture->ReleaseMouse();
4597         m_winCapture = (wxWindow *)NULL;
4598     }
4599
4600     m_cursorMode = mode;
4601
4602     switch ( m_cursorMode )
4603     {
4604         case WXGRID_CURSOR_RESIZE_ROW:
4605             win->SetCursor( m_rowResizeCursor );
4606             break;
4607
4608         case WXGRID_CURSOR_RESIZE_COL:
4609             win->SetCursor( m_colResizeCursor );
4610             break;
4611
4612         default:
4613             win->SetCursor( *wxSTANDARD_CURSOR );
4614     }
4615
4616     // we need to capture mouse when resizing
4617     bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
4618                   m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
4619
4620     if ( captureMouse && resize )
4621     {
4622         win->CaptureMouse();
4623         m_winCapture = win;
4624     }
4625 }
4626
4627 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
4628 {
4629     int x, y;
4630     wxPoint pos( event.GetPosition() );
4631     CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4632
4633     wxGridCellCoords coords;
4634     XYToCell( x, y, coords );
4635
4636     if ( event.Dragging() )
4637     {
4638         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4639
4640         // Don't start doing anything until the mouse has been drug at
4641         // least 3 pixels in any direction...
4642         if (! m_isDragging)
4643         {
4644             if (m_startDragPos == wxDefaultPosition)
4645             {
4646                 m_startDragPos = pos;
4647                 return;
4648             }
4649             if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
4650                 return;
4651         }
4652
4653         m_isDragging = TRUE;
4654         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4655         {
4656             // Hide the edit control, so it
4657             // won't interfer with drag-shrinking.
4658             if ( IsCellEditControlShown() )
4659             {
4660                 HideCellEditControl();
4661                 SaveEditControlValue();
4662             }
4663
4664             // Have we captured the mouse yet?
4665             if (! m_winCapture)
4666             {
4667                 m_winCapture = m_gridWin;
4668                 m_winCapture->CaptureMouse();
4669             }
4670
4671             if ( coords != wxGridNoCellCoords )
4672             {
4673                 if ( event.ControlDown() )
4674                 {
4675                     if ( m_selectingKeyboard == wxGridNoCellCoords)
4676                         m_selectingKeyboard = coords;
4677                     SelectBlock ( m_selectingKeyboard, coords );
4678                 }
4679                 else
4680                 {
4681                     if ( !IsSelection() )
4682                     {
4683                         SelectBlock( coords, coords );
4684                     }
4685                     else
4686                     {
4687                         SelectBlock( m_currentCellCoords, coords );
4688                     }
4689                 }
4690
4691                 if (! IsVisible(coords))
4692                 {
4693                     MakeCellVisible(coords);
4694                     // TODO: need to introduce a delay or something here.  The
4695                     // scrolling is way to fast, at least on MSW - also on GTK.
4696                 }
4697             }
4698         }
4699         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4700         {
4701             int cw, ch, left, dummy;
4702             m_gridWin->GetClientSize( &cw, &ch );
4703             CalcUnscrolledPosition( 0, 0, &left, &dummy );
4704
4705             wxClientDC dc( m_gridWin );
4706             PrepareDC( dc );
4707             y = wxMax( y, GetRowTop(m_dragRowOrCol) +
4708                           GetRowMinimalHeight(m_dragRowOrCol) );
4709             dc.SetLogicalFunction(wxINVERT);
4710             if ( m_dragLastPos >= 0 )
4711             {
4712                 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4713             }
4714             dc.DrawLine( left, y, left+cw, y );
4715             m_dragLastPos = y;
4716         }
4717         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4718         {
4719             int cw, ch, dummy, top;
4720             m_gridWin->GetClientSize( &cw, &ch );
4721             CalcUnscrolledPosition( 0, 0, &dummy, &top );
4722
4723             wxClientDC dc( m_gridWin );
4724             PrepareDC( dc );
4725             x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4726                           GetColMinimalWidth(m_dragRowOrCol) );
4727             dc.SetLogicalFunction(wxINVERT);
4728             if ( m_dragLastPos >= 0 )
4729             {
4730                 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4731             }
4732             dc.DrawLine( x, top, x, top+ch );
4733             m_dragLastPos = x;
4734         }
4735
4736         return;
4737     }
4738
4739     m_isDragging = FALSE;
4740     m_startDragPos = wxDefaultPosition;
4741
4742     // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
4743     //     immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
4744     //     wxGTK
4745 #if 0
4746     if ( event.Entering() || event.Leaving() )
4747     {
4748         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4749         m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
4750     }
4751     else
4752 #endif // 0
4753
4754     // ------------ Left button pressed
4755     //
4756     if ( event.LeftDown() && coords != wxGridNoCellCoords )
4757     {
4758         if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
4759                        coords.GetRow(),
4760                        coords.GetCol(),
4761                        event ) )
4762         {
4763             if ( !event.ControlDown() )
4764                 ClearSelection();
4765             if ( event.ShiftDown() )
4766             {
4767                 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4768                                           m_currentCellCoords.GetCol(),
4769                                           coords.GetRow(),
4770                                           coords.GetCol(),
4771                                           event.ControlDown(),
4772                                           event.ShiftDown(),
4773                                           event.AltDown(),
4774                                           event.MetaDown() );
4775             }
4776             else if ( XToEdgeOfCol(x) < 0  &&
4777                       YToEdgeOfRow(y) < 0 )
4778             {
4779                 DisableCellEditControl();
4780                 MakeCellVisible( coords );
4781
4782                 // if this is the second click on this cell then start
4783                 // the edit control
4784                 if ( m_waitForSlowClick &&
4785                      (coords == m_currentCellCoords) &&
4786                      CanEnableCellControl())
4787                 {
4788                     EnableCellEditControl();
4789
4790                     wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
4791                     wxGridCellEditor *editor = attr->GetEditor(this,
4792                                                                coords.GetRow(),
4793                                                                coords.GetCol());
4794                     editor->StartingClick();
4795                     editor->DecRef();
4796                     attr->DecRef();
4797
4798                     m_waitForSlowClick = FALSE;
4799                 }
4800                 else
4801                 {
4802                     if ( event.ControlDown() )
4803                     {
4804                         m_selection->ToggleCellSelection( coords.GetRow(),
4805                                                           coords.GetCol(),
4806                                                           event.ControlDown(),
4807                                                           event.ShiftDown(),
4808                                                           event.AltDown(),
4809                                                           event.MetaDown() );
4810                         m_selectingTopLeft = wxGridNoCellCoords;
4811                         m_selectingBottomRight = wxGridNoCellCoords;
4812                         m_selectingKeyboard = coords;
4813                     }
4814                     else
4815                     {
4816                         SetCurrentCell( coords );
4817                         if ( m_selection->GetSelectionMode()
4818                              != wxGrid::wxGridSelectCells)
4819                             SelectBlock( coords, coords );
4820                     }
4821                     m_waitForSlowClick = TRUE;
4822                 }
4823             }
4824         }
4825     }
4826
4827
4828     // ------------ Left double click
4829     //
4830     else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
4831     {
4832         DisableCellEditControl();
4833
4834         if ( XToEdgeOfCol(x) < 0  &&  YToEdgeOfRow(y) < 0 )
4835         {
4836             SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
4837                        coords.GetRow(),
4838                        coords.GetCol(),
4839                        event );
4840         }
4841     }
4842
4843
4844     // ------------ Left button released
4845     //
4846     else if ( event.LeftUp() )
4847     {
4848         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4849         {
4850             if ( m_selectingTopLeft != wxGridNoCellCoords &&
4851                  m_selectingBottomRight != wxGridNoCellCoords )
4852             {
4853                 if (m_winCapture)
4854                 {
4855                     m_winCapture->ReleaseMouse();
4856                     m_winCapture = NULL;
4857                 }
4858                 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
4859                                           m_selectingTopLeft.GetCol(),
4860                                           m_selectingBottomRight.GetRow(),
4861                                           m_selectingBottomRight.GetCol(),
4862                                           event.ControlDown(),
4863                                           event.ShiftDown(),
4864                                           event.AltDown(),
4865                                           event.MetaDown() );
4866                 m_selectingTopLeft = wxGridNoCellCoords;
4867                 m_selectingBottomRight = wxGridNoCellCoords;
4868             }
4869
4870             // Show the edit control, if it has been hidden for
4871             // drag-shrinking.
4872             ShowCellEditControl();
4873         }
4874         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4875         {
4876             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4877             DoEndDragResizeRow();
4878
4879             // Note: we are ending the event *after* doing
4880             // default processing in this case
4881             //
4882             SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4883         }
4884         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
4885         {
4886             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4887             DoEndDragResizeCol();
4888
4889             // Note: we are ending the event *after* doing
4890             // default processing in this case
4891             //
4892             SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
4893         }
4894
4895         m_dragLastPos = -1;
4896     }
4897
4898
4899     // ------------ Right button down
4900     //
4901     else if ( event.RightDown() && coords != wxGridNoCellCoords )
4902     {
4903         DisableCellEditControl();
4904         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
4905                          coords.GetRow(),
4906                          coords.GetCol(),
4907                          event ) )
4908         {
4909             // no default action at the moment
4910         }
4911     }
4912
4913
4914     // ------------ Right double click
4915     //
4916     else if ( event.RightDClick() && coords != wxGridNoCellCoords )
4917     {
4918         DisableCellEditControl();
4919         if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
4920                          coords.GetRow(),
4921                          coords.GetCol(),
4922                          event ) )
4923         {
4924             // no default action at the moment
4925         }
4926     }
4927
4928     // ------------ Moving and no button action
4929     //
4930     else if ( event.Moving() && !event.IsButton() )
4931     {
4932         int dragRow = YToEdgeOfRow( y );
4933         int dragCol = XToEdgeOfCol( x );
4934
4935         // Dragging on the corner of a cell to resize in both
4936         // directions is not implemented yet...
4937         //
4938         if ( dragRow >= 0  &&  dragCol >= 0 )
4939         {
4940             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4941             return;
4942         }
4943
4944         if ( dragRow >= 0 )
4945         {
4946             m_dragRowOrCol = dragRow;
4947
4948             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4949             {
4950                 if ( CanDragRowSize() && CanDragGridSize() )
4951                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
4952             }
4953
4954             if ( dragCol >= 0 )
4955             {
4956                 m_dragRowOrCol = dragCol;
4957             }
4958
4959             return;
4960         }
4961
4962         if ( dragCol >= 0 )
4963         {
4964             m_dragRowOrCol = dragCol;
4965
4966             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4967             {
4968                 if ( CanDragColSize() && CanDragGridSize() )
4969                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
4970             }
4971
4972             return;
4973         }
4974
4975         // Neither on a row or col edge
4976         //
4977         if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4978         {
4979             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
4980         }
4981     }
4982 }
4983
4984
4985 void wxGrid::DoEndDragResizeRow()
4986 {
4987     if ( m_dragLastPos >= 0 )
4988     {
4989         // erase the last line and resize the row
4990         //
4991         int cw, ch, left, dummy;
4992         m_gridWin->GetClientSize( &cw, &ch );
4993         CalcUnscrolledPosition( 0, 0, &left, &dummy );
4994
4995         wxClientDC dc( m_gridWin );
4996         PrepareDC( dc );
4997         dc.SetLogicalFunction( wxINVERT );
4998         dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4999         HideCellEditControl();
5000         SaveEditControlValue();
5001
5002         int rowTop = GetRowTop(m_dragRowOrCol);
5003         SetRowSize( m_dragRowOrCol,
5004                     wxMax( m_dragLastPos - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
5005
5006         if ( !GetBatchCount() )
5007         {
5008             // Only needed to get the correct rect.y:
5009             wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5010             rect.x = 0;
5011             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5012             rect.width = m_rowLabelWidth;
5013             rect.height = ch - rect.y;
5014             m_rowLabelWin->Refresh( TRUE, &rect );
5015             rect.width = cw;
5016             m_gridWin->Refresh( FALSE, &rect );
5017         }
5018
5019         ShowCellEditControl();
5020     }
5021 }
5022
5023
5024 void wxGrid::DoEndDragResizeCol()
5025 {
5026     if ( m_dragLastPos >= 0 )
5027     {
5028         // erase the last line and resize the col
5029         //
5030         int cw, ch, dummy, top;
5031         m_gridWin->GetClientSize( &cw, &ch );
5032         CalcUnscrolledPosition( 0, 0, &dummy, &top );
5033
5034         wxClientDC dc( m_gridWin );
5035         PrepareDC( dc );
5036         dc.SetLogicalFunction( wxINVERT );
5037         dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5038         HideCellEditControl();
5039         SaveEditControlValue();
5040
5041         int colLeft = GetColLeft(m_dragRowOrCol);
5042         SetColSize( m_dragRowOrCol,
5043                     wxMax( m_dragLastPos - colLeft,
5044                            GetColMinimalWidth(m_dragRowOrCol) ) );
5045
5046         if ( !GetBatchCount() )
5047         {
5048             // Only needed to get the correct rect.x:
5049             wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5050             rect.y = 0;
5051             CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5052             rect.width = cw - rect.x;
5053             rect.height = m_colLabelHeight;
5054             m_colLabelWin->Refresh( TRUE, &rect );
5055             rect.height = ch;
5056             m_gridWin->Refresh( FALSE, &rect );
5057         }
5058
5059         ShowCellEditControl();
5060     }
5061 }
5062
5063
5064
5065 //
5066 // ------ interaction with data model
5067 //
5068 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5069 {
5070     switch ( msg.GetId() )
5071     {
5072         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5073             return GetModelValues();
5074
5075         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5076             return SetModelValues();
5077
5078         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5079         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5080         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5081         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5082         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5083         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5084             return Redimension( msg );
5085
5086         default:
5087             return FALSE;
5088     }
5089 }
5090
5091
5092
5093 // The behaviour of this function depends on the grid table class
5094 // Clear() function.  For the default wxGridStringTable class the
5095 // behavious is to replace all cell contents with wxEmptyString but
5096 // not to change the number of rows or cols.
5097 //
5098 void wxGrid::ClearGrid()
5099 {
5100     if ( m_table )
5101     {
5102         if (IsCellEditControlEnabled())
5103             DisableCellEditControl();
5104
5105         m_table->Clear();
5106         if ( !GetBatchCount() ) m_gridWin->Refresh();
5107     }
5108 }
5109
5110
5111 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5112 {
5113     // TODO: something with updateLabels flag
5114
5115     if ( !m_created )
5116     {
5117         wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5118         return FALSE;
5119     }
5120
5121     if ( m_table )
5122     {
5123         if (IsCellEditControlEnabled())
5124             DisableCellEditControl();
5125
5126         return m_table->InsertRows( pos, numRows );
5127
5128         // the table will have sent the results of the insert row
5129         // operation to this view object as a grid table message
5130     }
5131     return FALSE;
5132 }
5133
5134
5135 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5136 {
5137     // TODO: something with updateLabels flag
5138
5139     if ( !m_created )
5140     {
5141         wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5142         return FALSE;
5143     }
5144
5145     return ( m_table && m_table->AppendRows( numRows ) );
5146     // the table will have sent the results of the append row
5147     // operation to this view object as a grid table message
5148 }
5149
5150
5151 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5152 {
5153     // TODO: something with updateLabels flag
5154
5155     if ( !m_created )
5156     {
5157         wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5158         return FALSE;
5159     }
5160
5161     if ( m_table )
5162     {
5163         if (IsCellEditControlEnabled())
5164             DisableCellEditControl();
5165
5166         return (m_table->DeleteRows( pos, numRows ));
5167         // the table will have sent the results of the delete row
5168         // operation to this view object as a grid table message
5169     }
5170     return FALSE;
5171 }
5172
5173
5174 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5175 {
5176     // TODO: something with updateLabels flag
5177
5178     if ( !m_created )
5179     {
5180         wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5181         return FALSE;
5182     }
5183
5184     if ( m_table )
5185     {
5186         if (IsCellEditControlEnabled())
5187             DisableCellEditControl();
5188
5189         return m_table->InsertCols( pos, numCols );
5190         // the table will have sent the results of the insert col
5191         // operation to this view object as a grid table message
5192     }
5193     return FALSE;
5194 }
5195
5196
5197 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5198 {
5199     // TODO: something with updateLabels flag
5200
5201     if ( !m_created )
5202     {
5203         wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5204         return FALSE;
5205     }
5206
5207     return ( m_table && m_table->AppendCols( numCols ) );
5208     // the table will have sent the results of the append col
5209     // operation to this view object as a grid table message
5210 }
5211
5212
5213 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5214 {
5215     // TODO: something with updateLabels flag
5216
5217     if ( !m_created )
5218     {
5219         wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5220         return FALSE;
5221     }
5222
5223     if ( m_table )
5224     {
5225         if (IsCellEditControlEnabled())
5226             DisableCellEditControl();
5227
5228         return ( m_table->DeleteCols( pos, numCols ) );
5229         // the table will have sent the results of the delete col
5230         // operation to this view object as a grid table message
5231     }
5232     return FALSE;
5233 }
5234
5235
5236
5237 //
5238 // ----- event handlers
5239 //
5240
5241 // Generate a grid event based on a mouse event and
5242 // return the result of ProcessEvent()
5243 //
5244 bool wxGrid::SendEvent( const wxEventType type,
5245                         int row, int col,
5246                         wxMouseEvent& mouseEv )
5247 {
5248     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5249     {
5250         int rowOrCol = (row == -1 ? col : row);
5251
5252         wxGridSizeEvent gridEvt( GetId(),
5253                                  type,
5254                                  this,
5255                                  rowOrCol,
5256                                  mouseEv.GetX() + GetColLabelSize(),
5257                                  mouseEv.GetY() + GetRowLabelSize(),
5258                                  mouseEv.ControlDown(),
5259                                  mouseEv.ShiftDown(),
5260                                  mouseEv.AltDown(),
5261                                  mouseEv.MetaDown() );
5262
5263         return GetEventHandler()->ProcessEvent(gridEvt);
5264     }
5265     else if ( type == wxEVT_GRID_RANGE_SELECT )
5266     {
5267         // Right now, it should _never_ end up here!
5268         wxGridRangeSelectEvent gridEvt( GetId(),
5269                                         type,
5270                                         this,
5271                                         m_selectingTopLeft,
5272                                         m_selectingBottomRight,
5273                                         TRUE,
5274                                         mouseEv.ControlDown(),
5275                                         mouseEv.ShiftDown(),
5276                                         mouseEv.AltDown(),
5277                                         mouseEv.MetaDown() );
5278
5279         return GetEventHandler()->ProcessEvent(gridEvt);
5280     }
5281     else
5282     {
5283         wxGridEvent gridEvt( GetId(),
5284                              type,
5285                              this,
5286                              row, col,
5287                              mouseEv.GetX() + GetColLabelSize(),
5288                              mouseEv.GetY() + GetRowLabelSize(),
5289                              FALSE,
5290                              mouseEv.ControlDown(),
5291                              mouseEv.ShiftDown(),
5292                              mouseEv.AltDown(),
5293                              mouseEv.MetaDown() );
5294
5295         return GetEventHandler()->ProcessEvent(gridEvt);
5296     }
5297 }
5298
5299
5300 // Generate a grid event of specified type and return the result
5301 // of ProcessEvent().
5302 //
5303 bool wxGrid::SendEvent( const wxEventType type,
5304                         int row, int col )
5305 {
5306     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5307     {
5308         int rowOrCol = (row == -1 ? col : row);
5309
5310         wxGridSizeEvent gridEvt( GetId(),
5311                                  type,
5312                                  this,
5313                                  rowOrCol );
5314
5315         return GetEventHandler()->ProcessEvent(gridEvt);
5316     }
5317     else
5318     {
5319         wxGridEvent gridEvt( GetId(),
5320                              type,
5321                              this,
5322                              row, col );
5323
5324         return GetEventHandler()->ProcessEvent(gridEvt);
5325     }
5326 }
5327
5328
5329 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
5330 {
5331     wxPaintDC dc(this);  // needed to prevent zillions of paint events on MSW
5332 }
5333
5334
5335 // This is just here to make sure that CalcDimensions gets called when
5336 // the grid view is resized... then the size event is skipped to allow
5337 // the box sizers to handle everything
5338 //
5339 void wxGrid::OnSize( wxSizeEvent& WXUNUSED(event) )
5340 {
5341     CalcWindowSizes();
5342     CalcDimensions();
5343 }
5344
5345
5346 void wxGrid::OnKeyDown( wxKeyEvent& event )
5347 {
5348     if ( m_inOnKeyDown )
5349     {
5350         // shouldn't be here - we are going round in circles...
5351         //
5352         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
5353     }
5354
5355     m_inOnKeyDown = TRUE;
5356
5357     // propagate the event up and see if it gets processed
5358     //
5359     wxWindow *parent = GetParent();
5360     wxKeyEvent keyEvt( event );
5361     keyEvt.SetEventObject( parent );
5362
5363     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
5364     {
5365
5366         // try local handlers
5367         //
5368         switch ( event.KeyCode() )
5369         {
5370             case WXK_UP:
5371                 if ( event.ControlDown() )
5372                 {
5373                     MoveCursorUpBlock( event.ShiftDown() );
5374                 }
5375                 else
5376                 {
5377                     MoveCursorUp( event.ShiftDown() );
5378                 }
5379                 break;
5380
5381             case WXK_DOWN:
5382                 if ( event.ControlDown() )
5383                 {
5384                     MoveCursorDownBlock( event.ShiftDown() );
5385                 }
5386                 else
5387                 {
5388                     MoveCursorDown( event.ShiftDown() );
5389                 }
5390                 break;
5391
5392             case WXK_LEFT:
5393                 if ( event.ControlDown() )
5394                 {
5395                     MoveCursorLeftBlock( event.ShiftDown() );
5396                 }
5397                 else
5398                 {
5399                     MoveCursorLeft( event.ShiftDown() );
5400                 }
5401                 break;
5402
5403             case WXK_RIGHT:
5404                 if ( event.ControlDown() )
5405                 {
5406                     MoveCursorRightBlock( event.ShiftDown() );
5407                 }
5408                 else
5409                 {
5410                     MoveCursorRight( event.ShiftDown() );
5411                 }
5412                 break;
5413
5414             case WXK_RETURN:
5415                 if ( event.ControlDown() )
5416                 {
5417                     event.Skip();  // to let the edit control have the return
5418                 }
5419                 else
5420                 {
5421                     if ( GetGridCursorRow() < GetNumberRows()-1 )
5422                     {
5423                         MoveCursorDown( event.ShiftDown() );
5424                     }
5425                     else
5426                     {
5427                         // at the bottom of a column
5428                         HideCellEditControl();
5429                         SaveEditControlValue();
5430                     }
5431                 }
5432                 break;
5433
5434             case WXK_ESCAPE:
5435                 ClearSelection();
5436                 break;
5437
5438             case WXK_TAB:
5439                 if (event.ShiftDown())
5440                 {
5441                     if ( GetGridCursorCol() > 0 )
5442                     {
5443                         MoveCursorLeft( FALSE );
5444                     }
5445                     else
5446                     {
5447                         // at left of grid
5448                         HideCellEditControl();
5449                         SaveEditControlValue();
5450                     }
5451                 }
5452                 else
5453                 {
5454                     if ( GetGridCursorCol() < GetNumberCols()-1 )
5455                     {
5456                         MoveCursorRight( FALSE );
5457                     }
5458                     else
5459                     {
5460                         // at right of grid
5461                         HideCellEditControl();
5462                         SaveEditControlValue();
5463                     }
5464                 }
5465                 break;
5466
5467             case WXK_HOME:
5468                 if ( event.ControlDown() )
5469                 {
5470                     MakeCellVisible( 0, 0 );
5471                     SetCurrentCell( 0, 0 );
5472                 }
5473                 else
5474                 {
5475                     event.Skip();
5476                 }
5477                 break;
5478
5479             case WXK_END:
5480                 if ( event.ControlDown() )
5481                 {
5482                     MakeCellVisible( m_numRows-1, m_numCols-1 );
5483                     SetCurrentCell( m_numRows-1, m_numCols-1 );
5484                 }
5485                 else
5486                 {
5487                     event.Skip();
5488                 }
5489                 break;
5490
5491             case WXK_PRIOR:
5492                 MovePageUp();
5493                 break;
5494
5495             case WXK_NEXT:
5496                 MovePageDown();
5497                 break;
5498
5499             case WXK_SPACE:
5500                 if ( event.ControlDown() )
5501                 {
5502                     m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
5503                                                       m_currentCellCoords.GetCol(),
5504                                                       event.ControlDown(),
5505                                                       event.ShiftDown(),
5506                                                       event.AltDown(),
5507                                                       event.MetaDown() );
5508                     break;
5509                 }
5510                 if ( !IsEditable() )
5511                 {
5512                     MoveCursorRight( FALSE );
5513                     break;
5514                 }
5515                 // Otherwise fall through to default
5516
5517             default:
5518                 // is it possible to edit the current cell at all?
5519                 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5520                 {
5521                     // yes, now check whether the cells editor accepts the key
5522                     int row = m_currentCellCoords.GetRow();
5523                     int col = m_currentCellCoords.GetCol();
5524                     wxGridCellAttr* attr = GetCellAttr(row, col);
5525                     wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5526
5527                     // <F2> is special and will always start editing, for
5528                     // other keys - ask the editor itself
5529                     if ( (event.KeyCode() == WXK_F2 && !event.HasModifiers())
5530                          || editor->IsAcceptedKey(event) )
5531                     {
5532                         EnableCellEditControl();
5533                         editor->StartingKey(event);
5534                     }
5535                     else
5536                     {
5537                         event.Skip();
5538                     }
5539
5540                     editor->DecRef();
5541                     attr->DecRef();
5542                 }
5543                 else
5544                 {
5545                     // let others process char events with modifiers or all
5546                     // char events for readonly cells
5547                     event.Skip();
5548                 }
5549                 break;
5550         }
5551     }
5552
5553     m_inOnKeyDown = FALSE;
5554 }
5555
5556 void wxGrid::OnKeyUp( wxKeyEvent& event )
5557 {
5558     // try local handlers
5559     //
5560     if ( event.KeyCode() == WXK_SHIFT )
5561     {
5562         if ( m_selectingTopLeft != wxGridNoCellCoords &&
5563              m_selectingBottomRight != wxGridNoCellCoords )
5564             m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5565                                       m_selectingTopLeft.GetCol(),
5566                                       m_selectingBottomRight.GetRow(),
5567                                       m_selectingBottomRight.GetCol(),
5568                                       event.ControlDown(),
5569                                       TRUE,
5570                                       event.AltDown(),
5571                                       event.MetaDown() );
5572         m_selectingTopLeft = wxGridNoCellCoords;
5573         m_selectingBottomRight = wxGridNoCellCoords;
5574         m_selectingKeyboard = wxGridNoCellCoords;
5575     }
5576 }
5577
5578 void wxGrid::OnEraseBackground(wxEraseEvent&)
5579 {
5580 }
5581
5582 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
5583 {
5584     if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
5585     {
5586         // the event has been intercepted - do nothing
5587         return;
5588     }
5589
5590     wxClientDC dc(m_gridWin);
5591     PrepareDC(dc);
5592
5593     if ( m_currentCellCoords != wxGridNoCellCoords )
5594     {
5595         HideCellEditControl();
5596         DisableCellEditControl();
5597
5598         if ( IsVisible( m_currentCellCoords, FALSE ) )  // zzz
5599         {
5600             wxRect r;
5601             r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
5602             if ( !m_gridLinesEnabled )
5603             {
5604                 r.x--;
5605                 r.y--;
5606                 r.width++;
5607                 r.height++;
5608             }
5609
5610             CalcCellsExposed( r );
5611
5612             // Otherwise refresh redraws the highlight!
5613             m_currentCellCoords = coords;
5614
5615             DrawGridCellArea(dc);
5616             DrawAllGridLines( dc, r );
5617         }
5618     }
5619
5620     m_currentCellCoords = coords;
5621
5622     wxGridCellAttr* attr = GetCellAttr(coords);
5623     DrawCellHighlight(dc, attr);
5624     attr->DecRef();
5625 }
5626
5627
5628 //
5629 // ------ functions to get/send data (see also public functions)
5630 //
5631
5632 bool wxGrid::GetModelValues()
5633 {
5634     if ( m_table )
5635     {
5636         // all we need to do is repaint the grid
5637         //
5638         m_gridWin->Refresh();
5639         return TRUE;
5640     }
5641
5642     return FALSE;
5643 }
5644
5645
5646 bool wxGrid::SetModelValues()
5647 {
5648     int row, col;
5649
5650     if ( m_table )
5651     {
5652         for ( row = 0;  row < m_numRows;  row++ )
5653         {
5654             for ( col = 0;  col < m_numCols;  col++ )
5655             {
5656                 m_table->SetValue( row, col, GetCellValue(row, col) );
5657             }
5658         }
5659
5660         return TRUE;
5661     }
5662
5663     return FALSE;
5664 }
5665
5666
5667
5668 // Note - this function only draws cells that are in the list of
5669 // exposed cells (usually set from the update region by
5670 // CalcExposedCells)
5671 //
5672 void wxGrid::DrawGridCellArea( wxDC& dc )
5673 {
5674     if ( !m_numRows || !m_numCols ) return;
5675
5676     size_t i;
5677     size_t numCells = m_cellsExposed.GetCount();
5678
5679     for ( i = 0;  i < numCells;  i++ )
5680     {
5681         DrawCell( dc, m_cellsExposed[i] );
5682     }
5683 }
5684
5685
5686 void wxGrid::DrawGridSpace( wxDC& dc )
5687 {
5688   int cw, ch;
5689   m_gridWin->GetClientSize( &cw, &ch );
5690
5691   int right, bottom;
5692   CalcUnscrolledPosition( cw, ch, &right, &bottom );
5693
5694   int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
5695   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
5696
5697   if ( right > rightCol || bottom > bottomRow )
5698   {
5699       int left, top;
5700       CalcUnscrolledPosition( 0, 0, &left, &top );
5701
5702       dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
5703       dc.SetPen( *wxTRANSPARENT_PEN );
5704
5705       if ( right > rightCol )
5706       {
5707           dc.DrawRectangle( rightCol, top, right - rightCol, ch);
5708       }
5709
5710       if ( bottom > bottomRow )
5711       {
5712           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
5713       }
5714   }
5715 }
5716
5717
5718 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
5719 {
5720     int row = coords.GetRow();
5721     int col = coords.GetCol();
5722
5723     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5724         return;
5725
5726     // we draw the cell border ourselves
5727 #if !WXGRID_DRAW_LINES
5728     if ( m_gridLinesEnabled )
5729         DrawCellBorder( dc, coords );
5730 #endif
5731
5732     wxGridCellAttr* attr = GetCellAttr(row, col);
5733
5734     bool isCurrent = coords == m_currentCellCoords;
5735
5736     wxRect rect = CellToRect( row, col );
5737
5738     // if the editor is shown, we should use it and not the renderer
5739     // Note: However, only if it is really _shown_, i.e. not hidden!
5740     if ( isCurrent && IsCellEditControlShown() )
5741     {
5742         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5743         editor->PaintBackground(rect, attr);
5744         editor->DecRef();
5745     }
5746     else
5747     {
5748         // but all the rest is drawn by the cell renderer and hence may be
5749         // customized
5750         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
5751         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
5752         renderer->DecRef();
5753     }
5754
5755     attr->DecRef();
5756 }
5757
5758 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
5759 {
5760     int row = m_currentCellCoords.GetRow();
5761     int col = m_currentCellCoords.GetCol();
5762
5763     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5764         return;
5765
5766     wxRect rect = CellToRect(row, col);
5767
5768     // hmmm... what could we do here to show that the cell is disabled?
5769     // for now, I just draw a thinner border than for the other ones, but
5770     // it doesn't look really good
5771     dc.SetPen(wxPen(m_cellHighlightColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
5772     dc.SetBrush(*wxTRANSPARENT_BRUSH);
5773
5774     dc.DrawRectangle(rect);
5775
5776 #if 0
5777         // VZ: my experiments with 3d borders...
5778
5779         // how to properly set colours for arbitrary bg?
5780         wxCoord x1 = rect.x,
5781                 y1 = rect.y,
5782                 x2 = rect.x + rect.width -1,
5783                 y2 = rect.y + rect.height -1;
5784
5785         dc.SetPen(*wxWHITE_PEN);
5786         dc.DrawLine(x1, y1, x2, y1);
5787         dc.DrawLine(x1, y1, x1, y2);
5788
5789         dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
5790         dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
5791
5792         dc.SetPen(*wxBLACK_PEN);
5793         dc.DrawLine(x1, y2, x2, y2);
5794         dc.DrawLine(x2, y1, x2, y2+1);
5795 #endif // 0
5796 }
5797
5798
5799 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
5800 {
5801     int row = coords.GetRow();
5802     int col = coords.GetCol();
5803     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5804         return;
5805
5806     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
5807
5808     // right hand border
5809     //
5810     dc.DrawLine( GetColRight(col), GetRowTop(row),
5811                  GetColRight(col), GetRowBottom(row) );
5812
5813     // bottom border
5814     //
5815     dc.DrawLine( GetColLeft(col), GetRowBottom(row),
5816                  GetColRight(col), GetRowBottom(row) );
5817 }
5818
5819 void wxGrid::DrawHighlight(wxDC& dc)
5820 {
5821     // This if block was previously in wxGrid::OnPaint but that doesn't
5822     // seem to get called under wxGTK - MB
5823     //
5824     if ( m_currentCellCoords == wxGridNoCellCoords  &&
5825          m_numRows && m_numCols )
5826     {
5827         m_currentCellCoords.Set(0, 0);
5828     }
5829
5830     if ( IsCellEditControlShown() )
5831     {
5832         // don't show highlight when the edit control is shown
5833         return;
5834     }
5835
5836     // if the active cell was repainted, repaint its highlight too because it
5837     // might have been damaged by the grid lines
5838     size_t count = m_cellsExposed.GetCount();
5839     for ( size_t n = 0; n < count; n++ )
5840     {
5841         if ( m_cellsExposed[n] == m_currentCellCoords )
5842         {
5843             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5844             DrawCellHighlight(dc, attr);
5845             attr->DecRef();
5846
5847             break;
5848         }
5849     }
5850 }
5851
5852 // TODO: remove this ???
5853 // This is used to redraw all grid lines e.g. when the grid line colour
5854 // has been changed
5855 //
5856 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
5857 {
5858     if ( !m_gridLinesEnabled ||
5859          !m_numRows ||
5860          !m_numCols ) return;
5861
5862     int top, bottom, left, right;
5863
5864 #if 0  //#ifndef __WXGTK__
5865     if (reg.IsEmpty())
5866     {
5867       int cw, ch;
5868       m_gridWin->GetClientSize(&cw, &ch);
5869
5870       // virtual coords of visible area
5871       //
5872       CalcUnscrolledPosition( 0, 0, &left, &top );
5873       CalcUnscrolledPosition( cw, ch, &right, &bottom );
5874     }
5875     else
5876     {
5877       wxCoord x, y, w, h;
5878       reg.GetBox(x, y, w, h);
5879       CalcUnscrolledPosition( x, y, &left, &top );
5880       CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
5881     }
5882 #else
5883       int cw, ch;
5884       m_gridWin->GetClientSize(&cw, &ch);
5885       CalcUnscrolledPosition( 0, 0, &left, &top );
5886       CalcUnscrolledPosition( cw, ch, &right, &bottom );
5887 #endif
5888
5889     // avoid drawing grid lines past the last row and col
5890     //
5891     right = wxMin( right, GetColRight(m_numCols - 1) );
5892     bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
5893
5894     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
5895
5896     // horizontal grid lines
5897     //
5898     int i;
5899     for ( i = 0; i < m_numRows; i++ )
5900     {
5901         int bot = GetRowBottom(i) - 1;
5902
5903         if ( bot > bottom )
5904         {
5905             break;
5906         }
5907
5908         if ( bot >= top )
5909         {
5910             dc.DrawLine( left, bot, right, bot );
5911         }
5912     }
5913
5914
5915     // vertical grid lines
5916     //
5917     for ( i = 0; i < m_numCols; i++ )
5918     {
5919         int colRight = GetColRight(i) - 1;
5920         if ( colRight > right )
5921         {
5922             break;
5923         }
5924
5925         if ( colRight >= left )
5926         {
5927             dc.DrawLine( colRight, top, colRight, bottom );
5928         }
5929     }
5930 }
5931
5932
5933 void wxGrid::DrawRowLabels( wxDC& dc )
5934 {
5935     if ( !m_numRows ) return;
5936
5937     size_t i;
5938     size_t numLabels = m_rowLabelsExposed.GetCount();
5939
5940     for ( i = 0;  i < numLabels;  i++ )
5941     {
5942         DrawRowLabel( dc, m_rowLabelsExposed[i] );
5943     }
5944 }
5945
5946
5947 void wxGrid::DrawRowLabel( wxDC& dc, int row )
5948 {
5949     if ( GetRowHeight(row) <= 0 )
5950         return;
5951
5952     int rowTop = GetRowTop(row),
5953         rowBottom = GetRowBottom(row) - 1;
5954
5955     dc.SetPen( *wxBLACK_PEN );
5956     dc.DrawLine( m_rowLabelWidth-1, rowTop,
5957                  m_rowLabelWidth-1, rowBottom );
5958
5959     dc.DrawLine( 0, rowBottom, m_rowLabelWidth-1, rowBottom );
5960
5961     dc.SetPen( *wxWHITE_PEN );
5962     dc.DrawLine( 0, rowTop, 0, rowBottom );
5963     dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );
5964
5965     dc.SetBackgroundMode( wxTRANSPARENT );
5966     dc.SetTextForeground( GetLabelTextColour() );
5967     dc.SetFont( GetLabelFont() );
5968
5969     int hAlign, vAlign;
5970     GetRowLabelAlignment( &hAlign, &vAlign );
5971
5972     wxRect rect;
5973     rect.SetX( 2 );
5974     rect.SetY( GetRowTop(row) + 2 );
5975     rect.SetWidth( m_rowLabelWidth - 4 );
5976     rect.SetHeight( GetRowHeight(row) - 4 );
5977     DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
5978 }
5979
5980
5981 void wxGrid::DrawColLabels( wxDC& dc )
5982 {
5983     if ( !m_numCols ) return;
5984
5985     size_t i;
5986     size_t numLabels = m_colLabelsExposed.GetCount();
5987
5988     for ( i = 0;  i < numLabels;  i++ )
5989     {
5990         DrawColLabel( dc, m_colLabelsExposed[i] );
5991     }
5992 }
5993
5994
5995 void wxGrid::DrawColLabel( wxDC& dc, int col )
5996 {
5997     if ( GetColWidth(col) <= 0 )
5998         return;
5999
6000     int colLeft = GetColLeft(col),
6001         colRight = GetColRight(col) - 1;
6002
6003     dc.SetPen( *wxBLACK_PEN );
6004     dc.DrawLine( colRight, 0,
6005                  colRight, m_colLabelHeight-1 );
6006
6007     dc.DrawLine( colLeft, m_colLabelHeight-1,
6008                  colRight, m_colLabelHeight-1 );
6009
6010     dc.SetPen( *wxWHITE_PEN );
6011     dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
6012     dc.DrawLine( colLeft, 0, colRight, 0 );
6013
6014     dc.SetBackgroundMode( wxTRANSPARENT );
6015     dc.SetTextForeground( GetLabelTextColour() );
6016     dc.SetFont( GetLabelFont() );
6017
6018     dc.SetBackgroundMode( wxTRANSPARENT );
6019     dc.SetTextForeground( GetLabelTextColour() );
6020     dc.SetFont( GetLabelFont() );
6021
6022     int hAlign, vAlign;
6023     GetColLabelAlignment( &hAlign, &vAlign );
6024
6025     wxRect rect;
6026     rect.SetX( colLeft + 2 );
6027     rect.SetY( 2 );
6028     rect.SetWidth( GetColWidth(col) - 4 );
6029     rect.SetHeight( m_colLabelHeight - 4 );
6030     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
6031 }
6032
6033
6034 void wxGrid::DrawTextRectangle( wxDC& dc,
6035                                 const wxString& value,
6036                                 const wxRect& rect,
6037                                 int horizAlign,
6038                                 int vertAlign )
6039 {
6040     long textWidth, textHeight;
6041     long lineWidth, lineHeight;
6042     wxArrayString lines;
6043
6044     dc.SetClippingRegion( rect );
6045     StringToLines( value, lines );
6046     if ( lines.GetCount() )
6047     {
6048         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
6049         dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
6050
6051         float x, y;
6052         switch ( horizAlign )
6053         {
6054             case wxALIGN_RIGHT:
6055                 x = rect.x + (rect.width - textWidth - 1);
6056                 break;
6057
6058             case wxALIGN_CENTRE:
6059                 x = rect.x + ((rect.width - textWidth)/2);
6060                 break;
6061
6062             case wxALIGN_LEFT:
6063             default:
6064                 x = rect.x + 1;
6065                 break;
6066         }
6067
6068         switch ( vertAlign )
6069         {
6070             case wxALIGN_BOTTOM:
6071                 y = rect.y + (rect.height - textHeight - 1);
6072                 break;
6073
6074             case wxALIGN_CENTRE:
6075                 y = rect.y + ((rect.height - textHeight)/2);
6076                 break;
6077
6078             case wxALIGN_TOP:
6079             default:
6080                 y = rect.y + 1;
6081                 break;
6082         }
6083
6084         for ( size_t i = 0;  i < lines.GetCount();  i++ )
6085         {
6086             dc.DrawText( lines[i], (int)x, (int)y );
6087             y += lineHeight;
6088         }
6089     }
6090
6091     dc.DestroyClippingRegion();
6092 }
6093
6094
6095 // Split multi line text up into an array of strings.  Any existing
6096 // contents of the string array are preserved.
6097 //
6098 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
6099 {
6100     int startPos = 0;
6101     int pos;
6102     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
6103     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
6104
6105     while ( startPos < (int)tVal.Length() )
6106     {
6107         pos = tVal.Mid(startPos).Find( eol );
6108         if ( pos < 0 )
6109         {
6110             break;
6111         }
6112         else if ( pos == 0 )
6113         {
6114             lines.Add( wxEmptyString );
6115         }
6116         else
6117         {
6118             lines.Add( value.Mid(startPos, pos) );
6119         }
6120         startPos += pos+1;
6121     }
6122     if ( startPos < (int)value.Length() )
6123     {
6124         lines.Add( value.Mid( startPos ) );
6125     }
6126 }
6127
6128
6129 void wxGrid::GetTextBoxSize( wxDC& dc,
6130                              wxArrayString& lines,
6131                              long *width, long *height )
6132 {
6133     long w = 0;
6134     long h = 0;
6135     long lineW, lineH;
6136
6137     size_t i;
6138     for ( i = 0;  i < lines.GetCount();  i++ )
6139     {
6140         dc.GetTextExtent( lines[i], &lineW, &lineH );
6141         w = wxMax( w, lineW );
6142         h += lineH;
6143     }
6144
6145     *width = w;
6146     *height = h;
6147 }
6148
6149 //
6150 // ------ Batch processing.
6151 //
6152 void wxGrid::EndBatch()
6153 {
6154     if ( m_batchCount > 0 )
6155     {
6156         m_batchCount--;
6157         if ( !m_batchCount )
6158         {
6159             CalcDimensions();
6160             m_rowLabelWin->Refresh();
6161             m_colLabelWin->Refresh();
6162             m_cornerLabelWin->Refresh();
6163             m_gridWin->Refresh();
6164         }
6165     }
6166 }
6167
6168 // Use this, rather than wxWindow::Refresh(), to force an immediate
6169 // repainting of the grid. Has no effect if you are already inside a
6170 // BeginBatch / EndBatch block.
6171 //
6172 void wxGrid::ForceRefresh()
6173 {
6174     BeginBatch();
6175     EndBatch();
6176 }
6177
6178
6179 //
6180 // ------ Edit control functions
6181 //
6182
6183
6184 void wxGrid::EnableEditing( bool edit )
6185 {
6186     // TODO: improve this ?
6187     //
6188     if ( edit != m_editable )
6189     {
6190         if(!edit) EnableCellEditControl(edit);
6191         m_editable = edit;
6192     }
6193 }
6194
6195
6196 void wxGrid::EnableCellEditControl( bool enable )
6197 {
6198     if (! m_editable)
6199         return;
6200
6201     if ( m_currentCellCoords == wxGridNoCellCoords )
6202         SetCurrentCell( 0, 0 );
6203
6204     if ( enable != m_cellEditCtrlEnabled )
6205     {
6206         // TODO allow the app to Veto() this event?
6207         SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
6208
6209         if ( enable )
6210         {
6211             // this should be checked by the caller!
6212             wxASSERT_MSG( CanEnableCellControl(),
6213                           _T("can't enable editing for this cell!") );
6214
6215             // do it before ShowCellEditControl()
6216             m_cellEditCtrlEnabled = enable;
6217
6218             ShowCellEditControl();
6219         }
6220         else
6221         {
6222             HideCellEditControl();
6223             SaveEditControlValue();
6224
6225             // do it after HideCellEditControl()
6226             m_cellEditCtrlEnabled = enable;
6227         }
6228     }
6229 }
6230
6231 bool wxGrid::IsCurrentCellReadOnly() const
6232 {
6233     // const_cast
6234     wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
6235     bool readonly = attr->IsReadOnly();
6236     attr->DecRef();
6237
6238     return readonly;
6239 }
6240
6241 bool wxGrid::CanEnableCellControl() const
6242 {
6243     return m_editable && !IsCurrentCellReadOnly();
6244 }
6245
6246 bool wxGrid::IsCellEditControlEnabled() const
6247 {
6248     // the cell edit control might be disable for all cells or just for the
6249     // current one if it's read only
6250     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
6251 }
6252
6253 bool wxGrid::IsCellEditControlShown() const
6254 {
6255     bool isShown = FALSE;
6256
6257     if ( m_cellEditCtrlEnabled )
6258     {
6259         int row = m_currentCellCoords.GetRow();
6260         int col = m_currentCellCoords.GetCol();
6261         wxGridCellAttr* attr = GetCellAttr(row, col);
6262         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
6263         attr->DecRef();
6264
6265         if ( editor )
6266         {
6267             if ( editor->IsCreated() )
6268             {
6269                 isShown = editor->GetControl()->IsShown();
6270             }
6271
6272             editor->DecRef();
6273         }
6274     }
6275
6276     return isShown;
6277 }
6278
6279 void wxGrid::ShowCellEditControl()
6280 {
6281     if ( IsCellEditControlEnabled() )
6282     {
6283         if ( !IsVisible( m_currentCellCoords ) )
6284         {
6285             m_cellEditCtrlEnabled = false;
6286             return;
6287         }
6288         else
6289         {
6290             wxRect rect = CellToRect( m_currentCellCoords );
6291             int row = m_currentCellCoords.GetRow();
6292             int col = m_currentCellCoords.GetCol();
6293
6294             // convert to scrolled coords
6295             //
6296             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6297
6298             // done in PaintBackground()
6299 #if 0
6300             // erase the highlight and the cell contents because the editor
6301             // might not cover the entire cell
6302             wxClientDC dc( m_gridWin );
6303             PrepareDC( dc );
6304             dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
6305             dc.SetPen(*wxTRANSPARENT_PEN);
6306             dc.DrawRectangle(rect);
6307 #endif // 0
6308
6309             // cell is shifted by one pixel
6310             rect.x--;
6311             rect.y--;
6312
6313             wxGridCellAttr* attr = GetCellAttr(row, col);
6314             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6315             if ( !editor->IsCreated() )
6316             {
6317                 editor->Create(m_gridWin, -1,
6318                                new wxGridCellEditorEvtHandler(this, editor));
6319             }
6320
6321             editor->Show( TRUE, attr );
6322
6323             editor->SetSize( rect );
6324
6325             editor->BeginEdit(row, col, this);
6326
6327             editor->DecRef();
6328             attr->DecRef();
6329          }
6330     }
6331 }
6332
6333
6334 void wxGrid::HideCellEditControl()
6335 {
6336     if ( IsCellEditControlEnabled() )
6337     {
6338         int row = m_currentCellCoords.GetRow();
6339         int col = m_currentCellCoords.GetCol();
6340
6341         wxGridCellAttr* attr = GetCellAttr(row, col);
6342         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6343         editor->Show( FALSE );
6344         editor->DecRef();
6345         attr->DecRef();
6346         m_gridWin->SetFocus();
6347         wxRect rect( CellToRect( row, col ) );
6348         m_gridWin->Refresh( FALSE, &rect );
6349     }
6350 }
6351
6352
6353 void wxGrid::SaveEditControlValue()
6354 {
6355     if ( IsCellEditControlEnabled() )
6356     {
6357         int row = m_currentCellCoords.GetRow();
6358         int col = m_currentCellCoords.GetCol();
6359
6360         wxGridCellAttr* attr = GetCellAttr(row, col);
6361         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6362         bool changed = editor->EndEdit(row, col, this);
6363
6364         editor->DecRef();
6365         attr->DecRef();
6366
6367         if (changed)
6368         {
6369             SendEvent( wxEVT_GRID_CELL_CHANGE,
6370                        m_currentCellCoords.GetRow(),
6371                        m_currentCellCoords.GetCol() );
6372         }
6373     }
6374 }
6375
6376
6377 //
6378 // ------ Grid location functions
6379 //  Note that all of these functions work with the logical coordinates of
6380 //  grid cells and labels so you will need to convert from device
6381 //  coordinates for mouse events etc.
6382 //
6383
6384 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
6385 {
6386     int row = YToRow(y);
6387     int col = XToCol(x);
6388
6389     if ( row == -1  ||  col == -1 )
6390     {
6391         coords = wxGridNoCellCoords;
6392     }
6393     else
6394     {
6395         coords.Set( row, col );
6396     }
6397 }
6398
6399
6400 int wxGrid::YToRow( int y )
6401 {
6402     int i;
6403
6404     for ( i = 0;  i < m_numRows;  i++ )
6405     {
6406         if ( y < GetRowBottom(i) )
6407             return i;
6408     }
6409
6410     return -1;
6411 }
6412
6413
6414 int wxGrid::XToCol( int x )
6415 {
6416     int i;
6417
6418     for ( i = 0;  i < m_numCols;  i++ )
6419     {
6420         if ( x < GetColRight(i) )
6421             return i;
6422     }
6423
6424     return -1;
6425 }
6426
6427
6428 // return the row number that that the y coord is near the edge of, or
6429 // -1 if not near an edge
6430 //
6431 int wxGrid::YToEdgeOfRow( int y )
6432 {
6433     int i, d;
6434
6435     for ( i = 0;  i < m_numRows;  i++ )
6436     {
6437         if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
6438         {
6439             d = abs( y - GetRowBottom(i) );
6440             if ( d < WXGRID_LABEL_EDGE_ZONE )
6441                 return i;
6442         }
6443     }
6444
6445     return -1;
6446 }
6447
6448
6449 // return the col number that that the x coord is near the edge of, or
6450 // -1 if not near an edge
6451 //
6452 int wxGrid::XToEdgeOfCol( int x )
6453 {
6454     int i, d;
6455
6456     for ( i = 0;  i < m_numCols;  i++ )
6457     {
6458         if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
6459         {
6460             d = abs( x - GetColRight(i) );
6461             if ( d < WXGRID_LABEL_EDGE_ZONE )
6462                 return i;
6463         }
6464     }
6465
6466     return -1;
6467 }
6468
6469
6470 wxRect wxGrid::CellToRect( int row, int col )
6471 {
6472     wxRect rect( -1, -1, -1, -1 );
6473
6474     if ( row >= 0  &&  row < m_numRows  &&
6475          col >= 0  &&  col < m_numCols )
6476     {
6477         rect.x = GetColLeft(col);
6478         rect.y = GetRowTop(row);
6479         rect.width = GetColWidth(col);
6480         rect.height = GetRowHeight(row);
6481     }
6482
6483     // if grid lines are enabled, then the area of the cell is a bit smaller
6484     if (m_gridLinesEnabled) {
6485         rect.width -= 1;
6486         rect.height -= 1;
6487     }
6488     return rect;
6489 }
6490
6491
6492 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
6493 {
6494     // get the cell rectangle in logical coords
6495     //
6496     wxRect r( CellToRect( row, col ) );
6497
6498     // convert to device coords
6499     //
6500     int left, top, right, bottom;
6501     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6502     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6503
6504     // check against the client area of the grid window
6505     //
6506     int cw, ch;
6507     m_gridWin->GetClientSize( &cw, &ch );
6508
6509     if ( wholeCellVisible )
6510     {
6511         // is the cell wholly visible ?
6512         //
6513         return ( left >= 0  &&  right <= cw  &&
6514                  top >= 0  &&  bottom <= ch );
6515     }
6516     else
6517     {
6518         // is the cell partly visible ?
6519         //
6520         return ( ((left >=0 && left < cw) || (right > 0 && right <= cw))  &&
6521                  ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6522     }
6523 }
6524
6525
6526 // make the specified cell location visible by doing a minimal amount
6527 // of scrolling
6528 //
6529 void wxGrid::MakeCellVisible( int row, int col )
6530 {
6531     int i;
6532     int xpos = -1, ypos = -1;
6533
6534     if ( row >= 0  &&  row < m_numRows  &&
6535          col >= 0  &&  col < m_numCols )
6536     {
6537         // get the cell rectangle in logical coords
6538         //
6539         wxRect r( CellToRect( row, col ) );
6540
6541         // convert to device coords
6542         //
6543         int left, top, right, bottom;
6544         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6545         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6546
6547         int cw, ch;
6548         m_gridWin->GetClientSize( &cw, &ch );
6549
6550         if ( top < 0 )
6551         {
6552             ypos = r.GetTop();
6553         }
6554         else if ( bottom > ch )
6555         {
6556             int h = r.GetHeight();
6557             ypos = r.GetTop();
6558             for ( i = row-1;  i >= 0;  i-- )
6559             {
6560                 int rowHeight = GetRowHeight(i);
6561                 if ( h + rowHeight > ch )
6562                     break;
6563
6564                 h += rowHeight;
6565                 ypos -= rowHeight;
6566             }
6567
6568             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6569             // have rounding errors (this is important, because if we do, we
6570             // might not scroll at all and some cells won't be redrawn)
6571             ypos += GRID_SCROLL_LINE / 2;
6572         }
6573
6574         if ( left < 0 )
6575         {
6576             xpos = r.GetLeft();
6577         }
6578         else if ( right > cw )
6579         {
6580             int w = r.GetWidth();
6581             xpos = r.GetLeft();
6582             for ( i = col-1;  i >= 0;  i-- )
6583             {
6584                 int colWidth = GetColWidth(i);
6585                 if ( w + colWidth > cw )
6586                     break;
6587
6588                 w += colWidth;
6589                 xpos -= colWidth;
6590             }
6591
6592             // see comment for ypos above
6593             xpos += GRID_SCROLL_LINE / 2;
6594         }
6595
6596         if ( xpos != -1  ||  ypos != -1 )
6597         {
6598             if ( xpos != -1 ) xpos /= GRID_SCROLL_LINE;
6599             if ( ypos != -1 ) ypos /= GRID_SCROLL_LINE;
6600             Scroll( xpos, ypos );
6601             AdjustScrollbars();
6602         }
6603     }
6604 }
6605
6606
6607 //
6608 // ------ Grid cursor movement functions
6609 //
6610
6611 bool wxGrid::MoveCursorUp( bool expandSelection )
6612 {
6613     if ( m_currentCellCoords != wxGridNoCellCoords  &&
6614          m_currentCellCoords.GetRow() >= 0 )
6615     {
6616         if ( expandSelection)
6617         {
6618             if ( m_selectingKeyboard == wxGridNoCellCoords )
6619                 m_selectingKeyboard = m_currentCellCoords;
6620             if ( m_selectingKeyboard.GetRow() > 0 )
6621             {
6622                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
6623                 MakeCellVisible( m_selectingKeyboard.GetRow(),
6624                                  m_selectingKeyboard.GetCol() );
6625                 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6626             }
6627         }
6628         else if ( m_currentCellCoords.GetRow() > 0 )
6629         {
6630             ClearSelection();
6631             MakeCellVisible( m_currentCellCoords.GetRow() - 1,
6632                              m_currentCellCoords.GetCol() );
6633             SetCurrentCell( m_currentCellCoords.GetRow() - 1,
6634                             m_currentCellCoords.GetCol() );
6635         }
6636         else
6637             return FALSE;
6638         return TRUE;
6639     }
6640
6641     return FALSE;
6642 }
6643
6644
6645 bool wxGrid::MoveCursorDown( bool expandSelection )
6646 {
6647     if ( m_currentCellCoords != wxGridNoCellCoords  &&
6648          m_currentCellCoords.GetRow() < m_numRows )
6649     {
6650         if ( expandSelection )
6651         {
6652             if ( m_selectingKeyboard == wxGridNoCellCoords )
6653                 m_selectingKeyboard = m_currentCellCoords;
6654             if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
6655             {
6656                 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
6657                 MakeCellVisible( m_selectingKeyboard.GetRow(),
6658                         m_selectingKeyboard.GetCol() );
6659                 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6660             }
6661         }
6662         else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
6663         {
6664             ClearSelection();
6665             MakeCellVisible( m_currentCellCoords.GetRow() + 1,
6666                              m_currentCellCoords.GetCol() );
6667             SetCurrentCell( m_currentCellCoords.GetRow() + 1,
6668                             m_currentCellCoords.GetCol() );
6669         }
6670         else
6671             return FALSE;
6672         return TRUE;
6673     }
6674
6675     return FALSE;
6676 }
6677
6678
6679 bool wxGrid::MoveCursorLeft( bool expandSelection )
6680 {
6681     if ( m_currentCellCoords != wxGridNoCellCoords  &&
6682          m_currentCellCoords.GetCol() >= 0 )
6683     {
6684         if ( expandSelection )
6685         {
6686             if ( m_selectingKeyboard == wxGridNoCellCoords )
6687                 m_selectingKeyboard = m_currentCellCoords;
6688             if ( m_selectingKeyboard.GetCol() > 0 )
6689             {
6690                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
6691                 MakeCellVisible( m_selectingKeyboard.GetRow(),
6692                         m_selectingKeyboard.GetCol() );
6693                 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6694             }
6695         }
6696         else if ( m_currentCellCoords.GetCol() > 0 )
6697         {
6698             ClearSelection();
6699             MakeCellVisible( m_currentCellCoords.GetRow(),
6700                              m_currentCellCoords.GetCol() - 1 );
6701             SetCurrentCell( m_currentCellCoords.GetRow(),
6702                             m_currentCellCoords.GetCol() - 1 );
6703         }
6704         else
6705             return FALSE;
6706         return TRUE;
6707     }
6708
6709     return FALSE;
6710 }
6711
6712
6713 bool wxGrid::MoveCursorRight( bool expandSelection )
6714 {
6715     if ( m_currentCellCoords != wxGridNoCellCoords  &&
6716          m_currentCellCoords.GetCol() < m_numCols )
6717     {
6718         if ( expandSelection )
6719         {
6720             if ( m_selectingKeyboard == wxGridNoCellCoords )
6721                 m_selectingKeyboard = m_currentCellCoords;
6722             if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
6723             {
6724                 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
6725                 MakeCellVisible( m_selectingKeyboard.GetRow(),
6726                         m_selectingKeyboard.GetCol() );
6727                 SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6728             }
6729         }
6730         else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
6731         {
6732             ClearSelection();
6733             MakeCellVisible( m_currentCellCoords.GetRow(),
6734                              m_currentCellCoords.GetCol() + 1 );
6735             SetCurrentCell( m_currentCellCoords.GetRow(),
6736                             m_currentCellCoords.GetCol() + 1 );
6737         }
6738         else
6739             return FALSE;
6740         return TRUE;
6741     }
6742
6743     return FALSE;
6744 }
6745
6746
6747 bool wxGrid::MovePageUp()
6748 {
6749     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
6750
6751     int row = m_currentCellCoords.GetRow();
6752     if ( row > 0 )
6753     {
6754         int cw, ch;
6755         m_gridWin->GetClientSize( &cw, &ch );
6756
6757         int y = GetRowTop(row);
6758         int newRow = YToRow( y - ch + 1 );
6759         if ( newRow == -1 )
6760         {
6761             newRow = 0;
6762         }
6763         else if ( newRow == row )
6764         {
6765             newRow = row - 1;
6766         }
6767
6768         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
6769         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
6770
6771         return TRUE;
6772     }
6773
6774     return FALSE;
6775 }
6776
6777 bool wxGrid::MovePageDown()
6778 {
6779     if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
6780
6781     int row = m_currentCellCoords.GetRow();
6782     if ( row < m_numRows )
6783     {
6784         int cw, ch;
6785         m_gridWin->GetClientSize( &cw, &ch );
6786
6787         int y = GetRowTop(row);
6788         int newRow = YToRow( y + ch );
6789         if ( newRow == -1 )
6790         {
6791             newRow = m_numRows - 1;
6792         }
6793         else if ( newRow == row )
6794         {
6795             newRow = row + 1;
6796         }
6797
6798         MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
6799         SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
6800
6801         return TRUE;
6802     }
6803
6804     return FALSE;
6805 }
6806
6807 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
6808 {
6809     if ( m_table &&
6810          m_currentCellCoords != wxGridNoCellCoords  &&
6811          m_currentCellCoords.GetRow() > 0 )
6812     {
6813         int row = m_currentCellCoords.GetRow();
6814         int col = m_currentCellCoords.GetCol();
6815
6816         if ( m_table->IsEmptyCell(row, col) )
6817         {
6818             // starting in an empty cell: find the next block of
6819             // non-empty cells
6820             //
6821             while ( row > 0 )
6822             {
6823                 row-- ;
6824                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6825             }
6826         }
6827         else if ( m_table->IsEmptyCell(row-1, col) )
6828         {
6829             // starting at the top of a block: find the next block
6830             //
6831             row--;
6832             while ( row > 0 )
6833             {
6834                 row-- ;
6835                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6836             }
6837         }
6838         else
6839         {
6840             // starting within a block: find the top of the block
6841             //
6842             while ( row > 0 )
6843             {
6844                 row-- ;
6845                 if ( m_table->IsEmptyCell(row, col) )
6846                 {
6847                     row++ ;
6848                     break;
6849                 }
6850             }
6851         }
6852
6853         MakeCellVisible( row, col );
6854         if ( expandSelection )
6855         {
6856             m_selectingKeyboard = wxGridCellCoords( row, col );
6857             SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6858         }
6859         else
6860         {
6861             ClearSelection();
6862             SetCurrentCell( row, col );
6863         }
6864         return TRUE;
6865     }
6866
6867     return FALSE;
6868 }
6869
6870 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
6871 {
6872     if ( m_table &&
6873          m_currentCellCoords != wxGridNoCellCoords  &&
6874          m_currentCellCoords.GetRow() < m_numRows-1 )
6875     {
6876         int row = m_currentCellCoords.GetRow();
6877         int col = m_currentCellCoords.GetCol();
6878
6879         if ( m_table->IsEmptyCell(row, col) )
6880         {
6881             // starting in an empty cell: find the next block of
6882             // non-empty cells
6883             //
6884             while ( row < m_numRows-1 )
6885             {
6886                 row++ ;
6887                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6888             }
6889         }
6890         else if ( m_table->IsEmptyCell(row+1, col) )
6891         {
6892             // starting at the bottom of a block: find the next block
6893             //
6894             row++;
6895             while ( row < m_numRows-1 )
6896             {
6897                 row++ ;
6898                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6899             }
6900         }
6901         else
6902         {
6903             // starting within a block: find the bottom of the block
6904             //
6905             while ( row < m_numRows-1 )
6906             {
6907                 row++ ;
6908                 if ( m_table->IsEmptyCell(row, col) )
6909                 {
6910                     row-- ;
6911                     break;
6912                 }
6913             }
6914         }
6915
6916         MakeCellVisible( row, col );
6917         if ( expandSelection )
6918         {
6919             m_selectingKeyboard = wxGridCellCoords( row, col );
6920             SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6921         }
6922         else
6923         {
6924             ClearSelection();
6925             SetCurrentCell( row, col );
6926         }
6927
6928         return TRUE;
6929     }
6930
6931     return FALSE;
6932 }
6933
6934 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
6935 {
6936     if ( m_table &&
6937          m_currentCellCoords != wxGridNoCellCoords  &&
6938          m_currentCellCoords.GetCol() > 0 )
6939     {
6940         int row = m_currentCellCoords.GetRow();
6941         int col = m_currentCellCoords.GetCol();
6942
6943         if ( m_table->IsEmptyCell(row, col) )
6944         {
6945             // starting in an empty cell: find the next block of
6946             // non-empty cells
6947             //
6948             while ( col > 0 )
6949             {
6950                 col-- ;
6951                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6952             }
6953         }
6954         else if ( m_table->IsEmptyCell(row, col-1) )
6955         {
6956             // starting at the left of a block: find the next block
6957             //
6958             col--;
6959             while ( col > 0 )
6960             {
6961                 col-- ;
6962                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
6963             }
6964         }
6965         else
6966         {
6967             // starting within a block: find the left of the block
6968             //
6969             while ( col > 0 )
6970             {
6971                 col-- ;
6972                 if ( m_table->IsEmptyCell(row, col) )
6973                 {
6974                     col++ ;
6975                     break;
6976                 }
6977             }
6978         }
6979
6980         MakeCellVisible( row, col );
6981         if ( expandSelection )
6982         {
6983             m_selectingKeyboard = wxGridCellCoords( row, col );
6984             SelectBlock( m_currentCellCoords, m_selectingKeyboard );
6985         }
6986         else
6987         {
6988             ClearSelection();
6989             SetCurrentCell( row, col );
6990         }
6991
6992         return TRUE;
6993     }
6994
6995     return FALSE;
6996 }
6997
6998 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
6999 {
7000     if ( m_table &&
7001          m_currentCellCoords != wxGridNoCellCoords  &&
7002          m_currentCellCoords.GetCol() < m_numCols-1 )
7003     {
7004         int row = m_currentCellCoords.GetRow();
7005         int col = m_currentCellCoords.GetCol();
7006
7007         if ( m_table->IsEmptyCell(row, col) )
7008         {
7009             // starting in an empty cell: find the next block of
7010             // non-empty cells
7011             //
7012             while ( col < m_numCols-1 )
7013             {
7014                 col++ ;
7015                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7016             }
7017         }
7018         else if ( m_table->IsEmptyCell(row, col+1) )
7019         {
7020             // starting at the right of a block: find the next block
7021             //
7022             col++;
7023             while ( col < m_numCols-1 )
7024             {
7025                 col++ ;
7026                 if ( !(m_table->IsEmptyCell(row, col)) ) break;
7027             }
7028         }
7029         else
7030         {
7031             // starting within a block: find the right of the block
7032             //
7033             while ( col < m_numCols-1 )
7034             {
7035                 col++ ;
7036                 if ( m_table->IsEmptyCell(row, col) )
7037                 {
7038                     col-- ;
7039                     break;
7040                 }
7041             }
7042         }
7043
7044         MakeCellVisible( row, col );
7045         if ( expandSelection )
7046         {
7047             m_selectingKeyboard = wxGridCellCoords( row, col );
7048             SelectBlock( m_currentCellCoords, m_selectingKeyboard );
7049         }
7050         else
7051         {
7052             ClearSelection();
7053             SetCurrentCell( row, col );
7054         }
7055
7056         return TRUE;
7057     }
7058
7059     return FALSE;
7060 }
7061
7062
7063
7064 //
7065 // ------ Label values and formatting
7066 //
7067
7068 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
7069 {
7070     *horiz = m_rowLabelHorizAlign;
7071     *vert  = m_rowLabelVertAlign;
7072 }
7073
7074 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
7075 {
7076     *horiz = m_colLabelHorizAlign;
7077     *vert  = m_colLabelVertAlign;
7078 }
7079
7080 wxString wxGrid::GetRowLabelValue( int row )
7081 {
7082     if ( m_table )
7083     {
7084         return m_table->GetRowLabelValue( row );
7085     }
7086     else
7087     {
7088         wxString s;
7089         s << row;
7090         return s;
7091     }
7092 }
7093
7094 wxString wxGrid::GetColLabelValue( int col )
7095 {
7096     if ( m_table )
7097     {
7098         return m_table->GetColLabelValue( col );
7099     }
7100     else
7101     {
7102         wxString s;
7103         s << col;
7104         return s;
7105     }
7106 }
7107
7108
7109 void wxGrid::SetRowLabelSize( int width )
7110 {
7111     width = wxMax( width, 0 );
7112     if ( width != m_rowLabelWidth )
7113     {
7114         if ( width == 0 )
7115         {
7116             m_rowLabelWin->Show( FALSE );
7117             m_cornerLabelWin->Show( FALSE );
7118         }
7119         else if ( m_rowLabelWidth == 0 )
7120         {
7121             m_rowLabelWin->Show( TRUE );
7122             if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
7123         }
7124
7125         m_rowLabelWidth = width;
7126         CalcWindowSizes();
7127         Refresh( TRUE );
7128     }
7129 }
7130
7131
7132 void wxGrid::SetColLabelSize( int height )
7133 {
7134     height = wxMax( height, 0 );
7135     if ( height != m_colLabelHeight )
7136     {
7137         if ( height == 0 )
7138         {
7139             m_colLabelWin->Show( FALSE );
7140             m_cornerLabelWin->Show( FALSE );
7141         }
7142         else if ( m_colLabelHeight == 0 )
7143         {
7144             m_colLabelWin->Show( TRUE );
7145             if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
7146         }
7147
7148         m_colLabelHeight = height;
7149         CalcWindowSizes();
7150         Refresh( TRUE );
7151     }
7152 }
7153
7154
7155 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
7156 {
7157     if ( m_labelBackgroundColour != colour )
7158     {
7159         m_labelBackgroundColour = colour;
7160         m_rowLabelWin->SetBackgroundColour( colour );
7161         m_colLabelWin->SetBackgroundColour( colour );
7162         m_cornerLabelWin->SetBackgroundColour( colour );
7163
7164         if ( !GetBatchCount() )
7165         {
7166             m_rowLabelWin->Refresh();
7167             m_colLabelWin->Refresh();
7168             m_cornerLabelWin->Refresh();
7169         }
7170     }
7171 }
7172
7173 void wxGrid::SetLabelTextColour( const wxColour& colour )
7174 {
7175     if ( m_labelTextColour != colour )
7176     {
7177         m_labelTextColour = colour;
7178         if ( !GetBatchCount() )
7179         {
7180             m_rowLabelWin->Refresh();
7181             m_colLabelWin->Refresh();
7182         }
7183     }
7184 }
7185
7186 void wxGrid::SetLabelFont( const wxFont& font )
7187 {
7188     m_labelFont = font;
7189     if ( !GetBatchCount() )
7190     {
7191         m_rowLabelWin->Refresh();
7192         m_colLabelWin->Refresh();
7193     }
7194 }
7195
7196 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
7197 {
7198     // allow old (incorrect) defs to be used
7199     switch ( horiz )
7200     {
7201         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7202         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7203         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7204     }
7205
7206     switch ( vert )
7207     {
7208         case wxTOP:    vert = wxALIGN_TOP;    break;
7209         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7210         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7211     }
7212
7213     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7214     {
7215         m_rowLabelHorizAlign = horiz;
7216     }
7217
7218     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7219     {
7220         m_rowLabelVertAlign = vert;
7221     }
7222
7223     if ( !GetBatchCount() )
7224     {
7225         m_rowLabelWin->Refresh();
7226     }
7227 }
7228
7229 void wxGrid::SetColLabelAlignment( int horiz, int vert )
7230 {
7231     // allow old (incorrect) defs to be used
7232     switch ( horiz )
7233     {
7234         case wxLEFT:   horiz = wxALIGN_LEFT; break;
7235         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
7236         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
7237     }
7238
7239     switch ( vert )
7240     {
7241         case wxTOP:    vert = wxALIGN_TOP;    break;
7242         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
7243         case wxCENTRE: vert = wxALIGN_CENTRE; break;
7244     }
7245
7246     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
7247     {
7248         m_colLabelHorizAlign = horiz;
7249     }
7250
7251     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
7252     {
7253         m_colLabelVertAlign = vert;
7254     }
7255
7256     if ( !GetBatchCount() )
7257     {
7258         m_colLabelWin->Refresh();
7259     }
7260 }
7261
7262 void wxGrid::SetRowLabelValue( int row, const wxString& s )
7263 {
7264     if ( m_table )
7265     {
7266         m_table->SetRowLabelValue( row, s );
7267         if ( !GetBatchCount() )
7268         {
7269             wxRect rect = CellToRect( row, 0);
7270             if ( rect.height > 0 )
7271             {
7272                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
7273                 rect.x = m_left;
7274                 rect.width = m_rowLabelWidth;
7275                 m_rowLabelWin->Refresh( TRUE, &rect );
7276             }
7277         }
7278     }
7279 }
7280
7281 void wxGrid::SetColLabelValue( int col, const wxString& s )
7282 {
7283     if ( m_table )
7284     {
7285         m_table->SetColLabelValue( col, s );
7286         if ( !GetBatchCount() )
7287         {
7288             wxRect rect = CellToRect( 0, col );
7289             if ( rect.width > 0 )
7290             {
7291                 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
7292                 rect.y = m_top;
7293                 rect.height = m_colLabelHeight;
7294                 m_colLabelWin->Refresh( TRUE, &rect );
7295             }
7296         }
7297     }
7298 }
7299
7300 void wxGrid::SetGridLineColour( const wxColour& colour )
7301 {
7302     if ( m_gridLineColour != colour )
7303     {
7304         m_gridLineColour = colour;
7305
7306         wxClientDC dc( m_gridWin );
7307         PrepareDC( dc );
7308         DrawAllGridLines( dc, wxRegion() );
7309     }
7310 }
7311
7312
7313 void wxGrid::SetCellHighlightColour( const wxColour& colour )
7314 {
7315     if ( m_cellHighlightColour != colour )
7316     {
7317         m_cellHighlightColour = colour;
7318
7319         wxClientDC dc( m_gridWin );
7320         PrepareDC( dc );
7321         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
7322         DrawCellHighlight(dc, attr);
7323         attr->DecRef();
7324     }
7325 }
7326
7327 void wxGrid::EnableGridLines( bool enable )
7328 {
7329     if ( enable != m_gridLinesEnabled )
7330     {
7331         m_gridLinesEnabled = enable;
7332
7333         if ( !GetBatchCount() )
7334         {
7335             if ( enable )
7336             {
7337                 wxClientDC dc( m_gridWin );
7338                 PrepareDC( dc );
7339                 DrawAllGridLines( dc, wxRegion() );
7340             }
7341             else
7342             {
7343                 m_gridWin->Refresh();
7344             }
7345         }
7346     }
7347 }
7348
7349
7350 int wxGrid::GetDefaultRowSize()
7351 {
7352     return m_defaultRowHeight;
7353 }
7354
7355 int wxGrid::GetRowSize( int row )
7356 {
7357     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
7358
7359     return GetRowHeight(row);
7360 }
7361
7362 int wxGrid::GetDefaultColSize()
7363 {
7364     return m_defaultColWidth;
7365 }
7366
7367 int wxGrid::GetColSize( int col )
7368 {
7369     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
7370
7371     return GetColWidth(col);
7372 }
7373
7374 // ============================================================================
7375 // access to the grid attributes: each of them has a default value in the grid
7376 // itself and may be overidden on a per-cell basis
7377 // ============================================================================
7378
7379 // ----------------------------------------------------------------------------
7380 // setting default attributes
7381 // ----------------------------------------------------------------------------
7382
7383 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7384 {
7385     m_defaultCellAttr->SetBackgroundColour(col);
7386 #ifdef __WXGTK__
7387     m_gridWin->SetBackgroundColour(col);
7388 #endif
7389 }
7390
7391 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7392 {
7393     m_defaultCellAttr->SetTextColour(col);
7394 }
7395
7396 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7397 {
7398     m_defaultCellAttr->SetAlignment(horiz, vert);
7399 }
7400
7401 void wxGrid::SetDefaultCellFont( const wxFont& font )
7402 {
7403     m_defaultCellAttr->SetFont(font);
7404 }
7405
7406 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7407 {
7408     m_defaultCellAttr->SetRenderer(renderer);
7409 }
7410
7411 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7412 {
7413     m_defaultCellAttr->SetEditor(editor);
7414 }
7415
7416 // ----------------------------------------------------------------------------
7417 // access to the default attrbiutes
7418 // ----------------------------------------------------------------------------
7419
7420 wxColour wxGrid::GetDefaultCellBackgroundColour()
7421 {
7422     return m_defaultCellAttr->GetBackgroundColour();
7423 }
7424
7425 wxColour wxGrid::GetDefaultCellTextColour()
7426 {
7427     return m_defaultCellAttr->GetTextColour();
7428 }
7429
7430 wxFont wxGrid::GetDefaultCellFont()
7431 {
7432     return m_defaultCellAttr->GetFont();
7433 }
7434
7435 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
7436 {
7437     m_defaultCellAttr->GetAlignment(horiz, vert);
7438 }
7439
7440 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7441 {
7442     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7443 }
7444
7445 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7446 {
7447     return m_defaultCellAttr->GetEditor(NULL,0,0);
7448 }
7449
7450 // ----------------------------------------------------------------------------
7451 // access to cell attributes
7452 // ----------------------------------------------------------------------------
7453
7454 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
7455 {
7456     wxGridCellAttr *attr = GetCellAttr(row, col);
7457     wxColour colour = attr->GetBackgroundColour();
7458     attr->DecRef();
7459     return colour;
7460 }
7461
7462 wxColour wxGrid::GetCellTextColour( int row, int col )
7463 {
7464     wxGridCellAttr *attr = GetCellAttr(row, col);
7465     wxColour colour = attr->GetTextColour();
7466     attr->DecRef();
7467     return colour;
7468 }
7469
7470 wxFont wxGrid::GetCellFont( int row, int col )
7471 {
7472     wxGridCellAttr *attr = GetCellAttr(row, col);
7473     wxFont font = attr->GetFont();
7474     attr->DecRef();
7475     return font;
7476 }
7477
7478 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
7479 {
7480     wxGridCellAttr *attr = GetCellAttr(row, col);
7481     attr->GetAlignment(horiz, vert);
7482     attr->DecRef();
7483 }
7484
7485 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
7486 {
7487     wxGridCellAttr* attr = GetCellAttr(row, col);
7488     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
7489     attr->DecRef();
7490
7491     return renderer;
7492 }
7493
7494 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
7495 {
7496     wxGridCellAttr* attr = GetCellAttr(row, col);
7497     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7498     attr->DecRef();
7499
7500     return editor;
7501 }
7502
7503 bool wxGrid::IsReadOnly(int row, int col) const
7504 {
7505     wxGridCellAttr* attr = GetCellAttr(row, col);
7506     bool isReadOnly = attr->IsReadOnly();
7507     attr->DecRef();
7508     return isReadOnly;
7509 }
7510
7511 // ----------------------------------------------------------------------------
7512 // attribute support: cache, automatic provider creation, ...
7513 // ----------------------------------------------------------------------------
7514
7515 bool wxGrid::CanHaveAttributes()
7516 {
7517     if ( !m_table )
7518     {
7519         return FALSE;
7520     }
7521
7522     return m_table->CanHaveAttributes();
7523 }
7524
7525 void wxGrid::ClearAttrCache()
7526 {
7527     if ( m_attrCache.row != -1 )
7528     {
7529         wxSafeDecRef(m_attrCache.attr);
7530         m_attrCache.row = -1;
7531     }
7532 }
7533
7534 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
7535 {
7536     wxGrid *self = (wxGrid *)this;  // const_cast
7537
7538     self->ClearAttrCache();
7539     self->m_attrCache.row = row;
7540     self->m_attrCache.col = col;
7541     self->m_attrCache.attr = attr;
7542     wxSafeIncRef(attr);
7543 }
7544
7545 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
7546 {
7547     if ( row == m_attrCache.row && col == m_attrCache.col )
7548     {
7549         *attr = m_attrCache.attr;
7550         wxSafeIncRef(m_attrCache.attr);
7551
7552 #ifdef DEBUG_ATTR_CACHE
7553         gs_nAttrCacheHits++;
7554 #endif
7555
7556         return TRUE;
7557     }
7558     else
7559     {
7560 #ifdef DEBUG_ATTR_CACHE
7561         gs_nAttrCacheMisses++;
7562 #endif
7563         return FALSE;
7564     }
7565 }
7566
7567 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
7568 {
7569     wxGridCellAttr *attr;
7570     if ( !LookupAttr(row, col, &attr) )
7571     {
7572         attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
7573         CacheAttr(row, col, attr);
7574     }
7575     if (attr)
7576     {
7577         attr->SetDefAttr(m_defaultCellAttr);
7578     }
7579     else
7580     {
7581         attr = m_defaultCellAttr;
7582         attr->IncRef();
7583     }
7584
7585     return attr;
7586 }
7587
7588 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
7589 {
7590     wxGridCellAttr *attr;
7591     if ( !LookupAttr(row, col, &attr) || !attr )
7592     {
7593         wxASSERT_MSG( m_table,
7594                       _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
7595
7596         attr = m_table->GetAttr(row, col);
7597         if ( !attr )
7598         {
7599             attr = new wxGridCellAttr;
7600
7601             // artificially inc the ref count to match DecRef() in caller
7602             attr->IncRef();
7603
7604             m_table->SetAttr(attr, row, col);
7605         }
7606
7607         CacheAttr(row, col, attr);
7608     }
7609     attr->SetDefAttr(m_defaultCellAttr);
7610     return attr;
7611 }
7612
7613 // ----------------------------------------------------------------------------
7614 // setting column attributes (wrappers around SetColAttr)
7615 // ----------------------------------------------------------------------------
7616
7617 void wxGrid::SetColFormatBool(int col)
7618 {
7619     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
7620 }
7621
7622 void wxGrid::SetColFormatNumber(int col)
7623 {
7624     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
7625 }
7626
7627 void wxGrid::SetColFormatFloat(int col, int width, int precision)
7628 {
7629     wxString typeName = wxGRID_VALUE_FLOAT;
7630     if ( (width != -1) || (precision != -1) )
7631     {
7632         typeName << _T(':') << width << _T(',') << precision;
7633     }
7634
7635     SetColFormatCustom(col, typeName);
7636 }
7637
7638 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
7639 {
7640     wxGridCellAttr *attr = new wxGridCellAttr;
7641     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
7642     attr->SetRenderer(renderer);
7643
7644     SetColAttr(col, attr);
7645 }
7646
7647 // ----------------------------------------------------------------------------
7648 // setting cell attributes: this is forwarded to the table
7649 // ----------------------------------------------------------------------------
7650
7651 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
7652 {
7653     if ( CanHaveAttributes() )
7654     {
7655         m_table->SetRowAttr(attr, row);
7656     }
7657     else
7658     {
7659         wxSafeDecRef(attr);
7660     }
7661 }
7662
7663 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
7664 {
7665     if ( CanHaveAttributes() )
7666     {
7667         m_table->SetColAttr(attr, col);
7668     }
7669     else
7670     {
7671         wxSafeDecRef(attr);
7672     }
7673 }
7674
7675 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
7676 {
7677     if ( CanHaveAttributes() )
7678     {
7679         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7680         attr->SetBackgroundColour(colour);
7681         attr->DecRef();
7682     }
7683 }
7684
7685 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
7686 {
7687     if ( CanHaveAttributes() )
7688     {
7689         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7690         attr->SetTextColour(colour);
7691         attr->DecRef();
7692     }
7693 }
7694
7695 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
7696 {
7697     if ( CanHaveAttributes() )
7698     {
7699         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7700         attr->SetFont(font);
7701         attr->DecRef();
7702     }
7703 }
7704
7705 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
7706 {
7707     if ( CanHaveAttributes() )
7708     {
7709         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7710         attr->SetAlignment(horiz, vert);
7711         attr->DecRef();
7712     }
7713 }
7714
7715 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
7716 {
7717     if ( CanHaveAttributes() )
7718     {
7719         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7720         attr->SetRenderer(renderer);
7721         attr->DecRef();
7722     }
7723 }
7724
7725 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
7726 {
7727     if ( CanHaveAttributes() )
7728     {
7729         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7730         attr->SetEditor(editor);
7731         attr->DecRef();
7732     }
7733 }
7734
7735 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
7736 {
7737     if ( CanHaveAttributes() )
7738     {
7739         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7740         attr->SetReadOnly(isReadOnly);
7741         attr->DecRef();
7742     }
7743 }
7744
7745 // ----------------------------------------------------------------------------
7746 // Data type registration
7747 // ----------------------------------------------------------------------------
7748
7749 void wxGrid::RegisterDataType(const wxString& typeName,
7750                               wxGridCellRenderer* renderer,
7751                               wxGridCellEditor* editor)
7752 {
7753     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
7754 }
7755
7756
7757 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
7758 {
7759     wxString typeName = m_table->GetTypeName(row, col);
7760     return GetDefaultEditorForType(typeName);
7761 }
7762
7763 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
7764 {
7765     wxString typeName = m_table->GetTypeName(row, col);
7766     return GetDefaultRendererForType(typeName);
7767 }
7768
7769 wxGridCellEditor*
7770 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
7771 {
7772     int index = m_typeRegistry->FindOrCloneDataType(typeName);
7773     if ( index == wxNOT_FOUND )
7774     {
7775         wxFAIL_MSG(wxT("Unknown data type name"));
7776
7777         return NULL;
7778     }
7779
7780     return m_typeRegistry->GetEditor(index);
7781 }
7782
7783 wxGridCellRenderer*
7784 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
7785 {
7786     int index = m_typeRegistry->FindOrCloneDataType(typeName);
7787     if ( index == wxNOT_FOUND )
7788     {
7789         wxFAIL_MSG(wxT("Unknown data type name"));
7790
7791         return NULL;
7792     }
7793
7794     return m_typeRegistry->GetRenderer(index);
7795 }
7796
7797
7798 // ----------------------------------------------------------------------------
7799 // row/col size
7800 // ----------------------------------------------------------------------------
7801
7802 void wxGrid::EnableDragRowSize( bool enable )
7803 {
7804     m_canDragRowSize = enable;
7805 }
7806
7807
7808 void wxGrid::EnableDragColSize( bool enable )
7809 {
7810     m_canDragColSize = enable;
7811 }
7812
7813 void wxGrid::EnableDragGridSize( bool enable )
7814 {
7815     m_canDragGridSize = enable;
7816 }
7817
7818
7819 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
7820 {
7821     m_defaultRowHeight = wxMax( height, WXGRID_MIN_ROW_HEIGHT );
7822
7823     if ( resizeExistingRows )
7824     {
7825         InitRowHeights();
7826
7827         CalcDimensions();
7828     }
7829 }
7830
7831 void wxGrid::SetRowSize( int row, int height )
7832 {
7833     wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
7834
7835     if ( m_rowHeights.IsEmpty() )
7836     {
7837         // need to really create the array
7838         InitRowHeights();
7839     }
7840
7841     int h = wxMax( 0, height );
7842     int diff = h - m_rowHeights[row];
7843
7844     m_rowHeights[row] = h;
7845     int i;
7846     for ( i = row;  i < m_numRows;  i++ )
7847     {
7848         m_rowBottoms[i] += diff;
7849     }
7850     CalcDimensions();
7851 }
7852
7853 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
7854 {
7855     m_defaultColWidth = wxMax( width, WXGRID_MIN_COL_WIDTH );
7856
7857     if ( resizeExistingCols )
7858     {
7859         InitColWidths();
7860
7861         CalcDimensions();
7862     }
7863 }
7864
7865 void wxGrid::SetColSize( int col, int width )
7866 {
7867     wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
7868
7869     // should we check that it's bigger than GetColMinimalWidth(col) here?
7870
7871     if ( m_colWidths.IsEmpty() )
7872     {
7873         // need to really create the array
7874         InitColWidths();
7875     }
7876
7877     int w = wxMax( 0, width );
7878     int diff = w - m_colWidths[col];
7879     m_colWidths[col] = w;
7880
7881     int i;
7882     for ( i = col;  i < m_numCols;  i++ )
7883     {
7884         m_colRights[i] += diff;
7885     }
7886     CalcDimensions();
7887 }
7888
7889
7890 void wxGrid::SetColMinimalWidth( int col, int width )
7891 {
7892     m_colMinWidths.Put(col, width);
7893 }
7894
7895 void wxGrid::SetRowMinimalHeight( int row, int width )
7896 {
7897     m_rowMinHeights.Put(row, width);
7898 }
7899
7900 int wxGrid::GetColMinimalWidth(int col) const
7901 {
7902     long value = m_colMinWidths.Get(col);
7903     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_COL_WIDTH;
7904 }
7905
7906 int wxGrid::GetRowMinimalHeight(int row) const
7907 {
7908     long value = m_rowMinHeights.Get(row);
7909     return value != wxNOT_FOUND ? (int)value : WXGRID_MIN_ROW_HEIGHT;
7910 }
7911
7912 // ----------------------------------------------------------------------------
7913 // auto sizing
7914 // ----------------------------------------------------------------------------
7915
7916 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
7917 {
7918     wxClientDC dc(m_gridWin);
7919
7920     // init both of them to avoid compiler warnings, even if weo nly need one
7921     int row = -1,
7922         col = -1;
7923     if ( column )
7924         col = colOrRow;
7925     else
7926         row = colOrRow;
7927
7928     wxCoord extent, extentMax = 0;
7929     int max = column ? m_numRows : m_numCols;
7930     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
7931     {
7932         if ( column )
7933             row = rowOrCol;
7934         else
7935             col = rowOrCol;
7936
7937         wxGridCellAttr* attr = GetCellAttr(row, col);
7938         wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
7939         if ( renderer )
7940         {
7941             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
7942             extent = column ? size.x : size.y;
7943             if ( extent > extentMax )
7944             {
7945                 extentMax = extent;
7946             }
7947
7948             renderer->DecRef();
7949         }
7950
7951         attr->DecRef();
7952     }
7953
7954     // now also compare with the column label extent
7955     wxCoord w, h;
7956     dc.SetFont( GetLabelFont() );
7957
7958     if ( column )
7959         dc.GetTextExtent( GetColLabelValue(col), &w, &h );
7960     else
7961         dc.GetTextExtent( GetRowLabelValue(col), &w, &h );
7962
7963     extent = column ? w : h;
7964     if ( extent > extentMax )
7965     {
7966         extentMax = extent;
7967     }
7968
7969     if ( !extentMax )
7970     {
7971         // empty column - give default extent (notice that if extentMax is less
7972         // than default extent but != 0, it's ok)
7973         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
7974     }
7975     else
7976     {
7977         if ( column )
7978         {
7979             // leave some space around text
7980             extentMax += 10;
7981         }
7982         else
7983         {
7984             extentMax += 6;
7985         }
7986     }
7987
7988     if ( column )
7989         SetColSize(col, extentMax);
7990     else
7991         SetRowSize(row, extentMax);
7992
7993     if ( setAsMin )
7994     {
7995         if ( column )
7996             SetColMinimalWidth(col, extentMax);
7997         else
7998             SetRowMinimalHeight(row, extentMax);
7999     }
8000 }
8001
8002 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8003 {
8004     int width = m_rowLabelWidth;
8005
8006     for ( int col = 0; col < m_numCols; col++ )
8007     {
8008         if ( !calcOnly )
8009         {
8010             AutoSizeColumn(col, setAsMin);
8011         }
8012
8013         width += GetColWidth(col);
8014     }
8015
8016     return width;
8017 }
8018
8019 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8020 {
8021     int height = m_colLabelHeight;
8022
8023     for ( int row = 0; row < m_numRows; row++ )
8024     {
8025         if ( !calcOnly )
8026         {
8027             AutoSizeRow(row, setAsMin);
8028         }
8029
8030         height += GetRowHeight(row);
8031     }
8032
8033     return height;
8034 }
8035
8036 void wxGrid::AutoSize()
8037 {
8038     // set the size too
8039     SetSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
8040 }
8041
8042 wxSize wxGrid::DoGetBestSize() const
8043 {
8044     // don't set sizes, only calculate them
8045     wxGrid *self = (wxGrid *)this;  // const_cast
8046
8047     return wxSize(self->SetOrCalcColumnSizes(TRUE),
8048                   self->SetOrCalcRowSizes(TRUE));
8049 }
8050
8051 void wxGrid::Fit()
8052 {
8053     AutoSize();
8054 }
8055
8056
8057 wxPen& wxGrid::GetDividerPen() const
8058 {
8059     return wxNullPen;
8060 }
8061
8062 // ----------------------------------------------------------------------------
8063 // cell value accessor functions
8064 // ----------------------------------------------------------------------------
8065
8066 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8067 {
8068     if ( m_table )
8069     {
8070         m_table->SetValue( row, col, s );
8071         if ( !GetBatchCount() )
8072         {
8073             wxClientDC dc( m_gridWin );
8074             PrepareDC( dc );
8075             DrawCell( dc, wxGridCellCoords(row, col) );
8076         }
8077
8078         if ( m_currentCellCoords.GetRow() == row &&
8079              m_currentCellCoords.GetCol() == col &&
8080              IsCellEditControlShown())
8081              // Note: If we are using IsCellEditControlEnabled,
8082              // this interacts badly with calling SetCellValue from
8083              // an EVT_GRID_CELL_CHANGE handler.
8084         {
8085             HideCellEditControl();
8086             ShowCellEditControl(); // will reread data from table
8087         }
8088     }
8089 }
8090
8091
8092 //
8093 // ------ Block, row and col selection
8094 //
8095
8096 void wxGrid::SelectRow( int row, bool addToSelected )
8097 {
8098     if ( IsSelection() && !addToSelected )
8099         ClearSelection();
8100
8101     m_selection->SelectRow( row, FALSE, addToSelected );
8102 }
8103
8104
8105 void wxGrid::SelectCol( int col, bool addToSelected )
8106 {
8107     if ( IsSelection() && !addToSelected )
8108         ClearSelection();
8109
8110     m_selection->SelectCol( col, FALSE, addToSelected );
8111 }
8112
8113
8114 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
8115 {
8116     int temp;
8117     wxGridCellCoords updateTopLeft, updateBottomRight;
8118
8119     if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
8120     {
8121         leftCol = 0;
8122         rightCol = GetNumberCols() - 1;
8123     }
8124     else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
8125     {
8126         topRow = 0;
8127         bottomRow = GetNumberRows() - 1;
8128     }
8129     if ( topRow > bottomRow )
8130     {
8131         temp = topRow;
8132         topRow = bottomRow;
8133         bottomRow = temp;
8134     }
8135
8136     if ( leftCol > rightCol )
8137     {
8138         temp = leftCol;
8139         leftCol = rightCol;
8140         rightCol = temp;
8141     }
8142
8143     updateTopLeft = wxGridCellCoords( topRow, leftCol );
8144     updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
8145
8146     if ( m_selectingTopLeft != updateTopLeft ||
8147          m_selectingBottomRight != updateBottomRight )
8148     {
8149         // Compute two optimal update rectangles:
8150         // Either one rectangle is a real subset of the
8151         // other, or they are (almost) disjoint!
8152         wxRect  rect[4];
8153         bool    need_refresh[4];
8154         need_refresh[0] =
8155         need_refresh[1] =
8156         need_refresh[2] =
8157         need_refresh[3] = FALSE;
8158         int     i;
8159
8160         // Store intermediate values
8161         wxCoord oldLeft   = m_selectingTopLeft.GetCol();
8162         wxCoord oldTop    = m_selectingTopLeft.GetRow();
8163         wxCoord oldRight  = m_selectingBottomRight.GetCol();
8164         wxCoord oldBottom = m_selectingBottomRight.GetRow();
8165
8166         // Determine the outer/inner coordinates.
8167         if (oldLeft > leftCol)
8168         {
8169             temp = oldLeft;
8170             oldLeft = leftCol;
8171             leftCol = temp;
8172         }
8173         if (oldTop > topRow )
8174         {
8175             temp = oldTop;
8176             oldTop = topRow;
8177             topRow = temp;
8178         }
8179         if (oldRight < rightCol )
8180         {
8181             temp = oldRight;
8182             oldRight = rightCol;
8183             rightCol = temp;
8184         }
8185         if (oldBottom < bottomRow)
8186         {
8187             temp = oldBottom;
8188             oldBottom = bottomRow;
8189             bottomRow = temp;
8190         }
8191
8192         // Now, either the stuff marked old is the outer
8193         // rectangle or we don't have a situation where one
8194         // is contained in the other.
8195
8196         if ( oldLeft < leftCol )
8197         {
8198             need_refresh[0] = TRUE;
8199             rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
8200                                                             oldLeft ),
8201                                          wxGridCellCoords ( oldBottom,
8202                                                             leftCol - 1 ) );
8203         }
8204
8205         if ( oldTop  < topRow )
8206         {
8207             need_refresh[1] = TRUE;
8208             rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
8209                                                             leftCol ),
8210                                          wxGridCellCoords ( topRow - 1,
8211                                                             rightCol ) );
8212         }
8213
8214         if ( oldRight > rightCol )
8215         {
8216             need_refresh[2] = TRUE;
8217             rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
8218                                                             rightCol + 1 ),
8219                                          wxGridCellCoords ( oldBottom,
8220                                                             oldRight ) );
8221         }
8222
8223         if ( oldBottom > bottomRow )
8224         {
8225             need_refresh[3] = TRUE;
8226             rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
8227                                                             leftCol ),
8228                                          wxGridCellCoords ( oldBottom,
8229                                                             rightCol ) );
8230         }
8231
8232
8233         // Change Selection
8234         m_selectingTopLeft = updateTopLeft;
8235         m_selectingBottomRight = updateBottomRight;
8236
8237         // various Refresh() calls
8238         for (i = 0; i < 4; i++ )
8239             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
8240                 m_gridWin->Refresh( FALSE, &(rect[i]) );
8241     }
8242
8243     // never generate an event as it will be generated from
8244     // wxGridSelection::SelectBlock!
8245 }
8246
8247 void wxGrid::SelectAll()
8248 {
8249     m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
8250 }
8251
8252 bool wxGrid::IsSelection()
8253 {
8254     return ( m_selection->IsSelection() ||
8255              ( m_selectingTopLeft != wxGridNoCellCoords &&
8256                m_selectingBottomRight != wxGridNoCellCoords ) );
8257 }
8258
8259 bool wxGrid::IsInSelection( int row, int col )
8260 {
8261     return ( m_selection->IsInSelection( row, col ) ||
8262              ( row >= m_selectingTopLeft.GetRow() &&
8263                col >= m_selectingTopLeft.GetCol() &&
8264                row <= m_selectingBottomRight.GetRow() &&
8265                col <= m_selectingBottomRight.GetCol() ) );
8266 }
8267
8268 void wxGrid::ClearSelection()
8269 {
8270     m_selectingTopLeft = wxGridNoCellCoords;
8271     m_selectingBottomRight = wxGridNoCellCoords;
8272     m_selection->ClearSelection();
8273 }
8274
8275
8276 // This function returns the rectangle that encloses the given block
8277 // in device coords clipped to the client size of the grid window.
8278 //
8279 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
8280                                   const wxGridCellCoords &bottomRight )
8281 {
8282     wxRect rect( wxGridNoCellRect );
8283     wxRect cellRect;
8284
8285     cellRect = CellToRect( topLeft );
8286     if ( cellRect != wxGridNoCellRect )
8287     {
8288         rect = cellRect;
8289     }
8290     else
8291     {
8292         rect = wxRect( 0, 0, 0, 0 );
8293     }
8294
8295     cellRect = CellToRect( bottomRight );
8296     if ( cellRect != wxGridNoCellRect )
8297     {
8298         rect += cellRect;
8299     }
8300     else
8301     {
8302         return wxGridNoCellRect;
8303     }
8304
8305     // convert to scrolled coords
8306     //
8307     int left, top, right, bottom;
8308     CalcScrolledPosition( rect.GetLeft(), rect.GetTop(), &left, &top );
8309     CalcScrolledPosition( rect.GetRight(), rect.GetBottom(), &right, &bottom );
8310
8311     int cw, ch;
8312     m_gridWin->GetClientSize( &cw, &ch );
8313
8314     if (right < 0 || bottom < 0 || left > cw || top > ch)
8315         return wxRect( 0, 0, 0, 0);
8316
8317     rect.SetLeft( wxMax(0, left) );
8318     rect.SetTop( wxMax(0, top) );
8319     rect.SetRight( wxMin(cw, right) );
8320     rect.SetBottom( wxMin(ch, bottom) );
8321
8322     return rect;
8323 }
8324
8325
8326
8327 //
8328 // ------ Grid event classes
8329 //
8330
8331 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
8332
8333 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8334                           int row, int col, int x, int y, bool sel,
8335                           bool control, bool shift, bool alt, bool meta )
8336         : wxNotifyEvent( type, id )
8337 {
8338     m_row = row;
8339     m_col = col;
8340     m_x = x;
8341     m_y = y;
8342     m_selecting = sel;
8343     m_control = control;
8344     m_shift = shift;
8345     m_alt = alt;
8346     m_meta = meta;
8347
8348     SetEventObject(obj);
8349 }
8350
8351
8352 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
8353
8354 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8355                                   int rowOrCol, int x, int y,
8356                                   bool control, bool shift, bool alt, bool meta )
8357         : wxNotifyEvent( type, id )
8358 {
8359     m_rowOrCol = rowOrCol;
8360     m_x = x;
8361     m_y = y;
8362     m_control = control;
8363     m_shift = shift;
8364     m_alt = alt;
8365     m_meta = meta;
8366
8367     SetEventObject(obj);
8368 }
8369
8370
8371 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
8372
8373 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8374                                                const wxGridCellCoords& topLeft,
8375                                                const wxGridCellCoords& bottomRight,
8376                                                bool sel, bool control,
8377                                                bool shift, bool alt, bool meta )
8378         : wxNotifyEvent( type, id )
8379 {
8380     m_topLeft     = topLeft;
8381     m_bottomRight = bottomRight;
8382     m_selecting   = sel;
8383     m_control     = control;
8384     m_shift       = shift;
8385     m_alt         = alt;
8386     m_meta        = meta;
8387
8388     SetEventObject(obj);
8389 }
8390
8391
8392 #endif // ifndef wxUSE_NEW_GRID