// Required for wxIs... functions
#include <ctype.h>
-WX_DECLARE_HASH_SET_WITH_DECL(int, wxIntegerHash, wxIntegerEqual,
- wxGridFixedIndicesSet, class WXDLLIMPEXP_ADV);
+WX_DECLARE_HASH_SET_WITH_DECL_PTR(int, wxIntegerHash, wxIntegerEqual,
+ wxGridFixedIndicesSet, class WXDLLIMPEXP_ADV);
// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
+namespace
+{
+
//#define DEBUG_ATTR_CACHE
#ifdef DEBUG_ATTR_CACHE
static size_t gs_nAttrCacheHits = 0;
static size_t gs_nAttrCacheMisses = 0;
#endif
+// this struct simply combines together the default header renderers
+//
+// as the renderers ctors are trivial, there is no problem with making them
+// globals
+struct DefaultHeaderRenderers
+{
+ wxGridColumnHeaderRendererDefault colRenderer;
+ wxGridRowHeaderRendererDefault rowRenderer;
+ wxGridCornerHeaderRendererDefault cornerRenderer;
+} gs_defaultHeaderRenderers;
+
+} // anonymous namespace
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
wxDEFINE_EVENT( wxEVT_GRID_EDITOR_SHOWN, wxGridEvent );
wxDEFINE_EVENT( wxEVT_GRID_EDITOR_HIDDEN, wxGridEvent );
wxDEFINE_EVENT( wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent );
+wxDEFINE_EVENT( wxEVT_GRID_TABBING, wxGridEvent );
+
+// ----------------------------------------------------------------------------
+// private helpers
+// ----------------------------------------------------------------------------
+
+namespace
+{
+
+ // ensure that first is less or equal to second, swapping the values if
+ // necessary
+ void EnsureFirstLessThanSecond(int& first, int& second)
+ {
+ if ( first > second )
+ wxSwap(first, second);
+ }
+
+} // anonymous namespace
// ============================================================================
// implementation
BEGIN_EVENT_TABLE(wxGridHeaderCtrl, wxHeaderCtrl)
EVT_HEADER_CLICK(wxID_ANY, wxGridHeaderCtrl::OnClick)
+ EVT_HEADER_DCLICK(wxID_ANY, wxGridHeaderCtrl::OnDoubleClick)
+ EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxGridHeaderCtrl::OnRightClick)
EVT_HEADER_BEGIN_RESIZE(wxID_ANY, wxGridHeaderCtrl::OnBeginResize)
EVT_HEADER_RESIZING(wxID_ANY, wxGridHeaderCtrl::OnResizing)
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;
}
}
+void wxGridCellAttr::GetNonDefaultAlignment(int *hAlign, int *vAlign) const
+{
+ if ( hAlign && m_hAlign != wxALIGN_INVALID )
+ *hAlign = m_hAlign;
+
+ if ( vAlign && m_vAlign != wxALIGN_INVALID )
+ *vAlign = m_vAlign;
+}
+
void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
{
if ( num_rows )
}
}
+const wxGridColumnHeaderRenderer&
+wxGridCellAttrProvider::GetColumnHeaderRenderer(int WXUNUSED(col))
+{
+ return gs_defaultHeaderRenderers.colRenderer;
+}
+
+const wxGridRowHeaderRenderer&
+wxGridCellAttrProvider::GetRowHeaderRenderer(int WXUNUSED(row))
+{
+ return gs_defaultHeaderRenderers.rowRenderer;
+}
+
+const wxGridCornerHeaderRenderer& wxGridCellAttrProvider::GetCornerRenderer()
+{
+ return gs_defaultHeaderRenderers.cornerRenderer;
+}
+
// ----------------------------------------------------------------------------
// wxGridTableBase
// ----------------------------------------------------------------------------
// m_colLabels stores just as many elements as it needs, e.g. if only
// the label of the first column had been set it would have only one
// element and not numCols, so account for it
- int nToRm = m_colLabels.size() - colID;
- if ( nToRm > 0 )
- m_colLabels.RemoveAt( colID, nToRm );
+ int numRemaining = m_colLabels.size() - colID;
+ 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 );
/////////////////////////////////////////////////////////////////////
-#if wxUSE_EXTENDED_RTTI
-WX_DEFINE_FLAGS( wxGridStyle )
-
-wxBEGIN_FLAGS( wxGridStyle )
- // new style border flags, we put them first to
- // use them for streaming out
- wxFLAGS_MEMBER(wxBORDER_SIMPLE)
- wxFLAGS_MEMBER(wxBORDER_SUNKEN)
- wxFLAGS_MEMBER(wxBORDER_DOUBLE)
- wxFLAGS_MEMBER(wxBORDER_RAISED)
- wxFLAGS_MEMBER(wxBORDER_STATIC)
- wxFLAGS_MEMBER(wxBORDER_NONE)
-
- // old style border flags
- wxFLAGS_MEMBER(wxSIMPLE_BORDER)
- wxFLAGS_MEMBER(wxSUNKEN_BORDER)
- wxFLAGS_MEMBER(wxDOUBLE_BORDER)
- wxFLAGS_MEMBER(wxRAISED_BORDER)
- wxFLAGS_MEMBER(wxSTATIC_BORDER)
- wxFLAGS_MEMBER(wxBORDER)
-
- // standard window styles
- wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
- wxFLAGS_MEMBER(wxCLIP_CHILDREN)
- wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
- wxFLAGS_MEMBER(wxWANTS_CHARS)
- wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
- wxFLAGS_MEMBER(wxALWAYS_SHOW_SB)
- wxFLAGS_MEMBER(wxVSCROLL)
- wxFLAGS_MEMBER(wxHSCROLL)
-
-wxEND_FLAGS( wxGridStyle )
-
-IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow,"wx/grid.h")
-
-wxBEGIN_PROPERTIES_TABLE(wxGrid)
- wxHIDE_PROPERTY( Children )
- wxPROPERTY_FLAGS( WindowStyle , wxGridStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
-wxEND_PROPERTIES_TABLE()
-
-wxBEGIN_HANDLERS_TABLE(wxGrid)
-wxEND_HANDLERS_TABLE()
-
-wxCONSTRUCTOR_5( wxGrid , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
-
-/*
- TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
-*/
-#else
-IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxScrolledWindow )
-#endif
-
BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
EVT_PAINT( wxGrid::OnPaint )
EVT_SIZE( wxGrid::OnSize )
Create();
SetInitialSize(size);
- SetScrollRate(m_scrollLineX, m_scrollLineY);
CalcDimensions();
return true;
m_table = NULL;
}
- delete m_selection;
- m_selection = NULL;
+ wxDELETE(m_selection);
m_ownTable = false;
m_numRows = 0;
m_created = true;
}
+ InvalidateBestSize();
+
return m_created;
}
m_extraWidth =
m_extraHeight = 0;
- m_scrollLineX = GRID_SCROLL_LINE_X;
- m_scrollLineY = GRID_SCROLL_LINE_Y;
+ // we can't call SetScrollRate() as the window isn't created yet but OTOH
+ // we don't need to call it neither as the scroll position is (0, 0) right
+ // now anyhow, so just set the parameters directly
+ m_xScrollPixelsPerLine = GRID_SCROLL_LINE_X;
+ m_yScrollPixelsPerLine = GRID_SCROLL_LINE_Y;
+
+ m_tabBehaviour = Tab_Stop;
}
// ----------------------------------------------------------------------------
int wxGrid::GetColWidth(int col) const
{
- return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
+ if ( m_colWidths.IsEmpty() )
+ return m_defaultColWidth;
+
+ // a negative width indicates a hidden column
+ return m_colWidths[col] > 0 ? m_colWidths[col] : 0;
}
int wxGrid::GetColLeft(int col) const
{
- return m_colRights.IsEmpty() ? GetColPos( col ) * m_defaultColWidth
- : m_colRights[col] - m_colWidths[col];
+ if ( m_colRights.IsEmpty() )
+ return GetColPos( col ) * m_defaultColWidth;
+
+ return m_colRights[col] - GetColWidth(col);
}
int wxGrid::GetColRight(int col) const
int wxGrid::GetRowHeight(int row) const
{
- return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
+ // no custom heights / hidden rows
+ if ( m_rowHeights.IsEmpty() )
+ return m_defaultRowHeight;
+
+ // a negative height indicates a hidden row
+ return m_rowHeights[row] > 0 ? m_rowHeights[row] : 0;
}
int wxGrid::GetRowTop(int row) const
{
- return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
- : m_rowBottoms[row] - m_rowHeights[row];
+ if ( m_rowBottoms.IsEmpty() )
+ return row * m_defaultRowHeight;
+
+ return m_rowBottoms[row] - GetRowHeight(row);
}
int wxGrid::GetRowBottom(int row) const
if ( !m_colAt.IsEmpty() )
{
//Shift the column IDs
- int i;
for ( i = 0; i < m_numCols - numCols; i++ )
{
if ( m_colAt[i] >= (int)pos )
m_colAt.Add( 0, numCols );
//Set the new columns' positions
- int i;
for ( i = oldNumCols; i < m_numCols; i++ )
{
m_colAt[i] = i;
break;
}
+ InvalidateBestSize();
+
if (result && !GetBatchCount() )
m_gridWin->Refresh();
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;
ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
m_dragLastPos = -1;
}
- else // not on row separator or it's not resizeable
+ else // not on row separator or it's not resizable
{
row = YToRow(y);
if ( row >=0 &&
void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
{
- int x, y;
- wxPoint pos( event.GetPosition() );
- CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
+ int x;
+ CalcUnscrolledPosition( event.GetPosition().x, 0, &x, NULL );
int col = XToCol(x);
if ( event.Dragging() )
//
else if ( event.LeftDown() )
{
- int col = XToEdgeOfCol(x);
- if ( col != wxNOT_FOUND && CanDragColSize(col) )
+ int colEdge = XToEdgeOfCol(x);
+ if ( colEdge != wxNOT_FOUND && CanDragColSize(colEdge) )
{
ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow());
}
else // not a request to start resizing
{
- col = XToCol(x);
if ( col >= 0 &&
!SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
{
}
else
{
- DoEndMoveCol(XToPos(x));
+ // get the position of the column we're over
+ int pos = XToPos(x);
+
+ // we may need to adjust the drop position but don't bother
+ // checking for it if we can't anyhow
+ if ( pos > 1 )
+ {
+ // also find the index of the column we're over: notice
+ // that the existing "col" variable may be invalid but
+ // we need a valid one here
+ const int colValid = GetColAt(pos);
+
+ // if we're on the "near" (usually left but right in
+ // RTL case) part of the column, the actual position we
+ // should be placed in is actually the one before it
+ bool onNearPart;
+ const int middle = GetColLeft(colValid) +
+ GetColWidth(colValid)/2;
+ if ( GetLayoutDirection() == wxLayout_LeftToRight )
+ onNearPart = (x <= middle);
+ else // wxLayout_RightToLeft
+ onNearPart = (x > middle);
+
+ if ( onNearPart )
+ pos--;
+ }
+
+ DoEndMoveCol(pos);
}
break;
bool captureMouse)
{
#if wxUSE_LOG_TRACE
- static const wxChar *cursorModes[] =
+ static const wxChar *const cursorModes[] =
{
wxT("SELECT_CELL"),
wxT("RESIZE_ROW"),
// 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() )
switch ( event.GetModifiers() )
{
- case wxMOD_CMD:
+ case wxMOD_CONTROL:
if ( m_selectedBlockCorner == wxGridNoCellCoords)
m_selectedBlockCorner = coords;
UpdateBlockBeingSelected(m_selectedBlockCorner, coords);
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:
if ( isFirstDrag )
{
+ wxASSERT_MSG( !m_winCapture, "shouldn't capture the mouse twice" );
+
m_winCapture = m_gridWin;
m_winCapture->CaptureMouse();
}
}
else
{
+ if ( m_selection )
+ {
+ // In row or column selection mode just clicking on the cell
+ // should select the row or column containing it: this is more
+ // convenient for the kinds of controls that use such selection
+ // mode and is compatible with 2.8 behaviour (see #12062).
+ switch ( m_selection->GetSelectionMode() )
+ {
+ case wxGridSelectCells:
+ case wxGridSelectRowsOrColumns:
+ // nothing to do in these cases
+ break;
+
+ case wxGridSelectRows:
+ m_selection->SelectRow(coords.GetRow());
+ break;
+
+ case wxGridSelectColumns:
+ m_selection->SelectCol(coords.GetCol());
+ break;
+ }
+ }
+
m_waitForSlowClick = m_currentCellCoords == coords &&
coords != wxGridNoCellCoords;
SetCurrentCell( coords );
void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
{
+ if ( event.Entering() || event.Leaving() )
+ {
+ // we don't care about these events but we must not reset m_isDragging
+ // if they happen so return before anything else is done
+ event.Skip();
+ return;
+ }
+
const wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
// coordinates of the cell under mouse
m_isDragging = false;
m_startDragPos = wxDefaultPosition;
- // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
- // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
- // wxGTK
-#if 0
- if ( event.Entering() || event.Leaving() )
- {
- ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
- m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
- }
-#endif // 0
-
// deal with various button presses
if ( event.IsButton() )
{
oper.SelectSize(rect) = oper.Select(size);
int subtractLines = 0;
- const int lineStart = oper.PosToLine(this, posLineStart);
- if ( lineStart >= 0 )
+ int line = doper.PosToLine(this, posLineStart);
+ if ( line >= 0 )
{
// ensure that if we have a multi-cell block we redraw all of
// it by increasing the refresh area to cover it entirely if a
// part of it is affected
- const int lineEnd = oper.PosToLine(this, posLineEnd, true);
- for ( int line = lineStart; line < lineEnd; line++ )
+ const int lineEnd = doper.PosToLine(this, posLineEnd, true);
+ for ( ; line < lineEnd; line++ )
{
int cellLines = oper.Select(
GetCellSize(oper.MakeCoords(m_dragRowOrCol, line)));
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();
}
break;
case WXK_TAB:
- if (event.ShiftDown())
- {
- if ( GetGridCursorCol() > 0 )
- {
- MoveCursorLeft( false );
- }
- else
- {
- // at left of grid
- DisableCellEditControl();
- }
- }
- else
{
- if ( GetGridCursorCol() < GetNumberCols() - 1 )
+ // send an event to the grid's parents for custom handling
+ wxGridEvent gridEvt(GetId(), wxEVT_GRID_TABBING, this,
+ GetGridCursorRow(), GetGridCursorCol(),
+ -1, -1, false, event);
+ if ( ProcessWindowEvent(gridEvt) )
{
- MoveCursorRight( false );
- }
- else
- {
- // at right of grid
- DisableCellEditControl();
+ // the event has been handled so no need for more processing
+ break;
}
}
+ DoGridProcessTab( event );
break;
case WXK_HOME:
- if ( event.ControlDown() )
- {
- GoToCell(0, 0);
- }
- else
- {
- event.Skip();
- }
+ GoToCell(event.ControlDown() ? 0
+ : m_currentCellCoords.GetRow(),
+ 0);
break;
case WXK_END:
- if ( event.ControlDown() )
- {
- GoToCell(m_numRows - 1, m_numCols - 1);
- }
- else
- {
- event.Skip();
- }
+ GoToCell(event.ControlDown() ? m_numRows - 1
+ : m_currentCellCoords.GetRow(),
+ m_numCols - 1);
break;
case WXK_PAGEUP:
{
}
+void wxGrid::DoGridProcessTab(wxKeyboardState& kbdState)
+{
+ const bool isForwardTab = !kbdState.ShiftDown();
+
+ // TAB processing only changes when we are at the borders of the grid, so
+ // let's first handle the common behaviour when we are not at the border.
+ if ( isForwardTab )
+ {
+ if ( GetGridCursorCol() < GetNumberCols() - 1 )
+ {
+ MoveCursorRight( false );
+ return;
+ }
+ }
+ else // going back
+ {
+ if ( GetGridCursorCol() )
+ {
+ MoveCursorLeft( false );
+ return;
+ }
+ }
+
+
+ // We only get here if the cursor is at the border of the grid, apply the
+ // configured behaviour.
+ switch ( m_tabBehaviour )
+ {
+ case Tab_Stop:
+ // Nothing special to do, we remain at the current cell.
+ break;
+
+ case Tab_Wrap:
+ // Go to the beginning of the next or the end of the previous row.
+ if ( isForwardTab )
+ {
+ if ( GetGridCursorRow() < GetNumberRows() - 1 )
+ {
+ GoToCell( GetGridCursorRow() + 1, 0 );
+ return;
+ }
+ }
+ else
+ {
+ if ( GetGridCursorRow() > 0 )
+ {
+ GoToCell( GetGridCursorRow() - 1, GetNumberCols() - 1 );
+ return;
+ }
+ }
+ break;
+
+ case Tab_Leave:
+ if ( Navigate( isForwardTab ? wxNavigationKeyEvent::IsForward
+ : wxNavigationKeyEvent::IsBackward ) )
+ return;
+ break;
+ }
+
+ // If we remain in this cell, stop editing it if we were doing so.
+ DisableCellEditControl();
+}
+
bool wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
{
if ( SendEvent(wxEVT_GRID_SELECT_CELL, coords) == -1 )
wxGrid::UpdateBlockBeingSelected(int topRow, int leftCol,
int bottomRow, int rightCol)
{
+ MakeCellVisible(m_selectedBlockCorner);
+ m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
+
if ( m_selection )
{
switch ( m_selection->GetSelectionMode() )
}
}
- m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
- MakeCellVisible(m_selectedBlockCorner);
-
EnsureFirstLessThanSecond(topRow, bottomRow);
EnsureFirstLessThanSecond(leftCol, rightCol);
// implicitly, causing this out-of order render.
#if !defined(__WXMAC__)
wxGridCellEditor *editor = attr->GetEditor(this, row, col);
- editor->PaintBackground(rect, attr);
+ editor->PaintBackground(dc, rect, *attr);
editor->DecRef();
#endif
}
}
}
+// 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)
if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
return;
+ wxGridCellAttrProvider * const
+ attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
+
+ // notice that an explicit static_cast is needed to avoid a compilation
+ // error with VC7.1 which, for some reason, tries to instantiate (abstract)
+ // wxGridRowHeaderRenderer class without it
const wxGridRowHeaderRenderer&
- rend = m_table->GetAttrProvider()->GetRowHeaderRenderer(row);
+ rend = attrProvider ? attrProvider->GetRowHeaderRenderer(row)
+ : static_cast<const wxGridRowHeaderRenderer&>
+ (gs_defaultHeaderRenderers.rowRenderer);
+
wxRect rect(0, GetRowTop(row), m_rowLabelWidth, GetRowHeight(row));
rend.DrawBorder(*this, dc, rect);
rect.width++;
rect.height++;
+ wxGridCellAttrProvider * const
+ attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
const wxGridCornerHeaderRenderer&
- rend = m_table->GetAttrProvider()->GetCornerRenderer();
+ rend = attrProvider ? attrProvider->GetCornerRenderer()
+ : static_cast<wxGridCornerHeaderRenderer&>
+ (gs_defaultHeaderRenderers.cornerRenderer);
rend.DrawBorder(*this, dc, rect);
}
int colLeft = GetColLeft(col);
wxRect rect(colLeft, 0, GetColWidth(col), m_colLabelHeight);
+ wxGridCellAttrProvider * const
+ attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
const wxGridColumnHeaderRenderer&
- rend = m_table->GetAttrProvider()->GetColumnHeaderRenderer(col);
+ rend = attrProvider ? attrProvider->GetColumnHeaderRenderer(col)
+ : static_cast<wxGridColumnHeaderRenderer&>
+ (gs_defaultHeaderRenderers.colRenderer);
if ( m_nativeColumnLabels )
{
}
else
{
+ // It is reported that we need to erase the background to avoid display
+ // artefacts, see #12055.
+ wxDCBrushChanger setBrush(dc, m_colWindow->GetBackgroundColour());
+ dc.DrawRectangle(rect);
+
rend.DrawBorder(*this, dc, rect);
}
bool wxGrid::IsCurrentCellReadOnly() const
{
- // const_cast
- wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
+ wxGridCellAttr*
+ attr = const_cast<wxGrid *>(this)->GetCellAttr(m_currentCellCoords);
bool readonly = attr->IsReadOnly();
attr->DecRef();
// compute row or column from some (unscrolled) coordinate value, using either
// m_defaultRowHeight/m_defaultColWidth or binary search on array of
-// m_rowBottoms/m_colRights to do it quickly (linear search shouldn't be used
-// for large grids)
+// m_rowBottoms/m_colRights to do it quickly in O(log n) time.
+// NOTE: This may not work correctly for reordered columns.
int wxGrid::PosToLinePos(int coord,
bool clipToMinMax,
const wxGridOperations& oper) const
}
- // adjust maxPos before starting the binary search
- if ( maxPos >= numLines )
- {
- maxPos = numLines - 1;
- }
- else
- {
- if ( coord >= lineEnds[oper.GetLineAt(this, maxPos)])
- {
- minPos = maxPos;
- const int minDist = oper.GetMinimalAcceptableLineSize(this);
- if ( minDist )
- maxPos = coord / minDist;
- else
- maxPos = numLines - 1;
- }
-
- if ( maxPos >= numLines )
- maxPos = numLines - 1;
- }
+ // binary search is quite efficient and we can't really make any assumptions
+ // on where to start here since row and columns could be of size 0 if they are
+ // hidden. While this could be made more efficient, some profiling will be
+ // necessary to determine if it really is a performance bottleneck
+ maxPos = numLines - 1;
// check if the position is beyond the last column
const int lineAtMaxPos = oper.GetLineAt(this, maxPos);
else if ( line > 0 &&
pos - oper.GetLineStartPos(this,
line) < WXGRID_LABEL_EDGE_ZONE )
- return line - 1;
+ {
+ return oper.GetLineBefore(this, line);
+ }
}
return -1;
//
// Sometimes GRID_SCROLL_LINE / 2 is not enough,
// so just add a full scroll unit...
- ypos += m_scrollLineY;
+ ypos += m_yScrollPixelsPerLine;
}
// special handling for wide cells - show always left part of the cell!
xpos = x0 + (right - cw);
// see comment for ypos above
- xpos += m_scrollLineX;
+ xpos += m_xScrollPixelsPerLine;
}
if ( xpos != -1 || ypos != -1 )
{
if ( xpos != -1 )
- xpos /= m_scrollLineX;
+ xpos /= m_xScrollPixelsPerLine;
if ( ypos != -1 )
- ypos /= m_scrollLineY;
+ ypos /= m_yScrollPixelsPerLine;
Scroll( xpos, ypos );
AdjustScrollbars();
}
}
m_rowLabelWidth = width;
+ InvalidateBestSize();
CalcWindowSizes();
wxScrolledWindow::Refresh( true );
}
}
m_colLabelHeight = height;
+ InvalidateBestSize();
CalcWindowSizes();
wxScrolledWindow::Refresh( true );
}
m_cellHighlightPenWidth = width;
// Just redrawing the cell highlight is not enough since that won't
- // make any visible change if the the thickness is getting smaller.
+ // make any visible change if the thickness is getting smaller.
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
m_cellHighlightROPenWidth = width;
// Just redrawing the cell highlight is not enough since that won't
- // make any visible change if the the thickness is getting smaller.
+ // make any visible change if the thickness is getting smaller.
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
if ( row == -1 || col == -1 ||
return allow;
}
-void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
+wxGrid::CellSpan
+wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
{
wxGridCellAttr *attr = GetCellAttr(row, col);
attr->GetSize( num_rows, num_cols );
attr->DecRef();
+
+ if ( *num_rows == 1 && *num_cols == 1 )
+ return CellSpan_None; // just a normal cell
+
+ if ( *num_rows < 0 || *num_cols < 0 )
+ return CellSpan_Inside; // covered by a multi-span cell
+
+ // this cell spans multiple cells to its right/bottom
+ return CellSpan_Main;
}
wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
}
}
+void wxGrid::RefreshAttr(int row, int col)
+{
+ if ( m_attrCache.row == row && m_attrCache.col == col )
+ ClearAttrCache();
+}
+
+
void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
{
if ( attr != NULL )
{
- wxGrid *self = (wxGrid *)this; // const_cast
+ wxGrid * const self = const_cast<wxGrid *>(this);
self->ClearAttrCache();
self->m_attrCache.row = row;
}
}
+namespace
+{
+
+// This is a common part of SetRowSize() and SetColSize() which takes care of
+// updating the height/width of a row/column depending on its current value and
+// the new one.
+//
+// Returns the difference between the new and the old size.
+int UpdateRowOrColSize(int& sizeCurrent, int sizeNew)
+{
+ // On input here sizeCurrent can be negative if it's currently hidden (the
+ // real size is its absolute value then). And sizeNew can be 0 to indicate
+ // that the row/column should be hidden or -1 to indicate that it should be
+ // shown again.
+
+ if ( sizeNew < 0 )
+ {
+ // We're showing back a previously hidden row/column.
+ wxASSERT_MSG( sizeNew == -1, wxS("New size must be positive or -1.") );
+
+ wxASSERT_MSG( sizeCurrent < 0, wxS("May only show back if hidden.") );
+
+ sizeCurrent = -sizeCurrent;
+
+ // This is positive which is correct.
+ return sizeCurrent;
+ }
+ else if ( sizeNew == 0 )
+ {
+ // We're hiding a row/column.
+ wxASSERT_MSG( sizeCurrent > 0, wxS("Can't hide if already hidden.") );
+
+ sizeCurrent = -sizeCurrent;
+
+ // This is negative which is correct.
+ return sizeCurrent;
+ }
+ else // We're just changing the row/column size.
+ {
+ // Here it could have been hidden or not previously.
+ const int sizeOld = sizeCurrent < 0 ? 0 : sizeCurrent;
+
+ sizeCurrent = sizeNew;
+
+ return sizeCurrent - sizeOld;
+ }
+}
+
+} // anonymous namespace
+
void wxGrid::SetRowSize( int row, int height )
{
- wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );
+ // See comment in SetColSize
+ if ( height > 0 && height < GetRowMinimalAcceptableHeight())
+ return;
- // if < 0 then calculate new height from label
- if ( height < 0 )
+ // The value of -1 is special and means to fit the height to the row label.
+ if ( height == -1 )
{
+ // As with the columns, ignore attempts to auto-size the hidden rows.
+ if ( GetRowHeight(row) == 0 )
+ return;
+
long w, h;
wxArrayString lines;
wxClientDC dc(m_rowLabelWin);
height = wxMax(h, GetRowMinimalAcceptableHeight());
}
- // See comment in SetColSize
- if ( height < GetRowMinimalAcceptableHeight())
- return;
+ DoSetRowSize(row, height);
+}
+
+void wxGrid::DoSetRowSize( int row, int height )
+{
+ wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );
if ( m_rowHeights.IsEmpty() )
{
InitRowHeights();
}
- int h = wxMax( 0, height );
- int diff = h - m_rowHeights[row];
+ const int diff = UpdateRowOrColSize(m_rowHeights[row], height);
+ if ( !diff )
+ return;
- m_rowHeights[row] = h;
for ( int i = row; i < m_numRows; i++ )
{
m_rowBottoms[i] += diff;
}
+ InvalidateBestSize();
+
if ( !GetBatchCount() )
+ {
CalcDimensions();
+ Refresh();
+ }
}
void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
void wxGrid::SetColSize( int col, int width )
{
- wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );
+ // we intentionally don't test whether the width is less than
+ // GetColMinimalWidth() here but we do compare it with
+ // GetColMinimalAcceptableWidth() as otherwise things currently break (see
+ // #651) -- and we also always allow the width of 0 as it has the special
+ // sense of hiding the column
+ if ( width > 0 && width < GetColMinimalAcceptableWidth() )
+ return;
- // if < 0 then calculate new width from label
- if ( width < 0 )
+ // The value of -1 is special and means to fit the width to the column label.
+ if ( width == -1 )
{
+ // We currently don't support auto-sizing hidden columns. We could, but
+ // it's not clear whether this is really needed and it would make the
+ // code more complex.
+ if ( GetColWidth(col) == 0 )
+ return;
+
long w, h;
wxArrayString lines;
wxClientDC dc(m_colWindow);
width = wxMax(width, GetColMinimalAcceptableWidth());
}
- // we intentionally don't test whether the width is less than
- // GetColMinimalWidth() here but we do compare it with
- // GetColMinimalAcceptableWidth() as otherwise things currently break (see
- // #651) -- and we also always allow the width of 0 as it has the special
- // sense of hiding the column
- if ( width > 0 && width < GetColMinimalAcceptableWidth() )
- return;
+ DoSetColSize(col, width);
+}
+
+void wxGrid::DoSetColSize( int col, int width )
+{
+ wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );
if ( m_colWidths.IsEmpty() )
{
InitColWidths();
}
- const int diff = width - m_colWidths[col];
- m_colWidths[col] = width;
+ const int diff = UpdateRowOrColSize(m_colWidths[col], width);
+ if ( !diff )
+ return;
+
if ( m_useNativeHeader )
GetGridColHeader()->UpdateColumn(col);
//else: will be refreshed when the header is redrawn
m_colRights[GetColAt(colPos)] += diff;
}
+ InvalidateBestSize();
+
if ( !GetBatchCount() )
{
CalcDimensions();
{
const bool column = direction == wxGRID_COLUMN;
+ // We don't support auto-sizing hidden rows or columns, this doesn't seem
+ // to make much sense.
+ if ( column )
+ {
+ if ( GetColWidth(colOrRow) == 0 )
+ return;
+ }
+ else
+ {
+ if ( GetRowHeight(colOrRow) == 0 )
+ return;
+ }
+
wxClientDC dc(m_gridWin);
// cancel editing of cell
HideCellEditControl();
SaveEditControlValue();
- // init both of them to avoid compiler warnings, even if we only need one
- int row = -1,
- col = -1;
+ // initialize both of them just to avoid compiler warnings even if only
+ // really needs to be initialized here
+ int row,
+ col;
if ( column )
+ {
+ row = -1;
col = colOrRow;
+ }
else
+ {
row = colOrRow;
+ col = -1;
+ }
wxCoord extent, extentMax = 0;
int max = column ? m_numRows : m_numCols;
for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
{
if ( column )
+ {
row = rowOrCol;
+ col = colOrRow;
+ }
else
+ {
+ row = colOrRow;
col = rowOrCol;
+ }
+
+ // we need to account for the cells spanning multiple columns/rows:
+ // while they may need a lot of space, they don't need all of it in
+ // this column/row
+ int numRows, numCols;
+ const CellSpan span = GetCellSize(row, col, &numRows, &numCols);
+ if ( span == CellSpan_Inside )
+ {
+ // we need to get the size of the main cell, not of a cell hidden
+ // by it
+ row += numRows;
+ col += numCols;
+
+ // get the size of the main cell too
+ GetCellSize(row, col, &numRows, &numCols);
+ }
+ // get cell ( main cell if CellSpan_Inside ) renderer best size
wxGridCellAttr *attr = GetCellAttr(row, col);
wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
if ( renderer )
{
wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
extent = column ? size.x : size.y;
+
+ if ( span != CellSpan_None )
+ {
+ // we spread the size of a spanning cell over all the cells it
+ // covers evenly -- this is probably not ideal but we can't
+ // really do much better here
+ //
+ // notice that numCols and numRows are never 0 as they
+ // correspond to the size of the main cell of the span and not
+ // of the cell inside it
+ extent /= column ? numCols : numRows;
+ }
+
if ( extent > extentMax )
extentMax = extent;
if ( column )
{
- dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
+ dc.GetMultiLineTextExtent( GetColLabelValue(colOrRow), &w, &h );
if ( GetColLabelTextOrientation() == wxVERTICAL )
w = h;
}
else
- dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
+ dc.GetMultiLineTextExtent( GetRowLabelValue(colOrRow), &w, &h );
extent = column ? w : h;
if ( extent > extentMax )
// comment in SetColSize() for explanation of why this isn't done
// in SetColSize().
if ( !setAsMin )
- extentMax = wxMax(extentMax, GetColMinimalWidth(col));
+ extentMax = wxMax(extentMax, GetColMinimalWidth(colOrRow));
- SetColSize( col, extentMax );
+ SetColSize( colOrRow, extentMax );
if ( !GetBatchCount() )
{
if ( m_useNativeHeader )
{
- GetGridColHeader()->UpdateColumn(col);
+ GetGridColHeader()->UpdateColumn(colOrRow);
}
else
{
int cw, ch, dummy;
m_gridWin->GetClientSize( &cw, &ch );
- wxRect rect ( CellToRect( 0, col ) );
+ wxRect rect ( CellToRect( 0, colOrRow ) );
rect.y = 0;
CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
rect.width = cw - rect.x;
// comment in SetColSize() for explanation of why this isn't done
// in SetRowSize().
if ( !setAsMin )
- extentMax = wxMax(extentMax, GetRowMinimalHeight(row));
+ extentMax = wxMax(extentMax, GetRowMinimalHeight(colOrRow));
- SetRowSize(row, extentMax);
+ SetRowSize(colOrRow, extentMax);
if ( !GetBatchCount() )
{
int cw, ch, dummy;
m_gridWin->GetClientSize( &cw, &ch );
- wxRect rect( CellToRect( row, 0 ) );
+ wxRect rect( CellToRect( colOrRow, 0 ) );
rect.x = 0;
CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
rect.width = m_rowLabelWidth;
if ( setAsMin )
{
if ( column )
- SetColMinimalWidth(col, extentMax);
+ SetColMinimalWidth(colOrRow, extentMax);
else
- SetRowMinimalHeight(row, extentMax);
+ SetRowMinimalHeight(colOrRow, extentMax);
}
}
// we know that we're not going to have scrollbars so disable them now to
// avoid trouble in SetClientSize() which can otherwise set the correct
// client size but also leave space for (not needed any more) scrollbars
- SetScrollbars(0, 0, 0, 0, 0, 0, true);
-
- // restore the scroll rate parameters overwritten by SetScrollbars()
- SetScrollRate(m_scrollLineX, m_scrollLineY);
+ SetScrollbars(m_xScrollPixelsPerLine, m_yScrollPixelsPerLine,
+ 0, 0, 0, 0, true);
SetClientSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight);
}
// autosize row height depending on label text
SetRowSize(row, -1);
+
ForceRefresh();
}
// autosize column width depending on label text
SetColSize(col, -1);
+
ForceRefresh();
}
wxSize wxGrid::DoGetBestSize() const
{
- wxGrid *self = (wxGrid *)this; // const_cast
+ wxGrid * const self = const_cast<wxGrid *>(this);
// we do the same as in AutoSize() here with the exception that we don't
// change the column/row sizes, only calculate them
wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
- // NOTE: This size should be cached, but first we need to add calls to
- // InvalidateBestSize everywhere that could change the results of this
- // calculation.
- // CacheBestSize(size);
-
return wxSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight)
+ GetWindowBorderSize();
}
AutoSize();
}
+#if WXWIN_COMPATIBILITY_2_8
wxPen& wxGrid::GetDividerPen() const
{
return wxNullPen;
}
+#endif // WXWIN_COMPATIBILITY_2_8
// ----------------------------------------------------------------------------
// cell value accessor functions
{
wxUnsignedToIntHashMap::const_iterator it = m_customSizes.find(pos);
- return it == m_customSizes.end() ? m_sizeDefault : it->second;
+ // if it's not found return the default
+ if ( it == m_customSizes.end() )
+ return m_sizeDefault;
+
+ // otherwise return 0 if it's hidden, currently there is no way to get
+ // its size before it had been hidden
+ if ( it->second < 0 )
+ return 0;
+
+ return it->second;
}
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff