wxASSERT_MSG( (!((num_rows > 0) && (num_cols <= 0)) ||
!((num_rows <= 0) && (num_cols > 0)) ||
!((num_rows == 0) && (num_cols == 0))),
- wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
+ wxT("wxGridCellAttr::SetSize only takes two positive values or negative/zero values"));
m_sizeRows = num_rows;
m_sizeCols = num_cols;
// the label of the first column had been set it would have only one
// element and not numCols, so account for it
int numRemaining = m_colLabels.size() - colID;
- m_colLabels.RemoveAt( colID, wxMin(numCols, numRemaining) );
+ if (numRemaining > 0)
+ m_colLabels.RemoveAt( colID, wxMin(numCols, numRemaining) );
}
if ( numCols >= curNumCols )
m_owner->DrawHighlight( dc, dirtyCells );
}
+void wxGrid::Render( wxDC& dc,
+ const wxPoint& position,
+ const wxSize& size,
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ int style )
+{
+ wxCHECK_RET( bottomRight.GetCol() < GetNumberCols(),
+ "Invalid right column" );
+ wxCHECK_RET( bottomRight.GetRow() < GetNumberRows(),
+ "Invalid bottom row" );
+
+ // store user settings and reset later
+
+ // remove grid selection, don't paint selection colour
+ // unless we have wxGRID_DRAW_SELECTION
+ // block selections are the only ones catered for here
+ wxGridCellCoordsArray selectedCells;
+ bool hasSelection = IsSelection();
+ if ( hasSelection && !( style & wxGRID_DRAW_SELECTION ) )
+ {
+ selectedCells = GetSelectionBlockTopLeft();
+ // non block selections may not have a bottom right
+ if ( GetSelectionBlockBottomRight().size() )
+ selectedCells.Add( GetSelectionBlockBottomRight()[ 0 ] );
+
+ ClearSelection();
+ }
+
+ // store user device origin
+ wxCoord userOriginX, userOriginY;
+ dc.GetDeviceOrigin( &userOriginX, &userOriginY );
+
+ // store user scale
+ double scaleUserX, scaleUserY;
+ dc.GetUserScale( &scaleUserX, &scaleUserY );
+
+ // set defaults if necessary
+ wxGridCellCoords leftTop( topLeft ), rightBottom( bottomRight );
+ if ( leftTop.GetCol() < 0 )
+ leftTop.SetCol(0);
+ if ( leftTop.GetRow() < 0 )
+ leftTop.SetRow(0);
+ if ( rightBottom.GetCol() < 0 )
+ rightBottom.SetCol(GetNumberCols() - 1);
+ if ( rightBottom.GetRow() < 0 )
+ rightBottom.SetRow(GetNumberRows() - 1);
+
+ // get grid offset, size and cell parameters
+ wxPoint pointOffSet;
+ wxSize sizeGrid;
+ wxGridCellCoordsArray renderCells;
+ wxArrayInt arrayCols;
+ wxArrayInt arrayRows;
+
+ GetRenderSizes( leftTop, rightBottom,
+ pointOffSet, sizeGrid,
+ renderCells,
+ arrayCols, arrayRows );
+
+ // add headers/labels to dimensions
+ if ( style & wxGRID_DRAW_ROWS_HEADER )
+ sizeGrid.x += GetRowLabelSize();
+ if ( style & wxGRID_DRAW_COLS_HEADER )
+ sizeGrid.y += GetColLabelSize();
+
+ // get render start position in logical units
+ wxPoint positionRender = GetRenderPosition( dc, position );
+
+ wxCoord originX = dc.LogicalToDeviceX( positionRender.x );
+ wxCoord originY = dc.LogicalToDeviceY( positionRender.y );
+
+ dc.SetDeviceOrigin( originX, originY );
+
+ SetRenderScale( dc, positionRender, size, sizeGrid );
+
+ // draw row headers at specified origin
+ if ( GetRowLabelSize() > 0 && ( style & wxGRID_DRAW_ROWS_HEADER ) )
+ {
+ if ( style & wxGRID_DRAW_COLS_HEADER )
+ {
+ DrawCornerLabel( dc ); // do only if both col and row labels drawn
+ originY += dc.LogicalToDeviceYRel( GetColLabelSize() );
+ }
+
+ originY -= dc.LogicalToDeviceYRel( pointOffSet.y );
+ dc.SetDeviceOrigin( originX, originY );
+
+ DrawRowLabels( dc, arrayRows );
+
+ // reset for columns
+ if ( style & wxGRID_DRAW_COLS_HEADER )
+ originY -= dc.LogicalToDeviceYRel( GetColLabelSize() );
+
+ originY += dc.LogicalToDeviceYRel( pointOffSet.y );
+ // X offset so we don't overwrite row labels
+ originX += dc.LogicalToDeviceXRel( GetRowLabelSize() );
+ }
+
+ // subtract col offset where startcol > 0
+ originX -= dc.LogicalToDeviceXRel( pointOffSet.x );
+ // no y offset for col labels, they are at the Y origin
+
+ // draw column labels
+ if ( style & wxGRID_DRAW_COLS_HEADER )
+ {
+ dc.SetDeviceOrigin( originX, originY );
+ DrawColLabels( dc, arrayCols );
+ // don't overwrite the labels, increment originY
+ originY += dc.LogicalToDeviceYRel( GetColLabelSize() );
+ }
+
+ // set device origin to draw grid cells and lines
+ originY -= dc.LogicalToDeviceYRel( pointOffSet.y );
+ dc.SetDeviceOrigin( originX, originY );
+
+ // draw cell area background
+ dc.SetBrush( GetDefaultCellBackgroundColour() );
+ dc.SetPen( *wxTRANSPARENT_PEN );
+ // subtract headers from grid area dimensions
+ wxSize sizeCells( sizeGrid );
+ if ( style & wxGRID_DRAW_ROWS_HEADER )
+ sizeCells.x -= GetRowLabelSize();
+ if ( style & wxGRID_DRAW_COLS_HEADER )
+ sizeCells.y -= GetColLabelSize();
+
+ dc.DrawRectangle( pointOffSet, sizeCells );
+
+ // draw cells
+ DrawGridCellArea( dc, renderCells );
+
+ // draw grid lines
+ if ( style & wxGRID_DRAW_CELL_LINES )
+ {
+ wxRegion regionClip( pointOffSet.x, pointOffSet.y,
+ sizeCells.x, sizeCells.y );
+
+ DrawRangeGridLines(dc, regionClip, renderCells[0], renderCells.Last());
+ }
+
+ // draw render rectangle bounding lines
+ DoRenderBox( dc, style,
+ pointOffSet, sizeCells,
+ leftTop, rightBottom );
+
+ // restore user setings
+ dc.SetDeviceOrigin( userOriginX, userOriginY );
+ dc.SetUserScale( scaleUserX, scaleUserY );
+
+ if ( selectedCells.size() && !( style & wxGRID_DRAW_SELECTION ) )
+ {
+ SelectBlock( selectedCells[ 0 ].GetRow(),
+ selectedCells[ 0 ].GetCol(),
+ selectedCells[ selectedCells.size() -1 ].GetRow(),
+ selectedCells[ selectedCells.size() -1 ].GetCol() );
+ }
+}
+
+void
+wxGrid::SetRenderScale(wxDC& dc,
+ const wxPoint& pos, const wxSize& size,
+ const wxSize& sizeGrid )
+{
+ double scaleX, scaleY;
+ wxSize sizeTemp;
+
+ if ( size.GetWidth() != wxDefaultSize.GetWidth() ) // size.x was specified
+ sizeTemp.SetWidth( size.GetWidth() );
+ else
+ sizeTemp.SetWidth( dc.DeviceToLogicalXRel( dc.GetSize().GetWidth() )
+ - pos.x );
+
+ if ( size.GetHeight() != wxDefaultSize.GetHeight() ) // size.y was specified
+ sizeTemp.SetHeight( size.GetHeight() );
+ else
+ sizeTemp.SetHeight( dc.DeviceToLogicalYRel( dc.GetSize().GetHeight() )
+ - pos.y );
+
+ scaleX = (double)( (double) sizeTemp.GetWidth() / (double) sizeGrid.GetWidth() );
+ scaleY = (double)( (double) sizeTemp.GetHeight() / (double) sizeGrid.GetHeight() );
+
+ dc.SetUserScale( wxMin( scaleX, scaleY), wxMin( scaleX, scaleY ) );
+}
+
+// get grid rendered size, origin offset and fill cell arrays
+void wxGrid::GetRenderSizes( const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ wxPoint& pointOffSet, wxSize& sizeGrid,
+ wxGridCellCoordsArray& renderCells,
+ wxArrayInt& arrayCols, wxArrayInt& arrayRows )
+{
+ pointOffSet.x = 0;
+ pointOffSet.y = 0;
+ sizeGrid.SetWidth( 0 );
+ sizeGrid.SetHeight( 0 );
+
+ int col, row;
+
+ wxGridSizesInfo sizeinfo = GetColSizes();
+ for ( col = 0; col <= bottomRight.GetCol(); col++ )
+ {
+ if ( col < topLeft.GetCol() )
+ {
+ pointOffSet.x += sizeinfo.GetSize( col );
+ }
+ else
+ {
+ for ( row = topLeft.GetRow(); row <= bottomRight.GetRow(); row++ )
+ {
+ renderCells.Add( wxGridCellCoords( row, col ));
+ arrayRows.Add( row ); // column labels rendered in DrawColLabels
+ }
+ arrayCols.Add( col ); // row labels rendered in DrawRowLabels
+ sizeGrid.x += sizeinfo.GetSize( col );
+ }
+ }
+
+ sizeinfo = GetRowSizes();
+ for ( row = 0; row <= bottomRight.GetRow(); row++ )
+ {
+ if ( row < topLeft.GetRow() )
+ pointOffSet.y += sizeinfo.GetSize( row );
+ else
+ sizeGrid.y += sizeinfo.GetSize( row );
+ }
+}
+
+// get render start position
+// if position not specified use dc draw extents MaxX and MaxY
+wxPoint wxGrid::GetRenderPosition( wxDC& dc, const wxPoint& position )
+{
+ wxPoint positionRender( position );
+
+ if ( !positionRender.IsFullySpecified() )
+ {
+ if ( positionRender.x == wxDefaultPosition.x )
+ positionRender.x = dc.MaxX();
+
+ if ( positionRender.y == wxDefaultPosition.y )
+ positionRender.y = dc.MaxY();
+ }
+
+ return positionRender;
+}
+
+// draw render rectangle bounding lines
+// useful where there is multi cell row or col clipping and no cell border
+void wxGrid::DoRenderBox( wxDC& dc, const int& style,
+ const wxPoint& pointOffSet,
+ const wxSize& sizeCells,
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight )
+{
+ if ( !( style & wxGRID_DRAW_BOX_RECT ) )
+ return;
+
+ int bottom = pointOffSet.y + sizeCells.GetY(),
+ right = pointOffSet.x + sizeCells.GetX() - 1;
+
+ // horiz top line if we are not drawing column header/labels
+ if ( !( style & wxGRID_DRAW_COLS_HEADER ) )
+ {
+ int left = pointOffSet.x;
+ left += ( style & wxGRID_DRAW_COLS_HEADER )
+ ? - GetRowLabelSize() : 0;
+ dc.SetPen( GetRowGridLinePen( topLeft.GetRow() ) );
+ dc.DrawLine( left,
+ pointOffSet.y,
+ right,
+ pointOffSet.y );
+ }
+
+ // horiz bottom line
+ dc.SetPen( GetRowGridLinePen( bottomRight.GetRow() ) );
+ dc.DrawLine( pointOffSet.x, bottom - 1, right, bottom - 1 );
+
+ // left vertical line if we are not drawing row header/labels
+ if ( !( style & wxGRID_DRAW_ROWS_HEADER ) )
+ {
+ int top = pointOffSet.y;
+ top += ( style & wxGRID_DRAW_COLS_HEADER )
+ ? - GetColLabelSize() : 0;
+ dc.SetPen( GetColGridLinePen( topLeft.GetCol() ) );
+ dc.DrawLine( pointOffSet.x -1,
+ top,
+ pointOffSet.x - 1,
+ bottom - 1 );
+ }
+
+ // right vertical line
+ dc.SetPen( GetColGridLinePen( bottomRight.GetCol() ) );
+ dc.DrawLine( right, pointOffSet.y, right, bottom - 1 );
+}
+
void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
{
wxWindow::ScrollWindow( dx, dy, rect );
wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg ) const
{
- wxRegionIterator iter( reg );
wxRect r;
wxGridCellCoordsArray cellsExposed;
int left, top, right, bottom;
- while ( iter )
+ for ( wxRegionIterator iter(reg); iter; ++iter )
{
r = iter.GetRect();
+ // Skip 0-height cells, they're invisible anyhow, don't waste time
+ // getting their rectangles and so on.
+ if ( !r.GetHeight() )
+ continue;
+
// TODO: remove this when we can...
// There is a bug in wxMotif that gives garbage update
// rectangles if you jump-scroll a long way by clicking the
for ( size_t n = 0; n < count; n++ )
cellsExposed.Add(wxGridCellCoords(row, cols[n]));
}
-
- ++iter;
}
return cellsExposed;
// grid mouse event processing
// ----------------------------------------------------------------------------
-void
+bool
wxGrid::DoGridCellDrag(wxMouseEvent& event,
const wxGridCellCoords& coords,
bool isFirstDrag)
{
+ bool performDefault = true ;
+
if ( coords == wxGridNoCellCoords )
- return; // we're outside any valid cell
+ return performDefault; // we're outside any valid cell
// Hide the edit control, so it won't interfere with drag-shrinking.
if ( IsCellEditControlShown() )
if ( m_selectedBlockCorner == wxGridNoCellCoords)
m_selectedBlockCorner = coords;
- SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event);
- return;
+ // if event is handled by user code, no further processing
+ if ( SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event) != 0 )
+ performDefault = false;
+
+ return performDefault;
}
}
// we don't handle the other key modifiers
event.Skip();
}
+
+ return performDefault;
}
void wxGrid::DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper)
switch ( m_cursorMode )
{
case WXGRID_CURSOR_SELECT_CELL:
- DoGridCellDrag(event, coords, isFirstDrag);
+ // no further handling if handled by user
+ if ( DoGridCellDrag(event, coords, isFirstDrag) == false )
+ return;
break;
case WXGRID_CURSOR_RESIZE_ROW:
mouseEv.GetY() + GetColLabelSize(),
false,
mouseEv);
+
+ if ( type == wxEVT_GRID_CELL_BEGIN_DRAG )
+ {
+ // by default the dragging is not supported, the user code must
+ // explicitly allow the event for it to take place
+ gridEvt.Veto();
+ }
+
claimed = GetEventHandler()->ProcessEvent(gridEvt);
vetoed = !gridEvt.IsAllowed();
}
}
}
+// Used by wxGrid::Render() to draw the grid lines only for the cells in the
+// specified range.
+void
+wxGrid::DrawRangeGridLines(wxDC& dc,
+ const wxRegion& reg,
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight)
+{
+ if ( !m_gridLinesEnabled )
+ return;
+
+ int top, left, width, height;
+ reg.GetBox( left, top, width, height );
+
+ // create a clipping region
+ wxRegion clippedcells( dc.LogicalToDeviceX( left ),
+ dc.LogicalToDeviceY( top ),
+ dc.LogicalToDeviceXRel( width ),
+ dc.LogicalToDeviceYRel( height ) );
+
+ // subtract multi cell span area from clipping region for lines
+ wxRect rect;
+ for ( int row = topLeft.GetRow(); row <= bottomRight.GetRow(); row++ )
+ {
+ for ( int col = topLeft.GetCol(); col <= bottomRight.GetCol(); col++ )
+ {
+ int cell_rows, cell_cols;
+ GetCellSize( row, col, &cell_rows, &cell_cols );
+ if ( cell_rows > 1 || cell_cols > 1 ) // multi cell
+ {
+ rect = CellToRect( row, col );
+ // cater for scaling
+ // device origin already set in ::Render() for x, y
+ rect.x = dc.LogicalToDeviceX( rect.x );
+ rect.y = dc.LogicalToDeviceY( rect.y );
+ rect.width = dc.LogicalToDeviceXRel( rect.width );
+ rect.height = dc.LogicalToDeviceYRel( rect.height ) - 1;
+ clippedcells.Subtract( rect );
+ }
+ else if ( cell_rows < 0 || cell_cols < 0 ) // part of multicell
+ {
+ rect = CellToRect( row + cell_rows, col + cell_cols );
+ rect.x = dc.LogicalToDeviceX( rect.x );
+ rect.y = dc.LogicalToDeviceY( rect.y );
+ rect.width = dc.LogicalToDeviceXRel( rect.width );
+ rect.height = dc.LogicalToDeviceYRel( rect.height ) - 1;
+ clippedcells.Subtract( rect );
+ }
+ }
+ }
+
+ dc.SetDeviceClippingRegion( clippedcells );
+
+ DoDrawGridLines(dc,
+ top, left, top + height, left + width,
+ topLeft.GetRow(), topLeft.GetCol(),
+ bottomRight.GetRow(), bottomRight.GetCol());
+
+ dc.DestroyClippingRegion();
+}
+
// This is used to redraw all grid lines e.g. when the grid line colour
// has been changed
//
dc.SetDeviceClippingRegion( clippedcells );
+ DoDrawGridLines(dc,
+ top, left, bottom, right,
+ topRow, leftCol, m_numRows, m_numCols);
+ dc.DestroyClippingRegion();
+}
+
+void
+wxGrid::DoDrawGridLines(wxDC& dc,
+ int top, int left,
+ int bottom, int right,
+ int topRow, int leftCol,
+ int bottomRow, int rightCol)
+{
// horizontal grid lines
- for ( int i = internalYToRow(top); i < m_numRows; i++ )
+ for ( int i = topRow; i < bottomRow; i++ )
{
int bot = GetRowBottom(i) - 1;
}
// vertical grid lines
- for ( int colPos = leftCol; colPos < m_numCols; colPos++ )
+ for ( int colPos = leftCol; colPos < rightCol; colPos++ )
{
int i = GetColAt( colPos );
dc.DrawLine( colRight, top, colRight, bottom );
}
}
-
- dc.DestroyClippingRegion();
}
void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
}
// See comment in SetColSize
- if ( height < GetRowMinimalAcceptableHeight())
+ if ( height > 0 && height < GetRowMinimalAcceptableHeight())
return;
if ( m_rowHeights.IsEmpty() )
}
if ( !GetBatchCount() )
+ {
CalcDimensions();
+ Refresh();
+ }
}
void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
projects / wxWidgets.git / blobdiff