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_PTR(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 positive 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 numRemaining = m_colLabels.size() - colID;
1538         if (numRemaining > 0)
1539             m_colLabels.RemoveAt( colID, wxMin(numCols, numRemaining) );
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 resizable
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 bool
3652 wxGrid::DoGridCellDrag(wxMouseEvent& event,
3653                        const wxGridCellCoords& coords,
3654                        bool isFirstDrag)
3655 {
3656     bool performDefault = true ;
3657
3658     if ( coords == wxGridNoCellCoords )
3659         return performDefault; // we're outside any valid cell
3660
3661     // Hide the edit control, so it won't interfere with drag-shrinking.
3662     if ( IsCellEditControlShown() )
3663     {
3664         HideCellEditControl();
3665         SaveEditControlValue();
3666     }
3667
3668     switch ( event.GetModifiers() )
3669     {
3670         case wxMOD_CONTROL:
3671             if ( m_selectedBlockCorner == wxGridNoCellCoords)
3672                 m_selectedBlockCorner = coords;
3673             UpdateBlockBeingSelected(m_selectedBlockCorner, coords);
3674             break;
3675
3676         case wxMOD_NONE:
3677             if ( CanDragCell() )
3678             {
3679                 if ( isFirstDrag )
3680                 {
3681                     if ( m_selectedBlockCorner == wxGridNoCellCoords)
3682                         m_selectedBlockCorner = coords;
3683
3684                     // if event is handled by user code, no further processing
3685                     if ( SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event) != 0 )
3686                         performDefault = false;
3687
3688                     return performDefault;
3689                 }
3690             }
3691
3692             UpdateBlockBeingSelected(m_currentCellCoords, coords);
3693             break;
3694
3695         default:
3696             // we don't handle the other key modifiers
3697             event.Skip();
3698     }
3699
3700     return performDefault;
3701 }
3702
3703 void wxGrid::DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper)
3704 {
3705     wxClientDC dc(m_gridWin);
3706     PrepareDC(dc);
3707     dc.SetLogicalFunction(wxINVERT);
3708
3709     const wxRect rectWin(CalcUnscrolledPosition(wxPoint(0, 0)),
3710                          m_gridWin->GetClientSize());
3711
3712     // erase the previously drawn line, if any
3713     if ( m_dragLastPos >= 0 )
3714         oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3715
3716     // we need the vertical position for rows and horizontal for columns here
3717     m_dragLastPos = oper.Dual().Select(CalcUnscrolledPosition(event.GetPosition()));
3718
3719     // don't allow resizing beneath the minimal size
3720     const int posMin = oper.GetLineStartPos(this, m_dragRowOrCol) +
3721                         oper.GetMinimalLineSize(this, m_dragRowOrCol);
3722     if ( m_dragLastPos < posMin )
3723         m_dragLastPos = posMin;
3724
3725     // and draw it at the new position
3726     oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3727 }
3728
3729 void wxGrid::DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords)
3730 {
3731     if ( !m_isDragging )
3732     {
3733         // Don't start doing anything until the mouse has been dragged far
3734         // enough
3735         const wxPoint& pt = event.GetPosition();
3736         if ( m_startDragPos == wxDefaultPosition )
3737         {
3738             m_startDragPos = pt;
3739             return;
3740         }
3741
3742         if ( abs(m_startDragPos.x - pt.x) <= DRAG_SENSITIVITY &&
3743                 abs(m_startDragPos.y - pt.y) <= DRAG_SENSITIVITY )
3744             return;
3745     }
3746
3747     const bool isFirstDrag = !m_isDragging;
3748     m_isDragging = true;
3749
3750     switch ( m_cursorMode )
3751     {
3752         case WXGRID_CURSOR_SELECT_CELL:
3753             // no further handling if handled by user
3754             if ( DoGridCellDrag(event, coords, isFirstDrag) == false )
3755                 return;
3756             break;
3757
3758         case WXGRID_CURSOR_RESIZE_ROW:
3759             DoGridLineDrag(event, wxGridRowOperations());
3760             break;
3761
3762         case WXGRID_CURSOR_RESIZE_COL:
3763             DoGridLineDrag(event, wxGridColumnOperations());
3764             break;
3765
3766         default:
3767             event.Skip();
3768     }
3769
3770     if ( isFirstDrag )
3771     {
3772         wxASSERT_MSG( !m_winCapture, "shouldn't capture the mouse twice" );
3773
3774         m_winCapture = m_gridWin;
3775         m_winCapture->CaptureMouse();
3776     }
3777 }
3778
3779 void
3780 wxGrid::DoGridCellLeftDown(wxMouseEvent& event,
3781                            const wxGridCellCoords& coords,
3782                            const wxPoint& pos)
3783 {
3784     if ( SendEvent(wxEVT_GRID_CELL_LEFT_CLICK, coords, event) )
3785     {
3786         // event handled by user code, no need to do anything here
3787         return;
3788     }
3789
3790     if ( !event.CmdDown() )
3791         ClearSelection();
3792
3793     if ( event.ShiftDown() )
3794     {
3795         if ( m_selection )
3796         {
3797             m_selection->SelectBlock(m_currentCellCoords, coords, event);
3798             m_selectedBlockCorner = coords;
3799         }
3800     }
3801     else if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3802     {
3803         DisableCellEditControl();
3804         MakeCellVisible( coords );
3805
3806         if ( event.CmdDown() )
3807         {
3808             if ( m_selection )
3809             {
3810                 m_selection->ToggleCellSelection(coords, event);
3811             }
3812
3813             m_selectedBlockTopLeft = wxGridNoCellCoords;
3814             m_selectedBlockBottomRight = wxGridNoCellCoords;
3815             m_selectedBlockCorner = coords;
3816         }
3817         else
3818         {
3819             if ( m_selection )
3820             {
3821                 // In row or column selection mode just clicking on the cell
3822                 // should select the row or column containing it: this is more
3823                 // convenient for the kinds of controls that use such selection
3824                 // mode and is compatible with 2.8 behaviour (see #12062).
3825                 switch ( m_selection->GetSelectionMode() )
3826                 {
3827                     case wxGridSelectCells:
3828                     case wxGridSelectRowsOrColumns:
3829                         // nothing to do in these cases
3830                         break;
3831
3832                     case wxGridSelectRows:
3833                         m_selection->SelectRow(coords.GetRow());
3834                         break;
3835
3836                     case wxGridSelectColumns:
3837                         m_selection->SelectCol(coords.GetCol());
3838                         break;
3839                 }
3840             }
3841
3842             m_waitForSlowClick = m_currentCellCoords == coords &&
3843                                         coords != wxGridNoCellCoords;
3844             SetCurrentCell( coords );
3845         }
3846     }
3847 }
3848
3849 void
3850 wxGrid::DoGridCellLeftDClick(wxMouseEvent& event,
3851                              const wxGridCellCoords& coords,
3852                              const wxPoint& pos)
3853 {
3854     if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3855     {
3856         if ( !SendEvent(wxEVT_GRID_CELL_LEFT_DCLICK, coords, event) )
3857         {
3858             // we want double click to select a cell and start editing
3859             // (i.e. to behave in same way as sequence of two slow clicks):
3860             m_waitForSlowClick = true;
3861         }
3862     }
3863 }
3864
3865 void
3866 wxGrid::DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords)
3867 {
3868     if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3869     {
3870         if (m_winCapture)
3871         {
3872             m_winCapture->ReleaseMouse();
3873             m_winCapture = NULL;
3874         }
3875
3876         if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
3877         {
3878             ClearSelection();
3879             EnableCellEditControl();
3880
3881             wxGridCellAttr *attr = GetCellAttr(coords);
3882             wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
3883             editor->StartingClick();
3884             editor->DecRef();
3885             attr->DecRef();
3886
3887             m_waitForSlowClick = false;
3888         }
3889         else if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
3890              m_selectedBlockBottomRight != wxGridNoCellCoords )
3891         {
3892             if ( m_selection )
3893             {
3894                 m_selection->SelectBlock( m_selectedBlockTopLeft,
3895                                           m_selectedBlockBottomRight,
3896                                           event );
3897             }
3898
3899             m_selectedBlockTopLeft = wxGridNoCellCoords;
3900             m_selectedBlockBottomRight = wxGridNoCellCoords;
3901
3902             // Show the edit control, if it has been hidden for
3903             // drag-shrinking.
3904             ShowCellEditControl();
3905         }
3906     }
3907     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3908     {
3909         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3910         DoEndDragResizeRow(event);
3911     }
3912     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3913     {
3914         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3915         DoEndDragResizeCol(event);
3916     }
3917
3918     m_dragLastPos = -1;
3919 }
3920
3921 void
3922 wxGrid::DoGridMouseMoveEvent(wxMouseEvent& WXUNUSED(event),
3923                              const wxGridCellCoords& coords,
3924                              const wxPoint& pos)
3925 {
3926     if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
3927     {
3928         // out of grid cell area
3929         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3930         return;
3931     }
3932
3933     int dragRow = YToEdgeOfRow( pos.y );
3934     int dragCol = XToEdgeOfCol( pos.x );
3935
3936     // Dragging on the corner of a cell to resize in both
3937     // directions is not implemented yet...
3938     //
3939     if ( dragRow >= 0 && dragCol >= 0 )
3940     {
3941         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3942         return;
3943     }
3944
3945     if ( dragRow >= 0 && CanDragGridSize() && CanDragRowSize(dragRow) )
3946     {
3947         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3948         {
3949             m_dragRowOrCol = dragRow;
3950             ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);
3951         }
3952     }
3953     // When using the native header window we can only resize the columns by
3954     // dragging the dividers in it because we can't make it enter into the
3955     // column resizing mode programmatically
3956     else if ( dragCol >= 0 && !m_useNativeHeader &&
3957                 CanDragGridSize() && CanDragColSize(dragCol) )
3958     {
3959         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3960         {
3961             m_dragRowOrCol = dragCol;
3962             ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);
3963         }
3964     }
3965     else // Neither on a row or col edge
3966     {
3967         if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3968         {
3969             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3970         }
3971     }
3972 }
3973
3974 void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
3975 {
3976     if ( event.Entering() || event.Leaving() )
3977     {
3978         // we don't care about these events but we must not reset m_isDragging
3979         // if they happen so return before anything else is done
3980         event.Skip();
3981         return;
3982     }
3983
3984     const wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
3985
3986     // coordinates of the cell under mouse
3987     wxGridCellCoords coords = XYToCell(pos);
3988
3989     int cell_rows, cell_cols;
3990     GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
3991     if ( (cell_rows < 0) || (cell_cols < 0) )
3992     {
3993         coords.SetRow(coords.GetRow() + cell_rows);
3994         coords.SetCol(coords.GetCol() + cell_cols);
3995     }
3996
3997     if ( event.Dragging() )
3998     {
3999         if ( event.LeftIsDown() )
4000             DoGridDragEvent(event, coords);
4001         else
4002             event.Skip();
4003         return;
4004     }
4005
4006     m_isDragging = false;
4007     m_startDragPos = wxDefaultPosition;
4008
4009     // deal with various button presses
4010     if ( event.IsButton() )
4011     {
4012         if ( coords != wxGridNoCellCoords )
4013         {
4014             DisableCellEditControl();
4015
4016             if ( event.LeftDown() )
4017                 DoGridCellLeftDown(event, coords, pos);
4018             else if ( event.LeftDClick() )
4019                 DoGridCellLeftDClick(event, coords, pos);
4020             else if ( event.RightDown() )
4021                 SendEvent(wxEVT_GRID_CELL_RIGHT_CLICK, coords, event);
4022             else if ( event.RightDClick() )
4023                 SendEvent(wxEVT_GRID_CELL_RIGHT_DCLICK, coords, event);
4024         }
4025
4026         // this one should be called even if we're not over any cell
4027         if ( event.LeftUp() )
4028         {
4029             DoGridCellLeftUp(event, coords);
4030         }
4031     }
4032     else if ( event.Moving() )
4033     {
4034         DoGridMouseMoveEvent(event, coords, pos);
4035     }
4036     else // unknown mouse event?
4037     {
4038         event.Skip();
4039     }
4040 }
4041
4042 // this function returns true only if the size really changed
4043 bool wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
4044 {
4045     if ( m_dragLastPos == -1 )
4046         return false;
4047
4048     const wxGridOperations& doper = oper.Dual();
4049
4050     const wxSize size = m_gridWin->GetClientSize();
4051
4052     const wxPoint ptOrigin = CalcUnscrolledPosition(wxPoint(0, 0));
4053
4054     // erase the last line we drew
4055     wxClientDC dc(m_gridWin);
4056     PrepareDC(dc);
4057     dc.SetLogicalFunction(wxINVERT);
4058
4059     const int posLineStart = oper.Select(ptOrigin);
4060     const int posLineEnd = oper.Select(ptOrigin) + oper.Select(size);
4061
4062     oper.DrawParallelLine(dc, posLineStart, posLineEnd, m_dragLastPos);
4063
4064     // temporarily hide the edit control before resizing
4065     HideCellEditControl();
4066     SaveEditControlValue();
4067
4068     // do resize the line
4069     const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);
4070     const int lineSizeOld = oper.GetLineSize(this, m_dragRowOrCol);
4071     oper.SetLineSize(this, m_dragRowOrCol,
4072                      wxMax(m_dragLastPos - lineStart,
4073                            oper.GetMinimalLineSize(this, m_dragRowOrCol)));
4074     const bool
4075         sizeChanged = oper.GetLineSize(this, m_dragRowOrCol) != lineSizeOld;
4076
4077     m_dragLastPos = -1;
4078
4079     // refresh now if we're not frozen
4080     if ( !GetBatchCount() )
4081     {
4082         // we need to refresh everything beyond the resized line in the header
4083         // window
4084
4085         // get the position from which to refresh in the other direction
4086         wxRect rect(CellToRect(oper.MakeCoords(m_dragRowOrCol, 0)));
4087         rect.SetPosition(CalcScrolledPosition(rect.GetPosition()));
4088
4089         // we only need the ordinate (for rows) or abscissa (for columns) here,
4090         // and need to cover the entire window in the other direction
4091         oper.Select(rect) = 0;
4092
4093         wxRect rectHeader(rect.GetPosition(),
4094                           oper.MakeSize
4095                                (
4096                                     oper.GetHeaderWindowSize(this),
4097                                     doper.Select(size) - doper.Select(rect)
4098                                ));
4099
4100         oper.GetHeaderWindow(this)->Refresh(true, &rectHeader);
4101
4102
4103         // also refresh the grid window: extend the rectangle
4104         if ( m_table )
4105         {
4106             oper.SelectSize(rect) = oper.Select(size);
4107
4108             int subtractLines = 0;
4109             const int lineStart = doper.PosToLine(this, posLineStart);
4110             if ( lineStart >= 0 )
4111             {
4112                 // ensure that if we have a multi-cell block we redraw all of
4113                 // it by increasing the refresh area to cover it entirely if a
4114                 // part of it is affected
4115                 const int lineEnd = doper.PosToLine(this, posLineEnd, true);
4116                 for ( int line = lineStart; line < lineEnd; line++ )
4117                 {
4118                     int cellLines = oper.Select(
4119                         GetCellSize(oper.MakeCoords(m_dragRowOrCol, line)));
4120                     if ( cellLines < subtractLines )
4121                         subtractLines = cellLines;
4122                 }
4123             }
4124
4125             int startPos =
4126                 oper.GetLineStartPos(this, m_dragRowOrCol + subtractLines);
4127             startPos = doper.CalcScrolledPosition(this, startPos);
4128
4129             doper.Select(rect) = startPos;
4130             doper.SelectSize(rect) = doper.Select(size) - startPos;
4131
4132             m_gridWin->Refresh(false, &rect);
4133         }
4134     }
4135
4136     // show the edit control back again
4137     ShowCellEditControl();
4138
4139     return sizeChanged;
4140 }
4141
4142 void wxGrid::DoEndDragResizeRow(const wxMouseEvent& event)
4143 {
4144     // TODO: generate RESIZING event, see #10754
4145
4146     if ( DoEndDragResizeLine(wxGridRowOperations()) )
4147         SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event);
4148 }
4149
4150 void wxGrid::DoEndDragResizeCol(const wxMouseEvent& event)
4151 {
4152     // TODO: generate RESIZING event, see #10754
4153
4154     if ( DoEndDragResizeLine(wxGridColumnOperations()) )
4155         SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event);
4156 }
4157
4158 void wxGrid::DoStartMoveCol(int col)
4159 {
4160     m_dragRowOrCol = col;
4161 }
4162
4163 void wxGrid::DoEndMoveCol(int pos)
4164 {
4165     wxASSERT_MSG( m_dragRowOrCol != -1, "no matching DoStartMoveCol?" );
4166
4167     if ( SendEvent(wxEVT_GRID_COL_MOVE, -1, m_dragRowOrCol) != -1 )
4168         SetColPos(m_dragRowOrCol, pos);
4169     //else: vetoed by user
4170
4171     m_dragRowOrCol = -1;
4172 }
4173
4174 void wxGrid::RefreshAfterColPosChange()
4175 {
4176     // recalculate the column rights as the column positions have changed,
4177     // unless we calculate them dynamically because all columns widths are the
4178     // same and it's easy to do
4179     if ( !m_colWidths.empty() )
4180     {
4181         int colRight = 0;
4182         for ( int colPos = 0; colPos < m_numCols; colPos++ )
4183         {
4184             int colID = GetColAt( colPos );
4185
4186             colRight += m_colWidths[colID];
4187             m_colRights[colID] = colRight;
4188         }
4189     }
4190
4191     // and make the changes visible
4192     if ( m_useNativeHeader )
4193     {
4194         if ( m_colAt.empty() )
4195             GetGridColHeader()->ResetColumnsOrder();
4196         else
4197             GetGridColHeader()->SetColumnsOrder(m_colAt);
4198     }
4199     else
4200     {
4201         m_colWindow->Refresh();
4202     }
4203     m_gridWin->Refresh();
4204 }
4205
4206 void wxGrid::SetColumnsOrder(const wxArrayInt& order)
4207 {
4208     m_colAt = order;
4209
4210     RefreshAfterColPosChange();
4211 }
4212
4213 void wxGrid::SetColPos(int idx, int pos)
4214 {
4215     // we're going to need m_colAt now, initialize it if needed
4216     if ( m_colAt.empty() )
4217     {
4218         m_colAt.reserve(m_numCols);
4219         for ( int i = 0; i < m_numCols; i++ )
4220             m_colAt.push_back(i);
4221     }
4222
4223     wxHeaderCtrl::MoveColumnInOrderArray(m_colAt, idx, pos);
4224
4225     RefreshAfterColPosChange();
4226 }
4227
4228 void wxGrid::ResetColPos()
4229 {
4230     m_colAt.clear();
4231
4232     RefreshAfterColPosChange();
4233 }
4234
4235 void wxGrid::EnableDragColMove( bool enable )
4236 {
4237     if ( m_canDragColMove == enable )
4238         return;
4239
4240     if ( m_useNativeHeader )
4241     {
4242         // update all columns to make them [not] reorderable
4243         GetGridColHeader()->SetColumnCount(m_numCols);
4244     }
4245
4246     m_canDragColMove = enable;
4247
4248     // we use to call ResetColPos() from here if !enable but this doesn't seem
4249     // right as it would mean there would be no way to "freeze" the current
4250     // columns order by disabling moving them after putting them in the desired
4251     // order, whereas now you can always call ResetColPos() manually if needed
4252 }
4253
4254
4255 //
4256 // ------ interaction with data model
4257 //
4258 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
4259 {
4260     switch ( msg.GetId() )
4261     {
4262         case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
4263             return GetModelValues();
4264
4265         case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4266             return SetModelValues();
4267
4268         case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4269         case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4270         case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4271         case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4272         case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4273         case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4274             return Redimension( msg );
4275
4276         default:
4277             return false;
4278     }
4279 }
4280
4281 // The behaviour of this function depends on the grid table class
4282 // Clear() function. For the default wxGridStringTable class the
4283 // behaviour is to replace all cell contents with wxEmptyString but
4284 // not to change the number of rows or cols.
4285 //
4286 void wxGrid::ClearGrid()
4287 {
4288     if ( m_table )
4289     {
4290         if (IsCellEditControlEnabled())
4291             DisableCellEditControl();
4292
4293         m_table->Clear();
4294         if (!GetBatchCount())
4295             m_gridWin->Refresh();
4296     }
4297 }
4298
4299 bool
4300 wxGrid::DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
4301                       int pos, int num, bool WXUNUSED(updateLabels) )
4302 {
4303     wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4304
4305     if ( !m_table )
4306         return false;
4307
4308     if ( IsCellEditControlEnabled() )
4309         DisableCellEditControl();
4310
4311     return (m_table->*funcModify)(pos, num);
4312
4313     // the table will have sent the results of the insert row
4314     // operation to this view object as a grid table message
4315 }
4316
4317 bool
4318 wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
4319                       int num, bool WXUNUSED(updateLabels))
4320 {
4321     wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4322
4323     if ( !m_table )
4324         return false;
4325
4326     return (m_table->*funcAppend)(num);
4327 }
4328
4329 // ----------------------------------------------------------------------------
4330 // event generation helpers
4331 // ----------------------------------------------------------------------------
4332
4333 void
4334 wxGrid::SendGridSizeEvent(wxEventType type,
4335                       int row, int col,
4336                       const wxMouseEvent& mouseEv)
4337 {
4338    int rowOrCol = row == -1 ? col : row;
4339
4340    wxGridSizeEvent gridEvt( GetId(),
4341            type,
4342            this,
4343            rowOrCol,
4344            mouseEv.GetX() + GetRowLabelSize(),
4345            mouseEv.GetY() + GetColLabelSize(),
4346            mouseEv);
4347
4348    GetEventHandler()->ProcessEvent(gridEvt);
4349 }
4350
4351 // Generate a grid event based on a mouse event and return:
4352 //  -1 if the event was vetoed
4353 //  +1 if the event was processed (but not vetoed)
4354 //   0 if the event wasn't handled
4355 int
4356 wxGrid::SendEvent(const wxEventType type,
4357                   int row, int col,
4358                   const wxMouseEvent& mouseEv)
4359 {
4360    bool claimed, vetoed;
4361
4362    if ( type == wxEVT_GRID_RANGE_SELECT )
4363    {
4364        // Right now, it should _never_ end up here!
4365        wxGridRangeSelectEvent gridEvt( GetId(),
4366                type,
4367                this,
4368                m_selectedBlockTopLeft,
4369                m_selectedBlockBottomRight,
4370                true,
4371                mouseEv);
4372
4373        claimed = GetEventHandler()->ProcessEvent(gridEvt);
4374        vetoed = !gridEvt.IsAllowed();
4375    }
4376    else if ( type == wxEVT_GRID_LABEL_LEFT_CLICK ||
4377              type == wxEVT_GRID_LABEL_LEFT_DCLICK ||
4378              type == wxEVT_GRID_LABEL_RIGHT_CLICK ||
4379              type == wxEVT_GRID_LABEL_RIGHT_DCLICK )
4380    {
4381        wxPoint pos = mouseEv.GetPosition();
4382
4383        if ( mouseEv.GetEventObject() == GetGridRowLabelWindow() )
4384            pos.y += GetColLabelSize();
4385        if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
4386            pos.x += GetRowLabelSize();
4387
4388        wxGridEvent gridEvt( GetId(),
4389                type,
4390                this,
4391                row, col,
4392                pos.x,
4393                pos.y,
4394                false,
4395                mouseEv);
4396        claimed = GetEventHandler()->ProcessEvent(gridEvt);
4397        vetoed = !gridEvt.IsAllowed();
4398    }
4399    else
4400    {
4401        wxGridEvent gridEvt( GetId(),
4402                type,
4403                this,
4404                row, col,
4405                mouseEv.GetX() + GetRowLabelSize(),
4406                mouseEv.GetY() + GetColLabelSize(),
4407                false,
4408                mouseEv);
4409
4410        if ( type == wxEVT_GRID_CELL_BEGIN_DRAG )
4411        {
4412            // by default the dragging is not supported, the user code must
4413            // explicitly allow the event for it to take place
4414            gridEvt.Veto();
4415        }
4416
4417        claimed = GetEventHandler()->ProcessEvent(gridEvt);
4418        vetoed = !gridEvt.IsAllowed();
4419    }
4420
4421    // A Veto'd event may not be `claimed' so test this first
4422    if (vetoed)
4423        return -1;
4424
4425    return claimed ? 1 : 0;
4426 }
4427
4428 // Generate a grid event of specified type, return value same as above
4429 //
4430 int
4431 wxGrid::SendEvent(const wxEventType type, int row, int col, const wxString& s)
4432 {
4433     wxGridEvent gridEvt( GetId(), type, this, row, col );
4434     gridEvt.SetString(s);
4435
4436     const bool claimed = GetEventHandler()->ProcessEvent(gridEvt);
4437
4438     // A Veto'd event may not be `claimed' so test this first
4439     if ( !gridEvt.IsAllowed() )
4440         return -1;
4441
4442     return claimed ? 1 : 0;
4443 }
4444
4445 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
4446 {
4447     // needed to prevent zillions of paint events on MSW
4448     wxPaintDC dc(this);
4449 }
4450
4451 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
4452 {
4453     // Don't do anything if between Begin/EndBatch...
4454     // EndBatch() will do all this on the last nested one anyway.
4455     if ( m_created && !GetBatchCount() )
4456     {
4457         // Refresh to get correct scrolled position:
4458         wxScrolledWindow::Refresh(eraseb, rect);
4459
4460         if (rect)
4461         {
4462             int rect_x, rect_y, rectWidth, rectHeight;
4463             int width_label, width_cell, height_label, height_cell;
4464             int x, y;
4465
4466             // Copy rectangle can get scroll offsets..
4467             rect_x = rect->GetX();
4468             rect_y = rect->GetY();
4469             rectWidth = rect->GetWidth();
4470             rectHeight = rect->GetHeight();
4471
4472             width_label = m_rowLabelWidth - rect_x;
4473             if (width_label > rectWidth)
4474                 width_label = rectWidth;
4475
4476             height_label = m_colLabelHeight - rect_y;
4477             if (height_label > rectHeight)
4478                 height_label = rectHeight;
4479
4480             if (rect_x > m_rowLabelWidth)
4481             {
4482                 x = rect_x - m_rowLabelWidth;
4483                 width_cell = rectWidth;
4484             }
4485             else
4486             {
4487                 x = 0;
4488                 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
4489             }
4490
4491             if (rect_y > m_colLabelHeight)
4492             {
4493                 y = rect_y - m_colLabelHeight;
4494                 height_cell = rectHeight;
4495             }
4496             else
4497             {
4498                 y = 0;
4499                 height_cell = rectHeight - (m_colLabelHeight - rect_y);
4500             }
4501
4502             // Paint corner label part intersecting rect.
4503             if ( width_label > 0 && height_label > 0 )
4504             {
4505                 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
4506                 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
4507             }
4508
4509             // Paint col labels part intersecting rect.
4510             if ( width_cell > 0 && height_label > 0 )
4511             {
4512                 wxRect anotherrect(x, rect_y, width_cell, height_label);
4513                 m_colWindow->Refresh(eraseb, &anotherrect);
4514             }
4515
4516             // Paint row labels part intersecting rect.
4517             if ( width_label > 0 && height_cell > 0 )
4518             {
4519                 wxRect anotherrect(rect_x, y, width_label, height_cell);
4520                 m_rowLabelWin->Refresh(eraseb, &anotherrect);
4521             }
4522
4523             // Paint cell area part intersecting rect.
4524             if ( width_cell > 0 && height_cell > 0 )
4525             {
4526                 wxRect anotherrect(x, y, width_cell, height_cell);
4527                 m_gridWin->Refresh(eraseb, &anotherrect);
4528             }
4529         }
4530         else
4531         {
4532             m_cornerLabelWin->Refresh(eraseb, NULL);
4533             m_colWindow->Refresh(eraseb, NULL);
4534             m_rowLabelWin->Refresh(eraseb, NULL);
4535             m_gridWin->Refresh(eraseb, NULL);
4536         }
4537     }
4538 }
4539
4540 void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
4541 {
4542     if (m_targetWindow != this) // check whether initialisation has been done
4543     {
4544         // reposition our children windows
4545         CalcWindowSizes();
4546     }
4547 }
4548
4549 void wxGrid::OnKeyDown( wxKeyEvent& event )
4550 {
4551     if ( m_inOnKeyDown )
4552     {
4553         // shouldn't be here - we are going round in circles...
4554         //
4555         wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
4556     }
4557
4558     m_inOnKeyDown = true;
4559
4560     // propagate the event up and see if it gets processed
4561     wxWindow *parent = GetParent();
4562     wxKeyEvent keyEvt( event );
4563     keyEvt.SetEventObject( parent );
4564
4565     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
4566     {
4567         if (GetLayoutDirection() == wxLayout_RightToLeft)
4568         {
4569             if (event.GetKeyCode() == WXK_RIGHT)
4570                 event.m_keyCode = WXK_LEFT;
4571             else if (event.GetKeyCode() == WXK_LEFT)
4572                 event.m_keyCode = WXK_RIGHT;
4573         }
4574
4575         // try local handlers
4576         switch ( event.GetKeyCode() )
4577         {
4578             case WXK_UP:
4579                 if ( event.ControlDown() )
4580                     MoveCursorUpBlock( event.ShiftDown() );
4581                 else
4582                     MoveCursorUp( event.ShiftDown() );
4583                 break;
4584
4585             case WXK_DOWN:
4586                 if ( event.ControlDown() )
4587                     MoveCursorDownBlock( event.ShiftDown() );
4588                 else
4589                     MoveCursorDown( event.ShiftDown() );
4590                 break;
4591
4592             case WXK_LEFT:
4593                 if ( event.ControlDown() )
4594                     MoveCursorLeftBlock( event.ShiftDown() );
4595                 else
4596                     MoveCursorLeft( event.ShiftDown() );
4597                 break;
4598
4599             case WXK_RIGHT:
4600                 if ( event.ControlDown() )
4601                     MoveCursorRightBlock( event.ShiftDown() );
4602                 else
4603                     MoveCursorRight( event.ShiftDown() );
4604                 break;
4605
4606             case WXK_RETURN:
4607             case WXK_NUMPAD_ENTER:
4608                 if ( event.ControlDown() )
4609                 {
4610                     event.Skip();  // to let the edit control have the return
4611                 }
4612                 else
4613                 {
4614                     if ( GetGridCursorRow() < GetNumberRows()-1 )
4615                     {
4616                         MoveCursorDown( event.ShiftDown() );
4617                     }
4618                     else
4619                     {
4620                         // at the bottom of a column
4621                         DisableCellEditControl();
4622                     }
4623                 }
4624                 break;
4625
4626             case WXK_ESCAPE:
4627                 ClearSelection();
4628                 break;
4629
4630             case WXK_TAB:
4631                 if (event.ShiftDown())
4632                 {
4633                     if ( GetGridCursorCol() > 0 )
4634                     {
4635                         MoveCursorLeft( false );
4636                     }
4637                     else
4638                     {
4639                         // at left of grid
4640                         DisableCellEditControl();
4641                     }
4642                 }
4643                 else
4644                 {
4645                     if ( GetGridCursorCol() < GetNumberCols() - 1 )
4646                     {
4647                         MoveCursorRight( false );
4648                     }
4649                     else
4650                     {
4651                         // at right of grid
4652                         DisableCellEditControl();
4653                     }
4654                 }
4655                 break;
4656
4657             case WXK_HOME:
4658                 GoToCell(event.ControlDown() ? 0
4659                                              : m_currentCellCoords.GetRow(),
4660                          0);
4661                 break;
4662
4663             case WXK_END:
4664                 GoToCell(event.ControlDown() ? m_numRows - 1
4665                                              : m_currentCellCoords.GetRow(),
4666                          m_numCols - 1);
4667                 break;
4668
4669             case WXK_PAGEUP:
4670                 MovePageUp();
4671                 break;
4672
4673             case WXK_PAGEDOWN:
4674                 MovePageDown();
4675                 break;
4676
4677             case WXK_SPACE:
4678                 // Ctrl-Space selects the current column, Shift-Space -- the
4679                 // current row and Ctrl-Shift-Space -- everything
4680                 switch ( m_selection ? event.GetModifiers() : wxMOD_NONE )
4681                 {
4682                     case wxMOD_CONTROL:
4683                         m_selection->SelectCol(m_currentCellCoords.GetCol());
4684                         break;
4685
4686                     case wxMOD_SHIFT:
4687                         m_selection->SelectRow(m_currentCellCoords.GetRow());
4688                         break;
4689
4690                     case wxMOD_CONTROL | wxMOD_SHIFT:
4691                         m_selection->SelectBlock(0, 0,
4692                                                  m_numRows - 1, m_numCols - 1);
4693                         break;
4694
4695                     case wxMOD_NONE:
4696                         if ( !IsEditable() )
4697                         {
4698                             MoveCursorRight(false);
4699                             break;
4700                         }
4701                         //else: fall through
4702
4703                     default:
4704                         event.Skip();
4705                 }
4706                 break;
4707
4708             default:
4709                 event.Skip();
4710                 break;
4711         }
4712     }
4713
4714     m_inOnKeyDown = false;
4715 }
4716
4717 void wxGrid::OnKeyUp( wxKeyEvent& event )
4718 {
4719     // try local handlers
4720     //
4721     if ( event.GetKeyCode() == WXK_SHIFT )
4722     {
4723         if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
4724              m_selectedBlockBottomRight != wxGridNoCellCoords )
4725         {
4726             if ( m_selection )
4727             {
4728                 m_selection->SelectBlock(
4729                     m_selectedBlockTopLeft,
4730                     m_selectedBlockBottomRight,
4731                     event);
4732             }
4733         }
4734
4735         m_selectedBlockTopLeft = wxGridNoCellCoords;
4736         m_selectedBlockBottomRight = wxGridNoCellCoords;
4737         m_selectedBlockCorner = wxGridNoCellCoords;
4738     }
4739 }
4740
4741 void wxGrid::OnChar( wxKeyEvent& event )
4742 {
4743     // is it possible to edit the current cell at all?
4744     if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
4745     {
4746         // yes, now check whether the cells editor accepts the key
4747         int row = m_currentCellCoords.GetRow();
4748         int col = m_currentCellCoords.GetCol();
4749         wxGridCellAttr *attr = GetCellAttr(row, col);
4750         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
4751
4752         // <F2> is special and will always start editing, for
4753         // other keys - ask the editor itself
4754         if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
4755              || editor->IsAcceptedKey(event) )
4756         {
4757             // ensure cell is visble
4758             MakeCellVisible(row, col);
4759             EnableCellEditControl();
4760
4761             // a problem can arise if the cell is not completely
4762             // visible (even after calling MakeCellVisible the
4763             // control is not created and calling StartingKey will
4764             // crash the app
4765             if ( event.GetKeyCode() != WXK_F2 && editor->IsCreated() && m_cellEditCtrlEnabled )
4766                 editor->StartingKey(event);
4767         }
4768         else
4769         {
4770             event.Skip();
4771         }
4772
4773         editor->DecRef();
4774         attr->DecRef();
4775     }
4776     else
4777     {
4778         event.Skip();
4779     }
4780 }
4781
4782 void wxGrid::OnEraseBackground(wxEraseEvent&)
4783 {
4784 }
4785
4786 bool wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
4787 {
4788     if ( SendEvent(wxEVT_GRID_SELECT_CELL, coords) == -1 )
4789     {
4790         // the event has been vetoed - do nothing
4791         return false;
4792     }
4793
4794 #if !defined(__WXMAC__)
4795     wxClientDC dc( m_gridWin );
4796     PrepareDC( dc );
4797 #endif
4798
4799     if ( m_currentCellCoords != wxGridNoCellCoords )
4800     {
4801         DisableCellEditControl();
4802
4803         if ( IsVisible( m_currentCellCoords, false ) )
4804         {
4805             wxRect r;
4806             r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
4807             if ( !m_gridLinesEnabled )
4808             {
4809                 r.x--;
4810                 r.y--;
4811                 r.width++;
4812                 r.height++;
4813             }
4814
4815             wxGridCellCoordsArray cells = CalcCellsExposed( r );
4816
4817             // Otherwise refresh redraws the highlight!
4818             m_currentCellCoords = coords;
4819
4820 #if defined(__WXMAC__)
4821             m_gridWin->Refresh(true /*, & r */);
4822 #else
4823             DrawGridCellArea( dc, cells );
4824             DrawAllGridLines( dc, r );
4825 #endif
4826         }
4827     }
4828
4829     m_currentCellCoords = coords;
4830
4831     wxGridCellAttr *attr = GetCellAttr( coords );
4832 #if !defined(__WXMAC__)
4833     DrawCellHighlight( dc, attr );
4834 #endif
4835     attr->DecRef();
4836
4837     return true;
4838 }
4839
4840 void
4841 wxGrid::UpdateBlockBeingSelected(int topRow, int leftCol,
4842                                  int bottomRow, int rightCol)
4843 {
4844     MakeCellVisible(m_selectedBlockCorner);
4845     m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
4846
4847     if ( m_selection )
4848     {
4849         switch ( m_selection->GetSelectionMode() )
4850         {
4851             default:
4852                 wxFAIL_MSG( "unknown selection mode" );
4853                 // fall through
4854
4855             case wxGridSelectCells:
4856                 // arbitrary blocks selection allowed so just use the cell
4857                 // coordinates as is
4858                 break;
4859
4860             case wxGridSelectRows:
4861                 // only full rows selection allowd, ensure that we do select
4862                 // full rows
4863                 leftCol = 0;
4864                 rightCol = GetNumberCols() - 1;
4865                 break;
4866
4867             case wxGridSelectColumns:
4868                 // same as above but for columns
4869                 topRow = 0;
4870                 bottomRow = GetNumberRows() - 1;
4871                 break;
4872
4873             case wxGridSelectRowsOrColumns:
4874                 // in this mode we can select only full rows or full columns so
4875                 // it doesn't make sense to select blocks at all (and we can't
4876                 // extend the block because there is no preferred direction, we
4877                 // could only extend it to cover the entire grid but this is
4878                 // not useful)
4879                 return;
4880         }
4881     }
4882
4883     EnsureFirstLessThanSecond(topRow, bottomRow);
4884     EnsureFirstLessThanSecond(leftCol, rightCol);
4885
4886     wxGridCellCoords updateTopLeft = wxGridCellCoords(topRow, leftCol),
4887                      updateBottomRight = wxGridCellCoords(bottomRow, rightCol);
4888
4889     // First the case that we selected a completely new area
4890     if ( m_selectedBlockTopLeft == wxGridNoCellCoords ||
4891          m_selectedBlockBottomRight == wxGridNoCellCoords )
4892     {
4893         wxRect rect;
4894         rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
4895                                   wxGridCellCoords ( bottomRow, rightCol ) );
4896         m_gridWin->Refresh( false, &rect );
4897     }
4898
4899     // Now handle changing an existing selection area.
4900     else if ( m_selectedBlockTopLeft != updateTopLeft ||
4901               m_selectedBlockBottomRight != updateBottomRight )
4902     {
4903         // Compute two optimal update rectangles:
4904         // Either one rectangle is a real subset of the
4905         // other, or they are (almost) disjoint!
4906         wxRect  rect[4];
4907         bool    need_refresh[4];
4908         need_refresh[0] =
4909         need_refresh[1] =
4910         need_refresh[2] =
4911         need_refresh[3] = false;
4912         int     i;
4913
4914         // Store intermediate values
4915         wxCoord oldLeft = m_selectedBlockTopLeft.GetCol();
4916         wxCoord oldTop = m_selectedBlockTopLeft.GetRow();
4917         wxCoord oldRight = m_selectedBlockBottomRight.GetCol();
4918         wxCoord oldBottom = m_selectedBlockBottomRight.GetRow();
4919
4920         // Determine the outer/inner coordinates.
4921         EnsureFirstLessThanSecond(oldLeft, leftCol);
4922         EnsureFirstLessThanSecond(oldTop, topRow);
4923         EnsureFirstLessThanSecond(rightCol, oldRight);
4924         EnsureFirstLessThanSecond(bottomRow, oldBottom);
4925
4926         // Now, either the stuff marked old is the outer
4927         // rectangle or we don't have a situation where one
4928         // is contained in the other.
4929
4930         if ( oldLeft < leftCol )
4931         {
4932             // Refresh the newly selected or deselected
4933             // area to the left of the old or new selection.
4934             need_refresh[0] = true;
4935             rect[0] = BlockToDeviceRect(
4936                 wxGridCellCoords( oldTop,  oldLeft ),
4937                 wxGridCellCoords( oldBottom, leftCol - 1 ) );
4938         }
4939
4940         if ( oldTop < topRow )
4941         {
4942             // Refresh the newly selected or deselected
4943             // area above the old or new selection.
4944             need_refresh[1] = true;
4945             rect[1] = BlockToDeviceRect(
4946                 wxGridCellCoords( oldTop, leftCol ),
4947                 wxGridCellCoords( topRow - 1, rightCol ) );
4948         }
4949
4950         if ( oldRight > rightCol )
4951         {
4952             // Refresh the newly selected or deselected
4953             // area to the right of the old or new selection.
4954             need_refresh[2] = true;
4955             rect[2] = BlockToDeviceRect(
4956                 wxGridCellCoords( oldTop, rightCol + 1 ),
4957                 wxGridCellCoords( oldBottom, oldRight ) );
4958         }
4959
4960         if ( oldBottom > bottomRow )
4961         {
4962             // Refresh the newly selected or deselected
4963             // area below the old or new selection.
4964             need_refresh[3] = true;
4965             rect[3] = BlockToDeviceRect(
4966                 wxGridCellCoords( bottomRow + 1, leftCol ),
4967                 wxGridCellCoords( oldBottom, rightCol ) );
4968         }
4969
4970         // various Refresh() calls
4971         for (i = 0; i < 4; i++ )
4972             if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
4973                 m_gridWin->Refresh( false, &(rect[i]) );
4974     }
4975
4976     // change selection
4977     m_selectedBlockTopLeft = updateTopLeft;
4978     m_selectedBlockBottomRight = updateBottomRight;
4979 }
4980
4981 //
4982 // ------ functions to get/send data (see also public functions)
4983 //
4984
4985 bool wxGrid::GetModelValues()
4986 {
4987     // Hide the editor, so it won't hide a changed value.
4988     HideCellEditControl();
4989
4990     if ( m_table )
4991     {
4992         // all we need to do is repaint the grid
4993         //
4994         m_gridWin->Refresh();
4995         return true;
4996     }
4997
4998     return false;
4999 }
5000
5001 bool wxGrid::SetModelValues()
5002 {
5003     int row, col;
5004
5005     // Disable the editor, so it won't hide a changed value.
5006     // Do we also want to save the current value of the editor first?
5007     // I think so ...
5008     DisableCellEditControl();
5009
5010     if ( m_table )
5011     {
5012         for ( row = 0; row < m_numRows; row++ )
5013         {
5014             for ( col = 0; col < m_numCols; col++ )
5015             {
5016                 m_table->SetValue( row, col, GetCellValue(row, col) );
5017             }
5018         }
5019
5020         return true;
5021     }
5022
5023     return false;
5024 }
5025
5026 // Note - this function only draws cells that are in the list of
5027 // exposed cells (usually set from the update region by
5028 // CalcExposedCells)
5029 //
5030 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
5031 {
5032     if ( !m_numRows || !m_numCols )
5033         return;
5034
5035     int i, numCells = cells.GetCount();
5036     int row, col, cell_rows, cell_cols;
5037     wxGridCellCoordsArray redrawCells;
5038
5039     for ( i = numCells - 1; i >= 0; i-- )
5040     {
5041         row = cells[i].GetRow();
5042         col = cells[i].GetCol();
5043         GetCellSize( row, col, &cell_rows, &cell_cols );
5044
5045         // If this cell is part of a multicell block, find owner for repaint
5046         if ( cell_rows <= 0 || cell_cols <= 0 )
5047         {
5048             wxGridCellCoords cell( row + cell_rows, col + cell_cols );
5049             bool marked = false;
5050             for ( int j = 0; j < numCells; j++ )
5051             {
5052                 if ( cell == cells[j] )
5053                 {
5054                     marked = true;
5055                     break;
5056                 }
5057             }
5058
5059             if (!marked)
5060             {
5061                 int count = redrawCells.GetCount();
5062                 for (int j = 0; j < count; j++)
5063                 {
5064                     if ( cell == redrawCells[j] )
5065                     {
5066                         marked = true;
5067                         break;
5068                     }
5069                 }
5070
5071                 if (!marked)
5072                     redrawCells.Add( cell );
5073             }
5074
5075             // don't bother drawing this cell
5076             continue;
5077         }
5078
5079         // If this cell is empty, find cell to left that might want to overflow
5080         if (m_table && m_table->IsEmptyCell(row, col))
5081         {
5082             for ( int l = 0; l < cell_rows; l++ )
5083             {
5084                 // find a cell in this row to leave already marked for repaint
5085                 int left = col;
5086                 for (int k = 0; k < int(redrawCells.GetCount()); k++)
5087                     if ((redrawCells[k].GetCol() < left) &&
5088                         (redrawCells[k].GetRow() == row))
5089                     {
5090                         left = redrawCells[k].GetCol();
5091                     }
5092
5093                 if (left == col)
5094                     left = 0; // oh well
5095
5096                 for (int j = col - 1; j >= left; j--)
5097                 {
5098                     if (!m_table->IsEmptyCell(row + l, j))
5099                     {
5100                         if (GetCellOverflow(row + l, j))
5101                         {
5102                             wxGridCellCoords cell(row + l, j);
5103                             bool marked = false;
5104
5105                             for (int k = 0; k < numCells; k++)
5106                             {
5107                                 if ( cell == cells[k] )
5108                                 {
5109                                     marked = true;
5110                                     break;
5111                                 }
5112                             }
5113
5114                             if (!marked)
5115                             {
5116                                 int count = redrawCells.GetCount();
5117                                 for (int k = 0; k < count; k++)
5118                                 {
5119                                     if ( cell == redrawCells[k] )
5120                                     {
5121                                         marked = true;
5122                                         break;
5123                                     }
5124                                 }
5125                                 if (!marked)
5126                                     redrawCells.Add( cell );
5127                             }
5128                         }
5129                         break;
5130                     }
5131                 }
5132             }
5133         }
5134
5135         DrawCell( dc, cells[i] );
5136     }
5137
5138     numCells = redrawCells.GetCount();
5139
5140     for ( i = numCells - 1; i >= 0; i-- )
5141     {
5142         DrawCell( dc, redrawCells[i] );
5143     }
5144 }
5145
5146 void wxGrid::DrawGridSpace( wxDC& dc )
5147 {
5148   int cw, ch;
5149   m_gridWin->GetClientSize( &cw, &ch );
5150
5151   int right, bottom;
5152   CalcUnscrolledPosition( cw, ch, &right, &bottom );
5153
5154   int rightCol = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) : 0;
5155   int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
5156
5157   if ( right > rightCol || bottom > bottomRow )
5158   {
5159       int left, top;
5160       CalcUnscrolledPosition( 0, 0, &left, &top );
5161
5162       dc.SetBrush(GetDefaultCellBackgroundColour());
5163       dc.SetPen( *wxTRANSPARENT_PEN );
5164
5165       if ( right > rightCol )
5166       {
5167           dc.DrawRectangle( rightCol, top, right - rightCol, ch );
5168       }
5169
5170       if ( bottom > bottomRow )
5171       {
5172           dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow );
5173       }
5174   }
5175 }
5176
5177 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
5178 {
5179     int row = coords.GetRow();
5180     int col = coords.GetCol();
5181
5182     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5183         return;
5184
5185     // we draw the cell border ourselves
5186     wxGridCellAttr* attr = GetCellAttr(row, col);
5187
5188     bool isCurrent = coords == m_currentCellCoords;
5189
5190     wxRect rect = CellToRect( row, col );
5191
5192     // if the editor is shown, we should use it and not the renderer
5193     // Note: However, only if it is really _shown_, i.e. not hidden!
5194     if ( isCurrent && IsCellEditControlShown() )
5195     {
5196         // NB: this "#if..." is temporary and fixes a problem where the
5197         // edit control is erased by this code after being rendered.
5198         // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
5199         // implicitly, causing this out-of order render.
5200 #if !defined(__WXMAC__)
5201         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5202         editor->PaintBackground(rect, attr);
5203         editor->DecRef();
5204 #endif
5205     }
5206     else
5207     {
5208         // but all the rest is drawn by the cell renderer and hence may be customized
5209         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
5210         renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
5211         renderer->DecRef();
5212     }
5213
5214     attr->DecRef();
5215 }
5216
5217 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
5218 {
5219     // don't show highlight when the grid doesn't have focus
5220     if ( !HasFocus() )
5221         return;
5222
5223     int row = m_currentCellCoords.GetRow();
5224     int col = m_currentCellCoords.GetCol();
5225
5226     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5227         return;
5228
5229     wxRect rect = CellToRect(row, col);
5230
5231     // hmmm... what could we do here to show that the cell is disabled?
5232     // for now, I just draw a thinner border than for the other ones, but
5233     // it doesn't look really good
5234
5235     int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
5236
5237     if (penWidth > 0)
5238     {
5239         // The center of the drawn line is where the position/width/height of
5240         // the rectangle is actually at (on wxMSW at least), so the
5241         // size of the rectangle is reduced to compensate for the thickness of
5242         // the line. If this is too strange on non-wxMSW platforms then
5243         // please #ifdef this appropriately.
5244         rect.x += penWidth / 2;
5245         rect.y += penWidth / 2;
5246         rect.width -= penWidth - 1;
5247         rect.height -= penWidth - 1;
5248
5249         // Now draw the rectangle
5250         // use the cellHighlightColour if the cell is inside a selection, this
5251         // will ensure the cell is always visible.
5252         dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground
5253                                                : m_cellHighlightColour,
5254                         penWidth));
5255         dc.SetBrush(*wxTRANSPARENT_BRUSH);
5256         dc.DrawRectangle(rect);
5257     }
5258 }
5259
5260 wxPen wxGrid::GetDefaultGridLinePen()
5261 {
5262     return wxPen(GetGridLineColour());
5263 }
5264
5265 wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
5266 {
5267     return GetDefaultGridLinePen();
5268 }
5269
5270 wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
5271 {
5272     return GetDefaultGridLinePen();
5273 }
5274
5275 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
5276 {
5277     int row = coords.GetRow();
5278     int col = coords.GetCol();
5279     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5280         return;
5281
5282
5283     wxRect rect = CellToRect( row, col );
5284
5285     // right hand border
5286     dc.SetPen( GetColGridLinePen(col) );
5287     dc.DrawLine( rect.x + rect.width, rect.y,
5288                  rect.x + rect.width, rect.y + rect.height + 1 );
5289
5290     // bottom border
5291     dc.SetPen( GetRowGridLinePen(row) );
5292     dc.DrawLine( rect.x, rect.y + rect.height,
5293                  rect.x + rect.width, rect.y + rect.height);
5294 }
5295
5296 void wxGrid::DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells)
5297 {
5298     // This if block was previously in wxGrid::OnPaint but that doesn't
5299     // seem to get called under wxGTK - MB
5300     //
5301     if ( m_currentCellCoords == wxGridNoCellCoords &&
5302          m_numRows && m_numCols )
5303     {
5304         m_currentCellCoords.Set(0, 0);
5305     }
5306
5307     if ( IsCellEditControlShown() )
5308     {
5309         // don't show highlight when the edit control is shown
5310         return;
5311     }
5312
5313     // if the active cell was repainted, repaint its highlight too because it
5314     // might have been damaged by the grid lines
5315     size_t count = cells.GetCount();
5316     for ( size_t n = 0; n < count; n++ )
5317     {
5318         wxGridCellCoords cell = cells[n];
5319
5320         // If we are using attributes, then we may have just exposed another
5321         // cell in a partially-visible merged cluster of cells. If the "anchor"
5322         // (upper left) cell of this merged cluster is the cell indicated by
5323         // m_currentCellCoords, then we need to refresh the cell highlight even
5324         // though the "anchor" itself is not part of our update segment.
5325         if ( CanHaveAttributes() )
5326         {
5327             int rows = 0,
5328                 cols = 0;
5329             GetCellSize(cell.GetRow(), cell.GetCol(), &rows, &cols);
5330
5331             if ( rows < 0 )
5332                 cell.SetRow(cell.GetRow() + rows);
5333
5334             if ( cols < 0 )
5335                 cell.SetCol(cell.GetCol() + cols);
5336         }
5337
5338         if ( cell == m_currentCellCoords )
5339         {
5340             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5341             DrawCellHighlight(dc, attr);
5342             attr->DecRef();
5343
5344             break;
5345         }
5346     }
5347 }
5348
5349 // Used by wxGrid::Render() to draw the grid lines only for the cells in the
5350 // specified range.
5351 void
5352 wxGrid::DrawRangeGridLines(wxDC& dc,
5353                            const wxRegion& reg,
5354                            const wxGridCellCoords& topLeft,
5355                            const wxGridCellCoords& bottomRight)
5356 {
5357     if ( !m_gridLinesEnabled )
5358          return;
5359
5360     int top, left, width, height;
5361     reg.GetBox( left, top, width, height );
5362
5363     // create a clipping region
5364     wxRegion clippedcells( dc.LogicalToDeviceX( left ),
5365                            dc.LogicalToDeviceY( top ),
5366                            dc.LogicalToDeviceXRel( width ),
5367                            dc.LogicalToDeviceYRel( height ) );
5368
5369     // subtract multi cell span area from clipping region for lines
5370     wxRect rect;
5371     for ( int row = topLeft.GetRow(); row <= bottomRight.GetRow(); row++ )
5372     {
5373         for ( int col = topLeft.GetCol(); col <= bottomRight.GetCol(); col++ )
5374         {
5375             int cell_rows, cell_cols;
5376             GetCellSize( row, col, &cell_rows, &cell_cols );
5377             if ( cell_rows > 1 || cell_cols > 1 ) // multi cell
5378             {
5379                 rect = CellToRect( row, col );
5380                 // cater for scaling
5381                 // device origin already set in ::Render() for x, y
5382                 rect.x = dc.LogicalToDeviceX( rect.x );
5383                 rect.y = dc.LogicalToDeviceY( rect.y );
5384                 rect.width = dc.LogicalToDeviceXRel( rect.width );
5385                 rect.height = dc.LogicalToDeviceYRel( rect.height ) - 1;
5386                 clippedcells.Subtract( rect );
5387             }
5388             else if ( cell_rows < 0 || cell_cols < 0 ) // part of multicell
5389             {
5390                 rect = CellToRect( row + cell_rows, col + cell_cols );
5391                 rect.x = dc.LogicalToDeviceX( rect.x );
5392                 rect.y = dc.LogicalToDeviceY( rect.y );
5393                 rect.width = dc.LogicalToDeviceXRel( rect.width );
5394                 rect.height = dc.LogicalToDeviceYRel( rect.height ) - 1;
5395                 clippedcells.Subtract( rect );
5396             }
5397         }
5398     }
5399
5400     dc.SetDeviceClippingRegion( clippedcells );
5401
5402     DoDrawGridLines(dc,
5403                     top, left, top + height, left + width,
5404                     topLeft.GetRow(), topLeft.GetCol(),
5405                     bottomRight.GetRow(), bottomRight.GetCol());
5406
5407     dc.DestroyClippingRegion();
5408 }
5409
5410 // This is used to redraw all grid lines e.g. when the grid line colour
5411 // has been changed
5412 //
5413 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
5414 {
5415     if ( !m_gridLinesEnabled )
5416          return;
5417
5418     int top, bottom, left, right;
5419
5420     int cw, ch;
5421     m_gridWin->GetClientSize(&cw, &ch);
5422     CalcUnscrolledPosition( 0, 0, &left, &top );
5423     CalcUnscrolledPosition( cw, ch, &right, &bottom );
5424
5425     // avoid drawing grid lines past the last row and col
5426     if ( m_gridLinesClipHorz )
5427     {
5428         if ( !m_numCols )
5429             return;
5430
5431         const int lastColRight = GetColRight(GetColAt(m_numCols - 1));
5432         if ( right > lastColRight )
5433             right = lastColRight;
5434     }
5435
5436     if ( m_gridLinesClipVert )
5437     {
5438         if ( !m_numRows )
5439             return;
5440
5441         const int lastRowBottom = GetRowBottom(m_numRows - 1);
5442         if ( bottom > lastRowBottom )
5443             bottom = lastRowBottom;
5444     }
5445
5446     // no gridlines inside multicells, clip them out
5447     int leftCol = GetColPos( internalXToCol(left) );
5448     int topRow = internalYToRow(top);
5449     int rightCol = GetColPos( internalXToCol(right) );
5450     int bottomRow = internalYToRow(bottom);
5451
5452     wxRegion clippedcells(0, 0, cw, ch);
5453
5454     int cell_rows, cell_cols;
5455     wxRect rect;
5456
5457     for ( int j = topRow; j <= bottomRow; j++ )
5458     {
5459         for ( int colPos = leftCol; colPos <= rightCol; colPos++ )
5460         {
5461             int i = GetColAt( colPos );
5462
5463             GetCellSize( j, i, &cell_rows, &cell_cols );
5464             if ((cell_rows > 1) || (cell_cols > 1))
5465             {
5466                 rect = CellToRect(j,i);
5467                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5468                 clippedcells.Subtract(rect);
5469             }
5470             else if ((cell_rows < 0) || (cell_cols < 0))
5471             {
5472                 rect = CellToRect(j + cell_rows, i + cell_cols);
5473                 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5474                 clippedcells.Subtract(rect);
5475             }
5476         }
5477     }
5478
5479     dc.SetDeviceClippingRegion( clippedcells );
5480
5481     DoDrawGridLines(dc,
5482                     top, left, bottom, right,
5483                     topRow, leftCol, m_numRows, m_numCols);
5484
5485     dc.DestroyClippingRegion();
5486 }
5487
5488 void
5489 wxGrid::DoDrawGridLines(wxDC& dc,
5490                         int top, int left,
5491                         int bottom, int right,
5492                         int topRow, int leftCol,
5493                         int bottomRow, int rightCol)
5494 {
5495     // horizontal grid lines
5496     for ( int i = topRow; i < bottomRow; i++ )
5497     {
5498         int bot = GetRowBottom(i) - 1;
5499
5500         if ( bot > bottom )
5501             break;
5502
5503         if ( bot >= top )
5504         {
5505             dc.SetPen( GetRowGridLinePen(i) );
5506             dc.DrawLine( left, bot, right, bot );
5507         }
5508     }
5509
5510     // vertical grid lines
5511     for ( int colPos = leftCol; colPos < rightCol; colPos++ )
5512     {
5513         int i = GetColAt( colPos );
5514
5515         int colRight = GetColRight(i);
5516 #ifdef __WXGTK__
5517         if (GetLayoutDirection() != wxLayout_RightToLeft)
5518 #endif
5519             colRight--;
5520
5521         if ( colRight > right )
5522             break;
5523
5524         if ( colRight >= left )
5525         {
5526             dc.SetPen( GetColGridLinePen(i) );
5527             dc.DrawLine( colRight, top, colRight, bottom );
5528         }
5529     }
5530 }
5531
5532 void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
5533 {
5534     if ( !m_numRows )
5535         return;
5536
5537     const size_t numLabels = rows.GetCount();
5538     for ( size_t i = 0; i < numLabels; i++ )
5539     {
5540         DrawRowLabel( dc, rows[i] );
5541     }
5542 }
5543
5544 void wxGrid::DrawRowLabel( wxDC& dc, int row )
5545 {
5546     if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
5547         return;
5548
5549     wxGridCellAttrProvider * const
5550         attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5551
5552     // notice that an explicit static_cast is needed to avoid a compilation
5553     // error with VC7.1 which, for some reason, tries to instantiate (abstract)
5554     // wxGridRowHeaderRenderer class without it
5555     const wxGridRowHeaderRenderer&
5556         rend = attrProvider ? attrProvider->GetRowHeaderRenderer(row)
5557                             : static_cast<const wxGridRowHeaderRenderer&>
5558                                 (gs_defaultHeaderRenderers.rowRenderer);
5559
5560     wxRect rect(0, GetRowTop(row), m_rowLabelWidth, GetRowHeight(row));
5561     rend.DrawBorder(*this, dc, rect);
5562
5563     int hAlign, vAlign;
5564     GetRowLabelAlignment(&hAlign, &vAlign);
5565
5566     rend.DrawLabel(*this, dc, GetRowLabelValue(row),
5567                    rect, hAlign, vAlign, wxHORIZONTAL);
5568 }
5569
5570 void wxGrid::UseNativeColHeader(bool native)
5571 {
5572     if ( native == m_useNativeHeader )
5573         return;
5574
5575     delete m_colWindow;
5576     m_useNativeHeader = native;
5577
5578     CreateColumnWindow();
5579
5580     if ( m_useNativeHeader )
5581         GetGridColHeader()->SetColumnCount(m_numCols);
5582     CalcWindowSizes();
5583 }
5584
5585 void wxGrid::SetUseNativeColLabels( bool native )
5586 {
5587     wxASSERT_MSG( !m_useNativeHeader,
5588                   "doesn't make sense when using native header" );
5589
5590     m_nativeColumnLabels = native;
5591     if (native)
5592     {
5593         int height = wxRendererNative::Get().GetHeaderButtonHeight( this );
5594         SetColLabelSize( height );
5595     }
5596
5597     GetColLabelWindow()->Refresh();
5598     m_cornerLabelWin->Refresh();
5599 }
5600
5601 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
5602 {
5603     if ( !m_numCols )
5604         return;
5605
5606     const size_t numLabels = cols.GetCount();
5607     for ( size_t i = 0; i < numLabels; i++ )
5608     {
5609         DrawColLabel( dc, cols[i] );
5610     }
5611 }
5612
5613 void wxGrid::DrawCornerLabel(wxDC& dc)
5614 {
5615     wxRect rect(wxSize(m_rowLabelWidth, m_colLabelHeight));
5616
5617     if ( m_nativeColumnLabels )
5618     {
5619         rect.Deflate(1);
5620
5621         wxRendererNative::Get().DrawHeaderButton(m_cornerLabelWin, dc, rect, 0);
5622     }
5623     else
5624     {
5625         rect.width++;
5626         rect.height++;
5627
5628         wxGridCellAttrProvider * const
5629             attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5630         const wxGridCornerHeaderRenderer&
5631             rend = attrProvider ? attrProvider->GetCornerRenderer()
5632                                 : static_cast<wxGridCornerHeaderRenderer&>
5633                                     (gs_defaultHeaderRenderers.cornerRenderer);
5634
5635         rend.DrawBorder(*this, dc, rect);
5636     }
5637 }
5638
5639 void wxGrid::DrawColLabel(wxDC& dc, int col)
5640 {
5641     if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
5642         return;
5643
5644     int colLeft = GetColLeft(col);
5645
5646     wxRect rect(colLeft, 0, GetColWidth(col), m_colLabelHeight);
5647     wxGridCellAttrProvider * const
5648         attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5649     const wxGridColumnHeaderRenderer&
5650         rend = attrProvider ? attrProvider->GetColumnHeaderRenderer(col)
5651                             : static_cast<wxGridColumnHeaderRenderer&>
5652                                 (gs_defaultHeaderRenderers.colRenderer);
5653
5654     if ( m_nativeColumnLabels )
5655     {
5656         wxRendererNative::Get().DrawHeaderButton
5657                                 (
5658                                     GetColLabelWindow(),
5659                                     dc,
5660                                     rect,
5661                                     0,
5662                                     IsSortingBy(col)
5663                                         ? IsSortOrderAscending()
5664                                             ? wxHDR_SORT_ICON_UP
5665                                             : wxHDR_SORT_ICON_DOWN
5666                                         : wxHDR_SORT_ICON_NONE
5667                                 );
5668         rect.Deflate(2);
5669     }
5670     else
5671     {
5672         // It is reported that we need to erase the background to avoid display
5673         // artefacts, see #12055.
5674         wxDCBrushChanger setBrush(dc, m_colWindow->GetBackgroundColour());
5675         dc.DrawRectangle(rect);
5676
5677         rend.DrawBorder(*this, dc, rect);
5678     }
5679
5680     int hAlign, vAlign;
5681     GetColLabelAlignment(&hAlign, &vAlign);
5682     const int orient = GetColLabelTextOrientation();
5683
5684     rend.DrawLabel(*this, dc, GetColLabelValue(col), rect, hAlign, vAlign, orient);
5685 }
5686
5687 // TODO: these 2 functions should be replaced with wxDC::DrawLabel() to which
5688 //       we just have to add textOrientation support
5689 void wxGrid::DrawTextRectangle( wxDC& dc,
5690                                 const wxString& value,
5691                                 const wxRect& rect,
5692                                 int horizAlign,
5693                                 int vertAlign,
5694                                 int textOrientation ) const
5695 {
5696     wxArrayString lines;
5697
5698     StringToLines( value, lines );
5699
5700     DrawTextRectangle(dc, lines, rect, horizAlign, vertAlign, textOrientation);
5701 }
5702
5703 void wxGrid::DrawTextRectangle(wxDC& dc,
5704                                const wxArrayString& lines,
5705                                const wxRect& rect,
5706                                int horizAlign,
5707                                int vertAlign,
5708                                int textOrientation) const
5709 {
5710     if ( lines.empty() )
5711         return;
5712
5713     wxDCClipper clip(dc, rect);
5714
5715     long textWidth,
5716          textHeight;
5717
5718     if ( textOrientation == wxHORIZONTAL )
5719         GetTextBoxSize( dc, lines, &textWidth, &textHeight );
5720     else
5721         GetTextBoxSize( dc, lines, &textHeight, &textWidth );
5722
5723     int x = 0,
5724         y = 0;
5725     switch ( vertAlign )
5726     {
5727         case wxALIGN_BOTTOM:
5728             if ( textOrientation == wxHORIZONTAL )
5729                 y = rect.y + (rect.height - textHeight - 1);
5730             else
5731                 x = rect.x + rect.width - textWidth;
5732             break;
5733
5734         case wxALIGN_CENTRE:
5735             if ( textOrientation == wxHORIZONTAL )
5736                 y = rect.y + ((rect.height - textHeight) / 2);
5737             else
5738                 x = rect.x + ((rect.width - textWidth) / 2);
5739             break;
5740
5741         case wxALIGN_TOP:
5742         default:
5743             if ( textOrientation == wxHORIZONTAL )
5744                 y = rect.y + 1;
5745             else
5746                 x = rect.x + 1;
5747             break;
5748     }
5749
5750     // Align each line of a multi-line label
5751     size_t nLines = lines.GetCount();
5752     for ( size_t l = 0; l < nLines; l++ )
5753     {
5754         const wxString& line = lines[l];
5755
5756         if ( line.empty() )
5757         {
5758             *(textOrientation == wxHORIZONTAL ? &y : &x) += dc.GetCharHeight();
5759             continue;
5760         }
5761
5762         wxCoord lineWidth = 0,
5763              lineHeight = 0;
5764         dc.GetTextExtent(line, &lineWidth, &lineHeight);
5765
5766         switch ( horizAlign )
5767         {
5768             case wxALIGN_RIGHT:
5769                 if ( textOrientation == wxHORIZONTAL )
5770                     x = rect.x + (rect.width - lineWidth - 1);
5771                 else
5772                     y = rect.y + lineWidth + 1;
5773                 break;
5774
5775             case wxALIGN_CENTRE:
5776                 if ( textOrientation == wxHORIZONTAL )
5777                     x = rect.x + ((rect.width - lineWidth) / 2);
5778                 else
5779                     y = rect.y + rect.height - ((rect.height - lineWidth) / 2);
5780                 break;
5781
5782             case wxALIGN_LEFT:
5783             default:
5784                 if ( textOrientation == wxHORIZONTAL )
5785                     x = rect.x + 1;
5786                 else
5787                     y = rect.y + rect.height - 1;
5788                 break;
5789         }
5790
5791         if ( textOrientation == wxHORIZONTAL )
5792         {
5793             dc.DrawText( line, x, y );
5794             y += lineHeight;
5795         }
5796         else
5797         {
5798             dc.DrawRotatedText( line, x, y, 90.0 );
5799             x += lineHeight;
5800         }
5801     }
5802 }
5803
5804 // Split multi-line text up into an array of strings.
5805 // Any existing contents of the string array are preserved.
5806 //
5807 // TODO: refactor wxTextFile::Read() and reuse the same code from here
5808 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
5809 {
5810     int startPos = 0;
5811     int pos;
5812     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
5813     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
5814
5815     while ( startPos < (int)tVal.length() )
5816     {
5817         pos = tVal.Mid(startPos).Find( eol );
5818         if ( pos < 0 )
5819         {
5820             break;
5821         }
5822         else if ( pos == 0 )
5823         {
5824             lines.Add( wxEmptyString );
5825         }
5826         else
5827         {
5828             lines.Add( tVal.Mid(startPos, pos) );
5829         }
5830
5831         startPos += pos + 1;
5832     }
5833
5834     if ( startPos < (int)tVal.length() )
5835     {
5836         lines.Add( tVal.Mid( startPos ) );
5837     }
5838 }
5839
5840 void wxGrid::GetTextBoxSize( const wxDC& dc,
5841                              const wxArrayString& lines,
5842                              long *width, long *height ) const
5843 {
5844     wxCoord w = 0;
5845     wxCoord h = 0;
5846     wxCoord lineW = 0, lineH = 0;
5847
5848     size_t i;
5849     for ( i = 0; i < lines.GetCount(); i++ )
5850     {
5851         dc.GetTextExtent( lines[i], &lineW, &lineH );
5852         w = wxMax( w, lineW );
5853         h += lineH;
5854     }
5855
5856     *width = w;
5857     *height = h;
5858 }
5859
5860 //
5861 // ------ Batch processing.
5862 //
5863 void wxGrid::EndBatch()
5864 {
5865     if ( m_batchCount > 0 )
5866     {
5867         m_batchCount--;
5868         if ( !m_batchCount )
5869         {
5870             CalcDimensions();
5871             m_rowLabelWin->Refresh();
5872             m_colWindow->Refresh();
5873             m_cornerLabelWin->Refresh();
5874             m_gridWin->Refresh();
5875         }
5876     }
5877 }
5878
5879 // Use this, rather than wxWindow::Refresh(), to force an immediate
5880 // repainting of the grid. Has no effect if you are already inside a
5881 // BeginBatch / EndBatch block.
5882 //
5883 void wxGrid::ForceRefresh()
5884 {
5885     BeginBatch();
5886     EndBatch();
5887 }
5888
5889 bool wxGrid::Enable(bool enable)
5890 {
5891     if ( !wxScrolledWindow::Enable(enable) )
5892         return false;
5893
5894     // redraw in the new state
5895     m_gridWin->Refresh();
5896
5897     return true;
5898 }
5899
5900 //
5901 // ------ Edit control functions
5902 //
5903
5904 void wxGrid::EnableEditing( bool edit )
5905 {
5906     if ( edit != m_editable )
5907     {
5908         if (!edit)
5909             EnableCellEditControl(edit);
5910         m_editable = edit;
5911     }
5912 }
5913
5914 void wxGrid::EnableCellEditControl( bool enable )
5915 {
5916     if (! m_editable)
5917         return;
5918
5919     if ( enable != m_cellEditCtrlEnabled )
5920     {
5921         if ( enable )
5922         {
5923             if ( SendEvent(wxEVT_GRID_EDITOR_SHOWN) == -1 )
5924                 return;
5925
5926             // this should be checked by the caller!
5927             wxASSERT_MSG( CanEnableCellControl(), wxT("can't enable editing for this cell!") );
5928
5929             // do it before ShowCellEditControl()
5930             m_cellEditCtrlEnabled = enable;
5931
5932             ShowCellEditControl();
5933         }
5934         else
5935         {
5936             SendEvent(wxEVT_GRID_EDITOR_HIDDEN);
5937
5938             HideCellEditControl();
5939             SaveEditControlValue();
5940
5941             // do it after HideCellEditControl()
5942             m_cellEditCtrlEnabled = enable;
5943         }
5944     }
5945 }
5946
5947 bool wxGrid::IsCurrentCellReadOnly() const
5948 {
5949     wxGridCellAttr*
5950         attr = const_cast<wxGrid *>(this)->GetCellAttr(m_currentCellCoords);
5951     bool readonly = attr->IsReadOnly();
5952     attr->DecRef();
5953
5954     return readonly;
5955 }
5956
5957 bool wxGrid::CanEnableCellControl() const
5958 {
5959     return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
5960         !IsCurrentCellReadOnly();
5961 }
5962
5963 bool wxGrid::IsCellEditControlEnabled() const
5964 {
5965     // the cell edit control might be disable for all cells or just for the
5966     // current one if it's read only
5967     return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
5968 }
5969
5970 bool wxGrid::IsCellEditControlShown() const
5971 {
5972     bool isShown = false;
5973
5974     if ( m_cellEditCtrlEnabled )
5975     {
5976         int row = m_currentCellCoords.GetRow();
5977         int col = m_currentCellCoords.GetCol();
5978         wxGridCellAttr* attr = GetCellAttr(row, col);
5979         wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
5980         attr->DecRef();
5981
5982         if ( editor )
5983         {
5984             if ( editor->IsCreated() )
5985             {
5986                 isShown = editor->GetControl()->IsShown();
5987             }
5988
5989             editor->DecRef();
5990         }
5991     }
5992
5993     return isShown;
5994 }
5995
5996 void wxGrid::ShowCellEditControl()
5997 {
5998     if ( IsCellEditControlEnabled() )
5999     {
6000         if ( !IsVisible( m_currentCellCoords, false ) )
6001         {
6002             m_cellEditCtrlEnabled = false;
6003             return;
6004         }
6005         else
6006         {
6007             wxRect rect = CellToRect( m_currentCellCoords );
6008             int row = m_currentCellCoords.GetRow();
6009             int col = m_currentCellCoords.GetCol();
6010
6011             // if this is part of a multicell, find owner (topleft)
6012             int cell_rows, cell_cols;
6013             GetCellSize( row, col, &cell_rows, &cell_cols );
6014             if ( cell_rows <= 0 || cell_cols <= 0 )
6015             {
6016                 row += cell_rows;
6017                 col += cell_cols;
6018                 m_currentCellCoords.SetRow( row );
6019                 m_currentCellCoords.SetCol( col );
6020             }
6021
6022             // erase the highlight and the cell contents because the editor
6023             // might not cover the entire cell
6024             wxClientDC dc( m_gridWin );
6025             PrepareDC( dc );
6026             wxGridCellAttr* attr = GetCellAttr(row, col);
6027             dc.SetBrush(wxBrush(attr->GetBackgroundColour()));
6028             dc.SetPen(*wxTRANSPARENT_PEN);
6029             dc.DrawRectangle(rect);
6030
6031             // convert to scrolled coords
6032             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6033
6034             int nXMove = 0;
6035             if (rect.x < 0)
6036                 nXMove = rect.x;
6037
6038             // cell is shifted by one pixel
6039             // However, don't allow x or y to become negative
6040             // since the SetSize() method interprets that as
6041             // "don't change."
6042             if (rect.x > 0)
6043                 rect.x--;
6044             if (rect.y > 0)
6045                 rect.y--;
6046
6047             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6048             if ( !editor->IsCreated() )
6049             {
6050                 editor->Create(m_gridWin, wxID_ANY,
6051                                new wxGridCellEditorEvtHandler(this, editor));
6052
6053                 wxGridEditorCreatedEvent evt(GetId(),
6054                                              wxEVT_GRID_EDITOR_CREATED,
6055                                              this,
6056                                              row,
6057                                              col,
6058                                              editor->GetControl());
6059                 GetEventHandler()->ProcessEvent(evt);
6060             }
6061
6062             // resize editor to overflow into righthand cells if allowed
6063             int maxWidth = rect.width;
6064             wxString value = GetCellValue(row, col);
6065             if ( (value != wxEmptyString) && (attr->GetOverflow()) )
6066             {
6067                 int y;
6068                 GetTextExtent(value, &maxWidth, &y, NULL, NULL, &attr->GetFont());
6069                 if (maxWidth < rect.width)
6070                     maxWidth = rect.width;
6071             }
6072
6073             int client_right = m_gridWin->GetClientSize().GetWidth();
6074             if (rect.x + maxWidth > client_right)
6075                 maxWidth = client_right - rect.x;
6076
6077             if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
6078             {
6079                 GetCellSize( row, col, &cell_rows, &cell_cols );
6080                 // may have changed earlier
6081                 for (int i = col + cell_cols; i < m_numCols; i++)
6082                 {
6083                     int c_rows, c_cols;
6084                     GetCellSize( row, i, &c_rows, &c_cols );
6085
6086                     // looks weird going over a multicell
6087                     if (m_table->IsEmptyCell( row, i ) &&
6088                             (rect.width < maxWidth) && (c_rows == 1))
6089                     {
6090                         rect.width += GetColWidth( i );
6091                     }
6092                     else
6093                         break;
6094                 }
6095
6096                 if (rect.GetRight() > client_right)
6097                     rect.SetRight( client_right - 1 );
6098             }
6099
6100             editor->SetCellAttr( attr );
6101             editor->SetSize( rect );
6102             if (nXMove != 0)
6103                 editor->GetControl()->Move(
6104                     editor->GetControl()->GetPosition().x + nXMove,
6105                     editor->GetControl()->GetPosition().y );
6106             editor->Show( true, attr );
6107
6108             // recalc dimensions in case we need to
6109             // expand the scrolled window to account for editor
6110             CalcDimensions();
6111
6112             editor->BeginEdit(row, col, this);
6113             editor->SetCellAttr(NULL);
6114
6115             editor->DecRef();
6116             attr->DecRef();
6117         }
6118     }
6119 }
6120
6121 void wxGrid::HideCellEditControl()
6122 {
6123     if ( IsCellEditControlEnabled() )
6124     {
6125         int row = m_currentCellCoords.GetRow();
6126         int col = m_currentCellCoords.GetCol();
6127
6128         wxGridCellAttr *attr = GetCellAttr(row, col);
6129         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6130         const bool editorHadFocus = editor->GetControl()->HasFocus();
6131         editor->Show( false );
6132         editor->DecRef();
6133         attr->DecRef();
6134
6135         // return the focus to the grid itself if the editor had it
6136         //
6137         // note that we must not do this unconditionally to avoid stealing
6138         // focus from the window which just received it if we are hiding the
6139         // editor precisely because we lost focus
6140         if ( editorHadFocus )
6141             m_gridWin->SetFocus();
6142
6143         // refresh whole row to the right
6144         wxRect rect( CellToRect(row, col) );
6145         CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
6146         rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
6147
6148 #ifdef __WXMAC__
6149         // ensure that the pixels under the focus ring get refreshed as well
6150         rect.Inflate(10, 10);
6151 #endif
6152
6153         m_gridWin->Refresh( false, &rect );
6154     }
6155 }
6156
6157 void wxGrid::SaveEditControlValue()
6158 {
6159     if ( IsCellEditControlEnabled() )
6160     {
6161         int row = m_currentCellCoords.GetRow();
6162         int col = m_currentCellCoords.GetCol();
6163
6164         wxString oldval = GetCellValue(row, col);
6165
6166         wxGridCellAttr* attr = GetCellAttr(row, col);
6167         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6168
6169         wxString newval;
6170         bool changed = editor->EndEdit(row, col, this, oldval, &newval);
6171
6172         if ( changed && SendEvent(wxEVT_GRID_CELL_CHANGING, newval) != -1 )
6173         {
6174             editor->ApplyEdit(row, col, this);
6175
6176             // for compatibility reasons dating back to wx 2.8 when this event
6177             // was called wxEVT_GRID_CELL_CHANGE and wxEVT_GRID_CELL_CHANGING
6178             // didn't exist we allow vetoing this one too
6179             if ( SendEvent(wxEVT_GRID_CELL_CHANGED, oldval) == -1 )
6180             {
6181                 // Event has been vetoed, set the data back.
6182                 SetCellValue(row, col, oldval);
6183             }
6184         }
6185
6186         editor->DecRef();
6187         attr->DecRef();
6188     }
6189 }
6190
6191 //
6192 // ------ Grid location functions
6193 //  Note that all of these functions work with the logical coordinates of
6194 //  grid cells and labels so you will need to convert from device
6195 //  coordinates for mouse events etc.
6196 //
6197
6198 wxGridCellCoords wxGrid::XYToCell(int x, int y) const
6199 {
6200     int row = YToRow(y);
6201     int col = XToCol(x);
6202
6203     return row == -1 || col == -1 ? wxGridNoCellCoords
6204                                   : wxGridCellCoords(row, col);
6205 }
6206
6207 // compute row or column from some (unscrolled) coordinate value, using either
6208 // m_defaultRowHeight/m_defaultColWidth or binary search on array of
6209 // m_rowBottoms/m_colRights to do it quickly (linear search shouldn't be used
6210 // for large grids)
6211 int wxGrid::PosToLinePos(int coord,
6212                          bool clipToMinMax,
6213                          const wxGridOperations& oper) const
6214 {
6215     const int numLines = oper.GetNumberOfLines(this);
6216
6217     if ( coord < 0 )
6218         return clipToMinMax && numLines > 0 ? 0 : wxNOT_FOUND;
6219
6220     const int defaultLineSize = oper.GetDefaultLineSize(this);
6221     wxCHECK_MSG( defaultLineSize, -1, "can't have 0 default line size" );
6222
6223     int maxPos = coord / defaultLineSize,
6224         minPos = 0;
6225
6226     // check for the simplest case: if we have no explicit line sizes
6227     // configured, then we already know the line this position falls in
6228     const wxArrayInt& lineEnds = oper.GetLineEnds(this);
6229     if ( lineEnds.empty() )
6230     {
6231         if ( maxPos < numLines )
6232             return maxPos;
6233
6234         return clipToMinMax ? numLines - 1 : -1;
6235     }
6236
6237
6238     // adjust maxPos before starting the binary search
6239     if ( maxPos >= numLines )
6240     {
6241         maxPos = numLines  - 1;
6242     }
6243     else
6244     {
6245         if ( coord >= lineEnds[oper.GetLineAt(this, maxPos)])
6246         {
6247             minPos = maxPos;
6248             const int minDist = oper.GetMinimalAcceptableLineSize(this);
6249             if ( minDist )
6250                 maxPos = coord / minDist;
6251             else
6252                 maxPos = numLines - 1;
6253         }
6254
6255         if ( maxPos >= numLines )
6256             maxPos = numLines  - 1;
6257     }
6258
6259     // check if the position is beyond the last column
6260     const int lineAtMaxPos = oper.GetLineAt(this, maxPos);
6261     if ( coord >= lineEnds[lineAtMaxPos] )
6262         return clipToMinMax ? maxPos : -1;
6263
6264     // or before the first one
6265     const int lineAt0 = oper.GetLineAt(this, 0);
6266     if ( coord < lineEnds[lineAt0] )
6267         return 0;
6268
6269
6270     // finally do perform the binary search
6271     while ( minPos < maxPos )
6272     {
6273         wxCHECK_MSG( lineEnds[oper.GetLineAt(this, minPos)] <= coord &&
6274                         coord < lineEnds[oper.GetLineAt(this, maxPos)],
6275                      -1,
6276                      "wxGrid: internal error in PosToLinePos()" );
6277
6278         if ( coord >= lineEnds[oper.GetLineAt(this, maxPos - 1)] )
6279             return maxPos;
6280         else
6281             maxPos--;
6282
6283         const int median = minPos + (maxPos - minPos + 1) / 2;
6284         if ( coord < lineEnds[oper.GetLineAt(this, median)] )
6285             maxPos = median;
6286         else
6287             minPos = median;
6288     }
6289
6290     return maxPos;
6291 }
6292
6293 int
6294 wxGrid::PosToLine(int coord,
6295                   bool clipToMinMax,
6296                   const wxGridOperations& oper) const
6297 {
6298     int pos = PosToLinePos(coord, clipToMinMax, oper);
6299
6300     return pos == wxNOT_FOUND ? wxNOT_FOUND : oper.GetLineAt(this, pos);
6301 }
6302
6303 int wxGrid::YToRow(int y, bool clipToMinMax) const
6304 {
6305     return PosToLine(y, clipToMinMax, wxGridRowOperations());
6306 }
6307
6308 int wxGrid::XToCol(int x, bool clipToMinMax) const
6309 {
6310     return PosToLine(x, clipToMinMax, wxGridColumnOperations());
6311 }
6312
6313 int wxGrid::XToPos(int x) const
6314 {
6315     return PosToLinePos(x, true /* clip */, wxGridColumnOperations());
6316 }
6317
6318 // return the row number such that the y coord is near the edge of, or -1 if
6319 // not near an edge.
6320 //
6321 // notice that position can only possibly be near an edge if the row/column is
6322 // large enough to still allow for an "inner" area that is _not_ near the edge
6323 // (i.e., if the height/width is smaller than WXGRID_LABEL_EDGE_ZONE, pos will
6324 // _never_ be considered to be near the edge).
6325 int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
6326 {
6327     const int line = oper.PosToLine(this, pos, true);
6328
6329     if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )
6330     {
6331         // We know that we are in this line, test whether we are close enough
6332         // to start or end border, respectively.
6333         if ( abs(oper.GetLineEndPos(this, line) - pos) < WXGRID_LABEL_EDGE_ZONE )
6334             return line;
6335         else if ( line > 0 &&
6336                     pos - oper.GetLineStartPos(this,
6337                                                line) < WXGRID_LABEL_EDGE_ZONE )
6338         {
6339             return oper.GetLineBefore(this, line);
6340         }
6341     }
6342
6343     return -1;
6344 }
6345
6346 int wxGrid::YToEdgeOfRow(int y) const
6347 {
6348     return PosToEdgeOfLine(y, wxGridRowOperations());
6349 }
6350
6351 int wxGrid::XToEdgeOfCol(int x) const
6352 {
6353     return PosToEdgeOfLine(x, wxGridColumnOperations());
6354 }
6355
6356 wxRect wxGrid::CellToRect( int row, int col ) const
6357 {
6358     wxRect rect( -1, -1, -1, -1 );
6359
6360     if ( row >= 0 && row < m_numRows &&
6361          col >= 0 && col < m_numCols )
6362     {
6363         int i, cell_rows, cell_cols;
6364         rect.width = rect.height = 0;
6365         GetCellSize( row, col, &cell_rows, &cell_cols );
6366         // if negative then find multicell owner
6367         if (cell_rows < 0)
6368             row += cell_rows;
6369         if (cell_cols < 0)
6370              col += cell_cols;
6371         GetCellSize( row, col, &cell_rows, &cell_cols );
6372
6373         rect.x = GetColLeft(col);
6374         rect.y = GetRowTop(row);
6375         for (i=col; i < col + cell_cols; i++)
6376             rect.width += GetColWidth(i);
6377         for (i=row; i < row + cell_rows; i++)
6378             rect.height += GetRowHeight(i);
6379
6380         // if grid lines are enabled, then the area of the cell is a bit smaller
6381         if (m_gridLinesEnabled)
6382         {
6383             rect.width -= 1;
6384             rect.height -= 1;
6385         }
6386     }
6387
6388     return rect;
6389 }
6390
6391 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
6392 {
6393     // get the cell rectangle in logical coords
6394     //
6395     wxRect r( CellToRect( row, col ) );
6396
6397     // convert to device coords
6398     //
6399     int left, top, right, bottom;
6400     CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6401     CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6402
6403     // check against the client area of the grid window
6404     int cw, ch;
6405     m_gridWin->GetClientSize( &cw, &ch );
6406
6407     if ( wholeCellVisible )
6408     {
6409         // is the cell wholly visible ?
6410         return ( left >= 0 && right <= cw &&
6411                  top >= 0 && bottom <= ch );
6412     }
6413     else
6414     {
6415         // is the cell partly visible ?
6416         //
6417         return ( ((left >= 0 && left < cw) || (right > 0 && right <= cw)) &&
6418                  ((top >= 0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6419     }
6420 }
6421
6422 // make the specified cell location visible by doing a minimal amount
6423 // of scrolling
6424 //
6425 void wxGrid::MakeCellVisible( int row, int col )
6426 {
6427     int i;
6428     int xpos = -1, ypos = -1;
6429
6430     if ( row >= 0 && row < m_numRows &&
6431          col >= 0 && col < m_numCols )
6432     {
6433         // get the cell rectangle in logical coords
6434         wxRect r( CellToRect( row, col ) );
6435
6436         // convert to device coords
6437         int left, top, right, bottom;
6438         CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6439         CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6440
6441         int cw, ch;
6442         m_gridWin->GetClientSize( &cw, &ch );
6443
6444         if ( top < 0 )
6445         {
6446             ypos = r.GetTop();
6447         }
6448         else if ( bottom > ch )
6449         {
6450             int h = r.GetHeight();
6451             ypos = r.GetTop();
6452             for ( i = row - 1; i >= 0; i-- )
6453             {
6454                 int rowHeight = GetRowHeight(i);
6455                 if ( h + rowHeight > ch )
6456                     break;
6457
6458                 h += rowHeight;
6459                 ypos -= rowHeight;
6460             }
6461
6462             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6463             // have rounding errors (this is important, because if we do,
6464             // we might not scroll at all and some cells won't be redrawn)
6465             //
6466             // Sometimes GRID_SCROLL_LINE / 2 is not enough,
6467             // so just add a full scroll unit...
6468             ypos += m_yScrollPixelsPerLine;
6469         }
6470
6471         // special handling for wide cells - show always left part of the cell!
6472         // Otherwise, e.g. when stepping from row to row, it would jump between
6473         // left and right part of the cell on every step!
6474 //      if ( left < 0 )
6475         if ( left < 0 || (right - left) >= cw )
6476         {
6477             xpos = r.GetLeft();
6478         }
6479         else if ( right > cw )
6480         {
6481             // position the view so that the cell is on the right
6482             int x0, y0;
6483             CalcUnscrolledPosition(0, 0, &x0, &y0);
6484             xpos = x0 + (right - cw);
6485
6486             // see comment for ypos above
6487             xpos += m_xScrollPixelsPerLine;
6488         }
6489
6490         if ( xpos != -1 || ypos != -1 )
6491         {
6492             if ( xpos != -1 )
6493                 xpos /= m_xScrollPixelsPerLine;
6494             if ( ypos != -1 )
6495                 ypos /= m_yScrollPixelsPerLine;
6496             Scroll( xpos, ypos );
6497             AdjustScrollbars();
6498         }
6499     }
6500 }
6501
6502 //
6503 // ------ Grid cursor movement functions
6504 //
6505
6506 bool
6507 wxGrid::DoMoveCursor(bool expandSelection,
6508                      const wxGridDirectionOperations& diroper)
6509 {
6510     if ( m_currentCellCoords == wxGridNoCellCoords )
6511         return false;
6512
6513     if ( expandSelection )
6514     {
6515         wxGridCellCoords coords = m_selectedBlockCorner;
6516         if ( coords == wxGridNoCellCoords )
6517             coords = m_currentCellCoords;
6518
6519         if ( diroper.IsAtBoundary(coords) )
6520             return false;
6521
6522         diroper.Advance(coords);
6523
6524         UpdateBlockBeingSelected(m_currentCellCoords, coords);
6525     }
6526     else // don't expand selection
6527     {
6528         ClearSelection();
6529
6530         if ( diroper.IsAtBoundary(m_currentCellCoords) )
6531             return false;
6532
6533         wxGridCellCoords coords = m_currentCellCoords;
6534         diroper.Advance(coords);
6535
6536         GoToCell(coords);
6537     }
6538
6539     return true;
6540 }
6541
6542 bool wxGrid::MoveCursorUp(bool expandSelection)
6543 {
6544     return DoMoveCursor(expandSelection,
6545                         wxGridBackwardOperations(this, wxGridRowOperations()));
6546 }
6547
6548 bool wxGrid::MoveCursorDown(bool expandSelection)
6549 {
6550     return DoMoveCursor(expandSelection,
6551                         wxGridForwardOperations(this, wxGridRowOperations()));
6552 }
6553
6554 bool wxGrid::MoveCursorLeft(bool expandSelection)
6555 {
6556     return DoMoveCursor(expandSelection,
6557                         wxGridBackwardOperations(this, wxGridColumnOperations()));
6558 }
6559
6560 bool wxGrid::MoveCursorRight(bool expandSelection)
6561 {
6562     return DoMoveCursor(expandSelection,
6563                         wxGridForwardOperations(this, wxGridColumnOperations()));
6564 }
6565
6566 bool wxGrid::DoMoveCursorByPage(const wxGridDirectionOperations& diroper)
6567 {
6568     if ( m_currentCellCoords == wxGridNoCellCoords )
6569         return false;
6570
6571     if ( diroper.IsAtBoundary(m_currentCellCoords) )
6572         return false;
6573
6574     const int oldRow = m_currentCellCoords.GetRow();
6575     int newRow = diroper.MoveByPixelDistance(oldRow, m_gridWin->GetClientSize().y);
6576     if ( newRow == oldRow )
6577     {
6578         wxGridCellCoords coords(m_currentCellCoords);
6579         diroper.Advance(coords);
6580         newRow = coords.GetRow();
6581     }
6582
6583     GoToCell(newRow, m_currentCellCoords.GetCol());
6584
6585     return true;
6586 }
6587
6588 bool wxGrid::MovePageUp()
6589 {
6590     return DoMoveCursorByPage(
6591                 wxGridBackwardOperations(this, wxGridRowOperations()));
6592 }
6593
6594 bool wxGrid::MovePageDown()
6595 {
6596     return DoMoveCursorByPage(
6597                 wxGridForwardOperations(this, wxGridRowOperations()));
6598 }
6599
6600 // helper of DoMoveCursorByBlock(): advance the cell coordinates using diroper
6601 // until we find a non-empty cell or reach the grid end
6602 void
6603 wxGrid::AdvanceToNextNonEmpty(wxGridCellCoords& coords,
6604                               const wxGridDirectionOperations& diroper)
6605 {
6606     while ( !diroper.IsAtBoundary(coords) )
6607     {
6608         diroper.Advance(coords);
6609         if ( !m_table->IsEmpty(coords) )
6610             break;
6611     }
6612 }
6613
6614 bool
6615 wxGrid::DoMoveCursorByBlock(bool expandSelection,
6616                             const wxGridDirectionOperations& diroper)
6617 {
6618     if ( !m_table || m_currentCellCoords == wxGridNoCellCoords )
6619         return false;
6620
6621     if ( diroper.IsAtBoundary(m_currentCellCoords) )
6622         return false;
6623
6624     wxGridCellCoords coords(m_currentCellCoords);
6625     if ( m_table->IsEmpty(coords) )
6626     {
6627         // we are in an empty cell: find the next block of non-empty cells
6628         AdvanceToNextNonEmpty(coords, diroper);
6629     }
6630     else // current cell is not empty
6631     {
6632         diroper.Advance(coords);
6633         if ( m_table->IsEmpty(coords) )
6634         {
6635             // we started at the end of a block, find the next one
6636             AdvanceToNextNonEmpty(coords, diroper);
6637         }
6638         else // we're in a middle of a block
6639         {
6640             // go to the end of it, i.e. find the last cell before the next
6641             // empty one
6642             while ( !diroper.IsAtBoundary(coords) )
6643             {
6644                 wxGridCellCoords coordsNext(coords);
6645                 diroper.Advance(coordsNext);
6646                 if ( m_table->IsEmpty(coordsNext) )
6647                     break;
6648
6649                 coords = coordsNext;
6650             }
6651         }
6652     }
6653
6654     if ( expandSelection )
6655     {
6656         UpdateBlockBeingSelected(m_currentCellCoords, coords);
6657     }
6658     else
6659     {
6660         ClearSelection();
6661         GoToCell(coords);
6662     }
6663
6664     return true;
6665 }
6666
6667 bool wxGrid::MoveCursorUpBlock(bool expandSelection)
6668 {
6669     return DoMoveCursorByBlock(
6670                 expandSelection,
6671                 wxGridBackwardOperations(this, wxGridRowOperations())
6672            );
6673 }
6674
6675 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
6676 {
6677     return DoMoveCursorByBlock(
6678                 expandSelection,
6679                 wxGridForwardOperations(this, wxGridRowOperations())
6680            );
6681 }
6682
6683 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
6684 {
6685     return DoMoveCursorByBlock(
6686                 expandSelection,
6687                 wxGridBackwardOperations(this, wxGridColumnOperations())
6688            );
6689 }
6690
6691 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
6692 {
6693     return DoMoveCursorByBlock(
6694                 expandSelection,
6695                 wxGridForwardOperations(this, wxGridColumnOperations())
6696            );
6697 }
6698
6699 //
6700 // ------ Label values and formatting
6701 //
6702
6703 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
6704 {
6705     if ( horiz )
6706         *horiz = m_rowLabelHorizAlign;
6707     if ( vert )
6708         *vert  = m_rowLabelVertAlign;
6709 }
6710
6711 void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
6712 {
6713     if ( horiz )
6714         *horiz = m_colLabelHorizAlign;
6715     if ( vert )
6716         *vert  = m_colLabelVertAlign;
6717 }
6718
6719 int wxGrid::GetColLabelTextOrientation() const
6720 {
6721     return m_colLabelTextOrientation;
6722 }
6723
6724 wxString wxGrid::GetRowLabelValue( int row ) const
6725 {
6726     if ( m_table )
6727     {
6728         return m_table->GetRowLabelValue( row );
6729     }
6730     else
6731     {
6732         wxString s;
6733         s << row;
6734         return s;
6735     }
6736 }
6737
6738 wxString wxGrid::GetColLabelValue( int col ) const
6739 {
6740     if ( m_table )
6741     {
6742         return m_table->GetColLabelValue( col );
6743     }
6744     else
6745     {
6746         wxString s;
6747         s << col;
6748         return s;
6749     }
6750 }
6751
6752 void wxGrid::SetRowLabelSize( int width )
6753 {
6754     wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
6755
6756     if ( width == wxGRID_AUTOSIZE )
6757     {
6758         width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
6759     }
6760
6761     if ( width != m_rowLabelWidth )
6762     {
6763         if ( width == 0 )
6764         {
6765             m_rowLabelWin->Show( false );
6766             m_cornerLabelWin->Show( false );
6767         }
6768         else if ( m_rowLabelWidth == 0 )
6769         {
6770             m_rowLabelWin->Show( true );
6771             if ( m_colLabelHeight > 0 )
6772                 m_cornerLabelWin->Show( true );
6773         }
6774
6775         m_rowLabelWidth = width;
6776         CalcWindowSizes();
6777         wxScrolledWindow::Refresh( true );
6778     }
6779 }
6780
6781 void wxGrid::SetColLabelSize( int height )
6782 {
6783     wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
6784
6785     if ( height == wxGRID_AUTOSIZE )
6786     {
6787         height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
6788     }
6789
6790     if ( height != m_colLabelHeight )
6791     {
6792         if ( height == 0 )
6793         {
6794             m_colWindow->Show( false );
6795             m_cornerLabelWin->Show( false );
6796         }
6797         else if ( m_colLabelHeight == 0 )
6798         {
6799             m_colWindow->Show( true );
6800             if ( m_rowLabelWidth > 0 )
6801                 m_cornerLabelWin->Show( true );
6802         }
6803
6804         m_colLabelHeight = height;
6805         CalcWindowSizes();
6806         wxScrolledWindow::Refresh( true );
6807     }
6808 }
6809
6810 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
6811 {
6812     if ( m_labelBackgroundColour != colour )
6813     {
6814         m_labelBackgroundColour = colour;
6815         m_rowLabelWin->SetBackgroundColour( colour );
6816         m_colWindow->SetBackgroundColour( colour );
6817         m_cornerLabelWin->SetBackgroundColour( colour );
6818
6819         if ( !GetBatchCount() )
6820         {
6821             m_rowLabelWin->Refresh();
6822             m_colWindow->Refresh();
6823             m_cornerLabelWin->Refresh();
6824         }
6825     }
6826 }
6827
6828 void wxGrid::SetLabelTextColour( const wxColour& colour )
6829 {
6830     if ( m_labelTextColour != colour )
6831     {
6832         m_labelTextColour = colour;
6833         if ( !GetBatchCount() )
6834         {
6835             m_rowLabelWin->Refresh();
6836             m_colWindow->Refresh();
6837         }
6838     }
6839 }
6840
6841 void wxGrid::SetLabelFont( const wxFont& font )
6842 {
6843     m_labelFont = font;
6844     if ( !GetBatchCount() )
6845     {
6846         m_rowLabelWin->Refresh();
6847         m_colWindow->Refresh();
6848     }
6849 }
6850
6851 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
6852 {
6853     // allow old (incorrect) defs to be used
6854     switch ( horiz )
6855     {
6856         case wxLEFT:   horiz = wxALIGN_LEFT; break;
6857         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
6858         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6859     }
6860
6861     switch ( vert )
6862     {
6863         case wxTOP:    vert = wxALIGN_TOP;    break;
6864         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6865         case wxCENTRE: vert = wxALIGN_CENTRE; break;
6866     }
6867
6868     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6869     {
6870         m_rowLabelHorizAlign = horiz;
6871     }
6872
6873     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6874     {
6875         m_rowLabelVertAlign = vert;
6876     }
6877
6878     if ( !GetBatchCount() )
6879     {
6880         m_rowLabelWin->Refresh();
6881     }
6882 }
6883
6884 void wxGrid::SetColLabelAlignment( int horiz, int vert )
6885 {
6886     // allow old (incorrect) defs to be used
6887     switch ( horiz )
6888     {
6889         case wxLEFT:   horiz = wxALIGN_LEFT; break;
6890         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
6891         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6892     }
6893
6894     switch ( vert )
6895     {
6896         case wxTOP:    vert = wxALIGN_TOP;    break;
6897         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6898         case wxCENTRE: vert = wxALIGN_CENTRE; break;
6899     }
6900
6901     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6902     {
6903         m_colLabelHorizAlign = horiz;
6904     }
6905
6906     if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6907     {
6908         m_colLabelVertAlign = vert;
6909     }
6910
6911     if ( !GetBatchCount() )
6912     {
6913         m_colWindow->Refresh();
6914     }
6915 }
6916
6917 // Note: under MSW, the default column label font must be changed because it
6918 //       does not support vertical printing
6919 //
6920 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
6921 //                      pGrid->SetLabelFont(font);
6922 //                      pGrid->SetColLabelTextOrientation(wxVERTICAL);
6923 //
6924 void wxGrid::SetColLabelTextOrientation( int textOrientation )
6925 {
6926     if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
6927         m_colLabelTextOrientation = textOrientation;
6928
6929     if ( !GetBatchCount() )
6930         m_colWindow->Refresh();
6931 }
6932
6933 void wxGrid::SetRowLabelValue( int row, const wxString& s )
6934 {
6935     if ( m_table )
6936     {
6937         m_table->SetRowLabelValue( row, s );
6938         if ( !GetBatchCount() )
6939         {
6940             wxRect rect = CellToRect( row, 0 );
6941             if ( rect.height > 0 )
6942             {
6943                 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
6944                 rect.x = 0;
6945                 rect.width = m_rowLabelWidth;
6946                 m_rowLabelWin->Refresh( true, &rect );
6947             }
6948         }
6949     }
6950 }
6951
6952 void wxGrid::SetColLabelValue( int col, const wxString& s )
6953 {
6954     if ( m_table )
6955     {
6956         m_table->SetColLabelValue( col, s );
6957         if ( !GetBatchCount() )
6958         {
6959             if ( m_useNativeHeader )
6960             {
6961                 GetGridColHeader()->UpdateColumn(col);
6962             }
6963             else
6964             {
6965                 wxRect rect = CellToRect( 0, col );
6966                 if ( rect.width > 0 )
6967                 {
6968                     CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
6969                     rect.y = 0;
6970                     rect.height = m_colLabelHeight;
6971                     GetColLabelWindow()->Refresh( true, &rect );
6972                 }
6973             }
6974         }
6975     }
6976 }
6977
6978 void wxGrid::SetGridLineColour( const wxColour& colour )
6979 {
6980     if ( m_gridLineColour != colour )
6981     {
6982         m_gridLineColour = colour;
6983
6984         if ( GridLinesEnabled() )
6985             RedrawGridLines();
6986     }
6987 }
6988
6989 void wxGrid::SetCellHighlightColour( const wxColour& colour )
6990 {
6991     if ( m_cellHighlightColour != colour )
6992     {
6993         m_cellHighlightColour = colour;
6994
6995         wxClientDC dc( m_gridWin );
6996         PrepareDC( dc );
6997         wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6998         DrawCellHighlight(dc, attr);
6999         attr->DecRef();
7000     }
7001 }
7002
7003 void wxGrid::SetCellHighlightPenWidth(int width)
7004 {
7005     if (m_cellHighlightPenWidth != width)
7006     {
7007         m_cellHighlightPenWidth = width;
7008
7009         // Just redrawing the cell highlight is not enough since that won't
7010         // make any visible change if the thickness is getting smaller.
7011         int row = m_currentCellCoords.GetRow();
7012         int col = m_currentCellCoords.GetCol();
7013         if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7014             return;
7015
7016         wxRect rect = CellToRect(row, col);
7017         m_gridWin->Refresh(true, &rect);
7018     }
7019 }
7020
7021 void wxGrid::SetCellHighlightROPenWidth(int width)
7022 {
7023     if (m_cellHighlightROPenWidth != width)
7024     {
7025         m_cellHighlightROPenWidth = width;
7026
7027         // Just redrawing the cell highlight is not enough since that won't
7028         // make any visible change if the thickness is getting smaller.
7029         int row = m_currentCellCoords.GetRow();
7030         int col = m_currentCellCoords.GetCol();
7031         if ( row == -1 || col == -1 ||
7032                 GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
7033             return;
7034
7035         wxRect rect = CellToRect(row, col);
7036         m_gridWin->Refresh(true, &rect);
7037     }
7038 }
7039
7040 void wxGrid::RedrawGridLines()
7041 {
7042     // the lines will be redrawn when the window is thawn
7043     if ( GetBatchCount() )
7044         return;
7045
7046     if ( GridLinesEnabled() )
7047     {
7048         wxClientDC dc( m_gridWin );
7049         PrepareDC( dc );
7050         DrawAllGridLines( dc, wxRegion() );
7051     }
7052     else // remove the grid lines
7053     {
7054         m_gridWin->Refresh();
7055     }
7056 }
7057
7058 void wxGrid::EnableGridLines( bool enable )
7059 {
7060     if ( enable != m_gridLinesEnabled )
7061     {
7062         m_gridLinesEnabled = enable;
7063
7064         RedrawGridLines();
7065     }
7066 }
7067
7068 void wxGrid::DoClipGridLines(bool& var, bool clip)
7069 {
7070     if ( clip != var )
7071     {
7072         var = clip;
7073
7074         if ( GridLinesEnabled() )
7075             RedrawGridLines();
7076     }
7077 }
7078
7079 int wxGrid::GetDefaultRowSize() const
7080 {
7081     return m_defaultRowHeight;
7082 }
7083
7084 int wxGrid::GetRowSize( int row ) const
7085 {
7086     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, wxT("invalid row index") );
7087
7088     return GetRowHeight(row);
7089 }
7090
7091 int wxGrid::GetDefaultColSize() const
7092 {
7093     return m_defaultColWidth;
7094 }
7095
7096 int wxGrid::GetColSize( int col ) const
7097 {
7098     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, wxT("invalid column index") );
7099
7100     return GetColWidth(col);
7101 }
7102
7103 // ============================================================================
7104 // access to the grid attributes: each of them has a default value in the grid
7105 // itself and may be overidden on a per-cell basis
7106 // ============================================================================
7107
7108 // ----------------------------------------------------------------------------
7109 // setting default attributes
7110 // ----------------------------------------------------------------------------
7111
7112 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7113 {
7114     m_defaultCellAttr->SetBackgroundColour(col);
7115 #ifdef __WXGTK__
7116     m_gridWin->SetBackgroundColour(col);
7117 #endif
7118 }
7119
7120 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7121 {
7122     m_defaultCellAttr->SetTextColour(col);
7123 }
7124
7125 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7126 {
7127     m_defaultCellAttr->SetAlignment(horiz, vert);
7128 }
7129
7130 void wxGrid::SetDefaultCellOverflow( bool allow )
7131 {
7132     m_defaultCellAttr->SetOverflow(allow);
7133 }
7134
7135 void wxGrid::SetDefaultCellFont( const wxFont& font )
7136 {
7137     m_defaultCellAttr->SetFont(font);
7138 }
7139
7140 // For editors and renderers the type registry takes precedence over the
7141 // default attr, so we need to register the new editor/renderer for the string
7142 // data type in order to make setting a default editor/renderer appear to
7143 // work correctly.
7144
7145 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7146 {
7147     RegisterDataType(wxGRID_VALUE_STRING,
7148                      renderer,
7149                      GetDefaultEditorForType(wxGRID_VALUE_STRING));
7150 }
7151
7152 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7153 {
7154     RegisterDataType(wxGRID_VALUE_STRING,
7155                      GetDefaultRendererForType(wxGRID_VALUE_STRING),
7156                      editor);
7157 }
7158
7159 // ----------------------------------------------------------------------------
7160 // access to the default attributes
7161 // ----------------------------------------------------------------------------
7162
7163 wxColour wxGrid::GetDefaultCellBackgroundColour() const
7164 {
7165     return m_defaultCellAttr->GetBackgroundColour();
7166 }
7167
7168 wxColour wxGrid::GetDefaultCellTextColour() const
7169 {
7170     return m_defaultCellAttr->GetTextColour();
7171 }
7172
7173 wxFont wxGrid::GetDefaultCellFont() const
7174 {
7175     return m_defaultCellAttr->GetFont();
7176 }
7177
7178 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
7179 {
7180     m_defaultCellAttr->GetAlignment(horiz, vert);
7181 }
7182
7183 bool wxGrid::GetDefaultCellOverflow() const
7184 {
7185     return m_defaultCellAttr->GetOverflow();
7186 }
7187
7188 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7189 {
7190     return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7191 }
7192
7193 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7194 {
7195     return m_defaultCellAttr->GetEditor(NULL, 0, 0);
7196 }
7197
7198 // ----------------------------------------------------------------------------
7199 // access to cell attributes
7200 // ----------------------------------------------------------------------------
7201
7202 wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
7203 {
7204     wxGridCellAttr *attr = GetCellAttr(row, col);
7205     wxColour colour = attr->GetBackgroundColour();
7206     attr->DecRef();
7207
7208     return colour;
7209 }
7210
7211 wxColour wxGrid::GetCellTextColour( int row, int col ) const
7212 {
7213     wxGridCellAttr *attr = GetCellAttr(row, col);
7214     wxColour colour = attr->GetTextColour();
7215     attr->DecRef();
7216
7217     return colour;
7218 }
7219
7220 wxFont wxGrid::GetCellFont( int row, int col ) const
7221 {
7222     wxGridCellAttr *attr = GetCellAttr(row, col);
7223     wxFont font = attr->GetFont();
7224     attr->DecRef();
7225
7226     return font;
7227 }
7228
7229 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
7230 {
7231     wxGridCellAttr *attr = GetCellAttr(row, col);
7232     attr->GetAlignment(horiz, vert);
7233     attr->DecRef();
7234 }
7235
7236 bool wxGrid::GetCellOverflow( int row, int col ) const
7237 {
7238     wxGridCellAttr *attr = GetCellAttr(row, col);
7239     bool allow = attr->GetOverflow();
7240     attr->DecRef();
7241
7242     return allow;
7243 }
7244
7245 wxGrid::CellSpan
7246 wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
7247 {
7248     wxGridCellAttr *attr = GetCellAttr(row, col);
7249     attr->GetSize( num_rows, num_cols );
7250     attr->DecRef();
7251
7252     if ( *num_rows == 1 && *num_cols == 1 )
7253         return CellSpan_None; // just a normal cell
7254
7255     if ( *num_rows < 0 || *num_cols < 0 )
7256         return CellSpan_Inside; // covered by a multi-span cell
7257
7258     // this cell spans multiple cells to its right/bottom
7259     return CellSpan_Main;
7260 }
7261
7262 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
7263 {
7264     wxGridCellAttr* attr = GetCellAttr(row, col);
7265     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
7266     attr->DecRef();
7267
7268     return renderer;
7269 }
7270
7271 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
7272 {
7273     wxGridCellAttr* attr = GetCellAttr(row, col);
7274     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7275     attr->DecRef();
7276
7277     return editor;
7278 }
7279
7280 bool wxGrid::IsReadOnly(int row, int col) const
7281 {
7282     wxGridCellAttr* attr = GetCellAttr(row, col);
7283     bool isReadOnly = attr->IsReadOnly();
7284     attr->DecRef();
7285
7286     return isReadOnly;
7287 }
7288
7289 // ----------------------------------------------------------------------------
7290 // attribute support: cache, automatic provider creation, ...
7291 // ----------------------------------------------------------------------------
7292
7293 bool wxGrid::CanHaveAttributes() const
7294 {
7295     if ( !m_table )
7296     {
7297         return false;
7298     }
7299
7300     return m_table->CanHaveAttributes();
7301 }
7302
7303 void wxGrid::ClearAttrCache()
7304 {
7305     if ( m_attrCache.row != -1 )
7306     {
7307         wxGridCellAttr *oldAttr = m_attrCache.attr;
7308         m_attrCache.attr = NULL;
7309         m_attrCache.row = -1;
7310         // wxSafeDecRec(...) might cause event processing that accesses
7311         // the cached attribute, if one exists (e.g. by deleting the
7312         // editor stored within the attribute). Therefore it is important
7313         // to invalidate the cache  before calling wxSafeDecRef!
7314         wxSafeDecRef(oldAttr);
7315     }
7316 }
7317
7318 void wxGrid::RefreshAttr(int row, int col)
7319 {
7320     if ( m_attrCache.row == row && m_attrCache.col == col )
7321         ClearAttrCache();
7322 }
7323
7324
7325 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
7326 {
7327     if ( attr != NULL )
7328     {
7329         wxGrid * const self = const_cast<wxGrid *>(this);
7330
7331         self->ClearAttrCache();
7332         self->m_attrCache.row = row;
7333         self->m_attrCache.col = col;
7334         self->m_attrCache.attr = attr;
7335         wxSafeIncRef(attr);
7336     }
7337 }
7338
7339 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
7340 {
7341     if ( row == m_attrCache.row && col == m_attrCache.col )
7342     {
7343         *attr = m_attrCache.attr;
7344         wxSafeIncRef(m_attrCache.attr);
7345
7346 #ifdef DEBUG_ATTR_CACHE
7347         gs_nAttrCacheHits++;
7348 #endif
7349
7350         return true;
7351     }
7352     else
7353     {
7354 #ifdef DEBUG_ATTR_CACHE
7355         gs_nAttrCacheMisses++;
7356 #endif
7357
7358         return false;
7359     }
7360 }
7361
7362 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
7363 {
7364     wxGridCellAttr *attr = NULL;
7365     // Additional test to avoid looking at the cache e.g. for
7366     // wxNoCellCoords, as this will confuse memory management.
7367     if ( row >= 0 )
7368     {
7369         if ( !LookupAttr(row, col, &attr) )
7370         {
7371             attr = m_table ? m_table->GetAttr(row, col, wxGridCellAttr::Any)
7372                            : NULL;
7373             CacheAttr(row, col, attr);
7374         }
7375     }
7376
7377     if (attr)
7378     {
7379         attr->SetDefAttr(m_defaultCellAttr);
7380     }
7381     else
7382     {
7383         attr = m_defaultCellAttr;
7384         attr->IncRef();
7385     }
7386
7387     return attr;
7388 }
7389
7390 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
7391 {
7392     wxGridCellAttr *attr = NULL;
7393     bool canHave = ((wxGrid*)this)->CanHaveAttributes();
7394
7395     wxCHECK_MSG( canHave, attr, wxT("Cell attributes not allowed"));
7396     wxCHECK_MSG( m_table, attr, wxT("must have a table") );
7397
7398     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
7399     if ( !attr )
7400     {
7401         attr = new wxGridCellAttr(m_defaultCellAttr);
7402
7403         // artificially inc the ref count to match DecRef() in caller
7404         attr->IncRef();
7405         m_table->SetAttr(attr, row, col);
7406     }
7407
7408     return attr;
7409 }
7410
7411 // ----------------------------------------------------------------------------
7412 // setting column attributes (wrappers around SetColAttr)
7413 // ----------------------------------------------------------------------------
7414
7415 void wxGrid::SetColFormatBool(int col)
7416 {
7417     SetColFormatCustom(col, wxGRID_VALUE_BOOL);
7418 }
7419
7420 void wxGrid::SetColFormatNumber(int col)
7421 {
7422     SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
7423 }
7424
7425 void wxGrid::SetColFormatFloat(int col, int width, int precision)
7426 {
7427     wxString typeName = wxGRID_VALUE_FLOAT;
7428     if ( (width != -1) || (precision != -1) )
7429     {
7430         typeName << wxT(':') << width << wxT(',') << precision;
7431     }
7432
7433     SetColFormatCustom(col, typeName);
7434 }
7435
7436 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
7437 {
7438     wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
7439     if (!attr)
7440         attr = new wxGridCellAttr;
7441     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
7442     attr->SetRenderer(renderer);
7443     wxGridCellEditor *editor = GetDefaultEditorForType(typeName);
7444     attr->SetEditor(editor);
7445
7446     SetColAttr(col, attr);
7447
7448 }
7449
7450 // ----------------------------------------------------------------------------
7451 // setting cell attributes: this is forwarded to the table
7452 // ----------------------------------------------------------------------------
7453
7454 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
7455 {
7456     if ( CanHaveAttributes() )
7457     {
7458         m_table->SetAttr(attr, row, col);
7459         ClearAttrCache();
7460     }
7461     else
7462     {
7463         wxSafeDecRef(attr);
7464     }
7465 }
7466
7467 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
7468 {
7469     if ( CanHaveAttributes() )
7470     {
7471         m_table->SetRowAttr(attr, row);
7472         ClearAttrCache();
7473     }
7474     else
7475     {
7476         wxSafeDecRef(attr);
7477     }
7478 }
7479
7480 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
7481 {
7482     if ( CanHaveAttributes() )
7483     {
7484         m_table->SetColAttr(attr, col);
7485         ClearAttrCache();
7486     }
7487     else
7488     {
7489         wxSafeDecRef(attr);
7490     }
7491 }
7492
7493 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
7494 {
7495     if ( CanHaveAttributes() )
7496     {
7497         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7498         attr->SetBackgroundColour(colour);
7499         attr->DecRef();
7500     }
7501 }
7502
7503 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
7504 {
7505     if ( CanHaveAttributes() )
7506     {
7507         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7508         attr->SetTextColour(colour);
7509         attr->DecRef();
7510     }
7511 }
7512
7513 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
7514 {
7515     if ( CanHaveAttributes() )
7516     {
7517         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7518         attr->SetFont(font);
7519         attr->DecRef();
7520     }
7521 }
7522
7523 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
7524 {
7525     if ( CanHaveAttributes() )
7526     {
7527         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7528         attr->SetAlignment(horiz, vert);
7529         attr->DecRef();
7530     }
7531 }
7532
7533 void wxGrid::SetCellOverflow( int row, int col, bool allow )
7534 {
7535     if ( CanHaveAttributes() )
7536     {
7537         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7538         attr->SetOverflow(allow);
7539         attr->DecRef();
7540     }
7541 }
7542
7543 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
7544 {
7545     if ( CanHaveAttributes() )
7546     {
7547         int cell_rows, cell_cols;
7548
7549         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7550         attr->GetSize(&cell_rows, &cell_cols);
7551         attr->SetSize(num_rows, num_cols);
7552         attr->DecRef();
7553
7554         // Cannot set the size of a cell to 0 or negative values
7555         // While it is perfectly legal to do that, this function cannot
7556         // handle all the possibilies, do it by hand by getting the CellAttr.
7557         // You can only set the size of a cell to 1,1 or greater with this fn
7558         wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
7559                       wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
7560         wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
7561                       wxT("wxGrid::SetCellSize setting cell size to < 1"));
7562
7563         // if this was already a multicell then "turn off" the other cells first
7564         if ((cell_rows > 1) || (cell_cols > 1))
7565         {
7566             int i, j;
7567             for (j=row; j < row + cell_rows; j++)
7568             {
7569                 for (i=col; i < col + cell_cols; i++)
7570                 {
7571                     if ((i != col) || (j != row))
7572                     {
7573                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7574                         attr_stub->SetSize( 1, 1 );
7575                         attr_stub->DecRef();
7576                     }
7577                 }
7578             }
7579         }
7580
7581         // mark the cells that will be covered by this cell to
7582         // negative or zero values to point back at this cell
7583         if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
7584         {
7585             int i, j;
7586             for (j=row; j < row + num_rows; j++)
7587             {
7588                 for (i=col; i < col + num_cols; i++)
7589                 {
7590                     if ((i != col) || (j != row))
7591                     {
7592                         wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7593                         attr_stub->SetSize( row - j, col - i );
7594                         attr_stub->DecRef();
7595                     }
7596                 }
7597             }
7598         }
7599     }
7600 }
7601
7602 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
7603 {
7604     if ( CanHaveAttributes() )
7605     {
7606         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7607         attr->SetRenderer(renderer);
7608         attr->DecRef();
7609     }
7610 }
7611
7612 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
7613 {
7614     if ( CanHaveAttributes() )
7615     {
7616         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7617         attr->SetEditor(editor);
7618         attr->DecRef();
7619     }
7620 }
7621
7622 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
7623 {
7624     if ( CanHaveAttributes() )
7625     {
7626         wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7627         attr->SetReadOnly(isReadOnly);
7628         attr->DecRef();
7629     }
7630 }
7631
7632 // ----------------------------------------------------------------------------
7633 // Data type registration
7634 // ----------------------------------------------------------------------------
7635
7636 void wxGrid::RegisterDataType(const wxString& typeName,
7637                               wxGridCellRenderer* renderer,
7638                               wxGridCellEditor* editor)
7639 {
7640     m_typeRegistry->RegisterDataType(typeName, renderer, editor);
7641 }
7642
7643
7644 wxGridCellEditor * wxGrid::GetDefaultEditorForCell(int row, int col) const
7645 {
7646     wxString typeName = m_table->GetTypeName(row, col);
7647     return GetDefaultEditorForType(typeName);
7648 }
7649
7650 wxGridCellRenderer * wxGrid::GetDefaultRendererForCell(int row, int col) const
7651 {
7652     wxString typeName = m_table->GetTypeName(row, col);
7653     return GetDefaultRendererForType(typeName);
7654 }
7655
7656 wxGridCellEditor * wxGrid::GetDefaultEditorForType(const wxString& typeName) const
7657 {
7658     int index = m_typeRegistry->FindOrCloneDataType(typeName);
7659     if ( index == wxNOT_FOUND )
7660     {
7661         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7662
7663         return NULL;
7664     }
7665
7666     return m_typeRegistry->GetEditor(index);
7667 }
7668
7669 wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName) const
7670 {
7671     int index = m_typeRegistry->FindOrCloneDataType(typeName);
7672     if ( index == wxNOT_FOUND )
7673     {
7674         wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7675
7676         return NULL;
7677     }
7678
7679     return m_typeRegistry->GetRenderer(index);
7680 }
7681
7682 // ----------------------------------------------------------------------------
7683 // row/col size
7684 // ----------------------------------------------------------------------------
7685
7686 void wxGrid::DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed)
7687 {
7688     if ( !setFixed )
7689     {
7690         setFixed = new wxGridFixedIndicesSet;
7691     }
7692
7693     setFixed->insert(line);
7694 }
7695
7696 bool
7697 wxGrid::DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const
7698 {
7699     return !setFixed || !setFixed->count(line);
7700 }
7701
7702 void wxGrid::EnableDragRowSize( bool enable )
7703 {
7704     m_canDragRowSize = enable;
7705 }
7706
7707 void wxGrid::EnableDragColSize( bool enable )
7708 {
7709     m_canDragColSize = enable;
7710 }
7711
7712 void wxGrid::EnableDragGridSize( bool enable )
7713 {
7714     m_canDragGridSize = enable;
7715 }
7716
7717 void wxGrid::EnableDragCell( bool enable )
7718 {
7719     m_canDragCell = enable;
7720 }
7721
7722 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
7723 {
7724     m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
7725
7726     if ( resizeExistingRows )
7727     {
7728         // since we are resizing all rows to the default row size,
7729         // we can simply clear the row heights and row bottoms
7730         // arrays (which also allows us to take advantage of
7731         // some speed optimisations)
7732         m_rowHeights.Empty();
7733         m_rowBottoms.Empty();
7734         if ( !GetBatchCount() )
7735             CalcDimensions();
7736     }
7737 }
7738
7739 void wxGrid::SetRowSize( int row, int height )
7740 {
7741     wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );
7742
7743     // if < 0 then calculate new height from label
7744     if ( height < 0 )
7745     {
7746         long w, h;
7747         wxArrayString lines;
7748         wxClientDC dc(m_rowLabelWin);
7749         dc.SetFont(GetLabelFont());
7750         StringToLines(GetRowLabelValue( row ), lines);
7751         GetTextBoxSize( dc, lines, &w, &h );
7752         //check that it is not less than the minimal height
7753         height = wxMax(h, GetRowMinimalAcceptableHeight());
7754     }
7755
7756     // See comment in SetColSize
7757     if ( height > 0 && height < GetRowMinimalAcceptableHeight())
7758         return;
7759
7760     if ( m_rowHeights.IsEmpty() )
7761     {
7762         // need to really create the array
7763         InitRowHeights();
7764     }
7765
7766     int h = wxMax( 0, height );
7767     int diff = h - m_rowHeights[row];
7768
7769     m_rowHeights[row] = h;
7770     for ( int i = row; i < m_numRows; i++ )
7771     {
7772         m_rowBottoms[i] += diff;
7773     }
7774
7775     if ( !GetBatchCount() )
7776     {
7777         CalcDimensions();
7778         Refresh();
7779     }
7780 }
7781
7782 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
7783 {
7784     // we dont allow zero default column width
7785     m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
7786
7787     if ( resizeExistingCols )
7788     {
7789         // since we are resizing all columns to the default column size,
7790         // we can simply clear the col widths and col rights
7791         // arrays (which also allows us to take advantage of
7792         // some speed optimisations)
7793         m_colWidths.Empty();
7794         m_colRights.Empty();
7795         if ( !GetBatchCount() )
7796             CalcDimensions();
7797     }
7798 }
7799
7800 void wxGrid::SetColSize( int col, int width )
7801 {
7802     wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );
7803
7804     // if < 0 then calculate new width from label
7805     if ( width < 0 )
7806     {
7807         long w, h;
7808         wxArrayString lines;
7809         wxClientDC dc(m_colWindow);
7810         dc.SetFont(GetLabelFont());
7811         StringToLines(GetColLabelValue(col), lines);
7812         if ( GetColLabelTextOrientation() == wxHORIZONTAL )
7813             GetTextBoxSize( dc, lines, &w, &h );
7814         else
7815             GetTextBoxSize( dc, lines, &h, &w );
7816         width = w + 6;
7817         //check that it is not less than the minimal width
7818         width = wxMax(width, GetColMinimalAcceptableWidth());
7819     }
7820
7821     // we intentionally don't test whether the width is less than
7822     // GetColMinimalWidth() here but we do compare it with
7823     // GetColMinimalAcceptableWidth() as otherwise things currently break (see
7824     // #651) -- and we also always allow the width of 0 as it has the special
7825     // sense of hiding the column
7826     if ( width > 0 && width < GetColMinimalAcceptableWidth() )
7827         return;
7828
7829     if ( m_colWidths.IsEmpty() )
7830     {
7831         // need to really create the array
7832         InitColWidths();
7833     }
7834
7835     const int diff = width - m_colWidths[col];
7836     m_colWidths[col] = width;
7837     if ( m_useNativeHeader )
7838         GetGridColHeader()->UpdateColumn(col);
7839     //else: will be refreshed when the header is redrawn
7840
7841     for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
7842     {
7843         m_colRights[GetColAt(colPos)] += diff;
7844     }
7845
7846     if ( !GetBatchCount() )
7847     {
7848         CalcDimensions();
7849         Refresh();
7850     }
7851 }
7852
7853 void wxGrid::SetColMinimalWidth( int col, int width )
7854 {
7855     if (width > GetColMinimalAcceptableWidth())
7856     {
7857         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7858         m_colMinWidths[key] = width;
7859     }
7860 }
7861
7862 void wxGrid::SetRowMinimalHeight( int row, int width )
7863 {
7864     if (width > GetRowMinimalAcceptableHeight())
7865     {
7866         wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7867         m_rowMinHeights[key] = width;
7868     }
7869 }
7870
7871 int wxGrid::GetColMinimalWidth(int col) const
7872 {
7873     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7874     wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
7875
7876     return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
7877 }
7878
7879 int wxGrid::GetRowMinimalHeight(int row) const
7880 {
7881     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7882     wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
7883
7884     return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
7885 }
7886
7887 void wxGrid::SetColMinimalAcceptableWidth( int width )
7888 {
7889     // We do allow a width of 0 since this gives us
7890     // an easy way to temporarily hiding columns.
7891     if ( width >= 0 )
7892         m_minAcceptableColWidth = width;
7893 }
7894
7895 void wxGrid::SetRowMinimalAcceptableHeight( int height )
7896 {
7897     // We do allow a height of 0 since this gives us
7898     // an easy way to temporarily hiding rows.
7899     if ( height >= 0 )
7900         m_minAcceptableRowHeight = height;
7901 }
7902
7903 int  wxGrid::GetColMinimalAcceptableWidth() const
7904 {
7905     return m_minAcceptableColWidth;
7906 }
7907
7908 int  wxGrid::GetRowMinimalAcceptableHeight() const
7909 {
7910     return m_minAcceptableRowHeight;
7911 }
7912
7913 // ----------------------------------------------------------------------------
7914 // auto sizing
7915 // ----------------------------------------------------------------------------
7916
7917 void
7918 wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
7919 {
7920     const bool column = direction == wxGRID_COLUMN;
7921
7922     wxClientDC dc(m_gridWin);
7923
7924     // cancel editing of cell
7925     HideCellEditControl();
7926     SaveEditControlValue();
7927
7928     // initialize both of them just to avoid compiler warnings even if only
7929     // really needs to be initialized here
7930     int row,
7931         col;
7932     if ( column )
7933     {
7934         row = -1;
7935         col = colOrRow;
7936     }
7937     else
7938     {
7939         row = colOrRow;
7940         col = -1;
7941     }
7942
7943     wxCoord extent, extentMax = 0;
7944     int max = column ? m_numRows : m_numCols;
7945     for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
7946     {
7947         if ( column )
7948             row = rowOrCol;
7949         else
7950             col = rowOrCol;
7951
7952         // we need to account for the cells spanning multiple columns/rows:
7953         // while they may need a lot of space, they don't need all of it in
7954         // this column/row
7955         int numRows, numCols;
7956         const CellSpan span = GetCellSize(row, col, &numRows, &numCols);
7957         if ( span == CellSpan_Inside )
7958         {
7959             // we need to get the size of the main cell, not of a cell hidden
7960             // by it
7961             row += numRows;
7962             col += numCols;
7963
7964             // get the size of the main cell too
7965             GetCellSize(row, col, &numRows, &numCols);
7966         }
7967
7968         wxGridCellAttr *attr = GetCellAttr(row, col);
7969         wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
7970         if ( renderer )
7971         {
7972             wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
7973             extent = column ? size.x : size.y;
7974
7975             if ( span != CellSpan_None )
7976             {
7977                 // we spread the size of a spanning cell over all the cells it
7978                 // covers evenly -- this is probably not ideal but we can't
7979                 // really do much better here
7980                 //
7981                 // notice that numCols and numRows are never 0 as they
7982                 // correspond to the size of the main cell of the span and not
7983                 // of the cell inside it
7984                 extent /= column ? numCols : numRows;
7985             }
7986
7987             if ( extent > extentMax )
7988                 extentMax = extent;
7989
7990             renderer->DecRef();
7991         }
7992
7993         attr->DecRef();
7994     }
7995
7996     // now also compare with the column label extent
7997     wxCoord w, h;
7998     dc.SetFont( GetLabelFont() );
7999
8000     if ( column )
8001     {
8002         dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
8003         if ( GetColLabelTextOrientation() == wxVERTICAL )
8004             w = h;
8005     }
8006     else
8007         dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
8008
8009     extent = column ? w : h;
8010     if ( extent > extentMax )
8011         extentMax = extent;
8012
8013     if ( !extentMax )
8014     {
8015         // empty column - give default extent (notice that if extentMax is less
8016         // than default extent but != 0, it's OK)
8017         extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
8018     }
8019     else
8020     {
8021         if ( column )
8022             // leave some space around text
8023             extentMax += 10;
8024         else
8025             extentMax += 6;
8026     }
8027
8028     if ( column )
8029     {
8030         // Ensure automatic width is not less than minimal width. See the
8031         // comment in SetColSize() for explanation of why this isn't done
8032         // in SetColSize().
8033         if ( !setAsMin )
8034             extentMax = wxMax(extentMax, GetColMinimalWidth(col));
8035
8036         SetColSize( col, extentMax );
8037         if ( !GetBatchCount() )
8038         {
8039             if ( m_useNativeHeader )
8040             {
8041                 GetGridColHeader()->UpdateColumn(col);
8042             }
8043             else
8044             {
8045                 int cw, ch, dummy;
8046                 m_gridWin->GetClientSize( &cw, &ch );
8047                 wxRect rect ( CellToRect( 0, col ) );
8048                 rect.y = 0;
8049                 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
8050                 rect.width = cw - rect.x;
8051                 rect.height = m_colLabelHeight;
8052                 GetColLabelWindow()->Refresh( true, &rect );
8053             }
8054         }
8055     }
8056     else
8057     {
8058         // Ensure automatic width is not less than minimal height. See the
8059         // comment in SetColSize() for explanation of why this isn't done
8060         // in SetRowSize().
8061         if ( !setAsMin )
8062             extentMax = wxMax(extentMax, GetRowMinimalHeight(row));
8063
8064         SetRowSize(row, extentMax);
8065         if ( !GetBatchCount() )
8066         {
8067             int cw, ch, dummy;
8068             m_gridWin->GetClientSize( &cw, &ch );
8069             wxRect rect( CellToRect( row, 0 ) );
8070             rect.x = 0;
8071             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8072             rect.width = m_rowLabelWidth;
8073             rect.height = ch - rect.y;
8074             m_rowLabelWin->Refresh( true, &rect );
8075         }
8076     }
8077
8078     if ( setAsMin )
8079     {
8080         if ( column )
8081             SetColMinimalWidth(col, extentMax);
8082         else
8083             SetRowMinimalHeight(row, extentMax);
8084     }
8085 }
8086
8087 wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
8088 {
8089     // calculate size for the rows or columns?
8090     const bool calcRows = direction == wxGRID_ROW;
8091
8092     wxClientDC dc(calcRows ? GetGridRowLabelWindow()
8093                            : GetGridColLabelWindow());
8094     dc.SetFont(GetLabelFont());
8095
8096     // which dimension should we take into account for calculations?
8097     //
8098     // for columns, the text can be only horizontal so it's easy but for rows
8099     // we also have to take into account the text orientation
8100     const bool
8101         useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
8102
8103     wxArrayString lines;
8104     wxCoord extentMax = 0;
8105
8106     const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
8107     for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
8108     {
8109         lines.Clear();
8110
8111         wxString label = calcRows ? GetRowLabelValue(rowOrCol)
8112                                   : GetColLabelValue(rowOrCol);
8113         StringToLines(label, lines);
8114
8115         long w, h;
8116         GetTextBoxSize(dc, lines, &w, &h);
8117
8118         const wxCoord extent = useWidth ? w : h;
8119         if ( extent > extentMax )
8120             extentMax = extent;
8121     }
8122
8123     if ( !extentMax )
8124     {
8125         // empty column - give default extent (notice that if extentMax is less
8126         // than default extent but != 0, it's OK)
8127         extentMax = calcRows ? GetDefaultRowLabelSize()
8128                              : GetDefaultColLabelSize();
8129     }
8130
8131     // leave some space around text (taken from AutoSizeColOrRow)
8132     if ( calcRows )
8133         extentMax += 10;
8134     else
8135         extentMax += 6;
8136
8137     return extentMax;
8138 }
8139
8140 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8141 {
8142     int width = m_rowLabelWidth;
8143
8144     wxGridUpdateLocker locker;
8145     if(!calcOnly)
8146         locker.Create(this);
8147
8148     for ( int col = 0; col < m_numCols; col++ )
8149     {
8150         if ( !calcOnly )
8151             AutoSizeColumn(col, setAsMin);
8152
8153         width += GetColWidth(col);
8154     }
8155
8156     return width;
8157 }
8158
8159 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8160 {
8161     int height = m_colLabelHeight;
8162
8163     wxGridUpdateLocker locker;
8164     if(!calcOnly)
8165         locker.Create(this);
8166
8167     for ( int row = 0; row < m_numRows; row++ )
8168     {
8169         if ( !calcOnly )
8170             AutoSizeRow(row, setAsMin);
8171
8172         height += GetRowHeight(row);
8173     }
8174
8175     return height;
8176 }
8177
8178 void wxGrid::AutoSize()
8179 {
8180     wxGridUpdateLocker locker(this);
8181
8182     wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
8183                 SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
8184
8185     // we know that we're not going to have scrollbars so disable them now to
8186     // avoid trouble in SetClientSize() which can otherwise set the correct
8187     // client size but also leave space for (not needed any more) scrollbars
8188     SetScrollbars(m_xScrollPixelsPerLine, m_yScrollPixelsPerLine,
8189                   0, 0, 0, 0, true);
8190
8191     SetClientSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight);
8192 }
8193
8194 void wxGrid::AutoSizeRowLabelSize( int row )
8195 {
8196     // Hide the edit control, so it
8197     // won't interfere with drag-shrinking.
8198     if ( IsCellEditControlShown() )
8199     {
8200         HideCellEditControl();
8201         SaveEditControlValue();
8202     }
8203
8204     // autosize row height depending on label text
8205     SetRowSize(row, -1);
8206     ForceRefresh();
8207 }
8208
8209 void wxGrid::AutoSizeColLabelSize( int col )
8210 {
8211     // Hide the edit control, so it
8212     // won't interfere with drag-shrinking.
8213     if ( IsCellEditControlShown() )
8214     {
8215         HideCellEditControl();
8216         SaveEditControlValue();
8217     }
8218
8219     // autosize column width depending on label text
8220     SetColSize(col, -1);
8221     ForceRefresh();
8222 }
8223
8224 wxSize wxGrid::DoGetBestSize() const
8225 {
8226     wxGrid * const self = const_cast<wxGrid *>(this);
8227
8228     // we do the same as in AutoSize() here with the exception that we don't
8229     // change the column/row sizes, only calculate them
8230     wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
8231                 self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
8232
8233     // NOTE: This size should be cached, but first we need to add calls to
8234     // InvalidateBestSize everywhere that could change the results of this
8235     // calculation.
8236     // CacheBestSize(size);
8237
8238     return wxSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight)
8239             + GetWindowBorderSize();
8240 }
8241
8242 void wxGrid::Fit()
8243 {
8244     AutoSize();
8245 }
8246
8247 #if WXWIN_COMPATIBILITY_2_8
8248 wxPen& wxGrid::GetDividerPen() const
8249 {
8250     return wxNullPen;
8251 }
8252 #endif // WXWIN_COMPATIBILITY_2_8
8253
8254 // ----------------------------------------------------------------------------
8255 // cell value accessor functions
8256 // ----------------------------------------------------------------------------
8257
8258 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8259 {
8260     if ( m_table )
8261     {
8262         m_table->SetValue( row, col, s );
8263         if ( !GetBatchCount() )
8264         {
8265             int dummy;
8266             wxRect rect( CellToRect( row, col ) );
8267             rect.x = 0;
8268             rect.width = m_gridWin->GetClientSize().GetWidth();
8269             CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8270             m_gridWin->Refresh( false, &rect );
8271         }
8272
8273         if ( m_currentCellCoords.GetRow() == row &&
8274              m_currentCellCoords.GetCol() == col &&
8275              IsCellEditControlShown())
8276              // Note: If we are using IsCellEditControlEnabled,
8277              // this interacts badly with calling SetCellValue from
8278              // an EVT_GRID_CELL_CHANGE handler.
8279         {
8280             HideCellEditControl();
8281             ShowCellEditControl(); // will reread data from table
8282         }
8283     }
8284 }
8285
8286 // ----------------------------------------------------------------------------
8287 // block, row and column selection
8288 // ----------------------------------------------------------------------------
8289
8290 void wxGrid::SelectRow( int row, bool addToSelected )
8291 {
8292     if ( !m_selection )
8293         return;
8294
8295     if ( !addToSelected )
8296         ClearSelection();
8297
8298     m_selection->SelectRow(row);
8299 }
8300
8301 void wxGrid::SelectCol( int col, bool addToSelected )
8302 {
8303     if ( !m_selection )
8304         return;
8305
8306     if ( !addToSelected )
8307         ClearSelection();
8308
8309     m_selection->SelectCol(col);
8310 }
8311
8312 void wxGrid::SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
8313                          bool addToSelected)
8314 {
8315     if ( !m_selection )
8316         return;
8317
8318     if ( !addToSelected )
8319         ClearSelection();
8320
8321     m_selection->SelectBlock(topRow, leftCol, bottomRow, rightCol);
8322 }
8323
8324 void wxGrid::SelectAll()
8325 {
8326     if ( m_numRows > 0 && m_numCols > 0 )
8327     {
8328         if ( m_selection )
8329             m_selection->SelectBlock( 0, 0, m_numRows - 1, m_numCols - 1 );
8330     }
8331 }
8332
8333 // ----------------------------------------------------------------------------
8334 // cell, row and col deselection
8335 // ----------------------------------------------------------------------------
8336
8337 void wxGrid::DeselectLine(int line, const wxGridOperations& oper)
8338 {
8339     if ( !m_selection )
8340         return;
8341
8342     const wxGridSelectionModes mode = m_selection->GetSelectionMode();
8343     if ( mode == oper.GetSelectionMode() ||
8344             mode == wxGrid::wxGridSelectRowsOrColumns )
8345     {
8346         const wxGridCellCoords c(oper.MakeCoords(line, 0));
8347         if ( m_selection->IsInSelection(c) )
8348             m_selection->ToggleCellSelection(c);
8349     }
8350     else if ( mode != oper.Dual().GetSelectionMode() )
8351     {
8352         const int nOther = oper.Dual().GetNumberOfLines(this);
8353         for ( int i = 0; i < nOther; i++ )
8354         {
8355             const wxGridCellCoords c(oper.MakeCoords(line, i));
8356             if ( m_selection->IsInSelection(c) )
8357                 m_selection->ToggleCellSelection(c);
8358         }
8359     }
8360     //else: can only select orthogonal lines so no lines in this direction
8361     //      could have been selected anyhow
8362 }
8363
8364 void wxGrid::DeselectRow(int row)
8365 {
8366     DeselectLine(row, wxGridRowOperations());
8367 }
8368
8369 void wxGrid::DeselectCol(int col)
8370 {
8371     DeselectLine(col, wxGridColumnOperations());
8372 }
8373
8374 void wxGrid::DeselectCell( int row, int col )
8375 {
8376     if ( m_selection && m_selection->IsInSelection(row, col) )
8377         m_selection->ToggleCellSelection(row, col);
8378 }
8379
8380 bool wxGrid::IsSelection() const
8381 {
8382     return ( m_selection && (m_selection->IsSelection() ||
8383              ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
8384                m_selectedBlockBottomRight != wxGridNoCellCoords) ) );
8385 }
8386
8387 bool wxGrid::IsInSelection( int row, int col ) const
8388 {
8389     return ( m_selection && (m_selection->IsInSelection( row, col ) ||
8390              ( row >= m_selectedBlockTopLeft.GetRow() &&
8391                col >= m_selectedBlockTopLeft.GetCol() &&
8392                row <= m_selectedBlockBottomRight.GetRow() &&
8393                col <= m_selectedBlockBottomRight.GetCol() )) );
8394 }
8395
8396 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
8397 {
8398     if (!m_selection)
8399     {
8400         wxGridCellCoordsArray a;
8401         return a;
8402     }
8403
8404     return m_selection->m_cellSelection;
8405 }
8406
8407 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
8408 {
8409     if (!m_selection)
8410     {
8411         wxGridCellCoordsArray a;
8412         return a;
8413     }
8414
8415     return m_selection->m_blockSelectionTopLeft;
8416 }
8417
8418 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
8419 {
8420     if (!m_selection)
8421     {
8422         wxGridCellCoordsArray a;
8423         return a;
8424     }
8425
8426     return m_selection->m_blockSelectionBottomRight;
8427 }
8428
8429 wxArrayInt wxGrid::GetSelectedRows() const
8430 {
8431     if (!m_selection)
8432     {
8433         wxArrayInt a;
8434         return a;
8435     }
8436
8437     return m_selection->m_rowSelection;
8438 }
8439
8440 wxArrayInt wxGrid::GetSelectedCols() const
8441 {
8442     if (!m_selection)
8443     {
8444         wxArrayInt a;
8445         return a;
8446     }
8447
8448     return m_selection->m_colSelection;
8449 }
8450
8451 void wxGrid::ClearSelection()
8452 {
8453     wxRect r1 = BlockToDeviceRect(m_selectedBlockTopLeft,
8454                                   m_selectedBlockBottomRight);
8455     wxRect r2 = BlockToDeviceRect(m_currentCellCoords,
8456                                   m_selectedBlockCorner);
8457
8458     m_selectedBlockTopLeft =
8459     m_selectedBlockBottomRight =
8460     m_selectedBlockCorner = wxGridNoCellCoords;
8461
8462     if ( !r1.IsEmpty() )
8463         RefreshRect(r1, false);
8464     if ( !r2.IsEmpty() )
8465         RefreshRect(r2, false);
8466
8467     if ( m_selection )
8468         m_selection->ClearSelection();
8469 }
8470
8471 // This function returns the rectangle that encloses the given block
8472 // in device coords clipped to the client size of the grid window.
8473 //
8474 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords& topLeft,
8475                                   const wxGridCellCoords& bottomRight ) const
8476 {
8477     wxRect resultRect;
8478     wxRect tempCellRect = CellToRect(topLeft);
8479     if ( tempCellRect != wxGridNoCellRect )
8480     {
8481         resultRect = tempCellRect;
8482     }
8483     else
8484     {
8485         resultRect = wxRect(0, 0, 0, 0);
8486     }
8487
8488     tempCellRect = CellToRect(bottomRight);
8489     if ( tempCellRect != wxGridNoCellRect )
8490     {
8491         resultRect += tempCellRect;
8492     }
8493     else
8494     {
8495         // If both inputs were "wxGridNoCellRect," then there's nothing to do.
8496         return wxGridNoCellRect;
8497     }
8498
8499     // Ensure that left/right and top/bottom pairs are in order.
8500     int left = resultRect.GetLeft();
8501     int top = resultRect.GetTop();
8502     int right = resultRect.GetRight();
8503     int bottom = resultRect.GetBottom();
8504
8505     int leftCol = topLeft.GetCol();
8506     int topRow = topLeft.GetRow();
8507     int rightCol = bottomRight.GetCol();
8508     int bottomRow = bottomRight.GetRow();
8509
8510     if (left > right)
8511     {
8512         int tmp = left;
8513         left = right;
8514         right = tmp;
8515
8516         tmp = leftCol;
8517         leftCol = rightCol;
8518         rightCol = tmp;
8519     }
8520
8521     if (top > bottom)
8522     {
8523         int tmp = top;
8524         top = bottom;
8525         bottom = tmp;
8526
8527         tmp = topRow;
8528         topRow = bottomRow;
8529         bottomRow = tmp;
8530     }
8531
8532     // The following loop is ONLY necessary to detect and handle merged cells.
8533     int cw, ch;
8534     m_gridWin->GetClientSize( &cw, &ch );
8535
8536     // Get the origin coordinates: notice that they will be negative if the
8537     // grid is scrolled downwards/to the right.
8538     int gridOriginX = 0;
8539     int gridOriginY = 0;
8540     CalcScrolledPosition(gridOriginX, gridOriginY, &gridOriginX, &gridOriginY);
8541
8542     int onScreenLeftmostCol = internalXToCol(-gridOriginX);
8543     int onScreenUppermostRow = internalYToRow(-gridOriginY);
8544
8545     int onScreenRightmostCol = internalXToCol(-gridOriginX + cw);
8546     int onScreenBottommostRow = internalYToRow(-gridOriginY + ch);
8547
8548     // Bound our loop so that we only examine the portion of the selected block
8549     // that is shown on screen. Therefore, we compare the Top-Left block values
8550     // to the Top-Left screen values, and the Bottom-Right block values to the
8551     // Bottom-Right screen values, choosing appropriately.
8552     const int visibleTopRow = wxMax(topRow, onScreenUppermostRow);
8553     const int visibleBottomRow = wxMin(bottomRow, onScreenBottommostRow);
8554     const int visibleLeftCol = wxMax(leftCol, onScreenLeftmostCol);
8555     const int visibleRightCol = wxMin(rightCol, onScreenRightmostCol);
8556
8557     for ( int j = visibleTopRow; j <= visibleBottomRow; j++ )
8558     {
8559         for ( int i = visibleLeftCol; i <= visibleRightCol; i++ )
8560         {
8561             if ( (j == visibleTopRow) || (j == visibleBottomRow) ||
8562                     (i == visibleLeftCol) || (i == visibleRightCol) )
8563             {
8564                 tempCellRect = CellToRect( j, i );
8565
8566                 if (tempCellRect.x < left)
8567                     left = tempCellRect.x;
8568                 if (tempCellRect.y < top)
8569                     top = tempCellRect.y;
8570                 if (tempCellRect.x + tempCellRect.width > right)
8571                     right = tempCellRect.x + tempCellRect.width;
8572                 if (tempCellRect.y + tempCellRect.height > bottom)
8573                     bottom = tempCellRect.y + tempCellRect.height;
8574             }
8575             else
8576             {
8577                 i = visibleRightCol; // jump over inner cells.
8578             }
8579         }
8580     }
8581
8582     // Convert to scrolled coords
8583     CalcScrolledPosition( left, top, &left, &top );
8584     CalcScrolledPosition( right, bottom, &right, &bottom );
8585
8586     if (right < 0 || bottom < 0 || left > cw || top > ch)
8587         return wxRect(0,0,0,0);
8588
8589     resultRect.SetLeft( wxMax(0, left) );
8590     resultRect.SetTop( wxMax(0, top) );
8591     resultRect.SetRight( wxMin(cw, right) );
8592     resultRect.SetBottom( wxMin(ch, bottom) );
8593
8594     return resultRect;
8595 }
8596
8597 void wxGrid::DoSetSizes(const wxGridSizesInfo& sizeInfo,
8598                         const wxGridOperations& oper)
8599 {
8600     BeginBatch();
8601     oper.SetDefaultLineSize(this, sizeInfo.m_sizeDefault, true);
8602     const int numLines = oper.GetNumberOfLines(this);
8603     for ( int i = 0; i < numLines; i++ )
8604     {
8605         int size = sizeInfo.GetSize(i);
8606         if ( size != sizeInfo.m_sizeDefault)
8607             oper.SetLineSize(this, i, size);
8608     }
8609     EndBatch();
8610 }
8611
8612 void wxGrid::SetColSizes(const wxGridSizesInfo& sizeInfo)
8613 {
8614     DoSetSizes(sizeInfo, wxGridColumnOperations());
8615 }
8616
8617 void wxGrid::SetRowSizes(const wxGridSizesInfo& sizeInfo)
8618 {
8619     DoSetSizes(sizeInfo, wxGridRowOperations());
8620 }
8621
8622 wxGridSizesInfo::wxGridSizesInfo(int defSize, const wxArrayInt& allSizes)
8623 {
8624     m_sizeDefault = defSize;
8625     for ( size_t i = 0; i < allSizes.size(); i++ )
8626     {
8627         if ( allSizes[i] != defSize )
8628             m_customSizes[i] = allSizes[i];
8629     }
8630 }
8631
8632 int wxGridSizesInfo::GetSize(unsigned pos) const
8633 {
8634     wxUnsignedToIntHashMap::const_iterator it = m_customSizes.find(pos);
8635
8636     return it == m_customSizes.end() ? m_sizeDefault : it->second;
8637 }
8638
8639 // ----------------------------------------------------------------------------
8640 // drop target
8641 // ----------------------------------------------------------------------------
8642
8643 #if wxUSE_DRAG_AND_DROP
8644
8645 // this allow setting drop target directly on wxGrid
8646 void wxGrid::SetDropTarget(wxDropTarget *dropTarget)
8647 {
8648     GetGridWindow()->SetDropTarget(dropTarget);
8649 }
8650
8651 #endif // wxUSE_DRAG_AND_DROP
8652
8653 // ----------------------------------------------------------------------------
8654 // grid event classes
8655 // ----------------------------------------------------------------------------
8656
8657 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8658
8659 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8660                           int row, int col, int x, int y, bool sel,
8661                           bool control, bool shift, bool alt, bool meta )
8662         : wxNotifyEvent( type, id ),
8663           wxKeyboardState(control, shift, alt, meta)
8664 {
8665     Init(row, col, x, y, sel);
8666
8667     SetEventObject(obj);
8668 }
8669
8670 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8671
8672 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8673                                   int rowOrCol, int x, int y,
8674                                   bool control, bool shift, bool alt, bool meta )
8675         : wxNotifyEvent( type, id ),
8676           wxKeyboardState(control, shift, alt, meta)
8677 {
8678     Init(rowOrCol, x, y);
8679
8680     SetEventObject(obj);
8681 }
8682
8683
8684 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8685
8686 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8687                                                const wxGridCellCoords& topLeft,
8688                                                const wxGridCellCoords& bottomRight,
8689                                                bool sel, bool control,
8690                                                bool shift, bool alt, bool meta )
8691         : wxNotifyEvent( type, id ),
8692           wxKeyboardState(control, shift, alt, meta)
8693 {
8694     Init(topLeft, bottomRight, sel);
8695
8696     SetEventObject(obj);
8697 }
8698
8699
8700 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8701
8702 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8703                                                    wxObject* obj, int row,
8704                                                    int col, wxControl* ctrl)
8705     : wxCommandEvent(type, id)
8706 {
8707     SetEventObject(obj);
8708     m_row = row;
8709     m_col = col;
8710     m_ctrl = ctrl;
8711 }
8712
8713
8714 // ----------------------------------------------------------------------------
8715 // wxGridTypeRegistry
8716 // ----------------------------------------------------------------------------
8717
8718 wxGridTypeRegistry::~wxGridTypeRegistry()
8719 {
8720     size_t count = m_typeinfo.GetCount();
8721     for ( size_t i = 0; i < count; i++ )
8722         delete m_typeinfo[i];
8723 }
8724
8725 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
8726                                           wxGridCellRenderer* renderer,
8727                                           wxGridCellEditor* editor)
8728 {
8729     wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
8730
8731     // is it already registered?
8732     int loc = FindRegisteredDataType(typeName);
8733     if ( loc != wxNOT_FOUND )
8734     {
8735         delete m_typeinfo[loc];
8736         m_typeinfo[loc] = info;
8737     }
8738     else
8739     {
8740         m_typeinfo.Add(info);
8741     }
8742 }
8743
8744 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
8745 {
8746     size_t count = m_typeinfo.GetCount();
8747     for ( size_t i = 0; i < count; i++ )
8748     {
8749         if ( typeName == m_typeinfo[i]->m_typeName )
8750         {
8751             return i;
8752         }
8753     }
8754
8755     return wxNOT_FOUND;
8756 }
8757
8758 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
8759 {
8760     int index = FindRegisteredDataType(typeName);
8761     if ( index == wxNOT_FOUND )
8762     {
8763         // check whether this is one of the standard ones, in which case
8764         // register it "on the fly"
8765 #if wxUSE_TEXTCTRL
8766         if ( typeName == wxGRID_VALUE_STRING )
8767         {
8768             RegisterDataType(wxGRID_VALUE_STRING,
8769                              new wxGridCellStringRenderer,
8770                              new wxGridCellTextEditor);
8771         }
8772         else
8773 #endif // wxUSE_TEXTCTRL
8774 #if wxUSE_CHECKBOX
8775         if ( typeName == wxGRID_VALUE_BOOL )
8776         {
8777             RegisterDataType(wxGRID_VALUE_BOOL,
8778                              new wxGridCellBoolRenderer,
8779                              new wxGridCellBoolEditor);
8780         }
8781         else
8782 #endif // wxUSE_CHECKBOX
8783 #if wxUSE_TEXTCTRL
8784         if ( typeName == wxGRID_VALUE_NUMBER )
8785         {
8786             RegisterDataType(wxGRID_VALUE_NUMBER,
8787                              new wxGridCellNumberRenderer,
8788                              new wxGridCellNumberEditor);
8789         }
8790         else if ( typeName == wxGRID_VALUE_FLOAT )
8791         {
8792             RegisterDataType(wxGRID_VALUE_FLOAT,
8793                              new wxGridCellFloatRenderer,
8794                              new wxGridCellFloatEditor);
8795         }
8796         else
8797 #endif // wxUSE_TEXTCTRL
8798 #if wxUSE_COMBOBOX
8799         if ( typeName == wxGRID_VALUE_CHOICE )
8800         {
8801             RegisterDataType(wxGRID_VALUE_CHOICE,
8802                              new wxGridCellStringRenderer,
8803                              new wxGridCellChoiceEditor);
8804         }
8805         else
8806 #endif // wxUSE_COMBOBOX
8807         {
8808             return wxNOT_FOUND;
8809         }
8810
8811         // we get here only if just added the entry for this type, so return
8812         // the last index
8813         index = m_typeinfo.GetCount() - 1;
8814     }
8815
8816     return index;
8817 }
8818
8819 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
8820 {
8821     int index = FindDataType(typeName);
8822     if ( index == wxNOT_FOUND )
8823     {
8824         // the first part of the typename is the "real" type, anything after ':'
8825         // are the parameters for the renderer
8826         index = FindDataType(typeName.BeforeFirst(wxT(':')));
8827         if ( index == wxNOT_FOUND )
8828         {
8829             return wxNOT_FOUND;
8830         }
8831
8832         wxGridCellRenderer *renderer = GetRenderer(index);
8833         wxGridCellRenderer *rendererOld = renderer;
8834         renderer = renderer->Clone();
8835         rendererOld->DecRef();
8836
8837         wxGridCellEditor *editor = GetEditor(index);
8838         wxGridCellEditor *editorOld = editor;
8839         editor = editor->Clone();
8840         editorOld->DecRef();
8841
8842         // do it even if there are no parameters to reset them to defaults
8843         wxString params = typeName.AfterFirst(wxT(':'));
8844         renderer->SetParameters(params);
8845         editor->SetParameters(params);
8846
8847         // register the new typename
8848         RegisterDataType(typeName, renderer, editor);
8849
8850         // we just registered it, it's the last one
8851         index = m_typeinfo.GetCount() - 1;
8852     }
8853
8854     return index;
8855 }
8856
8857 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
8858 {
8859     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
8860     if (renderer)
8861         renderer->IncRef();
8862
8863     return renderer;
8864 }
8865
8866 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
8867 {
8868     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
8869     if (editor)
8870         editor->IncRef();
8871
8872     return editor;
8873 }
8874
8875 #endif // wxUSE_GRID