applied patch 430452 (mingw32 compilation fixes)

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

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index d643c0ff7c60405e645991c31da66f894185e772..6a9750f96f44e180704e44fa5b669da1ae6cbf98 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -96,6 +96,27 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
 
 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
 

+// ----------------------------------------------------------------------------
+// events
+// ----------------------------------------------------------------------------
+
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK)
+DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE)
+DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE)
+DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT)
+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_EDITOR_CREATED)
+

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


@@ -112,6 +133,7 @@ private:
 
     void OnPaint( wxPaintEvent& event );
     void OnMouseEvent( wxMouseEvent& event );
 
     void OnPaint( wxPaintEvent& event );
     void OnMouseEvent( wxMouseEvent& event );

+    void OnMouseWheel( wxMouseEvent& event );

     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
 
     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
 


@@ -132,6 +154,7 @@ private:
 
     void OnPaint( wxPaintEvent &event );
     void OnMouseEvent( wxMouseEvent& event );
 
     void OnPaint( wxPaintEvent &event );
     void OnMouseEvent( wxMouseEvent& event );

+    void OnMouseWheel( wxMouseEvent& event );

     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
 
     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
 


@@ -151,6 +174,7 @@ private:
     wxGrid *m_owner;
 
     void OnMouseEvent( wxMouseEvent& event );
     wxGrid *m_owner;
 
     void OnMouseEvent( wxMouseEvent& event );

+    void OnMouseWheel( wxMouseEvent& event );

     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
     void OnPaint( wxPaintEvent& event );
     void OnKeyDown( wxKeyEvent& event );
     void OnKeyUp( wxKeyEvent& );
     void OnPaint( wxPaintEvent& event );


@@ -183,6 +207,7 @@ private:
     wxGridColLabelWindow     *m_colLabelWin;
 
     void OnPaint( wxPaintEvent &event );
     wxGridColLabelWindow     *m_colLabelWin;
 
     void OnPaint( wxPaintEvent &event );

+    void OnMouseWheel( wxMouseEvent& event );

     void OnMouseEvent( wxMouseEvent& event );
     void OnKeyDown( wxKeyEvent& );
     void OnKeyUp( wxKeyEvent& );
     void OnMouseEvent( wxMouseEvent& event );
     void OnKeyDown( wxKeyEvent& );
     void OnKeyUp( wxKeyEvent& );


@@ -354,8 +379,15 @@ wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
 // scroll line size
 wxRect           wxGridNoCellRect( -1, -1, -1, -1 );
 
 // scroll line size

-// TODO: fixed so far - make configurable later (and also different for x/y)
-static const size_t GRID_SCROLL_LINE = 10;
+// TODO: this doesn't work at all, grid cells have different sizes and approx
+//       calculations don't work as because of the size mismatch scrollbars
+//       sometimes fail to be shown when they should be or vice versa
+//
+//       The scroll bars may be a little flakey once in a while, but that is
+//       surely much less horrible than having scroll lines of only 1!!!
+//       -- Robin
+static const size_t GRID_SCROLL_LINE = 15;  // 1;
+

 
 // the size of hash tables used a bit everywhere (the max number of elements
 // in these hash tables is the number of rows/columns)
 
 // the size of hash tables used a bit everywhere (the max number of elements
 // in these hash tables is the number of rows/columns)


@@ -474,7 +506,7 @@ void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
 {
     // accept the simple key presses, not anything with Ctrl/Alt/Meta
 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
 {
     // accept the simple key presses, not anything with Ctrl/Alt/Meta

-    return !event.HasModifiers();
+    return !(event.ControlDown() || event.AltDown());

 }
 
 void wxGridCellEditor::StartingKey(wxKeyEvent& event)
 }
 
 void wxGridCellEditor::StartingKey(wxKeyEvent& event)


@@ -502,7 +534,8 @@ void wxGridCellTextEditor::Create(wxWindow* parent,
     m_control = new wxTextCtrl(parent, id, wxEmptyString,
                                wxDefaultPosition, wxDefaultSize
 #if defined(__WXMSW__)
     m_control = new wxTextCtrl(parent, id, wxEmptyString,
                                wxDefaultPosition, wxDefaultSize
 #if defined(__WXMSW__)

-                               , wxTE_MULTILINE | wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL
+                               , wxTE_PROCESS_TAB | wxTE_MULTILINE |
+                                 wxTE_NO_VSCROLL | wxTE_AUTO_SCROLL

 #endif
                               );
 
 #endif
                               );
 


@@ -538,9 +571,9 @@ void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
     }
 #else // !GTK
     int extra_x = ( rect.x > 2 )? 2 : 1;
     }
 #else // !GTK
     int extra_x = ( rect.x > 2 )? 2 : 1;

-    
-// MB: treat MSW separately here otherwise the caret doesn't show 
-// when the editor is in the first row. 
+
+// MB: treat MSW separately here otherwise the caret doesn't show
+// when the editor is in the first row.

 #if defined(__WXMSW__)
     int extra_y = 2;
 #else
 #if defined(__WXMSW__)
     int extra_y = 2;
 #else


@@ -1189,7 +1222,10 @@ void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
     if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
         m_startValue = grid->GetTable()->GetValueAsBool(row, col);
     else
     if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
         m_startValue = grid->GetTable()->GetValueAsBool(row, col);
     else

-        m_startValue = !!grid->GetTable()->GetValue(row, col);
+    {
+        wxString cellval( grid->GetTable()->GetValue(row, col) );
+        m_startValue = !( !cellval || (cellval == "0") );
+    }

     CBox()->SetValue(m_startValue);
     CBox()->SetFocus();
 }
     CBox()->SetValue(m_startValue);
     CBox()->SetFocus();
 }


@@ -1386,11 +1422,12 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
             break;
 
         case WXK_TAB:
             break;
 
         case WXK_TAB:

-            event.Skip( m_grid->ProcessEvent( event ) );
+            m_grid->GetEventHandler()->ProcessEvent( event );

             break;
 
         case WXK_RETURN:
             break;
 
         case WXK_RETURN:

-            if (!m_grid->ProcessEvent(event))
+        case WXK_NUMPAD_ENTER:
+            if (!m_grid->GetEventHandler()->ProcessEvent(event))

                 m_editor->HandleReturn(event);
             break;
 
                 m_editor->HandleReturn(event);
             break;
 


@@ -1407,6 +1444,7 @@ void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
         case WXK_ESCAPE:
         case WXK_TAB:
         case WXK_RETURN:
         case WXK_ESCAPE:
         case WXK_TAB:
         case WXK_RETURN:

+        case WXK_NUMPAD_ENTER:

             break;
 
         default:
             break;
 
         default:


@@ -1627,8 +1665,15 @@ wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
         {
             if ( m_width == -1 )
             {
         {
             if ( m_width == -1 )
             {

+                if ( m_precision == -1 )
+                {

                 // default width/precision
                 m_format = _T("%f");
                 // default width/precision
                 m_format = _T("%f");

+            }
+                else
+                {
+                    m_format.Printf(_T("%%.%df"), m_precision);
+                }

             }
             else if ( m_precision == -1 )
             {
             }
             else if ( m_precision == -1 )
             {


@@ -1642,6 +1687,7 @@ wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
         }
 
         text.Printf(m_format, val);
         }
 
         text.Printf(m_format, val);

+

     }
     //else: text already contains the string
 
     }
     //else: text already contains the string
 


@@ -1680,8 +1726,6 @@ wxSize wxGridCellFloatRenderer::GetBestSize(wxGrid& grid,
 
 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
 {
 
 void wxGridCellFloatRenderer::SetParameters(const wxString& params)
 {

-    bool ok = TRUE;
-

     if ( !params )
     {
         // reset to defaults
     if ( !params )
     {
         // reset to defaults


@@ -1694,37 +1738,34 @@ void wxGridCellFloatRenderer::SetParameters(const wxString& params)
         if ( !!tmp )
         {
             long width;
         if ( !!tmp )
         {
             long width;

-            if ( !tmp.ToLong(&width) )
+            if ( tmp.ToLong(&width) )

             {
             {

-                ok = FALSE;
+                SetWidth((int)width);

             }
             else
             {
             }
             else
             {

-                SetWidth((int)width);
+                wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
+            }

 
 

+        }

                 tmp = params.AfterFirst(_T(','));
                 if ( !!tmp )
                 {
                     long precision;
                 tmp = params.AfterFirst(_T(','));
                 if ( !!tmp )
                 {
                     long precision;

-                    if ( !tmp.ToLong(&precision) )
+            if ( tmp.ToLong(&precision) )

                     {
                     {

-                        ok = FALSE;
+                SetPrecision((int)precision);

                     }
                     else
                     {
                     }
                     else
                     {

-                        SetPrecision((int)precision);
-                    }
-                }
-            }
+                wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());

         }
 
         }
 

-        if ( !ok )
-        {
-            wxLogDebug(_T("Invalid wxGridCellFloatRenderer parameter string '%s ignored"), params.c_str());

         }
     }
 }
 
         }
     }
 }
 

+

 // ----------------------------------------------------------------------------
 // wxGridCellBoolRenderer
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGridCellBoolRenderer
 // ----------------------------------------------------------------------------


@@ -1795,7 +1836,10 @@ void wxGridCellBoolRenderer::Draw(wxGrid& grid,
     if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
         value = grid.GetTable()->GetValueAsBool(row, col);
     else
     if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
         value = grid.GetTable()->GetValueAsBool(row, col);
     else

-        value = !!grid.GetTable()->GetValue(row, col);
+    {
+        wxString cellval( grid.GetTable()->GetValue(row, col) );
+        value = !( !cellval || (cellval == "0") );
+    }

 
     if ( value )
     {
 
     if ( value )
     {


@@ -1848,11 +1892,47 @@ wxGridCellAttr *wxGridCellAttr::Clone() const
     if ( IsReadOnly() )
         attr->SetReadOnly();
 
     if ( IsReadOnly() )
         attr->SetReadOnly();
 

+    attr->SetKind( m_attrkind );
+

     attr->SetDefAttr(m_defGridAttr);
 
     return attr;
 }
 
     attr->SetDefAttr(m_defGridAttr);
 
     return attr;
 }
 

+void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
+{
+    if ( !HasTextColour() && mergefrom->HasTextColour() )
+        SetTextColour(mergefrom->GetTextColour());
+    if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
+        SetBackgroundColour(mergefrom->GetBackgroundColour());
+    if ( !HasFont() && mergefrom->HasFont() )
+        SetFont(mergefrom->GetFont());
+    if ( !!HasAlignment() && mergefrom->HasAlignment() ){
+        int hAlign, vAlign;
+        mergefrom->GetAlignment( &hAlign, &vAlign);
+        SetAlignment(hAlign, vAlign);
+    }
+
+    // Directly access member functions as GetRender/Editor don't just return
+    // m_renderer/m_editor
+    //
+    // Maybe add support for merge of Render and Editor?
+    if (!HasRenderer() && mergefrom->HasRenderer() )
+    {
+        m_renderer = mergefrom->m_renderer;
+        m_renderer->IncRef();
+    }
+    if ( !HasEditor() && mergefrom->HasEditor() )
+    {
+        m_editor =  mergefrom->m_editor;
+        m_editor->IncRef();
+    }
+    if ( !HasReadWriteMode()  && mergefrom->HasReadWriteMode() )
+        SetReadOnly(mergefrom->IsReadOnly());
+
+    SetDefAttr(mergefrom->m_defGridAttr);
+}
+

 const wxColour& wxGridCellAttr::GetTextColour() const
 {
     if (HasTextColour())
 const wxColour& wxGridCellAttr::GetTextColour() const
 {
     if (HasTextColour())


@@ -2205,28 +2285,77 @@ void wxGridCellAttrProvider::InitData()
     m_data = new wxGridCellAttrProviderData;
 }
 
     m_data = new wxGridCellAttrProviderData;
 }
 

-wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col) const
+wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
+                                                wxGridCellAttr::wxAttrKind  kind ) const

 {
     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
     if ( m_data )
     {
 {
     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
     if ( m_data )
     {

-        // first look for the attribute of this specific cell
-        attr = m_data->m_cellAttrs.GetAttr(row, col);
-
-        if ( !attr )
+        switch(kind)

         {
         {

-            // then look for the col attr (col attributes are more common than
-            // the row ones, hence they have priority)
-            attr = m_data->m_colAttrs.GetAttr(col);
-        }
-
-        if ( !attr )
+            case (wxGridCellAttr::Any):
+                //Get cached merge attributes.
+                // Currenlty not used as no cache implemented as not mutiable
+                // attr = m_data->m_mergeAttr.GetAttr(row, col);
+                if(!attr)
+                {
+                    //Basicaly implement old version.
+                    //Also check merge cache, so we don't have to re-merge every time..
+                    wxGridCellAttr *attrcell = (wxGridCellAttr *)NULL,
+                                   *attrrow = (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)){
+                        // Two or move are non NULL
+                        attr = new wxGridCellAttr;
+                        attr->SetKind(wxGridCellAttr::Merged);
+
+                        //Order important..
+                        if(attrcell){
+                            attr->MergeWith(attrcell);
+                            attrcell->DecRef();
+                        }
+                        if(attrcol){
+                            attr->MergeWith(attrcol);
+                            attrcol->DecRef();
+                        }
+                        if(attrrow){
+                            attr->MergeWith(attrrow);
+                            attrrow->DecRef();
+                        }
+                        //store merge attr if cache implemented
+                        //attr->IncRef();
+                        //m_data->m_mergeAttr.SetAttr(attr, row, col);
+                    }
+                    else

         {
         {

-            // finally try the row attributes
+                        // one or none is non null return it or null.
+                        if(attrrow) attr = attrrow;
+                        if(attrcol) attr = attrcol;
+                        if(attrcell) attr = attrcell;
+                    }
+                }
+            break;
+            case (wxGridCellAttr::Cell):
+                attr = m_data->m_cellAttrs.GetAttr(row, col);
+            break;
+            case (wxGridCellAttr::Col):
+                 attr = m_data->m_colAttrs.GetAttr(col);
+            break;
+            case (wxGridCellAttr::Row):

             attr = m_data->m_rowAttrs.GetAttr(row);
             attr = m_data->m_rowAttrs.GetAttr(row);

+            break;
+            default:
+                // unused as yet...
+                // (wxGridCellAttr::Default):
+                // (wxGridCellAttr::Merged):
+            break;

         }
     }
         }
     }

-

     return attr;
 }
 
     return attr;
 }
 


@@ -2411,14 +2540,16 @@ int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
 {
     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
 {
     wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;

-    renderer->IncRef();
+    if (renderer)
+        renderer->IncRef();

     return renderer;
 }
 
 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
 {
     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
     return renderer;
 }
 
 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
 {
     wxGridCellEditor* editor = m_typeinfo[index]->m_editor;

-    editor->IncRef();
+    if (editor)
+        editor->IncRef();

     return editor;
 }
 
     return editor;
 }
 


@@ -2456,10 +2587,10 @@ bool wxGridTableBase::CanHaveAttributes()
     return TRUE;
 }
 
     return TRUE;
 }
 

-wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col)
+wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind  kind)

 {
     if ( m_attrProvider )
 {
     if ( m_attrProvider )

-        return m_attrProvider->GetAttr(row, col);
+        return m_attrProvider->GetAttr(row, col, kind);

     else
         return (wxGridCellAttr *)NULL;
 }
     else
         return (wxGridCellAttr *)NULL;
 }


@@ -2468,6 +2599,7 @@ void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
 {
     if ( m_attrProvider )
     {
 {
     if ( m_attrProvider )
     {

+        attr->SetKind(wxGridCellAttr::Cell);

         m_attrProvider->SetAttr(attr, row, col);
     }
     else
         m_attrProvider->SetAttr(attr, row, col);
     }
     else


@@ -2482,6 +2614,7 @@ void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
 {
     if ( m_attrProvider )
     {
 {
     if ( m_attrProvider )
     {

+        attr->SetKind(wxGridCellAttr::Row);

         m_attrProvider->SetRowAttr(attr, row);
     }
     else
         m_attrProvider->SetRowAttr(attr, row);
     }
     else


@@ -2496,6 +2629,7 @@ void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
 {
     if ( m_attrProvider )
     {
 {
     if ( m_attrProvider )
     {

+        attr->SetKind(wxGridCellAttr::Col);

         m_attrProvider->SetColAttr(attr, col);
     }
     else
         m_attrProvider->SetColAttr(attr, col);
     }
     else


@@ -3069,6 +3203,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
 
 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
 
 BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
     EVT_PAINT( wxGridRowLabelWindow::OnPaint )

+    EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel)

     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
     EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )
     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown )
     EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp )


@@ -3096,8 +3231,8 @@ void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( 0, -y );
 
     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 );

 }
 
 
 }
 
 


@@ -3107,17 +3242,23 @@ void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
 }
 
 
 }
 
 

+void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
+{
+    m_owner->GetEventHandler()->ProcessEvent(event);
+}
+
+

 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
 {
 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
 {
 }
 
 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 
 }
 
 


@@ -3128,6 +3269,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
 
 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
     EVT_PAINT( wxGridColLabelWindow::OnPaint )
 
 BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
     EVT_PAINT( wxGridColLabelWindow::OnPaint )

+    EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel)

     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
     EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )
     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown )
     EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp )


@@ -3155,8 +3297,8 @@ void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( -x, 0 );
 
     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 );

 }
 
 
 }
 
 


@@ -3165,18 +3307,23 @@ void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
     m_owner->ProcessColLabelMouseEvent( event );
 }
 
     m_owner->ProcessColLabelMouseEvent( event );
 }
 

+void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
+{
+    m_owner->GetEventHandler()->ProcessEvent(event);
+}
+

 
 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
 {
 
 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
 {
 }
 
 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 
 }
 
 


@@ -3186,6 +3333,7 @@ void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
 
 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
 
 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )

+    EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel)

     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
     EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )
     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
     EVT_PAINT( wxGridCornerLabelWindow::OnPaint)
     EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown )


@@ -3224,17 +3372,22 @@ void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
 }
 
 
 }
 
 

+void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
+{
+    m_owner->GetEventHandler()->ProcessEvent(event);
+}
+

 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
 {
 // This seems to be required for wxMotif otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
 {
 }
 
 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 
 }
 
 


@@ -3245,6 +3398,7 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxPanel )
 
 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
     EVT_PAINT( wxGridWindow::OnPaint )
 
 BEGIN_EVENT_TABLE( wxGridWindow, wxPanel )
     EVT_PAINT( wxGridWindow::OnPaint )

+    EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel)

     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
     EVT_KEY_UP( wxGridWindow::OnKeyUp )
     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
     EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
     EVT_KEY_UP( wxGridWindow::OnKeyUp )


@@ -3274,13 +3428,13 @@ void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
     wxPaintDC dc( this );
     m_owner->PrepareDC( dc );
     wxRegion reg = GetUpdateRegion();
     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 );
 #if WXGRID_DRAW_LINES
     m_owner->DrawAllGridLines( dc, reg );
 #endif
     m_owner->DrawGridSpace( dc );

-    m_owner->DrawHighlight( dc );
+    m_owner->DrawHighlight( dc , DirtyCells );

 }
 
 
 }
 
 


@@ -3297,18 +3451,22 @@ void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
     m_owner->ProcessGridCellMouseEvent( event );
 }
 
     m_owner->ProcessGridCellMouseEvent( event );
 }
 

+void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
+{
+    m_owner->GetEventHandler()->ProcessEvent(event);
+}

 
 // This seems to be required for wxMotif/wxGTK otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
 {
 
 // This seems to be required for wxMotif/wxGTK otherwise the mouse
 // cursor must be in the cell edit control to get key events
 //
 void wxGridWindow::OnKeyDown( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
 {
 }
 
 void wxGridWindow::OnKeyUp( wxKeyEvent& event )
 {

-    if ( !m_owner->ProcessEvent( event ) ) event.Skip();
+    if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();

 }
 
 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 }
 
 void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )


@@ -3381,6 +3539,7 @@ void wxGrid::Create()
     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
 
     // Set default cell attributes
     m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
 
     // Set default cell attributes

+    m_defaultCellAttr->SetKind(wxGridCellAttr::Default);

     m_defaultCellAttr->SetFont(GetFont());
     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
     m_defaultCellAttr->SetTextColour(
     m_defaultCellAttr->SetFont(GetFont());
     m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
     m_defaultCellAttr->SetTextColour(


@@ -3532,6 +3691,8 @@ 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 = 2;
+    m_cellHighlightROPenWidth = 1;

 
     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
     m_winCapture = (wxWindow *)NULL;
 
     m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;
     m_winCapture = (wxWindow *)NULL;


@@ -3648,19 +3809,44 @@ void wxGrid::CalcDimensions()
     int cw, ch;
     GetClientSize( &cw, &ch );
 
     int cw, ch;
     GetClientSize( &cw, &ch );
 

-    if ( m_numRows > 0  ||  m_numCols > 0 )
-    {
-        int right = m_numCols > 0 ? GetColRight( m_numCols-1 ) + m_extraWidth : 0;
-        int bottom = m_numRows > 0 ? GetRowBottom( m_numRows-1 ) + m_extraHeight : 0;
+    if ( m_colLabelWin->IsShown() )
+        cw -= m_rowLabelWidth;
+    if ( m_rowLabelWin->IsShown() )
+        ch -= m_colLabelHeight;

 
 

-        // TODO: restore the scroll position that we had before sizing
-        //
-        int x, y;
-        GetViewStart( &x, &y );
-        SetScrollbars( GRID_SCROLL_LINE, GRID_SCROLL_LINE,
-                       right/GRID_SCROLL_LINE, bottom/GRID_SCROLL_LINE,
-                       x, y );
+    // grid total size
+    int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
+    int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
+
+    // preserve (more or less) the previous position
+    int x, y;
+    GetViewStart( &x, &y );
+    // maybe we don't need scrollbars at all? and if we do, transform w and h
+    // from pixels into logical units
+    if ( w <= cw )
+    {
+        w = 0; x= 0;
+    }
+    else
+    {
+       w = (w + GRID_SCROLL_LINE - 1)/GRID_SCROLL_LINE;
+       if ( x >= w )
+           x = w - 1;

     }
     }

+    if ( h <= ch )
+    {
+       h = 0; y = 0;
+    }
+    else
+    {
+       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));

 }
 
 
 }
 
 


@@ -3827,13 +4013,14 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
 // ifdef'd out following patch from Paul Gammans
 #if 0
                 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
 // ifdef'd out following patch from Paul Gammans
 #if 0

+                // No need to touch column attributes, unless we

                 // removed _all_ rows, in this case, we remove
                 // all column attributes.
                 // I hate to do this here, but the
                 // needed data is not available inside UpdateAttrRows.
                 if ( !GetNumberRows() )
                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
                 // removed _all_ rows, in this case, we remove
                 // all column attributes.
                 // I hate to do this here, but the
                 // needed data is not available inside UpdateAttrRows.
                 if ( !GetNumberRows() )
                     attrProvider->UpdateAttrCols( 0, -GetNumberCols() );

-#endif                    
+#endif

             }
             if ( !GetBatchCount() )
             {
             }
             if ( !GetBatchCount() )
             {


@@ -3960,7 +4147,7 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
             if (attrProvider) {
                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
             wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
             if (attrProvider) {
                 attrProvider->UpdateAttrCols( pos, -((int)numCols) );

-// ifdef'd out following patch from Paul Gammans                
+// ifdef'd out following patch from Paul Gammans

 #if 0
                 // No need to touch row attributes, unless we
                 // removed _all_ columns, in this case, we remove
 #if 0
                 // No need to touch row attributes, unless we
                 // removed _all_ columns, in this case, we remove


@@ -3969,20 +4156,16 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
                 // needed data is not available inside UpdateAttrCols.
                 if ( !GetNumberCols() )
                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
                 // needed data is not available inside UpdateAttrCols.
                 if ( !GetNumberCols() )
                     attrProvider->UpdateAttrRows( 0, -GetNumberRows() );

-#endif                    
+#endif

             }
             if ( !GetBatchCount() )
             {
                 CalcDimensions();
                 m_colLabelWin->Refresh();
             }
             }
             if ( !GetBatchCount() )
             {
                 CalcDimensions();
                 m_colLabelWin->Refresh();
             }

-            return TRUE;

         }
         }

-#if 0
-// There is no path to this code !!!!!!
-       result = TRUE;
+        result = TRUE;

         break;
         break;

-#endif

     }
 
     if (result && !GetBatchCount() )
     }
 
     if (result && !GetBatchCount() )


@@ -3991,13 +4174,13 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
 }
 
 
 }
 
 

-void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )

 {
     wxRegionIterator iter( reg );
     wxRect r;
 
 {
     wxRegionIterator iter( reg );
     wxRect r;
 

-    m_rowLabelsExposed.Empty();
-
+    wxArrayInt  rowlabels;           
+        

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


@@ -4032,20 +4215,22 @@ void wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
             if ( GetRowTop(row) > bottom )
                 break;
 
             if ( GetRowTop(row) > bottom )
                 break;
 

-            m_rowLabelsExposed.Add( row );
+            rowlabels.Add( row );

         }
 
         iter++ ;
     }
         }
 
         iter++ ;
     }

+
+    return rowlabels;

 }
 
 
 }
 
 

-void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )

 {
     wxRegionIterator iter( reg );
     wxRect r;
 
 {
     wxRegionIterator iter( reg );
     wxRect r;
 

-    m_colLabelsExposed.Empty();
+    wxArrayInt colLabels;

 
     int left, right;
     while ( iter )
 
     int left, right;
     while ( iter )


@@ -4081,22 +4266,21 @@ void wxGrid::CalcColLabelsExposed( const wxRegion& reg )
             if ( GetColLeft(col) > right )
                 break;
 
             if ( GetColLeft(col) > right )
                 break;
 

-            m_colLabelsExposed.Add( col );
+            colLabels.Add( col );

         }
 
         iter++ ;
     }
         }
 
         iter++ ;
     }

+    return colLabels;

 }
 
 
 }
 
 

-void wxGrid::CalcCellsExposed( const wxRegion& reg )
+wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )

 {
     wxRegionIterator iter( reg );
     wxRect r;
 
 {
     wxRegionIterator iter( reg );
     wxRect r;
 

-    m_cellsExposed.Empty();
-    m_rowsExposed.Empty();
-    m_colsExposed.Empty();
+    wxGridCellCoordsArray  cellsExposed;

 
     int left, top, right, bottom;
     while ( iter )
 
     int left, top, right, bottom;
     while ( iter )


@@ -4133,7 +4317,6 @@ void wxGrid::CalcCellsExposed( const wxRegion& reg )
             if ( GetRowTop(row) > bottom )
                 break;
 
             if ( GetRowTop(row) > bottom )
                 break;
 

-            m_rowsExposed.Add( row );

 
             for ( col = 0;  col < m_numCols;  col++ )
             {
 
             for ( col = 0;  col < m_numCols;  col++ )
             {


@@ -4143,14 +4326,14 @@ void wxGrid::CalcCellsExposed( const wxRegion& reg )
                 if ( GetColLeft(col) > right )
                     break;
 
                 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++;
     }
             }
         }
 
         iter++;
     }

+
+    return cellsExposed;

 }
 
 
 }
 
 


@@ -4582,7 +4765,9 @@ void wxGrid::ChangeCursorMode(CursorMode mode,
                cursorModes[m_cursorMode], cursorModes[mode]);
 #endif // __WXDEBUG__
 
                cursorModes[m_cursorMode], cursorModes[mode]);
 #endif // __WXDEBUG__
 

-    if ( mode == m_cursorMode )
+    if ( mode == m_cursorMode &&
+         win == m_winCapture &&
+         captureMouse == (m_winCapture != NULL))

         return;
 
     if ( !win )
         return;
 
     if ( !win )


@@ -5253,13 +5438,12 @@ bool wxGrid::SendEvent( const wxEventType type,
                                  type,
                                  this,
                                  rowOrCol,
                                  type,
                                  this,
                                  rowOrCol,

-                                 mouseEv.GetX() + GetColLabelSize(),
-                                 mouseEv.GetY() + GetRowLabelSize(),
+                                 mouseEv.GetX() + GetRowLabelSize(),
+                                 mouseEv.GetY() + GetColLabelSize(),

                                  mouseEv.ControlDown(),
                                  mouseEv.ShiftDown(),
                                  mouseEv.AltDown(),
                                  mouseEv.MetaDown() );
                                  mouseEv.ControlDown(),
                                  mouseEv.ShiftDown(),
                                  mouseEv.AltDown(),
                                  mouseEv.MetaDown() );

-

         return GetEventHandler()->ProcessEvent(gridEvt);
     }
     else if ( type == wxEVT_GRID_RANGE_SELECT )
         return GetEventHandler()->ProcessEvent(gridEvt);
     }
     else if ( type == wxEVT_GRID_RANGE_SELECT )


@@ -5284,14 +5468,13 @@ bool wxGrid::SendEvent( const wxEventType type,
                              type,
                              this,
                              row, col,
                              type,
                              this,
                              row, col,

-                             mouseEv.GetX() + GetColLabelSize(),
-                             mouseEv.GetY() + GetRowLabelSize(),
+                             mouseEv.GetX() + GetRowLabelSize(),
+                             mouseEv.GetY() + GetColLabelSize(),

                              FALSE,
                              mouseEv.ControlDown(),
                              mouseEv.ShiftDown(),
                              mouseEv.AltDown(),
                              mouseEv.MetaDown() );
                              FALSE,
                              mouseEv.ControlDown(),
                              mouseEv.ShiftDown(),
                              mouseEv.AltDown(),
                              mouseEv.MetaDown() );

-

         return GetEventHandler()->ProcessEvent(gridEvt);
     }
 }
         return GetEventHandler()->ProcessEvent(gridEvt);
     }
 }


@@ -5412,6 +5595,7 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 break;
 
             case WXK_RETURN:
                 break;
 
             case WXK_RETURN:

+            case WXK_NUMPAD_ENTER:

                 if ( event.ControlDown() )
                 {
                     event.Skip();  // to let the edit control have the return
                 if ( event.ControlDown() )
                 {
                     event.Skip();  // to let the edit control have the return


@@ -5595,10 +5779,10 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         HideCellEditControl();
         DisableCellEditControl();
 
         HideCellEditControl();
         DisableCellEditControl();
 

-        if ( IsVisible( m_currentCellCoords, FALSE ) )  // zzz
+        if ( IsVisible( m_currentCellCoords, FALSE ) )

         {
             wxRect r;
         {
             wxRect r;

-            r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
+            r = BlockToDeviceRect(m_currentCellCoords, coords);

             if ( !m_gridLinesEnabled )
             {
                 r.x--;
             if ( !m_gridLinesEnabled )
             {
                 r.x--;


@@ -5607,12 +5791,12 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
                 r.height++;
             }
 
                 r.height++;
             }
 

-            CalcCellsExposed( r );
-    
+             wxGridCellCoordsArray cells = CalcCellsExposed( r );
+

             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;
             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;

-
-            DrawGridCellArea(dc);
+            
+            DrawGridCellArea(dc,cells);

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


@@ -5759,7 +5943,6 @@ void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCo
     // (old comment from when this was the body of SelectBlock)
 }
 
     // (old comment from when this was the body of SelectBlock)
 }
 

-

 //
 // ------ functions to get/send data (see also public functions)
 //
 //
 // ------ functions to get/send data (see also public functions)
 //


@@ -5804,16 +5987,16 @@ bool wxGrid::SetModelValues()
 // exposed cells (usually set from the update region by
 // CalcExposedCells)
 //
 // 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;
 {
     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++ )
     {
 
     for ( i = 0;  i < numCells;  i++ )
     {

-        DrawCell( dc, m_cellsExposed[i] );
+        DrawCell( dc, cells[i] );

     }
 }
 
     }
 }
 


@@ -5903,10 +6086,27 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
     // hmmm... what could we do here to show that the cell is disabled?
     // for now, I just draw a thinner border than for the other ones, but
     // it doesn't look really good
     // hmmm... what could we do here to show that the cell is disabled?
     // for now, I just draw a thinner border than for the other ones, but
     // it doesn't look really good

-    dc.SetPen(wxPen(m_cellHighlightColour, attr->IsReadOnly() ? 1 : 3, wxSOLID));
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);

 
 

-    dc.DrawRectangle(rect);
+    int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
+
+    if (penWidth > 0) {
+
+        // The center of th drawn line is where the position/width/height of
+        // the rectangle is actually at, (on wxMSW atr least,) so we will
+        // reduce the size of the rectangle to compensate for the thickness of
+        // the line.  If this is too strange on non wxMSW platforms then
+        // please #ifdef this appropriately.
+        rect.x += penWidth/2;
+        rect.y += penWidth/2;
+        rect.width -= penWidth-1;
+        rect.height -= penWidth-1;
+
+
+        // Now draw the rectangle
+        dc.SetPen(wxPen(m_cellHighlightColour, penWidth, wxSOLID));
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.DrawRectangle(rect);
+    }

 
 #if 0
         // VZ: my experiments with 3d borders...
 
 #if 0
         // VZ: my experiments with 3d borders...


@@ -5951,7 +6151,7 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
                  GetColRight(col), GetRowBottom(row) );
 }
 
                  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
 {
     // This if block was previously in wxGrid::OnPaint but that doesn't
     // seem to get called under wxGTK - MB


@@ -5970,10 +6170,10 @@ void wxGrid::DrawHighlight(wxDC& dc)
 
     // if the active cell was repainted, repaint its highlight too because it
     // might have been damaged by the grid lines
 
     // 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++ )
     {
     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);
         {
             wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
             DrawCellHighlight(dc, attr);


@@ -5988,7 +6188,7 @@ void wxGrid::DrawHighlight(wxDC& dc)
 // This is used to redraw all grid lines e.g. when the grid line colour
 // has been changed
 //
 // This is used to redraw all grid lines e.g. when the grid line colour
 // has been changed
 //

-void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
+void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )

 {
     if ( !m_gridLinesEnabled ||
          !m_numRows ||
 {
     if ( !m_gridLinesEnabled ||
          !m_numRows ||


@@ -6065,16 +6265,16 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED_GTK(reg) )
 }
 
 
 }
 
 

-void wxGrid::DrawRowLabels( wxDC& dc )
+void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)

 {
     if ( !m_numRows ) return;
 
     size_t i;
 {
     if ( !m_numRows ) return;
 
     size_t i;

-    size_t numLabels = m_rowLabelsExposed.GetCount();
+    size_t numLabels = rows.GetCount();

 
     for ( i = 0;  i < numLabels;  i++ )
     {
 
     for ( i = 0;  i < numLabels;  i++ )
     {

-        DrawRowLabel( dc, m_rowLabelsExposed[i] );
+        DrawRowLabel( dc, rows[i] );

     }
 }
 
     }
 }
 


@@ -6113,16 +6313,16 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
 }
 
 
 }
 
 

-void wxGrid::DrawColLabels( wxDC& dc )
+void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )

 {
     if ( !m_numCols ) return;
 
     size_t i;
 {
     if ( !m_numCols ) return;
 
     size_t i;

-    size_t numLabels = m_colLabelsExposed.GetCount();
+    size_t numLabels = cols.GetCount();

 
     for ( i = 0;  i < numLabels;  i++ )
     {
 
     for ( i = 0;  i < numLabels;  i++ )
     {

-        DrawColLabel( dc, m_colLabelsExposed[i] );
+        DrawColLabel( dc, cols[i] );

     }
 }
 
     }
 }
 


@@ -6165,19 +6365,36 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
 }
 
     DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign );
 }
 

-

 void wxGrid::DrawTextRectangle( wxDC& dc,
                                 const wxString& value,
                                 const wxRect& rect,
                                 int horizAlign,
                                 int vertAlign )
 {
 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 );
     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 );
     if ( lines.GetCount() )
     {
         GetTextBoxSize( dc, lines, &textWidth, &textHeight );


@@ -6262,7 +6479,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
 
 
 void wxGrid::GetTextBoxSize( wxDC& dc,
 
 
 void wxGrid::GetTextBoxSize( wxDC& dc,

-                             wxArrayString& lines,
+                             const wxArrayString& lines,

                              long *width, long *height )
 {
     long w = 0;
                              long *width, long *height )
 {
     long w = 0;


@@ -6417,7 +6634,7 @@ void wxGrid::ShowCellEditControl()
     {
         if ( !IsVisible( m_currentCellCoords ) )
         {
     {
         if ( !IsVisible( m_currentCellCoords ) )
         {

-            m_cellEditCtrlEnabled = false;        
+            m_cellEditCtrlEnabled = FALSE;

             return;
         }
         else
             return;
         }
         else


@@ -6451,6 +6668,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 );


@@ -7337,14 +7562,14 @@ void wxGrid::SetRowLabelAlignment( int horiz, int vert )
         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
     }
         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
     }

-    
+

     switch ( vert )
     {
         case wxTOP:    vert = wxALIGN_TOP;    break;
         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
         case wxCENTRE: vert = wxALIGN_CENTRE; break;
     }
     switch ( vert )
     {
         case wxTOP:    vert = wxALIGN_TOP;    break;
         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
         case wxCENTRE: vert = wxALIGN_CENTRE; break;
     }

-    
+

     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
     {
         m_rowLabelHorizAlign = horiz;
     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
     {
         m_rowLabelHorizAlign = horiz;


@@ -7370,14 +7595,14 @@ void wxGrid::SetColLabelAlignment( int horiz, int vert )
         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
     }
         case wxRIGHT:  horiz = wxALIGN_RIGHT; break;
         case wxCENTRE: horiz = wxALIGN_CENTRE; break;
     }

-    
+

     switch ( vert )
     {
         case wxTOP:    vert = wxALIGN_TOP;    break;
         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
         case wxCENTRE: vert = wxALIGN_CENTRE; break;
     }
     switch ( vert )
     {
         case wxTOP:    vert = wxALIGN_TOP;    break;
         case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
         case wxCENTRE: vert = wxALIGN_CENTRE; break;
     }

-    
+

     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
     {
         m_colLabelHorizAlign = horiz;
     if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
     {
         m_colLabelHorizAlign = horiz;


@@ -7459,6 +7684,38 @@ void wxGrid::SetCellHighlightColour( const wxColour& colour )
     }
 }
 
     }
 }
 

+void wxGrid::SetCellHighlightPenWidth(int width)
+{
+    if (m_cellHighlightPenWidth != width) {
+        m_cellHighlightPenWidth = width;
+
+        // Just redrawing the cell highlight is not enough since that won't
+        // make any visible change if the the thickness is getting smaller.
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+        if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+            return;
+        wxRect rect = CellToRect(row, col);
+        m_gridWin->Refresh(TRUE, &rect);
+    }
+}
+
+void wxGrid::SetCellHighlightROPenWidth(int width)
+{
+    if (m_cellHighlightROPenWidth != width) {
+        m_cellHighlightROPenWidth = width;
+
+        // Just redrawing the cell highlight is not enough since that won't
+        // make any visible change if the the thickness is getting smaller.
+        int row = m_currentCellCoords.GetRow();
+        int col = m_currentCellCoords.GetCol();
+        if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+            return;
+        wxRect rect = CellToRect(row, col);
+        m_gridWin->Refresh(TRUE, &rect);
+    }
+}
+

 void wxGrid::EnableGridLines( bool enable )
 {
     if ( enable != m_gridLinesEnabled )
 void wxGrid::EnableGridLines( bool enable )
 {
     if ( enable != m_gridLinesEnabled )


@@ -7662,6 +7919,7 @@ void wxGrid::ClearAttrCache()
     if ( m_attrCache.row != -1 )
     {
         wxSafeDecRef(m_attrCache.attr);
     if ( m_attrCache.row != -1 )
     {
         wxSafeDecRef(m_attrCache.attr);

+        m_attrCache.attr = NULL;

         m_attrCache.row = -1;
     }
 }
         m_attrCache.row = -1;
     }
 }


@@ -7704,7 +7962,7 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
     wxGridCellAttr *attr;
     if ( !LookupAttr(row, col, &attr) )
     {
     wxGridCellAttr *attr;
     if ( !LookupAttr(row, col, &attr) )
     {

-        attr = m_table ? m_table->GetAttr(row, col) : (wxGridCellAttr *)NULL;
+        attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any) : (wxGridCellAttr *)NULL;

         CacheAttr(row, col, attr);
     }
     if (attr)
         CacheAttr(row, col, attr);
     }
     if (attr)


@@ -7722,25 +7980,19 @@ wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
 
 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
 {
 
 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
 {

-    wxGridCellAttr *attr;
-    if ( !LookupAttr(row, col, &attr) || !attr )
-    {
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;

         wxASSERT_MSG( m_table,
                       _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
 
         wxASSERT_MSG( m_table,
                       _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
 

-        attr = m_table->GetAttr(row, col);
+    attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell );

         if ( !attr )
         {
             attr = new wxGridCellAttr;
 
             // artificially inc the ref count to match DecRef() in caller
             attr->IncRef();
         if ( !attr )
         {
             attr = new wxGridCellAttr;
 
             // artificially inc the ref count to match DecRef() in caller
             attr->IncRef();

-

             m_table->SetAttr(attr, row, col);
         }
             m_table->SetAttr(attr, row, col);
         }

-
-        CacheAttr(row, col, attr);
-    }

     attr->SetDefAttr(m_defaultCellAttr);
     return attr;
 }
     attr->SetDefAttr(m_defaultCellAttr);
     return attr;
 }


@@ -7772,11 +8024,16 @@ void wxGrid::SetColFormatFloat(int col, int width, int precision)
 
 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
 {
 
 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
 {

-    wxGridCellAttr *attr = new wxGridCellAttr;
+    wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
+
+    attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
+    if(!attr)
+        attr = new wxGridCellAttr;

     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
     attr->SetRenderer(renderer);
 
     SetColAttr(col, attr);
     wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
     attr->SetRenderer(renderer);
 
     SetColAttr(col, attr);

+

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


@@ -7788,6 +8045,7 @@ void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
     if ( CanHaveAttributes() )
     {
         m_table->SetRowAttr(attr, row);
     if ( CanHaveAttributes() )
     {
         m_table->SetRowAttr(attr, row);

+        ClearAttrCache();

     }
     else
     {
     }
     else
     {


@@ -7800,6 +8058,7 @@ void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
     if ( CanHaveAttributes() )
     {
         m_table->SetColAttr(attr, col);
     if ( CanHaveAttributes() )
     {
         m_table->SetColAttr(attr, col);

+        ClearAttrCache();

     }
     else
     {
     }
     else
     {


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

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

     }
 }
 
     }
 }
 


@@ -7982,7 +8241,8 @@ void wxGrid::SetRowSize( int row, int height )
     {
         m_rowBottoms[i] += diff;
     }
     {
         m_rowBottoms[i] += diff;
     }

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

 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 }
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )


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

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

     }
 }
 
     }
 }
 


@@ -8018,7 +8278,8 @@ void wxGrid::SetColSize( int col, int width )
     {
         m_colRights[i] += diff;
     }
     {
         m_colRights[i] += diff;
     }

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

 }
 
 
 }
 
 


@@ -8093,7 +8354,7 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
     if ( column )
         dc.GetTextExtent( GetColLabelValue(col), &w, &h );
     else
     if ( column )
         dc.GetTextExtent( GetColLabelValue(col), &w, &h );
     else

-        dc.GetTextExtent( GetRowLabelValue(col), &w, &h );
+        dc.GetTextExtent( GetRowLabelValue(row), &w, &h );

 
     extent = column ? w : h;
     if ( extent > extentMax )
 
     extent = column ? w : h;
     if ( extent > extentMax )


@@ -8120,11 +8381,34 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
         }
     }
 
         }
     }
 

-    if ( column )
+    if ( column ){

         SetColSize(col, extentMax);
         SetColSize(col, extentMax);

-    else
+        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{

         SetRowSize(row, extentMax);
         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;
+            rect.height = ch - rect.y;
+           m_rowLabelWin->Refresh( TRUE, &rect );
+       }
+    }

     if ( setAsMin )
     {
         if ( column )
     if ( setAsMin )
     {
         if ( column )


@@ -8138,6 +8422,8 @@ int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
 {
     int width = m_rowLabelWidth;
 
 {
     int width = m_rowLabelWidth;
 

+    if ( !calcOnly )
+        BeginBatch();

     for ( int col = 0; col < m_numCols; col++ )
     {
         if ( !calcOnly )
     for ( int col = 0; col < m_numCols; col++ )
     {
         if ( !calcOnly )


@@ -8147,7 +8433,8 @@ int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
 
         width += GetColWidth(col);
     }
 
         width += GetColWidth(col);
     }

-
+    if ( !calcOnly )
+        EndBatch();

     return width;
 }
 
     return width;
 }
 


@@ -8155,6 +8442,8 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
 {
     int height = m_colLabelHeight;
 
 {
     int height = m_colLabelHeight;
 

+    if ( !calcOnly )
+        BeginBatch();

     for ( int row = 0; row < m_numRows; row++ )
     {
         if ( !calcOnly )
     for ( int row = 0; row < m_numRows; row++ )
     {
         if ( !calcOnly )


@@ -8164,14 +8453,15 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
 
         height += GetRowHeight(row);
     }
 
         height += GetRowHeight(row);
     }

-
+    if ( !calcOnly )
+        EndBatch();

     return height;
 }
 
 void wxGrid::AutoSize()
 {
     // set the size too
     return height;
 }
 
 void wxGrid::AutoSize()
 {
     // set the size too

-    SetSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
+    SetClientSize(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));

 }
 
 wxSize wxGrid::DoGetBestSize() const
 }
 
 wxSize wxGrid::DoGetBestSize() const


@@ -8246,20 +8536,67 @@ void wxGrid::SelectCol( int col, bool addToSelected )
 }
 
 
 }
 
 

-void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol, 
+void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,

                           bool addToSelected )
 {
     if ( IsSelection() && !addToSelected )
         ClearSelection();
 
                           bool addToSelected )
 {
     if ( IsSelection() && !addToSelected )
         ClearSelection();
 

-    m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol, 
-                              FALSE, addToSelected );    
+    m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
+                              FALSE, addToSelected );

 }
 
 
 void wxGrid::SelectAll()
 {
 }
 
 
 void wxGrid::SelectAll()
 {

-    m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+    if ( m_numRows > 0 && m_numCols > 0 )
+        m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+}
+
+//
+// ------ Cell, row and col deselection
+//
+
+void wxGrid::DeselectRow( int row )
+{
+    if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
+    {
+        if ( m_selection->IsInSelection(row, 0 ) )
+            m_selection->ToggleCellSelection( row, 0);
+    }
+    else
+    {
+        int nCols = GetNumberCols();
+        for ( int i = 0; i < nCols ; i++ )
+        {
+            if ( m_selection->IsInSelection(row, i ) )
+                m_selection->ToggleCellSelection( row, i);
+        }
+    }
+}
+
+void wxGrid::DeselectCol( int col )
+{
+    if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
+    {
+        if ( m_selection->IsInSelection(0, col ) )
+            m_selection->ToggleCellSelection( 0, col);
+    }
+    else
+    {
+        int nRows = GetNumberRows();
+        for ( int i = 0; i < nRows ; i++ )
+        {
+            if ( m_selection->IsInSelection(i, col ) )
+                m_selection->ToggleCellSelection(i, col);
+        }
+    }
+}
+
+void wxGrid::DeselectCell( int row, int col )
+{
+    if ( m_selection->IsInSelection(row, col) )
+        m_selection->ToggleCellSelection(row, col);

 }
 
 bool wxGrid::IsSelection()
 }
 
 bool wxGrid::IsSelection()


@@ -8341,7 +8678,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,


@@ -8362,7 +8699,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,


@@ -8381,7 +8718,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,


@@ -8402,4 +8739,18 @@ wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObjec
 }
 
 
 }
 
 

+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 // ifndef wxUSE_NEW_GRID
 #endif // ifndef wxUSE_NEW_GRID