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 #ifndef __WXMSW__
1421 //  HighlightCell(dc);
1422 #endif
1423   dc->DestroyClippingRegion();
1424
1425   //OnSelectCell(row, col);
1426   wxGridEvent g_evt2(GetId(), wxEVT_GRID_SELECT_CELL, this, row, col);
1427   GetEventHandler()->ProcessEvent(g_evt2);
1428 }
1429
1430 wxGridCell *wxGenericGrid::OnCreateCell(void)
1431 {
1432   return new wxGridCell(this);
1433 }
1434
1435 void wxGenericGrid::OnChangeLabels(void)
1436 {
1437   char buf[100];
1438   int i;
1439   for (i = 0; i < m_totalRows; i++)
1440   {
1441     sprintf(buf, "%d", i+1);
1442     SetLabelValue(wxVERTICAL, buf, i);
1443   }
1444   // A...Z,AA...ZZ,AAA...ZZZ, etc.
1445   for (i = 0; i < m_totalCols; i++)
1446   {
1447     int j;
1448     int noTimes = (i/26 + 1);
1449     int ch = (i % 26) + 65;
1450     buf[0] = 0;
1451     for (j = 0; j < noTimes; j++)
1452     {
1453       char buf2[20];
1454       sprintf(buf2, "%c", (char)ch);
1455       strcat(buf, buf2);
1456     }
1457     SetLabelValue(wxHORIZONTAL, buf, i);
1458   }
1459 }
1460
1461 void wxGenericGrid::OnChangeSelectionLabel(void)
1462 {
1463   if (!GetEditable())
1464     return;
1465
1466   wxString rowLabel(GetLabelValue(wxVERTICAL, GetCursorRow()));
1467   wxString colLabel(GetLabelValue(wxHORIZONTAL, GetCursorColumn()));
1468
1469   wxString newLabel = colLabel + rowLabel;
1470   if ((newLabel.Length() > 0) && (newLabel.Length() <= 8) && GetTextItem())
1471   {
1472 //    GetTextItem()->SetLabel(newLabel);
1473   }
1474 }
1475
1476 void wxGenericGrid::HighlightCell(wxDC *dc)
1477 {
1478   dc->SetLogicalFunction(wxINVERT);
1479
1480   // Top
1481   dc->DrawLine( m_currentRect.x + 1,
1482                 m_currentRect.y + 1,
1483                 m_currentRect.x + m_currentRect.width - 1,
1484                 m_currentRect.y + 1);
1485   // Right
1486   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1487                 m_currentRect.y + 1,
1488                 m_currentRect.x + m_currentRect.width - 1,
1489                 m_currentRect.y +m_currentRect.height - 1 );
1490   // Bottom
1491   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1492                 m_currentRect.y + m_currentRect.height - 1,
1493                 m_currentRect.x + 1,
1494                 m_currentRect.y + m_currentRect.height - 1);
1495   // Left
1496   dc->DrawLine( m_currentRect.x + 1,
1497                 m_currentRect.y + m_currentRect.height - 1,
1498                 m_currentRect.x + 1,
1499                 m_currentRect.y + 1);
1500
1501   dc->SetLogicalFunction(wxCOPY);
1502 }
1503
1504 void wxGenericGrid::DrawCellText(void)
1505 {
1506   if (!m_currentRectVisible)
1507     return;
1508
1509   wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1510   if (!cell)
1511     return;
1512
1513   static char szEdit[300];
1514
1515   wxClientDC dc(this);
1516   dc.BeginDrawing();
1517
1518   SetGridClippingRegion(& dc);
1519
1520   dc.SetBackgroundMode(wxTRANSPARENT);
1521   dc.SetBrush(cell->GetBackgroundBrush());
1522
1523   strcpy(szEdit, m_textItem->GetValue());
1524
1525   wxRect rect;
1526   rect = m_currentRect;
1527   rect.x += 3;
1528   rect.y += 2;
1529   rect.width -= 5;
1530   rect.height -= 4;
1531
1532   DrawTextRect(& dc, "                                    ", &rect, wxLEFT);
1533   DrawTextRect(& dc, szEdit, &rect, cell->GetAlignment());
1534
1535   dc.DestroyClippingRegion();
1536
1537   dc.SetBackgroundMode(wxSOLID);
1538
1539   dc.EndDrawing();
1540 }
1541
1542 void wxGenericGrid::SetCurrentRect(int Row, int Column, int canvasW, int canvasH)
1543 {
1544   int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
1545   int i;
1546   for (i = m_scrollPosX; i < Column; i++)
1547     currentWidth += m_colWidths[i];
1548
1549   int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
1550   for (i = m_scrollPosY; i < Row; i++)
1551     currentHeight += m_rowHeights[i];
1552
1553   m_currentRect.x = currentWidth;
1554   m_currentRect.y = currentHeight;
1555   m_currentRect.width = m_colWidths ? (m_colWidths[Column]) : 0;
1556   m_currentRect.height = m_rowHeights ? (m_rowHeights[Row]) : 0;
1557
1558   if (Row < m_scrollPosY || Column < m_scrollPosX)
1559     m_currentRectVisible = FALSE;
1560   else if ((canvasW != -1 && canvasH != -1) && (m_currentRect.x > canvasW || m_currentRect.y > canvasH))
1561     m_currentRectVisible = FALSE;
1562   else m_currentRectVisible = TRUE;
1563 }
1564
1565 static bool wxRectIntersection(wxRect *rect1, wxRect *rect2, wxRect *rect3)
1566 {
1567   int x2_1 = rect1->x + rect1->width;
1568   int y2_1 = rect1->y + rect1->height;
1569
1570   int x2_2 = rect2->x + rect2->width;
1571   int y2_2 = rect2->y + rect2->height;
1572
1573   int x2_3, y2_3;
1574
1575   // Check for intersection
1576   if ((rect1->x > x2_2) || (rect2->x > x2_1) ||
1577       (rect1->y > y2_2) || (rect2->y > y2_1))
1578   {
1579     // No intersection
1580     rect3->x = rect3->y = rect3->width = rect3->height = 0;
1581     return FALSE;
1582   }
1583
1584   if (rect1->x > rect2->x)
1585     rect3->x = rect1->x;
1586   else
1587     rect3->x = rect2->x;
1588   if (rect1->y > rect2->y)
1589     rect3->y = rect1->y;
1590   else
1591     rect3->y = rect2->y;
1592
1593   if (x2_1 > x2_2)
1594     x2_3 = x2_2;
1595   else
1596     x2_3 = x2_1;
1597   if (y2_1 > y2_2)
1598     y2_3 = y2_2;
1599   else
1600     y2_3 = y2_1;
1601
1602   rect3->width = (int)(x2_3 - rect3->x);
1603   rect3->height = (int)(y2_3 - rect3->y);
1604   return TRUE;
1605 }
1606
1607 void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRect *rect, int flag)
1608 {
1609   dc->BeginDrawing();
1610
1611   // Ultimately, this functionality should be built into wxWindows,
1612   // and optimized for each platform. E.g. on Windows, use DrawText
1613   // passing a clipping rectangle, so that the wxWindows clipping region
1614   // does not have to be used to implement this.
1615
1616   // If we're already clipping, we need to find the intersection
1617   // between current clipping area and text clipping area.
1618
1619   wxRect clipRect;
1620   wxRect clipRect2;
1621   long clipX, clipY, clipW, clipH;
1622   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1623   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1624   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1625
1626   bool alreadyClipping = TRUE;
1627
1628   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1629   {
1630     alreadyClipping = FALSE;
1631     clipRect2.x = rect->x; clipRect2.y = rect->y;
1632     clipRect2.width = rect->width; clipRect2.height = rect->height;
1633   }
1634   else
1635   {
1636     // Find intersection.
1637     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1638       return;
1639   }
1640
1641   if (alreadyClipping)
1642     dc->DestroyClippingRegion();
1643
1644   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1645   long textWidth, textHeight;
1646
1647   dc->GetTextExtent(text, &textWidth, &textHeight);
1648
1649   // Do alignment
1650   float x,y;
1651   switch (flag)
1652   {
1653     case wxRIGHT:
1654     {
1655       x = (rect->x + rect->width - textWidth - 1.0);
1656       y = (rect->y + (rect->height - textHeight)/2.0);
1657       break;
1658     }
1659     case wxCENTRE:
1660     {
1661       x = (rect->x + (rect->width - textWidth)/2.0);
1662       y = (rect->y + (rect->height - textHeight)/2.0);
1663       break;
1664     }
1665     case wxLEFT:
1666     default:
1667     {
1668       x = (rect->x + 1.0);
1669       y = (rect->y + (rect->height - textHeight)/2.0);
1670       break;
1671     }
1672   }
1673   dc->DrawText(text, (long)x, (long)y );
1674
1675   dc->DestroyClippingRegion();
1676
1677   // Restore old clipping
1678   if (alreadyClipping)
1679     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1680
1681   dc->EndDrawing();
1682 }
1683
1684 void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRect *rect, int flag)
1685 {
1686   dc->BeginDrawing();
1687
1688   // Ultimately, this functionality should be built into wxWindows,
1689   // and optimized for each platform. E.g. on Windows, use DrawText
1690   // passing a clipping rectangle, so that the wxWindows clipping region
1691   // does not have to be used to implement this.
1692
1693   // If we're already clipping, we need to find the intersection
1694   // between current clipping area and text clipping area.
1695
1696   wxRect clipRect;
1697   wxRect clipRect2;
1698   long clipX, clipY, clipW, clipH;
1699   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1700   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1701   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1702
1703   bool alreadyClipping = TRUE;
1704
1705   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1706   {
1707     alreadyClipping = FALSE;
1708     clipRect2.x = rect->x; clipRect2.y = rect->y;
1709     clipRect2.width = rect->width; clipRect2.height = rect->height;
1710   }
1711   else
1712   {
1713     // Find intersection.
1714     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1715       return;
1716   }
1717
1718   if (alreadyClipping)
1719     dc->DestroyClippingRegion();
1720
1721   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1722   float bitmapWidth, bitmapHeight;
1723
1724   bitmapWidth = bitmap->GetWidth();
1725   bitmapHeight = bitmap->GetHeight();
1726
1727   // Do alignment
1728   long x,y;
1729   switch (flag)
1730   {
1731     case wxRIGHT:
1732     {
1733       x = (long)(rect->x + rect->width - bitmapWidth - 1);
1734       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1735       break;
1736     }
1737     case wxCENTRE:
1738     {
1739       x = (long)(rect->x + (rect->width - bitmapWidth)/2.0);
1740       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1741       break;
1742     }
1743     case wxLEFT:
1744     default:
1745     {
1746       x = (long)(rect->x + 1);
1747       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1748       break;
1749     }
1750   }
1751   wxMemoryDC dcTemp;
1752   dcTemp.SelectObject(*bitmap);
1753
1754   dc->Blit( (long)x, (long)y, (long)bitmapWidth, (long)bitmapHeight, &dcTemp, 0, 0);
1755   dcTemp.SelectObject(wxNullBitmap);
1756
1757   dc->DestroyClippingRegion();
1758
1759   // Restore old clipping
1760   if (alreadyClipping)
1761     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1762
1763   dc->EndDrawing();
1764 }
1765
1766 void wxGenericGrid::OnActivate(bool active)
1767 {
1768   if (active)
1769   {
1770     // Edit control should always have the focus
1771     if (GetTextItem() && GetEditable())
1772     {
1773       GetTextItem()->SetFocus();
1774       wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1775       if (cell)
1776         GetTextItem()->SetValue(cell->GetTextValue());
1777     }
1778   }
1779 }
1780
1781 void wxGenericGrid::SetCellValue(const wxString& val, int row, int col)
1782 {
1783   wxGridCell *cell = GetCell(row, col);
1784   if (cell)
1785   {
1786     cell->SetTextValue(val);
1787
1788     RefreshCell(row, col, TRUE);
1789   }
1790 }
1791
1792 void wxGenericGrid::RefreshCell(int row, int col, bool setText)
1793 {
1794     // Don't refresh within a pair of batch brackets
1795     if (GetBatchCount() > 0)
1796         return;
1797
1798     int cw, ch;
1799     GetClientSize(&cw, &ch);
1800
1801     SetCurrentRect(row, col, cw, ch);
1802     if (m_currentRectVisible)
1803     {
1804       wxGridCell *cell = GetCell(row, col);
1805
1806       bool currentPos = FALSE;
1807       if (row == m_wCursorRow && col == m_wCursorColumn && GetTextItem() && GetTextItem()->IsShown() && setText)
1808       {
1809         GetTextItem()->SetValue(cell->GetTextValue());
1810         currentPos = TRUE;
1811       }
1812       // Gets refreshed anyway in MSW
1813 #ifdef __WXMSW__
1814       if (!currentPos)
1815 #endif
1816       {
1817         wxClientDC dc(this);
1818         dc.BeginDrawing();
1819         DrawCellBackground(& dc, &m_currentRect, row, col);
1820         DrawCellValue(& dc, &m_currentRect, row, col);
1821         dc.EndDrawing();
1822       }
1823     }
1824 }
1825
1826 wxString& wxGenericGrid::GetCellValue(int row, int col) const
1827 {
1828   static wxString emptyString("");
1829
1830   wxGridCell *cell = GetCell(row, col);
1831   if (cell)
1832     return cell->GetTextValue();
1833   else
1834     return emptyString;
1835 }
1836
1837 void wxGenericGrid::SetColumnWidth(int col, int width)
1838 {
1839   if (col <= m_totalCols)
1840     m_colWidths[col] = width;
1841 }
1842
1843 int wxGenericGrid::GetColumnWidth(int col) const
1844 {
1845   if (col <= m_totalCols)
1846     return m_colWidths[col];
1847   else
1848     return 0;
1849 }
1850
1851 void wxGenericGrid::SetRowHeight(int row, int height)
1852 {
1853   if (row <= m_totalRows)
1854     m_rowHeights[row] = height;
1855 }
1856
1857 int wxGenericGrid::GetRowHeight(int row) const
1858 {
1859   if (row <= m_totalRows)
1860     return m_rowHeights[row];
1861   else
1862     return 0;
1863 }
1864
1865 void wxGenericGrid::SetLabelSize(int orientation, int sz)
1866 {
1867   if (orientation == wxHORIZONTAL)
1868     m_horizontalLabelHeight = sz;
1869   else
1870     m_verticalLabelWidth = sz;
1871   UpdateDimensions();
1872   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1873 }
1874
1875 int wxGenericGrid::GetLabelSize(int orientation) const
1876 {
1877   if (orientation == wxHORIZONTAL)
1878     return m_horizontalLabelHeight;
1879   else
1880     return m_verticalLabelWidth;
1881 }
1882
1883 wxGridCell *wxGenericGrid::GetLabelCell(int orientation, int pos) const
1884 {
1885   if (orientation == wxHORIZONTAL)
1886   {
1887     if (m_colLabelCells && pos < m_totalCols)
1888       return m_colLabelCells[pos];
1889     else
1890       return (wxGridCell *) NULL;
1891   }
1892   else
1893   {
1894     if (m_rowLabelCells && pos < m_totalRows)
1895       return m_rowLabelCells[pos];
1896     else
1897       return (wxGridCell *) NULL;
1898   }
1899 }
1900
1901 void wxGenericGrid::SetLabelValue(int orientation, const wxString& val, int pos)
1902 {
1903   wxGridCell *cell = GetLabelCell(orientation, pos);
1904   if (cell)
1905     cell->SetTextValue(val);
1906 }
1907
1908 wxString& wxGenericGrid::GetLabelValue(int orientation, int pos) const
1909 {
1910  static wxString emptyString = "";
1911   wxGridCell *cell = GetLabelCell(orientation, pos);
1912   if (cell)
1913     return cell->GetTextValue();
1914   else
1915     return emptyString;
1916 }
1917
1918 void wxGenericGrid::SetLabelAlignment(int orientation, int align)
1919 {
1920   if (orientation == wxHORIZONTAL)
1921     m_horizontalLabelAlignment = align;
1922   else
1923     m_verticalLabelAlignment = align;
1924   UpdateDimensions();
1925   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1926 }
1927
1928 int wxGenericGrid::GetLabelAlignment(int orientation) const
1929 {
1930   if (orientation == wxHORIZONTAL)
1931     return m_horizontalLabelAlignment;
1932   else
1933     return m_verticalLabelAlignment;
1934 }
1935
1936 void wxGenericGrid::SetLabelTextColour(const wxColour& colour)
1937 {
1938   m_labelTextColour = colour;
1939
1940 }
1941
1942 void wxGenericGrid::SetLabelBackgroundColour(const wxColour& colour)
1943 {
1944   m_labelBackgroundColour = colour;
1945   m_labelBackgroundBrush = * wxTheBrushList->FindOrCreateBrush(m_labelBackgroundColour, wxSOLID);
1946 }
1947
1948 void wxGenericGrid::SetEditable(bool edit)
1949 {
1950   m_editable = edit;
1951   if (edit)
1952   {
1953     int controlW, controlH;
1954     m_textItem->GetSize(&controlW, &controlH);
1955     m_editControlPosition.height = controlH;
1956
1957     m_topOfSheet = m_editControlPosition.x + controlH + 2;
1958     if (m_textItem)
1959     {
1960       m_editingPanel->Show(TRUE);
1961       m_textItem->Show(TRUE);
1962       m_textItem->SetFocus();
1963     }
1964   }
1965   else
1966   {
1967     m_topOfSheet = 0;
1968     if (m_textItem)
1969     {
1970       m_textItem->Show(FALSE);
1971       m_editingPanel->Show(FALSE);
1972     }
1973   }
1974   UpdateDimensions();
1975   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1976
1977   int cw, ch;
1978   GetClientSize(&cw, &ch);
1979   wxSizeEvent evt;
1980   OnSize(evt);
1981 /*
1982   int cw, ch;
1983   int m_scrollWidth = 16;
1984   GetClientSize(&cw, &ch);
1985
1986   if (m_vScrollBar)
1987     m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1988        m_scrollWidth, ch - m_topOfSheet - m_scrollWidth);
1989 */
1990 }
1991
1992 void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
1993 {
1994   wxGridCell *cell = GetCell(row, col);
1995   if (cell)
1996     cell->SetAlignment(flag);
1997 }
1998
1999 int wxGenericGrid::GetCellAlignment(int row, int col) const
2000 {
2001   wxGridCell *cell = GetCell(row, col);
2002   if (cell)
2003     return cell->GetAlignment();
2004   else
2005     return m_cellAlignment;
2006 }
2007
2008 void wxGenericGrid::SetCellAlignment(int flag)
2009 {
2010   m_cellAlignment = flag;
2011   int i,j;
2012   for (i = 0; i < GetRows(); i++)
2013     for (j = 0; j < GetCols(); j++)
2014       if (GetCell(i, j))
2015         GetCell(i, j)->SetAlignment(flag);
2016 }
2017
2018 int wxGenericGrid::GetCellAlignment(void) const
2019 {
2020   return m_cellAlignment;
2021 }
2022
2023 void wxGenericGrid::SetCellBackgroundColour(const wxColour& col)
2024 {
2025   m_cellBackgroundColour = col;
2026   int i,j;
2027   for (i = 0; i < GetRows(); i++)
2028     for (j = 0; j < GetCols(); j++)
2029       if (GetCell(i, j))
2030         GetCell(i, j)->SetBackgroundColour(col);
2031 }
2032
2033 void wxGenericGrid::SetCellBackgroundColour(const wxColour& val, int row, int col)
2034 {
2035   wxGridCell *cell = GetCell(row, col);
2036   if (cell)
2037   {
2038     cell->SetBackgroundColour(val);
2039     RefreshCell(row, col);
2040   }
2041 }
2042
2043 wxColour& wxGenericGrid::GetCellBackgroundColour(int row, int col) const
2044 {
2045   wxGridCell *cell = GetCell(row, col);
2046   if (cell)
2047     return cell->GetBackgroundColour();
2048   else
2049     return (wxColour&) m_cellBackgroundColour;
2050 }
2051
2052 void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)
2053 {
2054   wxGridCell *cell = GetCell(row, col);
2055   if (cell)
2056   {
2057     cell->SetTextColour(val);
2058     RefreshCell(row, col);
2059   }
2060 }
2061
2062 void wxGenericGrid::SetCellTextFont(const wxFont& fnt, int row, int col)
2063 {
2064   wxGridCell *cell = GetCell(row, col);
2065   if (cell)
2066   {
2067     cell->SetFont(fnt);
2068     RefreshCell(row, col);
2069   }
2070 }
2071
2072 wxFont& wxGenericGrid::GetCellTextFont(int row, int col) const
2073 {
2074   wxGridCell *cell = GetCell(row, col);
2075   if (cell)
2076     return (wxFont&) cell->GetFont();
2077   else
2078     return (wxFont&) m_cellTextFont;
2079 }
2080
2081 wxColour& wxGenericGrid::GetCellTextColour(int row, int col) const
2082 {
2083   wxGridCell *cell = GetCell(row, col);
2084   if (cell)
2085     return (wxColour&) cell->GetTextColour();
2086   else
2087     return (wxColour&) m_cellTextColour;
2088 }
2089
2090 void wxGenericGrid::SetCellTextColour(const wxColour& val)
2091 {
2092   m_cellTextColour = val;
2093   int i,j;
2094   for (i = 0; i < GetRows(); i++)
2095     for (j = 0; j < GetCols(); j++)
2096       if (GetCell(i, j))
2097         GetCell(i, j)->SetTextColour(val);
2098 }
2099
2100 void wxGenericGrid::SetCellTextFont(const wxFont& fnt)
2101 {
2102   m_cellTextFont = fnt;
2103   int i,j;
2104   for (i = 0; i < GetRows(); i++)
2105     for (j = 0; j < GetCols(); j++)
2106       if (GetCell(i, j))
2107         GetCell(i, j)->SetFont(fnt);
2108 }
2109
2110 void wxGenericGrid::SetCellBitmap(wxBitmap *bitmap, int row, int col)
2111 {
2112   wxGridCell *cell = GetCell(row, col);
2113   if (cell)
2114   {
2115     cell->SetCellBitmap(bitmap);
2116     RefreshCell(row, col);
2117   }
2118 }
2119
2120 wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col) const
2121 {
2122   wxGridCell *cell = GetCell(row, col);
2123   if (cell)
2124   {
2125     return cell->GetCellBitmap();
2126   }
2127   else
2128     return (wxBitmap *) NULL;
2129 }
2130
2131 bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
2132 {
2133   if (pos > m_totalCols)
2134     return FALSE;
2135
2136   if (!m_gridCells)
2137     return CreateGrid(1, n);
2138   else
2139   {
2140     int i, j;
2141     // Cells
2142     for (i = 0; i < m_totalRows; i++)
2143     {
2144       wxGridCell **cols = m_gridCells[i];
2145       wxGridCell **newCols = new wxGridCell *[m_totalCols + n];
2146       for (j = 0; j < pos; j++)
2147         newCols[j] = cols[j];
2148       for (j = pos; j < pos + n; j++)
2149         newCols[j] = new wxGridCell(this);
2150       for (j = pos + n; j < m_totalCols + n; j++)
2151         newCols[j] = cols[j - n];
2152
2153       delete[] cols;
2154       m_gridCells[i] = newCols;
2155     }
2156
2157     // Column widths
2158     short *newColWidths = new short[m_totalCols + n];
2159     for (j = 0; j < pos; j++)
2160       newColWidths[j] = m_colWidths[j];
2161     for (j = pos; j < pos + n; j++)
2162       newColWidths[j] = wxGRID_DEFAULT_CELL_WIDTH;
2163     for (j = pos + n; j < m_totalCols + n; j++)
2164       newColWidths[j] = m_colWidths[j - n];
2165     delete[] m_colWidths;
2166     m_colWidths = newColWidths;
2167
2168     // Column labels
2169     wxGridCell **newLabels = new wxGridCell *[m_totalCols + n];
2170     for (j = 0; j < pos; j++)
2171       newLabels[j] = m_colLabelCells[j];
2172     for (j = pos; j < pos + n; j++)
2173       newLabels[j] = new wxGridCell(this);
2174     for (j = pos + n; j < m_totalCols + n; j++)
2175       newLabels[j] = m_colLabelCells[j - n];
2176
2177     delete[] m_colLabelCells;
2178     m_colLabelCells = newLabels;
2179
2180     m_totalCols += n;
2181
2182     if (updateLabels) {
2183         //OnChangeLabels();
2184         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2185         GetEventHandler()->ProcessEvent(g_evt);
2186     }
2187
2188     UpdateDimensions();
2189     AdjustScrollbars();
2190     return TRUE;
2191   }
2192 }
2193
2194 bool wxGenericGrid::InsertRows(int pos, int n, bool updateLabels)
2195 {
2196   if (pos > m_totalRows)
2197     return FALSE;
2198
2199   if (!m_gridCells)
2200     return CreateGrid(n, 1);
2201   else
2202   {
2203     int i, j;
2204
2205     wxGridCell ***rows = new wxGridCell **[m_totalRows + n];
2206
2207     // Cells
2208     for (i = 0; i < pos; i++)
2209       rows[i] = m_gridCells[i];
2210
2211     for (i = pos; i < pos + n; i++)
2212     {
2213       rows[i] = new wxGridCell *[m_totalCols];
2214       for (j = 0; j < m_totalCols; j++)
2215         rows[i][j] = new wxGridCell(this);
2216     }
2217
2218     for (i = pos + n; i < m_totalRows + n; i++)
2219       rows[i] = m_gridCells[i - n];
2220
2221     delete[] m_gridCells;
2222     m_gridCells = rows;
2223
2224     // Row heights
2225     short *newRowHeights = new short[m_totalRows + n];
2226     for (i = 0; i < pos; i++)
2227       newRowHeights[i] = m_rowHeights[i];
2228     for (i = pos; i < pos + n; i++)
2229       newRowHeights[i] = wxGRID_DEFAULT_CELL_HEIGHT;
2230     for (i = pos + n; i < m_totalRows + n; i++)
2231       newRowHeights[i] = m_rowHeights[i - n];
2232     delete[] m_rowHeights;
2233     m_rowHeights = newRowHeights;
2234
2235     // Column labels
2236     wxGridCell **newLabels = new wxGridCell *[m_totalRows + n];
2237     for (i = 0; i < pos; i++)
2238       newLabels[i] = m_rowLabelCells[i];
2239     for (i = pos; i < pos + n; i++)
2240       newLabels[i] = new wxGridCell(this);
2241     for (i = pos + n; i < m_totalRows + n; i++)
2242       newLabels[i] = m_rowLabelCells[i - n];
2243
2244     delete[] m_rowLabelCells;
2245     m_rowLabelCells = newLabels;
2246
2247     m_totalRows += n;
2248
2249     if (updateLabels) {
2250         //OnChangeLabels();
2251           wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2252           GetEventHandler()->ProcessEvent(g_evt);
2253     }
2254
2255     UpdateDimensions();
2256     AdjustScrollbars();
2257     return TRUE;
2258   }
2259 }
2260
2261 bool wxGenericGrid::AppendCols(int n, bool updateLabels)
2262 {
2263   return InsertCols(GetCols(), n, updateLabels);
2264 }
2265
2266 bool wxGenericGrid::AppendRows(int n, bool updateLabels)
2267 {
2268   return InsertRows(GetRows(), n, updateLabels);
2269 }
2270
2271 bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
2272 {
2273   if (pos > m_totalRows)
2274     return FALSE;
2275   if (!m_gridCells)
2276     return FALSE;
2277
2278   int i;
2279
2280   wxGridCell ***rows = new wxGridCell **[m_totalRows - n];
2281
2282   // Cells
2283   for (i = 0; i < pos; i++)
2284     rows[i] = m_gridCells[i];
2285
2286   for (i = pos + n; i < m_totalRows; i++)
2287     rows[i-n] = m_gridCells[i];
2288
2289   delete[] m_gridCells;
2290   m_gridCells = rows;
2291
2292   // Row heights
2293   short *newRowHeights = new short[m_totalRows - n];
2294   for (i = 0; i < pos; i++)
2295     newRowHeights[i] = m_rowHeights[i];
2296   for (i = pos + n; i < m_totalRows; i++)
2297     newRowHeights[i-n] = m_rowHeights[i];
2298   delete[] m_rowHeights;
2299   m_rowHeights = newRowHeights;
2300
2301   // Column labels
2302   wxGridCell **newLabels = new wxGridCell *[m_totalRows - n];
2303   for (i = 0; i < pos; i++)
2304     newLabels[i] = m_rowLabelCells[i];
2305   for (i = pos + n; i < m_totalRows; i++)
2306     newLabels[i-n] = m_rowLabelCells[i];
2307
2308   delete[] m_rowLabelCells;
2309   m_rowLabelCells = newLabels;
2310
2311   m_totalRows -= n;
2312
2313   if (updateLabels){
2314         //OnChangeLabels();
2315         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2316         GetEventHandler()->ProcessEvent(g_evt);
2317     }
2318   UpdateDimensions();
2319   AdjustScrollbars();
2320   return TRUE;
2321 }
2322
2323 bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
2324 {
2325   if (pos + n > m_totalCols)
2326     return FALSE;
2327   if (!m_gridCells)
2328     return FALSE;
2329
2330   int i, j;
2331
2332   // Cells
2333   for (i = 0; i < m_totalRows; i++)
2334   {
2335       wxGridCell **cols = m_gridCells[i];
2336       wxGridCell **newCols = new wxGridCell *[m_totalCols - n];
2337       for (j = 0; j < pos; j++)
2338         newCols[j] = cols[j];
2339       for (j = pos; j < pos + n; j++)
2340         delete cols[j];
2341       for (j = pos + n; j < m_totalCols; j++)
2342         newCols[j-n] = cols[j];
2343
2344       delete[] cols;
2345       m_gridCells[i] = newCols;
2346   }
2347
2348   // Column widths
2349   short *newColWidths = new short[m_totalCols - n];
2350   for (j = 0; j < pos; j++)
2351     newColWidths[j] = m_colWidths[j];
2352   for (j = pos + n; j < m_totalCols; j++)
2353     newColWidths[j-n] = m_colWidths[j];
2354   delete[] m_colWidths;
2355   m_colWidths = newColWidths;
2356
2357   // Column labels
2358   wxGridCell **newLabels = new wxGridCell *[m_totalCols - n];
2359   for (j = 0; j < pos; j++)
2360     newLabels[j] = m_colLabelCells[j];
2361   for (j = pos + n; j < m_totalCols; j++)
2362     newLabels[j-n] = m_colLabelCells[j];
2363
2364   delete[] m_colLabelCells;
2365   m_colLabelCells = newLabels;
2366
2367   m_totalCols -= n;
2368
2369   if (updateLabels) {
2370         //OnChangeLabels();
2371         wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
2372         GetEventHandler()->ProcessEvent(g_evt);
2373     }
2374   UpdateDimensions();
2375   AdjustScrollbars();
2376   return TRUE;
2377 }
2378
2379 void wxGenericGrid::SetGridCursor(int row, int col)
2380 {
2381   if (row >= m_totalRows || col >= m_totalCols)
2382     return;
2383
2384   if (row == GetCursorRow() && col == GetCursorColumn())
2385     return;
2386
2387   wxClientDC dc(this);
2388   dc.BeginDrawing();
2389
2390   SetGridClippingRegion(& dc);
2391
2392   if (m_currentRectVisible)
2393     HighlightCell(& dc);
2394
2395   m_wCursorRow = row;
2396   m_wCursorColumn = col;
2397
2398   int cw, ch;
2399   GetClientSize(&cw, &ch);
2400
2401   SetCurrentRect(row, col, cw, ch);
2402
2403   if (m_currentRectVisible)
2404     HighlightCell(& dc);
2405
2406   dc.DestroyClippingRegion();
2407   dc.EndDrawing();
2408 }
2409
2410 /*
2411  * Grid cell
2412  */
2413
2414 wxGridCell::wxGridCell(wxGenericGrid *window)
2415 {
2416   cellBitmap = (wxBitmap *) NULL;
2417   font = wxNullFont;
2418   backgroundBrush = wxNullBrush;
2419   if (window)
2420     textColour = window->GetCellTextColour();
2421   else
2422     textColour.Set(0,0,0);
2423   if (window)
2424     backgroundColour = window->GetCellBackgroundColour();
2425   else
2426     backgroundColour.Set(255,255,255);
2427
2428   if (window)
2429     font = window->GetCellTextFont();
2430   else
2431     font = * wxTheFontList->FindOrCreateFont(12, wxSWISS, wxNORMAL, wxNORMAL);
2432
2433   SetBackgroundColour(backgroundColour);
2434
2435   if (window)
2436     alignment = window->GetCellAlignment();
2437   else
2438     alignment = wxLEFT;
2439 }
2440
2441 wxGridCell::~wxGridCell(void)
2442 {
2443 }
2444
2445 void wxGridCell::SetBackgroundColour(const wxColour& colour)
2446 {
2447   backgroundColour = colour;
2448   backgroundBrush = * wxTheBrushList->FindOrCreateBrush(backgroundColour, wxSOLID);
2449 }
2450
2451 void wxGenericGrid::OnText(wxCommandEvent& WXUNUSED(ev) )
2452 {
2453   wxGenericGrid *grid = this;
2454   wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
2455   if (cell && grid->CurrentCellVisible())
2456   {
2457     cell->SetTextValue(grid->GetTextItem()->GetValue());
2458     wxClientDC dc(grid);
2459
2460     dc.BeginDrawing();
2461     grid->SetGridClippingRegion(& dc);
2462     grid->DrawCellBackground(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2463     grid->DrawCellValue(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2464     grid->HighlightCell(& dc);
2465     dc.DestroyClippingRegion();
2466     dc.EndDrawing();
2467
2468     //grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
2469     wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_CHANGE, grid,
2470                       grid->GetCursorRow(), grid->GetCursorColumn());
2471     GetEventHandler()->ProcessEvent(g_evt);
2472
2473 //    grid->DrawCellText();
2474   }
2475 }
2476
2477 void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
2478 {
2479   static bool inScroll = FALSE;
2480
2481   if ( inScroll )
2482         return;
2483
2484   inScroll = TRUE;
2485   wxGenericGrid *win = this;
2486
2487   bool change = FALSE;
2488
2489   if (ev.GetEventObject() == win->GetHorizScrollBar())
2490   {
2491     change = (ev.GetPosition() != m_scrollPosX);
2492     win->SetScrollPosX(ev.GetPosition());
2493   }
2494   else
2495   {
2496     change = (ev.GetPosition() != m_scrollPosY);
2497     win->SetScrollPosY(ev.GetPosition());
2498   }
2499
2500   win->UpdateDimensions();
2501
2502   win->SetCurrentRect(win->GetCursorRow(), win->GetCursorColumn());
2503
2504   // Because rows and columns can be arbitrary sizes,
2505   // the scrollbars will need to be adjusted to reflect the
2506   // current view.
2507   AdjustScrollbars();
2508
2509   if (change) win->Refresh(FALSE);
2510   inScroll = FALSE;
2511
2512 }
2513
2514
2515 //----------------------------------------------------------------------
2516 // Default wxGridEvent handlers
2517 //      (just redirect to the pre-existing virtual methods)
2518
2519 void wxGenericGrid::_OnSelectCell(wxGridEvent& ev)
2520 {
2521     OnSelectCell(ev.m_row, ev.m_col);
2522 }
2523
2524 void wxGenericGrid::_OnCreateCell(wxGridEvent& ev)
2525 {
2526     ev.m_cell = OnCreateCell();
2527 }
2528
2529 void wxGenericGrid::_OnChangeLabels(wxGridEvent& WXUNUSED(ev))
2530 {
2531     OnChangeLabels();
2532 }
2533
2534 void wxGenericGrid::_OnChangeSelectionLabel(wxGridEvent& WXUNUSED(ev))
2535 {
2536     OnChangeSelectionLabel();
2537 }
2538
2539 void wxGenericGrid::_OnCellChange(wxGridEvent& ev)
2540 {
2541     OnCellChange(ev.m_row, ev.m_col);
2542 }
2543
2544 void wxGenericGrid::_OnCellLeftClick(wxGridEvent& ev)
2545 {
2546     OnCellLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2547 }
2548
2549 void wxGenericGrid::_OnCellRightClick(wxGridEvent& ev)
2550 {
2551     OnCellRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2552 }
2553
2554 void wxGenericGrid::_OnLabelLeftClick(wxGridEvent& ev)
2555 {
2556     OnLabelLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2557 }
2558
2559 void wxGenericGrid::_OnLabelRightClick(wxGridEvent& ev)
2560 {
2561     OnLabelRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
2562 }
2563
2564