#include "wx/tokenzr.h"
#include "wx/grid.h"
+#include "wx/generic/gridsel.h"
// ----------------------------------------------------------------------------
// array classes
delete m_table;
delete m_typeRegistry;
+ delete m_selection;
}
// create the type registry
m_typeRegistry = new wxGridTypeRegistry;
-
+ m_selection = 0;
// subwindow components that make up the wxGrid
m_cornerLabelWin = new wxGridCornerLabelWindow( this,
-1,
}
-bool wxGrid::CreateGrid( int numRows, int numCols )
+bool wxGrid::CreateGrid( int numRows, int numCols,
+ wxGrid::wxGridSelectionModes selmode )
{
if ( m_created )
{
Init();
m_created = TRUE;
}
-
+ m_selection = new wxGridSelection( this, selmode );
return m_created;
}
m_currentCellCoords = wxGridNoCellCoords;
- m_selectedTopLeft = wxGridNoCellCoords;
- m_selectedBottomRight = wxGridNoCellCoords;
+ m_selectingTopLeft = wxGridNoCellCoords;
+ m_selectingBottomRight = wxGridNoCellCoords;
m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
//
if ( event.LeftDown() && coords != wxGridNoCellCoords )
{
+ if ( !event.ShiftDown() && !event.ControlDown() )
+ ClearSelection();
if ( event.ShiftDown() )
{
SelectBlock( m_currentCellCoords, coords );
}
else
{
+ m_selection->ToggleCellSelection( coords.GetRow(),
+ coords.GetCol() );
+ m_selectingTopLeft = wxGridNoCellCoords;
+ m_selectingBottomRight = wxGridNoCellCoords;
SetCurrentCell( coords );
m_waitForSlowClick = TRUE;
}
{
if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
{
- if ( IsSelection() )
+ if ( m_selectingTopLeft != wxGridNoCellCoords &&
+ m_selectingBottomRight != wxGridNoCellCoords )
{
+ m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
+ m_selectingTopLeft.GetCol(),
+ m_selectingBottomRight.GetRow(),
+ m_selectingBottomRight.GetCol() );
if (m_winCapture)
{
m_winCapture->ReleaseMouse();
SetCurrentCell( 0, 0 );
}
- ClearSelection();
+ m_selection->UpdateRows( pos, numRows );
if ( !GetBatchCount() ) Refresh();
}
// the table will have sent the results of the append row
// operation to this view object as a grid table message
//
- ClearSelection();
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
// the table will have sent the results of the delete row
// operation to this view object as a grid table message
//
- ClearSelection();
+ m_selection->UpdateRows( pos, -((int)numRows) );
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
SetCurrentCell( 0, 0 );
}
- ClearSelection();
+ m_selection->UpdateCols( pos, numCols );
if ( !GetBatchCount() ) Refresh();
}
SetCurrentCell( 0, 0 );
}
- ClearSelection();
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
// the table will have sent the results of the delete col
// operation to this view object as a grid table message
//
- ClearSelection();
+ m_selection->UpdateCols( pos, -((int)numCols) );
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
wxGridRangeSelectEvent gridEvt( GetId(),
type,
this,
- m_selectedTopLeft,
- m_selectedBottomRight,
+ m_selectingTopLeft,
+ m_selectingBottomRight,
mouseEv.ControlDown(),
mouseEv.ShiftDown(),
mouseEv.AltDown(),
wxGridCellAttr* attr = GetCellAttr(coords);
DrawCellHighlight(dc, attr);
attr->DecRef();
-
+#if 0
+ // SN: For my extended selection code, automatic
+ // deselection is definitely not a good idea.
if ( IsSelection() )
{
wxRect r( SelectionToDeviceRect() );
ClearSelection();
if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
}
+#endif
}
}
void wxGrid::SelectRow( int row, bool addToSelected )
{
- wxRect r;
-
- if ( IsSelection() && addToSelected )
- {
- wxRect rect[4];
- bool need_refresh[4];
- need_refresh[0] =
- need_refresh[1] =
- need_refresh[2] =
- need_refresh[3] = FALSE;
-
- int i;
+ if ( IsSelection() && !addToSelected )
+ m_selection->ClearSelection();
- 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 );
- }
-
- if ( oldLeft > 0 )
- {
- need_refresh[1] = TRUE;
- rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop, 0 ),
- wxGridCellCoords ( oldBottom,
- oldLeft - 1 ) );
-
- m_selectedTopLeft.SetCol( 0 );
- }
-
- if ( oldBottom < row )
- {
- need_refresh[2] = TRUE;
- rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldBottom + 1, 0 ),
- wxGridCellCoords ( row,
- m_numCols - 1 ) );
- m_selectedBottomRight.SetRow( row );
- }
-
- 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 );
- }
-
- 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( FALSE, &r );
-
- m_selectedTopLeft.Set( row, 0 );
- m_selectedBottomRight.Set( row, m_numCols-1 );
- r = SelectionToDeviceRect();
- m_gridWin->Refresh( FALSE, &r );
- }
+ m_selection->SelectRow( row );
wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT,
this,
- m_selectedTopLeft,
- m_selectedBottomRight );
+ wxGridCellCoords( row, 0 ),
+ wxGridCellCoords( row, m_numCols - 1 ) );
GetEventHandler()->ProcessEvent(gridEvt);
}
void wxGrid::SelectCol( int col, bool addToSelected )
{
- if ( IsSelection() && addToSelected )
- {
- wxRect rect[4];
- bool need_refresh[4];
- need_refresh[0] =
- need_refresh[1] =
- need_refresh[2] =
- need_refresh[3] = 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 );
- }
-
- if ( oldTop > 0 )
- {
- need_refresh[1] = TRUE;
- rect[1] = BlockToDeviceRect( wxGridCellCoords ( 0, oldLeft ),
- wxGridCellCoords ( oldTop - 1,
- oldRight ) );
- m_selectedTopLeft.SetRow( 0 );
- }
-
- if ( oldRight < col )
- {
- need_refresh[2] = TRUE;
- rect[2] = BlockToDeviceRect( wxGridCellCoords ( 0, oldRight + 1 ),
- wxGridCellCoords ( m_numRows - 1,
- col ) );
- m_selectedBottomRight.SetCol( col );
- }
+ if ( IsSelection() && !addToSelected )
+ m_selection->ClearSelection();
- 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 );
- }
-
- 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( FALSE, &r );
-
- m_selectedTopLeft.Set( 0, col );
- m_selectedBottomRight.Set( m_numRows-1, col );
- r = SelectionToDeviceRect();
- m_gridWin->Refresh( FALSE, &r );
- }
+ m_selection->SelectCol( col );
wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT,
this,
- m_selectedTopLeft,
- m_selectedBottomRight );
+ wxGridCellCoords( 0, col ),
+ wxGridCellCoords( m_numRows - 1, col ) );
GetEventHandler()->ProcessEvent(gridEvt);
}
updateTopLeft = wxGridCellCoords( topRow, leftCol );
updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
- if ( m_selectedTopLeft != updateTopLeft ||
- m_selectedBottomRight != updateBottomRight )
+ if ( m_selectingTopLeft != updateTopLeft ||
+ m_selectingBottomRight != updateBottomRight )
{
// Compute two optimal update rectangles:
// Either one rectangle is a real subset of the
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();
+ wxCoord oldLeft = m_selectingTopLeft.GetCol();
+ wxCoord oldTop = m_selectingTopLeft.GetRow();
+ wxCoord oldRight = m_selectingBottomRight.GetCol();
+ wxCoord oldBottom = m_selectingBottomRight.GetRow();
// Determine the outer/inner coordinates.
if (oldLeft > leftCol)
// Change Selection
- m_selectedTopLeft = updateTopLeft;
- m_selectedBottomRight = updateBottomRight;
+ m_selectingTopLeft = updateTopLeft;
+ m_selectingBottomRight = updateBottomRight;
// various Refresh() calls
for (i = 0; i < 4; i++ )
wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT,
this,
- m_selectedTopLeft,
- m_selectedBottomRight );
+ m_selectingTopLeft,
+ m_selectingBottomRight );
GetEventHandler()->ProcessEvent(gridEvt);
}
void wxGrid::SelectAll()
{
- m_selectedTopLeft.Set( 0, 0 );
- m_selectedBottomRight.Set( m_numRows-1, m_numCols-1 );
+ m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
+}
- m_gridWin->Refresh();
+bool wxGrid::IsSelection()
+{
+ return ( m_selection->IsSelection() ||
+ ( m_selectingTopLeft != wxGridNoCellCoords &&
+ m_selectingBottomRight != wxGridNoCellCoords ) );
}
+bool wxGrid::IsInSelection( int row, int col )
+{
+ return ( m_selection->IsInSelection( row, col ) ||
+ ( row >= m_selectingTopLeft.GetRow() &&
+ col >= m_selectingTopLeft.GetCol() &&
+ row <= m_selectingBottomRight.GetRow() &&
+ col <= m_selectingBottomRight.GetCol() ) );
+}
void wxGrid::ClearSelection()
{
- m_selectedTopLeft = wxGridNoCellCoords;
- m_selectedBottomRight = wxGridNoCellCoords;
+ m_selectingTopLeft = wxGridNoCellCoords;
+ m_selectingBottomRight = wxGridNoCellCoords;
+ m_selection->ClearSelection();
}
#endif // ifndef wxUSE_NEW_GRID
-
#include "wx/generic/gridsel.h"
wxGridSelection::wxGridSelection( wxGrid * grid,
- wxGridSelection::wxGridSelectionModes sel )
+ wxGrid::wxGridSelectionModes sel )
{
m_grid = grid;
m_selectionMode = sel;
bool wxGridSelection::IsSelection()
{
return ( m_cellSelection.GetCount() || m_blockSelectionTopLeft.GetCount() ||
- m_rowSelection.GetCount() || m_colSelection.GetCount() );
+ m_rowSelection.GetCount() || m_colSelection.GetCount() );
}
bool wxGridSelection::IsInSelection ( int row, int col )
{
size_t count;
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_cellSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( row == coords.GetRow() && col == coords.GetCol() )
- return true;
- }
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxGridCellCoords& coords = m_cellSelection[n];
+ if ( row == coords.GetRow() && col == coords.GetCol() )
+ return true;
+ }
}
count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
- wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
- if ( BlockContainsCell(coords1.GetRow(), coords1.GetCol(),
- coords2.GetRow(), coords2.GetCol(),
- row, col ) )
- return true;
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
+ wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
+ if ( BlockContainsCell(coords1.GetRow(), coords1.GetCol(),
+ coords2.GetRow(), coords2.GetCol(),
+ row, col ) )
+ return true;
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- size_t count = m_rowSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( row == m_rowSelection[n] )
- return true;
- }
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows )
+ size_t count = m_rowSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( row == m_rowSelection[n] )
+ return true;
+ }
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- size_t count = m_colSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( col == m_colSelection[n] )
- return true;
- }
+ size_t count = m_colSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( col == m_colSelection[n] )
+ return true;
+ }
}
return false;
}
void wxGridSelection::SelectRow( int row, bool addToSelected = FALSE )
{
- if ( m_selectionMode == wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode == wxGrid::wxGridSelectColumns )
return;
size_t count;
// Remove single cells contained in newly selected block.
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_cellSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( BlockContainsCell( row, 0, row, m_grid->GetNumberCols() - 1,
- coords.GetRow(), coords.GetCol() ) )
- {
- m_cellSelection.RemoveAt(n);
- n--; count--;
- }
- }
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxGridCellCoords& coords = m_cellSelection[n];
+ if ( BlockContainsCell( row, 0, row, m_grid->GetNumberCols() - 1,
+ coords.GetRow(), coords.GetCol() ) )
+ {
+ m_cellSelection.RemoveAt(n);
+ n--; count--;
+ }
+ }
}
// If possible, merge row with existing selected block
count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
- wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
- if ( coords1.GetRow() == row && row == coords2.GetRow() )
- {
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- }
- else if ( coords1.GetCol() == 0 &&
- coords2.GetCol() == m_grid->GetNumberCols() - 1 )
- {
- if ( coords1.GetRow() <= row && row <= coords2.GetRow() )
- return;
- else if ( coords1.GetRow() == row + 1)
- {
- coords1.SetRow(row);
- return;
- }
- else if ( coords2.GetRow() == row - 1)
- {
- coords2.SetRow(row);
- return;
- }
- }
+ wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
+ wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
+ if ( coords1.GetRow() == row && row == coords2.GetRow() )
+ {
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ }
+ else if ( coords1.GetCol() == 0 &&
+ coords2.GetCol() == m_grid->GetNumberCols() - 1 )
+ {
+ if ( coords1.GetRow() <= row && row <= coords2.GetRow() )
+ return;
+ else if ( coords1.GetRow() == row + 1)
+ {
+ coords1.SetRow(row);
+ return;
+ }
+ else if ( coords2.GetRow() == row - 1)
+ {
+ coords2.SetRow(row);
+ return;
+ }
+ }
}
// Check whether row is already selected.
for ( size_t n = 0; n < count; n++ )
{
if ( row == m_rowSelection[n] )
- return;
+ return;
}
// Add row to selection
m_rowSelection.Add(row);
+
+ // Update View:
+ wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
+ wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
void wxGridSelection::SelectCol( int col, bool addToSelected = FALSE )
{
- if ( m_selectionMode == wxGridSelection::wxGridSelectRows )
+ if ( m_selectionMode == wxGrid::wxGridSelectRows )
return;
size_t count;
// Remove single cells contained in newly selected block.
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_cellSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( BlockContainsCell( 0, col, m_grid->GetNumberRows() - 1, col,
- coords.GetRow(), coords.GetCol() ) )
- {
- m_cellSelection.RemoveAt(n);
- n--; count--;
- }
- }
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxGridCellCoords& coords = m_cellSelection[n];
+ if ( BlockContainsCell( 0, col, m_grid->GetNumberRows() - 1, col,
+ coords.GetRow(), coords.GetCol() ) )
+ {
+ m_cellSelection.RemoveAt(n);
+ n--; count--;
+ }
+ }
}
// If possible, merge col with existing selected block
count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
- wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
- if ( coords1.GetCol() == col && col == coords2.GetCol() )
- {
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- }
- else if ( coords1.GetRow() == 0 &&
- coords2.GetRow() == m_grid->GetNumberRows() - 1 )
- {
- if ( coords1.GetCol() <= col && col <= coords2.GetCol() )
- return;
- else if ( coords1.GetCol() == col + 1)
- {
- coords1.SetCol(col);
- return;
- }
- else if ( coords2.GetCol() == col - 1)
- {
- coords2.SetCol(col);
- return;
- }
- }
+ wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
+ wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
+ if ( coords1.GetCol() == col && col == coords2.GetCol() )
+ {
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ }
+ else if ( coords1.GetRow() == 0 &&
+ coords2.GetRow() == m_grid->GetNumberRows() - 1 )
+ {
+ if ( coords1.GetCol() <= col && col <= coords2.GetCol() )
+ return;
+ else if ( coords1.GetCol() == col + 1)
+ {
+ coords1.SetCol(col);
+ return;
+ }
+ else if ( coords2.GetCol() == col - 1)
+ {
+ coords2.SetCol(col);
+ return;
+ }
+ }
}
// Check whether col is already selected.
for ( size_t n = 0; n < count; n++ )
{
if ( col == m_colSelection[n] )
- return;
+ return;
}
// Add col to selection
m_colSelection.Add(col);
+
+ // Update View:
+ wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
+ wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
void wxGridSelection::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
{
// Fix the coordinates of the block if potentially needed
- if ( m_selectionMode == wxGridSelection::wxGridSelectRows )
+ if ( m_selectionMode == wxGrid::wxGridSelectRows )
{
- leftCol = 0;
- rightCol = m_grid->GetNumberCols() - 1;
+ leftCol = 0;
+ rightCol = m_grid->GetNumberCols() - 1;
}
- else if ( m_selectionMode == wxGridSelection::wxGridSelectColumns )
+ else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
{
- topRow = 0;
- bottomRow = m_grid->GetNumberRows() - 1;
+ topRow = 0;
+ bottomRow = m_grid->GetNumberRows() - 1;
}
// Handle single cell selection in SelectCell.
size_t count;
// Remove single cells contained in newly selected block.
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_cellSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
- coords.GetRow(), coords.GetCol() ) )
- {
- m_cellSelection.RemoveAt(n);
- n--; count--;
- }
- }
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxGridCellCoords& coords = m_cellSelection[n];
+ if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
+ coords.GetRow(), coords.GetCol() ) )
+ {
+ m_cellSelection.RemoveAt(n);
+ n--; count--;
+ }
+ }
}
// If a block containing the selection is already selected, return,
count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
- wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
- switch ( BlockContain( coords1.GetRow(), coords1.GetCol(),
- coords2.GetRow(), coords2.GetCol(),
- topRow, leftCol, bottomRow, rightCol ) )
- {
- case 1:
- return;
- case -1:
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- default:
- ;
- }
+ wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
+ wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
+ switch ( BlockContain( coords1.GetRow(), coords1.GetCol(),
+ coords2.GetRow(), coords2.GetCol(),
+ topRow, leftCol, bottomRow, rightCol ) )
+ {
+ case 1:
+ return;
+ case -1:
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ default:
+ ;
+ }
}
// If a row containing the selection is already selected, return,
// if a row contained in newly selected block is found, remove it.
- if ( m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- size_t count = m_rowSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- switch ( BlockContain( m_rowSelection[n], 0,
- m_rowSelection[n], m_grid->GetNumberCols()-1,
- topRow, leftCol, bottomRow, rightCol ) )
- {
- case 1:
- return;
- case -1:
- m_rowSelection.RemoveAt(n);
- n--; count--;
- default:
- ;
- }
- }
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows )
+ size_t count = m_rowSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ switch ( BlockContain( m_rowSelection[n], 0,
+ m_rowSelection[n], m_grid->GetNumberCols()-1,
+ topRow, leftCol, bottomRow, rightCol ) )
+ {
+ case 1:
+ return;
+ case -1:
+ m_rowSelection.RemoveAt(n);
+ n--; count--;
+ default:
+ ;
+ }
+ }
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- size_t count = m_colSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- switch ( BlockContain( 0, m_colSelection[n],
- m_grid->GetNumberRows()-1, m_colSelection[n],
- topRow, leftCol, bottomRow, rightCol ) )
- {
- case 1:
- return;
- case -1:
- m_colSelection.RemoveAt(n);
- n--; count--;
- default:
- ;
- }
- }
+ size_t count = m_colSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ switch ( BlockContain( 0, m_colSelection[n],
+ m_grid->GetNumberRows()-1, m_colSelection[n],
+ topRow, leftCol, bottomRow, rightCol ) )
+ {
+ case 1:
+ return;
+ case -1:
+ m_colSelection.RemoveAt(n);
+ n--; count--;
+ default:
+ ;
+ }
+ }
}
m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
+
+ // Update View:
+ wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
+ wxGridCellCoords( bottomRow, rightCol ) );
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
void wxGridSelection::SelectCell( int row, int col)
{
- if ( m_selectionMode == wxGridSelection::wxGridSelectRows )
+ if ( m_selectionMode == wxGrid::wxGridSelectRows )
SelectBlock(row, 0, row, m_grid->GetNumberCols() - 1 );
- else if ( m_selectionMode == wxGridSelection::wxGridSelectColumns )
+ else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
SelectBlock(0, col, m_grid->GetNumberRows() - 1, col );
else if ( IsInSelection ( row, col ) )
return;
m_cellSelection.Add( wxGridCellCoords( row, col ) );
+
+ wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ) );
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
void wxGridSelection::ToggleCellSelection( int row, int col)
{
if ( !IsInSelection ( row, col ) )
+ {
SelectCell( row, col );
+ return;
+ }
size_t count;
// Maybe we want to toggle a member of m_cellSelection.
// Then it can't be contained in rows/cols/block, and we
// just have to remove it from m_cellSelection.
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_cellSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( row == coords.GetRow() && col == coords.GetCol() )
- {
- m_cellSelection.RemoveAt(n);
- n--; count--;
- wxRect r;
- r = m_grid->BlockToDeviceRect( m_cellSelection[n],
- m_cellSelection[n] );
- if ( !m_grid->GetBatchCount() )
- ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
- return;
- }
- }
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxGridCellCoords& coords = m_cellSelection[n];
+ if ( row == coords.GetRow() && col == coords.GetCol() )
+ {
+ wxRect r;
+ r = m_grid->BlockToDeviceRect( m_cellSelection[n],
+ m_cellSelection[n] );
+ m_cellSelection.RemoveAt(n);
+ n--; count--;
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+ return;
+ }
+ }
}
// remove a cell from the middle of a block (the really ugly case)
count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
- wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
- int topRow = coords1.GetRow();
- int leftCol = coords1.GetCol();
- int bottomRow = coords2.GetRow();
- int rightCol = coords2.GetCol();
- if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
- row, col ) )
- {
- // remove the block
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- // add up to 4 smaller blocks and set update region
- if ( m_selectionMode != wxGridSelection::wxGridSelectColumns )
- {
- if ( topRow < row )
- SelectBlock( topRow, leftCol, row - 1, rightCol );
- if ( bottomRow > row )
- SelectBlock( row + 1, leftCol, bottomRow, rightCol );
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows )
- {
- if ( leftCol < col )
- SelectBlock( row, leftCol, row, col - 1 );
- if ( rightCol > col )
- SelectBlock( row, col + 1, row, rightCol );
- }
- }
+ wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
+ wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
+ int topRow = coords1.GetRow();
+ int leftCol = coords1.GetCol();
+ int bottomRow = coords2.GetRow();
+ int rightCol = coords2.GetCol();
+ if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
+ row, col ) )
+ {
+ // remove the block
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ // add up to 4 smaller blocks and set update region
+ if ( m_selectionMode != wxGrid::wxGridSelectColumns )
+ {
+ if ( topRow < row )
+ SelectBlock( topRow, leftCol, row - 1, rightCol );
+ if ( bottomRow > row )
+ SelectBlock( row + 1, leftCol, bottomRow, rightCol );
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectRows )
+ {
+ if ( leftCol < col )
+ SelectBlock( row, leftCol, row, col - 1 );
+ if ( rightCol > col )
+ SelectBlock( row, col + 1, row, rightCol );
+ }
+ }
}
// remove a cell from a row, adding up to two new blocks
- if ( m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- size_t count = m_rowSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( m_rowSelection[n] == row )
- {
- m_rowSelection.RemoveAt(n);
- n--; count--;
- if (m_selectionMode == wxGridSelection::wxGridSelectCells)
- {
- if ( col > 0 )
- SelectBlock( row, 0, row, col - 1 );
- if ( col < m_grid->GetNumberCols() - 1 )
- SelectBlock( row, col + 1, row, m_grid->GetNumberCols() - 1 );
- }
- }
- }
+ size_t count = m_rowSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( m_rowSelection[n] == row )
+ {
+ m_rowSelection.RemoveAt(n);
+ n--; count--;
+ if (m_selectionMode == wxGrid::wxGridSelectCells)
+ {
+ if ( col > 0 )
+ SelectBlock( row, 0, row, col - 1 );
+ if ( col < m_grid->GetNumberCols() - 1 )
+ SelectBlock( row, col + 1, row, m_grid->GetNumberCols() - 1 );
+ }
+ }
+ }
}
// remove a cell from a column, adding up to two new blocks
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- size_t count = m_colSelection.GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( m_colSelection[n] == col )
- {
- m_colSelection.RemoveAt(n);
- n--; count--;
- if (m_selectionMode == wxGridSelection::wxGridSelectCells)
- {
- if ( row > 0 )
- SelectBlock( 0, col, row - 1, col );
- if ( row < m_grid->GetNumberRows() - 1 )
- SelectBlock( row + 1, col, m_grid->GetNumberRows() - 1, col );
- }
- }
- }
+ size_t count = m_colSelection.GetCount();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( m_colSelection[n] == col )
+ {
+ m_colSelection.RemoveAt(n);
+ n--; count--;
+ if (m_selectionMode == wxGrid::wxGridSelectCells)
+ {
+ if ( row > 0 )
+ SelectBlock( 0, col, row - 1, col );
+ if ( row < m_grid->GetNumberRows() - 1 )
+ SelectBlock( row + 1, col, m_grid->GetNumberRows() - 1, col );
+ }
+ }
+ }
}
wxRect r;
switch (m_selectionMode)
{
- case wxGridSelection::wxGridSelectCells:
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
- wxGridCellCoords( row, col ) );
- break;
- case wxGridSelection::wxGridSelectRows:
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
- wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
- break;
- case wxGridSelection::wxGridSelectColumns:
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
- wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
- break;
+ case wxGrid::wxGridSelectCells:
+ r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ) );
+ break;
+ case wxGrid::wxGridSelectRows:
+ r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
+ wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+ break;
+ case wxGrid::wxGridSelectColumns:
+ r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
+ wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+ break;
}
if ( !m_grid->GetBatchCount() )
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
void wxGridSelection::ClearSelection()
{
size_t n;
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows &&
- m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ if ( m_selectionMode != wxGrid::wxGridSelectRows &&
+ m_selectionMode != wxGrid::wxGridSelectColumns )
{
- while( ( n = m_cellSelection.GetCount() ) > 0)
- {
- wxRect r;
- r = m_grid->BlockToDeviceRect( m_cellSelection[n],
- m_cellSelection[n] );
- m_cellSelection.RemoveAt(n);
- if ( !m_grid->GetBatchCount() )
- ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
- }
+ while( ( n = m_cellSelection.GetCount() ) > 0)
+ {
+ wxRect r;
+ n--;
+ r = m_grid->BlockToDeviceRect( m_cellSelection[n],
+ m_cellSelection[n] );
+ m_cellSelection.RemoveAt(n);
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+ }
}
while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
{
wxRect r;
- r = m_grid->BlockToDeviceRect( m_blockSelectionTopLeft[n],
- m_blockSelectionBottomRight[n] );
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- if ( !m_grid->GetBatchCount() )
- ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectColumns )
+ n--;
+ r = m_grid->BlockToDeviceRect( m_blockSelectionTopLeft[n],
+ m_blockSelectionBottomRight[n] );
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- while( ( n = m_rowSelection.GetCount() ) > 0)
- {
- int & row = m_rowSelection[n];
- wxRect r;
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
- wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
- m_rowSelection.RemoveAt(n);
- if ( !m_grid->GetBatchCount() )
- ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
- }
- }
- if ( m_selectionMode != wxGridSelection::wxGridSelectRows )
+ 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 ) );
+ m_rowSelection.RemoveAt(n);
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+ }
+ }
+ if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- while( ( n = m_colSelection.GetCount() ) > 0)
- {
- int & col = m_colSelection[n];
- wxRect r;
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
- wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
- m_colSelection.RemoveAt(n);
- if ( !m_grid->GetBatchCount() )
- ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
- }
+ 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 ) );
+ m_colSelection.RemoveAt(n);
+ if ( !m_grid->GetBatchCount() )
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
+ }
}
}
{
// If rows inserted, increase row counter where necessary
coords2.SetRow(row2 + numRows);
- if ( (size_t)row1 >= pos )
- coords1.SetRow(row1 + numRows);
+ if ( (size_t)row1 >= pos )
+ coords1.SetRow(row1 + numRows);
}
else if (numRows < 0)
{
{
// ...either decrement row counter (if row still exists)...
coords2.SetRow(row2 + numRows);
- if ( (size_t) row1 >= pos)
- coords1.SetRow( wxMax(row1 + numRows, (int) pos) );
-
+ if ( (size_t) row1 >= pos)
+ coords1.SetRow( wxMax(row1 + numRows, (int) pos) );
+
}
else
{
- if ( (size_t) row1 >= pos)
- {
- // ...or remove the attribute
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- }
- else
- coords2.SetRow(pos);
+ if ( (size_t) row1 >= pos)
+ {
+ // ...or remove the attribute
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ }
+ else
+ coords2.SetRow(pos);
}
}
}
{
// If rows inserted, increase row counter where necessary
coords2.SetCol(col2 + numCols);
- if ( (size_t)col1 >= pos )
- coords1.SetCol(col1 + numCols);
+ if ( (size_t)col1 >= pos )
+ coords1.SetCol(col1 + numCols);
}
else if (numCols < 0)
{
{
// ...either decrement col counter (if col still exists)...
coords2.SetCol(col2 + numCols);
- if ( (size_t) col1 >= pos)
- coords1.SetCol( wxMax(col1 + numCols, (int) pos) );
-
+ if ( (size_t) col1 >= pos)
+ coords1.SetCol( wxMax(col1 + numCols, (int) pos) );
+
}
else
{
- if ( (size_t) col1 >= pos)
- {
- // ...or remove the attribute
- m_blockSelectionTopLeft.RemoveAt(n);
- m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
- }
- else
- coords2.SetCol(pos);
+ if ( (size_t) col1 >= pos)
+ {
+ // ...or remove the attribute
+ m_blockSelectionTopLeft.RemoveAt(n);
+ m_blockSelectionBottomRight.RemoveAt(n);
+ n--; count--;
+ }
+ else
+ coords2.SetCol(pos);
}
}
}
}
int wxGridSelection::BlockContain( int topRow1, int leftCol1,
- int bottomRow1, int rightCol1,
- int topRow2, int leftCol2,
- int bottomRow2, int rightCol2 )
+ int bottomRow1, int rightCol1,
+ int topRow2, int leftCol2,
+ int bottomRow2, int rightCol2 )
// returns 1, if Block1 contains Block2,
// -1, if Block2 contains Block1,
// 0, otherwise
{
if ( topRow1 <= topRow2 && bottomRow2 <= bottomRow1 &&
- leftCol1 <= leftCol2 && rightCol2 <= rightCol1 )
+ leftCol1 <= leftCol2 && rightCol2 <= rightCol1 )
return 1;
else if ( topRow2 <= topRow1 && bottomRow1 <= bottomRow2 &&
- leftCol2 <= leftCol1 && rightCol1 <= rightCol2 )
+ leftCol2 <= leftCol1 && rightCol1 <= rightCol2 )
return -1;
return 0;
}
projects / wxWidgets.git / commitdiff
