src/generic/gridg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gridg.cpp
   3 // Purpose:     wxGenericGrid
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "gridg.h"
  14 #pragma interface
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx/wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25 #include "wx/wx.h"
  26 #endif
  27
  28 #include <string.h>
  29
  30 #include "wx/string.h"
  31 #include "wx/generic/gridg.h"
  32 #include "wx/settings.h"
  33
  34 // Set to zero to use no double-buffering
  35 #ifdef __WXMSW__
  36 #define wxUSE_DOUBLE_BUFFERING 1
  37 #else
  38 #define wxUSE_DOUBLE_BUFFERING 0
  39 #endif
  40
  41 #define wxGRID_DRAG_NONE       0
  42 #define wxGRID_DRAG_LEFT_RIGHT 1
  43 #define wxGRID_DRAG_UP_DOWN    2
  44
  45 IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
  46 IMPLEMENT_DYNAMIC_CLASS(wxGridEvent, wxEvent)
  47
  48 BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
  49     EVT_SIZE(wxGenericGrid::OnSize)
  50     EVT_PAINT(wxGenericGrid::OnPaint)
  51     EVT_ERASE_BACKGROUND(wxGenericGrid::OnEraseBackground)
  52     EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
  53     EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
  54     EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
  55     EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
  56
  57     // default wxGridEvent handlers
  58     EVT_GRID_SELECT_CELL(wxGenericGrid::_OnSelectCell)
  59     EVT_GRID_CREATE_CELL(wxGenericGrid::_OnCreateCell)
  60     EVT_GRID_CHANGE_LABELS(wxGenericGrid::_OnChangeLabels)
  61     EVT_GRID_CHANGE_SEL_LABEL(wxGenericGrid::_OnChangeSelectionLabel)
  62     EVT_GRID_CELL_CHANGE(wxGenericGrid::_OnCellChange)
  63     EVT_GRID_CELL_LCLICK(wxGenericGrid::_OnCellLeftClick)
  64     EVT_GRID_CELL_RCLICK(wxGenericGrid::_OnCellRightClick)
  65     EVT_GRID_LABEL_LCLICK(wxGenericGrid::_OnLabelLeftClick)
  66     EVT_GRID_LABEL_RCLICK(wxGenericGrid::_OnLabelRightClick)
  67
  68 END_EVENT_TABLE()
  69
  70
  71
  72
  73 wxGenericGrid::wxGenericGrid(void)
  74 {
  75   m_batchCount = 0;
  76   m_hScrollBar = (wxScrollBar *) NULL;
  77   m_vScrollBar = (wxScrollBar *) NULL;
  78   m_cellTextColour = *wxBLACK;
  79   m_cellBackgroundColour = *wxWHITE;
  80   m_labelTextColour = *wxBLACK;
  81 //  m_labelBackgroundColour = *wxLIGHT_GREY;
  82   m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
  83   m_labelBackgroundBrush = wxNullBrush;
  84   m_labelTextFont = wxNullFont;
  85   m_cellTextFont = wxNullFont;
  86   m_textItem = (wxTextCtrl *) NULL;
  87   m_currentRectVisible = FALSE;
  88   m_editable = TRUE;
  89 #if defined(__WIN95__)
  90   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
  91 #elif defined(__WXGTK__)
  92   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
  93 #else
  94   m_scrollWidth = 16;
  95 #endif
  96   m_dragStatus = wxGRID_DRAG_NONE;
  97   m_dragRowOrCol = 0;
  98   m_dragStartPosition = 0;
  99   m_dragLastPosition = 0;
 100   m_divisionPen = wxNullPen;
 101   m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
 102   m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
 103   m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
 104   m_totalGridWidth = 0;
 105   m_totalGridHeight = 0;
 106   m_colWidths = (short *) NULL;
 107   m_rowHeights = (short *) NULL;
 108   m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
 109   m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
 110   m_verticalLabelAlignment = wxCENTRE;
 111   m_horizontalLabelAlignment = wxCENTRE;
 112   m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
 113   m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
 114   m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
 115   m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
 116   m_wCursorRow = 0;
 117   m_wCursorColumn = 0;
 118   m_scrollPosX = 0;
 119   m_scrollPosY = 0;
 120   m_editCreated = FALSE;
 121   m_totalRows = 0;
 122   m_totalCols = 0;
 123   m_gridCells = (wxGridCell ***) NULL;
 124   m_rowLabelCells = (wxGridCell **) NULL;
 125   m_colLabelCells = (wxGridCell **) NULL;
 126   m_textItem = (wxTextCtrl *) NULL;
 127 }
 128
 129 bool wxGenericGrid::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
 130  long style, const wxString& name)
 131 {
 132   m_batchCount = 0;
 133   m_editingPanel = (wxPanel *) NULL;
 134   m_hScrollBar = (wxScrollBar *) NULL;
 135   m_vScrollBar = (wxScrollBar *) NULL;
 136   m_cellTextColour = *wxBLACK;
 137   m_cellBackgroundColour = *wxWHITE;
 138   m_labelTextColour = *wxBLACK;
 139 //  m_labelBackgroundColour = *wxLIGHT_GREY;
 140   m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
 141   m_labelBackgroundBrush = wxNullBrush;
 142   m_labelTextFont = * wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxBOLD);
 143   m_cellTextFont = * wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxNORMAL);
 144   m_textItem = (wxTextCtrl *) NULL;
 145   m_currentRectVisible = FALSE;
 146   m_editable = TRUE;
 147 #if defined(__WIN95__)
 148   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
 149 #elif defined(__WXGTK__)
 150   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
 151 #else
 152   m_scrollWidth = 16;
 153 #endif
 154   m_dragStatus = wxGRID_DRAG_NONE;
 155   m_dragRowOrCol = 0;
 156   m_dragStartPosition = 0;
 157   m_dragLastPosition = 0;
 158   m_divisionPen = * wxThePenList->FindOrCreatePen("LIGHT GREY", 1, wxSOLID);
 159   m_doubleBufferingBitmap = (wxBitmap *) NULL;
 160
 161   if (!m_horizontalSashCursor.Ok())
 162   {
 163     m_horizontalSashCursor = wxCursor(wxCURSOR_SIZEWE);
 164     m_verticalSashCursor = wxCursor(wxCURSOR_SIZENS);
 165   }
 166
 167   SetLabelBackgroundColour(m_labelBackgroundColour);
 168
 169   m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
 170   m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
 171   m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
 172   m_totalGridWidth = 0;
 173   m_totalGridHeight = 0;
 174   m_colWidths = (short *) NULL;
 175   m_rowHeights = (short *) NULL;
 176
 177   m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
 178   m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
 179   m_verticalLabelAlignment = wxCENTRE;
 180   m_horizontalLabelAlignment = wxCENTRE;
 181   m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
 182   m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
 183   m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
 184   m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
 185
 186   m_wCursorRow = 0;
 187   m_wCursorColumn = 0;
 188
 189   m_scrollPosX = 0;
 190   m_scrollPosY = 0;
 191
 192   /* Store the rect. coordinates for the current cell */
 193   SetCurrentRect(m_wCursorRow, m_wCursorColumn);
 194
 195   m_editCreated = FALSE;
 196
 197   m_totalRows = 0;
 198   m_totalCols = 0;
 199   m_gridCells = (wxGridCell ***) NULL;
 200   m_rowLabelCells = (wxGridCell **) NULL;
 201   m_colLabelCells = (wxGridCell **) NULL;
 202   m_textItem = (wxTextCtrl *) NULL;
 203
 204   wxPanel::Create(parent, id, pos, size, style, name);
 205
 206   m_editingPanel = new wxPanel(this);
 207
 208   m_textItem = new wxTextCtrl(m_editingPanel, wxGRID_TEXT_CTRL, "",
 209      wxPoint(m_editControlPosition.x, m_editControlPosition.y), wxSize(m_editControlPosition.width, -1),
 210      0);
 211   m_textItem->Show(TRUE);
 212   m_textItem->SetFocus();
 213   int controlW, controlH;
 214
 215   m_textItem->GetSize(&controlW, &controlH);
 216   m_editControlPosition.height = controlH;
 217
 218   m_topOfSheet = m_editControlPosition.y + controlH + 2;
 219
 220   m_editCreated = TRUE;
 221
 222   m_hScrollBar = new wxScrollBar(this, wxGRID_HSCROLL, wxPoint(0, 0), wxSize(20, 100), wxHORIZONTAL);
 223   m_vScrollBar = new wxScrollBar(this, wxGRID_VSCROLL, wxPoint(0, 0), wxSize(100, 20), wxVERTICAL);
 224
 225 //  SetSize(pos.x, pos.y, size.x, size.y);
 226
 227   return TRUE;
 228 }
 229
 230 wxGenericGrid::~wxGenericGrid(void)
 231 {
 232   ClearGrid();
 233 }
 234
 235 void wxGenericGrid::ClearGrid(void)
 236 {
 237   int i,j;
 238   if (m_gridCells)
 239   {
 240     for (i = 0; i < m_totalRows; i++)
 241     {
 242       for (j = 0; j < m_totalCols; j++)
 243         if (m_gridCells[i][j])
 244           delete m_gridCells[i][j];
 245       delete[] m_gridCells[i];
 246     }
 247     delete[] m_gridCells;
 248     m_gridCells = (wxGridCell ***) NULL;
 249   }
 250   if (m_colWidths)
 251     delete[] m_colWidths;
 252   m_colWidths = (short *) NULL;
 253   if (m_rowHeights)
 254     delete[] m_rowHeights;
 255   m_rowHeights = (short *) NULL;
 256
 257   if (m_rowLabelCells)
 258   {
 259     for (i = 0; i < m_totalRows; i++)
 260       delete m_rowLabelCells[i];
 261     delete[] m_rowLabelCells;
 262     m_rowLabelCells = (wxGridCell **) NULL;
 263   }
 264   if (m_colLabelCells)
 265   {
 266     for (i = 0; i < m_totalCols; i++)
 267       delete m_colLabelCells[i];
 268     delete[] m_colLabelCells;
 269     m_colLabelCells = (wxGridCell **) NULL;
 270   }
 271   if (m_doubleBufferingBitmap)
 272   {
 273     delete m_doubleBufferingBitmap;
 274     m_doubleBufferingBitmap = (wxBitmap *) NULL;
 275   }
 276 }
 277
 278 bool wxGenericGrid::CreateGrid(int nRows, int nCols, wxString **cellValues, short *widths,
 279      short defaultWidth, short defaultHeight)
 280 {
 281   m_totalRows = nRows;
 282   m_totalCols = nCols;
 283
 284   int i,j;
 285   m_colWidths = new short[nCols];
 286   m_rowHeights = new short[nRows];
 287   for (i = 0; i < nCols; i++)
 288     if (widths)
 289       m_colWidths[i] = widths[i];
 290     else
 291       m_colWidths[i] = defaultWidth;
 292   for (i = 0; i < nRows; i++)
 293     m_rowHeights[i] = defaultHeight;
 294
 295   m_gridCells = new wxGridCell **[nRows];
 296
 297   for (i = 0; i < nRows; i++)
 298     m_gridCells[i] = new wxGridCell *[nCols];
 299
 300   for (i = 0; i < nRows; i++)
 301     for (j = 0; j < nCols; j++)
 302       if (cellValues)
 303       {
 304         //m_gridCells[i][j] = OnCreateCell();
 305         wxGridEvent g_evt(GetId(), wxEVT_GRID_CREATE_CELL, this, i, j);
 306         GetEventHandler()->ProcessEvent(g_evt);
 307         m_gridCells[i][j] = g_evt.m_cell;
 308         m_gridCells[i][j]->SetTextValue(cellValues[i][j]);
 309       }
 310       else
 311         m_gridCells[i][j] = (wxGridCell *) NULL;
 312
 313   m_rowLabelCells = new wxGridCell *[nRows];
 314   for (i = 0; i < nRows; i++)
 315     m_rowLabelCells[i] = new wxGridCell(this);
 316   m_colLabelCells = new wxGridCell *[nCols];
 317   for (i = 0; i < nCols; i++)
 318     m_colLabelCells[i] = new wxGridCell(this);
 319
 320   m_wCursorRow = m_wCursorColumn = 0;
 321   SetCurrentRect(0, 0);
 322
 323   // Need to determine various dimensions
 324   UpdateDimensions();
 325
 326   // Number of 'lines'
 327   int objectSizeX = m_totalCols;
 328   int pageSizeX = 1;
 329   int viewLengthX = m_totalCols;
 330
 331 /*
 332   m_hScrollBar->SetViewLength(viewLengthX);
 333   m_hScrollBar->SetObjectLength(objectSizeX);
 334   m_hScrollBar->SetPageSize(pageSizeX);
 335 */
 336   m_hScrollBar->SetScrollbar(m_hScrollBar->GetThumbPosition(), pageSizeX, objectSizeX, viewLengthX);
 337
 338   int objectSizeY = m_totalRows;
 339   int pageSizeY = 1;
 340   int viewLengthY = m_totalRows;
 341
 342 /*
 343   m_vScrollBar->SetViewLength(viewLengthY);
 344   m_vScrollBar->SetObjectLength(objectSizeY);
 345   m_vScrollBar->SetPageSize(pageSizeY);
 346 */
 347
 348   m_vScrollBar->SetScrollbar(m_vScrollBar->GetThumbPosition(), pageSizeY, objectSizeY, viewLengthY);
 349
 350   AdjustScrollbars();
 351
 352   //OnChangeLabels();
 353   wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
 354   GetEventHandler()->ProcessEvent(g_evt);
 355
 356   //OnChangeSelectionLabel();
 357   wxGridEvent g_evt2(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL, this);
 358   GetEventHandler()->ProcessEvent(g_evt2);
 359
 360   return TRUE;
 361 }
 362
 363 // Need to determine various dimensions
 364 void wxGenericGrid::UpdateDimensions(void)
 365 {
 366   int canvasWidth, canvasHeight;
 367   GetSize(&canvasWidth, &canvasHeight);
 368
 369   if (m_editCreated && m_editable)
 370   {
 371     int controlW, controlH;
 372     GetTextItem()->GetSize(&controlW, &controlH);
 373     m_topOfSheet = m_editControlPosition.y + controlH + 2;
 374   }
 375   else
 376     m_topOfSheet = 0;
 377   m_rightOfSheet = m_leftOfSheet + m_verticalLabelWidth;
 378   int i;
 379   for (i = m_scrollPosX; i < m_totalCols; i++)
 380   {
 381     if (m_rightOfSheet > canvasWidth)
 382       break;
 383     else
 384       m_rightOfSheet += m_colWidths[i];
 385   }
 386   m_bottomOfSheet = m_topOfSheet + m_horizontalLabelHeight;
 387   for (i = m_scrollPosY; i < m_totalRows; i++)
 388   {
 389     if (m_bottomOfSheet > canvasHeight)
 390       break;
 391     else
 392       m_bottomOfSheet += m_rowHeights[i];
 393   }
 394
 395   m_totalGridWidth = m_leftOfSheet + m_verticalLabelWidth;
 396   for (i = 0; i < m_totalCols; i++)
 397   {
 398     m_totalGridWidth += m_colWidths[i];
 399   }
 400   m_totalGridHeight = m_topOfSheet + m_horizontalLabelHeight;
 401   for (i = 0; i < m_totalRows; i++)
 402   {
 403     m_totalGridHeight += m_rowHeights[i];
 404   }
 405 }
 406
 407 wxGridCell *wxGenericGrid::GetCell(int row, int col) const
 408 {
 409   if (!m_gridCells)
 410     return (wxGridCell *) NULL;
 411
 412   if ((row >= m_totalRows) || (col >= m_totalCols))
 413     return (wxGridCell *) NULL;
 414
 415   wxGridCell *cell = m_gridCells[row][col];
 416   if (!cell)
 417   {
 418     // m_gridCells[row][col] = OnCreateCell();
 419     wxGridEvent g_evt(GetId(), wxEVT_GRID_CREATE_CELL, (wxGenericGrid*) this, row, col);
 420     GetEventHandler()->ProcessEvent(g_evt);
 421     m_gridCells[row][col] = g_evt.m_cell;
 422     return m_gridCells[row][col];
 423   }
 424   else
 425     return cell;
 426 }
 427
 428 void wxGenericGrid::SetGridClippingRegion(wxDC *dc)
 429 {
 430   int m_scrollWidthHoriz = 0;
 431   int m_scrollWidthVert = 0;
 432   int cw, ch;
 433   GetClientSize(&cw, &ch);
 434
 435   if (m_hScrollBar && m_hScrollBar->IsShown())
 436     m_scrollWidthHoriz = m_scrollWidth;
 437   if (m_vScrollBar && m_vScrollBar->IsShown())
 438     m_scrollWidthVert = m_scrollWidth;
 439
 440   // Don't paint over the scrollbars
 441   dc->SetClippingRegion(m_leftOfSheet, m_topOfSheet,
 442      cw - m_scrollWidthVert - m_leftOfSheet, ch - m_scrollWidthHoriz - m_topOfSheet);
 443 }
 444
 445 void wxGenericGrid::OnPaint(wxPaintEvent& WXUNUSED(event))
 446 {
 447   int w, h;
 448   GetClientSize(&w, &h);
 449
 450   bool useDoubleBuffering = (bool) wxUSE_DOUBLE_BUFFERING;
 451   if (useDoubleBuffering)
 452   {
 453     // Reuse the old bitmap if possible
 454
 455     if (!m_doubleBufferingBitmap ||
 456        (m_doubleBufferingBitmap->GetWidth() < w || m_doubleBufferingBitmap->GetHeight() < h))
 457     {
 458         if (m_doubleBufferingBitmap)
 459             delete m_doubleBufferingBitmap;
 460         m_doubleBufferingBitmap = new wxBitmap(w, h);
 461     }
 462     if (!m_doubleBufferingBitmap || !m_doubleBufferingBitmap->Ok())
 463     {
 464         // If we couldn't create a new bitmap, perhaps because resources were low,
 465         // then don't complain, just don't double-buffer
 466         if (m_doubleBufferingBitmap)
 467             delete m_doubleBufferingBitmap;
 468         m_doubleBufferingBitmap = (wxBitmap *) NULL;
 469         useDoubleBuffering = FALSE;
 470     }
 471   }
 472
 473   if (useDoubleBuffering)
 474   {
 475     wxPaintDC paintDC(this);
 476     wxMemoryDC dc(& paintDC);
 477     dc.SelectObject(* m_doubleBufferingBitmap);
 478
 479     PaintGrid(dc);
 480
 481     int vertScrollBarWidth = m_scrollWidth;
 482     int horizScrollBarHeight = m_scrollWidth;
 483     if (m_vScrollBar && !m_vScrollBar->IsShown())
 484       vertScrollBarWidth = 0;
 485     if (m_hScrollBar && !m_hScrollBar->IsShown())
 486       horizScrollBarHeight = 0;
 487
 488     paintDC.Blit(m_leftOfSheet, m_topOfSheet, w - vertScrollBarWidth - m_leftOfSheet, h - horizScrollBarHeight - m_topOfSheet,
 489       &dc, m_leftOfSheet, m_topOfSheet, wxCOPY);
 490
 491     dc.SelectObject(wxNullBitmap);
 492   }
 493   else
 494   {
 495     wxPaintDC dc(this);
 496     PaintGrid(dc);
 497   }
 498 }
 499
 500 void wxGenericGrid::PaintGrid(wxDC& dc)
 501 {
 502     dc.BeginDrawing();
 503     dc.SetOptimization(FALSE);
 504
 505     SetGridClippingRegion(& dc);
 506
 507     DrawLabelAreas(& dc);
 508
 509     DrawEditableArea(& dc);
 510     DrawColumnLabels(& dc);
 511     DrawRowLabels(& dc);
 512     DrawCells(& dc);
 513     DrawGridLines(& dc);
 514
 515     /* Hilight present cell */
 516     SetCurrentRect(m_wCursorRow, m_wCursorColumn);
 517     if (m_currentRectVisible)
 518       HighlightCell(& dc);
 519
 520     dc.DestroyClippingRegion();
 521     dc.SetOptimization(TRUE);
 522     dc.EndDrawing();
 523 }
 524
 525 // Erase (some of) the background.
 526 // Currently, a Windows-only optimisation.
 527 void wxGenericGrid::OnEraseBackground(wxEraseEvent& WXUNUSED(event) )
 528 {
 529     wxClientDC dc(this);
 530     dc.BeginDrawing();
 531     dc.SetOptimization(FALSE);
 532
 533     int w, h;
 534     GetClientSize(& w, & h);
 535     dc.SetBrush(*wxLIGHT_GREY_BRUSH);
 536     dc.SetPen(*wxLIGHT_GREY_PEN);
 537
 538     if (m_hScrollBar && m_hScrollBar->IsShown() && m_vScrollBar && m_vScrollBar->IsShown())
 539     {
 540         dc.DrawRectangle(w - m_scrollWidth, h - m_scrollWidth, m_scrollWidth, m_scrollWidth);
 541     }
 542
 543     dc.SetOptimization(TRUE);
 544     dc.EndDrawing();
 545 }
 546
 547
 548 void wxGenericGrid::DrawLabelAreas(wxDC *dc)
 549 {
 550   int cw, ch;
 551   GetClientSize(&cw, &ch);
 552
 553   dc->SetPen(*wxTRANSPARENT_PEN);
 554 //  dc->SetBrush(*dc->GetBackground());
 555
 556   // Should blank out any area which isn't going to be painted over.
 557 //  dc->DrawRectangle(m_leftOfSheet, m_bottomOfSheet, cw - m_leftOfSheet, ch - m_bottomOfSheet);
 558 //  dc->DrawRectangle(m_rightOfSheet, m_topOfSheet, cw - m_rightOfSheet, ch - m_topOfSheet);
 559
 560   // Paint the label areas
 561   dc->SetBrush(m_labelBackgroundBrush);
 562 //  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_rightOfSheet - m_leftOfSheet + 1, m_horizontalLabelHeight + 1);
 563   dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, cw-m_leftOfSheet, m_horizontalLabelHeight + 1);
 564 //  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, m_bottomOfSheet - m_topOfSheet + 1);
 565   dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, ch-m_topOfSheet);
 566 }
 567
 568 void wxGenericGrid::DrawEditableArea(wxDC *dc)
 569 {
 570   int cw, ch;
 571   GetClientSize(&cw, &ch);
 572
 573   dc->SetPen(*wxTRANSPARENT_PEN);
 574   dc->SetBrush(*wxTheBrushList->FindOrCreateBrush(m_cellBackgroundColour, wxSOLID));
 575 //  dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
 576 //      m_rightOfSheet-(m_leftOfSheet+m_verticalLabelWidth) + 1, m_bottomOfSheet - (m_topOfSheet+m_horizontalLabelHeight) + 1);
 577   dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
 578       cw-(m_leftOfSheet+m_verticalLabelWidth), ch - (m_topOfSheet+m_horizontalLabelHeight));
 579 }
 580
 581 void wxGenericGrid::DrawGridLines(wxDC *dc)
 582 {
 583   int cw, ch;
 584   GetClientSize(&cw, &ch);
 585
 586   int i;
 587
 588   if (m_divisionPen.Ok())
 589   {
 590     dc->SetPen(m_divisionPen);
 591
 592     int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 593
 594     // Draw horizontal grey lines for cells
 595     for (i = m_scrollPosY; i < (m_totalRows+1); i++)
 596     {
 597       if (heightCount > ch)
 598         break;
 599       else
 600       {
 601         dc->DrawLine(m_leftOfSheet, heightCount,
 602                    cw, heightCount);
 603         if (i < m_totalRows)
 604           heightCount += m_rowHeights[i];
 605       }
 606     }
 607   }
 608
 609   if (m_verticalLabelWidth > 0)
 610   {
 611     dc->SetPen(*wxBLACK_PEN);
 612
 613     // Draw horizontal black lines for row labels
 614     int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 615     for (i = m_scrollPosY; i < (m_totalRows+1); i++)
 616     {
 617       if (heightCount > ch)
 618         break;
 619       else
 620       {
 621         dc->DrawLine(m_leftOfSheet, heightCount,
 622                      m_verticalLabelWidth, heightCount);
 623         if (i < m_totalRows)
 624           heightCount += m_rowHeights[i];
 625       }
 626     }
 627     // Draw a black vertical line for row number cells
 628     dc->DrawLine(m_leftOfSheet + m_verticalLabelWidth, m_topOfSheet,
 629       m_leftOfSheet + m_verticalLabelWidth, ch);
 630     // First vertical line
 631     dc->DrawLine(m_leftOfSheet, m_topOfSheet, m_leftOfSheet, ch);
 632
 633     dc->SetPen(*wxWHITE_PEN);
 634
 635     // Draw highlights on row labels
 636     heightCount = m_topOfSheet + m_horizontalLabelHeight;
 637     for (i = m_scrollPosY; i < m_totalRows; i++)
 638     {
 639       if (heightCount > ch)
 640         break;
 641       else
 642       {
 643         dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 644                      m_verticalLabelWidth, heightCount+1);
 645         dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 646                      m_leftOfSheet+1, heightCount + m_rowHeights[i] - 1);
 647         heightCount += m_rowHeights[i];
 648       }
 649     }
 650     // Last one - down to the floor.
 651     dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 652                  m_verticalLabelWidth, heightCount+1);
 653     dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 654                    m_leftOfSheet+1, ch);
 655
 656   }
 657
 658   if (m_divisionPen.Ok())
 659   {
 660     dc->SetPen(m_divisionPen);
 661
 662     // Draw vertical grey lines for cells
 663     int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 664     for (i = m_scrollPosX; i < m_totalCols; i++)
 665     {
 666       if (widthCount > cw)
 667         break;
 668       else
 669       {
 670         // Skip the first one
 671         if (i != m_scrollPosX)
 672         {
 673          dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
 674                        widthCount, m_bottomOfSheet);
 675         }
 676         widthCount += m_colWidths[i];
 677       }
 678     }
 679     // Last one
 680     dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
 681                     widthCount, m_bottomOfSheet);
 682   }
 683
 684   dc->SetPen(*wxBLACK_PEN);
 685
 686   // Draw two black horizontal lines for column number cells
 687   dc->DrawLine(
 688           m_leftOfSheet, m_topOfSheet,
 689           cw, m_topOfSheet);
 690   dc->DrawLine(m_leftOfSheet,  m_topOfSheet + m_horizontalLabelHeight,
 691                cw, m_topOfSheet + m_horizontalLabelHeight);
 692
 693   if (m_horizontalLabelHeight > 0)
 694   {
 695     int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 696
 697     // Draw black vertical lines for column number cells
 698     for (i = m_scrollPosX; i < m_totalCols; i++)
 699     {
 700       if (widthCount > cw)
 701         break;
 702       else
 703       {
 704         dc->DrawLine(widthCount, m_topOfSheet,
 705                       widthCount, m_topOfSheet + m_horizontalLabelHeight);
 706         widthCount += m_colWidths[i];
 707       }
 708     }
 709
 710     // Last one
 711     dc->DrawLine(widthCount, m_topOfSheet,
 712                     widthCount, m_topOfSheet + m_horizontalLabelHeight);
 713
 714     // Draw highlights
 715     dc->SetPen(*wxWHITE_PEN);
 716     widthCount = m_leftOfSheet + m_verticalLabelWidth;
 717
 718     for (i = m_scrollPosX; i < m_totalCols; i++)
 719     {
 720       if (widthCount > cw)
 721         break;
 722       else
 723       {
 724         dc->DrawLine(widthCount+1, m_topOfSheet+1,
 725                      widthCount+m_colWidths[i], m_topOfSheet+1);
 726         dc->DrawLine(widthCount+1, m_topOfSheet+1,
 727                      widthCount+1, m_topOfSheet+m_horizontalLabelHeight);
 728         widthCount += m_colWidths[i];
 729       }
 730     }
 731     // Last one - to the right side of the canvas.
 732     dc->DrawLine(widthCount+1, m_topOfSheet+1,
 733                    cw, m_topOfSheet+1);
 734     dc->DrawLine(widthCount+1, m_topOfSheet+1,
 735                    widthCount+1, m_topOfSheet+m_horizontalLabelHeight);
 736
 737   }
 738 }
 739
 740 void wxGenericGrid::DrawColumnLabels(wxDC *dc)
 741 {
 742   int cw, ch;
 743   GetClientSize(&cw, &ch);
 744
 745   if (m_horizontalLabelHeight == 0)
 746     return;
 747
 748   int i;
 749   wxRect rect;
 750
 751   // Draw letters for columns
 752   rect.y = m_topOfSheet + 1;
 753   rect.height = m_horizontalLabelHeight - 1;
 754
 755   dc->SetTextBackground(m_labelBackgroundColour);
 756   dc->SetBackgroundMode(wxTRANSPARENT);
 757 //  dc->SetTextForeground(m_labelTextColour);
 758
 759   int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 760   for (i = m_scrollPosX; i < m_totalCols; i++)
 761   {
 762      if (widthCount > cw)
 763        break;
 764      else
 765      {
 766        rect.x = 1 + widthCount;
 767        rect.width = m_colWidths[i];
 768        DrawColumnLabel(dc, &rect, i);
 769
 770        widthCount += m_colWidths[i];
 771      }
 772   }
 773 }
 774
 775 void wxGenericGrid::DrawColumnLabel(wxDC *dc, wxRect *rect, int col)
 776 {
 777   wxGridCell *cell = GetLabelCell(wxHORIZONTAL, col);
 778   if (cell)
 779   {
 780     wxRect rect2;
 781     rect2 = *rect;
 782     rect2.x += 3;
 783     rect2.y += 2;
 784     rect2.width -= 5;
 785     rect2.height -= 4;
 786     dc->SetTextForeground(GetLabelTextColour());
 787     dc->SetFont(GetLabelTextFont());
 788         if ( !cell->GetTextValue().IsNull() )
 789         DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxHORIZONTAL));
 790   }
 791 }
 792
 793 void wxGenericGrid::DrawRowLabels(wxDC *dc)
 794 {
 795   int cw, ch;
 796   GetClientSize(&cw, &ch);
 797
 798   if (m_verticalLabelWidth == 0)
 799     return;
 800
 801   int i;
 802   wxRect rect;
 803
 804   // Draw numbers for rows
 805   rect.x = m_leftOfSheet;
 806   rect.width = m_verticalLabelWidth;
 807
 808   int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 809
 810   dc->SetTextBackground(m_labelBackgroundColour);
 811   dc->SetBackgroundMode(wxTRANSPARENT);
 812
 813   for (i = m_scrollPosY; i < m_totalRows; i++)
 814   {
 815      if (heightCount > ch)
 816        break;
 817      else
 818      {
 819        rect.y = 1 + heightCount;
 820        rect.height = m_rowHeights[i];
 821        DrawRowLabel(dc, &rect, i);
 822
 823        heightCount += m_rowHeights[i];
 824      }
 825   }
 826 }
 827
 828 void wxGenericGrid::DrawRowLabel(wxDC *dc, wxRect *rect, int row)
 829 {
 830   wxGridCell *cell = GetLabelCell(wxVERTICAL, row);
 831   if (cell)
 832   {
 833     wxRect rect2;
 834     rect2 = *rect;
 835     rect2.x += 3;
 836     rect2.y += 2;
 837     rect2.width -= 5;
 838     rect2.height -= 4;
 839     dc->SetTextForeground(GetLabelTextColour());
 840     dc->SetFont(GetLabelTextFont());
 841         if ( !cell->GetTextValue().IsNull() )
 842         DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxVERTICAL));
 843   }
 844 }
 845
 846 void wxGenericGrid::DrawCells(wxDC *dc)
 847 {
 848   int cw, ch;
 849   GetClientSize(&cw, &ch);
 850
 851   int i,j;
 852
 853   // Draw value corresponding to each cell
 854   for (i = m_scrollPosY; i < m_totalRows; i++)
 855   {
 856     for (j = m_scrollPosX; j < m_totalCols; j++)
 857     {
 858       SetCurrentRect(i, j, cw, ch);
 859       if (m_currentRectVisible)
 860       {
 861         DrawCellBackground(dc, &m_currentRect, i, j);
 862         DrawCellValue(dc, &m_currentRect, i, j);
 863       }
 864       if (m_currentRect.x > cw)
 865         break;
 866     }
 867     if (m_currentRect.y > ch)
 868       break;
 869   }
 870   dc->SetBackgroundMode(wxSOLID);
 871   dc->SetPen(*wxBLACK_PEN);
 872 }
 873
 874 void wxGenericGrid::DrawCellBackground(wxDC *dc, wxRect *rect, int row, int col)
 875 {
 876   wxGridCell *cell = GetCell(row, col);
 877   if (cell)
 878   {
 879     dc->SetBrush(cell->GetBackgroundBrush());
 880     dc->SetPen(*wxTRANSPARENT_PEN);
 881
 882 #if 0    // In wxWin 2.0 the dc code is exact. RR.
 883 #ifdef __WXMOTIF__
 884     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 885 #else
 886     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width, rect->height);
 887 #endif
 888 #endif
 889
 890     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 891
 892     dc->SetPen(*wxBLACK_PEN);
 893   }
 894 }
 895
 896 void wxGenericGrid::DrawCellValue(wxDC *dc, wxRect *rect, int row, int col)
 897 {
 898   wxGridCell *cell = GetCell(row, col);
 899   if (cell)
 900   {
 901     wxBitmap *bitmap = cell->GetCellBitmap();
 902     wxRect rect2;
 903     rect2 = *rect;
 904     rect2.x += 3;
 905     rect2.y += 2;
 906     rect2.width -= 5;
 907     rect2.height -= 4;
 908
 909     if (bitmap)
 910     {
 911       DrawBitmapRect(dc, bitmap, &rect2, cell->GetAlignment());
 912     }
 913     else
 914     {
 915       dc->SetBackgroundMode(wxTRANSPARENT);
 916       dc->SetTextForeground(cell->GetTextColour());
 917       dc->SetFont(cell->GetFont());
 918
 919           if ( !cell->GetTextValue().IsNull() )
 920         DrawTextRect(dc, cell->GetTextValue(), &rect2, cell->GetAlignment());
 921     }
 922   }
 923 }
 924
 925 void wxGenericGrid::AdjustScrollbars(void)
 926 {
 927   int cw, ch;
 928   GetClientSize(&cw, &ch);
 929
 930   // We find the view size by seeing how many rows/cols fit on
 931   // the current view.
 932   // BUT... this means that the scrollbar should be adjusted every time
 933   // it's scrolled, as well as when sized, because with variable size rows/cols,
 934   // the number of rows/col visible on the view differs according to what bit
 935   // you're looking at. The object length is always the same, but the
 936   // view length differs.
 937
 938   // Since this may not be known until the end of this function, we should probably call AdjustScrollbars
 939   // twice.
 940   int vertScrollBarWidth = m_scrollWidth;
 941   int horizScrollBarHeight = m_scrollWidth;
 942   if (m_vScrollBar && !m_vScrollBar->IsShown())
 943     vertScrollBarWidth = 0;
 944   if (m_hScrollBar && !m_hScrollBar->IsShown())
 945     horizScrollBarHeight = 0;
 946
 947   int noHorizSteps = 0;
 948   int noVertSteps = 0;
 949
 950   if (m_totalGridWidth + vertScrollBarWidth <= cw)
 951     noHorizSteps = 0;
 952   else
 953   {
 954     noHorizSteps = 0;
 955     int widthCount = 0;
 956
 957     int i;
 958         int nx = 0;
 959     for (i = m_scrollPosX ; i < m_totalCols; i++)
 960     {
 961       widthCount += m_colWidths[i];
 962           // A partial bit doesn't count, we still have to scroll to see the
 963           // rest of it
 964       if (widthCount + m_leftOfSheet + m_verticalLabelWidth > (cw-vertScrollBarWidth))
 965         break;
 966           else
 967             nx ++;
 968
 969     }
 970
 971     noHorizSteps += nx;
 972   }
 973   if (m_totalGridHeight + horizScrollBarHeight <= ch)
 974     noVertSteps = 0;
 975   else
 976   {
 977     noVertSteps = 0;
 978     int heightCount = 0;
 979
 980     int i;
 981         int ny = 0;
 982     for (i = m_scrollPosY ; i < m_totalRows; i++)
 983     {
 984       heightCount += m_rowHeights[i];
 985           // A partial bit doesn't count, we still have to scroll to see the
 986           // rest of it
 987       if (heightCount + m_topOfSheet + m_horizontalLabelHeight > (ch-horizScrollBarHeight))
 988         break;
 989           else
 990             ny ++;
 991     }
 992
 993     noVertSteps += ny;
 994   }
 995
 996   if (m_totalGridWidth + vertScrollBarWidth <= cw)
 997   {
 998         if ( m_hScrollBar )
 999         m_hScrollBar->Show(FALSE);
1000     SetScrollPosX(0);
1001   }
1002   else
1003   {
1004       if ( m_hScrollBar )
1005           m_hScrollBar->Show(TRUE);
1006   }
1007
1008   if (m_totalGridHeight + horizScrollBarHeight <= ch)
1009   {
1010       if ( m_vScrollBar )
1011           m_vScrollBar->Show(FALSE);
1012       SetScrollPosY(0);
1013   }
1014   else
1015   {
1016       if ( m_vScrollBar )
1017           m_vScrollBar->Show(TRUE);
1018   }
1019
1020   UpdateDimensions(); // Necessary in case m_scrollPosX/Y changed
1021
1022   vertScrollBarWidth = m_scrollWidth;
1023   horizScrollBarHeight = m_scrollWidth;
1024   if (m_vScrollBar && !m_vScrollBar->IsShown())
1025     vertScrollBarWidth = 0;
1026   if (m_hScrollBar && !m_hScrollBar->IsShown())
1027     horizScrollBarHeight = 0;
1028
1029   if (m_hScrollBar && m_hScrollBar->IsShown())
1030   {
1031     int nCols = GetCols();
1032     m_hScrollBar->SetScrollbar(m_hScrollBar->GetThumbPosition(), wxMax(noHorizSteps, 1), (noHorizSteps == 0) ? 1 : nCols, wxMax(noHorizSteps, 1));
1033
1034 /*
1035     m_hScrollBar->SetSize(m_leftOfSheet, ch - m_scrollWidth -2,   // why -2 ? Robert.
1036       cw - vertScrollBarWidth - m_leftOfSheet, m_scrollWidth);
1037 */
1038     m_hScrollBar->SetSize(m_leftOfSheet, ch - m_scrollWidth,
1039       cw - vertScrollBarWidth - m_leftOfSheet, m_scrollWidth);
1040
1041   }
1042
1043   if (m_vScrollBar && m_vScrollBar->IsShown())
1044   {
1045     int nRows = GetRows();
1046
1047     m_vScrollBar->SetScrollbar(m_vScrollBar->GetThumbPosition(), wxMax(noVertSteps, 1), (noVertSteps == 0) ? 1 : nRows, wxMax(noVertSteps, 1));
1048     m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1049        m_scrollWidth, ch - m_topOfSheet - horizScrollBarHeight);
1050   }
1051 }
1052
1053 void wxGenericGrid::OnSize(wxSizeEvent& WXUNUSED(event) )
1054 {
1055   if (!m_vScrollBar || !m_hScrollBar)
1056           return;
1057
1058   AdjustScrollbars();
1059
1060   int cw, ch;
1061   GetClientSize(&cw, &ch);
1062
1063   if (m_editCreated && m_editingPanel && GetTextItem() && GetTextItem()->IsShown())
1064   {
1065     m_editingPanel->SetSize(0, 0, cw, m_editControlPosition.height + m_editControlPosition.y + 2);
1066     GetTextItem()->SetSize(m_editControlPosition.x, m_editControlPosition.y,
1067       cw - 2*m_editControlPosition.x, m_editControlPosition.height);
1068   }
1069 }
1070
1071 bool wxGenericGrid::CellHitTest(int x, int y, int *row, int *col)
1072 {
1073       // Find the selected cell and call OnSelectCell
1074       if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
1075           x <= m_rightOfSheet && y <= m_bottomOfSheet)
1076       {
1077          // Calculate the cell number from x and y
1078          x -= (m_verticalLabelWidth + m_leftOfSheet);
1079          y -= (m_topOfSheet + m_horizontalLabelHeight);
1080
1081          int i;
1082
1083          // Now we need to do a hit test for which row we're on
1084          int currentHeight = 0;
1085          for (i = m_scrollPosY; i < m_totalRows; i++)
1086          {
1087             if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))
1088             {
1089               *row = i;
1090               break;
1091             }
1092             currentHeight += m_rowHeights[i];
1093          }
1094
1095          // Now we need to do a hit test for which column we're on
1096          int currentWidth = 0;
1097          for (i = m_scrollPosX; i < m_totalCols; i++)
1098          {
1099             if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))
1100             {
1101               *col = i;
1102               break;
1103             }
1104             currentWidth += m_colWidths[i];
1105          }
1106          return TRUE;
1107        }
1108   return FALSE;
1109 }
1110
1111 bool wxGenericGrid::LabelSashHitTest(int x, int y, int *orientation, int *rowOrCol, int *startPos)
1112 {
1113   int i;
1114   int tolerance = 3;
1115
1116   if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= m_topOfSheet &&
1117       x <= m_rightOfSheet && y <= (m_topOfSheet + m_horizontalLabelHeight))
1118   {
1119     // We may be on a column label sash.
1120     int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
1121     for (i = m_scrollPosX; i < m_totalCols; i++)
1122     {
1123       if (x >= (currentWidth + m_colWidths[i] - tolerance) && x <= (currentWidth + m_colWidths[i] + tolerance))
1124       {
1125         *orientation = wxHORIZONTAL;
1126         *rowOrCol = i;
1127         *startPos = currentWidth;
1128         return TRUE;
1129       }
1130       currentWidth += m_colWidths[i];
1131     }
1132     return FALSE;
1133   }
1134   else if (x >= m_leftOfSheet && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
1135       x <= (m_leftOfSheet + m_verticalLabelWidth) && y <= m_bottomOfSheet)
1136   {
1137     // We may be on a row label sash.
1138     int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
1139     for (i = m_scrollPosY; i < m_totalRows; i++)
1140     {
1141       if (y >= (currentHeight + m_rowHeights[i] - tolerance) && y <= (currentHeight + m_rowHeights[i] + tolerance))
1142       {
1143         *orientation = wxVERTICAL;
1144         *rowOrCol = i;
1145         *startPos = currentHeight;
1146         return TRUE;
1147       }
1148       currentHeight += m_rowHeights[i];
1149     }
1150     return FALSE;
1151   }
1152   return FALSE;
1153 }
1154
1155 bool wxGenericGrid::LabelHitTest(int x, int y, int *row, int *col)
1156 {
1157       // Find the selected label
1158       if (x >= m_leftOfSheet && y >= m_topOfSheet &&
1159           x <= m_rightOfSheet && y <= m_bottomOfSheet)
1160       {
1161          // Calculate the cell number from x and y
1162          x -= m_leftOfSheet;
1163          y -= m_topOfSheet;
1164
1165          int i;
1166
1167          // Now we need to do a hit test for which row we're on
1168          int currentHeight = m_horizontalLabelHeight;
1169          for (i = m_scrollPosY; i < m_totalRows; i++)
1170          {
1171             if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))
1172             {
1173               *row = i;
1174               break;
1175             }
1176             currentHeight += m_rowHeights[i];
1177          }
1178          if (y >= 0 && y <= m_horizontalLabelHeight)
1179          {
1180              *row = -1;
1181          }
1182
1183          // Now we need to do a hit test for which column we're on
1184          int currentWidth = m_verticalLabelWidth;
1185          for (i = m_scrollPosX; i < m_totalCols; i++)
1186          {
1187             if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))
1188             {
1189               *col = i;
1190               break;
1191             }
1192             currentWidth += m_colWidths[i];
1193          }
1194          if (x >= 0 && x <= m_verticalLabelWidth)
1195          {
1196              *col = -1;
1197          }
1198
1199          if ((*col == -1) || (*row == -1))
1200          {
1201              return TRUE;
1202          }
1203        }
1204   return FALSE;
1205 }
1206
1207 void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
1208 {
1209   if (ev.LeftDown())
1210   {
1211     wxClientDC dc(this);
1212     dc.BeginDrawing();
1213
1214     int row, col;
1215     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1216     {
1217       OnSelectCellImplementation(& dc, row, col);
1218
1219       //OnCellLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1220       wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_LCLICK, this,
1221                         row, col, (int)ev.GetX(), (int)ev.GetY(),
1222                         ev.ControlDown(), ev.ShiftDown());
1223       GetEventHandler()->ProcessEvent(g_evt);
1224
1225     }
1226     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1227     {
1228       //OnLabelLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1229       wxGridEvent g_evt(GetId(), wxEVT_GRID_LABEL_LCLICK, this,
1230                         row, col, (int)ev.GetX(), (int)ev.GetY(),
1231                         ev.ControlDown(), ev.ShiftDown());
1232       GetEventHandler()->ProcessEvent(g_evt);
1233
1234     }
1235     dc.EndDrawing();
1236   }
1237   else if (ev.Dragging() && ev.LeftIsDown())
1238   {
1239     switch (m_dragStatus)
1240     {
1241       case wxGRID_DRAG_NONE:
1242       {
1243         int orientation;
1244         if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &m_dragRowOrCol, &m_dragStartPosition))
1245         {
1246           if (orientation == wxHORIZONTAL)
1247           {
1248             m_dragStatus = wxGRID_DRAG_LEFT_RIGHT;
1249             SetCursor(m_horizontalSashCursor);
1250             m_dragLastPosition = (int)ev.GetX();
1251           }
1252           else
1253           {
1254             m_dragStatus = wxGRID_DRAG_UP_DOWN;
1255             SetCursor(m_verticalSashCursor);
1256             m_dragLastPosition = (int)ev.GetY();
1257           }
1258           wxClientDC dc(this);
1259           dc.BeginDrawing();
1260           dc.SetLogicalFunction(wxINVERT);
1261           if (orientation == wxHORIZONTAL)
1262             dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);
1263           else
1264             dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());
1265           dc.EndDrawing();
1266
1267           CaptureMouse();
1268         }
1269         break;
1270       }
1271       case wxGRID_DRAG_LEFT_RIGHT:
1272       {
1273         wxClientDC dc(this);
1274         dc.BeginDrawing();
1275         dc.SetLogicalFunction(wxINVERT);
1276         dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);
1277
1278         dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);
1279         dc.EndDrawing();
1280
1281         m_dragLastPosition = (int)ev.GetX();
1282         SetCursor(m_horizontalSashCursor);
1283         break;
1284       }
1285       case wxGRID_DRAG_UP_DOWN:
1286       {
1287         wxClientDC dc(this);
1288         dc.BeginDrawing();
1289         dc.SetLogicalFunction(wxINVERT);
1290         dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);
1291
1292         dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());
1293         dc.EndDrawing();
1294
1295         m_dragLastPosition = (int)ev.GetY();
1296         SetCursor(m_verticalSashCursor);
1297         break;
1298       }
1299     }
1300   }
1301   else if (ev.Moving())
1302   {
1303     int rowOrCol, orientation, startPos;
1304     if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &rowOrCol, &startPos))
1305     {
1306       if (orientation == wxHORIZONTAL)
1307         SetCursor(m_horizontalSashCursor);
1308        else
1309         SetCursor(m_verticalSashCursor);
1310     }
1311     else
1312       SetCursor(*wxSTANDARD_CURSOR);
1313   }
1314   else if (ev.LeftUp())
1315   {
1316     switch (m_dragStatus)
1317     {
1318       case wxGRID_DRAG_LEFT_RIGHT:
1319       {
1320         wxClientDC dc(this);
1321         dc.BeginDrawing();
1322         dc.SetLogicalFunction(wxINVERT);
1323         dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);
1324         dc.SetLogicalFunction(wxCOPY);
1325         dc.EndDrawing();
1326
1327         ReleaseMouse();
1328         if (ev.GetX() > m_dragStartPosition)
1329         {
1330           m_colWidths[m_dragRowOrCol] = (short)(ev.GetX() - m_dragStartPosition);
1331           UpdateDimensions();
1332           AdjustScrollbars();
1333           Refresh();
1334         }
1335         SetCursor(*wxSTANDARD_CURSOR);
1336         int cw, ch;
1337         GetClientSize(&cw, &ch);
1338                 wxSizeEvent evt;
1339         OnSize(evt);
1340         break;
1341       }
1342       case wxGRID_DRAG_UP_DOWN:
1343       {
1344         wxClientDC dc(this);
1345         dc.BeginDrawing();
1346         dc.SetLogicalFunction(wxINVERT);
1347         dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);
1348         dc.SetLogicalFunction(wxCOPY);
1349         dc.EndDrawing();
1350
1351         ReleaseMouse();
1352         if (ev.GetY() > m_dragStartPosition)
1353         {
1354           m_rowHeights[m_dragRowOrCol] = (short)(ev.GetY() - m_dragStartPosition);
1355           UpdateDimensions();
1356           AdjustScrollbars();
1357           Refresh();
1358         }
1359         SetCursor(*wxSTANDARD_CURSOR);
1360         break;
1361       }
1362     }
1363     m_dragStatus = wxGRID_DRAG_NONE;
1364   }
1365   else if (ev.RightDown())
1366   {
1367     int row, col;
1368     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1369     {
1370       //OnCellRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1371       wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_RCLICK, this,
1372                         row, col, (int)ev.GetX(), (int)ev.GetY(),
1373                         ev.ControlDown(), ev.ShiftDown());
1374       GetEventHandler()->ProcessEvent(g_evt);
1375
1376     }
1377     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1378     {
1379       //OnLabelRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1380       wxGridEvent g_evt(GetId(), wxEVT_GRID_LABEL_RCLICK, this,
1381                         row, col, (int)ev.GetX(), (int)ev.GetY(),
1382                         ev.ControlDown(), ev.ShiftDown());
1383       GetEventHandler()->ProcessEvent(g_evt);
1384     }
1385   }
1386 }
1387
1388 void wxGenericGrid::OnSelectCellImplementation(wxDC *dc, int row, int col)
1389 {
1390   m_wCursorColumn = col;
1391   m_wCursorRow = row;
1392
1393   //OnChangeSelectionLabel();
1394   wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL, this);
1395   GetEventHandler()->ProcessEvent(g_evt);
1396
1397   SetGridClippingRegion(dc);
1398
1399   // Remove the highlight from the old cell
1400   if (m_currentRectVisible)
1401      HighlightCell(dc);
1402
1403   // Highlight the new cell and copy its content to the edit control
1404   SetCurrentRect(m_wCursorRow, m_wCursorColumn);
1405   wxGridCell *cell = GetCell(m_wCursorRow, m_wCursorColumn);
1406   if (cell)
1407   {
1408         if ( cell->GetTextValue().IsNull() )
1409                 m_textItem->SetValue("");
1410         else
1411         m_textItem->SetValue(cell->GetTextValue());
1412   }
1413
1414   SetGridClippingRegion(dc);
1415
1416   // 1) Why isn't this needed for Windows??
1417   // Probably because of the SetValue?? JS.
1418   // 2) Arrrrrgh. This isn't needed anywhere,
1419   // of course. One hour of debugging... RR.
1420   // Put back for Motif only on advice of Michael Bedward
1421 #ifdef __WXMOTIF__
1422   HighlightCell(dc);
1423 #endif
1424
1425   dc->DestroyClippingRegion();
1426
1427   //OnSelectCell(row, col);
1428   wxGridEvent g_evt2(GetId(), wxEVT_GRID_SELECT_CELL, this, row, col);
1429   GetEventHandler()->ProcessEvent(g_evt2);
1430 }
1431
1432 wxGridCell *wxGenericGrid::OnCreateCell(void)
1433 {
1434   return new wxGridCell(this);
1435 }
1436
1437 void wxGenericGrid::OnChangeLabels(void)
1438 {
1439   char buf[100];
1440   int i;
1441   for (i = 0; i < m_totalRows; i++)
1442   {
1443     sprintf(buf, "%d", i+1);
1444     SetLabelValue(wxVERTICAL, buf, i);
1445   }
1446   // A...Z,AA...ZZ,AAA...ZZZ, etc.
1447   for (i = 0; i < m_totalCols; i++)
1448   {
1449     int j;
1450     int noTimes = (i/26 + 1);
1451     int ch = (i % 26) + 65;
1452     buf[0] = 0;
1453     for (j = 0; j < noTimes; j++)
1454     {
1455       char buf2[20];
1456       sprintf(buf2, "%c", (char)ch);
1457       strcat(buf, buf2);
1458     }
1459     SetLabelValue(wxHORIZONTAL, buf, i);
1460   }
1461 }
1462
1463 void wxGenericGrid::OnChangeSelectionLabel(void)
1464 {
1465   if (!GetEditable())
1466     return;
1467
1468   wxString rowLabel(GetLabelValue(wxVERTICAL, GetCursorRow()));
1469   wxString colLabel(GetLabelValue(wxHORIZONTAL, GetCursorColumn()));
1470
1471   wxString newLabel = colLabel + rowLabel;
1472   if ((newLabel.Length() > 0) && (newLabel.Length() <= 8) && GetTextItem())
1473   {
1474 //    GetTextItem()->SetLabel(newLabel);
1475   }
1476 }
1477
1478 void wxGenericGrid::HighlightCell(wxDC *dc)
1479 {
1480   dc->SetLogicalFunction(wxINVERT);
1481
1482   // Top
1483   dc->DrawLine( m_currentRect.x + 1,
1484                 m_currentRect.y + 1,
1485                 m_currentRect.x + m_currentRect.width - 1,
1486                 m_currentRect.y + 1);
1487   // Right
1488   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1489                 m_currentRect.y + 1,
1490                 m_currentRect.x + m_currentRect.width - 1,
1491                 m_currentRect.y +m_currentRect.height - 1 );
1492   // Bottom
1493   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1494                 m_currentRect.y + m_currentRect.height - 1,
1495                 m_currentRect.x + 1,
1496                 m_currentRect.y + m_currentRect.height - 1);
1497   // Left
1498   dc->DrawLine( m_currentRect.x + 1,
1499                 m_currentRect.y + m_currentRect.height - 1,
1500                 m_currentRect.x + 1,
1501                 m_currentRect.y + 1);
1502
1503   dc->SetLogicalFunction(wxCOPY);
1504 }
1505
1506 void wxGenericGrid::DrawCellText(void)
1507 {
1508   if (!m_currentRectVisible)
1509     return;
1510
1511   wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1512   if (!cell)
1513     return;
1514
1515   static wxChar szEdit[300];
1516
1517   wxClientDC dc(this);
1518   dc.BeginDrawing();
1519
1520   SetGridClippingRegion(& dc);
1521
1522   dc.SetBackgroundMode(wxTRANSPARENT);
1523   dc.SetBrush(cell->GetBackgroundBrush());
1524
1525   wxStrcpy(szEdit, m_textItem->GetValue());
1526
1527   wxRect rect;
1528   rect = m_currentRect;
1529   rect.x += 3;
1530   rect.y += 2;
1531   rect.width -= 5;
1532   rect.height -= 4;
1533
1534   DrawTextRect(& dc, _T("                                    "), &rect, wxLEFT);
1535   DrawTextRect(& dc, szEdit, &rect, cell->GetAlignment());
1536
1537   dc.DestroyClippingRegion();
1538
1539   dc.SetBackgroundMode(wxSOLID);
1540
1541   dc.EndDrawing();
1542 }
1543
1544 void wxGenericGrid::SetCurrentRect(int Row, int Column, int canvasW, int canvasH)
1545 {
1546   int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
1547   int i;
1548   for (i = m_scrollPosX; i < Column; i++)
1549     currentWidth += m_colWidths[i];
1550
1551   int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
1552   for (i = m_scrollPosY; i < Row; i++)
1553     currentHeight += m_rowHeights[i];
1554
1555   m_currentRect.x = currentWidth;
1556   m_currentRect.y = currentHeight;
1557   m_currentRect.width = m_colWidths ? (m_colWidths[Column]) : 0;
1558   m_currentRect.height = m_rowHeights ? (m_rowHeights[Row]) : 0;
1559
1560   if (Row < m_scrollPosY || Column < m_scrollPosX)
1561     m_currentRectVisible = FALSE;
1562   else if ((canvasW != -1 && canvasH != -1) && (m_currentRect.x > canvasW || m_currentRect.y > canvasH))
1563     m_currentRectVisible = FALSE;
1564   else m_currentRectVisible = TRUE;
1565 }
1566
1567 static bool wxRectIntersection(wxRect *rect1, wxRect *rect2, wxRect *rect3)
1568 {
1569   int x2_1 = rect1->x + rect1->width;
1570   int y2_1 = rect1->y + rect1->height;
1571
1572   int x2_2 = rect2->x + rect2->width;
1573   int y2_2 = rect2->y + rect2->height;
1574
1575   int x2_3, y2_3;
1576
1577   // Check for intersection
1578   if ((rect1->x > x2_2) || (rect2->x > x2_1) ||
1579       (rect1->y > y2_2) || (rect2->y > y2_1))
1580   {
1581     // No intersection
1582     rect3->x = rect3->y = rect3->width = rect3->height = 0;
1583     return FALSE;
1584   }
1585
1586   if (rect1->x > rect2->x)
1587     rect3->x = rect1->x;
1588   else
1589     rect3->x = rect2->x;
1590   if (rect1->y > rect2->y)
1591     rect3->y = rect1->y;
1592   else
1593     rect3->y = rect2->y;
1594
1595   if (x2_1 > x2_2)
1596     x2_3 = x2_2;
1597   else
1598     x2_3 = x2_1;
1599   if (y2_1 > y2_2)
1600     y2_3 = y2_2;
1601   else
1602     y2_3 = y2_1;
1603
1604   rect3->width = (int)(x2_3 - rect3->x);
1605   rect3->height = (int)(y2_3 - rect3->y);
1606   return TRUE;
1607 }
1608
1609 void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRect *rect, int flag)
1610 {
1611   dc->BeginDrawing();
1612
1613   // Ultimately, this functionality should be built into wxWindows,
1614   // and optimized for each platform. E.g. on Windows, use DrawText
1615   // passing a clipping rectangle, so that the wxWindows clipping region
1616   // does not have to be used to implement this.
1617
1618   // If we're already clipping, we need to find the intersection
1619   // between current clipping area and text clipping area.
1620
1621   wxRect clipRect;
1622   wxRect clipRect2;
1623   long clipX, clipY, clipW, clipH;
1624   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1625   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1626   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1627
1628   bool alreadyClipping = TRUE;
1629
1630   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1631   {
1632     alreadyClipping = FALSE;
1633     clipRect2.x = rect->x; clipRect2.y = rect->y;
1634     clipRect2.width = rect->width; clipRect2.height = rect->height;
1635   }
1636   else
1637   {
1638     // Find intersection.
1639     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1640       return;
1641   }
1642
1643   if (alreadyClipping)
1644     dc->DestroyClippingRegion();
1645
1646   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1647   long textWidth, textHeight;
1648
1649   dc->GetTextExtent(text, &textWidth, &textHeight);
1650
1651   // Do alignment
1652   float x,y;
1653   switch (flag)
1654   {
1655     case wxRIGHT:
1656     {
1657       x = (rect->x + rect->width - textWidth - 1.0);
1658       y = (rect->y + (rect->height - textHeight)/2.0);
1659       break;
1660     }
1661     case wxCENTRE:
1662     {
1663       x = (rect->x + (rect->width - textWidth)/2.0);
1664       y = (rect->y + (rect->height - textHeight)/2.0);
1665       break;
1666     }
1667     case wxLEFT:
1668     default:
1669     {
1670       x = (rect->x + 1.0);
1671       y = (rect->y + (rect->height - textHeight)/2.0);
1672       break;
1673     }
1674   }
1675   dc->DrawText(text, (long)x, (long)y );
1676
1677   dc->DestroyClippingRegion();
1678
1679   // Restore old clipping
1680   if (alreadyClipping)
1681     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1682
1683   dc->EndDrawing();
1684 }
1685
1686 void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRect *rect, int flag)
1687 {
1688   dc->BeginDrawing();
1689
1690   // Ultimately, this functionality should be built into wxWindows,
1691   // and optimized for each platform. E.g. on Windows, use DrawText
1692   // passing a clipping rectangle, so that the wxWindows clipping region
1693   // does not have to be used to implement this.
1694
1695   // If we're already clipping, we need to find the intersection
1696   // between current clipping area and text clipping area.
1697
1698   wxRect clipRect;
1699   wxRect clipRect2;
1700   long clipX, clipY, clipW, clipH;
1701   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1702   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1703   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1704
1705   bool alreadyClipping = TRUE;
1706
1707   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1708   {
1709     alreadyClipping = FALSE;
1710     clipRect2.x = rect->x; clipRect2.y = rect->y;
1711     clipRect2.width = rect->width; clipRect2.height = rect->height;
1712   }
1713   else
1714   {
1715     // Find intersection.
1716     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1717       return;
1718   }
1719
1720   if (alreadyClipping)
1721     dc->DestroyClippingRegion();
1722
1723   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1724   float bitmapWidth, bitmapHeight;
1725
1726   bitmapWidth = bitmap->GetWidth();
1727   bitmapHeight = bitmap->GetHeight();
1728
1729   // Do alignment
1730   long x,y;
1731   switch (flag)
1732   {
1733     case wxRIGHT:
1734     {
1735       x = (long)(rect->x + rect->width - bitmapWidth - 1);
1736       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1737       break;
1738     }
1739     case wxCENTRE:
1740     {
1741       x = (long)(rect->x + (rect->width - bitmapWidth)/2.0);
1742       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1743       break;
1744     }
1745     case wxLEFT:
1746     default:
1747     {
1748       x = (long)(rect->x + 1);
1749       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1750       break;
1751     }
1752   }
1753   wxMemoryDC dcTemp;
1754   dcTemp.SelectObject(*bitmap);
1755
1756   dc->Blit( (long)x, (long)y, (long)bitmapWidth, (long)bitmapHeight, &dcTemp, 0, 0);
1757   dcTemp.SelectObject(wxNullBitmap);
1758
1759   dc->DestroyClippingRegion();
1760
1761   // Restore old clipping
1762   if (alreadyClipping)
1763     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1764
1765   dc->EndDrawing();
1766 }
1767
1768 void wxGenericGrid::OnActivate(bool active)
1769 {
1770   if (active)
1771   {
1772     // Edit control should always have the focus
1773     if (GetTextItem() && GetEditable())
1774     {
1775       GetTextItem()->SetFocus();
1776       wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1777       if (cell)
1778         GetTextItem()->SetValue(cell->GetTextValue());
1779     }
1780   }
1781 }
1782
1783 void wxGenericGrid::SetCellValue(const wxString& val, int row, int col)
1784 {
1785   wxGridCell *cell = GetCell(row, col);
1786   if (cell)
1787   {
1788     cell->SetTextValue(val);
1789
1790     RefreshCell(row, col, TRUE);
1791   }
1792 }
1793
1794 void wxGenericGrid::RefreshCell(int row, int col, bool setText)
1795 {
1796     // Don't refresh within a pair of batch brackets
1797     if (GetBatchCount() > 0)
1798         return;
1799
1800     int cw, ch;
1801     GetClientSize(&cw, &ch);
1802
1803     SetCurrentRect(row, col, cw, ch);
1804     if (m_currentRectVisible)
1805     {
1806       wxGridCell *cell = GetCell(row, col);
1807
1808       bool currentPos = FALSE;
1809       if (row == m_wCursorRow && col == m_wCursorColumn && GetTextItem() && GetTextItem()->IsShown() && setText)
1810       {
1811         GetTextItem()->SetValue(cell->GetTextValue());
1812         currentPos = TRUE;
1813       }
1814       // Gets refreshed anyway in MSW
1815 #ifdef __WXMSW__
1816       if (!currentPos)
1817 #endif
1818       {
1819         wxClientDC dc(this);
1820         dc.BeginDrawing();
1821         DrawCellBackground(& dc, &m_currentRect, row, col);
1822         DrawCellValue(& dc, &m_currentRect, row, col);
1823         dc.EndDrawing();
1824       }
1825     }
1826 }
1827
1828 wxString& wxGenericGrid::GetCellValue(int row, int col) const
1829 {
1830   static wxString emptyString("");
1831
1832   wxGridCell *cell = GetCell(row, col);
1833   if (cell)
1834     return cell->GetTextValue();
1835   else
1836     return emptyString;
1837 }
1838
1839 void wxGenericGrid::SetColumnWidth(int col, int width)
1840 {
1841   if (col <= m_totalCols)
1842     m_colWidths[col] = width;
1843 }
1844
1845 int wxGenericGrid::GetColumnWidth(int col) const
1846 {
1847   if (col <= m_totalCols)
1848     return m_colWidths[col];
1849   else
1850     return 0;
1851 }
1852
1853 void wxGenericGrid::SetRowHeight(int row, int height)
1854 {
1855   if (row <= m_totalRows)
1856     m_rowHeights[row] = height;
1857 }
1858
1859 int wxGenericGrid::GetRowHeight(int row) const
1860 {
1861   if (row <= m_totalRows)
1862     return m_rowHeights[row];
1863   else
1864     return 0;
1865 }
1866
1867 void wxGenericGrid::SetLabelSize(int orientation, int sz)
1868 {
1869   if (orientation == wxHORIZONTAL)
1870     m_horizontalLabelHeight = sz;
1871   else
1872     m_verticalLabelWidth = sz;
1873   UpdateDimensions();
1874   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1875 }
1876
1877 int wxGenericGrid::GetLabelSize(int orientation) const
1878 {
1879   if (orientation == wxHORIZONTAL)
1880     return m_horizontalLabelHeight;
1881   else
1882     return m_verticalLabelWidth;
1883 }
1884
1885 wxGridCell *wxGenericGrid::GetLabelCell(int orientation, int pos) const
1886 {
1887   if (orientation == wxHORIZONTAL)
1888   {
1889     if (m_colLabelCells && pos < m_totalCols)
1890       return m_colLabelCells[pos];
1891     else
1892       return (wxGridCell *) NULL;
1893   }
1894   else
1895   {
1896     if (m_rowLabelCells && pos < m_totalRows)
1897       return m_rowLabelCells[pos];
1898     else
1899       return (wxGridCell *) NULL;
1900   }
1901 }
1902
1903 void wxGenericGrid::SetLabelValue(int orientation, const wxString& val, int pos)
1904 {
1905   wxGridCell *cell = GetLabelCell(orientation, pos);
1906   if (cell)
1907     cell->SetTextValue(val);
1908 }
1909
1910 wxString& wxGenericGrid::GetLabelValue(int orientation, int pos) const
1911 {
1912  static wxString emptyString = "";
1913   wxGridCell *cell = GetLabelCell(orientation, pos);
1914   if (cell)
1915     return cell->GetTextValue();
1916   else
1917     return emptyString;
1918 }
1919
1920 void wxGenericGrid::SetLabelAlignment(int orientation, int align)
1921 {
1922   if (orientation == wxHORIZONTAL)
1923     m_horizontalLabelAlignment = align;
1924   else
1925     m_verticalLabelAlignment = align;
1926   UpdateDimensions();
1927   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1928 }
1929
1930 int wxGenericGrid::GetLabelAlignment(int orientation) const
1931 {
1932   if (orientation == wxHORIZONTAL)
1933     return m_horizontalLabelAlignment;
1934   else
1935     return m_verticalLabelAlignment;
1936 }
1937
1938 void wxGenericGrid::SetLabelTextColour(const wxColour& colour)
1939 {
1940   m_labelTextColour = colour;
1941
1942 }
1943
1944 void wxGenericGrid::SetLabelBackgroundColour(const wxColour& colour)
1945 {
1946   m_labelBackgroundColour = colour;
1947   m_labelBackgroundBrush = * wxTheBrushList->FindOrCreateBrush(m_labelBackgroundColour, wxSOLID);
1948 }
1949
1950 void wxGenericGrid::SetEditable(bool edit)
1951 {
1952   m_editable = edit;
1953   if (edit)
1954   {
1955     int controlW, controlH;
1956     m_textItem->GetSize(&controlW, &controlH);
1957     m_editControlPosition.height = controlH;
1958
1959     m_topOfSheet = m_editControlPosition.x + controlH + 2;
1960     if (m_textItem)
1961     {
1962       m_editingPanel->Show(TRUE);
1963       m_textItem->Show(TRUE);
1964       m_textItem->SetFocus();
1965     }
1966   }
1967   else
1968   {
1969     m_topOfSheet = 0;
1970     if (m_textItem)
1971     {
1972       m_textItem->Show(FALSE);
1973       m_editingPanel->Show(FALSE);
1974     }
1975   }
1976   UpdateDimensions();
1977   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1978
1979   int cw, ch;
1980   GetClientSize(&cw, &ch);
1981   wxSizeEvent evt;
1982   OnSize(evt);
1983 /*
1984   int cw, ch;
1985   int m_scrollWidth = 16;
1986   GetClientSize(&cw, &ch);
1987
1988   if (m_vScrollBar)
1989     m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1990        m_scrollWidth, ch - m_topOfSheet - m_scrollWidth);
1991 */
1992 }
1993
1994 void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
1995 {
1996   wxGridCell *cell = GetCell(row, col);
1997   if (cell)
1998     cell->SetAlignment(flag);
1999 }
2000
2001 int wxGenericGrid::GetCellAlignment(int row, int col) const
2002 {
2003   wxGridCell *cell = GetCell(row, col);
2004   if (cell)
2005     return cell->GetAlignment();
2006   else
2007     return m_cellAlignment;
2008 }
2009
2010 void wxGenericGrid::SetCellAlignment(int flag)
2011 {
2012   m_cellAlignment = flag;
2013   int i,j;
2014   for (i = 0; i < GetRows(); i++)
2015     for (j = 0; j < GetCols(); j++)
2016       if (GetCell(i, j))
2017         GetCell(i, j)->SetAlignment(flag);
2018 }
2019
2020 int wxGenericGrid::GetCellAlignment(void) const
2021 {
2022   return m_cellAlignment;
2023 }
2024
2025 void wxGenericGrid::SetCellBackgroundColour(const wxColour& col)
2026 {
2027   m_cellBackgroundColour = col;
2028   int i,j;
2029   for (i = 0; i < GetRows(); i++)
2030     for (j = 0; j < GetCols(); j++)
2031       if (GetCell(i, j))
2032         GetCell(i, j)->SetBackgroundColour(col);
2033 }
2034
2035 void wxGenericGrid::SetCellBackgroundColour(const wxColour& val, int row, int col)
2036 {
2037   wxGridCell *cell = GetCell(row, col);
2038   if (cell)
2039   {
2040     cell->SetBackgroundColour(val);
2041     RefreshCell(row, col);
2042   }
2043 }
2044
2045 wxColour& wxGenericGrid::GetCellBackgroundColour(int row, int col) const
2046 {
2047   wxGridCell *cell = GetCell(row, col);
2048   if (cell)
2049     return cell->GetBackgroundColour();
2050   else
2051     return (wxColour&) m_cellBackgroundColour;
2052 }
2053
2054 void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)
2055 {
2056   wxGridCell *cell = GetCell(row, col);
2057   if (cell)
2058   {
2059     cell->SetTextColour(val);
2060     RefreshCell(row, col);
2061   }
2062 }
2063
2064 void wxGenericGrid::SetCellTextFont(const wxFont& fnt, int row, int col)
2065 {
2066   wxGridCell *cell = GetCell(row, col);
2067   if (cell)
2068   {
2069     cell->SetFont(fnt);
2070     RefreshCell(row, col);
2071   }
2072 }
2073
2074 wxFont& wxGenericGrid::GetCellTextFont(int row, int col) const
2075 {
2076   wxGridCell *cell = GetCell(row, col);
2077   if (cell)
2078     return (wxFont&) cell->GetFont();
2079   else
2080     return (wxFont&) m_cellTextFont;
2081 }
2082
2083 wxColour& wxGenericGrid::GetCellTextColour(int row, int col) const
2084 {
2085   wxGridCell *cell = GetCell(row, col);
2086   if (cell)
2087     return (wxColour&) cell->GetTextColour();
2088   else
2089     return (wxColour&) m_cellTextColour;
2090 }
2091
2092 void wxGenericGrid::SetCellTextColour(const wxColour& val)
2093 {
2094   m_cellTextColour = val;
2095   int i,j;
2096   for (i = 0; i < GetRows(); i++)
2097     for (j = 0; j < GetCols(); j++)
2098       if (GetCell(i, j))
2099         GetCell(i, j)->SetTextColour(val);
2100 }
2101
2102 void wxGenericGrid::SetCellTextFont(const wxFont& fnt)
2103 {
2104   m_cellTextFont = fnt;
2105   int i,j;
2106   for (i = 0; i < GetRows(); i++)
2107     for (j = 0; j < GetCols(); j++)
2108       if (GetCell(i, j))
2109         GetCell(i, j)->SetFont(fnt);
2110 }
2111
2112 void wxGenericGrid::SetCellBitmap(wxBitmap *bitmap, int row, int col)
2113 {
2114   wxGridCell *cell = GetCell(row, col);
2115   if (cell)
2116   {
2117     cell->SetCellBitmap(bitmap);
2118     RefreshCell(row, col);
2119   }
2120 }
2121
2122 wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col) const
2123 {
2124   wxGridCell *cell = GetCell(row, col);
2125   if (cell)
2126   {
2127     return cell->GetCellBitmap();
2128   }
2129   else
2130     return (wxBitmap *) NULL;
2131 }
2132
2133 bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
2134 {
2135   if (pos > m_totalCols)
2136     return FALSE;
2137
2138   if (!m_gridCells)
2139     return CreateGrid(1, n);
2140   else
2141   {
2142     int i, j;
2143     // Cells
2144     for (i = 0; i < m_totalRows; i++)
2145     {
2146       wxGridCell **cols = m_gridCells[i];
2147       wxGridCell **newCols = new wxGridCell *[m_totalCols + n];
2148       for (j = 0; j < pos; j++)
2149         newCols[j] = cols[j];
2150       for (j = pos; j < pos + n; j++)
2151         newCols[j] = new wxGridCell(this);
2152       for (j = pos + n; j < m_totalCols + n; j++)
2153         newCols[j] = cols[j - n];
2154
2155       delete[] cols;
2156       m_gridCells[i] = newCols;
2157     }
2158
2159     // Column widths
2160     short *newColWidths = new short[m_totalCols + n];
2161     for (j = 0; j < pos; j++)
2162       newColWidths[j] = m_colWidths[j];
2163     for (j = pos; j < pos + n; j++)
2164       newColWidths[j] = wxGRID_DEFAULT_CELL_WIDTH;
2165     for (j = pos + n; j < m_totalCols + n; j++)
2166       newColWidths[j] = m_colWidths[j - n];
2167     delete[] m_colWidths;
2168     m_colWidths = newColWidths;
2169
2170     // Column labels
2171     wxGridCell **newLabels = new wxGridCell *[m_totalCols + n];
2172     for (j = 0; j < pos; j++)
2173       newLabels[j] = m_colLabelCells[j];
2174     for (j = pos; j < pos + n; j++)
2175       newLabels[j] = new wxGridCell(this);
2176     for (j = pos + n; j < m_totalCols + n; j++)
2177       newLabels[j] = m_colLabelCells[j - n];
2178
2179     delete[] m_colLabelCells;
2180     m_colLabelCells = newLabels;
2181
2182     m_totalCols += n;
2183
2184     if (updateLabels) {
2185         //OnChangeLabels();
2186         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2187         GetEventHandler()->ProcessEvent(g_evt);
2188     }
2189
2190     UpdateDimensions();
2191     AdjustScrollbars();
2192     return TRUE;
2193   }
2194 }
2195
2196 bool wxGenericGrid::InsertRows(int pos, int n, bool updateLabels)
2197 {
2198   if (pos > m_totalRows)
2199     return FALSE;
2200
2201   if (!m_gridCells)
2202     return CreateGrid(n, 1);
2203   else
2204   {
2205     int i, j;
2206
2207     wxGridCell ***rows = new wxGridCell **[m_totalRows + n];
2208
2209     // Cells
2210     for (i = 0; i < pos; i++)
2211       rows[i] = m_gridCells[i];
2212
2213     for (i = pos; i < pos + n; i++)
2214     {
2215       rows[i] = new wxGridCell *[m_totalCols];
2216       for (j = 0; j < m_totalCols; j++)
2217         rows[i][j] = new wxGridCell(this);
2218     }
2219
2220     for (i = pos + n; i < m_totalRows + n; i++)
2221       rows[i] = m_gridCells[i - n];
2222
2223     delete[] m_gridCells;
2224     m_gridCells = rows;
2225
2226     // Row heights
2227     short *newRowHeights = new short[m_totalRows + n];
2228     for (i = 0; i < pos; i++)
2229       newRowHeights[i] = m_rowHeights[i];
2230     for (i = pos; i < pos + n; i++)
2231       newRowHeights[i] = wxGRID_DEFAULT_CELL_HEIGHT;
2232     for (i = pos + n; i < m_totalRows + n; i++)
2233       newRowHeights[i] = m_rowHeights[i - n];
2234     delete[] m_rowHeights;
2235     m_rowHeights = newRowHeights;
2236
2237     // Column labels
2238     wxGridCell **newLabels = new wxGridCell *[m_totalRows + n];
2239     for (i = 0; i < pos; i++)
2240       newLabels[i] = m_rowLabelCells[i];
2241     for (i = pos; i < pos + n; i++)
2242       newLabels[i] = new wxGridCell(this);
2243     for (i = pos + n; i < m_totalRows + n; i++)
2244       newLabels[i] = m_rowLabelCells[i - n];
2245
2246     delete[] m_rowLabelCells;
2247     m_rowLabelCells = newLabels;
2248
2249     m_totalRows += n;
2250
2251     if (updateLabels) {
2252         //OnChangeLabels();
2253           wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2254           GetEventHandler()->ProcessEvent(g_evt);
2255     }
2256
2257     UpdateDimensions();
2258     AdjustScrollbars();
2259     return TRUE;
2260   }
2261 }
2262
2263 bool wxGenericGrid::AppendCols(int n, bool updateLabels)
2264 {
2265   return InsertCols(GetCols(), n, updateLabels);
2266 }
2267
2268 bool wxGenericGrid::AppendRows(int n, bool updateLabels)
2269 {
2270   return InsertRows(GetRows(), n, updateLabels);
2271 }
2272
2273 bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
2274 {
2275   if (pos > m_totalRows)
2276     return FALSE;
2277   if (!m_gridCells)
2278     return FALSE;
2279
2280   int i;
2281
2282   wxGridCell ***rows = new wxGridCell **[m_totalRows - n];
2283
2284   // Cells
2285   for (i = 0; i < pos; i++)
2286     rows[i] = m_gridCells[i];
2287
2288   for (i = pos + n; i < m_totalRows; i++)
2289     rows[i-n] = m_gridCells[i];
2290
2291   delete[] m_gridCells;
2292   m_gridCells = rows;
2293
2294   // Row heights
2295   short *newRowHeights = new short[m_totalRows - n];
2296   for (i = 0; i < pos; i++)
2297     newRowHeights[i] = m_rowHeights[i];
2298   for (i = pos + n; i < m_totalRows; i++)
2299     newRowHeights[i-n] = m_rowHeights[i];
2300   delete[] m_rowHeights;
2301   m_rowHeights = newRowHeights;
2302
2303   // Column labels
2304   wxGridCell **newLabels = new wxGridCell *[m_totalRows - n];
2305   for (i = 0; i < pos; i++)
2306     newLabels[i] = m_rowLabelCells[i];
2307   for (i = pos + n; i < m_totalRows; i++)
2308     newLabels[i-n] = m_rowLabelCells[i];
2309
2310   delete[] m_rowLabelCells;
2311   m_rowLabelCells = newLabels;
2312
2313   m_totalRows -= n;
2314
2315   if (updateLabels){
2316         //OnChangeLabels();
2317         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2318         GetEventHandler()->ProcessEvent(g_evt);
2319     }
2320   UpdateDimensions();
2321   AdjustScrollbars();
2322   return TRUE;
2323 }
2324
2325 bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
2326 {
2327   if (pos + n > m_totalCols)
2328     return FALSE;
2329   if (!m_gridCells)
2330     return FALSE;
2331
2332   int i, j;
2333
2334   // Cells
2335   for (i = 0; i < m_totalRows; i++)
2336   {
2337       wxGridCell **cols = m_gridCells[i];
2338       wxGridCell **newCols = new wxGridCell *[m_totalCols - n];
2339       for (j = 0; j < pos; j++)
2340         newCols[j] = cols[j];
2341       for (j = pos; j < pos + n; j++)
2342         delete cols[j];
2343       for (j = pos + n; j < m_totalCols; j++)
2344         newCols[j-n] = cols[j];
2345
2346       delete[] cols;
2347       m_gridCells[i] = newCols;
2348   }
2349
2350   // Column widths
2351   short *newColWidths = new short[m_totalCols - n];
2352   for (j = 0; j < pos; j++)
2353     newColWidths[j] = m_colWidths[j];
2354   for (j = pos + n; j < m_totalCols; j++)
2355     newColWidths[j-n] = m_colWidths[j];
2356   delete[] m_colWidths;
2357   m_colWidths = newColWidths;
2358
2359   // Column labels
2360   wxGridCell **newLabels = new wxGridCell *[m_totalCols - n];
2361   for (j = 0; j < pos; j++)
2362     newLabels[j] = m_colLabelCells[j];
2363   for (j = pos + n; j < m_totalCols; j++)
2364     newLabels[j-n] = m_colLabelCells[j];
2365
2366   delete[] m_colLabelCells;
2367   m_colLabelCells = newLabels;
2368
2369   m_totalCols -= n;
2370
2371   if (updateLabels) {
2372         //OnChangeLabels();
2373         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2374         GetEventHandler()->ProcessEvent(g_evt);
2375     }
2376   UpdateDimensions();
2377   AdjustScrollbars();
2378   return TRUE;
2379 }
2380
2381 void wxGenericGrid::SetGridCursor(int row, int col)
2382 {
2383   if (row >= m_totalRows || col >= m_totalCols)
2384     return;
2385
2386   if (row == GetCursorRow() && col == GetCursorColumn())
2387     return;
2388
2389   wxClientDC dc(this);
2390   dc.BeginDrawing();
2391
2392   SetGridClippingRegion(& dc);
2393
2394   if (m_currentRectVisible)
2395     HighlightCell(& dc);
2396
2397   m_wCursorRow = row;
2398   m_wCursorColumn = col;
2399
2400   int cw, ch;
2401   GetClientSize(&cw, &ch);
2402
2403   SetCurrentRect(row, col, cw, ch);
2404
2405   if (m_currentRectVisible)
2406     HighlightCell(& dc);
2407
2408   dc.DestroyClippingRegion();
2409   dc.EndDrawing();
2410 }
2411
2412 /*
2413  * Grid cell
2414  */
2415
2416 wxGridCell::wxGridCell(wxGenericGrid *window)
2417 {
2418   cellBitmap = (wxBitmap *) NULL;
2419   font = wxNullFont;
2420   backgroundBrush = wxNullBrush;
2421   if (window)
2422     textColour = window->GetCellTextColour();
2423   else
2424     textColour.Set(0,0,0);
2425   if (window)
2426     backgroundColour = window->GetCellBackgroundColour();
2427   else
2428     backgroundColour.Set(255,255,255);
2429
2430   if (window)
2431     font = window->GetCellTextFont();
2432   else
2433     font = * wxTheFontList->FindOrCreateFont(12, wxSWISS, wxNORMAL, wxNORMAL);
2434
2435   SetBackgroundColour(backgroundColour);
2436
2437   if (window)
2438     alignment = window->GetCellAlignment();
2439   else
2440     alignment = wxLEFT;
2441 }
2442
2443 wxGridCell::~wxGridCell(void)
2444 {
2445 }
2446
2447 void wxGridCell::SetBackgroundColour(const wxColour& colour)
2448 {
2449   backgroundColour = colour;
2450   backgroundBrush = * wxTheBrushList->FindOrCreateBrush(backgroundColour, wxSOLID);
2451 }
2452
2453 void wxGenericGrid::OnText(wxCommandEvent& WXUNUSED(ev) )
2454 {
2455   wxGenericGrid *grid = this;
2456   wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
2457   if (cell && grid->CurrentCellVisible())
2458   {
2459     cell->SetTextValue(grid->GetTextItem()->GetValue());
2460     wxClientDC dc(grid);
2461
2462     dc.BeginDrawing();
2463     grid->SetGridClippingRegion(& dc);
2464     grid->DrawCellBackground(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2465     grid->DrawCellValue(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2466     grid->HighlightCell(& dc);
2467     dc.DestroyClippingRegion();
2468     dc.EndDrawing();
2469
2470     //grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
2471     wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_CHANGE, grid,
2472                       grid->GetCursorRow(), grid->GetCursorColumn());
2473     GetEventHandler()->ProcessEvent(g_evt);
2474
2475 //    grid->DrawCellText();
2476   }
2477 }
2478
2479 void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
2480 {
2481   static bool inScroll = FALSE;
2482
2483   if ( inScroll )
2484         return;
2485
2486   inScroll = TRUE;
2487   wxGenericGrid *win = this;
2488
2489   bool change = FALSE;
2490
2491   if (ev.GetEventObject() == win->GetHorizScrollBar())
2492   {
2493     change = (ev.GetPosition() != m_scrollPosX);
2494     win->SetScrollPosX(ev.GetPosition());
2495   }
2496   else
2497   {
2498     change = (ev.GetPosition() != m_scrollPosY);
2499     win->SetScrollPosY(ev.GetPosition());
2500   }
2501
2502   win->UpdateDimensions();
2503
2504   win->SetCurrentRect(win->GetCursorRow(), win->GetCursorColumn());
2505
2506   // Because rows and columns can be arbitrary sizes,
2507   // the scrollbars will need to be adjusted to reflect the
2508   // current view.
2509   AdjustScrollbars();
2510
2511   if (change) win->Refresh(FALSE);
2512   inScroll = FALSE;
2513
2514 }
2515
2516
2517 //----------------------------------------------------------------------
2518 // Default wxGridEvent handlers
2519 //      (just redirect to the pre-existing virtual methods)
2520
2521 void wxGenericGrid::_OnSelectCell(wxGridEvent& ev)
2522 {
2523     OnSelectCell(ev.m_row, ev.m_col);
2524 }
2525
2526 void wxGenericGrid::_OnCreateCell(wxGridEvent& ev)
2527 {
2528     ev.m_cell = OnCreateCell();
2529 }
2530
2531 void wxGenericGrid::_OnChangeLabels(wxGridEvent& WXUNUSED(ev))
2532 {
2533     OnChangeLabels();
2534 }
2535
2536 void wxGenericGrid::_OnChangeSelectionLabel(wxGridEvent& WXUNUSED(ev))
2537 {
2538     OnChangeSelectionLabel();
2539 }
2540
2541 void wxGenericGrid::_OnCellChange(wxGridEvent& ev)
2542 {
2543     OnCellChange(ev.m_row, ev.m_col);
2544 }
2545
2546 void wxGenericGrid::_OnCellLeftClick(wxGridEvent& ev)
2547 {
2548     OnCellLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2549 }
2550
2551 void wxGenericGrid::_OnCellRightClick(wxGridEvent& ev)
2552 {
2553     OnCellRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2554 }
2555
2556 void wxGenericGrid::_OnLabelLeftClick(wxGridEvent& ev)
2557 {
2558     OnLabelLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2559 }
2560
2561 void wxGenericGrid::_OnLabelRightClick(wxGridEvent& ev)
2562 {
2563     OnLabelRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2564 }
2565
2566