DJGPP compilation

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

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 83b2116205a87de7d554d7a28d6e1bd4c55c3bec..e2b9e3580721124017104ac5a4c6e8e0901d0ad4 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -30,9 +30,11 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_GRID
+

 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)

-#include "gridg.cpp"
-#else
+    #include "gridg.cpp"
+#else // wxUSE_NEW_GRID

 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"


@@ -115,6 +117,7 @@ DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE)
 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)
 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)

+DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)

 
 // ----------------------------------------------------------------------------
 // private classes
 
 // ----------------------------------------------------------------------------
 // private classes


@@ -517,6 +520,8 @@ void wxGridCellEditor::StartingClick()
 {
 }
 
 {
 }
 

+#if wxUSE_TEXTCTRL
+

 // ----------------------------------------------------------------------------
 // wxGridCellTextEditor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellTextEditor
 // ----------------------------------------------------------------------------


@@ -1143,6 +1148,10 @@ bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
     return FALSE;
 }
 
     return FALSE;
 }
 

+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_CHECKBOX
+

 // ----------------------------------------------------------------------------
 // wxGridCellBoolEditor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellBoolEditor
 // ----------------------------------------------------------------------------


@@ -1287,6 +1296,10 @@ bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
     return FALSE;
 }
 
     return FALSE;
 }
 

+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_COMBOBOX
+

 // ----------------------------------------------------------------------------
 // wxGridCellChoiceEditor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellChoiceEditor
 // ----------------------------------------------------------------------------


@@ -1407,6 +1420,8 @@ void wxGridCellChoiceEditor::SetParameters(const wxString& params)
     }
 }
 
     }
 }
 

+#endif // wxUSE_COMBOBOX
+

 // ----------------------------------------------------------------------------
 // wxGridCellEditorEvtHandler
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellEditorEvtHandler
 // ----------------------------------------------------------------------------


@@ -1917,7 +1932,7 @@ void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
     //
     // Maybe add support for merge of Render and Editor?
     if (!HasRenderer() && mergefrom->HasRenderer() )
     //
     // Maybe add support for merge of Render and Editor?
     if (!HasRenderer() && mergefrom->HasRenderer() )

-    {   
+    {

         m_renderer = mergefrom->m_renderer;
         m_renderer->IncRef();
     }
         m_renderer = mergefrom->m_renderer;
         m_renderer->IncRef();
     }


@@ -2005,7 +2020,7 @@ wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col)
 {
     wxGridCellRenderer* renderer = NULL;
 
 {
     wxGridCellRenderer* renderer = NULL;
 

-    if ( m_defGridAttr != this || grid == NULL )
+    if ( m_defGridAttr == this || grid == NULL )

     {
         renderer = m_renderer;      // use local attribute
         if ( renderer )
     {
         renderer = m_renderer;      // use local attribute
         if ( renderer )


@@ -2073,6 +2088,9 @@ void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
     }
     else
     {
     }
     else
     {

+        // free the old attribute
+        m_attrs[(size_t)n].attr->DecRef();
+

         if ( attr )
         {
             // change the attribute
         if ( attr )
         {
             // change the attribute


@@ -2302,18 +2320,18 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
                     //Also check merge cache, so we don't have to re-merge every time..
                     wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
                                    *attrrow = (wxGridCellAttr *)NULL,
                     //Also check merge cache, so we don't have to re-merge every time..
                     wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
                                    *attrrow = (wxGridCellAttr *)NULL,

-                                   *attrcol = (wxGridCellAttr *)NULL; 
-                
+                                   *attrcol = (wxGridCellAttr *)NULL;
+

                     attrcell = m_data->m_cellAttrs.GetAttr(row, col);
                     attrcol = m_data->m_colAttrs.GetAttr(col);
                     attrrow = m_data->m_rowAttrs.GetAttr(row);
 
                     attrcell = m_data->m_cellAttrs.GetAttr(row, col);
                     attrcol = m_data->m_colAttrs.GetAttr(col);
                     attrrow = m_data->m_rowAttrs.GetAttr(row);
 

-                    if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){    
+                    if((attrcell != attrrow) && (attrrow !=attrcol) && (attrcell != attrcol)){

                         // Two or move are non NULL
                         attr = new wxGridCellAttr;
                         attr->SetKind(wxGridCellAttr::Merged);
 
                         // Two or move are non NULL
                         attr = new wxGridCellAttr;
                         attr->SetKind(wxGridCellAttr::Merged);
 

-                        //Order important.. 
+                        //Order important..

                         if(attrcell){
                             attr->MergeWith(attrcell);
                             attrcell->DecRef();
                         if(attrcell){
                             attr->MergeWith(attrcell);
                             attrcell->DecRef();


@@ -2335,7 +2353,7 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
                         // one or none is non null return it or null.
                         if(attrrow) attr = attrrow;
                         if(attrcol) attr = attrcol;
                         // one or none is non null return it or null.
                         if(attrrow) attr = attrrow;
                         if(attrcol) attr = attrcol;

-                        if(attrcell) attr = attrcell;                            
+                        if(attrcell) attr = attrcell;

                     }
                 }
             break;
                     }
                 }
             break;


@@ -2455,19 +2473,24 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
     {
         // check whether this is one of the standard ones, in which case
         // register it "on the fly"
     {
         // check whether this is one of the standard ones, in which case
         // register it "on the fly"

+#if wxUSE_TEXTCTRL

         if ( typeName == wxGRID_VALUE_STRING )
         {
             RegisterDataType(wxGRID_VALUE_STRING,
                              new wxGridCellStringRenderer,
                              new wxGridCellTextEditor);
         if ( typeName == wxGRID_VALUE_STRING )
         {
             RegisterDataType(wxGRID_VALUE_STRING,
                              new wxGridCellStringRenderer,
                              new wxGridCellTextEditor);

-        }
-        else if ( typeName == wxGRID_VALUE_BOOL )
+        } else
+#endif // wxUSE_TEXTCTRL
+#if wxUSE_CHECKBOX
+        if ( typeName == wxGRID_VALUE_BOOL )

         {
             RegisterDataType(wxGRID_VALUE_BOOL,
                              new wxGridCellBoolRenderer,
                              new wxGridCellBoolEditor);
         {
             RegisterDataType(wxGRID_VALUE_BOOL,
                              new wxGridCellBoolRenderer,
                              new wxGridCellBoolEditor);

-        }
-        else if ( typeName == wxGRID_VALUE_NUMBER )
+        } else
+#endif // wxUSE_CHECKBOX
+#if wxUSE_TEXTCTRL
+        if ( typeName == wxGRID_VALUE_NUMBER )

         {
             RegisterDataType(wxGRID_VALUE_NUMBER,
                              new wxGridCellNumberRenderer,
         {
             RegisterDataType(wxGRID_VALUE_NUMBER,
                              new wxGridCellNumberRenderer,


@@ -2478,14 +2501,16 @@ int wxGridTypeRegistry::FindDataType(const wxString& typeName)
             RegisterDataType(wxGRID_VALUE_FLOAT,
                              new wxGridCellFloatRenderer,
                              new wxGridCellFloatEditor);
             RegisterDataType(wxGRID_VALUE_FLOAT,
                              new wxGridCellFloatRenderer,
                              new wxGridCellFloatEditor);

-        }
-        else if ( typeName == wxGRID_VALUE_CHOICE )
+        } else
+#endif // wxUSE_TEXTCTRL
+#if wxUSE_COMBOBOX
+        if ( typeName == wxGRID_VALUE_CHOICE )

         {
             RegisterDataType(wxGRID_VALUE_CHOICE,
                              new wxGridCellStringRenderer,
                              new wxGridCellChoiceEditor);
         {
             RegisterDataType(wxGRID_VALUE_CHOICE,
                              new wxGridCellStringRenderer,
                              new wxGridCellChoiceEditor);

-        }
-        else
+        } else
+#endif // wxUSE_COMBOBOX

         {
             return wxNOT_FOUND;
         }
         {
             return wxNOT_FOUND;
         }


@@ -3002,7 +3027,7 @@ bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
     {
         for ( n = 0;  n < numRows;  n++ )
         {
     {
         for ( n = 0;  n < numRows;  n++ )
         {

-            m_data.Remove( pos );
+            m_data.RemoveAt( pos );

         }
     }
     if ( GetView() )
         }
     }
     if ( GetView() )


@@ -3118,7 +3143,7 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
         {
             for ( n = 0;  n < numCols;  n++ )
             {
         {
             for ( n = 0;  n < numCols;  n++ )
             {

-                m_data[row].Remove( pos );
+                m_data[row].RemoveAt( pos );

             }
         }
     }
             }
         }
     }


@@ -3413,7 +3438,7 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
     m_colLabelWin = colLblWin;
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
     m_colLabelWin = colLblWin;

-    SetBackgroundColour( "WHITE" );
+    SetBackgroundColour(_T("WHITE"));

 }
 
 
 }
 
 


@@ -3502,6 +3527,8 @@ wxGrid::wxGrid( wxWindow *parent,
 
 wxGrid::~wxGrid()
 {
 
 wxGrid::~wxGrid()
 {

+    // Must do this or ~wxScrollHelper will pop the wrong event handler
+    SetTargetWindow(this);

     ClearAttrCache();
     wxSafeDecRef(m_defaultCellAttr);
 
     ClearAttrCache();
     wxSafeDecRef(m_defaultCellAttr);
 


@@ -3583,6 +3610,8 @@ void wxGrid::Create()
                                   wxDefaultSize );
 
     SetTargetWindow( m_gridWin );
                                   wxDefaultSize );
 
     SetTargetWindow( m_gridWin );

+
+    Init();

 }
 
 
 }
 
 


@@ -3600,7 +3629,9 @@ bool wxGrid::CreateGrid( int numRows, int numCols,
     m_table->SetView( this );
     m_ownTable = TRUE;
     m_selection = new wxGridSelection( this, selmode );
     m_table->SetView( this );
     m_ownTable = TRUE;
     m_selection = new wxGridSelection( this, selmode );

-    Init();
+
+    CalcDimensions();
+

     m_created = TRUE;
 
     return m_created;
     m_created = TRUE;
 
     return m_created;


@@ -3608,12 +3639,10 @@ bool wxGrid::CreateGrid( int numRows, int numCols,
 
 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
 {
 
 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
 {

-    if ( !m_created )
-    {
-        wxFAIL_MSG( wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
-    }
-    else
-        m_selection->SetSelectionMode( selmode );
+    wxCHECK_RET( m_created,
+                 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
+
+    m_selection->SetSelectionMode( selmode );

 }
 
 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
 }
 
 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,


@@ -3640,7 +3669,9 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
         if (takeOwnership)
             m_ownTable = TRUE;
         m_selection = new wxGridSelection( this, selmode );
         if (takeOwnership)
             m_ownTable = TRUE;
         m_selection = new wxGridSelection( this, selmode );

-        Init();
+
+        CalcDimensions();
+

         m_created = TRUE;
     }
 
         m_created = TRUE;
     }
 


@@ -3690,7 +3721,7 @@ void wxGrid::Init()
     m_gridLineColour = wxColour( 128, 128, 255 );
     m_gridLinesEnabled = TRUE;
     m_cellHighlightColour = m_gridLineColour;
     m_gridLineColour = wxColour( 128, 128, 255 );
     m_gridLinesEnabled = TRUE;
     m_cellHighlightColour = m_gridLineColour;

-    m_cellHighlightPenWidth = 3;
+    m_cellHighlightPenWidth = 2;

     m_cellHighlightROPenWidth = 1;
 
     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
     m_cellHighlightROPenWidth = 1;
 
     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;


@@ -3722,8 +3753,6 @@ void wxGrid::Init()
 
     m_extraWidth =
     m_extraHeight = 50;
 
     m_extraWidth =
     m_extraHeight = 50;

-
-    CalcDimensions();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -3828,24 +3857,24 @@ void wxGrid::CalcDimensions()
     }
     else
     {
     }
     else
     {

-       w = (w + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
-       if ( x >= w )
-           x = w - 1;
+        w = (w + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
+        if ( x >= w )
+            x = w - 1;

     }
     if ( h <= ch )
     {
     }
     if ( h <= ch )
     {

-       h = 0; y = 0;
+        h = 0; y = 0;

     }
     else
     {
     }
     else
     {

-       h = (h + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
-       if ( y >= h )
-           y = h - 1;
+        h = (h + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
+        if ( y >= h )
+            y = h - 1;

     }
 
     // do set scrollbar parameters
     SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
     }
 
     // do set scrollbar parameters
     SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,

-                  w, h, x, y, (GetBatchCount() != 0));
+                   w, h, x, y, (GetBatchCount() != 0));

 }
 
 
 }
 
 


@@ -3986,8 +4015,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 for ( i = 0;  i < numRows;  i++ )
                 {
             {
                 for ( i = 0;  i < numRows;  i++ )
                 {

-                    m_rowHeights.Remove( pos );
-                    m_rowBottoms.Remove( pos );
+                    m_rowHeights.RemoveAt( pos );
+                    m_rowBottoms.RemoveAt( pos );

                 }
 
                 int h = 0;
                 }
 
                 int h = 0;


@@ -4122,8 +4151,8 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             {
                 for ( i = 0;  i < numCols;  i++ )
                 {
             {
                 for ( i = 0;  i < numCols;  i++ )
                 {

-                    m_colWidths.Remove( pos );
-                    m_colRights.Remove( pos );
+                    m_colWidths.RemoveAt( pos );
+                    m_colRights.RemoveAt( pos );

                 }
 
                 int w = 0;
                 }
 
                 int w = 0;


@@ -4178,8 +4207,8 @@ wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
     wxRegionIterator iter( reg );
     wxRect r;
 
     wxRegionIterator iter( reg );
     wxRect r;
 

-    wxArrayInt  rowlabels;           
-        
+    wxArrayInt  rowlabels;
+

     int top, bottom;
     while ( iter )
     {
     int top, bottom;
     while ( iter )
     {


@@ -5425,11 +5454,14 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
 // Generate a grid event based on a mouse event and
 // return the result of ProcessEvent()
 //
 // Generate a grid event based on a mouse event and
 // return the result of ProcessEvent()
 //

-bool wxGrid::SendEvent( const wxEventType type,
+int wxGrid::SendEvent( const wxEventType type,

                         int row, int col,
                         wxMouseEvent& mouseEv )
 {
                         int row, int col,
                         wxMouseEvent& mouseEv )
 {

-    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
+   bool claimed;
+   bool vetoed= FALSE;
+       
+   if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )

     {
         int rowOrCol = (row == -1 ? col : row);
 
     {
         int rowOrCol = (row == -1 ? col : row);
 


@@ -5443,9 +5475,12 @@ bool wxGrid::SendEvent( const wxEventType type,
                                  mouseEv.ShiftDown(),
                                  mouseEv.AltDown(),
                                  mouseEv.MetaDown() );
                                  mouseEv.ShiftDown(),
                                  mouseEv.AltDown(),
                                  mouseEv.MetaDown() );

-        return GetEventHandler()->ProcessEvent(gridEvt);
+
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+       vetoed = !gridEvt.IsAllowed();
+

     }
     }

-    else if ( type == wxEVT_GRID_RANGE_SELECT )
+   else if ( type == wxEVT_GRID_RANGE_SELECT )

     {
         // Right now, it should _never_ end up here!
         wxGridRangeSelectEvent gridEvt( GetId(),
     {
         // Right now, it should _never_ end up here!
         wxGridRangeSelectEvent gridEvt( GetId(),


@@ -5459,9 +5494,11 @@ bool wxGrid::SendEvent( const wxEventType type,
                                         mouseEv.AltDown(),
                                         mouseEv.MetaDown() );
 
                                         mouseEv.AltDown(),
                                         mouseEv.MetaDown() );
 

-        return GetEventHandler()->ProcessEvent(gridEvt);
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+       vetoed = !gridEvt.IsAllowed();
+       

     }
     }

-    else
+   else

     {
         wxGridEvent gridEvt( GetId(),
                              type,
     {
         wxGridEvent gridEvt( GetId(),
                              type,


@@ -5474,17 +5511,27 @@ bool wxGrid::SendEvent( const wxEventType type,
                              mouseEv.ShiftDown(),
                              mouseEv.AltDown(),
                              mouseEv.MetaDown() );
                              mouseEv.ShiftDown(),
                              mouseEv.AltDown(),
                              mouseEv.MetaDown() );

-        return GetEventHandler()->ProcessEvent(gridEvt);
+         claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed = !gridEvt.IsAllowed();

     }
     }

+
+  // A Veto'd event may not be `claimed' so test this first
+  if (vetoed) return -1;
+  return claimed ? 1 : 0;
+
+

 }
 
 
 // Generate a grid event of specified type and return the result
 // of ProcessEvent().
 //
 }
 
 
 // Generate a grid event of specified type and return the result
 // of ProcessEvent().
 //

-bool wxGrid::SendEvent( const wxEventType type,
+int wxGrid::SendEvent( const wxEventType type,

                         int row, int col )
 {
                         int row, int col )
 {

+   bool claimed;
+   bool vetoed= FALSE;
+

     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
     {
         int rowOrCol = (row == -1 ? col : row);
     if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
     {
         int rowOrCol = (row == -1 ? col : row);


@@ -5494,7 +5541,8 @@ bool wxGrid::SendEvent( const wxEventType type,
                                  this,
                                  rowOrCol );
 
                                  this,
                                  rowOrCol );
 

-        return GetEventHandler()->ProcessEvent(gridEvt);
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed  = !gridEvt.IsAllowed();

     }
     else
     {
     }
     else
     {


@@ -5503,8 +5551,14 @@ bool wxGrid::SendEvent( const wxEventType type,
                              this,
                              row, col );
 
                              this,
                              row, col );
 

-        return GetEventHandler()->ProcessEvent(gridEvt);
-    }
+        claimed = GetEventHandler()->ProcessEvent(gridEvt);
+        vetoed  = !gridEvt.IsAllowed();
+     }
+
+       // A Veto'd event may not be `claimed' so test this first
+       if (vetoed) return -1;
+       return claimed ? 1 : 0;
+

 }
 
 
 }
 
 


@@ -5794,7 +5848,7 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
 
             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;
 
             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;

-            
+

             DrawGridCellArea(dc,cells);
             DrawAllGridLines( dc, r );
         }
             DrawGridCellArea(dc,cells);
             DrawAllGridLines( dc, r );
         }


@@ -6554,12 +6608,12 @@ void wxGrid::EnableCellEditControl( bool enable )
 
     if ( enable != m_cellEditCtrlEnabled )
     {
 
     if ( enable != m_cellEditCtrlEnabled )
     {

-        // TODO allow the app to Veto() this event?
-        SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
-

         if ( enable )
         {
         if ( enable )
         {

-            // this should be checked by the caller!
+           if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
+               return;
+
+           // this should be checked by the caller!

             wxASSERT_MSG( CanEnableCellControl(),
                           _T("can't enable editing for this cell!") );
 
             wxASSERT_MSG( CanEnableCellControl(),
                           _T("can't enable editing for this cell!") );
 


@@ -6570,7 +6624,10 @@ void wxGrid::EnableCellEditControl( bool enable )
         }
         else
         {
         }
         else
         {

-            HideCellEditControl();
+           //FIXME:add veto support
+           SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
+
+           HideCellEditControl();

             SaveEditControlValue();
 
             // do it after HideCellEditControl()
             SaveEditControlValue();
 
             // do it after HideCellEditControl()


@@ -6667,6 +6724,14 @@ void wxGrid::ShowCellEditControl()
             {
                 editor->Create(m_gridWin, -1,
                                new wxGridCellEditorEvtHandler(this, editor));
             {
                 editor->Create(m_gridWin, -1,
                                new wxGridCellEditorEvtHandler(this, editor));

+
+                wxGridEditorCreatedEvent evt(GetId(),
+                                             wxEVT_GRID_EDITOR_CREATED,
+                                             this,
+                                             row,
+                                             col,
+                                             editor->GetControl());
+                GetEventHandler()->ProcessEvent(evt);

             }
 
             editor->Show( TRUE, attr );
             }
 
             editor->Show( TRUE, attr );


@@ -6708,6 +6773,8 @@ void wxGrid::SaveEditControlValue()
         int row = m_currentCellCoords.GetRow();
         int col = m_currentCellCoords.GetCol();
 
         int row = m_currentCellCoords.GetRow();
         int col = m_currentCellCoords.GetCol();
 

+        wxString oldval = GetCellValue(row,col);
+

         wxGridCellAttr* attr = GetCellAttr(row, col);
         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
         bool changed = editor->EndEdit(row, col, this);
         wxGridCellAttr* attr = GetCellAttr(row, col);
         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
         bool changed = editor->EndEdit(row, col, this);


@@ -6717,9 +6784,13 @@ void wxGrid::SaveEditControlValue()
 
         if (changed)
         {
 
         if (changed)
         {

-            SendEvent( wxEVT_GRID_CELL_CHANGE,
+            if ( SendEvent( wxEVT_GRID_CELL_CHANGE,

                        m_currentCellCoords.GetRow(),
                        m_currentCellCoords.GetRow(),

-                       m_currentCellCoords.GetCol() );
+                       m_currentCellCoords.GetCol() ) < 0 ) {
+
+                             //Event has been veto set the data back.
+                              SetCellValue(row,col,oldval);
+              }

         }
     }
 }
         }
     }
 }


@@ -6879,6 +6950,7 @@ bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
 //
 void wxGrid::MakeCellVisible( int row, int col )
 {
 //
 void wxGrid::MakeCellVisible( int row, int col )
 {

+

     int i;
     int xpos = -1, ypos = -1;
 
     int i;
     int xpos = -1, ypos = -1;
 


@@ -6919,7 +6991,10 @@ void wxGrid::MakeCellVisible( int row, int col )
             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
             // have rounding errors (this is important, because if we do, we
             // might not scroll at all and some cells won't be redrawn)
             // we divide it later by GRID_SCROLL_LINE, make sure that we don't
             // have rounding errors (this is important, because if we do, we
             // might not scroll at all and some cells won't be redrawn)

-            ypos += GRID_SCROLL_LINE / 2;
+            //
+            // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
+            // scroll unit...
+            ypos += GRID_SCROLL_LINE;

         }
 
         if ( left < 0 )
         }
 
         if ( left < 0 )


@@ -6941,7 +7016,7 @@ void wxGrid::MakeCellVisible( int row, int col )
             }
 
             // see comment for ypos above
             }
 
             // see comment for ypos above

-            xpos += GRID_SCROLL_LINE / 2;
+            xpos += GRID_SCROLL_LINE;

         }
 
         if ( xpos != -1  ||  ypos != -1 )
         }
 
         if ( xpos != -1  ||  ypos != -1 )


@@ -8208,8 +8283,8 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
     if ( resizeExistingRows )
     {
         InitRowHeights();
     if ( resizeExistingRows )
     {
         InitRowHeights();

-       if ( !GetBatchCount() )
-           CalcDimensions();
+        if ( !GetBatchCount() )
+            CalcDimensions();

     }
 }
 
     }
 }
 


@@ -8243,8 +8318,8 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
     if ( resizeExistingCols )
     {
         InitColWidths();
     if ( resizeExistingCols )
     {
         InitColWidths();

-       if ( !GetBatchCount() )
-           CalcDimensions();
+        if ( !GetBatchCount() )
+            CalcDimensions();

     }
 }
 
     }
 }
 


@@ -8372,33 +8447,35 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
         }
     }
 
         }
     }
 

-    if ( column ){
+    if ( column )
+    {

         SetColSize(col, extentMax);
         if ( !GetBatchCount() )
         {
         SetColSize(col, extentMax);
         if ( !GetBatchCount() )
         {

-           int cw, ch, dummy;
-           m_gridWin->GetClientSize( &cw, &ch );
-           wxRect rect ( CellToRect( 0, col ) );
-           rect.y = 0;
-           CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
-           rect.width = cw - rect.x;
-           rect.height = m_colLabelHeight;
-           m_colLabelWin->Refresh( TRUE, &rect );
-       }
-    }
-    else{
+            int cw, ch, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            wxRect rect ( CellToRect( 0, col ) );
+            rect.y = 0;
+            CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
+            rect.width = cw - rect.x;
+            rect.height = m_colLabelHeight;
+            m_colLabelWin->Refresh( TRUE, &rect );
+        }
+    }
+    else
+    {

         SetRowSize(row, extentMax);
         if ( !GetBatchCount() )
         {
         SetRowSize(row, extentMax);
         if ( !GetBatchCount() )
         {

-           int cw, ch, dummy;
-           m_gridWin->GetClientSize( &cw, &ch );
-           wxRect rect ( CellToRect( row, 0 ) );
-           rect.x = 0;
-           CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
-           rect.width = m_rowLabelWidth;
+            int cw, ch, dummy;
+            m_gridWin->GetClientSize( &cw, &ch );
+            wxRect rect ( CellToRect( row, 0 ) );
+            rect.x = 0;
+            CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
+            rect.width = m_rowLabelWidth;

             rect.height = ch - rect.y;
             rect.height = ch - rect.y;

-           m_rowLabelWin->Refresh( TRUE, &rect );
-       }
+            m_rowLabelWin->Refresh( TRUE, &rect );
+        }

     }
     if ( setAsMin )
     {
     }
     if ( setAsMin )
     {


@@ -8669,7 +8746,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
 // ------ Grid event classes
 //
 
 // ------ Grid event classes
 //
 

-IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )

 
 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
                           int row, int col, int x, int y, bool sel,
 
 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
                           int row, int col, int x, int y, bool sel,


@@ -8690,7 +8767,7 @@ wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
 }
 
 
 }
 
 

-IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )

 
 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
                                   int rowOrCol, int x, int y,
 
 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
                                   int rowOrCol, int x, int y,


@@ -8709,7 +8786,7 @@ wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
 }
 
 
 }
 
 

-IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )

 
 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                const wxGridCellCoords& topLeft,
 
 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
                                                const wxGridCellCoords& topLeft,


@@ -8730,4 +8807,21 @@ wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObjec
 }
 
 
 }
 
 

-#endif // ifndef wxUSE_NEW_GRID
+IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
+
+wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
+                                                   wxObject* obj, int row,
+                                                   int col, wxControl* ctrl)
+    : wxCommandEvent(type, id)
+{
+    SetEventObject(obj);
+    m_row = row;
+    m_col = col;
+    m_ctrl = ctrl;
+}
+
+
+#endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
+
+#endif // wxUSE_GRID
+