Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added extended selection support.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6412 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Neis
2000-03-03 16:44:33 +00:00
parent d2e4966591
commit b58088819b
5 changed files with 475 additions and 561 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
include/wx/generic/grid.h
View File

@@ -76,6 +76,7 @@ class WXDLLEXPORT wxGridRowLabelWindow;
class WXDLLEXPORT wxGridTableBase; class WXDLLEXPORT wxGridTableBase;
class WXDLLEXPORT wxGridWindow; class WXDLLEXPORT wxGridWindow;
class WXDLLEXPORT wxGridTypeRegistry; class WXDLLEXPORT wxGridTypeRegistry;
class WXDLLEXPORT wxGridSelection;
class WXDLLEXPORT wxCheckBox; class WXDLLEXPORT wxCheckBox;
class WXDLLEXPORT wxComboBox; class WXDLLEXPORT wxComboBox;
@@ -960,7 +961,13 @@ public:
~wxGrid(); ~wxGrid();
bool CreateGrid( int numRows, int numCols ); enum wxGridSelectionModes {wxGridSelectCells,
wxGridSelectRows,
wxGridSelectColumns};
bool CreateGrid( int numRows, int numCols,
wxGrid::wxGridSelectionModes selmode =
wxGrid::wxGridSelectCells );
// ------ grid dimensions // ------ grid dimensions
@@ -1269,34 +1276,15 @@ public:
void SelectAll(); void SelectAll();
bool IsSelection() bool IsSelection();
{ return ( m_selectedTopLeft != wxGridNoCellCoords &&
m_selectedBottomRight != wxGridNoCellCoords );
}
void ClearSelection(); void ClearSelection();
bool IsInSelection( int row, int col ) bool IsInSelection( int row, int col );
{ return ( IsSelection() &&
row >= m_selectedTopLeft.GetRow() &&
col >= m_selectedTopLeft.GetCol() &&
row <= m_selectedBottomRight.GetRow() &&
col <= m_selectedBottomRight.GetCol() );
}
bool IsInSelection( const wxGridCellCoords& coords ) bool IsInSelection( const wxGridCellCoords& coords )
{ return IsInSelection( coords.GetRow(), coords.GetCol() ); } { return IsInSelection( coords.GetRow(), coords.GetCol() ); }
void GetSelection( int* topRow, int* leftCol, int* bottomRow, int* rightCol )
{
// these will all be -1 if there is no selected block
//
*topRow = m_selectedTopLeft.GetRow();
*leftCol = m_selectedTopLeft.GetCol();
*bottomRow = m_selectedBottomRight.GetRow();
*rightCol = m_selectedBottomRight.GetCol();
}
// This function returns the rectangle that encloses the block of cells // This function returns the rectangle that encloses the block of cells
// limited by TopLeft and BottomRight cell in device coords and clipped // limited by TopLeft and BottomRight cell in device coords and clipped
@@ -1310,8 +1298,8 @@ public:
// //
wxRect SelectionToDeviceRect() wxRect SelectionToDeviceRect()
{ {
return BlockToDeviceRect( m_selectedTopLeft, return BlockToDeviceRect( m_selectingTopLeft,
m_selectedBottomRight ); m_selectingBottomRight );
} }
// Access or update the selection fore/back colours // Access or update the selection fore/back colours
@@ -1531,8 +1519,9 @@ protected:
wxGridCellCoords m_currentCellCoords; wxGridCellCoords m_currentCellCoords;
wxGridCellCoords m_selectedTopLeft; wxGridCellCoords m_selectingTopLeft;
wxGridCellCoords m_selectedBottomRight; wxGridCellCoords m_selectingBottomRight;
wxGridSelection *m_selection;
wxColour m_selectionBackground; wxColour m_selectionBackground;
wxColour m_selectionForeground; wxColour m_selectionForeground;
@@ -1725,7 +1714,7 @@ protected:
bool GetModelValues(); bool GetModelValues();
bool SetModelValues(); bool SetModelValues();
friend class wxGridSelection; friend class wxGridSelection;
DECLARE_DYNAMIC_CLASS( wxGrid ) DECLARE_DYNAMIC_CLASS( wxGrid )
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
@@ -1898,4 +1887,3 @@ const wxEventType wxEVT_GRID_CHANGE_SEL_LABEL = wxEVT_FIRST + 1578;
#endif // #ifndef __WXGRID_H__ #endif // #ifndef __WXGRID_H__
#endif // ifndef wxUSE_NEW_GRID #endif // ifndef wxUSE_NEW_GRID

37
include/wx/generic/gridsel.h
View File

@@ -24,11 +24,8 @@
class WXDLLEXPORT wxGridSelection{ class WXDLLEXPORT wxGridSelection{
public: public:
enum wxGridSelectionModes {wxGridSelectCells, wxGridSelection( wxGrid * grid, wxGrid::wxGridSelectionModes sel =
wxGridSelectRows, wxGrid::wxGridSelectCells );
wxGridSelectColumns};
wxGridSelection( wxGrid * grid, wxGridSelection::wxGridSelectionModes sel =
wxGridSelection::wxGridSelectCells );
bool IsSelection(); bool IsSelection();
bool IsInSelection ( int row, int col ); bool IsInSelection ( int row, int col );
void SelectRow( int row, bool addToSelected = FALSE ); void SelectRow( int row, bool addToSelected = FALSE );
@@ -43,32 +40,32 @@ public:
private: private:
int BlockContain( int topRow1, int leftCol1, int BlockContain( int topRow1, int leftCol1,
int bottomRow1, int rightCol1, int bottomRow1, int rightCol1,
int topRow2, int leftCol2, int topRow2, int leftCol2,
int bottomRow2, int rightCol2 ); int bottomRow2, int rightCol2 );
// returns 1, if Block1 contains Block2, // returns 1, if Block1 contains Block2,
// -1, if Block2 contains Block1, // -1, if Block2 contains Block1,
// 0, otherwise // 0, otherwise
int BlockContainsCell( int topRow, int leftCol, int BlockContainsCell( int topRow, int leftCol,
int bottomRow, int rightCol, int bottomRow, int rightCol,
int row, int col ) int row, int col )
// returns 1, if Block contains Cell, // returns 1, if Block contains Cell,
// 0, otherwise // 0, otherwise
{ {
return ( topRow <= row && row <= bottomRow && return ( topRow <= row && row <= bottomRow &&
leftCol <= col && col <= rightCol ); leftCol <= col && col <= rightCol );
} }
wxGridCellCoordsArray m_cellSelection; wxGridCellCoordsArray m_cellSelection;
wxGridCellCoordsArray m_blockSelectionTopLeft; wxGridCellCoordsArray m_blockSelectionTopLeft;
wxGridCellCoordsArray m_blockSelectionBottomRight; wxGridCellCoordsArray m_blockSelectionBottomRight;
wxArrayInt m_rowSelection; wxArrayInt m_rowSelection;
wxArrayInt m_colSelection; wxArrayInt m_colSelection;
wxGrid *m_grid; wxGrid *m_grid;
wxGridSelectionModes m_selectionMode; wxGrid::wxGridSelectionModes m_selectionMode;
}; };
#endif // #ifdef __WXGRIDSEL_H__ #endif // #ifdef __WXGRIDSEL_H__
#endif // #ifndef wxUSE_NEW_GRID #endif // #ifndef wxUSE_NEW_GRID

4
samples/newgrid/griddemo.cpp
View File

@@ -482,23 +482,27 @@ void GridFrame::InsertCol( wxCommandEvent& WXUNUSED(ev) )
void GridFrame::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) ) void GridFrame::DeleteSelectedRows( wxCommandEvent& WXUNUSED(ev) )
{ {
#if 0
if ( grid->IsSelection() ) if ( grid->IsSelection() )
{ {
int topRow, bottomRow, leftCol, rightCol; int topRow, bottomRow, leftCol, rightCol;
grid->GetSelection( &topRow, &leftCol, &bottomRow, &rightCol ); grid->GetSelection( &topRow, &leftCol, &bottomRow, &rightCol );
grid->DeleteRows( topRow, bottomRow - topRow + 1 ); grid->DeleteRows( topRow, bottomRow - topRow + 1 );
} }
#endif
} }
void GridFrame::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) ) void GridFrame::DeleteSelectedCols( wxCommandEvent& WXUNUSED(ev) )
{ {
#if 0
if ( grid->IsSelection() ) if ( grid->IsSelection() )
{ {
int topRow, bottomRow, leftCol, rightCol; int topRow, bottomRow, leftCol, rightCol;
grid->GetSelection( &topRow, &leftCol, &bottomRow, &rightCol ); grid->GetSelection( &topRow, &leftCol, &bottomRow, &rightCol );
grid->DeleteCols( leftCol, rightCol - leftCol + 1 ); grid->DeleteCols( leftCol, rightCol - leftCol + 1 );
} }
#endif
} }

243
src/generic/grid.cpp
View File

@@ -50,6 +50,7 @@
#include "wx/tokenzr.h" #include "wx/tokenzr.h"
#include "wx/grid.h" #include "wx/grid.h"
#include "wx/generic/gridsel.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// array classes // array classes
@@ -3078,6 +3079,7 @@ wxGrid::~wxGrid()
delete m_table; delete m_table;
delete m_typeRegistry; delete m_typeRegistry;
delete m_selection;
} }
@@ -3118,7 +3120,7 @@ void wxGrid::Create()
// create the type registry // create the type registry
m_typeRegistry = new wxGridTypeRegistry; m_typeRegistry = new wxGridTypeRegistry;
m_selection = 0;
// subwindow components that make up the wxGrid // subwindow components that make up the wxGrid
m_cornerLabelWin = new wxGridCornerLabelWindow( this, m_cornerLabelWin = new wxGridCornerLabelWindow( this,
-1, -1,
@@ -3146,7 +3148,8 @@ void wxGrid::Create()
} }
bool wxGrid::CreateGrid( int numRows, int numCols ) bool wxGrid::CreateGrid( int numRows, int numCols,
wxGrid::wxGridSelectionModes selmode )
{ {
if ( m_created ) if ( m_created )
{ {
@@ -3164,7 +3167,7 @@ bool wxGrid::CreateGrid( int numRows, int numCols )
Init(); Init();
m_created = TRUE; m_created = TRUE;
} }
m_selection = new wxGridSelection( this, selmode );
return m_created; return m_created;
} }
@@ -3262,8 +3265,8 @@ void wxGrid::Init()
m_currentCellCoords = wxGridNoCellCoords; m_currentCellCoords = wxGridNoCellCoords;
m_selectedTopLeft = wxGridNoCellCoords; m_selectingTopLeft = wxGridNoCellCoords;
m_selectedBottomRight = wxGridNoCellCoords; m_selectingBottomRight = wxGridNoCellCoords;
m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT); m_selectionBackground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT);
m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT); m_selectionForeground = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
@@ -4304,6 +4307,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
// //
if ( event.LeftDown() && coords != wxGridNoCellCoords ) if ( event.LeftDown() && coords != wxGridNoCellCoords )
{ {
if ( !event.ShiftDown() && !event.ControlDown() )
ClearSelection();
if ( event.ShiftDown() ) if ( event.ShiftDown() )
{ {
SelectBlock( m_currentCellCoords, coords ); SelectBlock( m_currentCellCoords, coords );
@@ -4339,6 +4344,10 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
} }
else else
{ {
m_selection->ToggleCellSelection( coords.GetRow(),
coords.GetCol() );
m_selectingTopLeft = wxGridNoCellCoords;
m_selectingBottomRight = wxGridNoCellCoords;
SetCurrentCell( coords ); SetCurrentCell( coords );
m_waitForSlowClick = TRUE; m_waitForSlowClick = TRUE;
} }
@@ -4369,8 +4378,13 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
{ {
if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL ) 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) if (m_winCapture)
{ {
m_winCapture->ReleaseMouse(); m_winCapture->ReleaseMouse();
@@ -4659,7 +4673,7 @@ bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
SetCurrentCell( 0, 0 ); SetCurrentCell( 0, 0 );
} }
ClearSelection(); m_selection->UpdateRows( pos, numRows );
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
} }
@@ -4695,7 +4709,6 @@ bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
// the table will have sent the results of the append row // the table will have sent the results of the append row
// operation to this view object as a grid table message // operation to this view object as a grid table message
// //
ClearSelection();
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
return TRUE; return TRUE;
} }
@@ -4727,7 +4740,7 @@ bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
// the table will have sent the results of the delete row // the table will have sent the results of the delete row
// operation to this view object as a grid table message // operation to this view object as a grid table message
// //
ClearSelection(); m_selection->UpdateRows( pos, -((int)numRows) );
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
return TRUE; return TRUE;
} }
@@ -4766,7 +4779,7 @@ bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
SetCurrentCell( 0, 0 ); SetCurrentCell( 0, 0 );
} }
ClearSelection(); m_selection->UpdateCols( pos, numCols );
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
} }
@@ -4802,7 +4815,6 @@ bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
SetCurrentCell( 0, 0 ); SetCurrentCell( 0, 0 );
} }
ClearSelection();
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
return TRUE; return TRUE;
} }
@@ -4833,7 +4845,7 @@ bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
// the table will have sent the results of the delete col // the table will have sent the results of the delete col
// operation to this view object as a grid table message // operation to this view object as a grid table message
// //
ClearSelection(); m_selection->UpdateCols( pos, -((int)numCols) );
if ( !GetBatchCount() ) Refresh(); if ( !GetBatchCount() ) Refresh();
return TRUE; return TRUE;
} }
@@ -4875,8 +4887,8 @@ bool wxGrid::SendEvent( const wxEventType type,
wxGridRangeSelectEvent gridEvt( GetId(), wxGridRangeSelectEvent gridEvt( GetId(),
type, type,
this, this,
m_selectedTopLeft, m_selectingTopLeft,
m_selectedBottomRight, m_selectingBottomRight,
mouseEv.ControlDown(), mouseEv.ControlDown(),
mouseEv.ShiftDown(), mouseEv.ShiftDown(),
mouseEv.AltDown(), mouseEv.AltDown(),
@@ -5157,13 +5169,16 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
wxGridCellAttr* attr = GetCellAttr(coords); wxGridCellAttr* attr = GetCellAttr(coords);
DrawCellHighlight(dc, attr); DrawCellHighlight(dc, attr);
attr->DecRef(); attr->DecRef();
#if 0
// SN: For my extended selection code, automatic
// deselection is definitely not a good idea.
if ( IsSelection() ) if ( IsSelection() )
{ {
wxRect r( SelectionToDeviceRect() ); wxRect r( SelectionToDeviceRect() );
ClearSelection(); ClearSelection();
if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r ); if ( !GetBatchCount() ) m_gridWin->Refresh( FALSE, &r );
} }
#endif
} }
} }
@@ -7422,83 +7437,16 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
void wxGrid::SelectRow( int row, bool addToSelected ) void wxGrid::SelectRow( int row, bool addToSelected )
{ {
wxRect r; if ( IsSelection() && !addToSelected )
m_selection->ClearSelection();
if ( IsSelection() && addToSelected ) m_selection->SelectRow( row );
{
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 ( 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 );
}
wxGridRangeSelectEvent gridEvt( GetId(), wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT, wxEVT_GRID_RANGE_SELECT,
this, this,
m_selectedTopLeft, wxGridCellCoords( row, 0 ),
m_selectedBottomRight ); wxGridCellCoords( row, m_numCols - 1 ) );
GetEventHandler()->ProcessEvent(gridEvt); GetEventHandler()->ProcessEvent(gridEvt);
} }
@@ -7506,81 +7454,16 @@ void wxGrid::SelectRow( int row, bool addToSelected )
void wxGrid::SelectCol( int col, bool addToSelected ) void wxGrid::SelectCol( int col, bool addToSelected )
{ {
if ( IsSelection() && addToSelected ) if ( IsSelection() && !addToSelected )
{ m_selection->ClearSelection();
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(); m_selection->SelectCol( col );
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 ( 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 );
}
wxGridRangeSelectEvent gridEvt( GetId(), wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT, wxEVT_GRID_RANGE_SELECT,
this, this,
m_selectedTopLeft, wxGridCellCoords( 0, col ),
m_selectedBottomRight ); wxGridCellCoords( m_numRows - 1, col ) );
GetEventHandler()->ProcessEvent(gridEvt); GetEventHandler()->ProcessEvent(gridEvt);
} }
@@ -7608,8 +7491,8 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
updateTopLeft = wxGridCellCoords( topRow, leftCol ); updateTopLeft = wxGridCellCoords( topRow, leftCol );
updateBottomRight = wxGridCellCoords( bottomRow, rightCol ); updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
if ( m_selectedTopLeft != updateTopLeft || if ( m_selectingTopLeft != updateTopLeft ||
m_selectedBottomRight != updateBottomRight ) m_selectingBottomRight != updateBottomRight )
{ {
// Compute two optimal update rectangles: // Compute two optimal update rectangles:
// Either one rectangle is a real subset of the // Either one rectangle is a real subset of the
@@ -7623,10 +7506,10 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
int i; int i;
// Store intermediate values // Store intermediate values
wxCoord oldLeft = m_selectedTopLeft.GetCol(); wxCoord oldLeft = m_selectingTopLeft.GetCol();
wxCoord oldTop = m_selectedTopLeft.GetRow(); wxCoord oldTop = m_selectingTopLeft.GetRow();
wxCoord oldRight = m_selectedBottomRight.GetCol(); wxCoord oldRight = m_selectingBottomRight.GetCol();
wxCoord oldBottom = m_selectedBottomRight.GetRow(); wxCoord oldBottom = m_selectingBottomRight.GetRow();
// Determine the outer/inner coordinates. // Determine the outer/inner coordinates.
if (oldLeft > leftCol) if (oldLeft > leftCol)
@@ -7696,8 +7579,8 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
// Change Selection // Change Selection
m_selectedTopLeft = updateTopLeft; m_selectingTopLeft = updateTopLeft;
m_selectedBottomRight = updateBottomRight; m_selectingBottomRight = updateBottomRight;
// various Refresh() calls // various Refresh() calls
for (i = 0; i < 4; i++ ) for (i = 0; i < 4; i++ )
@@ -7713,8 +7596,8 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
wxGridRangeSelectEvent gridEvt( GetId(), wxGridRangeSelectEvent gridEvt( GetId(),
wxEVT_GRID_RANGE_SELECT, wxEVT_GRID_RANGE_SELECT,
this, this,
m_selectedTopLeft, m_selectingTopLeft,
m_selectedBottomRight ); m_selectingBottomRight );
GetEventHandler()->ProcessEvent(gridEvt); GetEventHandler()->ProcessEvent(gridEvt);
} }
@@ -7722,17 +7605,30 @@ void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
void wxGrid::SelectAll() void wxGrid::SelectAll()
{ {
m_selectedTopLeft.Set( 0, 0 ); m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
m_selectedBottomRight.Set( 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() void wxGrid::ClearSelection()
{ {
m_selectedTopLeft = wxGridNoCellCoords; m_selectingTopLeft = wxGridNoCellCoords;
m_selectedBottomRight = wxGridNoCellCoords; m_selectingBottomRight = wxGridNoCellCoords;
m_selection->ClearSelection();
} }
@@ -7847,4 +7743,3 @@ wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObjec
#endif // ifndef wxUSE_NEW_GRID #endif // ifndef wxUSE_NEW_GRID

708
src/generic/gridsel.cpp
View File

@@ -33,7 +33,7 @@
#include "wx/generic/gridsel.h" #include "wx/generic/gridsel.h"
wxGridSelection::wxGridSelection( wxGrid * grid, wxGridSelection::wxGridSelection( wxGrid * grid,
wxGridSelection::wxGridSelectionModes sel ) wxGrid::wxGridSelectionModes sel )
{ {
m_grid = grid; m_grid = grid;
m_selectionMode = sel; m_selectionMode = sel;
@@ -42,105 +42,105 @@ wxGridSelection::wxGridSelection( wxGrid * grid,
bool wxGridSelection::IsSelection() bool wxGridSelection::IsSelection()
{ {
return ( m_cellSelection.GetCount() || m_blockSelectionTopLeft.GetCount() || 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 ) bool wxGridSelection::IsInSelection ( int row, int col )
{ {
size_t count; size_t count;
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
count = m_cellSelection.GetCount(); count = m_cellSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords = m_cellSelection[n]; wxGridCellCoords& coords = m_cellSelection[n];
if ( row == coords.GetRow() && col == coords.GetCol() ) if ( row == coords.GetRow() && col == coords.GetCol() )
return true; return true;
} }
} }
count = m_blockSelectionTopLeft.GetCount(); count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n]; wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n]; wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
if ( BlockContainsCell(coords1.GetRow(), coords1.GetCol(), if ( BlockContainsCell(coords1.GetRow(), coords1.GetCol(),
coords2.GetRow(), coords2.GetCol(), coords2.GetRow(), coords2.GetCol(),
row, col ) ) row, col ) )
return true; return true;
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectColumns ) if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
size_t count = m_rowSelection.GetCount(); size_t count = m_rowSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( row == m_rowSelection[n] ) if ( row == m_rowSelection[n] )
return true; return true;
} }
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectRows ) if ( m_selectionMode != wxGrid::wxGridSelectRows )
{ {
size_t count = m_colSelection.GetCount(); size_t count = m_colSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( col == m_colSelection[n] ) if ( col == m_colSelection[n] )
return true; return true;
} }
} }
return false; return false;
} }
void wxGridSelection::SelectRow( int row, bool addToSelected = FALSE ) void wxGridSelection::SelectRow( int row, bool addToSelected = FALSE )
{ {
if ( m_selectionMode == wxGridSelection::wxGridSelectColumns ) if ( m_selectionMode == wxGrid::wxGridSelectColumns )
return; return;
size_t count; size_t count;
// Remove single cells contained in newly selected block. // Remove single cells contained in newly selected block.
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
count = m_cellSelection.GetCount(); count = m_cellSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords = m_cellSelection[n]; wxGridCellCoords& coords = m_cellSelection[n];
if ( BlockContainsCell( row, 0, row, m_grid->GetNumberCols() - 1, if ( BlockContainsCell( row, 0, row, m_grid->GetNumberCols() - 1,
coords.GetRow(), coords.GetCol() ) ) coords.GetRow(), coords.GetCol() ) )
{ {
m_cellSelection.RemoveAt(n); m_cellSelection.RemoveAt(n);
n--; count--; n--; count--;
} }
} }
} }
// If possible, merge row with existing selected block // If possible, merge row with existing selected block
count = m_blockSelectionTopLeft.GetCount(); count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n]; wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n]; wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
if ( coords1.GetRow() == row && row == coords2.GetRow() ) if ( coords1.GetRow() == row && row == coords2.GetRow() )
{ {
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
} }
else if ( coords1.GetCol() == 0 && else if ( coords1.GetCol() == 0 &&
coords2.GetCol() == m_grid->GetNumberCols() - 1 ) coords2.GetCol() == m_grid->GetNumberCols() - 1 )
{ {
if ( coords1.GetRow() <= row && row <= coords2.GetRow() ) if ( coords1.GetRow() <= row && row <= coords2.GetRow() )
return; return;
else if ( coords1.GetRow() == row + 1) else if ( coords1.GetRow() == row + 1)
{ {
coords1.SetRow(row); coords1.SetRow(row);
return; return;
} }
else if ( coords2.GetRow() == row - 1) else if ( coords2.GetRow() == row - 1)
{ {
coords2.SetRow(row); coords2.SetRow(row);
return; return;
} }
} }
} }
// Check whether row is already selected. // Check whether row is already selected.
@@ -148,64 +148,70 @@ void wxGridSelection::SelectRow( int row, bool addToSelected = FALSE )
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( row == m_rowSelection[n] ) if ( row == m_rowSelection[n] )
return; return;
} }
// Add row to selection // Add row to selection
m_rowSelection.Add(row); 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 ) void wxGridSelection::SelectCol( int col, bool addToSelected = FALSE )
{ {
if ( m_selectionMode == wxGridSelection::wxGridSelectRows ) if ( m_selectionMode == wxGrid::wxGridSelectRows )
return; return;
size_t count; size_t count;
// Remove single cells contained in newly selected block. // Remove single cells contained in newly selected block.
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
count = m_cellSelection.GetCount(); count = m_cellSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords = m_cellSelection[n]; wxGridCellCoords& coords = m_cellSelection[n];
if ( BlockContainsCell( 0, col, m_grid->GetNumberRows() - 1, col, if ( BlockContainsCell( 0, col, m_grid->GetNumberRows() - 1, col,
coords.GetRow(), coords.GetCol() ) ) coords.GetRow(), coords.GetCol() ) )
{ {
m_cellSelection.RemoveAt(n); m_cellSelection.RemoveAt(n);
n--; count--; n--; count--;
} }
} }
} }
// If possible, merge col with existing selected block // If possible, merge col with existing selected block
count = m_blockSelectionTopLeft.GetCount(); count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n]; wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n]; wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
if ( coords1.GetCol() == col && col == coords2.GetCol() ) if ( coords1.GetCol() == col && col == coords2.GetCol() )
{ {
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
} }
else if ( coords1.GetRow() == 0 && else if ( coords1.GetRow() == 0 &&
coords2.GetRow() == m_grid->GetNumberRows() - 1 ) coords2.GetRow() == m_grid->GetNumberRows() - 1 )
{ {
if ( coords1.GetCol() <= col && col <= coords2.GetCol() ) if ( coords1.GetCol() <= col && col <= coords2.GetCol() )
return; return;
else if ( coords1.GetCol() == col + 1) else if ( coords1.GetCol() == col + 1)
{ {
coords1.SetCol(col); coords1.SetCol(col);
return; return;
} }
else if ( coords2.GetCol() == col - 1) else if ( coords2.GetCol() == col - 1)
{ {
coords2.SetCol(col); coords2.SetCol(col);
return; return;
} }
} }
} }
// Check whether col is already selected. // Check whether col is already selected.
@@ -213,25 +219,31 @@ void wxGridSelection::SelectCol( int col, bool addToSelected = FALSE )
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( col == m_colSelection[n] ) if ( col == m_colSelection[n] )
return; return;
} }
// Add col to selection // Add col to selection
m_colSelection.Add(col); 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 ) void wxGridSelection::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
{ {
// Fix the coordinates of the block if potentially needed // Fix the coordinates of the block if potentially needed
if ( m_selectionMode == wxGridSelection::wxGridSelectRows ) if ( m_selectionMode == wxGrid::wxGridSelectRows )
{ {
leftCol = 0; leftCol = 0;
rightCol = m_grid->GetNumberCols() - 1; rightCol = m_grid->GetNumberCols() - 1;
} }
else if ( m_selectionMode == wxGridSelection::wxGridSelectColumns ) else if ( m_selectionMode == wxGrid::wxGridSelectColumns )
{ {
topRow = 0; topRow = 0;
bottomRow = m_grid->GetNumberRows() - 1; bottomRow = m_grid->GetNumberRows() - 1;
} }
// Handle single cell selection in SelectCell. // Handle single cell selection in SelectCell.
@@ -240,20 +252,20 @@ void wxGridSelection::SelectBlock( int topRow, int leftCol, int bottomRow, int r
size_t count; size_t count;
// Remove single cells contained in newly selected block. // Remove single cells contained in newly selected block.
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
count = m_cellSelection.GetCount(); count = m_cellSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords = m_cellSelection[n]; wxGridCellCoords& coords = m_cellSelection[n];
if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol, if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
coords.GetRow(), coords.GetCol() ) ) coords.GetRow(), coords.GetCol() ) )
{ {
m_cellSelection.RemoveAt(n); m_cellSelection.RemoveAt(n);
n--; count--; n--; count--;
} }
} }
} }
// If a block containing the selection is already selected, return, // If a block containing the selection is already selected, return,
@@ -262,200 +274,214 @@ void wxGridSelection::SelectBlock( int topRow, int leftCol, int bottomRow, int r
count = m_blockSelectionTopLeft.GetCount(); count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n]; wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n]; wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
switch ( BlockContain( coords1.GetRow(), coords1.GetCol(), switch ( BlockContain( coords1.GetRow(), coords1.GetCol(),
coords2.GetRow(), coords2.GetCol(), coords2.GetRow(), coords2.GetCol(),
topRow, leftCol, bottomRow, rightCol ) ) topRow, leftCol, bottomRow, rightCol ) )
{ {
case 1: case 1:
return; return;
case -1: case -1:
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
default: default:
; ;
} }
} }
// If a row containing the selection is already selected, return, // If a row containing the selection is already selected, return,
// if a row contained in newly selected block is found, remove it. // 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(); size_t count = m_rowSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
switch ( BlockContain( m_rowSelection[n], 0, switch ( BlockContain( m_rowSelection[n], 0,
m_rowSelection[n], m_grid->GetNumberCols()-1, m_rowSelection[n], m_grid->GetNumberCols()-1,
topRow, leftCol, bottomRow, rightCol ) ) topRow, leftCol, bottomRow, rightCol ) )
{ {
case 1: case 1:
return; return;
case -1: case -1:
m_rowSelection.RemoveAt(n); m_rowSelection.RemoveAt(n);
n--; count--; n--; count--;
default: default:
; ;
} }
} }
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectRows ) if ( m_selectionMode != wxGrid::wxGridSelectRows )
{ {
size_t count = m_colSelection.GetCount(); size_t count = m_colSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
switch ( BlockContain( 0, m_colSelection[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 ) ) topRow, leftCol, bottomRow, rightCol ) )
{ {
case 1: case 1:
return; return;
case -1: case -1:
m_colSelection.RemoveAt(n); m_colSelection.RemoveAt(n);
n--; count--; n--; count--;
default: default:
; ;
} }
} }
} }
m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) ); m_blockSelectionTopLeft.Add( wxGridCellCoords( topRow, leftCol ) );
m_blockSelectionBottomRight.Add( wxGridCellCoords( bottomRow, rightCol ) ); 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) 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 ); 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 ); SelectBlock(0, col, m_grid->GetNumberRows() - 1, col );
else if ( IsInSelection ( row, col ) ) else if ( IsInSelection ( row, col ) )
return; return;
m_cellSelection.Add( wxGridCellCoords( row, col ) ); 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) void wxGridSelection::ToggleCellSelection( int row, int col)
{ {
if ( !IsInSelection ( row, col ) ) if ( !IsInSelection ( row, col ) )
{
SelectCell( row, col ); SelectCell( row, col );
return;
}
size_t count; size_t count;
// Maybe we want to toggle a member of m_cellSelection. // Maybe we want to toggle a member of m_cellSelection.
// Then it can't be contained in rows/cols/block, and we // Then it can't be contained in rows/cols/block, and we
// just have to remove it from m_cellSelection. // just have to remove it from m_cellSelection.
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
count = m_cellSelection.GetCount(); count = m_cellSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords = m_cellSelection[n]; wxGridCellCoords& coords = m_cellSelection[n];
if ( row == coords.GetRow() && col == coords.GetCol() ) if ( row == coords.GetRow() && col == coords.GetCol() )
{ {
m_cellSelection.RemoveAt(n); wxRect r;
n--; count--; r = m_grid->BlockToDeviceRect( m_cellSelection[n],
wxRect r; m_cellSelection[n] );
r = m_grid->BlockToDeviceRect( m_cellSelection[n], m_cellSelection.RemoveAt(n);
m_cellSelection[n] ); n--; count--;
if ( !m_grid->GetBatchCount() ) if ( !m_grid->GetBatchCount() )
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
return; return;
} }
} }
} }
// remove a cell from the middle of a block (the really ugly case) // remove a cell from the middle of a block (the really ugly case)
count = m_blockSelectionTopLeft.GetCount(); count = m_blockSelectionTopLeft.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n]; wxGridCellCoords& coords1 = m_blockSelectionTopLeft[n];
wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n]; wxGridCellCoords& coords2 = m_blockSelectionBottomRight[n];
int topRow = coords1.GetRow(); int topRow = coords1.GetRow();
int leftCol = coords1.GetCol(); int leftCol = coords1.GetCol();
int bottomRow = coords2.GetRow(); int bottomRow = coords2.GetRow();
int rightCol = coords2.GetCol(); int rightCol = coords2.GetCol();
if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol, if ( BlockContainsCell( topRow, leftCol, bottomRow, rightCol,
row, col ) ) row, col ) )
{ {
// remove the block // remove the block
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
// add up to 4 smaller blocks and set update region // add up to 4 smaller blocks and set update region
if ( m_selectionMode != wxGridSelection::wxGridSelectColumns ) if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
if ( topRow < row ) if ( topRow < row )
SelectBlock( topRow, leftCol, row - 1, rightCol ); SelectBlock( topRow, leftCol, row - 1, rightCol );
if ( bottomRow > row ) if ( bottomRow > row )
SelectBlock( row + 1, leftCol, bottomRow, rightCol ); SelectBlock( row + 1, leftCol, bottomRow, rightCol );
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectRows ) if ( m_selectionMode != wxGrid::wxGridSelectRows )
{ {
if ( leftCol < col ) if ( leftCol < col )
SelectBlock( row, leftCol, row, col - 1 ); SelectBlock( row, leftCol, row, col - 1 );
if ( rightCol > col ) if ( rightCol > col )
SelectBlock( row, col + 1, row, rightCol ); SelectBlock( row, col + 1, row, rightCol );
} }
} }
} }
// remove a cell from a row, adding up to two new blocks // 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(); size_t count = m_rowSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( m_rowSelection[n] == row ) if ( m_rowSelection[n] == row )
{ {
m_rowSelection.RemoveAt(n); m_rowSelection.RemoveAt(n);
n--; count--; n--; count--;
if (m_selectionMode == wxGridSelection::wxGridSelectCells) if (m_selectionMode == wxGrid::wxGridSelectCells)
{ {
if ( col > 0 ) if ( col > 0 )
SelectBlock( row, 0, row, col - 1 ); SelectBlock( row, 0, row, col - 1 );
if ( col < m_grid->GetNumberCols() - 1 ) if ( col < m_grid->GetNumberCols() - 1 )
SelectBlock( row, col + 1, row, 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 // 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(); size_t count = m_colSelection.GetCount();
for ( size_t n = 0; n < count; n++ ) for ( size_t n = 0; n < count; n++ )
{ {
if ( m_colSelection[n] == col ) if ( m_colSelection[n] == col )
{ {
m_colSelection.RemoveAt(n); m_colSelection.RemoveAt(n);
n--; count--; n--; count--;
if (m_selectionMode == wxGridSelection::wxGridSelectCells) if (m_selectionMode == wxGrid::wxGridSelectCells)
{ {
if ( row > 0 ) if ( row > 0 )
SelectBlock( 0, col, row - 1, col ); SelectBlock( 0, col, row - 1, col );
if ( row < m_grid->GetNumberRows() - 1 ) if ( row < m_grid->GetNumberRows() - 1 )
SelectBlock( row + 1, col, m_grid->GetNumberRows() - 1, col ); SelectBlock( row + 1, col, m_grid->GetNumberRows() - 1, col );
} }
} }
} }
} }
wxRect r; wxRect r;
switch (m_selectionMode) switch (m_selectionMode)
{ {
case wxGridSelection::wxGridSelectCells: case wxGrid::wxGridSelectCells:
r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ), r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, col ),
wxGridCellCoords( row, col ) ); wxGridCellCoords( row, col ) );
break; break;
case wxGridSelection::wxGridSelectRows: case wxGrid::wxGridSelectRows:
r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ), r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) ); wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
break; break;
case wxGridSelection::wxGridSelectColumns: case wxGrid::wxGridSelectColumns:
r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ), r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) ); wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
break; break;
} }
if ( !m_grid->GetBatchCount() ) if ( !m_grid->GetBatchCount() )
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
@@ -464,55 +490,59 @@ void wxGridSelection::ToggleCellSelection( int row, int col)
void wxGridSelection::ClearSelection() void wxGridSelection::ClearSelection()
{ {
size_t n; size_t n;
if ( m_selectionMode != wxGridSelection::wxGridSelectRows && if ( m_selectionMode != wxGrid::wxGridSelectRows &&
m_selectionMode != wxGridSelection::wxGridSelectColumns ) m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
while( ( n = m_cellSelection.GetCount() ) > 0) while( ( n = m_cellSelection.GetCount() ) > 0)
{ {
wxRect r; wxRect r;
r = m_grid->BlockToDeviceRect( m_cellSelection[n], n--;
m_cellSelection[n] ); r = m_grid->BlockToDeviceRect( m_cellSelection[n],
m_cellSelection.RemoveAt(n); m_cellSelection[n] );
if ( !m_grid->GetBatchCount() ) m_cellSelection.RemoveAt(n);
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); if ( !m_grid->GetBatchCount() )
} ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
} }
while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0) while( ( n = m_blockSelectionTopLeft.GetCount() ) > 0)
{ {
wxRect r; wxRect r;
r = m_grid->BlockToDeviceRect( m_blockSelectionTopLeft[n], n--;
m_blockSelectionBottomRight[n] ); r = m_grid->BlockToDeviceRect( m_blockSelectionTopLeft[n],
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionBottomRight[n] );
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
if ( !m_grid->GetBatchCount() ) m_blockSelectionBottomRight.RemoveAt(n);
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); if ( !m_grid->GetBatchCount() )
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectColumns ) if ( m_selectionMode != wxGrid::wxGridSelectColumns )
{ {
while( ( n = m_rowSelection.GetCount() ) > 0) while( ( n = m_rowSelection.GetCount() ) > 0)
{ {
int & row = m_rowSelection[n]; n--;
wxRect r; int & row = m_rowSelection[n];
r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ), wxRect r;
wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) ); r = m_grid->BlockToDeviceRect( wxGridCellCoords( row, 0 ),
m_rowSelection.RemoveAt(n); wxGridCellCoords( row, m_grid->GetNumberCols() - 1 ) );
if ( !m_grid->GetBatchCount() ) m_rowSelection.RemoveAt(n);
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); if ( !m_grid->GetBatchCount() )
} ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
} }
if ( m_selectionMode != wxGridSelection::wxGridSelectRows ) if ( m_selectionMode != wxGrid::wxGridSelectRows )
{ {
while( ( n = m_colSelection.GetCount() ) > 0) while( ( n = m_colSelection.GetCount() ) > 0)
{ {
int & col = m_colSelection[n]; n--;
wxRect r; int & col = m_colSelection[n];
r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ), wxRect r;
wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) ); r = m_grid->BlockToDeviceRect( wxGridCellCoords( 0, col ),
m_colSelection.RemoveAt(n); wxGridCellCoords( m_grid->GetNumberRows() - 1, col ) );
if ( !m_grid->GetBatchCount() ) m_colSelection.RemoveAt(n);
((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r ); if ( !m_grid->GetBatchCount() )
} ((wxWindow *)m_grid->m_gridWin)->Refresh( FALSE, &r );
}
} }
} }
@@ -562,8 +592,8 @@ void wxGridSelection::UpdateRows( size_t pos, int numRows )
{ {
// If rows inserted, increase row counter where necessary // If rows inserted, increase row counter where necessary
coords2.SetRow(row2 + numRows); coords2.SetRow(row2 + numRows);
if ( (size_t)row1 >= pos ) if ( (size_t)row1 >= pos )
coords1.SetRow(row1 + numRows); coords1.SetRow(row1 + numRows);
} }
else if (numRows < 0) else if (numRows < 0)
{ {
@@ -572,21 +602,21 @@ void wxGridSelection::UpdateRows( size_t pos, int numRows )
{ {
// ...either decrement row counter (if row still exists)... // ...either decrement row counter (if row still exists)...
coords2.SetRow(row2 + numRows); coords2.SetRow(row2 + numRows);
if ( (size_t) row1 >= pos) if ( (size_t) row1 >= pos)
coords1.SetRow( wxMax(row1 + numRows, (int) pos) ); coords1.SetRow( wxMax(row1 + numRows, (int) pos) );
} }
else else
{ {
if ( (size_t) row1 >= pos) if ( (size_t) row1 >= pos)
{ {
// ...or remove the attribute // ...or remove the attribute
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
} }
else else
coords2.SetRow(pos); coords2.SetRow(pos);
} }
} }
} }
@@ -663,8 +693,8 @@ void wxGridSelection::UpdateCols( size_t pos, int numCols )
{ {
// If rows inserted, increase row counter where necessary // If rows inserted, increase row counter where necessary
coords2.SetCol(col2 + numCols); coords2.SetCol(col2 + numCols);
if ( (size_t)col1 >= pos ) if ( (size_t)col1 >= pos )
coords1.SetCol(col1 + numCols); coords1.SetCol(col1 + numCols);
} }
else if (numCols < 0) else if (numCols < 0)
{ {
@@ -673,21 +703,21 @@ void wxGridSelection::UpdateCols( size_t pos, int numCols )
{ {
// ...either decrement col counter (if col still exists)... // ...either decrement col counter (if col still exists)...
coords2.SetCol(col2 + numCols); coords2.SetCol(col2 + numCols);
if ( (size_t) col1 >= pos) if ( (size_t) col1 >= pos)
coords1.SetCol( wxMax(col1 + numCols, (int) pos) ); coords1.SetCol( wxMax(col1 + numCols, (int) pos) );
} }
else else
{ {
if ( (size_t) col1 >= pos) if ( (size_t) col1 >= pos)
{ {
// ...or remove the attribute // ...or remove the attribute
m_blockSelectionTopLeft.RemoveAt(n); m_blockSelectionTopLeft.RemoveAt(n);
m_blockSelectionBottomRight.RemoveAt(n); m_blockSelectionBottomRight.RemoveAt(n);
n--; count--; n--; count--;
} }
else else
coords2.SetCol(pos); coords2.SetCol(pos);
} }
} }
} }
@@ -720,18 +750,18 @@ void wxGridSelection::UpdateCols( size_t pos, int numCols )
} }
int wxGridSelection::BlockContain( int topRow1, int leftCol1, int wxGridSelection::BlockContain( int topRow1, int leftCol1,
int bottomRow1, int rightCol1, int bottomRow1, int rightCol1,
int topRow2, int leftCol2, int topRow2, int leftCol2,
int bottomRow2, int rightCol2 ) int bottomRow2, int rightCol2 )
// returns 1, if Block1 contains Block2, // returns 1, if Block1 contains Block2,
// -1, if Block2 contains Block1, // -1, if Block2 contains Block1,
// 0, otherwise // 0, otherwise
{ {
if ( topRow1 <= topRow2 && bottomRow2 <= bottomRow1 && if ( topRow1 <= topRow2 && bottomRow2 <= bottomRow1 &&
leftCol1 <= leftCol2 && rightCol2 <= rightCol1 ) leftCol1 <= leftCol2 && rightCol2 <= rightCol1 )
return 1; return 1;
else if ( topRow2 <= topRow1 && bottomRow1 <= bottomRow2 && else if ( topRow2 <= topRow1 && bottomRow1 <= bottomRow2 &&
leftCol2 <= leftCol1 && rightCol1 <= rightCol2 ) leftCol2 <= leftCol1 && rightCol1 <= rightCol2 )
return -1; return -1;
return 0; return 0;
} }