///////////////////////////////////////////////////////////////////////////
-// Name: generic/gridsel.cpp
+// Name: src/generic/gridsel.cpp
// Purpose: wxGridSelection
// Author: Stefan Neis
// Modified by:
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
// ============================================================================
// declarations
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "gridsel.h"
-#endif
-
-// For compilers that support precompilation, includes "wx/wx.h".
-#include "wx/wxprec.h"
-
-#include "wx/defs.h"
-
-#ifdef __BORLANDC__
- #pragma hdrstop
-#endif
-
#if wxUSE_GRID
#include "wx/generic/gridsel.h"
+
// Some explanation for the members of the class:
// m_cellSelection stores individual selected cells
// -- this is only used if m_selectionMode == wxGridSelectCells
m_rowSelection.GetCount() || m_colSelection.GetCount() );
}
-bool wxGridSelection::IsInSelection ( int row, int col )
+bool wxGridSelection::IsInSelection( int row, int col )
{
size_t count;
// (unless we are in column selection mode).
if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- size_t count = m_rowSelection.GetCount();
+ count = m_rowSelection.GetCount();
for ( size_t n = 0; n < count; n++ )
{
if ( row == m_rowSelection[n] )
// (unless we are in row selection mode).
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- size_t count = m_colSelection.GetCount();
+ count = m_colSelection.GetCount();
for ( size_t n = 0; n < count; n++ )
{
if ( col == m_colSelection[n] )
return true;
}
}
+
return false;
}
// Change the selection mode
-void wxGridSelection::SetSelectionMode(wxGrid::wxGridSelectionModes selmode)
+void wxGridSelection::SetSelectionMode( wxGrid::wxGridSelectionModes selmode )
{
// if selection mode is unchanged return immediately
if (selmode == m_selectionMode)
SelectCol( col );
}
- for (n = 0; n < m_blockSelectionTopLeft.GetCount(); n++)
// Note that m_blockSelectionTopLeft's size may be changing!
+ for (n = 0; n < m_blockSelectionTopLeft.GetCount(); n++)
{
wxGridCellCoords& coords = m_blockSelectionTopLeft[n];
int topRow = coords.GetRow();
coords = m_blockSelectionBottomRight[n];
int bottomRow = coords.GetRow();
int rightCol = coords.GetCol();
+
if (selmode == wxGrid::wxGridSelectRows)
{
if (leftCol != 0 || rightCol != m_grid->GetNumberCols() - 1 )
}
}
}
+
m_selectionMode = selmode;
}
}
{
if ( m_selectionMode == wxGrid::wxGridSelectColumns )
return;
+
size_t count, n;
// Remove single cells contained in newly selected block.
coords.GetRow(), coords.GetCol() ) )
{
m_cellSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
// Simplify list of selected blocks (if possible)
count = m_blockSelectionTopLeft.GetCount();
bool done = false;
+
for ( n = 0; n < count; n++ )
{
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
{
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
else if ( coords1.GetCol() == 0 &&
coords2.GetCol() == m_grid->GetNumberCols() - 1 )
ControlDown, ShiftDown,
AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
void wxGridSelection::SelectCol( int col,
coords.GetRow(), coords.GetCol() ) )
{
m_cellSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
{
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
else if ( coords1.GetRow() == 0 &&
coords2.GetRow() == m_grid->GetNumberRows() - 1 )
ControlDown, ShiftDown,
AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
void wxGridSelection::SelectBlock( int topRow, int leftCol,
topRow = 0;
bottomRow = m_grid->GetNumberRows() - 1;
}
+
if ( topRow > bottomRow )
{
int temp = topRow;
// grid only has 1 col)
if ( m_selectionMode == wxGrid::wxGridSelectCells &&
topRow == bottomRow && leftCol == rightCol )
+ {
SelectCell( topRow, leftCol, ControlDown, ShiftDown,
AltDown, MetaDown, sendEvent );
+ }
size_t count, n;
+
// Remove single cells contained in newly selected block.
if ( m_selectionMode == wxGrid::wxGridSelectCells )
{
coords.GetRow(), coords.GetCol() ) )
{
m_cellSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
{
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:
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
break;
default:
for ( n = 0; n < count; n++ )
{
switch ( BlockContain( m_rowSelection[n], 0,
- m_rowSelection[n], m_grid->GetNumberCols()-1,
+ m_rowSelection[n], m_grid->GetNumberCols() - 1,
topRow, leftCol, bottomRow, rightCol ) )
{
case 1:
case -1:
m_rowSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
break;
default:
}
}
}
+
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
count = m_colSelection.GetCount();
for ( n = 0; n < count; n++ )
{
switch ( BlockContain( 0, m_colSelection[n],
- m_grid->GetNumberRows()-1, m_colSelection[n],
+ m_grid->GetNumberRows() - 1, m_colSelection[n],
topRow, leftCol, bottomRow, rightCol ) )
{
case 1:
case -1:
m_colSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
break;
default:
}
}
}
+
m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
if ( sendEvent )
{
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
- wxEVT_GRID_RANGE_SELECT,
- m_grid,
- wxGridCellCoords( topRow, leftCol ),
- wxGridCellCoords( bottomRow, rightCol ),
- true,
- ControlDown, ShiftDown,
- AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+ wxEVT_GRID_RANGE_SELECT,
+ m_grid,
+ wxGridCellCoords( topRow, leftCol ),
+ wxGridCellCoords( bottomRow, rightCol ),
+ true,
+ ControlDown, ShiftDown,
+ AltDown, MetaDown );
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
}
{
SelectBlock(row, 0, row, m_grid->GetNumberCols() - 1,
ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);
+
return;
}
else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
{
SelectBlock(0, col, m_grid->GetNumberRows() - 1, col,
ControlDown, ShiftDown, AltDown, MetaDown, sendEvent);
+
return;
}
else if ( IsInSelection ( row, col ) )
return;
+
m_cellSelection.Add( wxGridCellCoords( row, col ) );
// Update View:
if ( !m_grid->GetBatchCount() )
{
- wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
- wxGridCellCoords( row, col ) );
+ wxRect r = m_grid->BlockToDeviceRect(
+ wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
if (sendEvent)
{
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
- wxEVT_GRID_RANGE_SELECT,
- m_grid,
- wxGridCellCoords( row, col ),
- wxGridCellCoords( row, col ),
- true,
- ControlDown, ShiftDown,
- AltDown, MetaDown);
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+ wxEVT_GRID_RANGE_SELECT,
+ m_grid,
+ wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ),
+ true,
+ ControlDown, ShiftDown,
+ AltDown, MetaDown );
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
}
// if the cell is not selected, select it
if ( !IsInSelection ( row, col ) )
{
- SelectCell( row, col, ControlDown, ShiftDown,
- AltDown, MetaDown );
+ SelectCell( row, col, ControlDown, ShiftDown, AltDown, MetaDown );
+
return;
}
count = m_cellSelection.GetCount();
for ( n = 0; n < count; n++ )
{
- wxGridCellCoords& coords = m_cellSelection[n];
- if ( row == coords.GetRow() && col == coords.GetCol() )
+ const wxGridCellCoords& sel = m_cellSelection[n];
+ if ( row == sel.GetRow() && col == sel.GetCol() )
{
wxGridCellCoords coords = m_cellSelection[n];
m_cellSelection.RemoveAt(n);
false,
ControlDown, ShiftDown,
AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
+
return;
}
}
count = m_blockSelectionTopLeft.GetCount();
for ( 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 ) )
+
+ if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol, row, col ) )
{
// remove the block
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
+
// add up to 4 smaller blocks and set update region
if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
SelectBlock( row + 1, leftCol, bottomRow, rightCol,
false, false, false, false, false );
}
+
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
if ( leftCol < col )
if ( m_rowSelection[n] == row )
{
m_rowSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
+
if (m_selectionMode == wxGrid::wxGridSelectCells)
{
if ( col > 0 )
if ( m_colSelection[n] == col )
{
m_colSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
+
if (m_selectionMode == wxGrid::wxGridSelectCells)
{
if ( row > 0 )
wxRect r;
switch (m_selectionMode)
{
- case wxGrid::wxGridSelectCells:
- {
- if ( !m_grid->GetBatchCount() )
- {
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
- wxGridCellCoords( row, col ) );
- ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
- }
+ case wxGrid::wxGridSelectCells:
+ {
+ if ( !m_grid->GetBatchCount() )
+ {
+ r = m_grid->BlockToDeviceRect(
+ wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ) );
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+ }
- wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
- wxEVT_GRID_RANGE_SELECT,
- m_grid,
- wxGridCellCoords( row, col ),
- wxGridCellCoords( row, col ),
- false,
- ControlDown, ShiftDown,
- AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
- break;
- }
- case wxGrid::wxGridSelectRows:
- {
- if ( !m_grid->GetBatchCount() )
- {
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
- wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
- ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
- }
+ wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+ wxEVT_GRID_RANGE_SELECT,
+ m_grid,
+ wxGridCellCoords( row, col ),
+ wxGridCellCoords( row, col ),
+ false,
+ ControlDown, ShiftDown,
+ AltDown, MetaDown );
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
+ }
+ break;
- wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
- wxEVT_GRID_RANGE_SELECT,
- m_grid,
- wxGridCellCoords( row, 0 ),
- wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
- false,
- ControlDown, ShiftDown,
- AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
- break;
- }
- case wxGrid::wxGridSelectColumns:
- {
- if ( !m_grid->GetBatchCount() )
- {
- r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
- wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
+ case wxGrid::wxGridSelectRows:
+ {
+ if ( !m_grid->GetBatchCount() )
+ {
+ r = m_grid->BlockToDeviceRect(
+ wxGridCellCoords( row, 0 ),
+ wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
+ ((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+ }
+
+ wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+ wxEVT_GRID_RANGE_SELECT,
+ m_grid,
+ wxGridCellCoords( row, 0 ),
+ wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ),
+ false,
+ ControlDown, ShiftDown,
+ AltDown, MetaDown );
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
+ }
+ break;
+
+ case wxGrid::wxGridSelectColumns:
+ {
+ if ( !m_grid->GetBatchCount() )
+ {
+ r = m_grid->BlockToDeviceRect(
+ wxGridCellCoords( 0, col ),
+ wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
- }
+ }
- wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
- wxEVT_GRID_RANGE_SELECT,
- m_grid,
- wxGridCellCoords( 0, col ),
- wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
- false,
- ControlDown, ShiftDown,
- AltDown, MetaDown );
- m_grid->GetEventHandler()->ProcessEvent(gridEvt);
- break;
- }
+ wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
+ wxEVT_GRID_RANGE_SELECT,
+ m_grid,
+ wxGridCellCoords( 0, col ),
+ wxGridCellCoords( m_grid->GetNumberRows() - 1, col ),
+ false,
+ ControlDown, ShiftDown,
+ AltDown, MetaDown );
+ m_grid->GetEventHandler()->ProcessEvent( gridEvt );
+ }
+ break;
+
+ default:
+ break;
}
}
wxRect r;
wxGridCellCoords coords1, coords2;
- // deselect all invidiual cells and update the screen
+ // deselect all individual cells and update the screen
if ( m_selectionMode == wxGrid::wxGridSelectCells )
{
- while( ( n = m_cellSelection.GetCount() ) > 0)
+ while ( ( n = m_cellSelection.GetCount() ) > 0)
{
n--;
coords1 = m_cellSelection[n];
{
r = m_grid->BlockToDeviceRect( coords1, coords1 );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+
#ifdef __WXMAC__
((wxWindow *)m_grid->m_gridWin)->Update();
#endif
}
// deselect all blocks and update the screen
- while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
+ while ( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
{
n--;
coords1 = m_blockSelectionTopLeft[n];
{
r = m_grid->BlockToDeviceRect( coords1, coords2 );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+
#ifdef __WXMAC__
((wxWindow *)m_grid->m_gridWin)->Update();
#endif
// deselect all rows and update the screen
if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
- while( ( n = m_rowSelection.GetCount() ) > 0)
+ while ( ( n = m_rowSelection.GetCount() ) > 0)
{
n--;
int row = m_rowSelection[n];
r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+
#ifdef __WXMAC__
((wxWindow *)m_grid->m_gridWin)->Update();
#endif
// deselect all columns and update the screen
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
- while( ( n = m_colSelection.GetCount() ) > 0)
+ while ( ( n = m_colSelection.GetCount() ) > 0)
{
n--;
int col = m_colSelection[n];
r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
+
#ifdef __WXMAC__
((wxWindow *)m_grid->m_gridWin)->Update();
#endif
wxEVT_GRID_RANGE_SELECT,
m_grid,
wxGridCellCoords( 0, 0 ),
- wxGridCellCoords( m_grid->GetNumberRows() - 1,
- m_grid->GetNumberCols() - 1 ),
+ wxGridCellCoords(
+ m_grid->GetNumberRows() - 1,
+ m_grid->GetNumberCols() - 1 ),
false );
m_grid->GetEventHandler()->ProcessEvent(gridEvt);
{
// ...or remove the attribute
m_cellSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
wxCoord row1 = coords1.GetRow();
wxCoord row2 = coords2.GetRow();
+
if ((size_t)row2 >= pos)
{
if (numRows > 0)
{
// If rows inserted, increase row counter where necessary
- coords2.SetRow(row2 + numRows);
- if ( (size_t)row1 >= pos )
- coords1.SetRow(row1 + numRows);
+ coords2.SetRow( row2 + numRows );
+ if ((size_t)row1 >= pos)
+ coords1.SetRow( row1 + numRows );
}
else if (numRows < 0)
{
if ((size_t)row2 >= pos - numRows)
{
// ...either decrement row counter (if row still exists)...
- coords2.SetRow(row2 + numRows);
- if ( (size_t) row1 >= pos)
- coords1.SetRow( wxMax(row1 + numRows, (int) pos) );
+ coords2.SetRow( row2 + numRows );
+ if ((size_t)row1 >= pos)
+ coords1.SetRow( wxMax(row1 + numRows, (int)pos) );
}
else
{
- if ( (size_t) row1 >= pos)
+ if ((size_t)row1 >= pos)
{
// ...or remove the attribute
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
else
- coords2.SetRow(pos);
+ coords2.SetRow( pos );
}
}
}
count = m_rowSelection.GetCount();
for ( n = 0; n < count; n++ )
{
- int rowOrCol_ = m_rowSelection [ n ];
+ int rowOrCol_ = m_rowSelection[n];
- if ( ( size_t ) rowOrCol_ >= pos )
+ if ((size_t) rowOrCol_ >= pos)
{
if ( numRows > 0 )
{
- m_rowSelection [ n ] += numRows;
+ m_rowSelection[n] += numRows;
}
else if ( numRows < 0 )
{
- if ( ( size_t ) rowOrCol_ >= ( pos - numRows ) )
- m_rowSelection [ n ] += numRows;
+ if ((size_t)rowOrCol_ >= (pos - numRows))
+ m_rowSelection[n] += numRows;
else
{
- m_rowSelection.RemoveAt ( n );
+ m_rowSelection.RemoveAt( n );
n--;
count--;
}
{
size_t count = m_cellSelection.GetCount();
size_t n;
+
for ( n = 0; n < count; n++ )
{
wxGridCellCoords& coords = m_cellSelection[n];
{
// ...or remove the attribute
m_cellSelection.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
wxCoord col1 = coords1.GetCol();
wxCoord col2 = coords2.GetCol();
+
if ((size_t)col2 >= pos)
{
if (numCols > 0)
{
// If rows inserted, increase row counter where necessary
coords2.SetCol(col2 + numCols);
- if ( (size_t)col1 >= pos )
+ 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) );
+ coords1.SetCol( wxMax(col1 + numCols, (int)pos) );
}
else
{
- if ( (size_t) col1 >= pos)
+ if ((size_t)col1 >= pos)
{
// ...or remove the attribute
m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
else
coords2.SetCol(pos);
count = m_colSelection.GetCount();
for ( n = 0; n < count; n++ )
{
+ int rowOrCol = m_colSelection[n];
- int rowOrCol = m_colSelection [ n ];
- if ( ( size_t ) rowOrCol >= pos )
+ if ((size_t)rowOrCol >= pos)
{
if ( numCols > 0 )
- m_colSelection [ n ] += numCols;
+ m_colSelection[n] += numCols;
else if ( numCols < 0 )
{
- if ( ( size_t ) rowOrCol >= ( pos -numCols ) )
- m_colSelection [ n ] += numCols;
+ if ((size_t)rowOrCol >= (pos - numCols))
+ m_colSelection[n] += numCols;
else
{
- m_colSelection.RemoveAt ( n );
+ m_colSelection.RemoveAt( n );
n--;
count--;
}
}
}
-
}
// No need to touch selected rows, unless we removed _all_
m_rowSelection.Clear();
}
-
int wxGridSelection::BlockContain( int topRow1, int leftCol1,
int bottomRow1, int rightCol1,
int topRow2, int leftCol2,
else if ( topRow2 <= topRow1 && bottomRow1 <= bottomRow2 &&
leftCol2 <= leftCol1 && rightCol1 <= rightCol2 )
return -1;
+
return 0;
}
projects / wxWidgets.git / blobdiff