bool nuiMatrixView::ForceSelectColumn(uint col, bool set)
{
bool eventDisabled = false;
if (!SelectionChanged.IsEnabled())
eventDisabled = true;
if (!eventDisabled)
SelectionChanged.Disable();
uint firstRow=0;
if (mColumnHeader)
firstRow=1;
// unselect
if (!set)
{
for (uint k=firstRow; k < GetNbRows(); k++)
SelectCell(col, k, false, false);
mColumnSelected[col] = false;
}
// select
else
{
for (uint k=firstRow; k < GetNbRows(); k++)
SelectCell(col, k, true, false);
mColumnSelected[col] = true;
}
if (!eventDisabled)
SelectionChanged.Enable();
SelectionChanged();
return true;
}
bool nuiMatrixView::ForceSelectRow(uint row, bool set)
{
bool eventDisabled = false;
if (!SelectionChanged.IsEnabled())
eventDisabled = true;
if (!eventDisabled)
SelectionChanged.Disable();
uint firstCol=0;
if (mRowHeader)
firstCol=1;
// unselect
if (!set)
{
for (uint k=firstCol; k < GetNbColumns(); k++)
SelectCell(k, row, false, false);
mRowSelected[row] = false;
}
// select
else
{
for (uint k=firstCol; k < GetNbColumns(); k++)
SelectCell(k, row, true, false);
mRowSelected[row] = true;
}
if (!eventDisabled)
SelectionChanged.Enable();
SelectionChanged();
return true;
}
bool nuiMatrixView::Selected(uint col, uint row)
{
if (mColumnHeader & mRowHeader & !col & !row)
{
if (mCanSelectAll)
return SelectAll();
else return true;
}
if (mColumnHeader && !row)
return SelectColumn(col);
if (mRowHeader & !col)
return SelectRow(row);
if (IsSelected(col, row))
return SelectCell(col, row, false);
return SelectCell(col, row, true);
}
void
PIInspectorTable::DuplicateDynamicItem()
{
// Validate pointers.
ValidateThis_();
// See where the dynamic item is.
DMListAttribute* attr;
UInt32 after;
if (!GetSelectedListItem(attr, after))
return;
ValidateObject_(attr);
// We have a valid list item. Set up a transaction for the new item.
StDMTransactionBuilder trans(mFollowUndoHost, mFollowSelection, cmd_Duplicate);
// Duplicate current item.
DMElement* currentItem;
attr->GetSubElements().FetchItemAt(after, ¤tItem);
ValidateObject_(currentItem);
DMAttributePtr newItem;
newItem = (DMAttribute*) currentItem->Clone();
ValidateObject_(newItem.GetObject());
// Insert it into the container.
attr->InsertElementAt(after+1, newItem, true);
// Select the new item.
OVItem* newDisplay = FindItemForSubElement(newItem, true);
if (newDisplay != nil) {
ValidateObject_(newDisplay);
STableCell cell(FindRowForItem(newDisplay), 1);
UnselectAllCells();
SelectCell(cell);
}
// Commit the transaction.
trans.Commit();
}
bool nuiMatrixView::SelectAll()
{
if (mAllSelected)
return DeselectAll();
uint row, col;
uint firstRow = 0;
uint firstCol = 0;
if (mColumnHeader)
firstRow=1;
if (mRowHeader)
firstCol = 1;
mAllSelected = true;
bool eventDisabled = false;
if (!SelectionChanged.IsEnabled())
eventDisabled = true;
if (!eventDisabled)
SelectionChanged.Disable();
// entire rows and cols have a special selection process
for (row=firstRow; row < GetNbRows(); row++)
mRowSelected[row] = true;
for (col=firstCol; col < GetNbColumns(); col++)
mColumnSelected[col] = true;
for (row=firstRow; row < GetNbRows(); row++)
{
for (col=firstCol; col < GetNbColumns(); col++)
{
SelectCell(col, row, true, false);
}
}
if (!eventDisabled)
SelectionChanged.Enable();
SelectionChanged();
return true;
}
/*=============================================================================
-- Message handling.
=============================================================================*/
void ListBox::_SendMessage(Message message)
{
switch (message)
{
//was a cell selected?
case MBL_DOWN_OVER:
{
if (!mSelectedCell.expired())
mSelectedCell.lock()->SetBackgroundImage("cell.png");
SelectCell(GetCellAtPoint(GetWindow()->GetInput()->GetMousePos()));
if (!mSelectedCell.expired())
mSelectedCell.lock()->SetBackgroundImage("cell_selected.png");
break;
}
}
}
void
wxGridSelection::ToggleCellSelection(int row, int col,
const wxKeyboardState& kbd)
{
// if the cell is not selected, select it
if ( !IsInSelection ( row, col ) )
{
SelectCell(row, col, kbd);
return;
}
// otherwise deselect it. This can be simple or more or
// less difficult, depending on how the cell is selected.
size_t count, n;
// The simplest case: The cell is contained in m_cellSelection
// Then it can't be contained in rows/cols/block (since those
// would remove the cell from m_cellSelection on creation), so
// we just have to remove it from m_cellSelection.
if ( m_selectionMode == wxGrid::wxGridSelectCells )
{
count = m_cellSelection.GetCount();
for ( n = 0; n < count; n++ )
{
const wxGridCellCoords& sel = m_cellSelection[n];
if ( row == sel.GetRow() && col == sel.GetCol() )
{
wxGridCellCoords coords = m_cellSelection[n];
m_cellSelection.RemoveAt(n);
if ( !m_grid->GetBatchCount() )
{
wxRect r = m_grid->BlockToDeviceRect( coords, coords );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
// Send event
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
wxEVT_GRID_RANGE_SELECT,
m_grid,
wxGridCellCoords( row, col ),
wxGridCellCoords( row, col ),
false,
kbd );
m_grid->GetEventHandler()->ProcessEvent( gridEvt );
return;
}
}
}
// The most difficult case: The cell is member of one or even several
// blocks. Split each such block in up to 4 new parts, that don't
// contain the cell to be selected, like this:
// |---------------------------|
// | |
// | part 1 |
// | |
// |---------------------------|
// | part 3 |x| part 4 |
// |---------------------------|
// | |
// | part 2 |
// | |
// |---------------------------|
// (The x marks the newly deselected cell).
// Note: in row selection mode, we only need part1 and part2;
// in column selection mode, we only need part 3 and part4,
// which are expanded to whole columns automatically!
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 ) )
{
// 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 )
SelectBlockNoEvent(topRow, leftCol, row - 1, rightCol);
if ( bottomRow > row )
SelectBlockNoEvent(row + 1, leftCol, bottomRow, rightCol);
}
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
if ( leftCol < col )
SelectBlockNoEvent(row, leftCol, row, col - 1);
if ( rightCol > col )
SelectBlockNoEvent(row, col + 1, row, rightCol);
}
}
}
bool rowSelectionWasChanged = false;
// remove a cell from a row, adding up to two new blocks
if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{
count = m_rowSelection.GetCount();
for ( n = 0; n < count; n++ )
{
if ( m_rowSelection[n] == row )
{
m_rowSelection.RemoveAt(n);
n--;
count--;
rowSelectionWasChanged = true;
if (m_selectionMode == wxGrid::wxGridSelectCells)
{
if ( col > 0 )
SelectBlockNoEvent(row, 0, row, col - 1);
if ( col < m_grid->GetNumberCols() - 1 )
SelectBlockNoEvent( row, col + 1,
row, m_grid->GetNumberCols() - 1);
}
}
}
}
bool colSelectionWasChanged = false;
// remove a cell from a column, adding up to two new blocks
if ( m_selectionMode != wxGrid::wxGridSelectRows )
{
count = m_colSelection.GetCount();
for ( n = 0; n < count; n++ )
{
if ( m_colSelection[n] == col )
{
m_colSelection.RemoveAt(n);
n--;
count--;
colSelectionWasChanged = true;
if (m_selectionMode == wxGrid::wxGridSelectCells)
{
if ( row > 0 )
SelectBlockNoEvent(0, col, row - 1, col);
if ( row < m_grid->GetNumberRows() - 1 )
SelectBlockNoEvent(row + 1, col,
m_grid->GetNumberRows() - 1, col);
}
}
}
}
// Refresh the screen and send the event; according to m_selectionMode,
// we need to either update only the cell, or the whole row/column.
wxRect r;
if ( m_selectionMode == 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,
kbd );
m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
else // rows/columns selection mode
{
if ( m_selectionMode != wxGrid::wxGridSelectColumns &&
rowSelectionWasChanged )
{
int numCols = m_grid->GetNumberCols();
for ( int colFrom = 0, colTo = 0; colTo <= numCols; ++colTo )
{
if ( m_colSelection.Index(colTo) >= 0 || colTo == numCols )
{
if ( colFrom < colTo )
{
if ( !m_grid->GetBatchCount() )
{
r = m_grid->BlockToDeviceRect(
wxGridCellCoords( row, colFrom ),
wxGridCellCoords( row, colTo-1 ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
wxEVT_GRID_RANGE_SELECT,
m_grid,
wxGridCellCoords( row, colFrom ),
wxGridCellCoords( row, colTo - 1 ),
false,
kbd );
m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
colFrom = colTo + 1;
}
}
}
if ( m_selectionMode != wxGrid::wxGridSelectRows &&
colSelectionWasChanged )
{
int numRows = m_grid->GetNumberRows();
for ( int rowFrom = 0, rowTo = 0; rowTo <= numRows; ++rowTo )
{
if ( m_rowSelection.Index(rowTo) >= 0 || rowTo == numRows )
{
if (rowFrom < rowTo)
{
if ( !m_grid->GetBatchCount() )
{
r = m_grid->BlockToDeviceRect(
wxGridCellCoords( rowFrom, col ),
wxGridCellCoords( rowTo - 1, col ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
wxEVT_GRID_RANGE_SELECT,
m_grid,
wxGridCellCoords( rowFrom, col ),
wxGridCellCoords( rowTo - 1, col ),
false,
kbd );
m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
rowFrom = rowTo + 1;
}
}
}
}
}
void wxGridSelection::SelectBlock( int topRow, int leftCol,
int bottomRow, int rightCol,
const wxKeyboardState& kbd,
bool sendEvent )
{
// Fix the coordinates of the block if needed.
switch ( m_selectionMode )
{
default:
wxFAIL_MSG( "unknown selection mode" );
// fall through
case wxGrid::wxGridSelectCells:
// nothing to do -- in this mode arbitrary blocks can be selected
break;
case wxGrid::wxGridSelectRows:
leftCol = 0;
rightCol = m_grid->GetNumberCols() - 1;
break;
case wxGrid::wxGridSelectColumns:
topRow = 0;
bottomRow = m_grid->GetNumberRows() - 1;
break;
case wxGrid::wxGridSelectRowsOrColumns:
// block selection doesn't make sense for this mode, we could only
// select the entire grid but this wouldn't be useful
return;
}
if ( topRow > bottomRow )
{
int temp = topRow;
topRow = bottomRow;
bottomRow = temp;
}
if ( leftCol > rightCol )
{
int temp = leftCol;
leftCol = rightCol;
rightCol = temp;
}
// Handle single cell selection in SelectCell.
// (MB: added check for selection mode here to prevent
// crashes if, for example, we are select rows and the
// grid only has 1 col)
if ( m_selectionMode == wxGrid::wxGridSelectCells &&
topRow == bottomRow && leftCol == rightCol )
{
SelectCell( topRow, leftCol, kbd, sendEvent );
}
size_t count, n;
if ( m_selectionMode == wxGrid::wxGridSelectRows )
{
// find out which rows are already selected:
wxArrayInt alreadyselected;
alreadyselected.Add(0,bottomRow-topRow+1);
for( n = 0; n < m_rowSelection.GetCount(); n++)
{
int row = m_rowSelection[n];
if( (row >= topRow) && (row <= bottomRow) )
{
alreadyselected[ row - topRow ]=1;
}
}
// add the newly selected rows:
for ( int row = topRow; row <= bottomRow; row++ )
{
if ( alreadyselected[ row - topRow ] == 0 )
{
m_rowSelection.Add( row );
}
}
}
else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
{
// find out which columns are already selected:
wxArrayInt alreadyselected;
alreadyselected.Add(0,rightCol-leftCol+1);
for( n = 0; n < m_colSelection.GetCount(); n++)
{
int col = m_colSelection[n];
if( (col >= leftCol) && (col <= rightCol) )
{
alreadyselected[ col - leftCol ]=1;
}
}
// add the newly selected columns:
for ( int col = leftCol; col <= rightCol; col++ )
{
if ( alreadyselected[ col - leftCol ] == 0 )
{
m_colSelection.Add( col );
}
}
}
else
{
// Remove single cells contained in newly selected block.
if ( m_selectionMode == wxGrid::wxGridSelectCells )
{
count = m_cellSelection.GetCount();
for ( 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,
// if a block contained in the selection is found, remove it.
count = m_blockSelectionTopLeft.GetCount();
for ( 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--;
break;
default:
break;
}
}
// If a row containing the selection is already selected, return,
// if a row contained in newly selected block is found, remove it.
count = m_rowSelection.GetCount();
for ( 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--;
break;
default:
break;
}
}
// Same for columns.
count = m_colSelection.GetCount();
for ( 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--;
break;
default:
break;
}
}
m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
}
// Update View:
if ( !m_grid->GetBatchCount() )
{
wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
wxGridCellCoords( bottomRow, rightCol ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
// Send Event, if not disabled.
if ( sendEvent )
{
wxGridRangeSelectEvent gridEvt( m_grid->GetId(),
wxEVT_GRID_RANGE_SELECT,
m_grid,
wxGridCellCoords( topRow, leftCol ),
wxGridCellCoords( bottomRow, rightCol ),
true,
kbd);
m_grid->GetEventHandler()->ProcessEvent( gridEvt );
}
}
void CCellView::MouseDown(BPoint where)
{
StPenState save(this);
try
{
bool optional = IsOptionalClick(Window()->CurrentMessage());
if (!IsFocus() && !fEntering)
MakeFocus();
ResetOffset(-1);
BRect myRect, bounds(Bounds());
cell myCell = cell(fFrozen.h ? 1 : fPosition.h, fFrozen.v ? 1 : fPosition.v);
if (fFirstGraphic)
{
if (fFirstGraphic->HandleMouseDown(where))
return;
else if (fFirstGraphic->HasFocus())
fFirstGraphic->MakeFocus(false);
}
if (fCellBounds.Contains(where))
{
if ((PointIsInSelection(where) &&
!fEntering) &&
(optional ||
WaitMouseMoved(where, false)))
{
StartDrag(where, optional);
}
else if (optional)
GridMenu(where);
else
SelectCell(where);
}
if (!fShowBorders)
return;
myRect = bounds;
myRect.top = fBorderHeight;
myRect.left = 0.0;
myRect.right = fBorderWidth;
if (myRect.Contains(where))
{
if (optional)
BorderMenu(where);
else
{
do
{
myCell.v++;
GetCellRect(myCell, myRect);
}
while (myRect.top + 2.0 <= where.y);
if (where.y >= myRect.top - 2.0 && where.y <= myRect.top + 2.0)
ResizeRow(where, myCell.v - 1);
else
SelectRow(where, myCell.v - 1);
}
return;
}
myRect.Set(fBorderWidth, 0.0, bounds.right, fBorderHeight);
if (myRect.Contains(where))
{
if (optional)
BorderMenu(where);
else
{
do
{
myCell.h++;
GetCellRect(myCell, myRect);
}
while (myRect.left + 2.0 <= where.x);
if (where.x >= myRect.left - 2.0 && where.x <= myRect.left + 2.0)
ResizeCol(where, myCell.h - 1);
else
SelectCol(where, myCell.h - 1);
}
return;
}
myRect.Set(0.0, 0.0, fBorderWidth, fBorderHeight);
if (myRect.Contains(where))
{
if (!fEntering)
SetSelection(range(1, 1, kColCount, kRowCount));
else
beep();
}
}
catch(CErr& e)
{
CATCHED;
e.DoError();
return;
}
catch(...)
{
CATCHED;
ASSERT(FALSE);
}
}
//
// [public] ODBCGridCtrl::Load
//
BOOL
ODBCGridCtrl::Load()
{
ASSERT( m_pRstSelect && m_pRstSelect->IsOpen() );
AfxGetApp()->BeginWaitCursor();
SetRedraw(FALSE);
// Open recordset and load record data. ##########
try
{
// Free record data array. ###################
FreeRecordDataArray();
// ###########################################
m_pRecord = m_pRstSelect->GetRecordPtr();
ASSERT( m_pRecord );
m_nUIDField = m_pRecord->GetFieldID(m_sUIDField);
ASSERT( m_nUIDField > -1 );
m_pArrRecDataById->OptimizeForLargeData (TRUE);
BuildODBCColumnsArray ();
m_pRecord->SetFreeDataOnDestroy (FALSE);
void* lpRecData = m_pRecord->GetRecordData();
int nRecDataSize = m_pRecord->GetRecordSize();
m_pRecord->SetRecordData(lpRecData);
while( !m_pRstSelect->IsEOF() )
{
InsertItem(0, _T(""));
long lUID = m_pRecord->GetLong(m_nUIDField);
// Allocate record data. #############################
void* lpNewRecData = new BYTE[nRecDataSize];
memcpy(lpNewRecData, lpRecData, nRecDataSize);
// ###################################################
m_pArrRecDataById->Add (lUID, (long)lpNewRecData);
m_pRstSelect->MoveNext ();
}
delete lpRecData;
m_pRstSelect->Close();
}
catch(CDBException* e)
{
SetRedraw(TRUE);
m_strLastError = e->m_strError;
e->Delete();
AfxGetApp()->EndWaitCursor();
return FALSE;
}
// ###############################################
if( GetItemCount() > -1 )
SelectCell(0, 0, true);
SetRedraw(TRUE);
AfxGetApp()->EndWaitCursor();
return TRUE;
}
void wxGridSelection::SelectBlock( int topRow, int leftCol,
int bottomRow, int rightCol,
bool ControlDown, bool ShiftDown,
bool AltDown, bool MetaDown,
bool sendEvent )
{
// Fix the coordinates of the block if needed.
if ( m_selectionMode == wxGrid::wxGridSelectRows )
{
leftCol = 0;
rightCol = m_grid->GetNumberCols() - 1;
}
else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
{
topRow = 0;
bottomRow = m_grid->GetNumberRows() - 1;
}
if ( topRow > bottomRow )
{
int temp = topRow;
topRow = bottomRow;
bottomRow = temp;
}
if ( leftCol > rightCol )
{
int temp = leftCol;
leftCol = rightCol;
rightCol = temp;
}
// Handle single cell selection in SelectCell.
// (MB: added check for selection mode here to prevent
// crashes if, for example, we are select rows and the
// grid only has 1 col)
if ( m_selectionMode == wxGrid::wxGridSelectCells &&
topRow == bottomRow && leftCol == rightCol )
SelectCell( topRow, leftCol, ControlDown, ShiftDown,
AltDown, MetaDown, sendEvent );
size_t count, n;
// Remove single cells contained in newly selected block.
if ( m_selectionMode == wxGrid::wxGridSelectCells )
{
count = m_cellSelection.GetCount();
for ( 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,
// if a block contained in the selection is found, remove it.
count = m_blockSelectionTopLeft.GetCount();
for ( 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--;
break;
default:
break;
}
}
// 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 != wxGrid::wxGridSelectColumns )
{
count = m_rowSelection.GetCount();
for ( 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--;
break;
default:
break;
}
}
}
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],
topRow, leftCol, bottomRow, rightCol ) )
{
case 1:
return;
case -1:
m_colSelection.RemoveAt(n);
n--; count--;
break;
default:
break;
}
}
}
m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) );
// Update View:
if ( !m_grid->GetBatchCount() )
{
wxRect r = m_grid->BlockToDeviceRect( wxGridCellCoords( topRow, leftCol ),
wxGridCellCoords( bottomRow, rightCol ) );
((wxWindow *)m_grid->m_gridWin)->Refresh( false, &r );
}
// Send Event, if not disabled.
if ( sendEvent )
{
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);
}
}