and ITEM_COLLAPSED/ING too

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

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 5867454005b06f7179d81c8699b6898318849f9b..3264306ecee4e299645c3779d36f6fd27acee181 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -32,10 +32,15 @@
     #include "wx/settings.h"
     #include "wx/log.h"
     #include "wx/sizer.h"
     #include "wx/settings.h"
     #include "wx/log.h"
     #include "wx/sizer.h"

+    #include "wx/layout.h"

 #endif
 
 #include "wx/generic/grid.h"
 
 #endif
 
 #include "wx/generic/grid.h"
 

+#ifndef WXGRID_DRAW_LINES
+#define WXGRID_DRAW_LINES 1
+#endif
+

 //////////////////////////////////////////////////////////////////////
 
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );
 //////////////////////////////////////////////////////////////////////
 
 wxGridCellCoords wxGridNoCellCoords( -1, -1 );


@@ -630,7 +635,7 @@ void wxGridTextCtrl::OnKeyDown( wxKeyEvent& event )
             {
                 if ( !m_grid->ProcessEvent( event ) )
                 {
             {
                 if ( !m_grid->ProcessEvent( event ) )
                 {

-#ifdef __WXMOTIF__
+#if defined(__WXMOTIF__) || defined(__WXGTK__)

                     // wxMotif needs a little extra help...
                     //
                     int pos = GetInsertionPoint();
                     // wxMotif needs a little extra help...
                     //
                     int pos = GetInsertionPoint();


@@ -706,7 +711,7 @@ void wxGridRowLabelWindow::OnPaint( wxPaintEvent &event )
     //
     // m_owner->PrepareDC( dc );
 
     //
     // m_owner->PrepareDC( dc );
 

-    wxCoord x, y;
+    int x, y;

     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( 0, -y );
 
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( 0, -y );
 


@@ -759,7 +764,7 @@ void wxGridColLabelWindow::OnPaint( wxPaintEvent &event )
     //
     // m_owner->PrepareDC( dc );
 
     //
     // m_owner->PrepareDC( dc );
 

-    wxCoord x, y;
+    int x, y;

     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( -x, 0 );
 
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
     dc.SetDeviceOrigin( -x, 0 );
 


@@ -850,7 +855,7 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
                             wxGridRowLabelWindow *rowLblWin,
                             wxGridColLabelWindow *colLblWin,
                             wxWindowID id, const wxPoint &pos, const wxSize &size )
                             wxGridRowLabelWindow *rowLblWin,
                             wxGridColLabelWindow *colLblWin,
                             wxWindowID id, const wxPoint &pos, const wxSize &size )

-        : wxPanel( parent, id, pos, size, wxSUNKEN_BORDER, "grid window" )
+        : wxPanel( parent, id, pos, size, 0, "grid window" )

 {
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
 {
     m_owner = parent;
     m_rowLabelWin = rowLblWin;


@@ -869,9 +874,12 @@ void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
 {
     wxPaintDC dc( this );
     m_owner->PrepareDC( dc );
 {
     wxPaintDC dc( this );
     m_owner->PrepareDC( dc );

-
-    m_owner->CalcCellsExposed( GetUpdateRegion() );
+    wxRegion reg = GetUpdateRegion();
+    m_owner->CalcCellsExposed( reg );

     m_owner->DrawGridCellArea( dc );
     m_owner->DrawGridCellArea( dc );

+#if WXGRID_DRAW_LINES
+    m_owner->DrawAllGridLines( dc, reg );
+#endif

 }
 
 
 }
 
 


@@ -933,23 +941,33 @@ wxGrid::~wxGrid()
 
 void wxGrid::Create()
 {
 
 void wxGrid::Create()
 {

-    int colLblH = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
-    int rowLblW = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_created = FALSE;    // set to TRUE by CreateGrid
+    m_displayed = FALSE;  // set to TRUE by OnPaint
+
+    m_table        = (wxGridTableBase *) NULL;
+    m_cellEditCtrl = (wxWindow *) NULL;
+
+    m_numRows = 0;
+    m_numCols = 0;
+    m_currentCellCoords = wxGridNoCellCoords;
+    
+    m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
+    m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
+
+    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
+                                                    -1,
+                                                    wxDefaultPosition,
+                                                    wxDefaultSize );

 
     m_rowLabelWin = new wxGridRowLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,
 
     m_rowLabelWin = new wxGridRowLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,

-                                              wxSize(rowLblW,-1) );
+                                              wxDefaultSize );

 
     m_colLabelWin = new wxGridColLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,
 
     m_colLabelWin = new wxGridColLabelWindow( this,
                                               -1,
                                               wxDefaultPosition,

-                                              wxSize(-1, colLblH ) );
-
-    m_cornerLabelWin = new wxGridCornerLabelWindow( this,
-                                                    -1,
-                                                    wxDefaultPosition,
-                                                    wxSize(rowLblW, colLblH ) );
+                                              wxDefaultSize );

 
     m_gridWin = new wxGridWindow( this,
                                   m_rowLabelWin,
 
     m_gridWin = new wxGridWindow( this,
                                   m_rowLabelWin,


@@ -959,23 +977,6 @@ void wxGrid::Create()
                                   wxDefaultSize );
 
     SetTargetWindow( m_gridWin );
                                   wxDefaultSize );
 
     SetTargetWindow( m_gridWin );

-
-    m_mainSizer = new wxBoxSizer( wxVERTICAL );
-
-    m_topSizer = new wxBoxSizer( wxHORIZONTAL );
-    m_topSizer->Add( m_cornerLabelWin, 0 );
-    m_topSizer->Add( m_colLabelWin, 1 );
-
-    m_mainSizer->Add( m_topSizer, 0, wxEXPAND );
-
-    m_middleSizer = new wxBoxSizer( wxHORIZONTAL );
-    m_middleSizer->Add( m_rowLabelWin, 0, wxEXPAND );
-    m_middleSizer->Add( m_gridWin, 1, wxEXPAND );
-
-    m_mainSizer->Add( m_middleSizer, 1, wxEXPAND );
-
-    SetAutoLayout( TRUE );
-    SetSizer( m_mainSizer );

 }
 
 
 }
 
 


@@ -1117,8 +1118,8 @@ void wxGrid::CalcDimensions()
 
     if ( m_numRows > 0  &&  m_numCols > 0 )
     {
 
     if ( m_numRows > 0  &&  m_numCols > 0 )
     {

-        int right = m_colRights[ m_numCols-1 ] + 20;
-        int bottom = m_rowBottoms[ m_numRows-1 ] + 20;
+        int right = m_colRights[ m_numCols-1 ] + 50;
+        int bottom = m_rowBottoms[ m_numRows-1 ] + 50;

 
         // TODO: restore the scroll position that we had before sizing
         //
 
         // TODO: restore the scroll position that we had before sizing
         //


@@ -1131,6 +1132,25 @@ void wxGrid::CalcDimensions()
 }
 
 
 }
 
 

+void wxGrid::CalcWindowSizes()
+{
+    int cw, ch;
+    GetClientSize( &cw, &ch );
+    
+    if ( m_cornerLabelWin->IsShown() )
+        m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
+
+    if ( m_colLabelWin->IsShown() )
+        m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
+
+    if ( m_rowLabelWin->IsShown() )
+        m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
+
+    if ( m_gridWin->IsShown() )
+        m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
+}
+
+

 // this is called when the grid table sends a message to say that it
 // has been redimensioned
 //
 // this is called when the grid table sends a message to say that it
 // has been redimensioned
 //


@@ -1441,6 +1461,7 @@ void wxGrid::CalcCellsExposed( wxRegion& reg )
         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
 
         CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
         CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
 

+       left++; top++; 

         // find the cells within these bounds
         //
         int row, col;
         // find the cells within these bounds
         //
         int row, col;


@@ -1585,9 +1606,15 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                 SetRowSize( m_dragRowOrCol, wxMax( y - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
                 if ( !GetBatchCount() )
                 {
                 SetRowSize( m_dragRowOrCol, wxMax( y - rowTop, WXGRID_MIN_ROW_HEIGHT ) );
                 if ( !GetBatchCount() )
                 {

-                  // TODO: optimize this
-                  m_rowLabelWin->Refresh();
-                  m_gridWin->Refresh();
+                  // Only needed to get the correct rect.y:
+                  wxRect rect ( CellToRect( m_dragRowOrCol, 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 );
+                  rect.width = cw;
+                  m_gridWin->Refresh( FALSE, &rect );

                 }
 
                 ShowCellEditControl();
                 }
 
                 ShowCellEditControl();


@@ -1599,6 +1626,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
             }
         }
 
             }
         }
 

+        m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;

         m_dragLastPos  = -1;
     }
 
         m_dragLastPos  = -1;
     }
 


@@ -1642,11 +1670,9 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
         }
         else
         {
         }
         else
         {

-            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-            {
-                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+            if ( m_rowLabelWin->GetCursor() == m_rowResizeCursor )

                 m_rowLabelWin->SetCursor( *wxSTANDARD_CURSOR );
                 m_rowLabelWin->SetCursor( *wxSTANDARD_CURSOR );

-            }

         }
     }
 }
         }
     }
 }


@@ -1767,9 +1793,15 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
 
                 if ( !GetBatchCount() )
                 {
 
                 if ( !GetBatchCount() )
                 {

-                  // TODO: optimize this
-                  m_colLabelWin->Refresh();
-                  m_gridWin->Refresh();
+                  // Only needed to get the correct rect.x:
+                  wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
+                  rect.y = 0;
+                  CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
+                  rect.width = cw - rect.x;
+                  rect.height = m_colLabelHeight;
+                  m_colLabelWin->Refresh( TRUE, &rect );
+                  rect.height = ch;
+                  m_gridWin->Refresh( FALSE, &rect );

                 }
 
                 ShowCellEditControl();
                 }
 
                 ShowCellEditControl();


@@ -1781,6 +1813,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
             }
         }
 
             }
         }
 

+        m_cursorMode  = WXGRID_CURSOR_SELECT_CELL;

         m_dragLastPos  = -1;
     }
 
         m_dragLastPos  = -1;
     }
 


@@ -1824,11 +1857,9 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         }
         else
         {
         }
         else
         {

-            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
-            {
-                m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+            if ( m_colLabelWin->GetCursor() == m_colResizeCursor )

                 m_colLabelWin->SetCursor( *wxSTANDARD_CURSOR );
                 m_colLabelWin->SetCursor( *wxSTANDARD_CURSOR );

-            }

         }
     }
 }
         }
     }
 }


@@ -1986,6 +2017,13 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 // no default action at the moment
             }
         }
                 // no default action at the moment
             }
         }

+
+        // ------------ Moving and no button action
+        //
+        else if ( event.Moving() && !event.IsButton() )
+        {
+            m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+        }

     }
 }
 
     }
 }
 


@@ -2357,6 +2395,8 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
         SetEditControlValue();
         ShowCellEditControl();
     }
         SetEditControlValue();
         ShowCellEditControl();
     }

+
+    m_displayed = TRUE;

 }
 
 
 }
 
 


@@ -2366,8 +2406,8 @@ void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
 //
 void wxGrid::OnSize( wxSizeEvent& event )
 {
 //
 void wxGrid::OnSize( wxSizeEvent& event )
 {

+    CalcWindowSizes();

     CalcDimensions();
     CalcDimensions();

-    event.Skip();

 }
 
 
 }
 
 


@@ -2445,8 +2485,9 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 }
                 else
                 {
                 }
                 else
                 {

-                    event.Skip()
+                    event.Skip();

                 }
                 }

+                break;

 
             case WXK_RETURN:
                 if ( event.ControlDown() )
 
             case WXK_RETURN:
                 if ( event.ControlDown() )


@@ -2515,10 +2556,8 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         return;
     }
 
         return;
     }
 

-    wxClientDC dc( m_gridWin );
-    PrepareDC( dc );
-
-    if ( m_currentCellCoords != wxGridNoCellCoords )
+    if ( m_displayed  &&
+         m_currentCellCoords != wxGridNoCellCoords )

     {
         HideCellEditControl();
         SaveEditControlValue();
     {
         HideCellEditControl();
         SaveEditControlValue();


@@ -2527,13 +2566,17 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
     m_currentCellCoords = coords;
 
     SetEditControlValue();
     m_currentCellCoords = coords;
 
     SetEditControlValue();

-    ShowCellEditControl();

 
 

-    if ( IsSelection() )
+    if ( m_displayed )

     {
     {

-        wxRect r( SelectionToDeviceRect() );
-        ClearSelection();
-        if ( !GetBatchCount() ) m_gridWin->Refresh( TRUE, &r );
+        ShowCellEditControl();
+
+        if ( IsSelection() )
+        {
+            wxRect r( SelectionToDeviceRect() );
+            ClearSelection();
+            if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
+        }

     }
 }
 
     }
 }
 


@@ -2601,8 +2644,10 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
     if ( m_colWidths[coords.GetCol()] <=0  ||
          m_rowHeights[coords.GetRow()] <= 0 ) return;
 
     if ( m_colWidths[coords.GetCol()] <=0  ||
          m_rowHeights[coords.GetRow()] <= 0 ) return;
 

+#if !WXGRID_DRAW_LINES

     if ( m_gridLinesEnabled )
         DrawCellBorder( dc, coords );
     if ( m_gridLinesEnabled )
         DrawCellBorder( dc, coords );

+#endif

 
     DrawCellBackground( dc, coords );
 
 
     DrawCellBackground( dc, coords );
 


@@ -2624,13 +2669,13 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
 
     // right hand border
     //
 
     // right hand border
     //

-    dc.DrawLine( m_colRights[col], m_rowBottoms[row] - m_rowHeights[row],
-                 m_colRights[col], m_rowBottoms[row] );
+    dc.DrawLine( m_colRights[col]-1, m_rowBottoms[row] - m_rowHeights[row],
+                 m_colRights[col]-1, m_rowBottoms[row]-1 );

 
     // bottom border
     //
 
     // bottom border
     //

-    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row],
-                 m_colRights[col], m_rowBottoms[row] );
+    dc.DrawLine( m_colRights[col] - m_colWidths[col], m_rowBottoms[row]-1,
+                 m_colRights[col]-1, m_rowBottoms[row]-1 );

 }
 
 
 }
 
 


@@ -2706,50 +2751,64 @@ void wxGrid::DrawCellValue( wxDC& dc, const wxGridCellCoords& coords )
 // 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 )
+void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & reg )

 {
     if ( !m_gridLinesEnabled ||
          !m_numRows ||
          !m_numCols ) return;
 
 {
     if ( !m_gridLinesEnabled ||
          !m_numRows ||
          !m_numCols ) return;
 

-    int cw, ch;
-    m_gridWin->GetClientSize(&cw, &ch);
+    int top, bottom, left, right;
+
+    if (reg.IsEmpty()){
+      int cw, ch;
+      m_gridWin->GetClientSize(&cw, &ch);

 
 

-    // virtual coords of visible area
+      // virtual coords of visible area
+      //
+      CalcUnscrolledPosition( 0, 0, &left, &top );
+      CalcUnscrolledPosition( cw, ch, &right, &bottom );
+    }
+    else{
+      wxCoord x, y, w, h;
+      reg.GetBox(x, y, w, h);
+      CalcUnscrolledPosition( x, y, &left, &top );
+      CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
+    }
+
+    // avoid drawing grid lines past the last row and col

     //
     //

-    int top, bottom, left, right;
-    CalcUnscrolledPosition( 0, 0, &left, &top );
-    CalcUnscrolledPosition( cw, ch, &right, &bottom );
+    right = wxMin( right, m_colRights[m_numCols-1] );
+    bottom = wxMin( bottom, m_rowBottoms[m_numRows-1] );

 
     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
 
     // horizontal grid lines
     //
     int i;
 
     dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
 
     // horizontal grid lines
     //
     int i;

-    for ( i = 0; i <= m_numRows; i++ )
+    for ( i = 0; i < m_numRows; i++ )

     {
     {

-        if ( m_rowBottoms[i] > bottom )
+        if ( m_rowBottoms[i]-1 > bottom )

         {
             break;
         }
         {
             break;
         }

-        else if ( m_rowBottoms[i] >= top )
+        else if ( m_rowBottoms[i]-1 >= top )

         {
         {

-            dc.DrawLine( left, m_rowBottoms[i], right, m_rowBottoms[i] );
+            dc.DrawLine( left, m_rowBottoms[i]-1, right, m_rowBottoms[i]-1 );

         }
     }
 
 
     // vertical grid lines
     //
         }
     }
 
 
     // vertical grid lines
     //

-    for ( i = 0; i <= m_numCols; i++ )
+    for ( i = 0; i < m_numCols; i++ )

     {
     {

-        if ( m_colRights[i] > right )
+        if ( m_colRights[i]-1 > right )

         {
             break;
         }
         {
             break;
         }

-        else if ( m_colRights[i] >= left )
+        else if ( m_colRights[i]-1 >= left )

         {
         {

-            dc.DrawLine( m_colRights[i], top, m_colRights[i], bottom );
+            dc.DrawLine( m_colRights[i]-1, top, m_colRights[i]-1, bottom );

         }
     }
 }
         }
     }
 }


@@ -2773,18 +2832,18 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
 {
     if ( m_rowHeights[row] <= 0 ) return;
 
 {
     if ( m_rowHeights[row] <= 0 ) return;
 

-    // draw the label's horizontal border (the vertical border is
-    // provided by the cell area window margin)
-    //
+    int rowTop = m_rowBottoms[row] - m_rowHeights[row];
+    

     dc.SetPen( *wxBLACK_PEN );
     dc.SetPen( *wxBLACK_PEN );

-
-    dc.DrawLine( 0, m_rowBottoms[row]+1,
-                 m_rowLabelWidth, m_rowBottoms[row]+1 );
-
+    dc.DrawLine( m_rowLabelWidth-1, rowTop,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+    
+    dc.DrawLine( 0, m_rowBottoms[row]-1,
+                 m_rowLabelWidth-1, m_rowBottoms[row]-1 );
+    

     dc.SetPen( *wxWHITE_PEN );
     dc.SetPen( *wxWHITE_PEN );

-
-    dc.DrawLine( 0, m_rowBottoms[row]+2,
-                 m_rowLabelWidth, m_rowBottoms[row]+2 );
+    dc.DrawLine( 0, rowTop, 0, m_rowBottoms[row]-1 );
+    dc.DrawLine( 0, rowTop, m_rowLabelWidth-1, rowTop );

 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );


@@ -2820,18 +2879,22 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
 {
     if ( m_colWidths[col] <= 0 ) return;
 
 {
     if ( m_colWidths[col] <= 0 ) return;
 

-    // draw the label's vertical border (the horizontal border is
-    // provided by the cell area window margin)
-    //
+    int colLeft = m_colRights[col] - m_colWidths[col];
+    

     dc.SetPen( *wxBLACK_PEN );
     dc.SetPen( *wxBLACK_PEN );

-
-    dc.DrawLine( m_colRights[col]+1, 0,
-                 m_colRights[col]+1, m_colLabelHeight );
-
+    dc.DrawLine( m_colRights[col]-1, 0,
+                 m_colRights[col]-1, m_colLabelHeight-1 );
+    
+    dc.DrawLine( colLeft, m_colLabelHeight-1,
+                 m_colRights[col]-1, m_colLabelHeight-1 );
+    

     dc.SetPen( *wxWHITE_PEN );
     dc.SetPen( *wxWHITE_PEN );

+    dc.DrawLine( colLeft, 0, colLeft, m_colLabelHeight-1 );
+    dc.DrawLine( colLeft, 0, m_colRights[col]-1, 0 );

 
 

-    dc.DrawLine( m_colRights[col]+2, 0,
-                 m_colRights[col]+2, m_colLabelHeight );
+    dc.SetBackgroundMode( wxTRANSPARENT );
+    dc.SetTextForeground( GetLabelTextColour() );
+    dc.SetFont( GetLabelFont() );

 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );
 
     dc.SetBackgroundMode( wxTRANSPARENT );
     dc.SetTextForeground( GetLabelTextColour() );


@@ -3837,16 +3900,53 @@ wxString wxGrid::GetColLabelValue( int col )
     }
 }
 
     }
 }
 

+

 void wxGrid::SetRowLabelSize( int width )
 {
 void wxGrid::SetRowLabelSize( int width )
 {

-    // TODO: how to do this with the box sizers ?
+    width = wxMax( width, 0 );
+    if ( width != m_rowLabelWidth )
+    {
+        if ( width == 0 )
+        {
+            m_rowLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_rowLabelWidth == 0 )
+        {
+            m_rowLabelWin->Show( TRUE );
+            if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+        
+        m_rowLabelWidth = width;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }

 }
 
 }
 

+

 void wxGrid::SetColLabelSize( int height )
 {
 void wxGrid::SetColLabelSize( int height )
 {

-    // TODO: how to do this with the box sizers ?
+    height = wxMax( height, 0 );
+    if ( height != m_colLabelHeight )
+    {
+        if ( height == 0 )
+        {
+            m_colLabelWin->Show( FALSE );
+            m_cornerLabelWin->Show( FALSE );
+        }
+        else if ( m_colLabelHeight == 0 )
+        {
+            m_colLabelWin->Show( TRUE );
+            if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
+        }
+
+        m_colLabelHeight = height;
+        CalcWindowSizes();
+        Refresh( TRUE );
+    }

 }
 
 }
 

+

 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
 {
     if ( m_labelBackgroundColour != colour )
 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
 {
     if ( m_labelBackgroundColour != colour )


@@ -3903,7 +4003,6 @@ void wxGrid::SetRowLabelAlignment( int horiz, int vert )
     if ( !GetBatchCount() )
     {
         m_rowLabelWin->Refresh();
     if ( !GetBatchCount() )
     {
         m_rowLabelWin->Refresh();

-        m_colLabelWin->Refresh();

     }
 }
 
     }
 }
 


@@ -3921,7 +4020,6 @@ void wxGrid::SetColLabelAlignment( int horiz, int vert )
 
     if ( !GetBatchCount() )
     {
 
     if ( !GetBatchCount() )
     {

-        m_rowLabelWin->Refresh();

         m_colLabelWin->Refresh();
     }
 }
         m_colLabelWin->Refresh();
     }
 }


@@ -3933,9 +4031,14 @@ void wxGrid::SetRowLabelValue( int row, const wxString& s )
         m_table->SetRowLabelValue( row, s );
         if ( !GetBatchCount() )
         {
         m_table->SetRowLabelValue( row, s );
         if ( !GetBatchCount() )
         {

-            // TODO: Optimize this
-            //
-            m_rowLabelWin->Refresh();
+            wxRect rect = CellToRect( row, 0);
+            if ( rect.height > 0 )
+            {
+                CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
+                rect.x = m_left;
+                rect.width = m_rowLabelWidth;
+                m_rowLabelWin->Refresh( TRUE, &rect );
+            }

         }
     }
 }
         }
     }
 }


@@ -3947,9 +4050,14 @@ void wxGrid::SetColLabelValue( int col, const wxString& s )
         m_table->SetColLabelValue( col, s );
         if ( !GetBatchCount() )
         {
         m_table->SetColLabelValue( col, s );
         if ( !GetBatchCount() )
         {

-            // TODO: optimize this
-            //
-            m_colLabelWin->Refresh();
+            wxRect rect = CellToRect( 0, col );
+            if ( rect.width > 0 )
+            {
+                CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
+                rect.y = m_top;
+                rect.height = m_colLabelHeight;
+                m_colLabelWin->Refresh( TRUE, &rect );
+            }

         }
     }
 }
         }
     }
 }


@@ -3962,7 +4070,7 @@ void wxGrid::SetGridLineColour( const wxColour& colour )
 
         wxClientDC dc( m_gridWin );
         PrepareDC( dc );
 
         wxClientDC dc( m_gridWin );
         PrepareDC( dc );

-        DrawAllGridLines( dc );
+        DrawAllGridLines( dc, wxRegion() );

     }
 }
 
     }
 }
 


@@ -3978,7 +4086,7 @@ void wxGrid::EnableGridLines( bool enable )
             {
                 wxClientDC dc( m_gridWin );
                 PrepareDC( dc );
             {
                 wxClientDC dc( m_gridWin );
                 PrepareDC( dc );

-                DrawAllGridLines( dc );
+                DrawAllGridLines( dc, wxRegion() );

             }
             else
             {
             }
             else
             {


@@ -4253,32 +4361,67 @@ void wxGrid::SelectRow( int row, bool addToSelected )
 
     if ( IsSelection() && addToSelected )
     {
 
     if ( IsSelection() && addToSelected )
     {

-        if ( m_selectedTopLeft.GetRow() > row )
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        if ( oldTop > row )
+        {
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( row, 0 ),
+                                         wxGridCellCoords ( oldTop - 1,
+                                                            m_numCols - 1 ) );

             m_selectedTopLeft.SetRow( row );
             m_selectedTopLeft.SetRow( row );

+        }

 
 

-        m_selectedTopLeft.SetCol( 0 );
+        if ( oldLeft > 0 )
+        {
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop, 0 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            oldLeft - 1 ) );
+
+            m_selectedTopLeft.SetCol( 0 );
+        }

 
 

-        if ( m_selectedBottomRight.GetRow() < row )
+        if ( oldBottom < row )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1, 0 ),
+                                         wxGridCellCoords ( row,
+                                                            m_numCols - 1 ) );

             m_selectedBottomRight.SetRow( row );
             m_selectedBottomRight.SetRow( row );

+        }

 
 

-        m_selectedBottomRight.SetCol( m_numCols - 1 );
+        if ( oldRight < m_numCols - 1 )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldTop ,
+                                                            oldRight + 1 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            m_numCols - 1 ) );
+            m_selectedBottomRight.SetCol( m_numCols - 1 );
+        }

 
 

-        // TODO: optimize this so that we only refresh the newly
-        // selected cells
-        //
-        r = SelectionToDeviceRect();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
     else
     {
         r = SelectionToDeviceRect();
         ClearSelection();
     }
     else
     {
         r = SelectionToDeviceRect();
         ClearSelection();

-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );

 
         m_selectedTopLeft.Set( row, 0 );
         m_selectedBottomRight.Set( row, m_numCols-1 );
         r = SelectionToDeviceRect();
 
         m_selectedTopLeft.Set( row, 0 );
         m_selectedBottomRight.Set( row, m_numCols-1 );
         r = SelectionToDeviceRect();

-        m_gridWin->Refresh( TRUE, &r );
+        m_gridWin->Refresh( FALSE, &r );

     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),


@@ -4293,36 +4436,70 @@ void wxGrid::SelectRow( int row, bool addToSelected )
 
 void wxGrid::SelectCol( int col, bool addToSelected )
 {
 
 void wxGrid::SelectCol( int col, bool addToSelected )
 {

-    wxRect r;
-

     if ( IsSelection() && addToSelected )
     {
     if ( IsSelection() && addToSelected )
     {

-        if ( m_selectedTopLeft.GetCol() > col )
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        if ( oldLeft > col )
+        {
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( 0, col ),
+                                         wxGridCellCoords ( m_numRows - 1, 
+                                                            oldLeft - 1 ) );

             m_selectedTopLeft.SetCol( col );
             m_selectedTopLeft.SetCol( col );

+        }

 
 

-        m_selectedTopLeft.SetRow( 0 );
+        if ( oldTop  > 0 )
+        {
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
+                                         wxGridCellCoords ( oldTop - 1, 
+                                                            oldRight ) );
+            m_selectedTopLeft.SetRow( 0 );
+        }

 
 

-        if ( m_selectedBottomRight.GetCol() < col )
+        if ( oldRight < col )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( 0, oldRight + 1 ),
+                                         wxGridCellCoords ( m_numRows - 1,
+                                                            col            ) );

             m_selectedBottomRight.SetCol( col );
             m_selectedBottomRight.SetCol( col );

+        }

 
 

-        m_selectedBottomRight.SetRow( m_numRows - 1 );
+        if ( oldBottom < m_numRows - 1 )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1,
+                                                            oldLeft ),
+                                         wxGridCellCoords ( m_numRows - 1,
+                                                            oldRight ) );
+            m_selectedBottomRight.SetRow( m_numRows - 1 );
+        }

 
 

-        // TODO: optimize this so that we only refresh the newly
-        // selected cells
-        //
-        r = SelectionToDeviceRect();
-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
     else
     {
     }
     else
     {

+        wxRect r;
+    

         r = SelectionToDeviceRect();
         ClearSelection();
         r = SelectionToDeviceRect();
         ClearSelection();

-        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( TRUE, &r );
+        if ( r != wxGridNoCellRect ) m_gridWin->Refresh( FALSE, &r );

 
         m_selectedTopLeft.Set( 0, col );
         m_selectedBottomRight.Set( m_numRows-1, col );
         r = SelectionToDeviceRect();
 
         m_selectedTopLeft.Set( 0, col );
         m_selectedBottomRight.Set( m_numRows-1, col );
         r = SelectionToDeviceRect();

-        m_gridWin->Refresh( TRUE, &r );
+        m_gridWin->Refresh( FALSE, &r );

     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),
     }
 
     wxGridRangeSelectEvent gridEvt( GetId(),


@@ -4338,7 +4515,6 @@ void wxGrid::SelectCol( int col, bool addToSelected )
 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
 {
     int temp;
 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
 {
     int temp;

-    bool changed = false;

     wxGridCellCoords updateTopLeft, updateBottomRight;
 
     if ( topRow > bottomRow )
     wxGridCellCoords updateTopLeft, updateBottomRight;
 
     if ( topRow > bottomRow )


@@ -4355,46 +4531,100 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
         rightCol = temp;
     }
 
         rightCol = temp;
     }
 

-    updateTopLeft = m_selectedTopLeft;
-    if (m_selectedTopLeft != wxGridCellCoords( topRow, leftCol ) )
+    updateTopLeft = wxGridCellCoords( topRow, leftCol );
+    updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
+
+    if ( m_selectedTopLeft != updateTopLeft ||
+         m_selectedBottomRight != updateBottomRight )

     {
     {

-        m_selectedTopLeft = wxGridCellCoords( topRow, leftCol );
-        if (updateTopLeft == wxGridNoCellCoords)
+        // Compute two optimal update rectangles:
+        // Either one rectangle is a real subset of the
+        // other, or they are (almost) disjoint!
+        wxRect  rect[4];
+        bool    need_refresh[4] = { FALSE, FALSE, FALSE, FALSE };
+        int     i;
+
+        // Store intermediate values
+        wxCoord oldLeft   = m_selectedTopLeft.GetCol();
+        wxCoord oldTop    = m_selectedTopLeft.GetRow();
+        wxCoord oldRight  = m_selectedBottomRight.GetCol();
+        wxCoord oldBottom = m_selectedBottomRight.GetRow();
+
+        // Determine the outer/inner coordinates.
+        if (oldLeft > leftCol)

         {
         {

-            updateTopLeft = m_selectedTopLeft;
+            temp = oldLeft;
+            oldLeft = leftCol;
+            leftCol = temp;

         }
         }

-        else
+        if (oldTop > topRow )

         {
         {

-             if(updateTopLeft.GetRow() > topRow)
-                updateTopLeft.SetRow(topRow);
-            if (updateTopLeft.GetCol() > leftCol)
-              updateTopLeft.SetCol(leftCol);
+            temp = oldTop;
+            oldTop = topRow;
+            topRow = temp;
+        }
+        if (oldRight < rightCol )
+        {
+            temp = oldRight;
+            oldRight = rightCol;
+            rightCol = temp;
+        }
+        if (oldBottom < bottomRow)
+        {
+            temp = oldBottom;
+            oldBottom = bottomRow;
+            bottomRow = temp;

         }
         }

-        changed = true;
-    }

 
 

-    updateBottomRight = m_selectedBottomRight;
-    if (m_selectedBottomRight != wxGridCellCoords( bottomRow, rightCol ) )
-    {
-        m_selectedBottomRight = wxGridCellCoords( bottomRow, rightCol );
-        if (updateBottomRight == wxGridNoCellCoords)
+        // Now, either the stuff marked old is the outer
+        // rectangle or we don't have a situation where one
+        // is contained in the other.
+        
+        if ( oldLeft < leftCol )

         {
         {

-            updateBottomRight = m_selectedBottomRight;
+            need_refresh[0] = TRUE;
+            rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            oldLeft ),
+                                         wxGridCellCoords ( oldBottom, 
+                                                            leftCol - 1 ) );

         }
         }

-        else
+
+        if ( oldTop  < topRow )

         {
         {

-            if (updateBottomRight.GetRow() < bottomRow)
-                updateBottomRight.SetRow(bottomRow);
-            if (updateBottomRight.GetCol() < rightCol)
-                updateBottomRight.SetCol(rightCol);
+            need_refresh[1] = TRUE;
+            rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            leftCol ),
+                                         wxGridCellCoords ( topRow - 1, 
+                                                            rightCol ) );

         }
         }

-        changed = true;
-    }

 
 

-    if (changed)
-    {
-        wxRect r( BlockToDeviceRect( updateTopLeft, updateBottomRight ) );
-        m_gridWin->Refresh( TRUE, &r );
+        if ( oldRight > rightCol )
+        {
+            need_refresh[2] = TRUE;
+            rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
+                                                            rightCol + 1 ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            oldRight ) );
+        }
+
+        if ( oldBottom > bottomRow )
+        {
+            need_refresh[3] = TRUE;
+            rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
+                                                            leftCol ),
+                                         wxGridCellCoords ( oldBottom,
+                                                            rightCol ) );
+        }
+
+
+        // Change Selection
+        m_selectedTopLeft = updateTopLeft;
+        m_selectedBottomRight = updateBottomRight;
+        
+        // various Refresh() calls
+        for (i = 0; i < 4; i++ )
+            if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
+                m_gridWin->Refresh( FALSE, &(rect[i]) );

     }
 
     // only generate an event if the block is not being selected by
     }
 
     // only generate an event if the block is not being selected by