Added wxGrid::DrawGridSpace function to suppress junk beyond last

[wxWidgets.git] / src / generic / gridg.cpp

diff --git a/src/generic/gridg.cpp b/src/generic/gridg.cpp
index 2043f5e7a21fc369ad3b7d1d514f54284dead750..cb590108cbf6988ca8d2c6b9bbc1dab649c65b6a 100644 (file)
--- a/src/generic/gridg.cpp
+++ b/src/generic/gridg.cpp
@@ -2,381 +2,493 @@
 // Name:        gridg.cpp
 // Purpose:     wxGenericGrid
 // Author:      Julian Smart
 // Name:        gridg.cpp
 // Purpose:     wxGenericGrid
 // Author:      Julian Smart

-// Modified by:
+// Modified by: Michael Bedward
+//                Added edit in place facility, 20 Apr 1999
+//                Added cursor key control, 29 Jun 1999
+//              Gerhard Gruber
+//                Added keyboard navigation, client data, other fixes

 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem

-// Licence:    wxWindows license
+// Licence:     wxWindows license

 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__

-#pragma implementation "gridg.h"
-#pragma interface
+    #pragma implementation "gridg.h"
+    #pragma interface

 #endif
 
 // For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include "wx/wx.h"
+    #include "wx/utils.h"
+    #include "wx/dcclient.h"
+    #include "wx/dcmemory.h"
+    #include "wx/textctrl.h"
+    #include "wx/settings.h"

 #endif
 
 #include <string.h>
 
 #include "wx/string.h"
 #endif
 
 #include <string.h>
 
 #include "wx/string.h"

+

 #include "wx/generic/gridg.h"
 #include "wx/generic/gridg.h"

-#include "wx/settings.h"

 
 

-static wxFont *wxGridEntryFont = NULL;
+
+// Values used to adjust the size of the in-place-edit control, and other
+// goodies.  Per-platform tweaks should be done here.
+#ifdef __WXMSW__
+#define wxIPE_ADJUST            -2
+#define wxIPE_STYLE             wxNO_BORDER
+#define wxIPE_HIGHLIGHT         1
+#define wxUSE_DOUBLE_BUFFERING  1
+#endif
+
+#ifdef __WXPM__
+#define wxIPE_ADJUST            -1
+#define wxIPE_STYLE             wxNO_BORDER
+#define wxIPE_HIGHLIGHT         1
+#define wxUSE_DOUBLE_BUFFERING  1
+#endif
+
+#ifdef __WXGTK__
+#define wxIPE_ADJUST            -1
+#define wxIPE_STYLE             wxNO_BORDER
+#define wxIPE_HIGHLIGHT         0
+#define wxUSE_DOUBLE_BUFFERING  1
+#endif
+
+#ifdef __WXMOTIF__
+#define wxIPE_ADJUST            2
+#define wxIPE_STYLE             wxNO_BORDER
+#define wxIPE_HIGHLIGHT         0
+#define wxUSE_DOUBLE_BUFFERING  0
+#endif
+
+#ifndef wxIPE_ADJUST
+#define wxIPE_ADJUST            2
+#define wxIPE_STYLE             wxNO_BORDER
+#define wxIPE_HIGHLIGHT         0
+#define wxUSE_DOUBLE_BUFFERING  0
+#endif
+
+

 
 #define wxGRID_DRAG_NONE       0
 #define wxGRID_DRAG_LEFT_RIGHT 1
 #define wxGRID_DRAG_UP_DOWN    2
 
 IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
 
 #define wxGRID_DRAG_NONE       0
 #define wxGRID_DRAG_LEFT_RIGHT 1
 #define wxGRID_DRAG_UP_DOWN    2
 
 IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)

+IMPLEMENT_DYNAMIC_CLASS(wxGridEvent, wxEvent)

 
 BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
 
 BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)

-       EVT_SIZE(wxGenericGrid::OnSize)
-       EVT_PAINT(wxGenericGrid::OnPaint)
-       EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
+    EVT_SIZE(wxGenericGrid::OnSize)
+    EVT_PAINT(wxGenericGrid::OnPaint)
+    EVT_ERASE_BACKGROUND(wxGenericGrid::OnEraseBackground)
+    EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)

     EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
     EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)

+    EVT_TEXT(wxGRID_EDIT_IN_PLACE_TEXT_CTRL, wxGenericGrid::OnTextInPlace)
+    EVT_TEXT_ENTER(wxGRID_TEXT_CTRL, wxGenericGrid::OnTextEnter)
+    EVT_TEXT_ENTER(wxGRID_EDIT_IN_PLACE_TEXT_CTRL, wxGenericGrid::OnTextInPlaceEnter)

     EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
     EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
     EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
     EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)

+
+    // default wxGridEvent handlers
+    EVT_GRID_SELECT_CELL(wxGenericGrid::_OnSelectCell)
+    EVT_GRID_CREATE_CELL(wxGenericGrid::_OnCreateCell)
+    EVT_GRID_CHANGE_LABELS(wxGenericGrid::_OnChangeLabels)
+    EVT_GRID_CHANGE_SEL_LABEL(wxGenericGrid::_OnChangeSelectionLabel)
+    EVT_GRID_CELL_CHANGE(wxGenericGrid::_OnCellChange)
+    EVT_GRID_CELL_LCLICK(wxGenericGrid::_OnCellLeftClick)
+    EVT_GRID_CELL_RCLICK(wxGenericGrid::_OnCellRightClick)
+    EVT_GRID_LABEL_LCLICK(wxGenericGrid::_OnLabelLeftClick)
+    EVT_GRID_LABEL_RCLICK(wxGenericGrid::_OnLabelRightClick)
+

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

-wxCursor *wxGenericGrid::horizontalSashCursor = NULL;
-wxCursor *wxGenericGrid::verticalSashCursor = NULL;
-
-wxGenericGrid::wxGenericGrid(void)
-{
-  hScrollBar = NULL;
-  vScrollBar = NULL;
-  batchCount = 0;
-  cellTextColour = *wxBLACK;
-  cellBackgroundColour = *wxWHITE;
-  labelTextColour = *wxBLACK;
-  labelBackgroundColour = *wxLIGHT_GREY;
-  labelBackgroundBrush = NULL;
-  labelTextFont = NULL;
-  cellTextFont = NULL;
-  textItem = NULL;
-  currentRectVisible = FALSE;
-  editable = TRUE;
+
+wxGenericGrid::wxGenericGrid()
+{
+  m_viewWidth = 0;
+  m_viewHeight = 0;
+  m_batchCount = 0;
+  m_hScrollBar = (wxScrollBar *) NULL;
+  m_vScrollBar = (wxScrollBar *) NULL;
+  m_cellTextColour = *wxBLACK;
+  m_cellBackgroundColour = *wxWHITE;
+  m_labelTextColour = *wxBLACK;
+//  m_labelBackgroundColour = *wxLIGHT_GREY;
+  m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+  m_labelBackgroundBrush = wxNullBrush;
+  m_labelTextFont = wxNullFont;
+  m_cellTextFont = wxNullFont;
+  m_textItem = (wxTextCtrl *) NULL;
+  m_currentRectVisible = FALSE;
+  m_editable = TRUE;
+
+  m_editInPlace = FALSE;
+  m_inOnTextInPlace = FALSE;
+  m_inScroll = FALSE;
+

 #if defined(__WIN95__)
 #if defined(__WIN95__)

-  scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
+  m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
+#elif defined(__WXGTK__)
+  m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);

 #else
 #else

-  scrollWidth = 16;
+  m_scrollWidth = 16;

 #endif
 #endif

-  dragStatus = wxGRID_DRAG_NONE;
-  dragRowOrCol = 0;
-  dragStartPosition = 0;
-  dragLastPosition = 0;
-  divisionPen = NULL;
-  wxGridEntryFont = NULL;
-  leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
-  topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
-  cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
-  totalGridWidth = 0;
-  totalGridHeight = 0;
-  colWidths = NULL;
-  rowHeights = NULL;
-  verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
-  horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
-  verticalLabelAlignment = wxCENTRE;
-  horizontalLabelAlignment = wxCENTRE;
-  editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
-  editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
-  editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
-  editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
-  wCursorRow = 0;
-  wCursorColumn = 0;
-  scrollPosX = 0;
-  scrollPosY = 0;
-  bEditCreated = FALSE;
-  totalRows = 0;
-  totalCols = 0;
-  gridCells = NULL;
-  rowLabelCells = NULL;
-  colLabelCells = NULL;
-  textItem = NULL;
-}
-
-bool wxGenericGrid::Create(wxWindow *parent, const wxWindowID id, const wxPoint& pos, const wxSize& size,
- const long style, const wxString& name)
-{
-  hScrollBar = NULL;
-  vScrollBar = NULL;
-  
-  batchCount = 0;
-  cellTextColour = *wxBLACK;
-  cellBackgroundColour = *wxWHITE;
-  labelTextColour = *wxBLACK;
-  labelBackgroundColour = *wxLIGHT_GREY;
-  labelBackgroundBrush = NULL;
-  labelTextFont = wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxBOLD);
-  cellTextFont = wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxNORMAL);
-  textItem = NULL;
-  currentRectVisible = FALSE;
-  editable = TRUE;
+  m_dragStatus = wxGRID_DRAG_NONE;
+  m_dragRowOrCol = 0;
+  m_dragStartPosition = 0;
+  m_dragLastPosition = 0;
+  m_divisionPen = wxNullPen;
+  m_highlightPen = wxNullPen;
+  m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
+  m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
+  m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
+  m_totalGridWidth = 0;
+  m_totalGridHeight = 0;
+  m_colWidths = (short *) NULL;
+  m_rowHeights = (short *) NULL;
+  m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
+  m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
+  m_verticalLabelAlignment = wxCENTRE;
+  m_horizontalLabelAlignment = wxCENTRE;
+  m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
+  m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
+  m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
+  m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
+  m_wCursorRow = 0;
+  m_wCursorColumn = 0;
+  m_scrollPosX = 0;
+  m_scrollPosY = 0;
+  m_editCreated = FALSE;
+  m_totalRows = 0;
+  m_totalCols = 0;
+  m_gridCells = (wxGridCell ***) NULL;
+  m_rowLabelCells = (wxGridCell **) NULL;
+  m_colLabelCells = (wxGridCell **) NULL;
+  m_textItem = (wxTextCtrl *) NULL;
+}
+
+bool wxGenericGrid::Create(wxWindow *parent,
+                           wxWindowID id,
+                           const wxPoint& pos,
+                           const wxSize& size,
+                           long style,
+                           const wxString& name)
+{
+  m_viewWidth = 0;
+  m_viewHeight = 0;
+  m_batchCount = 0;
+  m_editingPanel = (wxPanel *) NULL;
+  m_hScrollBar = (wxScrollBar *) NULL;
+  m_vScrollBar = (wxScrollBar *) NULL;
+  m_cellTextColour = *wxBLACK;
+  m_cellBackgroundColour = *wxWHITE;
+  m_labelTextColour = *wxBLACK;
+//  m_labelBackgroundColour = *wxLIGHT_GREY;
+  m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
+  m_labelBackgroundBrush = wxNullBrush;
+  m_labelTextFont = * wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxBOLD);
+  m_cellTextFont = * wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxNORMAL);
+  m_textItem = (wxTextCtrl *) NULL;
+  m_currentRectVisible = FALSE;
+  m_editable = TRUE;
+  m_editInPlace = FALSE;
+  m_inOnTextInPlace = FALSE;
+  m_inScroll = FALSE;

 #if defined(__WIN95__)
 #if defined(__WIN95__)

-  scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
+  m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
+#elif defined(__WXGTK__)
+  m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);

 #else
 #else

-  scrollWidth = 16;
+  m_scrollWidth = 16;

 #endif
 #endif

-  dragStatus = wxGRID_DRAG_NONE;
-  dragRowOrCol = 0;
-  dragStartPosition = 0;
-  dragLastPosition = 0;
-  divisionPen = wxThePenList->FindOrCreatePen("LIGHT GREY", 1, wxSOLID);
-  
-  if (!wxGridEntryFont)
-    wxGridEntryFont = new wxFont(9, wxSWISS, wxNORMAL, wxBOLD);
-
-  if (!horizontalSashCursor)
-  {
-    horizontalSashCursor = new wxCursor(wxCURSOR_SIZEWE);
-    verticalSashCursor = new wxCursor(wxCURSOR_SIZENS);
-  }
-    
-  SetLabelBackgroundColour(labelBackgroundColour);
-
-  leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
-  topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
-  cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
-  totalGridWidth = 0;
-  totalGridHeight = 0;
-  colWidths = NULL;
-  rowHeights = NULL;
-
-  verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
-  horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
-  verticalLabelAlignment = wxCENTRE;
-  horizontalLabelAlignment = wxCENTRE;
-  editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
-  editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
-  editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
-  editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
-
-  wCursorRow = 0;
-  wCursorColumn = 0;
-  
-  scrollPosX = 0;
-  scrollPosY = 0;
+  m_dragStatus = wxGRID_DRAG_NONE;
+  m_dragRowOrCol = 0;
+  m_dragStartPosition = 0;
+  m_dragLastPosition = 0;
+  m_divisionPen = * wxThePenList->FindOrCreatePen("LIGHT GREY", 1, wxSOLID);
+  m_highlightPen = * wxBLACK_PEN;
+  m_doubleBufferingBitmap = (wxBitmap *) NULL;
+
+  if (!m_horizontalSashCursor.Ok())
+  {
+    m_horizontalSashCursor = wxCursor(wxCURSOR_SIZEWE);
+    m_verticalSashCursor = wxCursor(wxCURSOR_SIZENS);
+  }
+
+  SetLabelBackgroundColour(m_labelBackgroundColour);
+
+  m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
+  m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
+  m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
+  m_totalGridWidth = 0;
+  m_totalGridHeight = 0;
+  m_colWidths = (short *) NULL;
+  m_rowHeights = (short *) NULL;
+
+  m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
+  m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
+  m_verticalLabelAlignment = wxCENTRE;
+  m_horizontalLabelAlignment = wxCENTRE;
+  m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
+  m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
+  m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
+  m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
+
+  m_wCursorRow = 0;
+  m_wCursorColumn = 0;
+
+  m_scrollPosX = 0;
+  m_scrollPosY = 0;

 
   /* Store the rect. coordinates for the current cell */
 
   /* Store the rect. coordinates for the current cell */

-  SetCurrentRect(wCursorRow, wCursorColumn);
+  SetCurrentRect(m_wCursorRow, m_wCursorColumn);

 
 

-  bEditCreated = FALSE;
+  m_editCreated = FALSE;

 
 

-  totalRows = 0;
-  totalCols = 0;
-  gridCells = NULL;
-  rowLabelCells = NULL;
-  colLabelCells = NULL;
-  textItem = NULL;
+  m_totalRows = 0;
+  m_totalCols = 0;
+  m_gridCells = (wxGridCell ***) NULL;
+  m_rowLabelCells = (wxGridCell **) NULL;
+  m_colLabelCells = (wxGridCell **) NULL;
+  m_textItem = (wxTextCtrl *) NULL;

 
   wxPanel::Create(parent, id, pos, size, style, name);
 
 
   wxPanel::Create(parent, id, pos, size, style, name);
 

-  SetButtonFont(*wxGridEntryFont);
-  SetLabelFont(*wxGridEntryFont);
-  
-  textItem = new wxTextCtrl(this, wxGRID_TEXT_CTRL, "",
-     wxPoint(editControlPosition.x, editControlPosition.y), wxSize(editControlPosition.width, -1),
-     0);
-  textItem->Show(TRUE);
-//  textItem->SetLabel("");
-  textItem->SetFocus();
+  m_editingPanel = new wxPanel(this);
+
+  m_textItem = new wxTextCtrl(m_editingPanel, wxGRID_TEXT_CTRL, "",
+                              wxPoint(m_editControlPosition.x, m_editControlPosition.y),
+                              wxSize(m_editControlPosition.width, -1),
+                              wxTE_PROCESS_ENTER);
+  m_textItem->Show(TRUE);
+  m_textItem->SetFocus();

   int controlW, controlH;
   int controlW, controlH;

-  
-  textItem->GetSize(&controlW, &controlH);
-  editControlPosition.height = controlH;
-  
-  topOfSheet = editControlPosition.x + controlH + 2;
-
-  bEditCreated = TRUE;
-  
-  hScrollBar = new wxScrollBar(this, wxGRID_HSCROLL, wxPoint(0, 0), wxSize(20, 100), wxHORIZONTAL);
-  vScrollBar = new wxScrollBar(this, wxGRID_VSCROLL, wxPoint(0, 0), wxSize(100, 20), wxVERTICAL);
-//  hScrollBar->Show(FALSE);
-//  vScrollBar->Show(FALSE);
-  AllowDoubleClick(TRUE);
+
+  m_textItem->GetSize(&controlW, &controlH);
+  m_editControlPosition.height = controlH;
+
+  m_topOfSheet = m_editControlPosition.y + controlH + 2;
+
+  m_editCreated = TRUE;
+
+  m_hScrollBar = new wxScrollBar(this, wxGRID_HSCROLL, wxPoint(0, 0), wxSize(20, 100), wxHORIZONTAL);
+  m_vScrollBar = new wxScrollBar(this, wxGRID_VSCROLL, wxPoint(0, 0), wxSize(100, 20), wxVERTICAL);
+
+//  SetSize(pos.x, pos.y, size.x, size.y);
+
+  m_inPlaceTextItem = new wxTextCtrl( (wxPanel*)this, wxGRID_EDIT_IN_PLACE_TEXT_CTRL, "",
+                                      wxPoint( m_currentRect.x-wxIPE_ADJUST, m_currentRect.y-wxIPE_ADJUST ),
+                                      wxSize( m_currentRect.width+wxIPE_ADJUST*2, m_currentRect.height+wxIPE_ADJUST*2 ),
+                                      wxNO_BORDER | wxTE_PROCESS_ENTER );
+  m_inPlaceTextItem->Show(m_editInPlace);
+  if ( m_editInPlace )
+    m_inPlaceTextItem->SetFocus();

 
   return TRUE;
 }
 
 
   return TRUE;
 }
 

-wxGenericGrid::~wxGenericGrid(void)
+wxGenericGrid::~wxGenericGrid()

 {
   ClearGrid();
 }
 
 {
   ClearGrid();
 }
 

-void wxGenericGrid::ClearGrid(void)
+void wxGenericGrid::ClearGrid()

 {
   int i,j;
 {
   int i,j;

-  if (gridCells)
+  if (m_gridCells)

   {
   {

-    for (i = 0; i < totalRows; i++)
+    for (i = 0; i < m_totalRows; i++)

     {
     {

-      for (j = 0; j < totalCols; j++)
-        if (gridCells[i][j])
-          delete gridCells[i][j];
-      delete[] gridCells[i];
+      for (j = 0; j < m_totalCols; j++)
+        if (m_gridCells[i][j])
+          delete m_gridCells[i][j];
+      delete[] m_gridCells[i];

     }
     }

-    delete[] gridCells;
-    gridCells = NULL;
+    delete[] m_gridCells;
+    m_gridCells = (wxGridCell ***) NULL;
+  }
+  if (m_colWidths)
+    delete[] m_colWidths;
+  m_colWidths = (short *) NULL;
+  if (m_rowHeights)
+    delete[] m_rowHeights;
+  m_rowHeights = (short *) NULL;
+
+  if (m_rowLabelCells)
+  {
+    for (i = 0; i < m_totalRows; i++)
+      delete m_rowLabelCells[i];
+    delete[] m_rowLabelCells;
+    m_rowLabelCells = (wxGridCell **) NULL;

   }
   }

-  if (colWidths)
-    delete[] colWidths;
-  colWidths = NULL;
-  if (rowHeights)
-    delete[] rowHeights;
-  rowHeights = NULL;
-  
-  if (rowLabelCells)
+  if (m_colLabelCells)

   {
   {

-    for (i = 0; i < totalRows; i++)
-      delete rowLabelCells[i];
-    delete[] rowLabelCells;
-    rowLabelCells = NULL;
+    for (i = 0; i < m_totalCols; i++)
+      delete m_colLabelCells[i];
+    delete[] m_colLabelCells;
+    m_colLabelCells = (wxGridCell **) NULL;

   }
   }

-  if (colLabelCells)
+  if (m_doubleBufferingBitmap)

   {
   {

-    for (i = 0; i < totalCols; i++)
-      delete colLabelCells[i];
-    delete[] colLabelCells;
-    colLabelCells = NULL;
+    delete m_doubleBufferingBitmap;
+    m_doubleBufferingBitmap = (wxBitmap *) NULL;

   }
 }
 
 bool wxGenericGrid::CreateGrid(int nRows, int nCols, wxString **cellValues, short *widths,
      short defaultWidth, short defaultHeight)
 {
   }
 }
 
 bool wxGenericGrid::CreateGrid(int nRows, int nCols, wxString **cellValues, short *widths,
      short defaultWidth, short defaultHeight)
 {

-  totalRows = nRows;
-  totalCols = nCols;
+  m_totalRows = nRows;
+  m_totalCols = nCols;

 
   int i,j;
 
   int i,j;

-  colWidths = new short[nCols];
-  rowHeights = new short[nRows];
+  m_colWidths = new short[nCols];
+  m_rowHeights = new short[nRows];

   for (i = 0; i < nCols; i++)
     if (widths)
   for (i = 0; i < nCols; i++)
     if (widths)

-      colWidths[i] = widths[i];
+      m_colWidths[i] = widths[i];

     else
     else

-      colWidths[i] = defaultWidth;
+      m_colWidths[i] = defaultWidth;

   for (i = 0; i < nRows; i++)
   for (i = 0; i < nRows; i++)

-    rowHeights[i] = defaultHeight;
-  
-  gridCells = new wxGridCell **[nRows];
-  
+    m_rowHeights[i] = defaultHeight;
+
+  m_gridCells = new wxGridCell **[nRows];
+

   for (i = 0; i < nRows; i++)
   for (i = 0; i < nRows; i++)

-    gridCells[i] = new wxGridCell *[nCols];
-    
+    m_gridCells[i] = new wxGridCell *[nCols];
+

   for (i = 0; i < nRows; i++)
     for (j = 0; j < nCols; j++)
       if (cellValues)
       {
   for (i = 0; i < nRows; i++)
     for (j = 0; j < nCols; j++)
       if (cellValues)
       {

-        gridCells[i][j] = OnCreateCell();
-        gridCells[i][j]->SetTextValue(cellValues[i][j]);
+        //m_gridCells[i][j] = OnCreateCell();
+        wxGridEvent g_evt(GetId(), wxEVT_GRID_CREATE_CELL, this, i, j);
+        GetEventHandler()->ProcessEvent(g_evt);
+        m_gridCells[i][j] = g_evt.m_cell;
+        m_gridCells[i][j]->SetTextValue(cellValues[i][j]);

       }
       else
       }
       else

-        gridCells[i][j] = NULL;
-        
-  rowLabelCells = new wxGridCell *[nRows];
+        m_gridCells[i][j] = (wxGridCell *) NULL;
+
+  m_rowLabelCells = new wxGridCell *[nRows];

   for (i = 0; i < nRows; i++)
   for (i = 0; i < nRows; i++)

-    rowLabelCells[i] = new wxGridCell(this);
-  colLabelCells = new wxGridCell *[nCols];
+    m_rowLabelCells[i] = new wxGridCell(this);
+  m_colLabelCells = new wxGridCell *[nCols];

   for (i = 0; i < nCols; i++)
   for (i = 0; i < nCols; i++)

-    colLabelCells[i] = new wxGridCell(this);
+    m_colLabelCells[i] = new wxGridCell(this);

 
 

-  wCursorRow = wCursorColumn = 0;
+  m_wCursorRow = m_wCursorColumn = 0;

   SetCurrentRect(0, 0);
 
   // Need to determine various dimensions
   UpdateDimensions();
 
   // Number of 'lines'
   SetCurrentRect(0, 0);
 
   // Need to determine various dimensions
   UpdateDimensions();
 
   // Number of 'lines'

-  int objectSizeX = totalCols;
+  int objectSizeX = m_totalCols;

   int pageSizeX = 1;
   int pageSizeX = 1;

-  int viewLengthX = totalCols;
-  hScrollBar->SetViewLength(viewLengthX);
-  hScrollBar->SetObjectLength(objectSizeX);
-  hScrollBar->SetPageSize(pageSizeX);
+  int viewLengthX = m_totalCols;

 
 

-  int objectSizeY = totalRows;
+/*
+  m_hScrollBar->SetViewLength(viewLengthX);
+  m_hScrollBar->SetObjectLength(objectSizeX);
+  m_hScrollBar->SetPageSize(pageSizeX);
+*/
+  m_hScrollBar->SetScrollbar(m_hScrollBar->GetThumbPosition(), pageSizeX, objectSizeX, viewLengthX);
+
+  int objectSizeY = m_totalRows;

   int pageSizeY = 1;
   int pageSizeY = 1;

-  int viewLengthY = totalRows;
+  int viewLengthY = m_totalRows;
+
+/*
+  m_vScrollBar->SetViewLength(viewLengthY);
+  m_vScrollBar->SetObjectLength(objectSizeY);
+  m_vScrollBar->SetPageSize(pageSizeY);
+*/

 
 

-  vScrollBar->SetViewLength(viewLengthY);
-  vScrollBar->SetObjectLength(objectSizeY);
-  vScrollBar->SetPageSize(pageSizeY);
+  m_vScrollBar->SetScrollbar(m_vScrollBar->GetThumbPosition(), pageSizeY, objectSizeY, viewLengthY);

 
   AdjustScrollbars();
 
 
   AdjustScrollbars();
 

-  OnChangeLabels();
-  OnChangeSelectionLabel();
-  
+  //OnChangeLabels();
+  wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
+  GetEventHandler()->ProcessEvent(g_evt);
+
+  //OnChangeSelectionLabel();
+  wxGridEvent g_evt2(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL, this);
+  GetEventHandler()->ProcessEvent(g_evt2);
+

   return TRUE;
 }
 
 // Need to determine various dimensions
   return TRUE;
 }
 
 // Need to determine various dimensions

-void wxGenericGrid::UpdateDimensions(void)
+void wxGenericGrid::UpdateDimensions()

 {
   int canvasWidth, canvasHeight;
   GetSize(&canvasWidth, &canvasHeight);
 {
   int canvasWidth, canvasHeight;
   GetSize(&canvasWidth, &canvasHeight);

-  
-  if (editable)
+
+  if (m_editCreated && m_editable)

   {
     int controlW, controlH;
     GetTextItem()->GetSize(&controlW, &controlH);
   {
     int controlW, controlH;
     GetTextItem()->GetSize(&controlW, &controlH);

-    topOfSheet = editControlPosition.x + controlH + 2;
+    m_topOfSheet = m_editControlPosition.y + controlH + 2;

   }
   else
   }
   else

-    topOfSheet = 0;
-  rightOfSheet = leftOfSheet + verticalLabelWidth;
+    m_topOfSheet = 0;
+  m_rightOfSheet = m_leftOfSheet + m_verticalLabelWidth;

   int i;
   int i;

-  for (i = scrollPosX; i < totalCols; i++)
+  for (i = m_scrollPosX; i < m_totalCols; i++)

   {
   {

-    if (rightOfSheet > canvasWidth)
+    if (m_rightOfSheet > canvasWidth)

       break;
     else
       break;
     else

-      rightOfSheet += colWidths[i];
+      m_rightOfSheet += m_colWidths[i];

   }
   }

-  bottomOfSheet = topOfSheet + horizontalLabelHeight;
-  for (i = scrollPosY; i < totalRows; i++)
+  m_bottomOfSheet = m_topOfSheet + m_horizontalLabelHeight;
+  for (i = m_scrollPosY; i < m_totalRows; i++)

   {
   {

-    if (bottomOfSheet > canvasHeight)
+    if (m_bottomOfSheet > canvasHeight)

       break;
     else
       break;
     else

-      bottomOfSheet += rowHeights[i];
+      m_bottomOfSheet += m_rowHeights[i];

   }
   }

-    
-  totalGridWidth = leftOfSheet + verticalLabelWidth;
-  for (i = 0; i < totalCols; i++)
+
+  m_totalGridWidth = m_leftOfSheet + m_verticalLabelWidth;
+  for (i = 0; i < m_totalCols; i++)

   {
   {

-    totalGridWidth += colWidths[i];
+    m_totalGridWidth += m_colWidths[i];

   }
   }

-  totalGridHeight = topOfSheet + horizontalLabelHeight;
-  for (i = 0; i < totalRows; i++)
+  m_totalGridHeight = m_topOfSheet + m_horizontalLabelHeight;
+  for (i = 0; i < m_totalRows; i++)

   {
   {

-    totalGridHeight += rowHeights[i];
+    m_totalGridHeight += m_rowHeights[i];

   }
 }
 
   }
 }
 

-wxGridCell *wxGenericGrid::GetCell(int row, int col)
+wxGridCell *wxGenericGrid::GetCell(int row, int col) const

 {
 {

-  if (!gridCells)
-    return NULL;
+  if (!m_gridCells)
+    return (wxGridCell *) NULL;
+
+  if ((row >= m_totalRows) || (col >= m_totalCols))
+    return (wxGridCell *) NULL;

 
 

-  if ((row >= totalRows) || (col >= totalCols))
-    return NULL;
-    
-  wxGridCell *cell = gridCells[row][col];
+  wxGridCell *cell = m_gridCells[row][col];

   if (!cell)
   {
   if (!cell)
   {

-    gridCells[row][col] = OnCreateCell();
-    return gridCells[row][col];
+    // m_gridCells[row][col] = OnCreateCell();
+    wxGridEvent g_evt(GetId(), wxEVT_GRID_CREATE_CELL, (wxGenericGrid*) this, row, col);
+    GetEventHandler()->ProcessEvent(g_evt);
+    m_gridCells[row][col] = g_evt.m_cell;
+    return m_gridCells[row][col];

   }
   else
     return cell;
   }
   else
     return cell;


@@ -384,59 +496,124 @@ wxGridCell *wxGenericGrid::GetCell(int row, int col)
 
 void wxGenericGrid::SetGridClippingRegion(wxDC *dc)
 {
 
 void wxGenericGrid::SetGridClippingRegion(wxDC *dc)
 {

-  int scrollWidthHoriz = 0;
-  int scrollWidthVert = 0;
+  int m_scrollWidthHoriz = 0;
+  int m_scrollWidthVert = 0;

   int cw, ch;
   GetClientSize(&cw, &ch);
 
   int cw, ch;
   GetClientSize(&cw, &ch);
 

-  if (hScrollBar && hScrollBar->IsShown())
-    scrollWidthHoriz = scrollWidth;
-  if (vScrollBar && vScrollBar->IsShown())
-    scrollWidthVert = scrollWidth;
+  if (m_hScrollBar && m_hScrollBar->IsShown())
+    m_scrollWidthHoriz = m_scrollWidth;
+  if (m_vScrollBar && m_vScrollBar->IsShown())
+    m_scrollWidthVert = m_scrollWidth;

 
   // Don't paint over the scrollbars
 
   // Don't paint over the scrollbars

-  dc->SetClippingRegion(leftOfSheet, topOfSheet,
-     cw - scrollWidthVert - leftOfSheet, ch - scrollWidthHoriz - topOfSheet);
+  dc->SetClippingRegion(m_leftOfSheet, m_topOfSheet,
+     cw - m_scrollWidthVert - m_leftOfSheet, ch - m_scrollWidthHoriz - m_topOfSheet);

 }
 
 void wxGenericGrid::OnPaint(wxPaintEvent& WXUNUSED(event))
 {
 }
 
 void wxGenericGrid::OnPaint(wxPaintEvent& WXUNUSED(event))
 {

-/*
-  static bool inPaint = FALSE;
+  int w, h;
+  GetClientSize(&w, &h);

 
 

-  if ( inPaint )
-       return;
+  bool useDoubleBuffering = (bool) wxUSE_DOUBLE_BUFFERING;
+  if (useDoubleBuffering)
+  {
+    // Reuse the old bitmap if possible

 
 

-  inPaint = TRUE;
-*/
+    if (!m_doubleBufferingBitmap ||
+       (m_doubleBufferingBitmap->GetWidth() < w || m_doubleBufferingBitmap->GetHeight() < h))
+    {
+        if (m_doubleBufferingBitmap)
+            delete m_doubleBufferingBitmap;
+        m_doubleBufferingBitmap = new wxBitmap(w, h);
+    }
+    if (!m_doubleBufferingBitmap || !m_doubleBufferingBitmap->Ok())
+    {
+        // If we couldn't create a new bitmap, perhaps because resources were low,
+        // then don't complain, just don't double-buffer
+        if (m_doubleBufferingBitmap)
+            delete m_doubleBufferingBitmap;
+        m_doubleBufferingBitmap = (wxBitmap *) NULL;
+        useDoubleBuffering = FALSE;
+    }
+  }

 
 

-  wxRectangle rect;
+  if (useDoubleBuffering)
+  {
+    wxPaintDC paintDC(this);
+    wxMemoryDC dc(& paintDC);
+    dc.SelectObject(* m_doubleBufferingBitmap);

 
 

-  wxPaintDC dc(this);
-  dc.BeginDrawing();
-  dc.SetOptimization(FALSE);
-  
-  SetGridClippingRegion(&dc);
-
-  DrawLabelAreas(&dc);
-  DrawEditableArea(&dc);
-  DrawColumnLabels(&dc);
-  DrawRowLabels(&dc);
-  DrawCells(&dc);
-  DrawGridLines(&dc);
-
-  /* Hilight present cell */
-  SetCurrentRect(wCursorRow, wCursorColumn);
-  if (currentRectVisible)
-    HighlightCell(&dc);
+    PaintGrid(dc);

 
 

-  dc.DestroyClippingRegion();
-  dc.SetOptimization(TRUE);
-  dc.EndDrawing();
+    int vertScrollBarWidth = m_scrollWidth;
+    int horizScrollBarHeight = m_scrollWidth;
+    if (m_vScrollBar && !m_vScrollBar->IsShown())
+      vertScrollBarWidth = 0;
+    if (m_hScrollBar && !m_hScrollBar->IsShown())
+      horizScrollBarHeight = 0;
+
+    paintDC.Blit(m_leftOfSheet, m_topOfSheet, w - vertScrollBarWidth - m_leftOfSheet, h - horizScrollBarHeight - m_topOfSheet,
+      &dc, m_leftOfSheet, m_topOfSheet, wxCOPY);

 
 

-//  inPaint = FALSE;
+    dc.SelectObject(wxNullBitmap);
+  }
+  else
+  {
+    wxPaintDC dc(this);
+    PaintGrid(dc);
+  }

 }
 
 }
 

+void wxGenericGrid::PaintGrid(wxDC& dc)
+{
+    dc.BeginDrawing();
+    dc.SetOptimization(FALSE);
+
+    SetGridClippingRegion(& dc);
+
+    DrawLabelAreas(& dc);
+
+    DrawEditableArea(& dc);
+    DrawColumnLabels(& dc);
+    DrawRowLabels(& dc);
+    DrawCells(& dc);
+    DrawGridLines(& dc);
+
+    /* Hilight present cell */
+    SetCurrentRect(m_wCursorRow, m_wCursorColumn);
+    if (m_currentRectVisible && (wxIPE_HIGHLIGHT || !(m_editable && m_editInPlace)))
+      HighlightCell(& dc, TRUE);
+
+    dc.DestroyClippingRegion();
+    dc.SetOptimization(TRUE);
+    dc.EndDrawing();
+}
+
+// Erase (some of) the background.
+// Currently, a Windows-only optimisation.
+void wxGenericGrid::OnEraseBackground(wxEraseEvent& WXUNUSED(event) )
+{
+    wxClientDC dc(this);
+    dc.BeginDrawing();
+    dc.SetOptimization(FALSE);
+
+    int w, h;
+    GetClientSize(& w, & h);
+    dc.SetBrush(*wxLIGHT_GREY_BRUSH);
+    dc.SetPen(*wxLIGHT_GREY_PEN);
+
+    if (m_hScrollBar && m_hScrollBar->IsShown() && m_vScrollBar && m_vScrollBar->IsShown())
+    {
+        dc.DrawRectangle(w - m_scrollWidth, h - m_scrollWidth, m_scrollWidth, m_scrollWidth);
+    }
+
+    dc.SetOptimization(TRUE);
+    dc.EndDrawing();
+}
+
+

 void wxGenericGrid::DrawLabelAreas(wxDC *dc)
 {
   int cw, ch;
 void wxGenericGrid::DrawLabelAreas(wxDC *dc)
 {
   int cw, ch;


@@ -446,15 +623,15 @@ void wxGenericGrid::DrawLabelAreas(wxDC *dc)
 //  dc->SetBrush(*dc->GetBackground());
 
   // Should blank out any area which isn't going to be painted over.
 //  dc->SetBrush(*dc->GetBackground());
 
   // Should blank out any area which isn't going to be painted over.

-//  dc->DrawRectangle(leftOfSheet, bottomOfSheet, cw - leftOfSheet, ch - bottomOfSheet);
-//  dc->DrawRectangle(rightOfSheet, topOfSheet, cw - rightOfSheet, ch - topOfSheet);
+//  dc->DrawRectangle(m_leftOfSheet, m_bottomOfSheet, cw - m_leftOfSheet, ch - m_bottomOfSheet);
+//  dc->DrawRectangle(m_rightOfSheet, m_topOfSheet, cw - m_rightOfSheet, ch - m_topOfSheet);

 
   // Paint the label areas
 
   // Paint the label areas

-  dc->SetBrush(*labelBackgroundBrush);
-//  dc->DrawRectangle(leftOfSheet, topOfSheet, rightOfSheet - leftOfSheet + 1, horizontalLabelHeight + 1);
-  dc->DrawRectangle(leftOfSheet, topOfSheet, cw-leftOfSheet, horizontalLabelHeight + 1);
-//  dc->DrawRectangle(leftOfSheet, topOfSheet, verticalLabelWidth + 1, bottomOfSheet - topOfSheet + 1);
-  dc->DrawRectangle(leftOfSheet, topOfSheet, verticalLabelWidth + 1, ch-topOfSheet);
+  dc->SetBrush(m_labelBackgroundBrush);
+//  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_rightOfSheet - m_leftOfSheet + 1, m_horizontalLabelHeight + 1);
+  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, cw-m_leftOfSheet, m_horizontalLabelHeight + 1);
+//  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, m_bottomOfSheet - m_topOfSheet + 1);
+  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, ch-m_topOfSheet);

 }
 
 void wxGenericGrid::DrawEditableArea(wxDC *dc)
 }
 
 void wxGenericGrid::DrawEditableArea(wxDC *dc)


@@ -463,168 +640,168 @@ void wxGenericGrid::DrawEditableArea(wxDC *dc)
   GetClientSize(&cw, &ch);
 
   dc->SetPen(*wxTRANSPARENT_PEN);
   GetClientSize(&cw, &ch);
 
   dc->SetPen(*wxTRANSPARENT_PEN);

-  dc->SetBrush(*wxTheBrushList->FindOrCreateBrush(cellBackgroundColour, wxSOLID));
-//  dc->DrawRectangle(leftOfSheet+verticalLabelWidth, topOfSheet+horizontalLabelHeight,
-//      rightOfSheet-(leftOfSheet+verticalLabelWidth) + 1, bottomOfSheet - (topOfSheet+horizontalLabelHeight) + 1);
-  dc->DrawRectangle(leftOfSheet+verticalLabelWidth, topOfSheet+horizontalLabelHeight,
-      cw-(leftOfSheet+verticalLabelWidth), ch - (topOfSheet+horizontalLabelHeight));
+  dc->SetBrush(*wxTheBrushList->FindOrCreateBrush(m_cellBackgroundColour, wxSOLID));
+//  dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
+//      m_rightOfSheet-(m_leftOfSheet+m_verticalLabelWidth) + 1, m_bottomOfSheet - (m_topOfSheet+m_horizontalLabelHeight) + 1);
+  dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
+      cw-(m_leftOfSheet+m_verticalLabelWidth), ch - (m_topOfSheet+m_horizontalLabelHeight));

 }
 
 void wxGenericGrid::DrawGridLines(wxDC *dc)
 {
   int cw, ch;
   GetClientSize(&cw, &ch);
 }
 
 void wxGenericGrid::DrawGridLines(wxDC *dc)
 {
   int cw, ch;
   GetClientSize(&cw, &ch);

-  
+

   int i;
 
   int i;
 

-  if (divisionPen)
+  if (m_divisionPen.Ok())

   {
   {

-    dc->SetPen(*divisionPen);
+    dc->SetPen(m_divisionPen);

 
 

-    int heightCount = topOfSheet + horizontalLabelHeight;
+    int heightCount = m_topOfSheet + m_horizontalLabelHeight;

 
     // Draw horizontal grey lines for cells
 
     // Draw horizontal grey lines for cells

-    for (i = scrollPosY; i < (totalRows+1); i++)
+    for (i = m_scrollPosY; i < (m_totalRows+1); i++)

     {
       if (heightCount > ch)
         break;
       else
       {
     {
       if (heightCount > ch)
         break;
       else
       {

-        dc->DrawLine(leftOfSheet, heightCount,
+        dc->DrawLine(m_leftOfSheet, heightCount,

                    cw, heightCount);
                    cw, heightCount);

-        if (i < totalRows)
-          heightCount += rowHeights[i];
+        if (i < m_totalRows)
+          heightCount += m_rowHeights[i];

       }
     }
   }
 
       }
     }
   }
 

-  if (verticalLabelWidth > 0)
+  if (m_verticalLabelWidth > 0)

   {
     dc->SetPen(*wxBLACK_PEN);
 
     // Draw horizontal black lines for row labels
   {
     dc->SetPen(*wxBLACK_PEN);
 
     // Draw horizontal black lines for row labels

-    int heightCount = topOfSheet + horizontalLabelHeight;
-    for (i = scrollPosY; i < (totalRows+1); i++)
+    int heightCount = m_topOfSheet + m_horizontalLabelHeight;
+    for (i = m_scrollPosY; i < (m_totalRows+1); i++)

     {
       if (heightCount > ch)
         break;
       else
       {
     {
       if (heightCount > ch)
         break;
       else
       {

-        dc->DrawLine(leftOfSheet, heightCount,
-                     verticalLabelWidth, heightCount);
-        if (i < totalRows)
-          heightCount += rowHeights[i];
+        dc->DrawLine(m_leftOfSheet, heightCount,
+                     m_verticalLabelWidth, heightCount);
+        if (i < m_totalRows)
+          heightCount += m_rowHeights[i];

       }
     }
     // Draw a black vertical line for row number cells
       }
     }
     // Draw a black vertical line for row number cells

-    dc->DrawLine(leftOfSheet + verticalLabelWidth, topOfSheet,
-      leftOfSheet + verticalLabelWidth, ch);
+    dc->DrawLine(m_leftOfSheet + m_verticalLabelWidth, m_topOfSheet,
+      m_leftOfSheet + m_verticalLabelWidth, ch);

     // First vertical line
     // First vertical line

-    dc->DrawLine(leftOfSheet, topOfSheet, leftOfSheet, ch);
+    dc->DrawLine(m_leftOfSheet, m_topOfSheet, m_leftOfSheet, ch);

 
     dc->SetPen(*wxWHITE_PEN);
 
     // Draw highlights on row labels
 
     dc->SetPen(*wxWHITE_PEN);
 
     // Draw highlights on row labels

-    heightCount = topOfSheet + horizontalLabelHeight;
-    for (i = scrollPosY; i < totalRows; i++)
+    heightCount = m_topOfSheet + m_horizontalLabelHeight;
+    for (i = m_scrollPosY; i < m_totalRows; i++)

     {
       if (heightCount > ch)
         break;
       else
       {
     {
       if (heightCount > ch)
         break;
       else
       {

-        dc->DrawLine(leftOfSheet+1, heightCount+1,
-                     verticalLabelWidth, heightCount+1);
-        dc->DrawLine(leftOfSheet+1, heightCount+1,
-                     leftOfSheet+1, heightCount + rowHeights[i] - 1);
-        heightCount += rowHeights[i];
+        dc->DrawLine(m_leftOfSheet+1, heightCount+1,
+                     m_verticalLabelWidth, heightCount+1);
+        dc->DrawLine(m_leftOfSheet+1, heightCount+1,
+                     m_leftOfSheet+1, heightCount + m_rowHeights[i] - 1);
+        heightCount += m_rowHeights[i];

       }
     }
     // Last one - down to the floor.
       }
     }
     // Last one - down to the floor.

-    dc->DrawLine(leftOfSheet+1, heightCount+1,
-                 verticalLabelWidth, heightCount+1);
-    dc->DrawLine(leftOfSheet+1, heightCount+1,
-                   leftOfSheet+1, ch);
+    dc->DrawLine(m_leftOfSheet+1, heightCount+1,
+                 m_verticalLabelWidth, heightCount+1);
+    dc->DrawLine(m_leftOfSheet+1, heightCount+1,
+                   m_leftOfSheet+1, ch);

 
   }
 
 
   }
 

-  if (divisionPen)
+  if (m_divisionPen.Ok())

   {
   {

-    dc->SetPen(*divisionPen);
+    dc->SetPen(m_divisionPen);

 
     // Draw vertical grey lines for cells
 
     // Draw vertical grey lines for cells

-    int widthCount = leftOfSheet + verticalLabelWidth;
-    for (i = scrollPosX; i < totalCols; i++)
+    int widthCount = m_leftOfSheet + m_verticalLabelWidth;
+    for (i = m_scrollPosX; i < m_totalCols; i++)

     {
       if (widthCount > cw)
         break;
       else
       {
         // Skip the first one
     {
       if (widthCount > cw)
         break;
       else
       {
         // Skip the first one

-        if (i != scrollPosX)
+        if (i != m_scrollPosX)

         {
         {

-         dc->DrawLine(widthCount, topOfSheet + horizontalLabelHeight,
-                       widthCount, bottomOfSheet);
+         dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
+                       widthCount, m_bottomOfSheet);

         }
         }

-        widthCount += colWidths[i];
+        widthCount += m_colWidths[i];

       }
     }
     // Last one
       }
     }
     // Last one

-    dc->DrawLine(widthCount, topOfSheet + horizontalLabelHeight,
-                    widthCount, bottomOfSheet);
+    dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
+                    widthCount, m_bottomOfSheet);

   }
 
   dc->SetPen(*wxBLACK_PEN);
 
   // Draw two black horizontal lines for column number cells
   dc->DrawLine(
   }
 
   dc->SetPen(*wxBLACK_PEN);
 
   // Draw two black horizontal lines for column number cells
   dc->DrawLine(

-          leftOfSheet, topOfSheet,
-          cw, topOfSheet);
-  dc->DrawLine(leftOfSheet,  topOfSheet + horizontalLabelHeight,
-               cw, topOfSheet + horizontalLabelHeight);
+          m_leftOfSheet, m_topOfSheet,
+          cw, m_topOfSheet);
+  dc->DrawLine(m_leftOfSheet,  m_topOfSheet + m_horizontalLabelHeight,
+               cw, m_topOfSheet + m_horizontalLabelHeight);

 
 

-  if (horizontalLabelHeight > 0)
+  if (m_horizontalLabelHeight > 0)

   {
   {

-    int widthCount = leftOfSheet + verticalLabelWidth;
-  
+    int widthCount = m_leftOfSheet + m_verticalLabelWidth;
+

     // Draw black vertical lines for column number cells
     // Draw black vertical lines for column number cells

-    for (i = scrollPosX; i < totalCols; i++)
+    for (i = m_scrollPosX; i < m_totalCols; i++)

     {
       if (widthCount > cw)
         break;
       else
       {
     {
       if (widthCount > cw)
         break;
       else
       {

-        dc->DrawLine(widthCount, topOfSheet,
-                      widthCount, topOfSheet + horizontalLabelHeight);
-        widthCount += colWidths[i];
+        dc->DrawLine(widthCount, m_topOfSheet,
+                      widthCount, m_topOfSheet + m_horizontalLabelHeight);
+        widthCount += m_colWidths[i];

       }
     }
 
     // Last one
       }
     }
 
     // Last one

-    dc->DrawLine(widthCount, topOfSheet,
-                    widthCount, topOfSheet + horizontalLabelHeight);
+    dc->DrawLine(widthCount, m_topOfSheet,
+                    widthCount, m_topOfSheet + m_horizontalLabelHeight);

 
     // Draw highlights
     dc->SetPen(*wxWHITE_PEN);
 
     // Draw highlights
     dc->SetPen(*wxWHITE_PEN);

-    widthCount = leftOfSheet + verticalLabelWidth;
-  
-    for (i = scrollPosX; i < totalCols; i++)
+    widthCount = m_leftOfSheet + m_verticalLabelWidth;
+
+    for (i = m_scrollPosX; i < m_totalCols; i++)

     {
       if (widthCount > cw)
         break;
       else
       {
     {
       if (widthCount > cw)
         break;
       else
       {

-        dc->DrawLine(widthCount+1, topOfSheet+1,
-                     widthCount+colWidths[i], topOfSheet+1);
-        dc->DrawLine(widthCount+1, topOfSheet+1,
-                     widthCount+1, topOfSheet+horizontalLabelHeight);
-        widthCount += colWidths[i];
+        dc->DrawLine(widthCount+1, m_topOfSheet+1,
+                     widthCount+m_colWidths[i], m_topOfSheet+1);
+        dc->DrawLine(widthCount+1, m_topOfSheet+1,
+                     widthCount+1, m_topOfSheet+m_horizontalLabelHeight);
+        widthCount += m_colWidths[i];

       }
     }
     // Last one - to the right side of the canvas.
       }
     }
     // Last one - to the right side of the canvas.

-    dc->DrawLine(widthCount+1, topOfSheet+1,
-                   cw, topOfSheet+1);
-    dc->DrawLine(widthCount+1, topOfSheet+1,
-                   widthCount+1, topOfSheet+horizontalLabelHeight);
+    dc->DrawLine(widthCount+1, m_topOfSheet+1,
+                   cw, m_topOfSheet+1);
+    dc->DrawLine(widthCount+1, m_topOfSheet+1,
+                   widthCount+1, m_topOfSheet+m_horizontalLabelHeight);

 
   }
 }
 
   }
 }


@@ -634,51 +811,51 @@ void wxGenericGrid::DrawColumnLabels(wxDC *dc)
   int cw, ch;
   GetClientSize(&cw, &ch);
 
   int cw, ch;
   GetClientSize(&cw, &ch);
 

-  if (horizontalLabelHeight == 0)
+  if (m_horizontalLabelHeight == 0)

     return;
     return;

-    
+

   int i;
   int i;

-  wxRectangle rect;
+  wxRect rect;

 
   // Draw letters for columns
 
   // Draw letters for columns

-  rect.y = topOfSheet + 1;
-  rect.height = horizontalLabelHeight - 1;
+  rect.y = m_topOfSheet + 1;
+  rect.height = m_horizontalLabelHeight - 1;

 
 

-  dc->SetTextBackground(labelBackgroundColour);
+  dc->SetTextBackground(m_labelBackgroundColour);

   dc->SetBackgroundMode(wxTRANSPARENT);
   dc->SetBackgroundMode(wxTRANSPARENT);

-//  dc->SetTextForeground(labelTextColour);
-  
-  int widthCount = leftOfSheet + verticalLabelWidth;
-  for (i = scrollPosX; i < totalCols; i++)
+//  dc->SetTextForeground(m_labelTextColour);
+
+  int widthCount = m_leftOfSheet + m_verticalLabelWidth;
+  for (i = m_scrollPosX; i < m_totalCols; i++)

   {
      if (widthCount > cw)
        break;
      else
      {
        rect.x = 1 + widthCount;
   {
      if (widthCount > cw)
        break;
      else
      {
        rect.x = 1 + widthCount;

-       rect.width = colWidths[i];
+       rect.width = m_colWidths[i];

        DrawColumnLabel(dc, &rect, i);
 
        DrawColumnLabel(dc, &rect, i);
 

-       widthCount += colWidths[i];
+       widthCount += m_colWidths[i];

      }
   }
 }
 
      }
   }
 }
 

-void wxGenericGrid::DrawColumnLabel(wxDC *dc, wxRectangle *rect, int col)
+void wxGenericGrid::DrawColumnLabel(wxDC *dc, wxRect *rect, int col)

 {
   wxGridCell *cell = GetLabelCell(wxHORIZONTAL, col);
   if (cell)
   {
 {
   wxGridCell *cell = GetLabelCell(wxHORIZONTAL, col);
   if (cell)
   {

-    wxRectangle rect2;
+    wxRect rect2;

     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;
     rect2.width -= 5;
     rect2.height -= 4;
     dc->SetTextForeground(GetLabelTextColour());
     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;
     rect2.width -= 5;
     rect2.height -= 4;
     dc->SetTextForeground(GetLabelTextColour());

-    dc->SetFont(*GetLabelTextFont());
-       if ( !cell->GetTextValue().IsNull() )
-       DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxHORIZONTAL));
+    dc->SetFont(GetLabelTextFont());
+        if ( !cell->GetTextValue().IsNull() )
+            DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxHORIZONTAL));

   }
 }
 
   }
 }
 


@@ -687,51 +864,51 @@ void wxGenericGrid::DrawRowLabels(wxDC *dc)
   int cw, ch;
   GetClientSize(&cw, &ch);
 
   int cw, ch;
   GetClientSize(&cw, &ch);
 

-  if (verticalLabelWidth == 0)
+  if (m_verticalLabelWidth == 0)

     return;
 
   int i;
     return;
 
   int i;

-  wxRectangle rect;
-  
+  wxRect rect;
+

   // Draw numbers for rows
   // Draw numbers for rows

-  rect.x = leftOfSheet;
-  rect.width = verticalLabelWidth;
+  rect.x = m_leftOfSheet;
+  rect.width = m_verticalLabelWidth;

 
 

-  int heightCount = topOfSheet + horizontalLabelHeight;
+  int heightCount = m_topOfSheet + m_horizontalLabelHeight;

 
 

-  dc->SetTextBackground(labelBackgroundColour);
+  dc->SetTextBackground(m_labelBackgroundColour);

   dc->SetBackgroundMode(wxTRANSPARENT);
 
   dc->SetBackgroundMode(wxTRANSPARENT);
 

-  for (i = scrollPosY; i < totalRows; i++)
+  for (i = m_scrollPosY; i < m_totalRows; i++)

   {
      if (heightCount > ch)
        break;
      else
      {
        rect.y = 1 + heightCount;
   {
      if (heightCount > ch)
        break;
      else
      {
        rect.y = 1 + heightCount;

-       rect.height = rowHeights[i];
+       rect.height = m_rowHeights[i];

        DrawRowLabel(dc, &rect, i);
        DrawRowLabel(dc, &rect, i);

-     
-       heightCount += rowHeights[i];
+
+       heightCount += m_rowHeights[i];

      }
   }
 }
 
      }
   }
 }
 

-void wxGenericGrid::DrawRowLabel(wxDC *dc, wxRectangle *rect, int row)
+void wxGenericGrid::DrawRowLabel(wxDC *dc, wxRect *rect, int row)

 {
   wxGridCell *cell = GetLabelCell(wxVERTICAL, row);
   if (cell)
   {
 {
   wxGridCell *cell = GetLabelCell(wxVERTICAL, row);
   if (cell)
   {

-    wxRectangle rect2;
+    wxRect rect2;

     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;
     rect2.width -= 5;
     rect2.height -= 4;
     dc->SetTextForeground(GetLabelTextColour());
     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;
     rect2.width -= 5;
     rect2.height -= 4;
     dc->SetTextForeground(GetLabelTextColour());

-    dc->SetFont(*GetLabelTextFont());
-       if ( !cell->GetTextValue().IsNull() )
-       DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxVERTICAL));
+    dc->SetFont(GetLabelTextFont());
+        if ( !cell->GetTextValue().IsNull() )
+            DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxVERTICAL));

   }
 }
 
   }
 }
 


@@ -741,51 +918,57 @@ void wxGenericGrid::DrawCells(wxDC *dc)
   GetClientSize(&cw, &ch);
 
   int i,j;
   GetClientSize(&cw, &ch);
 
   int i,j;

-  
+

   // Draw value corresponding to each cell
   // Draw value corresponding to each cell

-  for (i = scrollPosY; i < totalRows; i++)
+  for (i = m_scrollPosY; i < m_totalRows; i++)

   {
   {

-    for (j = scrollPosX; j < totalCols; j++)
+    for (j = m_scrollPosX; j < m_totalCols; j++)

     {
       SetCurrentRect(i, j, cw, ch);
     {
       SetCurrentRect(i, j, cw, ch);

-      if (currentRectVisible)
+      if (m_currentRectVisible)

       {
       {

-        DrawCellBackground(dc, &CurrentRect, i, j);
-        DrawCellValue(dc, &CurrentRect, i, j);
+        DrawCellBackground(dc, &m_currentRect, i, j);
+        DrawCellValue(dc, &m_currentRect, i, j);

       }
       }

-      if (CurrentRect.x > cw)
+      if (m_currentRect.x > cw)

         break;
     }
         break;
     }

-    if (CurrentRect.y > ch)
+    if (m_currentRect.y > ch)

       break;
   }
   dc->SetBackgroundMode(wxSOLID);
   dc->SetPen(*wxBLACK_PEN);
 }
 
       break;
   }
   dc->SetBackgroundMode(wxSOLID);
   dc->SetPen(*wxBLACK_PEN);
 }
 

-void wxGenericGrid::DrawCellBackground(wxDC *dc, wxRectangle *rect, int row, int col)
+void wxGenericGrid::DrawCellBackground(wxDC *dc, wxRect *rect, int row, int col)

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
   {
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
   {

-    dc->SetBrush(*cell->GetBackgroundBrush());
+    dc->SetBrush(cell->GetBackgroundBrush());

     dc->SetPen(*wxTRANSPARENT_PEN);
     dc->SetPen(*wxTRANSPARENT_PEN);

-#ifdef __MOTIF__
+
+#if 0    // In wxWin 2.0 the dc code is exact. RR.
+#ifdef __WXMOTIF__

     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 #else
     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width, rect->height);
 #endif
     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 #else
     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width, rect->height);
 #endif

+#endif
+
+    dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
+

     dc->SetPen(*wxBLACK_PEN);
   }
 }
 
     dc->SetPen(*wxBLACK_PEN);
   }
 }
 

-void wxGenericGrid::DrawCellValue(wxDC *dc, wxRectangle *rect, int row, int col)
+void wxGenericGrid::DrawCellValue(wxDC *dc, wxRect *rect, int row, int col)

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
   {
     wxBitmap *bitmap = cell->GetCellBitmap();
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
   {
     wxBitmap *bitmap = cell->GetCellBitmap();

-    wxRectangle rect2;
+    wxRect rect2;

     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;
     rect2 = *rect;
     rect2.x += 3;
     rect2.y += 2;


@@ -800,28 +983,19 @@ void wxGenericGrid::DrawCellValue(wxDC *dc, wxRectangle *rect, int row, int col)
     {
       dc->SetBackgroundMode(wxTRANSPARENT);
       dc->SetTextForeground(cell->GetTextColour());
     {
       dc->SetBackgroundMode(wxTRANSPARENT);
       dc->SetTextForeground(cell->GetTextColour());

-      dc->SetFont(*cell->GetFont());
+      dc->SetFont(cell->GetFont());

 
 

-         if ( !cell->GetTextValue().IsNull() )
-       DrawTextRect(dc, cell->GetTextValue(), &rect2, cell->GetAlignment());
+          if ( !cell->GetTextValue().IsNull() )
+              DrawTextRect(dc, cell->GetTextValue(), &rect2, cell->GetAlignment());

     }
   }
 }
 
     }
   }
 }
 

-void wxGenericGrid::AdjustScrollbars(void)
+void wxGenericGrid::AdjustScrollbars()

 {
   int cw, ch;
   GetClientSize(&cw, &ch);
 {
   int cw, ch;
   GetClientSize(&cw, &ch);

-  
-  // To calculate the number of steps for each scrollbar,
-  // we need to see how much will fit onto the canvas
-  // at the present size. So:
-  // 1) Find the *last* row r1 such that when it's at the top of the
-  //    window, all the remaining rows are visible.
-  // 2) There should therefore be r1 - 1 steps in the scrollbar.
-  // Similarly with columns.
-
-  // IGNORE THE ABOVE, it's crap.
+

   // We find the view size by seeing how many rows/cols fit on
   // the current view.
   // BUT... this means that the scrollbar should be adjusted every time
   // We find the view size by seeing how many rows/cols fit on
   // the current view.
   // BUT... this means that the scrollbar should be adjusted every time


@@ -832,183 +1006,168 @@ void wxGenericGrid::AdjustScrollbars(void)
 
   // Since this may not be known until the end of this function, we should probably call AdjustScrollbars
   // twice.
 
   // Since this may not be known until the end of this function, we should probably call AdjustScrollbars
   // twice.

-  int vertScrollBarWidth = scrollWidth;
-  int horizScrollBarHeight = scrollWidth;
-  if (vScrollBar && !vScrollBar->IsShown())
+  int vertScrollBarWidth = m_scrollWidth;
+  int horizScrollBarHeight = m_scrollWidth;
+  if (m_vScrollBar && !m_vScrollBar->IsShown())

     vertScrollBarWidth = 0;
     vertScrollBarWidth = 0;

-  if (hScrollBar && !hScrollBar->IsShown())
+  if (m_hScrollBar && !m_hScrollBar->IsShown())

     horizScrollBarHeight = 0;
     horizScrollBarHeight = 0;

-  
+

   int noHorizSteps = 0;
   int noVertSteps = 0;
   int noHorizSteps = 0;
   int noVertSteps = 0;

-  
-  if (totalGridWidth <= cw)
-    noHorizSteps = 0;
-  else
+
+  if (m_totalGridWidth + vertScrollBarWidth > cw)

   {
   {

-    noHorizSteps = 0;

     int widthCount = 0;
     int widthCount = 0;

-/*
-    if (GetLabelSize(wxVERTICAL) > 0)
-      noHorizSteps ++;
-*/

 
     int i;
 
     int i;

-       int nx = 0;
-    for (i = scrollPosX ; i < totalCols; i++)
+    int nx = 0;
+    for (i = m_scrollPosX ; i < m_totalCols; i++)

     {
     {

-      widthCount += colWidths[i];
-         // A partial bit doesn't count, we still have to scroll to see the
-         // rest of it
-      if (widthCount + leftOfSheet + verticalLabelWidth > (cw-vertScrollBarWidth))
+      widthCount += m_colWidths[i];
+      // A partial bit doesn't count, we still have to scroll to see the
+      // rest of it
+      if (widthCount + m_leftOfSheet + m_verticalLabelWidth > (cw-vertScrollBarWidth))

         break;
         break;

-         else
-           nx ++;
-
+      else
+           nx ++;

     }
     }

-    
+

     noHorizSteps += nx;
   }
     noHorizSteps += nx;
   }

-  if (totalGridHeight <= ch)
-    noVertSteps = 0;
-  else
+  m_viewWidth = noHorizSteps;
+
+  if (m_totalGridHeight + horizScrollBarHeight > ch)

   {
   {

-    noVertSteps = 0;

     int heightCount = 0;
     int heightCount = 0;

-/*
-    if (GetLabelSize(wxHORIZONTAL) > 0)
-      noVertSteps ++;
-*/

 
     int i;
 
     int i;

-       int ny = 0;
-    for (i = scrollPosY ; i < totalRows; i++)
+    int ny = 0;
+    for (i = m_scrollPosY ; i < m_totalRows; i++)

     {
     {

-      heightCount += rowHeights[i];
-         // A partial bit doesn't count, we still have to scroll to see the
-         // rest of it
-      if (heightCount + topOfSheet + horizontalLabelHeight > (ch-horizScrollBarHeight))
+      heightCount += m_rowHeights[i];
+      // A partial bit doesn't count, we still have to scroll to see the
+      // rest of it
+      if (heightCount + m_topOfSheet + m_horizontalLabelHeight > (ch-horizScrollBarHeight))

         break;
         break;

-         else
-           ny ++;
+      else
+        ny ++;

     }
     }

-    
+

     noVertSteps += ny;
   }
     noVertSteps += ny;
   }

-  
-  if (totalGridWidth <= cw)
+
+  m_viewHeight = noVertSteps;
+
+  if (m_totalGridWidth + vertScrollBarWidth <= cw)

   {
   {

-       if ( hScrollBar )
-       hScrollBar->Show(FALSE);
+    if ( m_hScrollBar )
+        m_hScrollBar->Show(FALSE);

     SetScrollPosX(0);
   }
   else
   {
     SetScrollPosX(0);
   }
   else
   {

-       if ( hScrollBar )
-       hScrollBar->Show(TRUE);
+      if ( m_hScrollBar )
+          m_hScrollBar->Show(TRUE);

   }
 
   }
 

-  if (totalGridHeight <= ch)
+  if (m_totalGridHeight + horizScrollBarHeight <= ch)

   {
   {

-       if ( vScrollBar )
-       vScrollBar->Show(FALSE);
-    SetScrollPosY(0);
+      if ( m_vScrollBar )
+          m_vScrollBar->Show(FALSE);
+      SetScrollPosY(0);

   }
   else
   {
   }
   else
   {

-       if ( vScrollBar )
-       vScrollBar->Show(TRUE);
+      if ( m_vScrollBar )
+          m_vScrollBar->Show(TRUE);

   }
 
   }
 

-  UpdateDimensions(); // Necessary in case scrollPosX/Y changed
+  UpdateDimensions(); // Necessary in case m_scrollPosX/Y changed

 
 

-  vertScrollBarWidth = scrollWidth;
-  horizScrollBarHeight = scrollWidth;
-  if (vScrollBar && !vScrollBar->IsShown())
+  vertScrollBarWidth = m_scrollWidth;
+  horizScrollBarHeight = m_scrollWidth;
+  if (m_vScrollBar && !m_vScrollBar->IsShown())

     vertScrollBarWidth = 0;
     vertScrollBarWidth = 0;

-  if (hScrollBar && !hScrollBar->IsShown())
+  if (m_hScrollBar && !m_hScrollBar->IsShown())

     horizScrollBarHeight = 0;
 
     horizScrollBarHeight = 0;
 

-  if (hScrollBar)
+  if (m_hScrollBar && m_hScrollBar->IsShown())

   {
     int nCols = GetCols();
   {
     int nCols = GetCols();

+    m_hScrollBar->SetScrollbar(m_hScrollBar->GetThumbPosition(), wxMax(noHorizSteps, 1), (noHorizSteps == 0) ? 1 : nCols, wxMax(noHorizSteps, 1));
+

 /*
 /*

-    hScrollBar->SetPageSize(wxMax(noHorizSteps, 1));
-    hScrollBar->SetViewLength(wxMax(noHorizSteps, 1));
-    hScrollBar->SetObjectLength(nCols);
+    m_hScrollBar->SetSize(m_leftOfSheet, ch - m_scrollWidth -2,   // why -2 ? Robert.
+      cw - vertScrollBarWidth - m_leftOfSheet, m_scrollWidth);

 */
 */

-    hScrollBar->SetScrollbar(hScrollBar->GetPosition(), wxMax(noHorizSteps, 1), nCols, wxMax(noHorizSteps, 1));
+    m_hScrollBar->SetSize(m_leftOfSheet, ch - m_scrollWidth,
+      cw - vertScrollBarWidth - m_leftOfSheet, m_scrollWidth);

 
 

-    hScrollBar->SetSize(leftOfSheet, ch - scrollWidth,
-      cw - vertScrollBarWidth - leftOfSheet, scrollWidth);

   }
   }

-       
-  if (vScrollBar)
+
+  if (m_vScrollBar && m_vScrollBar->IsShown())

   {
     int nRows = GetRows();
   {
     int nRows = GetRows();

-/*
-    vScrollBar->SetPageSize(wxMax(noVertSteps, 1));
-    vScrollBar->SetViewLength(wxMax(noVertSteps, 1));
-    vScrollBar->SetObjectLength(nRows);
-*/

 
 

-    vScrollBar->SetScrollbar(vScrollBar->GetPosition(), wxMax(noVertSteps, 1), nRows, wxMax(noVertSteps, 1));
-    vScrollBar->SetSize(cw - scrollWidth, topOfSheet,
-       scrollWidth, ch - topOfSheet - horizScrollBarHeight);
+    m_vScrollBar->SetScrollbar(m_vScrollBar->GetThumbPosition(), wxMax(noVertSteps, 1), (noVertSteps == 0) ? 1 : nRows, wxMax(noVertSteps, 1));
+    m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
+       m_scrollWidth, ch - m_topOfSheet - horizScrollBarHeight);

   }
 }
 
 void wxGenericGrid::OnSize(wxSizeEvent& WXUNUSED(event) )
 {
   }
 }
 
 void wxGenericGrid::OnSize(wxSizeEvent& WXUNUSED(event) )
 {

-  if (!vScrollBar || !hScrollBar)
-         return;
+  if (!m_vScrollBar || !m_hScrollBar)
+          return;

 
   AdjustScrollbars();
 
   AdjustScrollbars();

-  
+

   int cw, ch;
   GetClientSize(&cw, &ch);
 
   int cw, ch;
   GetClientSize(&cw, &ch);
 

-  if (GetTextItem() && GetTextItem()->IsShown())
+  if (m_editCreated && m_editingPanel && GetTextItem() && GetTextItem()->IsShown())

   {
   {

-    GetTextItem()->SetSize(editControlPosition.x, editControlPosition.y,
-      cw - editControlPosition.x, editControlPosition.height);
+    m_editingPanel->SetSize(0, 0, cw, m_editControlPosition.height + m_editControlPosition.y + 2);
+    GetTextItem()->SetSize(m_editControlPosition.x, m_editControlPosition.y,
+      cw - 2*m_editControlPosition.x, m_editControlPosition.height);

   }
 }
 
 bool wxGenericGrid::CellHitTest(int x, int y, int *row, int *col)
 {
       // Find the selected cell and call OnSelectCell
   }
 }
 
 bool wxGenericGrid::CellHitTest(int x, int y, int *row, int *col)
 {
       // Find the selected cell and call OnSelectCell

-      if (x >= (leftOfSheet + verticalLabelWidth) && y >= (topOfSheet + horizontalLabelHeight) &&
-          x <= rightOfSheet && y <= bottomOfSheet)
+      if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
+          x <= m_rightOfSheet && y <= m_bottomOfSheet)

       {
          // Calculate the cell number from x and y
       {
          // Calculate the cell number from x and y

-         x -= (verticalLabelWidth + leftOfSheet);
-         y -= (topOfSheet + horizontalLabelHeight);
+         x -= (m_verticalLabelWidth + m_leftOfSheet);
+         y -= (m_topOfSheet + m_horizontalLabelHeight);

 
          int i;
 
          int i;

-         
+

          // Now we need to do a hit test for which row we're on
          int currentHeight = 0;
          // Now we need to do a hit test for which row we're on
          int currentHeight = 0;

-         for (i = scrollPosY; i < totalRows; i++)
+         for (i = m_scrollPosY; i < m_totalRows; i++)

          {
          {

-            if (y >= currentHeight && y <= (currentHeight + rowHeights[i]))
+            if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))

             {
               *row = i;
               break;
             }
             {
               *row = i;
               break;
             }

-            currentHeight += rowHeights[i];
+            currentHeight += m_rowHeights[i];

          }
          }

-         
+

          // Now we need to do a hit test for which column we're on
          int currentWidth = 0;
          // Now we need to do a hit test for which column we're on
          int currentWidth = 0;

-         for (i = scrollPosX; i < totalCols; i++)
+         for (i = m_scrollPosX; i < m_totalCols; i++)

          {
          {

-            if (x >= currentWidth && x <= (currentWidth + colWidths[i]))
+            if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))

             {
               *col = i;
               break;
             }
             {
               *col = i;
               break;
             }

-            currentWidth += colWidths[i];
+            currentWidth += m_colWidths[i];

          }
          return TRUE;
        }
          }
          return TRUE;
        }


@@ -1019,40 +1178,40 @@ bool wxGenericGrid::LabelSashHitTest(int x, int y, int *orientation, int *rowOrC
 {
   int i;
   int tolerance = 3;
 {
   int i;
   int tolerance = 3;

-  
-  if (x >= (leftOfSheet + verticalLabelWidth) && y >= topOfSheet &&
-      x <= rightOfSheet && y <= (topOfSheet + horizontalLabelHeight))
+
+  if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= m_topOfSheet &&
+      x <= m_rightOfSheet && y <= (m_topOfSheet + m_horizontalLabelHeight))

   {
     // We may be on a column label sash.
   {
     // We may be on a column label sash.

-    int currentWidth = leftOfSheet + verticalLabelWidth;
-    for (i = scrollPosX; i < totalCols; i++)
+    int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
+    for (i = m_scrollPosX; i < m_totalCols; i++)

     {
     {

-      if (x >= (currentWidth + colWidths[i] - tolerance) && x <= (currentWidth + colWidths[i] + tolerance))
+      if (x >= (currentWidth + m_colWidths[i] - tolerance) && x <= (currentWidth + m_colWidths[i] + tolerance))

       {
         *orientation = wxHORIZONTAL;
         *rowOrCol = i;
         *startPos = currentWidth;
         return TRUE;
       }
       {
         *orientation = wxHORIZONTAL;
         *rowOrCol = i;
         *startPos = currentWidth;
         return TRUE;
       }

-      currentWidth += colWidths[i];
+      currentWidth += m_colWidths[i];

     }
     return FALSE;
   }
     }
     return FALSE;
   }

-  else if (x >= leftOfSheet && y >= (topOfSheet + horizontalLabelHeight) &&
-      x <= (leftOfSheet + verticalLabelWidth) && y <= bottomOfSheet)
+  else if (x >= m_leftOfSheet && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
+      x <= (m_leftOfSheet + m_verticalLabelWidth) && y <= m_bottomOfSheet)

   {
     // We may be on a row label sash.
   {
     // We may be on a row label sash.

-    int currentHeight = topOfSheet + horizontalLabelHeight;
-    for (i = scrollPosY; i < totalRows; i++)
+    int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
+    for (i = m_scrollPosY; i < m_totalRows; i++)

     {
     {

-      if (y >= (currentHeight + rowHeights[i] - tolerance) && y <= (currentHeight + rowHeights[i] + tolerance))
+      if (y >= (currentHeight + m_rowHeights[i] - tolerance) && y <= (currentHeight + m_rowHeights[i] + tolerance))

       {
         *orientation = wxVERTICAL;
         *rowOrCol = i;
         *startPos = currentHeight;
         return TRUE;
       }
       {
         *orientation = wxVERTICAL;
         *rowOrCol = i;
         *startPos = currentHeight;
         return TRUE;
       }

-      currentHeight += rowHeights[i];
+      currentHeight += m_rowHeights[i];

     }
     return FALSE;
   }
     }
     return FALSE;
   }


@@ -1062,43 +1221,43 @@ bool wxGenericGrid::LabelSashHitTest(int x, int y, int *orientation, int *rowOrC
 bool wxGenericGrid::LabelHitTest(int x, int y, int *row, int *col)
 {
       // Find the selected label
 bool wxGenericGrid::LabelHitTest(int x, int y, int *row, int *col)
 {
       // Find the selected label

-      if (x >= leftOfSheet && y >= topOfSheet &&
-          x <= rightOfSheet && y <= bottomOfSheet)
+      if (x >= m_leftOfSheet && y >= m_topOfSheet &&
+          x <= m_rightOfSheet && y <= m_bottomOfSheet)

       {
          // Calculate the cell number from x and y
       {
          // Calculate the cell number from x and y

-         x -= leftOfSheet;
-         y -= topOfSheet;
+         x -= m_leftOfSheet;
+         y -= m_topOfSheet;

 
          int i;
 
          // Now we need to do a hit test for which row we're on
 
          int i;
 
          // Now we need to do a hit test for which row we're on

-         int currentHeight = horizontalLabelHeight;
-         for (i = scrollPosY; i < totalRows; i++)
+         int currentHeight = m_horizontalLabelHeight;
+         for (i = m_scrollPosY; i < m_totalRows; i++)

          {
          {

-            if (y >= currentHeight && y <= (currentHeight + rowHeights[i]))
+            if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))

             {
               *row = i;
               break;
             }
             {
               *row = i;
               break;
             }

-            currentHeight += rowHeights[i];
+            currentHeight += m_rowHeights[i];

          }
          }

-         if (y >= 0 && y <= horizontalLabelHeight)
+         if (y >= 0 && y <= m_horizontalLabelHeight)

          {
              *row = -1;
          }
 
          // Now we need to do a hit test for which column we're on
          {
              *row = -1;
          }
 
          // Now we need to do a hit test for which column we're on

-         int currentWidth = verticalLabelWidth;
-         for (i = scrollPosX; i < totalCols; i++)
+         int currentWidth = m_verticalLabelWidth;
+         for (i = m_scrollPosX; i < m_totalCols; i++)

          {
          {

-            if (x >= currentWidth && x <= (currentWidth + colWidths[i]))
+            if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))

             {
               *col = i;
               break;
             }
             {
               *col = i;
               break;
             }

-            currentWidth += colWidths[i];
+            currentWidth += m_colWidths[i];

          }
          }

-         if (x >= 0 && x <= verticalLabelWidth)
+         if (x >= 0 && x <= m_verticalLabelWidth)

          {
              *col = -1;
          }
          {
              *col = -1;
          }


@@ -1117,49 +1276,60 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
   {
     wxClientDC dc(this);
     dc.BeginDrawing();
   {
     wxClientDC dc(this);
     dc.BeginDrawing();

-    
+

     int row, col;
     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {
       OnSelectCellImplementation(& dc, row, col);
     int row, col;
     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {
       OnSelectCellImplementation(& dc, row, col);

-      OnCellLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+
+      //OnCellLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_LCLICK, this,
+                        row, col, (int)ev.GetX(), (int)ev.GetY(),
+                        ev.ControlDown(), ev.ShiftDown());
+      GetEventHandler()->ProcessEvent(g_evt);
+

     }
     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {
     }
     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {

-      OnLabelLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      //OnLabelLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      wxGridEvent g_evt(GetId(), wxEVT_GRID_LABEL_LCLICK, this,
+                        row, col, (int)ev.GetX(), (int)ev.GetY(),
+                        ev.ControlDown(), ev.ShiftDown());
+      GetEventHandler()->ProcessEvent(g_evt);
+

     }
     dc.EndDrawing();
   }
   else if (ev.Dragging() && ev.LeftIsDown())
   {
     }
     dc.EndDrawing();
   }
   else if (ev.Dragging() && ev.LeftIsDown())
   {

-    switch (dragStatus)
+    switch (m_dragStatus)

     {
       case wxGRID_DRAG_NONE:
       {
         int orientation;
     {
       case wxGRID_DRAG_NONE:
       {
         int orientation;

-        if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &dragRowOrCol, &dragStartPosition))
+        if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &m_dragRowOrCol, &m_dragStartPosition))

         {
           if (orientation == wxHORIZONTAL)
           {
         {
           if (orientation == wxHORIZONTAL)
           {

-            dragStatus = wxGRID_DRAG_LEFT_RIGHT;
-            SetCursor(*horizontalSashCursor);
-            dragLastPosition = (int)ev.GetX();
+            m_dragStatus = wxGRID_DRAG_LEFT_RIGHT;
+            SetCursor(m_horizontalSashCursor);
+            m_dragLastPosition = (int)ev.GetX();

           }
           else
           {
           }
           else
           {

-            dragStatus = wxGRID_DRAG_UP_DOWN;
-            SetCursor(*verticalSashCursor);
-            dragLastPosition = (int)ev.GetY();
+            m_dragStatus = wxGRID_DRAG_UP_DOWN;
+            SetCursor(m_verticalSashCursor);
+            m_dragLastPosition = (int)ev.GetY();

           }
           wxClientDC dc(this);
           dc.BeginDrawing();
           dc.SetLogicalFunction(wxINVERT);
           if (orientation == wxHORIZONTAL)
           }
           wxClientDC dc(this);
           dc.BeginDrawing();
           dc.SetLogicalFunction(wxINVERT);
           if (orientation == wxHORIZONTAL)

-            dc.DrawLine((int)ev.GetX(), topOfSheet, (int)ev.GetX(), bottomOfSheet);
+            dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);

           else
           else

-            dc.DrawLine(leftOfSheet, (int)ev.GetY(), rightOfSheet, (int)ev.GetY());
+            dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());

           dc.EndDrawing();
           dc.EndDrawing();

-          
+

           CaptureMouse();
         }
         break;
           CaptureMouse();
         }
         break;


@@ -1169,13 +1339,13 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);

-        dc.DrawLine(dragLastPosition, topOfSheet, dragLastPosition, bottomOfSheet);
+        dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);

 
 

-        dc.DrawLine((int)ev.GetX(), topOfSheet, (int)ev.GetX(), bottomOfSheet);
+        dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);

         dc.EndDrawing();
 
         dc.EndDrawing();
 

-        dragLastPosition = (int)ev.GetX();
-        SetCursor(*horizontalSashCursor);
+        m_dragLastPosition = (int)ev.GetX();
+        SetCursor(m_horizontalSashCursor);

         break;
       }
       case wxGRID_DRAG_UP_DOWN:
         break;
       }
       case wxGRID_DRAG_UP_DOWN:


@@ -1183,13 +1353,13 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);

-        dc.DrawLine(leftOfSheet, dragLastPosition, rightOfSheet, dragLastPosition);
+        dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);

 
 

-        dc.DrawLine(leftOfSheet, (int)ev.GetY(), rightOfSheet, (int)ev.GetY());
+        dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());

         dc.EndDrawing();
 
         dc.EndDrawing();
 

-        dragLastPosition = (int)ev.GetY();
-        SetCursor(*verticalSashCursor);
+        m_dragLastPosition = (int)ev.GetY();
+        SetCursor(m_verticalSashCursor);

         break;
       }
     }
         break;
       }
     }


@@ -1200,30 +1370,30 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
     if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &rowOrCol, &startPos))
     {
       if (orientation == wxHORIZONTAL)
     if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &rowOrCol, &startPos))
     {
       if (orientation == wxHORIZONTAL)

-        SetCursor(*horizontalSashCursor);
+        SetCursor(m_horizontalSashCursor);

        else
        else

-        SetCursor(*verticalSashCursor);
+        SetCursor(m_verticalSashCursor);

     }
     else
       SetCursor(*wxSTANDARD_CURSOR);
   }
   else if (ev.LeftUp())
   {
     }
     else
       SetCursor(*wxSTANDARD_CURSOR);
   }
   else if (ev.LeftUp())
   {

-    switch (dragStatus)
+    switch (m_dragStatus)

     {
       case wxGRID_DRAG_LEFT_RIGHT:
       {
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);
     {
       case wxGRID_DRAG_LEFT_RIGHT:
       {
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);

-        dc.DrawLine(dragLastPosition, topOfSheet, dragLastPosition, bottomOfSheet);
+        dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);

         dc.SetLogicalFunction(wxCOPY);
         dc.EndDrawing();
 
         ReleaseMouse();
         dc.SetLogicalFunction(wxCOPY);
         dc.EndDrawing();
 
         ReleaseMouse();

-        if (ev.GetX() > dragStartPosition)
+        if (ev.GetX() > m_dragStartPosition)

         {
         {

-          colWidths[dragRowOrCol] = (short)(ev.GetX() - dragStartPosition);
+          m_colWidths[m_dragRowOrCol] = (short)(ev.GetX() - m_dragStartPosition);

           UpdateDimensions();
           AdjustScrollbars();
           Refresh();
           UpdateDimensions();
           AdjustScrollbars();
           Refresh();


@@ -1231,7 +1401,7 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
         SetCursor(*wxSTANDARD_CURSOR);
         int cw, ch;
         GetClientSize(&cw, &ch);
         SetCursor(*wxSTANDARD_CURSOR);
         int cw, ch;
         GetClientSize(&cw, &ch);

-               wxSizeEvent evt;
+                wxSizeEvent evt;

         OnSize(evt);
         break;
       }
         OnSize(evt);
         break;
       }


@@ -1240,14 +1410,14 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);
         wxClientDC dc(this);
         dc.BeginDrawing();
         dc.SetLogicalFunction(wxINVERT);

-        dc.DrawLine(leftOfSheet, dragLastPosition, rightOfSheet, dragLastPosition);
+        dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);

         dc.SetLogicalFunction(wxCOPY);
         dc.EndDrawing();
 
         ReleaseMouse();
         dc.SetLogicalFunction(wxCOPY);
         dc.EndDrawing();
 
         ReleaseMouse();

-        if (ev.GetY() > dragStartPosition)
+        if (ev.GetY() > m_dragStartPosition)

         {
         {

-          rowHeights[dragRowOrCol] = (short)(ev.GetY() - dragStartPosition);
+          m_rowHeights[m_dragRowOrCol] = (short)(ev.GetY() - m_dragStartPosition);

           UpdateDimensions();
           AdjustScrollbars();
           Refresh();
           UpdateDimensions();
           AdjustScrollbars();
           Refresh();


@@ -1256,74 +1426,154 @@ void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
         break;
       }
     }
         break;
       }
     }

-    dragStatus = wxGRID_DRAG_NONE;
+    m_dragStatus = wxGRID_DRAG_NONE;

   }
   else if (ev.RightDown())
   {
     int row, col;
     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {
   }
   else if (ev.RightDown())
   {
     int row, col;
     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {

-      OnCellRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      //OnCellRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_RCLICK, this,
+                        row, col, (int)ev.GetX(), (int)ev.GetY(),
+                        ev.ControlDown(), ev.ShiftDown());
+      GetEventHandler()->ProcessEvent(g_evt);
+

     }
     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {
     }
     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
     {

-      OnLabelRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      //OnLabelRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
+      wxGridEvent g_evt(GetId(), wxEVT_GRID_LABEL_RCLICK, this,
+                        row, col, (int)ev.GetX(), (int)ev.GetY(),
+                        ev.ControlDown(), ev.ShiftDown());
+      GetEventHandler()->ProcessEvent(g_evt);

     }
   }
 }
 
 void wxGenericGrid::OnSelectCellImplementation(wxDC *dc, int row, int col)
 {
     }
   }
 }
 
 void wxGenericGrid::OnSelectCellImplementation(wxDC *dc, int row, int col)
 {

-  wCursorColumn = col;
-  wCursorRow = row;
-  
-  OnChangeSelectionLabel();
+  m_wCursorColumn = col;
+  m_wCursorRow = row;
+
+  //OnChangeSelectionLabel();
+  wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_SEL_LABEL, this);
+  GetEventHandler()->ProcessEvent(g_evt);

 
   SetGridClippingRegion(dc);
 
   // Remove the highlight from the old cell
 
   SetGridClippingRegion(dc);
 
   // Remove the highlight from the old cell

-  if (currentRectVisible)
-     HighlightCell(dc);
+  if ( m_currentRectVisible && (wxIPE_HIGHLIGHT || !(m_editable && m_editInPlace)))
+    {
+      HighlightCell(dc, FALSE);
+    }
+

 
   // Highlight the new cell and copy its content to the edit control
 
   // Highlight the new cell and copy its content to the edit control

-  SetCurrentRect(wCursorRow, wCursorColumn);
-  wxGridCell *cell = GetCell(wCursorRow, wCursorColumn);
+  SetCurrentRect(m_wCursorRow, m_wCursorColumn);
+  wxGridCell *cell = GetCell(m_wCursorRow, m_wCursorColumn);

   if (cell)
   {
   if (cell)
   {

-       if ( cell->GetTextValue().IsNull() )
-               textItem->SetValue("");
-       else
-       textItem->SetValue(cell->GetTextValue());
+        if ( cell->GetTextValue().IsNull() )
+                m_textItem->SetValue("");
+        else
+            m_textItem->SetValue(cell->GetTextValue());

   }
 
   SetGridClippingRegion(dc);
 
   }
 
   SetGridClippingRegion(dc);
 

-  // Why isn't this needed for Windows??
-  // Probably because of the SetValue??
-#ifndef __WINDOWS__
-  HighlightCell(dc);
+
+  if ( m_editable && m_editInPlace )
+    {
+      int x, y, width, height;
+      if ( m_currentRect.x <= 0 )
+        {
+          x = 0;
+          width = m_currentRect.width + wxIPE_ADJUST;
+        }
+      else
+        {
+          x = m_currentRect.x - wxIPE_ADJUST;
+          width = m_currentRect.width + wxIPE_ADJUST*2;
+        }
+
+      if ( m_currentRect.y <= 0 )
+        {
+          y = 0;
+          height = m_currentRect.height + wxIPE_ADJUST;
+        }
+      else
+        {
+          y = m_currentRect.y - wxIPE_ADJUST;
+          height = m_currentRect.height + wxIPE_ADJUST*2;
+        }
+
+      m_inPlaceTextItem->SetSize( x, y, width, height );
+
+      if ( cell ) {
+          m_inPlaceTextItem->SetFont( cell->GetFont() );
+          m_inPlaceTextItem->SetBackgroundColour(cell->GetBackgroundColour());
+          m_inPlaceTextItem->SetForegroundColour(cell->GetTextColour());
+
+          if ( cell->GetTextValue().IsNull() ) {
+              m_inPlaceTextItem->SetValue( "" );
+          }
+          else {
+              m_inPlaceTextItem->SetValue( cell->GetTextValue() );
+          }
+      }
+
+      m_inPlaceTextItem->Show(TRUE);
+      m_inPlaceTextItem->SetFocus();
+#if defined(__VISAGECPP__)
+      {
+          int                       highlight = wxIPE_HIGHLIGHT;
+          if (highlight != 0)
+              HighlightCell(dc, TRUE);
+      }
+#else
+      if (wxIPE_HIGHLIGHT != 0)
+          HighlightCell(dc, TRUE);

 #endif
 #endif

+    }
+  else
+    {
+      // 1) Why isn't this needed for Windows??
+      // Probably because of the SetValue?? JS.
+      // 2) Arrrrrgh. This isn't needed anywhere,
+      // of course. One hour of debugging... RR.
+      //
+      // 3) It *is* needed for Motif - michael
+      //
+#if defined(__WXMOTIF__)
+      if ((wxIPE_HIGHLIGHT || !(m_editable && m_editInPlace)))
+          HighlightCell(dc, TRUE);
+#endif
+    }
+

   dc->DestroyClippingRegion();
   dc->DestroyClippingRegion();

-  
+

   OnSelectCell(row, col);
   OnSelectCell(row, col);

+  wxGridEvent g_evt2(GetId(), wxEVT_GRID_SELECT_CELL, this, row, col);
+  GetEventHandler()->ProcessEvent(g_evt2);

 }
 
 }
 

-wxGridCell *wxGenericGrid::OnCreateCell(void)
+wxGridCell *wxGenericGrid::OnCreateCell()

 {
   return new wxGridCell(this);
 }
 
 {
   return new wxGridCell(this);
 }
 

-void wxGenericGrid::OnChangeLabels(void)
+void wxGenericGrid::OnChangeLabels()

 {
   char buf[100];
   int i;
 {
   char buf[100];
   int i;

-  for (i = 0; i < totalRows; i++)
+  for (i = 0; i < m_totalRows; i++)

   {
     sprintf(buf, "%d", i+1);
     SetLabelValue(wxVERTICAL, buf, i);
   }
   // A...Z,AA...ZZ,AAA...ZZZ, etc.
   {
     sprintf(buf, "%d", i+1);
     SetLabelValue(wxVERTICAL, buf, i);
   }
   // A...Z,AA...ZZ,AAA...ZZZ, etc.

-  for (i = 0; i < totalCols; i++)
+  for (i = 0; i < m_totalCols; i++)

   {
     int j;
     int noTimes = (i/26 + 1);
   {
     int j;
     int noTimes = (i/26 + 1);


@@ -1339,14 +1589,14 @@ void wxGenericGrid::OnChangeLabels(void)
   }
 }
 
   }
 }
 

-void wxGenericGrid::OnChangeSelectionLabel(void)
+void wxGenericGrid::OnChangeSelectionLabel()

 {
   if (!GetEditable())
     return;
 {
   if (!GetEditable())
     return;

-    
+

   wxString rowLabel(GetLabelValue(wxVERTICAL, GetCursorRow()));
   wxString colLabel(GetLabelValue(wxHORIZONTAL, GetCursorColumn()));
   wxString rowLabel(GetLabelValue(wxVERTICAL, GetCursorRow()));
   wxString colLabel(GetLabelValue(wxHORIZONTAL, GetCursorColumn()));

-  
+

   wxString newLabel = colLabel + rowLabel;
   if ((newLabel.Length() > 0) && (newLabel.Length() <= 8) && GetTextItem())
   {
   wxString newLabel = colLabel + rowLabel;
   if ((newLabel.Length() > 0) && (newLabel.Length() <= 8) && GetTextItem())
   {


@@ -1354,33 +1604,46 @@ void wxGenericGrid::OnChangeSelectionLabel(void)
   }
 }
 
   }
 }
 

-void wxGenericGrid::HighlightCell(wxDC *dc)
+void wxGenericGrid::HighlightCell(wxDC *dc, bool doHighlight)

 {
 {

-  dc->SetLogicalFunction(wxINVERT);
+  wxPen savePen = dc->GetPen();
+  if (doHighlight)
+      dc->SetPen(m_highlightPen);
+  else
+      dc->SetPen(*wxThePenList->FindOrCreatePen(m_cellBackgroundColour, 1, wxSOLID));
+

   // Top
   // Top

-  dc->DrawLine(CurrentRect.x + 1, CurrentRect.y + 1, CurrentRect.x + CurrentRect.width - 1, CurrentRect.y + 1);
+  dc->DrawLine( m_currentRect.x + 1,
+                m_currentRect.y + 1,
+                m_currentRect.x + m_currentRect.width - 1,
+                m_currentRect.y + 1);

   // Right
   // Right

-  dc->DrawLine(CurrentRect.x + CurrentRect.width - 1, CurrentRect.y + 1,
-      CurrentRect.x + CurrentRect.width - 1, CurrentRect.y +CurrentRect.height - 1);
+  dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
+                m_currentRect.y + 1,
+                m_currentRect.x + m_currentRect.width - 1,
+                m_currentRect.y + m_currentRect.height - 1 );

   // Bottom
   // Bottom

-  dc->DrawLine(CurrentRect.x + CurrentRect.width - 1, CurrentRect.y + CurrentRect.height - 1,
-         CurrentRect.x + 1, CurrentRect.y + CurrentRect.height - 1);
+  dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
+                m_currentRect.y + m_currentRect.height - 1,
+                m_currentRect.x + 1,
+                m_currentRect.y + m_currentRect.height - 1);

   // Left
   // Left

-  dc->DrawLine(CurrentRect.x + 1, CurrentRect.y + CurrentRect.height - 1, CurrentRect.x + 1, CurrentRect.y + 1);
+  dc->DrawLine( m_currentRect.x + 1,
+                m_currentRect.y + m_currentRect.height - 1,
+                m_currentRect.x + 1,
+                m_currentRect.y + 1);

 
 

-  dc->SetLogicalFunction(wxCOPY);
+  dc->SetPen(savePen);

 }
 
 }
 

-void wxGenericGrid::DrawCellText(void)
+void wxGenericGrid::DrawCellText()

 {
 {

-  if (!currentRectVisible)
+  if (!m_currentRectVisible)

     return;
     return;

-  
+

   wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
   if (!cell)
     return;
   wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
   if (!cell)
     return;

-    
-  static char szEdit[300];

 
   wxClientDC dc(this);
   dc.BeginDrawing();
 
   wxClientDC dc(this);
   dc.BeginDrawing();


@@ -1388,22 +1651,23 @@ void wxGenericGrid::DrawCellText(void)
   SetGridClippingRegion(& dc);
 
   dc.SetBackgroundMode(wxTRANSPARENT);
   SetGridClippingRegion(& dc);
 
   dc.SetBackgroundMode(wxTRANSPARENT);

-  dc.SetBrush(*cell->GetBackgroundBrush());
+  dc.SetBrush(cell->GetBackgroundBrush());
+
+  wxString editValue = m_textItem->GetValue();

 
 

-  strcpy(szEdit, textItem->GetValue());
-  
-  wxRectangle rect;
-  rect = CurrentRect;
+  wxRect rect;
+  rect = m_currentRect;

   rect.x += 3;
   rect.y += 2;
   rect.width -= 5;
   rect.height -= 4;
 
   rect.x += 3;
   rect.y += 2;
   rect.width -= 5;
   rect.height -= 4;
 

+  // FIXME: what's this string of spaces supposed to represent?

   DrawTextRect(& dc, "                                    ", &rect, wxLEFT);
   DrawTextRect(& dc, "                                    ", &rect, wxLEFT);

-  DrawTextRect(& dc, szEdit, &rect, cell->GetAlignment());
-  
+  DrawTextRect(& dc, editValue, &rect, cell->GetAlignment());
+

   dc.DestroyClippingRegion();
   dc.DestroyClippingRegion();

-  
+

   dc.SetBackgroundMode(wxSOLID);
 
   dc.EndDrawing();
   dc.SetBackgroundMode(wxSOLID);
 
   dc.EndDrawing();


@@ -1411,37 +1675,37 @@ void wxGenericGrid::DrawCellText(void)
 
 void wxGenericGrid::SetCurrentRect(int Row, int Column, int canvasW, int canvasH)
 {
 
 void wxGenericGrid::SetCurrentRect(int Row, int Column, int canvasW, int canvasH)
 {

-  int currentWidth = leftOfSheet + verticalLabelWidth;
+  int currentWidth = m_leftOfSheet + m_verticalLabelWidth;

   int i;
   int i;

-  for (i = scrollPosX; i < Column; i++)
-    currentWidth += colWidths[i];
+  for (i = m_scrollPosX; i < Column; i++)
+    currentWidth += m_colWidths[i];
+
+  int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
+  for (i = m_scrollPosY; i < Row; i++)
+    currentHeight += m_rowHeights[i];

 
 

-  int currentHeight = topOfSheet + horizontalLabelHeight;
-  for (i = scrollPosY; i < Row; i++)
-    currentHeight += rowHeights[i];
+  m_currentRect.x = currentWidth;
+  m_currentRect.y = currentHeight;
+  m_currentRect.width = m_colWidths ? (m_colWidths[Column]) : 0;
+  m_currentRect.height = m_rowHeights ? (m_rowHeights[Row]) : 0;

 
 

-  CurrentRect.x = currentWidth;
-  CurrentRect.y = currentHeight;
-  CurrentRect.width = colWidths ? (colWidths[Column]) : 0;
-  CurrentRect.height = rowHeights ? (rowHeights[Row]) : 0;
-  
-  if (Row < scrollPosY || Column < scrollPosX)
-    currentRectVisible = FALSE;
-  else if ((canvasW != -1 && canvasH != -1) && (CurrentRect.x > canvasW || CurrentRect.y > canvasH))
-    currentRectVisible = FALSE;
-  else currentRectVisible = TRUE;
+  if (Row < m_scrollPosY || Column < m_scrollPosX)
+    m_currentRectVisible = FALSE;
+  else if ((canvasW != -1 && canvasH != -1) && (m_currentRect.x > canvasW || m_currentRect.y > canvasH))
+    m_currentRectVisible = FALSE;
+  else m_currentRectVisible = TRUE;

 }
 
 }
 

-static bool wxRectIntersection(wxRectangle *rect1, wxRectangle *rect2, wxRectangle *rect3)
+static bool wxRectIntersection(wxRect *rect1, wxRect *rect2, wxRect *rect3)

 {
   int x2_1 = rect1->x + rect1->width;
   int y2_1 = rect1->y + rect1->height;
 
   int x2_2 = rect2->x + rect2->width;
   int y2_2 = rect2->y + rect2->height;
 {
   int x2_1 = rect1->x + rect1->width;
   int y2_1 = rect1->y + rect1->height;
 
   int x2_2 = rect2->x + rect2->width;
   int y2_2 = rect2->y + rect2->height;

-  
+

   int x2_3, y2_3;
   int x2_3, y2_3;

-  
+

   // Check for intersection
   if ((rect1->x > x2_2) || (rect2->x > x2_1) ||
       (rect1->y > y2_2) || (rect2->y > y2_1))
   // Check for intersection
   if ((rect1->x > x2_2) || (rect2->x > x2_1) ||
       (rect1->y > y2_2) || (rect2->y > y2_1))


@@ -1459,7 +1723,7 @@ static bool wxRectIntersection(wxRectangle *rect1, wxRectangle *rect2, wxRectang
     rect3->y = rect1->y;
   else
     rect3->y = rect2->y;
     rect3->y = rect1->y;
   else
     rect3->y = rect2->y;

-  
+

   if (x2_1 > x2_2)
     x2_3 = x2_2;
   else
   if (x2_1 > x2_2)
     x2_3 = x2_2;
   else


@@ -1468,31 +1732,31 @@ static bool wxRectIntersection(wxRectangle *rect1, wxRectangle *rect2, wxRectang
     y2_3 = y2_2;
   else
     y2_3 = y2_1;
     y2_3 = y2_2;
   else
     y2_3 = y2_1;

-    
+

   rect3->width = (int)(x2_3 - rect3->x);
   rect3->height = (int)(y2_3 - rect3->y);
   return TRUE;
 }
 
   rect3->width = (int)(x2_3 - rect3->x);
   rect3->height = (int)(y2_3 - rect3->y);
   return TRUE;
 }
 

-void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRectangle *rect, int flag)
+void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRect *rect, int flag)

 {
   dc->BeginDrawing();
 {
   dc->BeginDrawing();

-  
+

   // Ultimately, this functionality should be built into wxWindows,
   // and optimized for each platform. E.g. on Windows, use DrawText
   // passing a clipping rectangle, so that the wxWindows clipping region
   // does not have to be used to implement this.
   // Ultimately, this functionality should be built into wxWindows,
   // and optimized for each platform. E.g. on Windows, use DrawText
   // passing a clipping rectangle, so that the wxWindows clipping region
   // does not have to be used to implement this.

-  
+

   // If we're already clipping, we need to find the intersection
   // between current clipping area and text clipping area.
   // If we're already clipping, we need to find the intersection
   // between current clipping area and text clipping area.

-  
-  wxRectangle clipRect;
-  wxRectangle clipRect2;
+
+  wxRect clipRect;
+  wxRect clipRect2;

   long clipX, clipY, clipW, clipH;
   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
   long clipX, clipY, clipW, clipH;
   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
   clipRect.width = (int)clipW; clipRect.height = (int)clipH;

-  
+

   bool alreadyClipping = TRUE;
 
   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
   bool alreadyClipping = TRUE;
 
   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)


@@ -1510,38 +1774,38 @@ void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRectangle *re
 
   if (alreadyClipping)
     dc->DestroyClippingRegion();
 
   if (alreadyClipping)
     dc->DestroyClippingRegion();

-  
+

   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
   long textWidth, textHeight;
   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
   long textWidth, textHeight;

-  
+

   dc->GetTextExtent(text, &textWidth, &textHeight);
   dc->GetTextExtent(text, &textWidth, &textHeight);

-  
+

   // Do alignment
   float x,y;
   switch (flag)
   {
     case wxRIGHT:
     {
   // Do alignment
   float x,y;
   switch (flag)
   {
     case wxRIGHT:
     {

-      x = (rect->x + rect->width - textWidth - 1.0);
-      y = (rect->y + (rect->height - textHeight)/2.0);
+      x = (rect->x + rect->width - textWidth - (float)1.0);
+      y = (rect->y + (rect->height - textHeight)/(float)2.0);

       break;
     }
     case wxCENTRE:
     {
       break;
     }
     case wxCENTRE:
     {

-      x = (rect->x + (rect->width - textWidth)/2.0);
-      y = (rect->y + (rect->height - textHeight)/2.0);
+      x = (rect->x + (rect->width - textWidth)/(float)2.0);
+      y = (rect->y + (rect->height - textHeight)/(float)2.0);

       break;
     }
     case wxLEFT:
     default:
     {
       break;
     }
     case wxLEFT:
     default:
     {

-      x = (rect->x + 1.0);
-      y = (rect->y + (rect->height - textHeight)/2.0);
+      x = (rect->x + (float)1.0);
+      y = (rect->y + (rect->height - textHeight)/(float)2.0);

       break;
     }
   }
   dc->DrawText(text, (long)x, (long)y );
       break;
     }
   }
   dc->DrawText(text, (long)x, (long)y );

-  
+

   dc->DestroyClippingRegion();
 
   // Restore old clipping
   dc->DestroyClippingRegion();
 
   // Restore old clipping


@@ -1551,25 +1815,25 @@ void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRectangle *re
   dc->EndDrawing();
 }
 
   dc->EndDrawing();
 }
 

-void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRectangle *rect, int flag)
+void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRect *rect, int flag)

 {
   dc->BeginDrawing();
 {
   dc->BeginDrawing();

-  
+

   // Ultimately, this functionality should be built into wxWindows,
   // and optimized for each platform. E.g. on Windows, use DrawText
   // passing a clipping rectangle, so that the wxWindows clipping region
   // does not have to be used to implement this.
   // Ultimately, this functionality should be built into wxWindows,
   // and optimized for each platform. E.g. on Windows, use DrawText
   // passing a clipping rectangle, so that the wxWindows clipping region
   // does not have to be used to implement this.

-  
+

   // If we're already clipping, we need to find the intersection
   // between current clipping area and text clipping area.
   // If we're already clipping, we need to find the intersection
   // between current clipping area and text clipping area.

-  
-  wxRectangle clipRect;
-  wxRectangle clipRect2;
+
+  wxRect clipRect;
+  wxRect clipRect2;

   long clipX, clipY, clipW, clipH;
   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
   long clipX, clipY, clipW, clipH;
   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
   clipRect.width = (int)clipW; clipRect.height = (int)clipH;

-  
+

   bool alreadyClipping = TRUE;
 
   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
   bool alreadyClipping = TRUE;
 
   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)


@@ -1587,13 +1851,13 @@ void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRectangle *rect
 
   if (alreadyClipping)
     dc->DestroyClippingRegion();
 
   if (alreadyClipping)
     dc->DestroyClippingRegion();

-  
+

   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
   float bitmapWidth, bitmapHeight;
   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
   float bitmapWidth, bitmapHeight;

-  
+

   bitmapWidth = bitmap->GetWidth();
   bitmapHeight = bitmap->GetHeight();
   bitmapWidth = bitmap->GetWidth();
   bitmapHeight = bitmap->GetHeight();

-  
+

   // Do alignment
   long x,y;
   switch (flag)
   // Do alignment
   long x,y;
   switch (flag)


@@ -1620,10 +1884,10 @@ void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRectangle *rect
   }
   wxMemoryDC dcTemp;
   dcTemp.SelectObject(*bitmap);
   }
   wxMemoryDC dcTemp;
   dcTemp.SelectObject(*bitmap);

-  
+

   dc->Blit( (long)x, (long)y, (long)bitmapWidth, (long)bitmapHeight, &dcTemp, 0, 0);
   dcTemp.SelectObject(wxNullBitmap);
   dc->Blit( (long)x, (long)y, (long)bitmapWidth, (long)bitmapHeight, &dcTemp, 0, 0);
   dcTemp.SelectObject(wxNullBitmap);

-  
+

   dc->DestroyClippingRegion();
 
   // Restore old clipping
   dc->DestroyClippingRegion();
 
   // Restore old clipping


@@ -1664,39 +1928,39 @@ void wxGenericGrid::RefreshCell(int row, int col, bool setText)
     // Don't refresh within a pair of batch brackets
     if (GetBatchCount() > 0)
         return;
     // Don't refresh within a pair of batch brackets
     if (GetBatchCount() > 0)
         return;

-      
+

     int cw, ch;
     GetClientSize(&cw, &ch);
 
     SetCurrentRect(row, col, cw, ch);
     int cw, ch;
     GetClientSize(&cw, &ch);
 
     SetCurrentRect(row, col, cw, ch);

-    if (currentRectVisible)
+    if (m_currentRectVisible)

     {
       wxGridCell *cell = GetCell(row, col);
 
       bool currentPos = FALSE;
     {
       wxGridCell *cell = GetCell(row, col);
 
       bool currentPos = FALSE;

-      if (row == wCursorRow && col == wCursorColumn && GetTextItem() && GetTextItem()->IsShown() && setText)
+      if (row == m_wCursorRow && col == m_wCursorColumn && GetTextItem() && GetTextItem()->IsShown() && setText)

       {
         GetTextItem()->SetValue(cell->GetTextValue());
         currentPos = TRUE;
       }
       // Gets refreshed anyway in MSW
       {
         GetTextItem()->SetValue(cell->GetTextValue());
         currentPos = TRUE;
       }
       // Gets refreshed anyway in MSW

-#ifdef __WINDOWS__
+#ifdef __WXMSW__

       if (!currentPos)
 #endif
       {
         wxClientDC dc(this);
         dc.BeginDrawing();
       if (!currentPos)
 #endif
       {
         wxClientDC dc(this);
         dc.BeginDrawing();

-        DrawCellBackground(& dc, &CurrentRect, row, col);
-        DrawCellValue(& dc, &CurrentRect, row, col);
+        DrawCellBackground(& dc, &m_currentRect, row, col);
+        DrawCellValue(& dc, &m_currentRect, row, col);

         dc.EndDrawing();
       }
     }
 }
 
         dc.EndDrawing();
       }
     }
 }
 

-wxString& wxGenericGrid::GetCellValue(int row, int col)
+wxString& wxGenericGrid::GetCellValue(int row, int col) const

 {
   static wxString emptyString("");
 {
   static wxString emptyString("");

- 
+

   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetTextValue();
   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetTextValue();


@@ -1706,28 +1970,28 @@ wxString& wxGenericGrid::GetCellValue(int row, int col)
 
 void wxGenericGrid::SetColumnWidth(int col, int width)
 {
 
 void wxGenericGrid::SetColumnWidth(int col, int width)
 {

-  if (col <= totalCols)
-    colWidths[col] = width;
+  if (col <= m_totalCols)
+    m_colWidths[col] = width;

 }
 
 }
 

-int wxGenericGrid::GetColumnWidth(int col)
+int wxGenericGrid::GetColumnWidth(int col) const

 {
 {

-  if (col <= totalCols)
-    return colWidths[col];
+  if (col <= m_totalCols)
+    return m_colWidths[col];

   else
     return 0;
 }
 
 void wxGenericGrid::SetRowHeight(int row, int height)
 {
   else
     return 0;
 }
 
 void wxGenericGrid::SetRowHeight(int row, int height)
 {

-  if (row <= totalRows)
-    rowHeights[row] = height;
+  if (row <= m_totalRows)
+    m_rowHeights[row] = height;

 }
 
 }
 

-int wxGenericGrid::GetRowHeight(int row)
+int wxGenericGrid::GetRowHeight(int row) const

 {
 {

-  if (row <= totalRows)
-    return rowHeights[row];
+  if (row <= m_totalRows)
+    return m_rowHeights[row];

   else
     return 0;
 }
   else
     return 0;
 }


@@ -1735,36 +1999,36 @@ int wxGenericGrid::GetRowHeight(int row)
 void wxGenericGrid::SetLabelSize(int orientation, int sz)
 {
   if (orientation == wxHORIZONTAL)
 void wxGenericGrid::SetLabelSize(int orientation, int sz)
 {
   if (orientation == wxHORIZONTAL)

-    horizontalLabelHeight = sz;
+    m_horizontalLabelHeight = sz;

   else
   else

-    verticalLabelWidth = sz;
+    m_verticalLabelWidth = sz;

   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());
 }
 
   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());
 }
 

-int wxGenericGrid::GetLabelSize(int orientation)
+int wxGenericGrid::GetLabelSize(int orientation) const

 {
   if (orientation == wxHORIZONTAL)
 {
   if (orientation == wxHORIZONTAL)

-    return horizontalLabelHeight;
+    return m_horizontalLabelHeight;

   else
   else

-    return verticalLabelWidth;
+    return m_verticalLabelWidth;

 }
 
 }
 

-wxGridCell *wxGenericGrid::GetLabelCell(int orientation, int pos)
+wxGridCell *wxGenericGrid::GetLabelCell(int orientation, int pos) const

 {
   if (orientation == wxHORIZONTAL)
   {
 {
   if (orientation == wxHORIZONTAL)
   {

-    if (colLabelCells && pos < totalCols)
-      return colLabelCells[pos];
+    if (m_colLabelCells && pos < m_totalCols)
+      return m_colLabelCells[pos];

     else
     else

-      return NULL;
+      return (wxGridCell *) NULL;

   }
   else
   {
   }
   else
   {

-    if (rowLabelCells && pos < totalRows)
-      return rowLabelCells[pos];
+    if (m_rowLabelCells && pos < m_totalRows)
+      return m_rowLabelCells[pos];

     else
     else

-      return NULL;
+      return (wxGridCell *) NULL;

   }
 }
 
   }
 }
 


@@ -1775,7 +2039,7 @@ void wxGenericGrid::SetLabelValue(int orientation, const wxString& val, int pos)
     cell->SetTextValue(val);
 }
 
     cell->SetTextValue(val);
 }
 

-wxString& wxGenericGrid::GetLabelValue(int orientation, int pos)
+wxString& wxGenericGrid::GetLabelValue(int orientation, int pos) const

 {
  static wxString emptyString = "";
   wxGridCell *cell = GetLabelCell(orientation, pos);
 {
  static wxString emptyString = "";
   wxGridCell *cell = GetLabelCell(orientation, pos);


@@ -1788,64 +2052,69 @@ wxString& wxGenericGrid::GetLabelValue(int orientation, int pos)
 void wxGenericGrid::SetLabelAlignment(int orientation, int align)
 {
   if (orientation == wxHORIZONTAL)
 void wxGenericGrid::SetLabelAlignment(int orientation, int align)
 {
   if (orientation == wxHORIZONTAL)

-    horizontalLabelAlignment = align;
+    m_horizontalLabelAlignment = align;

   else
   else

-    verticalLabelAlignment = align;
+    m_verticalLabelAlignment = align;

   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());
 }
 
   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());
 }
 

-int wxGenericGrid::GetLabelAlignment(int orientation)
+int wxGenericGrid::GetLabelAlignment(int orientation) const

 {
   if (orientation == wxHORIZONTAL)
 {
   if (orientation == wxHORIZONTAL)

-    return horizontalLabelAlignment;
+    return m_horizontalLabelAlignment;

   else
   else

-    return verticalLabelAlignment;
+    return m_verticalLabelAlignment;

 }
 
 void wxGenericGrid::SetLabelTextColour(const wxColour& colour)
 {
 }
 
 void wxGenericGrid::SetLabelTextColour(const wxColour& colour)
 {

-  labelTextColour = colour;
+  m_labelTextColour = colour;

 
 }
 
 void wxGenericGrid::SetLabelBackgroundColour(const wxColour& colour)
 {
 
 }
 
 void wxGenericGrid::SetLabelBackgroundColour(const wxColour& colour)
 {

-  labelBackgroundColour = colour;
-  labelBackgroundBrush = wxTheBrushList->FindOrCreateBrush(labelBackgroundColour, wxSOLID);
+  m_labelBackgroundColour = colour;
+  m_labelBackgroundBrush = * wxTheBrushList->FindOrCreateBrush(m_labelBackgroundColour, wxSOLID);

 }
 
 void wxGenericGrid::SetEditable(bool edit)
 {
 }
 
 void wxGenericGrid::SetEditable(bool edit)
 {

-  editable = edit;
+  m_editable = edit;

   if (edit)
   {
     int controlW, controlH;
   if (edit)
   {
     int controlW, controlH;

-    textItem->GetSize(&controlW, &controlH);
-    editControlPosition.height = controlH;
-  
-    topOfSheet = editControlPosition.x + controlH + 2;
-    if (textItem)
+    m_textItem->GetSize(&controlW, &controlH);
+    m_editControlPosition.height = controlH;
+
+    m_topOfSheet = m_editControlPosition.x + controlH + 2;
+    if (m_textItem)

     {
     {

-      textItem->Show(TRUE);
-      // Bug fix
-#if defined(__WINDOWS__) && (wxMINOR_VERSION == 6 && wxRELEASE_NUMBER < 6)
-      ::ShowWindow(textItem->GetLabelHWND(), TRUE);
-#endif
-      textItem->SetFocus();
+      m_editingPanel->Show(TRUE);
+      m_textItem->Show(TRUE);
+      m_textItem->SetFocus();

     }
     }

+
+    if (m_inPlaceTextItem)
+      {
+        m_inPlaceTextItem->Show(TRUE);
+        m_inPlaceTextItem->SetFocus();
+      }

   }
   else
   {
   }
   else
   {

-    topOfSheet = 0;
-    if (textItem)
+    m_topOfSheet = 0;
+    if (m_textItem)

     {
     {

-      textItem->Show(FALSE);
-      // Bug fix
-#if defined(__WINDOWS__) && (wxMINOR_VERSION == 6 && wxRELEASE_NUMBER < 6)
-      ::ShowWindow(textItem->GetLabelHWND(), FALSE);
-#endif
+      m_textItem->Show(FALSE);
+      m_editingPanel->Show(FALSE);

     }
     }

+
+    if ( m_inPlaceTextItem )
+      {
+        m_inPlaceTextItem->Show(FALSE);
+      }

   }
   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());
   }
   UpdateDimensions();
   SetCurrentRect(GetCursorRow(), GetCursorColumn());


@@ -1856,15 +2125,58 @@ void wxGenericGrid::SetEditable(bool edit)
   OnSize(evt);
 /*
   int cw, ch;
   OnSize(evt);
 /*
   int cw, ch;

-  int scrollWidth = 16;
+  int m_scrollWidth = 16;

   GetClientSize(&cw, &ch);
   GetClientSize(&cw, &ch);

-  
-  if (vScrollBar)
-    vScrollBar->SetSize(cw - scrollWidth, topOfSheet,
-       scrollWidth, ch - topOfSheet - scrollWidth);
+
+  if (m_vScrollBar)
+    m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
+       m_scrollWidth, ch - m_topOfSheet - m_scrollWidth);

 */
 }
 
 */
 }
 

+
+void wxGenericGrid::SetEditInPlace(bool edit)
+{
+  if ( m_editInPlace != edit )
+    {
+      m_editInPlace = edit;
+
+      if ( m_editInPlace )  // switched on
+        {
+          if ( m_currentRectVisible && m_editable )
+            {
+              m_inPlaceTextItem->SetSize( m_currentRect.x-wxIPE_ADJUST,
+                                          m_currentRect.y-wxIPE_ADJUST,
+                                          m_currentRect.width+wxIPE_ADJUST*2,
+                                          m_currentRect.height+wxIPE_ADJUST*2 );
+
+              wxGridCell *cell = GetCell(m_wCursorRow, m_wCursorColumn);
+
+              if ( cell ) {
+                  m_inPlaceTextItem->SetFont( cell->GetFont() );
+                  m_inPlaceTextItem->SetBackgroundColour(cell->GetBackgroundColour());
+                  m_inPlaceTextItem->SetForegroundColour(cell->GetTextColour());
+
+                  if ( cell->GetTextValue().IsNull() ) {
+                      m_inPlaceTextItem->SetValue( "" );
+                  }
+                  else {
+                      m_inPlaceTextItem->SetValue( cell->GetTextValue() );
+                  }
+              }
+
+              m_inPlaceTextItem->Show( TRUE );
+              m_inPlaceTextItem->SetFocus();
+            }
+        }
+      else  // switched off
+        {
+          m_inPlaceTextItem->Show( FALSE );
+        }
+    }
+}
+
+

 void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
 {
   wxGridCell *cell = GetCell(row, col);
 void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
 {
   wxGridCell *cell = GetCell(row, col);


@@ -1872,18 +2184,18 @@ void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
     cell->SetAlignment(flag);
 }
 
     cell->SetAlignment(flag);
 }
 

-int wxGenericGrid::GetCellAlignment(int row, int col)
+int wxGenericGrid::GetCellAlignment(int row, int col) const

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetAlignment();
   else
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetAlignment();
   else

-    return cellAlignment;
+    return m_cellAlignment;

 }
 
 void wxGenericGrid::SetCellAlignment(int flag)
 {
 }
 
 void wxGenericGrid::SetCellAlignment(int flag)
 {

-  cellAlignment = flag;
+  m_cellAlignment = flag;

   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)
   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)


@@ -1891,14 +2203,14 @@ void wxGenericGrid::SetCellAlignment(int flag)
         GetCell(i, j)->SetAlignment(flag);
 }
 
         GetCell(i, j)->SetAlignment(flag);
 }
 

-int wxGenericGrid::GetCellAlignment(void)
+int wxGenericGrid::GetCellAlignment(void) const

 {
 {

-  return cellAlignment;
+  return m_cellAlignment;

 }
 
 void wxGenericGrid::SetCellBackgroundColour(const wxColour& col)
 {
 }
 
 void wxGenericGrid::SetCellBackgroundColour(const wxColour& col)
 {

-  cellBackgroundColour = col;
+  m_cellBackgroundColour = col;

   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)
   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)


@@ -1916,13 +2228,13 @@ void wxGenericGrid::SetCellBackgroundColour(const wxColour& val, int row, int co
   }
 }
 
   }
 }
 

-wxColour& wxGenericGrid::GetCellBackgroundColour(int row, int col)
+wxColour& wxGenericGrid::GetCellBackgroundColour(int row, int col) const

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetBackgroundColour();
   else
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
     return cell->GetBackgroundColour();
   else

-    return cellBackgroundColour;
+    return (wxColour&) m_cellBackgroundColour;

 }
 
 void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)
 }
 
 void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)


@@ -1935,7 +2247,7 @@ void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)
   }
 }
 
   }
 }
 

-void wxGenericGrid::SetCellTextFont(wxFont *fnt, int row, int col)
+void wxGenericGrid::SetCellTextFont(const wxFont& fnt, int row, int col)

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)


@@ -1945,27 +2257,27 @@ void wxGenericGrid::SetCellTextFont(wxFont *fnt, int row, int col)
   }
 }
 
   }
 }
 

-wxFont *wxGenericGrid::GetCellTextFont(int row, int col)
+wxFont& wxGenericGrid::GetCellTextFont(int row, int col) const

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)

-    return cell->GetFont();
+    return (wxFont&) cell->GetFont();

   else
   else

-    return cellTextFont;
+    return (wxFont&) m_cellTextFont;

 }
 
 }
 

-wxColour& wxGenericGrid::GetCellTextColour(int row, int col)
+wxColour& wxGenericGrid::GetCellTextColour(int row, int col) const

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)

-    return cell->GetTextColour();
+    return (wxColour&) cell->GetTextColour();

   else
   else

-    return cellTextColour;
+    return (wxColour&) m_cellTextColour;

 }
 
 void wxGenericGrid::SetCellTextColour(const wxColour& val)
 {
 }
 
 void wxGenericGrid::SetCellTextColour(const wxColour& val)
 {

-  cellTextColour = val;
+  m_cellTextColour = val;

   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)
   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)


@@ -1973,9 +2285,9 @@ void wxGenericGrid::SetCellTextColour(const wxColour& val)
         GetCell(i, j)->SetTextColour(val);
 }
 
         GetCell(i, j)->SetTextColour(val);
 }
 

-void wxGenericGrid::SetCellTextFont(wxFont *fnt)
+void wxGenericGrid::SetCellTextFont(const wxFont& fnt)

 {
 {

-  cellTextFont = fnt;
+  m_cellTextFont = fnt;

   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)
   int i,j;
   for (i = 0; i < GetRows(); i++)
     for (j = 0; j < GetCols(); j++)


@@ -1993,7 +2305,7 @@ void wxGenericGrid::SetCellBitmap(wxBitmap *bitmap, int row, int col)
   }
 }
 
   }
 }
 

-wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col)
+wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col) const

 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)
 {
   wxGridCell *cell = GetCell(row, col);
   if (cell)


@@ -2001,62 +2313,66 @@ wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col)
     return cell->GetCellBitmap();
   }
   else
     return cell->GetCellBitmap();
   }
   else

-    return NULL;
+    return (wxBitmap *) NULL;

 }
 
 bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
 {
 }
 
 bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
 {

-  if (pos > totalCols)
+  if (pos > m_totalCols)

     return FALSE;
     return FALSE;

-    
-  if (!gridCells)
+
+  if (!m_gridCells)

     return CreateGrid(1, n);
   else
   {
     int i, j;
     // Cells
     return CreateGrid(1, n);
   else
   {
     int i, j;
     // Cells

-    for (i = 0; i < totalRows; i++)
+    for (i = 0; i < m_totalRows; i++)

     {
     {

-      wxGridCell **cols = gridCells[i];
-      wxGridCell **newCols = new wxGridCell *[totalCols + n];
+      wxGridCell **cols = m_gridCells[i];
+      wxGridCell **newCols = new wxGridCell *[m_totalCols + n];

       for (j = 0; j < pos; j++)
         newCols[j] = cols[j];
       for (j = pos; j < pos + n; j++)
         newCols[j] = new wxGridCell(this);
       for (j = 0; j < pos; j++)
         newCols[j] = cols[j];
       for (j = pos; j < pos + n; j++)
         newCols[j] = new wxGridCell(this);

-      for (j = pos + n; j < totalCols + n; j++)
+      for (j = pos + n; j < m_totalCols + n; j++)

         newCols[j] = cols[j - n];
         newCols[j] = cols[j - n];

-        
+

       delete[] cols;
       delete[] cols;

-      gridCells[i] = newCols;
+      m_gridCells[i] = newCols;

     }
 
     // Column widths
     }
 
     // Column widths

-    short *newColWidths = new short[totalCols + n];
+    short *newColWidths = new short[m_totalCols + n];

     for (j = 0; j < pos; j++)
     for (j = 0; j < pos; j++)

-      newColWidths[j] = colWidths[j];
+      newColWidths[j] = m_colWidths[j];

     for (j = pos; j < pos + n; j++)
       newColWidths[j] = wxGRID_DEFAULT_CELL_WIDTH;
     for (j = pos; j < pos + n; j++)
       newColWidths[j] = wxGRID_DEFAULT_CELL_WIDTH;

-    for (j = pos + n; j < totalCols + n; j++)
-      newColWidths[j] = colWidths[j - n];
-    delete[] colWidths;
-    colWidths = newColWidths;
+    for (j = pos + n; j < m_totalCols + n; j++)
+      newColWidths[j] = m_colWidths[j - n];
+    delete[] m_colWidths;
+    m_colWidths = newColWidths;

 
     // Column labels
 
     // Column labels

-    wxGridCell **newLabels = new wxGridCell *[totalCols + n];
+    wxGridCell **newLabels = new wxGridCell *[m_totalCols + n];

     for (j = 0; j < pos; j++)
     for (j = 0; j < pos; j++)

-      newLabels[j] = colLabelCells[j];
+      newLabels[j] = m_colLabelCells[j];

     for (j = pos; j < pos + n; j++)
       newLabels[j] = new wxGridCell(this);
     for (j = pos; j < pos + n; j++)
       newLabels[j] = new wxGridCell(this);

-    for (j = pos + n; j < totalCols + n; j++)
-      newLabels[j] = colLabelCells[j - n];
-        
-    delete[] colLabelCells;
-    colLabelCells = newLabels;
-      
-    totalCols += n;
-
-    if (updateLabels)
-      OnChangeLabels();
+    for (j = pos + n; j < m_totalCols + n; j++)
+      newLabels[j] = m_colLabelCells[j - n];
+
+    delete[] m_colLabelCells;
+    m_colLabelCells = newLabels;
+
+    m_totalCols += n;
+
+    if (updateLabels) {
+        //OnChangeLabels();
+        wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
+        GetEventHandler()->ProcessEvent(g_evt);
+    }
+

     UpdateDimensions();
     AdjustScrollbars();
     return TRUE;
     UpdateDimensions();
     AdjustScrollbars();
     return TRUE;


@@ -2065,61 +2381,65 @@ bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
 
 bool wxGenericGrid::InsertRows(int pos, int n, bool updateLabels)
 {
 
 bool wxGenericGrid::InsertRows(int pos, int n, bool updateLabels)
 {

-  if (pos > totalRows)
+  if (pos > m_totalRows)

     return FALSE;
     return FALSE;

-    
-  if (!gridCells)
+
+  if (!m_gridCells)

     return CreateGrid(n, 1);
   else
   {
     int i, j;
     return CreateGrid(n, 1);
   else
   {
     int i, j;

-    
-    wxGridCell ***rows = new wxGridCell **[totalRows + n];
+
+    wxGridCell ***rows = new wxGridCell **[m_totalRows + n];

 
     // Cells
     for (i = 0; i < pos; i++)
 
     // Cells
     for (i = 0; i < pos; i++)

-      rows[i] = gridCells[i];
+      rows[i] = m_gridCells[i];

 
     for (i = pos; i < pos + n; i++)
     {
 
     for (i = pos; i < pos + n; i++)
     {

-      rows[i] = new wxGridCell *[totalCols];
-      for (j = 0; j < totalCols; j++)
+      rows[i] = new wxGridCell *[m_totalCols];
+      for (j = 0; j < m_totalCols; j++)

         rows[i][j] = new wxGridCell(this);
     }
         rows[i][j] = new wxGridCell(this);
     }

-    
-    for (i = pos + n; i < totalRows + n; i++)
-      rows[i] = gridCells[i - n];
-      
-    delete[] gridCells;
-    gridCells = rows;
+
+    for (i = pos + n; i < m_totalRows + n; i++)
+      rows[i] = m_gridCells[i - n];
+
+    delete[] m_gridCells;
+    m_gridCells = rows;

 
     // Row heights
 
     // Row heights

-    short *newRowHeights = new short[totalRows + n];
+    short *newRowHeights = new short[m_totalRows + n];

     for (i = 0; i < pos; i++)
     for (i = 0; i < pos; i++)

-      newRowHeights[i] = rowHeights[i];
+      newRowHeights[i] = m_rowHeights[i];

     for (i = pos; i < pos + n; i++)
       newRowHeights[i] = wxGRID_DEFAULT_CELL_HEIGHT;
     for (i = pos; i < pos + n; i++)
       newRowHeights[i] = wxGRID_DEFAULT_CELL_HEIGHT;

-    for (i = pos + n; i < totalRows + n; i++)
-      newRowHeights[i] = rowHeights[i - n];
-    delete[] rowHeights;
-    rowHeights = newRowHeights;
+    for (i = pos + n; i < m_totalRows + n; i++)
+      newRowHeights[i] = m_rowHeights[i - n];
+    delete[] m_rowHeights;
+    m_rowHeights = newRowHeights;

 
     // Column labels
 
     // Column labels

-    wxGridCell **newLabels = new wxGridCell *[totalRows + n];
+    wxGridCell **newLabels = new wxGridCell *[m_totalRows + n];

     for (i = 0; i < pos; i++)
     for (i = 0; i < pos; i++)

-      newLabels[i] = rowLabelCells[i];
+      newLabels[i] = m_rowLabelCells[i];

     for (i = pos; i < pos + n; i++)
       newLabels[i] = new wxGridCell(this);
     for (i = pos; i < pos + n; i++)
       newLabels[i] = new wxGridCell(this);

-    for (i = pos + n; i < totalRows + n; i++)
-      newLabels[i] = rowLabelCells[i - n];
-        
-    delete[] rowLabelCells;
-    rowLabelCells = newLabels;
-      
-    totalRows += n;
-
-    if (updateLabels)
-      OnChangeLabels();
+    for (i = pos + n; i < m_totalRows + n; i++)
+      newLabels[i] = m_rowLabelCells[i - n];
+
+    delete[] m_rowLabelCells;
+    m_rowLabelCells = newLabels;
+
+    m_totalRows += n;
+
+    if (updateLabels) {
+        //OnChangeLabels();
+          wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
+          GetEventHandler()->ProcessEvent(g_evt);
+    }
+

     UpdateDimensions();
     AdjustScrollbars();
     return TRUE;
     UpdateDimensions();
     AdjustScrollbars();
     return TRUE;


@@ -2138,48 +2458,51 @@ bool wxGenericGrid::AppendRows(int n, bool updateLabels)
 
 bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
 {
 
 bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
 {

-  if (pos > totalRows)
+  if (pos > m_totalRows)

     return FALSE;
     return FALSE;

-  if (!gridCells)
+  if (!m_gridCells)

     return FALSE;
 
   int i;
     return FALSE;
 
   int i;

-    
-  wxGridCell ***rows = new wxGridCell **[totalRows - n];
+
+  wxGridCell ***rows = new wxGridCell **[m_totalRows - n];

 
   // Cells
   for (i = 0; i < pos; i++)
 
   // Cells
   for (i = 0; i < pos; i++)

-    rows[i] = gridCells[i];
+    rows[i] = m_gridCells[i];

 
 

-  for (i = pos + n; i < totalRows; i++)
-    rows[i-n] = gridCells[i];
-      
-  delete[] gridCells;
-  gridCells = rows;
+  for (i = pos + n; i < m_totalRows; i++)
+    rows[i-n] = m_gridCells[i];
+
+  delete[] m_gridCells;
+  m_gridCells = rows;

 
   // Row heights
 
   // Row heights

-  short *newRowHeights = new short[totalRows - n];
+  short *newRowHeights = new short[m_totalRows - n];

   for (i = 0; i < pos; i++)
   for (i = 0; i < pos; i++)

-    newRowHeights[i] = rowHeights[i];
-  for (i = pos + n; i < totalRows; i++)
-    newRowHeights[i-n] = rowHeights[i];
-  delete[] rowHeights;
-  rowHeights = newRowHeights;
+    newRowHeights[i] = m_rowHeights[i];
+  for (i = pos + n; i < m_totalRows; i++)
+    newRowHeights[i-n] = m_rowHeights[i];
+  delete[] m_rowHeights;
+  m_rowHeights = newRowHeights;

 
   // Column labels
 
   // Column labels

-  wxGridCell **newLabels = new wxGridCell *[totalRows - n];
+  wxGridCell **newLabels = new wxGridCell *[m_totalRows - n];

   for (i = 0; i < pos; i++)
   for (i = 0; i < pos; i++)

-    newLabels[i] = rowLabelCells[i];
-  for (i = pos + n; i < totalRows; i++)
-    newLabels[i-n] = rowLabelCells[i];
-        
-  delete[] rowLabelCells;
-  rowLabelCells = newLabels;
-      
-  totalRows -= n;
-
-  if (updateLabels)
-    OnChangeLabels();
+    newLabels[i] = m_rowLabelCells[i];
+  for (i = pos + n; i < m_totalRows; i++)
+    newLabels[i-n] = m_rowLabelCells[i];
+
+  delete[] m_rowLabelCells;
+  m_rowLabelCells = newLabels;
+
+  m_totalRows -= n;
+
+  if (updateLabels){
+        //OnChangeLabels();
+        wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
+        GetEventHandler()->ProcessEvent(g_evt);
+    }

   UpdateDimensions();
   AdjustScrollbars();
   return TRUE;
   UpdateDimensions();
   AdjustScrollbars();
   return TRUE;


@@ -2187,52 +2510,55 @@ bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
 
 bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
 {
 
 bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
 {

-  if (pos + n > totalCols)
+  if (pos + n > m_totalCols)

     return FALSE;
     return FALSE;

-  if (!gridCells)
+  if (!m_gridCells)

     return FALSE;
 
   int i, j;
 
   // Cells
     return FALSE;
 
   int i, j;
 
   // Cells

-  for (i = 0; i < totalRows; i++)
+  for (i = 0; i < m_totalRows; i++)

   {
   {

-      wxGridCell **cols = gridCells[i];
-      wxGridCell **newCols = new wxGridCell *[totalCols - n];
+      wxGridCell **cols = m_gridCells[i];
+      wxGridCell **newCols = new wxGridCell *[m_totalCols - n];

       for (j = 0; j < pos; j++)
         newCols[j] = cols[j];
       for (j = pos; j < pos + n; j++)
         delete cols[j];
       for (j = 0; j < pos; j++)
         newCols[j] = cols[j];
       for (j = pos; j < pos + n; j++)
         delete cols[j];

-      for (j = pos + n; j < totalCols; j++)
+      for (j = pos + n; j < m_totalCols; j++)

         newCols[j-n] = cols[j];
         newCols[j-n] = cols[j];

-        
+

       delete[] cols;
       delete[] cols;

-      gridCells[i] = newCols;
+      m_gridCells[i] = newCols;

   }
 
   // Column widths
   }
 
   // Column widths

-  short *newColWidths = new short[totalCols - n];
+  short *newColWidths = new short[m_totalCols - n];

   for (j = 0; j < pos; j++)
   for (j = 0; j < pos; j++)

-    newColWidths[j] = colWidths[j];
-  for (j = pos + n; j < totalCols; j++)
-    newColWidths[j-n] = colWidths[j];
-  delete[] colWidths;
-  colWidths = newColWidths;
+    newColWidths[j] = m_colWidths[j];
+  for (j = pos + n; j < m_totalCols; j++)
+    newColWidths[j-n] = m_colWidths[j];
+  delete[] m_colWidths;
+  m_colWidths = newColWidths;

 
   // Column labels
 
   // Column labels

-  wxGridCell **newLabels = new wxGridCell *[totalCols - n];
+  wxGridCell **newLabels = new wxGridCell *[m_totalCols - n];

   for (j = 0; j < pos; j++)
   for (j = 0; j < pos; j++)

-    newLabels[j] = colLabelCells[j];
-  for (j = pos + n; j < totalCols; j++)
-    newLabels[j-n] = colLabelCells[j];
-        
-  delete[] colLabelCells;
-  colLabelCells = newLabels;
-      
-  totalCols -= n;
-
-  if (updateLabels)
-    OnChangeLabels();
+    newLabels[j] = m_colLabelCells[j];
+  for (j = pos + n; j < m_totalCols; j++)
+    newLabels[j-n] = m_colLabelCells[j];
+
+  delete[] m_colLabelCells;
+  m_colLabelCells = newLabels;
+
+  m_totalCols -= n;
+
+  if (updateLabels) {
+        //OnChangeLabels();
+        wxGridEvent g_evt(GetId(), wxEVT_GRID_CHANGE_LABELS, this);
+        GetEventHandler()->ProcessEvent(g_evt);
+    }

   UpdateDimensions();
   AdjustScrollbars();
   return TRUE;
   UpdateDimensions();
   AdjustScrollbars();
   return TRUE;


@@ -2240,39 +2566,44 @@ bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
 
 void wxGenericGrid::SetGridCursor(int row, int col)
 {
 
 void wxGenericGrid::SetGridCursor(int row, int col)
 {

-  if (row >= totalRows || col >= totalCols)
+  if (row >= m_totalRows || col >= m_totalCols)

     return;
     return;

-    
+

   if (row == GetCursorRow() && col == GetCursorColumn())
     return;
   if (row == GetCursorRow() && col == GetCursorColumn())
     return;

-    
+

   wxClientDC dc(this);
   dc.BeginDrawing();
   wxClientDC dc(this);
   dc.BeginDrawing();

-  
+

   SetGridClippingRegion(& dc);
 
   SetGridClippingRegion(& dc);
 

-  if (currentRectVisible)
-    HighlightCell(& dc);
-  
-  wCursorRow = row;
-  wCursorColumn = col;
-  SetCurrentRect(row, col);
-  if (currentRectVisible)
-    HighlightCell(& dc);
+  if (m_currentRectVisible && (wxIPE_HIGHLIGHT || !(m_editable && m_editInPlace)))
+      HighlightCell(& dc, FALSE);
+
+  m_wCursorRow = row;
+  m_wCursorColumn = col;
+
+  int cw, ch;
+  GetClientSize(&cw, &ch);
+
+  SetCurrentRect(row, col, cw, ch);
+
+  if (m_currentRectVisible && (wxIPE_HIGHLIGHT || !(m_editable && m_editInPlace)))
+      HighlightCell(& dc, TRUE);

 
   dc.DestroyClippingRegion();
   dc.EndDrawing();
 }
 
 
   dc.DestroyClippingRegion();
   dc.EndDrawing();
 }
 

-/*
- * Grid cell
- */
- 
+// ----------------------------------------------------------------------------
+// Grid cell
+// ----------------------------------------------------------------------------
+

 wxGridCell::wxGridCell(wxGenericGrid *window)
 {
 wxGridCell::wxGridCell(wxGenericGrid *window)
 {

-  cellBitmap = NULL;
-  font = NULL;
-  backgroundBrush = NULL;
+  cellBitmap = (wxBitmap *) NULL;
+  font = wxNullFont;
+  backgroundBrush = wxNullBrush;

   if (window)
     textColour = window->GetCellTextColour();
   else
   if (window)
     textColour = window->GetCellTextColour();
   else


@@ -2281,77 +2612,151 @@ wxGridCell::wxGridCell(wxGenericGrid *window)
     backgroundColour = window->GetCellBackgroundColour();
   else
     backgroundColour.Set(255,255,255);
     backgroundColour = window->GetCellBackgroundColour();
   else
     backgroundColour.Set(255,255,255);

-    
+

   if (window)
     font = window->GetCellTextFont();
   else
   if (window)
     font = window->GetCellTextFont();
   else

-    font = wxTheFontList->FindOrCreateFont(12, wxSWISS, wxNORMAL, wxNORMAL);
-    
+    font = * wxTheFontList->FindOrCreateFont(12, wxSWISS, wxNORMAL, wxNORMAL);
+

   SetBackgroundColour(backgroundColour);
   SetBackgroundColour(backgroundColour);

-  
+

   if (window)
     alignment = window->GetCellAlignment();
   else
     alignment = wxLEFT;
   if (window)
     alignment = window->GetCellAlignment();
   else
     alignment = wxLEFT;

+
+  cellData = (void *)NULL;

 }
 
 }
 

-wxGridCell::~wxGridCell(void)
+wxGridCell::~wxGridCell()

 {
 }
 
 void wxGridCell::SetBackgroundColour(const wxColour& colour)
 {
   backgroundColour = colour;
 {
 }
 
 void wxGridCell::SetBackgroundColour(const wxColour& colour)
 {
   backgroundColour = colour;

-  backgroundBrush = wxTheBrushList->FindOrCreateBrush(backgroundColour, wxSOLID);
+  backgroundBrush = * wxTheBrushList->FindOrCreateBrush(backgroundColour, wxSOLID);

 }
 
 void wxGenericGrid::OnText(wxCommandEvent& WXUNUSED(ev) )
 {
 }
 
 void wxGenericGrid::OnText(wxCommandEvent& WXUNUSED(ev) )
 {

-  wxGenericGrid *grid = this;
-  wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
-  if (cell && grid->CurrentCellVisible())
-  {
-    cell->SetTextValue(grid->GetTextItem()->GetValue());
-    wxClientDC dc(grid);
+  // michael - added this conditional to prevent change to
+  // grid cell text when edit control is hidden but still has
+  // focus
+  //
+  if ( m_editable )
+    {
+      wxGenericGrid *grid = this;
+      wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
+      if (cell && grid->CurrentCellVisible())
+        {
+          cell->SetTextValue(grid->GetTextItem()->GetValue());
+          if ( m_editInPlace && !m_inOnTextInPlace )
+            {
+              m_inPlaceTextItem->SetValue( grid->GetTextItem()->GetValue() );
+            }

 
 

-    dc.BeginDrawing();
-    grid->SetGridClippingRegion(& dc);
-    grid->DrawCellBackground(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
-    grid->DrawCellValue(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
-    grid->HighlightCell(& dc);
-    dc.DestroyClippingRegion();
-    dc.EndDrawing();
-      
-    grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
-      
-//    grid->DrawCellText();
-  }
+          if (!m_editInPlace) {
+              wxClientDC dc(grid);
+
+              dc.BeginDrawing();
+              grid->SetGridClippingRegion(& dc);
+              grid->DrawCellBackground(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
+              grid->DrawCellValue(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
+              grid->HighlightCell(& dc, TRUE);
+              dc.DestroyClippingRegion();
+              dc.EndDrawing();
+          }
+
+          //grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
+          wxGridEvent g_evt(GetId(), wxEVT_GRID_CELL_CHANGE, grid,
+                            grid->GetCursorRow(), grid->GetCursorColumn());
+          GetEventHandler()->ProcessEvent(g_evt);
+
+          //    grid->DrawCellText();
+        }
+    }
+}
+
+void wxGenericGrid::OnTextEnter(wxCommandEvent& WXUNUSED(ev) )
+{
+  // move the cursor down the current row (if possible)
+  // when the enter key has been pressed
+  //
+  if ( m_editable )
+    {
+      if ( GetCursorRow() < GetRows()-1 )
+        {
+          wxClientDC dc( this );
+          dc.BeginDrawing();
+          OnSelectCellImplementation(& dc,
+                                     GetCursorRow()+1,
+                                     GetCursorColumn() );
+          dc.EndDrawing();
+        }
+    }
+}
+
+void wxGenericGrid::OnTextInPlace(wxCommandEvent& ev )
+{
+  if ( m_editable )
+    {
+      wxGenericGrid *grid = this;
+      wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
+      if (cell && grid->CurrentCellVisible())
+        {
+          m_inOnTextInPlace = TRUE;
+          grid->GetTextItem()->SetValue( m_inPlaceTextItem->GetValue() );
+          OnText( ev );
+          m_inOnTextInPlace = FALSE;
+        }
+    }
+}
+
+void wxGenericGrid::OnTextInPlaceEnter(wxCommandEvent& WXUNUSED(ev) )
+{
+  // move the cursor down the current row (if possible)
+  // when the enter key has been pressed
+  //
+  if ( m_editable )
+    {
+      if ( GetCursorRow() < GetRows()-1 )
+        {
+          wxClientDC dc( this );
+          dc.BeginDrawing();
+          OnSelectCellImplementation(& dc,
+                                     GetCursorRow()+1,
+                                     GetCursorColumn() );
+          dc.EndDrawing();
+        }
+    }

 }
 
 void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
 {
 }
 
 void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
 {

-  static bool inScroll = FALSE;
+  if ( m_inScroll )
+        return;

 
 

-  if ( inScroll )
-       return;
+  if ( m_editInPlace ) m_inPlaceTextItem->Show(FALSE);

 
 

-  inScroll = TRUE;
+  m_inScroll = TRUE;

   wxGenericGrid *win = this;
 
   bool change = FALSE;
   wxGenericGrid *win = this;
 
   bool change = FALSE;

-  
+

   if (ev.GetEventObject() == win->GetHorizScrollBar())
   {
   if (ev.GetEventObject() == win->GetHorizScrollBar())
   {

-    change = (ev.GetPosition() != scrollPosX);
+    change = (ev.GetPosition() != m_scrollPosX);

     win->SetScrollPosX(ev.GetPosition());
   }
   else
   {
     win->SetScrollPosX(ev.GetPosition());
   }
   else
   {

-    change = (ev.GetPosition() != scrollPosY);
+    change = (ev.GetPosition() != m_scrollPosY);

     win->SetScrollPosY(ev.GetPosition());
   }
 
   win->UpdateDimensions();
     win->SetScrollPosY(ev.GetPosition());
   }
 
   win->UpdateDimensions();

+

   win->SetCurrentRect(win->GetCursorRow(), win->GetCursorColumn());
 
   // Because rows and columns can be arbitrary sizes,
   win->SetCurrentRect(win->GetCursorRow(), win->GetCursorColumn());
 
   // Because rows and columns can be arbitrary sizes,


@@ -2360,6 +2765,90 @@ void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
   AdjustScrollbars();
 
   if (change) win->Refresh(FALSE);
   AdjustScrollbars();
 
   if (change) win->Refresh(FALSE);

-  inScroll = FALSE;
-  
+
+  if ( m_editInPlace && m_currentRectVisible )
+    {
+      m_inPlaceTextItem->SetSize( m_currentRect.x-wxIPE_ADJUST,
+                                  m_currentRect.y-wxIPE_ADJUST,
+                                  m_currentRect.width+wxIPE_ADJUST*2,
+                                  m_currentRect.height+wxIPE_ADJUST*2 );
+      m_inPlaceTextItem->Show( TRUE );
+      m_inPlaceTextItem->SetFocus();
+    }
+
+  m_inScroll = FALSE;
+
+}
+
+
+//----------------------------------------------------------------------
+// Default wxGridEvent handlers
+//      (just redirect to the pre-existing virtual methods)
+
+void wxGenericGrid::_OnSelectCell(wxGridEvent& ev)
+{
+    OnSelectCell(ev.m_row, ev.m_col);
+}
+
+void wxGenericGrid::_OnCreateCell(wxGridEvent& ev)
+{
+    ev.m_cell = OnCreateCell();
+}
+
+void wxGenericGrid::_OnChangeLabels(wxGridEvent& WXUNUSED(ev))
+{
+    OnChangeLabels();
+}
+
+void wxGenericGrid::_OnChangeSelectionLabel(wxGridEvent& WXUNUSED(ev))
+{
+    OnChangeSelectionLabel();
+}
+
+void wxGenericGrid::_OnCellChange(wxGridEvent& ev)
+{
+    OnCellChange(ev.m_row, ev.m_col);
+}
+
+void wxGenericGrid::_OnCellLeftClick(wxGridEvent& ev)
+{
+    OnCellLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
+}
+
+void wxGenericGrid::_OnCellRightClick(wxGridEvent& ev)
+{
+    OnCellRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
+}
+
+void wxGenericGrid::_OnLabelLeftClick(wxGridEvent& ev)
+{
+    OnLabelLeftClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);
+}
+
+void wxGenericGrid::_OnLabelRightClick(wxGridEvent& ev)
+{
+    OnLabelRightClick(ev.m_row, ev.m_col, ev.m_x, ev.m_y, ev.m_control, ev.m_shift);

 }
 }

+
+void *wxGenericGrid::SetCellData(void *data, int row, int col)
+{
+    void *rc = NULL;
+
+    wxGridCell *cell = GetCell(row, col);
+    if ( cell )
+        rc = cell->SetCellData(data);
+
+    return rc;
+}
+
+void *wxGenericGrid::GetCellData(int row, int col)
+{
+    void *rc = NULL;
+
+    wxGridCell *cell = GetCell(row, col);
+    if ( cell )
+        rc = cell->GetCellData();
+
+    return rc;
+}
+