-////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
// Name: grid.cpp
// Purpose: wxGrid and related classes
// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#include "wx/defs.h"
-
-#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
-#include "gridg.cpp"
-#else
-
#ifdef __GNUG__
#pragma implementation "grid.h"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
+#include "wx/defs.h"
+
#ifdef __BORLANDC__
#pragma hdrstop
#endif
+#if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
+#include "gridg.cpp"
+#else
+
#ifndef WX_PRECOMP
#include "wx/utils.h"
#include "wx/dcclient.h"
bool wxGridTableBase::InsertRows( size_t pos, size_t numRows )
{
- wxLogWarning( "Called grid table class function InsertRows(pos=%d, N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function InsertRows(pos=%d, N=%d)\n"
+ "but your derived table class does not override this function"),
pos, numRows );
return FALSE;
bool wxGridTableBase::AppendRows( size_t numRows )
{
- wxLogWarning( "Called grid table class function AppendRows(N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function AppendRows(N=%d)\n"
+ "but your derived table class does not override this function"),
numRows );
return FALSE;
bool wxGridTableBase::DeleteRows( size_t pos, size_t numRows )
{
- wxLogWarning( "Called grid table class function DeleteRows(pos=%d, N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function DeleteRows(pos=%d, N=%d)\n"
+ "but your derived table class does not override this function"),
pos, numRows );
return FALSE;
bool wxGridTableBase::InsertCols( size_t pos, size_t numCols )
{
- wxLogWarning( "Called grid table class function InsertCols(pos=%d, N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function InsertCols(pos=%d, N=%d)\n"
+ "but your derived table class does not override this function"),
pos, numCols );
return FALSE;
bool wxGridTableBase::AppendCols( size_t numCols )
{
- wxLogWarning( "Called grid table class function AppendCols(N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function AppendCols(N=%d)\n"
+ "but your derived table class does not override this function"),
numCols );
return FALSE;
bool wxGridTableBase::DeleteCols( size_t pos, size_t numCols )
{
- wxLogWarning( "Called grid table class function DeleteCols(pos=%d, N=%d)\n"
- "but your derived table class does not override this function",
+ wxLogWarning( wxT("Called grid table class function DeleteCols(pos=%d, N=%d)\n"
+ "but your derived table class does not override this function"),
pos, numCols );
return FALSE;
// this is a magic incantation which must be done!
#include <wx/arrimpl.cpp>
-WX_DEFINE_OBJARRAY(wxGridStringArray);
+WX_DEFINE_OBJARRAY(wxGridStringArray)
IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
if ( pos >= curNumRows )
{
- wxLogError( "Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
- "Pos value is invalid for present table with %d rows",
+ wxLogError( wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)...\n"
+ "Pos value is invalid for present table with %d rows"),
pos, numRows, curNumRows );
return FALSE;
}
{
// TODO: something better than this ?
//
- wxLogError( "Unable to append cols to a grid table with no rows.\n"
- "Call AppendRows() first" );
+ wxLogError( wxT("Unable to append cols to a grid table with no rows.\n"
+ "Call AppendRows() first") );
return FALSE;
}
if ( pos >= curNumCols )
{
- wxLogError( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
- "Pos value is invalid for present table with %d cols",
+ wxLogError( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
+ "Pos value is invalid for present table with %d cols"),
pos, numCols, curNumCols );
return FALSE;
}
case WXK_DOWN:
case WXK_LEFT:
case WXK_RIGHT:
+ case WXK_PRIOR:
+ case WXK_NEXT:
case WXK_RETURN:
if ( m_isCellControl )
{
m_rowHeights.Alloc( m_numRows );
m_rowBottoms.Alloc( m_numRows );
+ m_sumRowHeights = 0;
for ( i = 0; i < m_numRows; i++ )
{
m_rowHeights.Add( m_defaultRowHeight );
m_rowBottoms.Add( 0 ); // set by CalcDimensions()
}
-
+ m_sumRowHeights = m_defaultRowHeight * m_numRows;
+
m_colWidths.Alloc( m_numCols );
m_colRights.Alloc( m_numRows );
+ m_sumColWidths = 0;
for ( i = 0; i < m_numCols; i++ )
{
m_colWidths.Add( m_defaultColWidth );
m_colRights.Add( 0 ); // set by CalcDimensions()
}
-
+ m_sumColWidths = m_defaultColWidth * m_numCols;
+
// TODO: improve this ?
//
m_defaultCellFont = this->GetFont();
wxGRID_CELLCTRL,
"",
wxPoint(1,1),
- wxSize(1,1),
- wxNO_BORDER
+ wxSize(1,1)
#ifdef __WXMSW__
- | wxTE_MULTILINE | wxTE_NO_VSCROLL
+ , wxTE_MULTILINE | wxTE_NO_VSCROLL
#endif
);
m_cellEditCtrlEnabled = TRUE;
m_editCtrlType = wxGRID_TEXTCTRL;
- // Not really needed here, it gets called by OnSize()
+ // This is here in case OnSize does not get called when the grid is
+ // displayed
//
- // CalcDimensions();
+ CalcDimensions();
}
m_top = 0;
}
- int bottom = m_top + m_colLabelHeight;
- for ( i = m_scrollPosY; i < m_numRows; i++ )
- {
- bottom += m_rowHeights[i];
- m_rowBottoms[i] = bottom;
- }
-
- int right = m_left + m_rowLabelWidth;
- for ( i = m_scrollPosX; i < m_numCols; i++ )
- {
- right += m_colWidths[i];
- m_colRights[i] = right;
- }
-
- // adjust the scroll bars
+ // check to see if either of the scroll bars are required
//
-
int cw, ch;
GetClientSize(&cw, &ch);
int check;
for ( check = 0; check < 2; check++ )
{
- if ( m_numRows > 0 &&
- m_rowBottoms[m_numRows-1] + horizScrollBarHeight > ch )
+ if ( m_top + m_colLabelHeight + m_sumRowHeights + horizScrollBarHeight > ch )
{
vertScrollBarWidth = m_scrollBarWidth;
+ }
- m_wholeRowsVisible = 0;
- for ( i = m_scrollPosY; i < m_numRows; i++ )
- {
- // A partial row doesn't count, we still have to scroll to
- // see the rest of it
- if ( m_rowBottoms[i] + horizScrollBarHeight > ch ) break;
+ if ( m_left + m_rowLabelWidth + m_sumColWidths + vertScrollBarWidth > cw)
+ {
+ horizScrollBarHeight = m_scrollBarWidth;
+ }
+ }
- m_wholeRowsVisible++ ;
- }
+
+ // if the window has been resized while scrolled then the scroll
+ // position might need to be adjusted...
+ //
+ bool adjustScrollPos = FALSE;
+ if ( !vertScrollBarWidth )
+ {
+ if ( m_scrollPosY )
+ {
+ adjustScrollPos = TRUE;
+ m_scrollPosY = 0;
}
- else
+ }
+ if ( !horizScrollBarHeight )
+ {
+ if ( m_scrollPosX )
{
- m_wholeRowsVisible = m_numRows - m_scrollPosY;
- if ( m_scrollPosY )
- {
- vertScrollBarWidth = m_scrollBarWidth;
- }
+ adjustScrollPos = TRUE;
+ m_scrollPosX = 0;
}
-
+ }
- if ( m_numCols &&
- m_colRights[m_numCols-1] + vertScrollBarWidth > cw)
+
+ // calculate the coords of row bottom edges and col right edges
+ //
+ int bottom = m_top + m_colLabelHeight;
+ for ( i = m_scrollPosY; i < m_numRows; i++ )
+ {
+ bottom += m_rowHeights[i];
+ m_rowBottoms[i] = bottom;
+ }
+
+ int right = m_left + m_rowLabelWidth;
+ for ( i = m_scrollPosX; i < m_numCols; i++ )
+ {
+ right += m_colWidths[i];
+ m_colRights[i] = right;
+ }
+
+
+ // check how many rows and cols are visible
+ //
+ m_wholeRowsVisible = 0;
+ if ( m_numRows > 0 )
+ {
+ for ( i = m_scrollPosY; i < m_numRows; i++ )
{
- horizScrollBarHeight = m_scrollBarWidth;
+ // A partial row doesn't count, we still have to scroll to
+ // see the rest of it
+ if ( m_rowBottoms[i] + horizScrollBarHeight > ch ) break;
- m_wholeColsVisible = 0;
- for ( i = m_scrollPosX; i < m_numCols; i++ )
- {
- // A partial col doesn't count, we still have to scroll to
- // see the rest of it
- if ( m_colRights[i] + vertScrollBarWidth > cw ) break;
-
- m_wholeColsVisible++ ;
- }
+ m_wholeRowsVisible++ ;
}
- else
+ }
+
+ m_wholeColsVisible = 0;
+ if ( m_numCols )
+ {
+ for ( i = m_scrollPosX; i < m_numCols; i++ )
{
- // we can see the right-most column
- //
- m_wholeColsVisible = m_numCols - m_scrollPosX;
- if ( m_scrollPosX )
- {
- horizScrollBarHeight = m_scrollBarWidth;
- }
+ // A partial col doesn't count, we still have to scroll to
+ // see the rest of it
+ if ( m_colRights[i] + vertScrollBarWidth > cw ) break;
+
+ m_wholeColsVisible++ ;
}
}
-
if ( m_vertScrollBar )
{
m_right = wxMin( m_colRights[m_numCols-1],
cw - vertScrollBarWidth );
}
+
+ // if the scroll position was adjusted (due to a window resize)
+ // ensure that the cell highlight and edit control are displayed
+ // correctly
+ //
+ if ( adjustScrollPos ) SelectCell( m_currentCellCoords );
}
{
m_rowHeights.Insert( m_defaultRowHeight, pos );
m_rowBottoms.Insert( 0, pos );
+ m_sumRowHeights += m_defaultRowHeight;
}
m_numRows += numRows;
CalcDimensions();
{
m_rowHeights.Add( m_defaultRowHeight );
m_rowBottoms.Add( 0 );
+ m_sumRowHeights += m_defaultRowHeight;
}
m_numRows += numRows;
CalcDimensions();
int numRows = msg.GetCommandInt2();
for ( i = 0; i < numRows; i++ )
{
+ m_sumRowHeights -= m_rowHeights[ pos ];
m_rowHeights.Remove( pos );
m_rowBottoms.Remove( pos );
}
{
m_colWidths.Insert( m_defaultColWidth, pos );
m_colRights.Insert( 0, pos );
+ m_sumColWidths += m_defaultColWidth;
}
m_numCols += numCols;
CalcDimensions();
{
m_colWidths.Add( m_defaultColWidth );
m_colRights.Add( 0 );
+ m_sumColWidths += m_defaultColWidth;
}
m_numCols += numCols;
CalcDimensions();
int numCols = msg.GetCommandInt2();
for ( i = 0; i < numCols; i++ )
{
+ m_sumColWidths -= m_colWidths[ pos ];
m_colWidths.Remove( pos );
m_colRights.Remove( pos );
}
int row, int col,
wxMouseEvent& mouseEv )
{
- if ( type == EVT_WXGRID_ROW_SIZE ||
- type == EVT_WXGRID_COL_SIZE )
+ if ( type == EVT_GRID_ROW_SIZE ||
+ type == EVT_GRID_COL_SIZE )
{
int rowOrCol = (row == -1 ? col : row);
return GetEventHandler()->ProcessEvent(gridEvt);
}
- else if ( type == EVT_WXGRID_RANGE_SELECT )
+ else if ( type == EVT_GRID_RANGE_SELECT )
{
wxGridRangeSelectEvent gridEvt( GetId(),
type,
bool wxGrid::SendEvent( const wxEventType type,
int row, int col )
{
- if ( type == EVT_WXGRID_ROW_SIZE ||
- type == EVT_WXGRID_COL_SIZE )
+ if ( type == EVT_GRID_ROW_SIZE ||
+ type == EVT_GRID_COL_SIZE )
{
int rowOrCol = (row == -1 ? col : row);
}
-void wxGrid::OnPaint( wxPaintEvent& ev )
+void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(ev) )
{
wxPaintDC dc( this );
}
-void wxGrid::OnSize( wxSizeEvent& ev )
+void wxGrid::OnSize( wxSizeEvent& WXUNUSED(ev) )
{
- CalcDimensions();
+ if ( m_created ) CalcDimensions();
}
{
SelectBlock( cellCoords, cellCoords );
}
- else if ( !IsInSelection( cellCoords ) )
+ else
{
- SelectBlock( m_currentCellCoords, cellCoords );
+ // check for the mouse being outside the cell area
+ // (we still want to let the user grow the selected block)
+ //
+ if ( cellCoords.GetCol() == -1 )
+ {
+ if ( x >= m_right )
+ cellCoords.SetCol( m_numCols-1 );
+ else
+ cellCoords.SetCol( m_scrollPosX );
+ }
+
+ if ( cellCoords.GetRow() == -1 )
+ {
+ if ( y >= m_bottom )
+ cellCoords.SetRow( m_numRows-1 );
+ else
+ cellCoords.SetRow( m_scrollPosY );
+ }
+
+ if ( !IsInSelection( cellCoords ) )
+ SelectBlock( m_currentCellCoords, cellCoords );
}
}
}
if ( YToEdgeOfRow(y) < 0 )
{
row = YToRow(y);
- if ( !SendEvent( EVT_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
{
SelectRow( row, ev.ShiftDown() );
m_cursorMode = WXGRID_CURSOR_SELECT_ROW;
if ( XToEdgeOfCol(x) < 0 )
{
col = XToCol(x);
- if ( !SendEvent( EVT_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
{
SelectCol( col, ev.ShiftDown() );
m_cursorMode = WXGRID_CURSOR_SELECT_COL;
{
// leave both row and col as -1
//
- if ( !SendEvent( EVT_WXGRID_LABEL_LEFT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_LEFT_CLICK, row, col, ev ) )
{
SelectAll();
}
case WXGRID_CELL:
{
XYToCell( x, y, cellCoords );
- if ( !SendEvent( EVT_WXGRID_CELL_LEFT_CLICK,
+ if ( !SendEvent( EVT_GRID_CELL_LEFT_CLICK,
cellCoords.GetRow(),
cellCoords.GetCol(),
ev ) )
if ( YToEdgeOfRow(y) < 0 )
{
row = YToRow(y);
- SendEvent( EVT_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
}
}
break;
if ( XToEdgeOfCol(x) < 0 )
{
col = XToCol(x);
- SendEvent( EVT_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
}
}
break;
{
// leave both row and col as -1
//
- SendEvent( EVT_WXGRID_LABEL_LEFT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_LEFT_DCLICK, row, col, ev );
}
break;
case WXGRID_CELL:
{
XYToCell( x, y, cellCoords );
- SendEvent( EVT_WXGRID_CELL_LEFT_DCLICK,
+ SendEvent( EVT_GRID_CELL_LEFT_DCLICK,
cellCoords.GetRow(),
cellCoords.GetCol(),
ev );
int top = m_top + m_colLabelHeight;
if ( m_dragRowOrCol > 0 )
top = m_rowBottoms[m_dragRowOrCol-1];
+
+ m_sumRowHeights -= m_rowHeights[ m_dragRowOrCol ];
m_rowHeights[m_dragRowOrCol] = wxMax( ev.GetY() - top,
WXGRID_MIN_ROW_HEIGHT );
+ m_sumRowHeights += m_rowHeights[ m_dragRowOrCol ];
CalcDimensions();
ShowCellEditControl();
Refresh();
// Note: we are ending the event *after* doing
// default processing in this case
//
- SendEvent( EVT_WXGRID_ROW_SIZE, m_dragRowOrCol, -1, ev );
+ SendEvent( EVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, ev );
}
}
break;
int left = m_left + m_rowLabelWidth;
if ( m_dragRowOrCol > 0 )
left = m_colRights[m_dragRowOrCol-1];
+
+ m_sumColWidths -= m_colWidths[m_dragRowOrCol];
m_colWidths[m_dragRowOrCol] = wxMax( ev.GetX() - left,
WXGRID_MIN_COL_WIDTH );
+ m_sumColWidths += m_colWidths[m_dragRowOrCol];
+
CalcDimensions();
ShowCellEditControl();
Refresh();
// Note: we are ending the event *after* doing
// default processing in this case
//
- SendEvent( EVT_WXGRID_COL_SIZE, -1, m_dragRowOrCol, ev );
+ SendEvent( EVT_GRID_COL_SIZE, -1, m_dragRowOrCol, ev );
}
}
break;
// Note: we are ending the event *after* doing
// default processing in this case
//
- SendEvent( EVT_WXGRID_RANGE_SELECT, -1, -1, ev );
+ SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, ev );
}
}
break;
case WXGRID_ROWLABEL:
{
row = YToRow(y);
- if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
{
// TODO: default processing ?
}
case WXGRID_COLLABEL:
{
col = XToCol(x);
- if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
{
// TODO: default processing ?
}
{
// leave both row and col as -1
//
- if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
+ if ( !SendEvent( EVT_GRID_LABEL_RIGHT_CLICK, row, col, ev ) )
{
// TODO: default processing ?
}
case WXGRID_CELL:
{
XYToCell( x, y, cellCoords );
- if ( !SendEvent( EVT_WXGRID_CELL_RIGHT_CLICK,
+ if ( !SendEvent( EVT_GRID_CELL_RIGHT_CLICK,
cellCoords.GetRow(),
cellCoords.GetCol(),
ev ) )
case WXGRID_ROWLABEL:
{
row = YToRow(y);
- SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
}
break;
case WXGRID_COLLABEL:
{
col = XToCol(x);
- SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
}
break;
{
// leave both row and col as -1
//
- SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+ SendEvent( EVT_GRID_LABEL_RIGHT_DCLICK, row, col, ev );
}
break;
case WXGRID_CELL:
{
XYToCell( x, y, cellCoords );
- SendEvent( EVT_WXGRID_CELL_RIGHT_DCLICK,
+ SendEvent( EVT_GRID_CELL_RIGHT_DCLICK,
cellCoords.GetRow(),
cellCoords.GetCol(),
ev );
{
// shouldn't be here - we are going round in circles...
//
- wxLogFatalError( "wxGrid::OnKeyDown called while alread active" );
+ wxLogFatalError( wxT("wxGrid::OnKeyDown called while alread active") );
}
m_inOnKeyDown = TRUE;
}
break;
+ case WXK_PRIOR:
+ MovePageUp();
+ break;
+
+ case WXK_NEXT:
+ MovePageDown();
+ break;
+
default:
// now try the cell edit control
//
break;
}
}
- else if ( ctrl == m_topEditCtrl &&
- IsCellEditControlEnabled() )
+ else if ( ctrl == m_topEditCtrl )
{
- switch ( m_editCtrlType )
+ if ( IsCellEditControlEnabled() )
{
- case wxGRID_TEXTCTRL:
- ((wxTextCtrl *)m_cellEditCtrl)->
- SetValue(((wxTextCtrl *)ctrl)->GetValue());
- break;
-
- case wxGRID_COMBOBOX:
- ((wxComboBox *)m_cellEditCtrl)->
- SetValue(((wxComboBox *)ctrl)->GetValue());
- break;
+ switch ( m_editCtrlType )
+ {
+ case wxGRID_TEXTCTRL:
+ ((wxTextCtrl *)m_cellEditCtrl)->
+ SetValue(((wxTextCtrl *)ctrl)->GetValue());
+ break;
+
+ case wxGRID_COMBOBOX:
+ ((wxComboBox *)m_cellEditCtrl)->
+ SetValue(((wxComboBox *)ctrl)->GetValue());
+ break;
+ }
+ }
+ else
+ {
+ // in the case when in-place editing is turned off we just want to
+ // echo the text changes in the cell but not yet update the grid table
+ //
+ switch ( m_editCtrlType )
+ {
+ case wxGRID_TEXTCTRL:
+ DrawCellValue( m_currentCellCoords, ((wxTextCtrl *)ctrl)->GetValue() );
+ break;
+
+ case wxGRID_COMBOBOX:
+ DrawCellValue( m_currentCellCoords, ((wxComboBox *)ctrl)->GetValue() );
+ break;
+ }
}
}
}
void wxGrid::SelectCell( const wxGridCellCoords& coords )
{
+ if ( SendEvent( EVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
+ {
+ // the event has been intercepted - do nothing
+ return;
+ }
+
wxClientDC dc( this );
if ( m_currentCellCoords != wxGridNoCellCoords )
if ( m_table )
{
wxString s;
- s = ( value == wxEmptyString ? GetCellValue(m_currentCellCoords) : value );
+ if ( !value )
+ s = GetCellValue(m_currentCellCoords);
+ else
+ s = value;
if ( IsTopEditControlEnabled() )
{
if ( valueChanged )
{
- SendEvent( EVT_WXGRID_CELL_CHANGE,
+ SendEvent( EVT_GRID_CELL_CHANGE,
m_currentCellCoords.GetRow(),
m_currentCellCoords.GetCol() );
}
return FALSE;
}
+bool wxGrid::MovePageUp()
+{
+ if ( m_currentCellCoords != wxGridNoCellCoords &&
+ m_scrollPosY > 0 )
+ {
+ int row = m_currentCellCoords.GetRow();
+ int y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+ while ( row > 0 )
+ {
+ if ( y + m_rowHeights[row-1] > m_bottom ) break;
+ y += m_rowHeights[ --row ];
+ }
+ SetVerticalScrollPos( row );
+
+ SelectCell( row, m_currentCellCoords.GetCol() );
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+bool wxGrid::MovePageDown()
+{
+ if ( m_currentCellCoords != wxGridNoCellCoords &&
+ m_scrollPosY + m_wholeRowsVisible < m_numRows )
+ {
+ if ( m_wholeRowsVisible > 0 )
+ {
+ SetVerticalScrollPos( m_scrollPosY + m_wholeRowsVisible );
+ }
+ else if ( m_scrollPosY < m_numRows - 1 )
+ {
+ SetVerticalScrollPos( m_scrollPosY + 1 );
+ }
+ else
+ {
+ return FALSE;
+ }
+
+ // m_scrollPosY will have been updated
+ //
+ SelectCell( m_scrollPosY, m_currentCellCoords.GetCol() );
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
bool wxGrid::MoveCursorUpBlock()
{
if ( m_table &&
}
-void wxGrid::DrawCellValue( wxDC& dc, const wxRect& rect, int row, int col )
+// This draws a text value in the given cell. If useValueArg is FALSE
+// (the default) then the grid table value will be used
+//
+void wxGrid::DrawCellValue( wxDC& dc, const wxRect& rect, int row, int col,
+ const wxString& value, bool useValueArg )
{
wxRect rect2;
rect2 = rect;
int hAlign, vAlign;
GetCellAlignment( row, col, &hAlign, &vAlign );
- DrawTextRectangle( dc, GetCellValue( row, col ), rect2, hAlign, vAlign );
+
+ if ( useValueArg )
+ {
+ DrawTextRectangle( dc, value, rect2, hAlign, vAlign );
+ }
+ else
+ {
+ DrawTextRectangle( dc, GetCellValue( row, col ), rect2, hAlign, vAlign );
+ }
+}
+
+
+// this is used to echo text being entered into the top edit control when
+// in-place editing is turned off
+//
+void wxGrid::DrawCellValue( const wxGridCellCoords& coords, const wxString& value )
+{
+ if ( IsVisible( coords ) )
+ {
+ int row = coords.GetRow();
+ int col = coords.GetCol();
+ wxRect rect;
+ rect.x = m_colRights[ col ] - m_colWidths[ col ];
+ rect.y = m_rowBottoms[ row ] - m_rowHeights[ row ];
+ rect.width = m_colWidths[ col ];
+ rect.height = m_rowHeights[ row ];
+
+ wxClientDC dc( this );
+ DrawCellBackground( dc, rect, row, col );
+ DrawCellValue( dc, rect, row, col, value, TRUE );
+ }
}
y = m_rowBottoms[row] - m_rowHeights[row];
if ( y >= ch ) return;
- dc.SetLogicalFunction( wxXOR );
+ dc.SetLogicalFunction( wxINVERT );
dc.SetPen( wxPen(GetCellHighlightColour(), 2, wxSOLID) );
dc.SetBrush( *wxTRANSPARENT_BRUSH );
- dc.DrawRectangle( x, y,
- m_colWidths[col] + 2,
- m_rowHeights[row] + 2 );
+ dc.DrawRectangle( x-2, y-2,
+ m_colWidths[col] + 6,
+ m_rowHeights[row] + 6 );
dc.SetLogicalFunction( wxCOPY );
}
int horizAlign,
int vertAlign )
{
- int i;
long textWidth, textHeight;
long lineWidth, lineHeight;
wxArrayString lines;
break;
}
- for ( i = 0; i < lines.GetCount(); i++ )
+ for ( size_t i = 0; i < lines.GetCount(); i++ )
{
dc.DrawText( lines[i], (long)x, (long)y );
y += lineHeight;
void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
{
// TODO: this won't work for WXMAC ? (lines end with '\r')
- //
+ // => use wxTextFile functions then (VZ)
int startPos = 0;
int pos;
- while ( startPos < value.Length() )
+ while ( startPos < (int)value.Length() )
{
pos = value.Mid(startPos).Find( '\n' );
if ( pos < 0 )
}
startPos += pos+1;
}
- if ( startPos < value.Length() )
+ if ( startPos < (int)value.Length() )
{
lines.Add( value.Mid( startPos ) );
}
long h = 0;
long lineW, lineH;
- int i;
+ size_t i;
for ( i = 0; i < lines.GetCount(); i++ )
{
dc.GetTextExtent( lines[i], &lineW, &lineH );
{
if ( m_created )
{
- wxLogError( "wxGrid::CreateGrid(numRows, numCols) called more than once" );
+ wxLogError( wxT("wxGrid::CreateGrid(numRows, numCols) called more than once") );
return FALSE;
}
else
if ( !m_created )
{
- wxLogError( "Called wxGrid::InsertRows() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
return FALSE;
}
//
if ( ok )
{
+ if ( m_numCols == 0 )
+ {
+ m_table->AppendCols( WXGRID_DEFAULT_NUMBER_COLS );
+ //
+ // TODO: perhaps instead of appending the default number of cols
+ // we should remember what the last non-zero number of cols was ?
+ //
+ }
+
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ {
+ // if we have just inserted cols into an empty grid the current
+ // cell will be undefined...
+ //
+ SelectCell( 0, 0 );
+ }
+
if ( !GetBatchCount() ) Refresh();
}
+
SetEditControlValue();
return ok;
}
if ( !m_created )
{
- wxLogError( "Called wxGrid::AppendRows() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
return FALSE;
}
if ( m_table && m_table->AppendRows( numRows ) )
{
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ {
+ // if we have just inserted cols into an empty grid the current
+ // cell will be undefined...
+ //
+ SelectCell( 0, 0 );
+ }
+
// the table will have sent the results of the append row
// operation to this view object as a grid table message
//
if ( !m_created )
{
- wxLogError( "Called wxGrid::DeleteRows() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
return FALSE;
}
if ( !m_created )
{
- wxLogError( "Called wxGrid::InsertCols() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
return FALSE;
}
{
HideCellEditControl();
bool ok = m_table->InsertCols( pos, numCols );
+
+ // the table will have sent the results of the insert col
+ // operation to this view object as a grid table message
+ //
if ( ok )
{
- // the table will have sent the results of the insert col
- // operation to this view object as a grid table message
- //
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ {
+ // if we have just inserted cols into an empty grid the current
+ // cell will be undefined...
+ //
+ SelectCell( 0, 0 );
+ }
+
if ( !GetBatchCount() ) Refresh();
}
+
SetEditControlValue();
return ok;
}
if ( !m_created )
{
- wxLogError( "Called wxGrid::AppendCols() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
return FALSE;
}
// the table will have sent the results of the append col
// operation to this view object as a grid table message
//
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ {
+ // if we have just inserted cols into an empty grid the current
+ // cell will be undefined...
+ //
+ SelectCell( 0, 0 );
+ }
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
if ( !m_created )
{
- wxLogError( "Called wxGrid::DeleteCols() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
return FALSE;
}
if ( m_cellEditCtrl &&
enable != m_cellEditCtrlEnabled )
{
+ wxClientDC dc( this );
+
+ HideCurrentCellHighlight( dc );
HideCellEditControl();
SaveEditControlValue();
SetEditControlValue();
ShowCellEditControl();
+ ShowCurrentCellHighlight( dc );
}
}
return wxColour( 255, 255, 255 );
}
-wxColour wxGrid::GetCellBackgroundColour( int row, int col )
+wxColour wxGrid::GetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col) )
{
// TODO: replace this temp test code
//
return wxColour( 0, 0, 0 );
}
-wxColour wxGrid::GetCellTextColour( int row, int col )
+wxColour wxGrid::GetCellTextColour( int WXUNUSED(row), int WXUNUSED(col) )
{
// TODO: replace this temp test code
//
return m_defaultCellFont;
}
-wxFont wxGrid::GetCellFont( int row, int col )
+wxFont wxGrid::GetCellFont( int WXUNUSED(row), int WXUNUSED(col) )
{
// TODO: replace this temp test code
//
*vert = wxTOP;
}
-void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
+void wxGrid::GetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int *horiz, int *vert )
{
// TODO: replace this temp test code
//
{
m_rowHeights[row] = m_defaultRowHeight;
}
+ m_sumRowHeights = m_defaultRowHeight * m_numRows;
CalcDimensions();
if ( !GetBatchCount() ) Refresh();
}
{
if ( row >= 0 && row < m_numRows )
{
+ m_sumRowHeights -= m_rowHeights[row];
m_rowHeights[row] = wxMax( 0, height );
+ m_sumRowHeights += m_rowHeights[row];
CalcDimensions();
if ( !GetBatchCount() ) Refresh();
// Note: we are ending the event *after* doing
// default processing in this case
//
- SendEvent( EVT_WXGRID_ROW_SIZE,
+ SendEvent( EVT_GRID_ROW_SIZE,
row, -1 );
}
else
{
m_colWidths[col] = m_defaultColWidth;
}
+ m_sumColWidths = m_defaultColWidth * m_numCols;
CalcDimensions();
if ( !GetBatchCount() ) Refresh();
}
{
if ( col >= 0 && col < m_numCols )
{
+ m_sumColWidths -= m_colWidths[col];
m_colWidths[col] = wxMax( 0, width );
+ m_sumColWidths += m_colWidths[col];
CalcDimensions();
if ( !GetBatchCount() ) Refresh();
// Note: we are ending the event *after* doing
// default processing in this case
//
- SendEvent( EVT_WXGRID_COL_SIZE,
+ SendEvent( EVT_GRID_COL_SIZE,
-1, col );
}
else
//
}
-void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& )
+void wxGrid::SetCellBackgroundColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
{
// TODO: everything !!!
//
//
}
-void wxGrid::SetCellTextColour( int row, int col, const wxColour& )
+void wxGrid::SetCellTextColour( int WXUNUSED(row), int WXUNUSED(col), const wxColour& )
{
// TODO: everything !!!
//
//
}
-void wxGrid::SetCellFont( int row, int col, const wxFont& )
+void wxGrid::SetCellFont( int WXUNUSED(row), int WXUNUSED(col), const wxFont& )
{
// TODO: everything !!!
//
}
-void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
+void wxGrid::SetDefaultCellAlignment( int WXUNUSED(horiz), int WXUNUSED(vert) )
{
// TODO: everything !!!
//
}
-void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
+void wxGrid::SetCellAlignment( int WXUNUSED(row), int WXUNUSED(col), int WXUNUSED(horiz), int WXUNUSED(vert) )
{
// TODO: everything !!!
//
}
wxGridRangeSelectEvent gridEvt( GetId(),
- EVT_WXGRID_RANGE_SELECT,
+ EVT_GRID_RANGE_SELECT,
this,
m_selectedTopLeft,
m_selectedBottomRight );
}
wxGridRangeSelectEvent gridEvt( GetId(),
- EVT_WXGRID_RANGE_SELECT,
+ EVT_GRID_RANGE_SELECT,
this,
m_selectedTopLeft,
m_selectedBottomRight );
if ( !m_isDragging )
{
wxGridRangeSelectEvent gridEvt( GetId(),
- EVT_WXGRID_RANGE_SELECT,
+ EVT_GRID_RANGE_SELECT,
this,
m_selectedTopLeft,
m_selectedBottomRight );
projects / wxWidgets.git / blobdiff