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