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