src/generic/grid.cpp

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