#include "wx/settings.h"
#include "wx/log.h"
#include "wx/sizer.h"
+ #include "wx/layout.h"
#endif
#include "wx/generic/grid.h"
+#ifndef WXGRID_DRAW_LINES
+#define WXGRID_DRAW_LINES 1
+#endif
+
//////////////////////////////////////////////////////////////////////
wxGridCellCoords wxGridNoCellCoords( -1, -1 );
{
if ( !m_grid->ProcessEvent( event ) )
{
-#ifdef __WXMOTIF__
+#if defined(__WXMOTIF__) || defined(__WXGTK__)
// wxMotif needs a little extra help...
//
int pos = GetInsertionPoint();
//
// m_owner->PrepareDC( dc );
- wxCoord x, y;
+ int x, y;
m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
dc.SetDeviceOrigin( 0, -y );
//
// m_owner->PrepareDC( dc );
- wxCoord x, y;
+ int x, y;
m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
dc.SetDeviceOrigin( -x, 0 );
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;
{
wxPaintDC dc( this );
m_owner->PrepareDC( dc );
-
- m_owner->CalcCellsExposed( GetUpdateRegion() );
+ wxRegion reg = GetUpdateRegion();
+ m_owner->CalcCellsExposed( reg );
m_owner->DrawGridCellArea( dc );
+#if WXGRID_DRAW_LINES
+ m_owner->DrawAllGridLines( dc, reg );
+#endif
}
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,
- wxSize(rowLblW,-1) );
+ wxDefaultSize );
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,
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 );
}
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
//
}
+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
//
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;
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();
}
}
+ m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
m_dragLastPos = -1;
}
}
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 );
- }
}
}
}
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();
}
}
+ m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
m_dragLastPos = -1;
}
}
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 );
- }
}
}
}
// no default action at the moment
}
}
+
+ // ------------ Moving and no button action
+ //
+ else if ( event.Moving() && !event.IsButton() )
+ {
+ m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+ }
}
}
SetEditControlValue();
ShowCellEditControl();
}
+
+ m_displayed = TRUE;
}
//
void wxGrid::OnSize( wxSizeEvent& event )
{
+ CalcWindowSizes();
CalcDimensions();
- event.Skip();
}
}
else
{
- event.Skip()
+ event.Skip();
}
+ break;
case WXK_RETURN:
if ( event.ControlDown() )
return;
}
- wxClientDC dc( m_gridWin );
- PrepareDC( dc );
-
- if ( m_currentCellCoords != wxGridNoCellCoords )
+ if ( m_displayed &&
+ m_currentCellCoords != wxGridNoCellCoords )
{
HideCellEditControl();
SaveEditControlValue();
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 );
+ }
}
}
if ( m_colWidths[coords.GetCol()] <=0 ||
m_rowHeights[coords.GetRow()] <= 0 ) return;
+#if !WXGRID_DRAW_LINES
if ( m_gridLinesEnabled )
DrawCellBorder( dc, coords );
+#endif
DrawCellBackground( dc, coords );
// 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
//
- 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 );
}
// 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;
- 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;
- 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;
}
- 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
//
- 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;
}
- 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 );
}
}
}
{
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.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.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() );
{
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.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.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() );
}
}
+
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 )
{
- // 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 )
if ( !GetBatchCount() )
{
m_rowLabelWin->Refresh();
- m_colLabelWin->Refresh();
}
}
if ( !GetBatchCount() )
{
- m_rowLabelWin->Refresh();
m_colLabelWin->Refresh();
}
}
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 );
+ }
}
}
}
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 );
+ }
}
}
}
wxClientDC dc( m_gridWin );
PrepareDC( dc );
- DrawAllGridLines( dc );
+ DrawAllGridLines( dc, wxRegion() );
}
}
{
wxClientDC dc( m_gridWin );
PrepareDC( dc );
- DrawAllGridLines( dc );
+ DrawAllGridLines( dc, wxRegion() );
}
else
{
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.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.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();
- 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_gridWin->Refresh( TRUE, &r );
+ m_gridWin->Refresh( FALSE, &r );
}
wxGridRangeSelectEvent gridEvt( GetId(),
void wxGrid::SelectCol( int col, bool addToSelected )
{
- wxRect r;
-
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.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.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
{
+ wxRect r;
+
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_gridWin->Refresh( TRUE, &r );
+ m_gridWin->Refresh( FALSE, &r );
}
wxGridRangeSelectEvent gridEvt( GetId(),
void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
{
int temp;
- bool changed = false;
wxGridCellCoords updateTopLeft, updateBottomRight;
if ( topRow > bottomRow )
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
projects / wxWidgets.git / blobdiff