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