stopwatch.h needed for wxGetLocalTimeMillis

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

diff --git a/src/generic/gridsel.cpp b/src/generic/gridsel.cpp
index 99d908201419ad776f5f90257ae190ea8b5982f6..317b5038e175de9d4653085ebbd3e3184747fd11 100644 (file)
--- a/src/generic/gridsel.cpp
+++ b/src/generic/gridsel.cpp
@@ -4,7 +4,7 @@
 // Author:      Stefan Neis
 // Modified by:
 // Created:     20/02/1999
 // Author:      Stefan Neis
 // Modified by:
 // Created:     20/02/1999

-// RCS-ID:      $$
+// RCS-ID:      $Id$

 // Copyright:   (c) Stefan Neis (Stefan.Neis@t-online.de)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Stefan Neis (Stefan.Neis@t-online.de)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "gridsel.h"
 #endif
 
     #pragma implementation "gridsel.h"
 #endif
 


@@ -30,7 +30,7 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#if defined(wxUSE_NEW_GRID) && (wxUSE_NEW_GRID)
+#if wxUSE_GRID

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


@@ -165,7 +165,7 @@ void wxGridSelection::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
                     m_blockSelectionBottomRight.RemoveAt(n);
                     SelectBlock( topRow, 0,
                                  bottomRow, m_grid->GetNumberCols() - 1,
                     m_blockSelectionBottomRight.RemoveAt(n);
                     SelectBlock( topRow, 0,
                                  bottomRow, m_grid->GetNumberCols() - 1,

-                                 0, FALSE );
+                                 false, false, false, false, false );

                 }
             }
             else // selmode == wxGridSelectColumns)
                 }
             }
             else // selmode == wxGridSelectColumns)


@@ -176,7 +176,7 @@ void wxGridSelection::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
                     m_blockSelectionBottomRight.RemoveAt(n);
                     SelectBlock( 0, leftCol,
                                  m_grid->GetNumberRows() - 1, rightCol,
                     m_blockSelectionBottomRight.RemoveAt(n);
                     SelectBlock( 0, leftCol,
                                  m_grid->GetNumberRows() - 1, rightCol,

-                                 0, FALSE );
+                                 false, false, false, false, false );

                 }
             }
         }
                 }
             }
         }


@@ -184,7 +184,9 @@ void wxGridSelection::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
     }
 }
 
     }
 }
 

-void wxGridSelection::SelectRow( int row, bool addToSelected )
+void wxGridSelection::SelectRow( int row,
+                                 bool ControlDown,  bool ShiftDown,
+                                 bool AltDown, bool MetaDown )

 {
     if ( m_selectionMode == wxGrid::wxGridSelectColumns )
         return;
 {
     if ( m_selectionMode == wxGrid::wxGridSelectColumns )
         return;


@@ -220,7 +222,7 @@ void wxGridSelection::SelectRow( int row, bool addToSelected )
             m_blockSelectionTopLeft.RemoveAt(n);
             m_blockSelectionBottomRight.RemoveAt(n);
             n--; count--;
             m_blockSelectionTopLeft.RemoveAt(n);
             m_blockSelectionBottomRight.RemoveAt(n);
             n--; count--;

-        }       
+        }

         else if ( coords1.GetCol() == 0  &&
                   coords2.GetCol() == m_grid->GetNumberCols() - 1 )
         {
         else if ( coords1.GetCol() == 0  &&
                   coords2.GetCol() == m_grid->GetNumberCols() - 1 )
         {


@@ -237,7 +239,7 @@ void wxGridSelection::SelectRow( int row, bool addToSelected )
             {
                 coords2.SetRow(row);
                 done = true;
             {
                 coords2.SetRow(row);
                 done = true;

-            }           
+            }

         }
     }
 
         }
     }
 


@@ -257,22 +259,29 @@ void wxGridSelection::SelectRow( int row, bool addToSelected )
     }
 
     // Update View:
     }
 
     // Update View:

-    wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
-                                          wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );

     if ( !m_grid->GetBatchCount() )
     if ( !m_grid->GetBatchCount() )

-        ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+    {
+        wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
+                                              wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+        ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+    }

 
     // Send Event
     wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                     wxEVT_GRID_RANGE_SELECT,
                                     m_grid,
                                     wxGridCellCoords( row, 0 ),
 
     // Send Event
     wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                     wxEVT_GRID_RANGE_SELECT,
                                     m_grid,
                                     wxGridCellCoords( row, 0 ),

-                                    wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+                                    wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
+                                    true,
+                                    ControlDown,  ShiftDown,
+                                    AltDown, MetaDown );

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

-void wxGridSelection::SelectCol( int col, bool addToSelected )
+void wxGridSelection::SelectCol( int col,
+                                 bool ControlDown,  bool ShiftDown,
+                                 bool AltDown, bool MetaDown )

 {
     if ( m_selectionMode == wxGrid::wxGridSelectRows )
         return;
 {
     if ( m_selectionMode == wxGrid::wxGridSelectRows )
         return;


@@ -325,7 +334,7 @@ void wxGridSelection::SelectCol( int col, bool addToSelected )
             {
                 coords2.SetCol(col);
                 done = true;
             {
                 coords2.SetCol(col);
                 done = true;

-            }           
+            }

         }
     }
 
         }
     }
 


@@ -345,24 +354,31 @@ void wxGridSelection::SelectCol( int col, bool addToSelected )
     }
 
     // Update View:
     }
 
     // Update View:

-    wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
-                                          wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );

     if ( !m_grid->GetBatchCount() )
     if ( !m_grid->GetBatchCount() )

-        ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+    {
+        wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
+                                              wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+        ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+    }

 
     // Send Event
     wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                     wxEVT_GRID_RANGE_SELECT,
                                     m_grid,
                                     wxGridCellCoords( 0, col ),
 
     // Send Event
     wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                     wxEVT_GRID_RANGE_SELECT,
                                     m_grid,
                                     wxGridCellCoords( 0, col ),

-                                    wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+                                    wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
+                                    true,
+                                    ControlDown,  ShiftDown,
+                                    AltDown, MetaDown );

 
     m_grid->GetEventHandler()->ProcessEvent(gridEvt);
 }
 
 void wxGridSelection::SelectBlock( int topRow, int leftCol,
                                    int bottomRow, int rightCol,
 
     m_grid->GetEventHandler()->ProcessEvent(gridEvt);
 }
 
 void wxGridSelection::SelectBlock( int topRow, int leftCol,
                                    int bottomRow, int rightCol,

-                                   wxMouseEvent* mouseEv, bool sendEvent )
+                                   bool ControlDown, bool ShiftDown,
+                                   bool AltDown, bool MetaDown,
+                                   bool sendEvent )

 {
     // Fix the coordinates of the block if needed.
     if ( m_selectionMode == wxGrid::wxGridSelectRows )
 {
     // Fix the coordinates of the block if needed.
     if ( m_selectionMode == wxGrid::wxGridSelectRows )


@@ -390,8 +406,13 @@ void wxGridSelection::SelectBlock( int topRow, int leftCol,
     }
 
     // Handle single cell selection in SelectCell.
     }
 
     // Handle single cell selection in SelectCell.

-    if ( topRow == bottomRow && leftCol == rightCol )
-        SelectCell( topRow, leftCol, sendEvent );
+    // (MB: added check for selection mode here to prevent
+    //  crashes if, for example, we are select rows and the
+    //  grid only has 1 col)
+    if ( m_selectionMode == wxGrid::wxGridSelectCells &&
+         topRow == bottomRow && leftCol == rightCol )
+        SelectCell( topRow, leftCol, ControlDown,  ShiftDown,
+                    AltDown, MetaDown, sendEvent );

 
     size_t count, n;
     // Remove single cells contained in newly selected block.
 
     size_t count, n;
     // Remove single cells contained in newly selected block.


@@ -460,7 +481,7 @@ void wxGridSelection::SelectBlock( int topRow, int leftCol,
         for ( n = 0; n < count; n++ )
         {
             switch ( BlockContain( 0, m_colSelection[n],
         for ( n = 0; n < count; n++ )
         {
             switch ( BlockContain( 0, m_colSelection[n],

-                                   m_grid->GetNumberRows()-1, m_colSelection[n], 
+                                   m_grid->GetNumberRows()-1, m_colSelection[n],

                                    topRow, leftCol, bottomRow, rightCol ) )
             {
               case 1:
                                    topRow, leftCol, bottomRow, rightCol ) )
             {
               case 1:


@@ -477,50 +498,43 @@ void wxGridSelection::SelectBlock( int topRow, int leftCol,
     m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
 
     // Update View:
     m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
 
     // Update View:

-    wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
-                                          wxGridCellCoords( bottomRow, rightCol ) );

     if ( !m_grid->GetBatchCount() )
     if ( !m_grid->GetBatchCount() )

-        ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+    {
+        wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
+                                              wxGridCellCoords( bottomRow, rightCol ) );
+        ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+    }

 
     // Send Event, if not disabled.
     if ( sendEvent )
     {
 
     // Send Event, if not disabled.
     if ( sendEvent )
     {

-        if ( mouseEv == 0)
-        {
-            wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
-                                            wxEVT_GRID_RANGE_SELECT,
-                                            m_grid,
-                                            wxGridCellCoords( topRow, leftCol ),
-                                            wxGridCellCoords( bottomRow, rightCol ) );
-            m_grid->GetEventHandler()->ProcessEvent(gridEvt);
-        }
-        else        
-        {
-            wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
-                                            wxEVT_GRID_RANGE_SELECT,
-                                            m_grid,
-                                            wxGridCellCoords( topRow, leftCol ),
-                                            wxGridCellCoords( bottomRow, rightCol ),
-                                            TRUE,
-                                            mouseEv->ControlDown(),
-                                            mouseEv->ShiftDown(),
-                                            mouseEv->AltDown(),
-                                            mouseEv->MetaDown() );
-            m_grid->GetEventHandler()->ProcessEvent(gridEvt);
-        }
+        wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+                                        wxEVT_GRID_RANGE_SELECT,
+                                        m_grid,
+                                        wxGridCellCoords( topRow, leftCol ),
+                                        wxGridCellCoords( bottomRow, rightCol ),
+                                        true,
+                                        ControlDown, ShiftDown,
+                                        AltDown, MetaDown );
+        m_grid->GetEventHandler()->ProcessEvent(gridEvt);

     }
 }
 
     }
 }
 

-void wxGridSelection::SelectCell( int row, int col, bool sendEvent )
+void wxGridSelection::SelectCell( int row, int col,
+                                  bool ControlDown, bool ShiftDown,
+                                  bool AltDown, bool MetaDown,
+                                  bool sendEvent )

 {
     if ( m_selectionMode == wxGrid::wxGridSelectRows )
     {
 {
     if ( m_selectionMode == wxGrid::wxGridSelectRows )
     {

-        SelectBlock(row, 0, row, m_grid->GetNumberCols() - 1 );
+        SelectBlock(row, 0, row, m_grid->GetNumberCols() - 1,
+                    ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);

         return;
     }
     else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
     {
         return;
     }
     else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
     {

-        SelectBlock(0, col, m_grid->GetNumberRows() - 1, col );
+        SelectBlock(0, col, m_grid->GetNumberRows() - 1, col,
+                    ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);

         return;
     }
     else if ( IsInSelection ( row, col ) )
         return;
     }
     else if ( IsInSelection ( row, col ) )


@@ -528,25 +542,37 @@ void wxGridSelection::SelectCell( int row, int col, bool sendEvent )
     m_cellSelection.Add( wxGridCellCoords( row, col ) );
 
     // Update View:
     m_cellSelection.Add( wxGridCellCoords( row, col ) );
 
     // Update View:

-    wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
-                                          wxGridCellCoords( row, col ) );

     if ( !m_grid->GetBatchCount() )
     if ( !m_grid->GetBatchCount() )

-        ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+    {
+        wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
+                                              wxGridCellCoords( row, col ) );
+        ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+    }

 
     // Send event
 
     // Send event

-    wxGridEvent gridEvt( m_grid->GetId(),
-                         wxEVT_GRID_SELECT_CELL,
-                         m_grid,
-                         row, col );
-    m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+    if (sendEvent)
+    {
+        wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+                                        wxEVT_GRID_RANGE_SELECT,
+                                        m_grid,
+                                        wxGridCellCoords( row, col ),
+                                        wxGridCellCoords( row, col ),
+                                        true,
+                                        ControlDown, ShiftDown,
+                                        AltDown, MetaDown);
+        m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+    }

 }
 
 }
 

-void wxGridSelection::ToggleCellSelection( int row, int col)
+void wxGridSelection::ToggleCellSelection( int row, int col,
+                                           bool ControlDown, bool ShiftDown,
+                                           bool AltDown, bool MetaDown )

 {
     // if the cell is not selected, select it
     if ( !IsInSelection ( row, col ) )
     {
 {
     // if the cell is not selected, select it
     if ( !IsInSelection ( row, col ) )
     {

-        SelectCell( row, col );
+        SelectCell( row, col, ControlDown, ShiftDown,
+                    AltDown, MetaDown );

         return;
     }
 
         return;
     }
 


@@ -567,21 +593,25 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
             wxGridCellCoords& coords = m_cellSelection[n];
             if ( row == coords.GetRow() && col == coords.GetCol() )
             {
             wxGridCellCoords& coords = m_cellSelection[n];
             if ( row == coords.GetRow() && col == coords.GetCol() )
             {

-                wxRect r;
-                r = m_grid->BlockToDeviceRect( m_cellSelection[n],
-                                               m_cellSelection[n] );
+                wxGridCellCoords coords = m_cellSelection[n];

                 m_cellSelection.RemoveAt(n);
                 m_cellSelection.RemoveAt(n);

-                n--; count--;

                 if ( !m_grid->GetBatchCount() )
                 if ( !m_grid->GetBatchCount() )

-                    ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
-                return;
+                {
+                    wxRect r = m_grid->BlockToDeviceRect( coords, coords );
+                    ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+                }

 
                 // Send event
 
                 // Send event

-                wxGridEvent gridEvt( m_grid->GetId(),
-                                     wxEVT_GRID_SELECT_CELL,
-                                     m_grid,
-                                     row, col, -1, -1, FALSE );
+                wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+                                                wxEVT_GRID_RANGE_SELECT,
+                                                m_grid,
+                                                wxGridCellCoords( row, col ),
+                                                wxGridCellCoords( row, col ),
+                                                false,
+                                                ControlDown, ShiftDown,
+                                                AltDown, MetaDown );

                 m_grid->GetEventHandler()->ProcessEvent(gridEvt);
                 m_grid->GetEventHandler()->ProcessEvent(gridEvt);

+                return;

             }
         }
     }
             }
         }
     }


@@ -625,18 +655,20 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
             if ( m_selectionMode != wxGrid::wxGridSelectColumns )
             {
                 if ( topRow < row )
             if ( m_selectionMode != wxGrid::wxGridSelectColumns )
             {
                 if ( topRow < row )

-                    SelectBlock( topRow, leftCol,
-                                 row - 1, rightCol, 0, FALSE );
+                    SelectBlock( topRow, leftCol, row - 1, rightCol,
+                                 false, false, false, false, false );

                 if ( bottomRow > row )
                 if ( bottomRow > row )

-                    SelectBlock( row + 1, leftCol,
-                                 bottomRow, rightCol, 0, FALSE );
+                    SelectBlock( row + 1, leftCol, bottomRow, rightCol,
+                                 false, false, false, false, false );

             }
             if ( m_selectionMode != wxGrid::wxGridSelectRows )
             {
                 if ( leftCol < col )
             }
             if ( m_selectionMode != wxGrid::wxGridSelectRows )
             {
                 if ( leftCol < col )

-                    SelectBlock( row, leftCol, row, col - 1, 0, FALSE );
+                    SelectBlock( row, leftCol, row, col - 1,
+                                 false, false, false, false, false );

                 if ( rightCol > col )
                 if ( rightCol > col )

-                    SelectBlock( row, col + 1, row, rightCol, 0, FALSE );
+                    SelectBlock( row, col + 1, row, rightCol,
+                                 false, false, false, false, false );

             }
         }
     }
             }
         }
     }


@@ -654,11 +686,12 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
                 if (m_selectionMode == wxGrid::wxGridSelectCells)
                 {
                     if ( col > 0 )
                 if (m_selectionMode == wxGrid::wxGridSelectCells)
                 {
                     if ( col > 0 )

-                        SelectBlock( row, 0, row, col - 1, 0, FALSE );
+                        SelectBlock( row, 0, row, col - 1,
+                                     false, false, false, false, false );

                     if ( col < m_grid->GetNumberCols() - 1 )
                         SelectBlock( row, col + 1,
                                      row, m_grid->GetNumberCols() - 1,
                     if ( col < m_grid->GetNumberCols() - 1 )
                         SelectBlock( row, col + 1,
                                      row, m_grid->GetNumberCols() - 1,

-                                     0, FALSE );
+                                     false, false, false, false, false );

                 }
             }
         }
                 }
             }
         }


@@ -677,11 +710,12 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
                 if (m_selectionMode == wxGrid::wxGridSelectCells)
                 {
                     if ( row > 0 )
                 if (m_selectionMode == wxGrid::wxGridSelectCells)
                 {
                     if ( row > 0 )

-                        SelectBlock( 0, col, row - 1, col, 0, FALSE );
+                        SelectBlock( 0, col, row - 1, col,
+                                     false, false, false, false, false );

                     if ( row < m_grid->GetNumberRows() - 1 )
                         SelectBlock( row + 1, col,
                                      m_grid->GetNumberRows() - 1, col,
                     if ( row < m_grid->GetNumberRows() - 1 )
                         SelectBlock( row + 1, col,
                                      m_grid->GetNumberRows() - 1, col,

-                                     0, FALSE );
+                                     false, false, false, false, false );

                 }
             }
         }
                 }
             }
         }


@@ -694,44 +728,61 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
     {
       case wxGrid::wxGridSelectCells:
       {
     {
       case wxGrid::wxGridSelectCells:
       {

-          r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
-                                         wxGridCellCoords( row, col ) );

           if ( !m_grid->GetBatchCount() )
           if ( !m_grid->GetBatchCount() )

-              ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
-          wxGridEvent gridEvt( m_grid->GetId(),
-                               wxEVT_GRID_SELECT_CELL,
-                               m_grid,
-                               row, col, -1, -1, FALSE );
+          {
+              r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
+                                             wxGridCellCoords( row, col ) );
+              ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+          }
+
+          wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+                                          wxEVT_GRID_RANGE_SELECT,
+                                          m_grid,
+                                          wxGridCellCoords( row, col ),
+                                          wxGridCellCoords( row, col ),
+                                          false,
+                                          ControlDown, ShiftDown,
+                                          AltDown, MetaDown );

           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }
       case wxGrid::wxGridSelectRows:
       {
           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }
       case wxGrid::wxGridSelectRows:
       {

-          r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
-                                         wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );

           if ( !m_grid->GetBatchCount() )
           if ( !m_grid->GetBatchCount() )

-              ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+          {
+              r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
+                                             wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+              ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+          }
+

           wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                           wxEVT_GRID_RANGE_SELECT,
                                           m_grid,
                                           wxGridCellCoords( row, 0 ),
                                           wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
           wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                           wxEVT_GRID_RANGE_SELECT,
                                           m_grid,
                                           wxGridCellCoords( row, 0 ),
                                           wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),

-                                          FALSE );
+                                          false,
+                                          ControlDown, ShiftDown,
+                                          AltDown, MetaDown );

           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }
       case wxGrid::wxGridSelectColumns:
       {
           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }
       case wxGrid::wxGridSelectColumns:
       {

-          r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
-                                         wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );

           if ( !m_grid->GetBatchCount() )
           if ( !m_grid->GetBatchCount() )

-              ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+          {
+              r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
+                                             wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+              ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+          }
+

           wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                           wxEVT_GRID_RANGE_SELECT,
                                           m_grid,
                                           wxGridCellCoords( 0, col ),
                                           wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
           wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
                                           wxEVT_GRID_RANGE_SELECT,
                                           m_grid,
                                           wxGridCellCoords( 0, col ),
                                           wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),

-                                          FALSE );
+                                          false,
+                                          ControlDown, ShiftDown,
+                                          AltDown, MetaDown );

           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }
           m_grid->GetEventHandler()->ProcessEvent(gridEvt);
           break;
       }


@@ -740,36 +791,39 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
 
 void wxGridSelection::ClearSelection()
 {
 
 void wxGridSelection::ClearSelection()
 {

-    // Should this send deselection events?

     size_t n;
     size_t n;

+    wxRect r;
+    wxGridCellCoords coords1, coords2;

 
     // deselect all invidiual cells and update the screen
     if ( m_selectionMode == wxGrid::wxGridSelectCells )
     {
 
     // deselect all invidiual cells and update the screen
     if ( m_selectionMode == wxGrid::wxGridSelectCells )
     {

-      

         while( ( n = m_cellSelection.GetCount() ) > 0)
         {
         while( ( n = m_cellSelection.GetCount() ) > 0)
         {

-            wxRect r;

             n--;
             n--;

-            r = m_grid->BlockToDeviceRect( m_cellSelection[n],
-                                           m_cellSelection[n] );
+            coords1 = m_cellSelection[n];

             m_cellSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )
             m_cellSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )

-                ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+            {
+                r = m_grid->BlockToDeviceRect( coords1, coords1 );
+                ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+            }

         }
     }
 
     // deselect all blocks and update the screen
     while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
     {
         }
     }
 
     // deselect all blocks and update the screen
     while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
     {

-        wxRect r;

         n--;
         n--;

-        r = m_grid->BlockToDeviceRect( m_blockSelectionTopLeft[n],
-                                       m_blockSelectionBottomRight[n] );
+        coords1 = m_blockSelectionTopLeft[n];
+        coords2 = m_blockSelectionBottomRight[n];

         m_blockSelectionTopLeft.RemoveAt(n);
         m_blockSelectionBottomRight.RemoveAt(n);
         if ( !m_grid->GetBatchCount() )
         m_blockSelectionTopLeft.RemoveAt(n);
         m_blockSelectionBottomRight.RemoveAt(n);
         if ( !m_grid->GetBatchCount() )

-            ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );   
+        {
+            r = m_grid->BlockToDeviceRect( coords1, coords2 );
+            ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+        }

     }
 
     // deselect all rows and update the screen
     }
 
     // deselect all rows and update the screen


@@ -778,13 +832,14 @@ void wxGridSelection::ClearSelection()
         while( ( n = m_rowSelection.GetCount() ) > 0)
         {
             n--;
         while( ( n = m_rowSelection.GetCount() ) > 0)
         {
             n--;

-            int & row = m_rowSelection[n];
-            wxRect r;
-            r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
-                                           wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+            int row = m_rowSelection[n];

             m_rowSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )
             m_rowSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )

-                ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );   
+            {
+                r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
+                                               wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+                ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+            }

         }
     }
 
         }
     }
 


@@ -794,15 +849,29 @@ void wxGridSelection::ClearSelection()
         while( ( n = m_colSelection.GetCount() ) > 0)
         {
             n--;
         while( ( n = m_colSelection.GetCount() ) > 0)
         {
             n--;

-            int & col = m_colSelection[n];
-            wxRect r;
-            r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
-                                           wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+            int col = m_colSelection[n];

             m_colSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )
             m_colSelection.RemoveAt(n);
             if ( !m_grid->GetBatchCount() )

-                ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );   
+            {
+                r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
+                                               wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+                ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+            }

         }
     }
         }
     }

+
+    // One deselection event, indicating deselection of _all_ cells.
+    // (No finer grained events for each of the smaller regions
+    //  deselected above!)
+    wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+                                    wxEVT_GRID_RANGE_SELECT,
+                                    m_grid,
+                                    wxGridCellCoords( 0, 0 ),
+                                    wxGridCellCoords( m_grid->GetNumberRows() - 1,
+                                                      m_grid->GetNumberCols() - 1 ),
+                                    false );
+
+    m_grid->GetEventHandler()->ProcessEvent(gridEvt);

 }
 
 
 }
 
 


@@ -864,7 +933,7 @@ void wxGridSelection::UpdateRows( size_t pos, int numRows )
                     coords2.SetRow(row2 + numRows);
                     if ( (size_t) row1 >= pos)
                         coords1.SetRow( wxMax(row1 + numRows, (int) pos) );
                     coords2.SetRow(row2 + numRows);
                     if ( (size_t) row1 >= pos)
                         coords1.SetRow( wxMax(row1 + numRows, (int) pos) );

-                    
+

                 }
                 else
                 {
                 }
                 else
                 {


@@ -885,29 +954,35 @@ void wxGridSelection::UpdateRows( size_t pos, int numRows )
     count = m_rowSelection.GetCount();
     for ( n = 0; n < count; n++ )
     {
     count = m_rowSelection.GetCount();
     for ( n = 0; n < count; n++ )
     {

-        int & rowOrCol = m_rowSelection[n];
-        if ( (size_t)rowOrCol >= pos )
-        {
-            if ( numRows > 0 )
-            {
-                // If rows inserted, include row counter where necessary
-                rowOrCol += numRows;
-            }
-            else if ( numRows < 0)
-            {
-                // If rows deleted, either decrement row counter (if row still exists)
-                if ((size_t)rowOrCol >= pos - numRows)
-                    rowOrCol += numRows;
-                else
-                {
-                    m_rowSelection.RemoveAt(n);
-                    n--; count--;
-                }
-            }
-        }
+    int  rowOrCol_ = m_rowSelection [ n ];
+
+      if ( ( size_t ) rowOrCol_ >= pos )
+      {
+          if ( numRows > 0 )
+          {
+              m_rowSelection [ n ] += numRows;
+          }
+          else if ( numRows < 0 )
+          {
+              if ( ( size_t ) rowOrCol_ >= ( pos - numRows ) )
+                  m_rowSelection [ n ] += numRows;
+              else
+              {
+                  m_rowSelection.RemoveAt ( n );
+                  n--;
+                  count--;
+              }
+          }
+      }

     }
     }

+    // No need to touch selected columns, unless we removed _all_
+    // rows, in this case, we remove all columns from the selection.
+
+    if ( !m_grid->GetNumberRows() )
+        m_colSelection.Clear();

 }
 
 }
 

+

 void wxGridSelection::UpdateCols( size_t pos, int numCols )
 {
     size_t count = m_cellSelection.GetCount();
 void wxGridSelection::UpdateCols( size_t pos, int numCols )
 {
     size_t count = m_cellSelection.GetCount();


@@ -966,7 +1041,7 @@ void wxGridSelection::UpdateCols( size_t pos, int numCols )
                     coords2.SetCol(col2 + numCols);
                     if ( (size_t) col1 >= pos)
                         coords1.SetCol( wxMax(col1 + numCols, (int) pos) );
                     coords2.SetCol(col2 + numCols);
                     if ( (size_t) col1 >= pos)
                         coords1.SetCol( wxMax(col1 + numCols, (int) pos) );

-                    
+

                 }
                 else
                 {
                 }
                 else
                 {


@@ -987,29 +1062,34 @@ void wxGridSelection::UpdateCols( size_t pos, int numCols )
     count = m_colSelection.GetCount();
     for ( n = 0; n < count; n++ )
     {
     count = m_colSelection.GetCount();
     for ( n = 0; n < count; n++ )
     {

-        int & rowOrCol = m_colSelection[n];
-        if ( (size_t)rowOrCol >= pos )
+
+      int   rowOrCol = m_colSelection [ n ];
+        if ( ( size_t ) rowOrCol >= pos )

         {
             if ( numCols > 0 )
         {
             if ( numCols > 0 )

+                m_colSelection [ n ] += numCols;
+            else if ( numCols < 0 )

             {
             {

-                // If cols inserted, include col counter where necessary
-                rowOrCol += numCols;
-            }
-            else if ( numCols < 0)
-            {
-                // If cols deleted, either decrement col counter (if col still exists)
-                if ((size_t)rowOrCol >= pos - numCols)
-                    rowOrCol += numCols;
+                if ( ( size_t ) rowOrCol >= ( pos -numCols ) )
+                    m_colSelection [ n ] += numCols;

                 else
                 {
                 else
                 {

-                    m_colSelection.RemoveAt(n);
-                    n--; count--;
+                    m_colSelection.RemoveAt ( n );
+                    n--;
+                    count--;

                 }
             }
         }
                 }
             }
         }

+

     }
     }

+
+    // No need to touch selected rows, unless we removed _all_
+    // columns, in this case, we remove all rows from the selection.
+    if ( !m_grid->GetNumberCols() )
+        m_rowSelection.Clear();

 }
 
 }
 

+

 int wxGridSelection::BlockContain( int topRow1, int leftCol1,
                                    int bottomRow1, int rightCol1,
                                    int topRow2, int leftCol2,
 int wxGridSelection::BlockContain( int topRow1, int leftCol1,
                                    int bottomRow1, int rightCol1,
                                    int topRow2, int leftCol2,