#pragma hdrstop
#endif
+#if wxUSE_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"
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
{
}
+#if wxUSE_TEXTCTRL
+
// ----------------------------------------------------------------------------
// wxGridCellTextEditor
// ----------------------------------------------------------------------------
return FALSE;
}
+#endif // wxUSE_TEXTCTRL
+
+#if wxUSE_CHECKBOX
+
// ----------------------------------------------------------------------------
// wxGridCellBoolEditor
// ----------------------------------------------------------------------------
return FALSE;
}
+#endif // wxUSE_CHECKBOX
+
+#if wxUSE_COMBOBOX
+
// ----------------------------------------------------------------------------
// wxGridCellChoiceEditor
// ----------------------------------------------------------------------------
}
}
+#endif // wxUSE_COMBOBOX
+
// ----------------------------------------------------------------------------
// wxGridCellEditorEvtHandler
// ----------------------------------------------------------------------------
//
// Maybe add support for merge of Render and Editor?
if (!HasRenderer() && mergefrom->HasRenderer() )
- {
+ {
m_renderer = mergefrom->m_renderer;
m_renderer->IncRef();
}
{
wxGridCellRenderer* renderer = NULL;
- if ( m_defGridAttr != this || grid == NULL )
+ if ( m_defGridAttr == this || grid == NULL )
{
renderer = m_renderer; // use local attribute
if ( renderer )
}
else
{
+ // free the old attribute
+ m_attrs[(size_t)n].attr->DecRef();
+
if ( attr )
{
// change the attribute
//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);
- 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);
- //Order important..
+ //Order important..
if(attrcell){
attr->MergeWith(attrcell);
attrcell->DecRef();
// 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;
{
// 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);
- }
- 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);
- }
- 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_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);
- }
- else
+ } else
+#endif // wxUSE_COMBOBOX
{
return wxNOT_FOUND;
}
{
for ( n = 0; n < numRows; n++ )
{
- m_data.Remove( pos );
+ m_data.RemoveAt( pos );
}
}
if ( GetView() )
{
for ( n = 0; n < numCols; n++ )
{
- m_data[row].Remove( pos );
+ m_data[row].RemoveAt( pos );
}
}
}
m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
dc.SetDeviceOrigin( 0, -y );
- m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
- m_owner->DrawRowLabels( dc );
+ wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
+ m_owner->DrawRowLabels( dc , rows );
}
m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
dc.SetDeviceOrigin( -x, 0 );
- m_owner->CalcColLabelsExposed( GetUpdateRegion() );
- m_owner->DrawColLabels( dc );
+ wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
+ m_owner->DrawColLabels( dc , cols );
}
m_owner = parent;
m_rowLabelWin = rowLblWin;
m_colLabelWin = colLblWin;
- SetBackgroundColour( "WHITE" );
+ SetBackgroundColour(_T("WHITE"));
}
wxPaintDC dc( this );
m_owner->PrepareDC( dc );
wxRegion reg = GetUpdateRegion();
- m_owner->CalcCellsExposed( reg );
- m_owner->DrawGridCellArea( dc );
+ wxGridCellCoordsArray DirtyCells = m_owner->CalcCellsExposed( reg );
+ m_owner->DrawGridCellArea( dc , DirtyCells);
#if WXGRID_DRAW_LINES
m_owner->DrawAllGridLines( dc, reg );
#endif
m_owner->DrawGridSpace( dc );
- m_owner->DrawHighlight( dc );
+ m_owner->DrawHighlight( dc , DirtyCells );
}
wxGrid::~wxGrid()
{
+ // Must do this or ~wxScrollHelper will pop the wrong event handler
+ SetTargetWindow(this);
ClearAttrCache();
wxSafeDecRef(m_defaultCellAttr);
wxDefaultSize );
SetTargetWindow( m_gridWin );
+
+ Init();
}
m_table->SetView( this );
m_ownTable = TRUE;
m_selection = new wxGridSelection( this, selmode );
- Init();
+
+ CalcDimensions();
+
m_created = TRUE;
return m_created;
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,
if (takeOwnership)
m_ownTable = TRUE;
m_selection = new wxGridSelection( this, selmode );
- Init();
+
+ CalcDimensions();
+
m_created = TRUE;
}
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_extraWidth =
m_extraHeight = 50;
-
- CalcDimensions();
}
// ----------------------------------------------------------------------------
}
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 )
{
- h = 0; y = 0;
+ h = 0; y = 0;
}
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,
- w, h, x, y, (GetBatchCount() != 0));
+ w, h, x, y, (GetBatchCount() != 0));
}
{
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;
{
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;
}
-void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
{
wxRegionIterator iter( reg );
wxRect r;
- m_rowLabelsExposed.Empty();
+ wxArrayInt rowlabels;
int top, bottom;
while ( iter )
if ( GetRowTop(row) > bottom )
break;
- m_rowLabelsExposed.Add( row );
+ rowlabels.Add( row );
}
iter++ ;
}
+
+ return rowlabels;
}
-void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
{
wxRegionIterator iter( reg );
wxRect r;
- m_colLabelsExposed.Empty();
+ wxArrayInt colLabels;
int left, right;
while ( iter )
if ( GetColLeft(col) > right )
break;
- m_colLabelsExposed.Add( col );
+ colLabels.Add( col );
}
iter++ ;
}
+ return colLabels;
}
-void wxGrid::CalcCellsExposed( const wxRegion& reg )
+wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
{
wxRegionIterator iter( reg );
wxRect r;
- m_cellsExposed.Empty();
- m_rowsExposed.Empty();
- m_colsExposed.Empty();
+ wxGridCellCoordsArray cellsExposed;
int left, top, right, bottom;
while ( iter )
if ( GetRowTop(row) > bottom )
break;
- m_rowsExposed.Add( row );
for ( col = 0; col < m_numCols; col++ )
{
if ( GetColLeft(col) > right )
break;
- if ( m_colsExposed.Index( col ) == wxNOT_FOUND )
- m_colsExposed.Add( col );
- m_cellsExposed.Add( wxGridCellCoords( row, col ) );
+ cellsExposed.Add( wxGridCellCoords( row, col ) );
}
}
iter++;
}
+
+ return cellsExposed;
}
// 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 )
{
- 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);
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(),
mouseEv.AltDown(),
mouseEv.MetaDown() );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ claimed = GetEventHandler()->ProcessEvent(gridEvt);
+ vetoed = !gridEvt.IsAllowed();
+
}
- else
+ else
{
wxGridEvent gridEvt( GetId(),
type,
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().
//
-bool wxGrid::SendEvent( const wxEventType type,
+int wxGrid::SendEvent( const wxEventType type,
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);
this,
rowOrCol );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ claimed = GetEventHandler()->ProcessEvent(gridEvt);
+ vetoed = !gridEvt.IsAllowed();
}
else
{
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;
+
}
if ( IsVisible( m_currentCellCoords, FALSE ) )
{
wxRect r;
- r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
+ r = BlockToDeviceRect(m_currentCellCoords, coords);
if ( !m_gridLinesEnabled )
{
r.x--;
r.height++;
}
- CalcCellsExposed( r );
+ wxGridCellCoordsArray cells = CalcCellsExposed( r );
// Otherwise refresh redraws the highlight!
m_currentCellCoords = coords;
- DrawGridCellArea(dc);
+ DrawGridCellArea(dc,cells);
DrawAllGridLines( dc, r );
}
}
// exposed cells (usually set from the update region by
// CalcExposedCells)
//
-void wxGrid::DrawGridCellArea( wxDC& dc )
+void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
{
if ( !m_numRows || !m_numCols ) return;
size_t i;
- size_t numCells = m_cellsExposed.GetCount();
+ size_t numCells = cells.GetCount();
for ( i = 0; i < numCells; i++ )
{
- DrawCell( dc, m_cellsExposed[i] );
+ DrawCell( dc, cells[i] );
}
}
GetColRight(col), GetRowBottom(row) );
}
-void wxGrid::DrawHighlight(wxDC& dc)
+void wxGrid::DrawHighlight(wxDC& dc,const wxGridCellCoordsArray& cells)
{
// This if block was previously in wxGrid::OnPaint but that doesn't
// seem to get called under wxGTK - MB
// if the active cell was repainted, repaint its highlight too because it
// might have been damaged by the grid lines
- size_t count = m_cellsExposed.GetCount();
+ size_t count = cells.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- if ( m_cellsExposed[n] == m_currentCellCoords )
+ if ( cells[n] == m_currentCellCoords )
{
wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
DrawCellHighlight(dc, attr);
}
-void wxGrid::DrawRowLabels( wxDC& dc )
+void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
{
if ( !m_numRows ) return;
size_t i;
- size_t numLabels = m_rowLabelsExposed.GetCount();
+ size_t numLabels = rows.GetCount();
for ( i = 0; i < numLabels; i++ )
{
- DrawRowLabel( dc, m_rowLabelsExposed[i] );
+ DrawRowLabel( dc, rows[i] );
}
}
}
-void wxGrid::DrawColLabels( wxDC& dc )
+void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
{
if ( !m_numCols ) return;
size_t i;
- size_t numLabels = m_colLabelsExposed.GetCount();
+ size_t numLabels = cols.GetCount();
for ( i = 0; i < numLabels; i++ )
{
- DrawColLabel( dc, m_colLabelsExposed[i] );
+ DrawColLabel( dc, cols[i] );
}
}
DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
}
-
void wxGrid::DrawTextRectangle( wxDC& dc,
const wxString& value,
const wxRect& rect,
int horizAlign,
int vertAlign )
{
- long textWidth, textHeight;
- long lineWidth, lineHeight;
wxArrayString lines;
dc.SetClippingRegion( rect );
StringToLines( value, lines );
+
+
+ //Forward to new API.
+ DrawTextRectangle( dc,
+ lines,
+ rect,
+ horizAlign,
+ vertAlign );
+
+}
+
+void wxGrid::DrawTextRectangle( wxDC& dc,
+ const wxArrayString& lines,
+ const wxRect& rect,
+ int horizAlign,
+ int vertAlign )
+{
+ long textWidth, textHeight;
+ long lineWidth, lineHeight;
+
if ( lines.GetCount() )
{
GetTextBoxSize( dc, lines, &textWidth, &textHeight );
void wxGrid::GetTextBoxSize( wxDC& dc,
- wxArrayString& lines,
+ const wxArrayString& lines,
long *width, long *height )
{
long w = 0;
if ( enable != m_cellEditCtrlEnabled )
{
- // TODO allow the app to Veto() this event?
- SendEvent(enable ? wxEVT_GRID_EDITOR_SHOWN : wxEVT_GRID_EDITOR_HIDDEN);
-
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!") );
}
else
{
- HideCellEditControl();
+ //FIXME:add veto support
+ SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
+
+ HideCellEditControl();
SaveEditControlValue();
// do it after HideCellEditControl()
{
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 );
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);
if (changed)
{
- SendEvent( wxEVT_GRID_CELL_CHANGE,
+ if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
m_currentCellCoords.GetRow(),
- m_currentCellCoords.GetCol() );
+ m_currentCellCoords.GetCol() ) < 0 ) {
+
+ //Event has been veto set the data back.
+ SetCellValue(row,col,oldval);
+ }
}
}
}
//
void wxGrid::MakeCellVisible( int row, int col )
{
+
int i;
int xpos = -1, ypos = -1;
// 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 )
}
// see comment for ypos above
- xpos += GRID_SCROLL_LINE / 2;
+ xpos += GRID_SCROLL_LINE;
}
if ( xpos != -1 || ypos != -1 )
if ( resizeExistingRows )
{
InitRowHeights();
- if ( !GetBatchCount() )
- CalcDimensions();
+ if ( !GetBatchCount() )
+ CalcDimensions();
}
}
if ( resizeExistingCols )
{
InitColWidths();
- if ( !GetBatchCount() )
- CalcDimensions();
+ if ( !GetBatchCount() )
+ CalcDimensions();
}
}
}
}
- if ( column ){
+ if ( column )
+ {
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() )
{
- 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;
- m_rowLabelWin->Refresh( TRUE, &rect );
- }
+ m_rowLabelWin->Refresh( TRUE, &rect );
+ }
}
if ( setAsMin )
{
// ------ 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,
}
-IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
int rowOrCol, int x, int y,
}
-IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
+IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
const wxGridCellCoords& topLeft,
}
-#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
+
projects / wxWidgets.git / blobdiff