-////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
// Name: grid.cpp
// Purpose: wxGrid and related classes
// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-// For compilers that support precompilation, includes "wx/wx.h".
-#include "wx/wxprec.h"
-
-#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>
+#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(wxGridStringArray);
+WX_DEFINE_OBJARRAY(wxGridStringArray)
IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
: wxGridTableBase()
{
int row, col;
-
+
m_data.Alloc( numRows );
wxArrayString sa;
{
sa.Add( wxEmptyString );
}
-
+
for ( row = 0; row < numRows; row++ )
{
m_data.Add( sa );
{
int row, col;
int numRows, numCols;
-
+
numRows = m_data.GetCount();
if ( numRows > 0 )
{
size_t curNumRows = m_data.GetCount();
size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
-
+
if ( pos >= curNumRows )
{
return AppendRows( numRows );
}
-
+
wxArrayString sa;
sa.Alloc( curNumCols );
for ( col = 0; col < curNumCols; col++ )
wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
pos,
numRows );
-
+
GetView()->ProcessTableMessage( msg );
}
size_t curNumRows = m_data.GetCount();
size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
-
+
wxArrayString sa;
if ( curNumCols > 0 )
{
sa.Add( wxEmptyString );
}
}
-
+
for ( row = 0; row < numRows; row++ )
{
m_data.Add( sa );
wxGridTableMessage msg( this,
wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
numRows );
-
+
GetView()->ProcessTableMessage( msg );
}
- return TRUE;
+ return TRUE;
}
bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
size_t n;
size_t curNumRows = m_data.GetCount();
-
+
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;
}
{
numRows = curNumRows - pos;
}
-
+
if ( numRows >= curNumRows )
{
m_data.Empty(); // don't release memory just yet
wxGRIDTABLE_NOTIFY_ROWS_DELETED,
pos,
numRows );
-
+
GetView()->ProcessTableMessage( msg );
}
- return TRUE;
+ return TRUE;
}
bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
size_t curNumRows = m_data.GetCount();
size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
-
+
if ( pos >= curNumCols )
{
return AppendCols( numCols );
wxGRIDTABLE_NOTIFY_COLS_INSERTED,
pos,
numCols );
-
+
GetView()->ProcessTableMessage( msg );
}
{
// 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;
}
-
+
for ( row = 0; row < curNumRows; row++ )
{
for ( n = 0; n < numCols; n++ )
wxGridTableMessage msg( this,
wxGRIDTABLE_NOTIFY_COLS_APPENDED,
numCols );
-
+
GetView()->ProcessTableMessage( msg );
}
size_t curNumRows = m_data.GetCount();
size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() : 0 );
-
+
if ( pos >= curNumCols )
{
- wxLogError( "Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\n"
- "Pos value is invalid for present table with %d cols",
- pos, numCols, curNumCols );
- return FALSE;
+ 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;
}
if ( numCols > curNumCols - pos )
{
- numCols = curNumCols - pos;
+ numCols = curNumCols - pos;
}
for ( row = 0; row < curNumRows; row++ )
wxGRIDTABLE_NOTIFY_COLS_DELETED,
pos,
numCols );
-
+
GetView()->ProcessTableMessage( msg );
}
- return TRUE;
+ return TRUE;
}
wxString wxGridStringTable::GetRowLabelValue( int row )
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC_CLASS( wxGridTextCtrl, wxTextCtrl )
-
+
BEGIN_EVENT_TABLE( wxGridTextCtrl, wxTextCtrl )
EVT_KEY_DOWN( wxGridTextCtrl::OnKeyDown )
END_EVENT_TABLE()
case WXK_DOWN:
case WXK_LEFT:
case WXK_RIGHT:
+ case WXK_PRIOR:
+ case WXK_NEXT:
case WXK_RETURN:
if ( m_isCellControl )
{
ev.Skip();
}
break;
-
+
default:
ev.Skip();
}
IMPLEMENT_DYNAMIC_CLASS( wxGrid, wxPanel )
-
+
BEGIN_EVENT_TABLE( wxGrid, wxPanel )
EVT_PAINT( wxGrid::OnPaint )
EVT_SIZE( wxGrid::OnSize )
EVT_COMMAND_SCROLL( wxGRID_HORIZSCROLL, wxGrid::OnGridScroll)
EVT_COMMAND_SCROLL( wxGRID_VERTSCROLL, wxGrid::OnGridScroll)
END_EVENT_TABLE()
-
+
wxGrid::~wxGrid()
{
//
m_topEditCtrlEnabled = FALSE;
m_topEditCtrl = new wxGridTextCtrl( this,
- FALSE,
- wxGRID_TOPCTRL,
- "",
- wxPoint(10, 10),
- wxSize(WXGRID_DEFAULT_TOPEDIT_WIDTH,
+ FALSE,
+ wxGRID_TOPCTRL,
+ "",
+ wxPoint(10, 10),
+ wxSize(WXGRID_DEFAULT_TOPEDIT_WIDTH,
WXGRID_DEFAULT_TOPEDIT_HEIGHT),
- wxTE_MULTILINE );
- m_topEditCtrl->Show( FALSE );
+ wxTE_MULTILINE );
+ m_topEditCtrl->Show( FALSE );
if ( m_numRows <= 0 )
m_numRows = WXGRID_DEFAULT_NUMBER_ROWS;
//
m_labelFont = this->GetFont();
m_labelFont.SetWeight( m_labelFont.GetWeight() + 2 );
-
+
m_rowLabelHorizAlign = wxLEFT;
m_rowLabelVertAlign = wxCENTRE;
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();
-
+
m_gridLineColour = wxColour( 0, 0, 255 );
m_gridLinesEnabled = TRUE;
-
+
m_scrollBarWidth = WXGRID_DEFAULT_SCROLLBAR_WIDTH;
m_horizScrollBar = new wxScrollBar( this,
wxPoint(0, 0),
wxSize(10, 10),
wxHORIZONTAL);
-
+
m_vertScrollBar = new wxScrollBar( this,
wxGRID_VERTSCROLL,
wxPoint(0, 0),
m_scrollPosX = 0;
m_scrollPosY = 0;
m_wholeColsVisible = 0;
- m_wholeRowsVisible = 0;
+ m_wholeRowsVisible = 0;
m_firstPaint = TRUE;
m_inOnKeyDown = FALSE;
m_batchCount = 0;
-
+
m_cursorMode = WXGRID_CURSOR_DEFAULT;
m_dragLastPos = -1;
m_dragRowOrCol = -1;
m_selectedTopLeft = wxGridNoCellCoords;
m_selectedBottomRight = wxGridNoCellCoords;
-
+
m_editable = TRUE; // default for whole grid
// TODO: extend this to other types of controls
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_cellEditCtrl->Show( FALSE );
+
+ m_cellEditCtrl->Show( FALSE );
m_cellEditCtrlEnabled = TRUE;
- m_editCtrlType = wxGRID_TEXTCTRL;
-
- // Not really needed here, it gets called by OnSize()
+ m_editCtrlType = wxGRID_TEXTCTRL;
+
+ // This is here in case OnSize does not get called when the grid is
+ // displayed
//
- // CalcDimensions();
+ CalcDimensions();
}
{
int ctrlW, ctrlH;
m_topEditCtrl->GetSize( &ctrlW, &ctrlH );
-
+
m_top = ctrlH + 20;
}
else
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 )
{
if ( !vertScrollBarWidth )
wxMax(m_wholeRowsVisible, 1),
(m_wholeRowsVisible == 0 ? 1 : m_numRows),
wxMax(m_wholeRowsVisible, 1) );
-
+
m_vertScrollBar->SetSize( cw - m_scrollBarWidth,
m_top,
m_scrollBarWidth,
ch - m_top - horizScrollBarHeight);
}
}
-
+
if ( m_horizScrollBar )
{
if ( !horizScrollBarHeight )
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 );
}
bool wxGrid::Redimension( wxGridTableMessage& msg )
{
int i;
-
+
switch ( msg.GetId() )
{
case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
{
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 );
}
m_numRows = 0;
m_rowHeights.Clear();
m_rowBottoms.Clear();
-#endif
+#endif
m_currentCellCoords = wxGridNoCellCoords;
}
else if ( m_currentCellCoords.GetCol() >= m_numCols )
// ----- event handlers
//
-// Generate a grid event based on a mouse event and
+// Generate a grid event based on a mouse event and
// return the result of ProcessEvent()
//
bool wxGrid::SendEvent( const wxEventType type,
- int row, int col,
- wxMouseEvent& mouseEv )
+ 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);
+ int rowOrCol = (row == -1 ? col : row);
- wxGridSizeEvent gridEvt( GetId(),
- type,
- this,
- rowOrCol,
- mouseEv.GetX(), mouseEv.GetY(),
- mouseEv.ControlDown(),
- mouseEv.ShiftDown(),
- mouseEv.AltDown(),
- mouseEv.MetaDown() );
+ wxGridSizeEvent gridEvt( GetId(),
+ type,
+ this,
+ rowOrCol,
+ mouseEv.GetX(), mouseEv.GetY(),
+ mouseEv.ControlDown(),
+ mouseEv.ShiftDown(),
+ mouseEv.AltDown(),
+ mouseEv.MetaDown() );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ return GetEventHandler()->ProcessEvent(gridEvt);
}
- else if ( type == EVT_WXGRID_RANGE_SELECT )
+ else if ( type == EVT_GRID_RANGE_SELECT )
{
- wxGridRangeSelectEvent gridEvt( GetId(),
- type,
- this,
- m_selectedTopLeft,
- m_selectedBottomRight,
- mouseEv.ControlDown(),
- mouseEv.ShiftDown(),
- mouseEv.AltDown(),
- mouseEv.MetaDown() );
+ wxGridRangeSelectEvent gridEvt( GetId(),
+ type,
+ this,
+ m_selectedTopLeft,
+ m_selectedBottomRight,
+ mouseEv.ControlDown(),
+ mouseEv.ShiftDown(),
+ mouseEv.AltDown(),
+ mouseEv.MetaDown() );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ return GetEventHandler()->ProcessEvent(gridEvt);
}
else
{
- wxGridEvent gridEvt( GetId(),
- type,
- this,
- row, col,
- mouseEv.GetX(), mouseEv.GetY(),
- mouseEv.ControlDown(),
- mouseEv.ShiftDown(),
- mouseEv.AltDown(),
- mouseEv.MetaDown() );
+ wxGridEvent gridEvt( GetId(),
+ type,
+ this,
+ row, col,
+ mouseEv.GetX(), mouseEv.GetY(),
+ mouseEv.ControlDown(),
+ mouseEv.ShiftDown(),
+ mouseEv.AltDown(),
+ mouseEv.MetaDown() );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ return GetEventHandler()->ProcessEvent(gridEvt);
}
}
// of ProcessEvent().
//
bool wxGrid::SendEvent( const wxEventType type,
- int row, int col )
+ 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);
+ int rowOrCol = (row == -1 ? col : row);
- wxGridSizeEvent gridEvt( GetId(),
- type,
- this,
- rowOrCol );
+ wxGridSizeEvent gridEvt( GetId(),
+ type,
+ this,
+ rowOrCol );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ return GetEventHandler()->ProcessEvent(gridEvt);
}
else
{
- wxGridEvent gridEvt( GetId(),
- type,
- this,
- row, col );
+ wxGridEvent gridEvt( GetId(),
+ type,
+ this,
+ row, col );
- return GetEventHandler()->ProcessEvent(gridEvt);
+ return GetEventHandler()->ProcessEvent(gridEvt);
}
}
-void wxGrid::OnPaint( wxPaintEvent& ev )
+void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(ev) )
{
wxPaintDC dc( this );
int cw, ch;
GetClientSize( &cw, &ch );
dc.SetClippingRegion( 0, 0, cw - vs, ch - hs );
-
+
HideCurrentCellHighlight( dc );
-
+
DrawLabelAreas( dc );
DrawColLabels( dc );
DrawRowLabels( dc );
{
if ( m_currentCellCoords == wxGridNoCellCoords )
m_currentCellCoords.Set(0, 0);
-
+
SetEditControlValue();
ShowCellEditControl();
m_firstPaint = FALSE;
}
-void wxGrid::OnSize( wxSizeEvent& ev )
+void wxGrid::OnSize( wxSizeEvent& WXUNUSED(ev) )
{
- CalcDimensions();
+ if ( m_created ) CalcDimensions();
}
int x = ev.GetX();
int y = ev.GetY();
int row, col;
-
+
// ------------------------------------------------------------
//
// Mouse dragging
if ( ev.Dragging() )
{
m_isDragging = TRUE;
-
+
if ( ev.LeftIsDown() )
{
switch( m_cursorMode )
{
if ( !IsSelection() )
{
- SelectBlock( cellCoords, cellCoords );
- }
- else if ( !IsInSelection( cellCoords ) )
- {
- SelectBlock( m_currentCellCoords, cellCoords );
- }
+ SelectBlock( cellCoords, cellCoords );
+ }
+ else
+ {
+ // 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 );
+ }
}
}
break;
}
dc.DrawLine( m_left, ev.GetY(),
m_right, ev.GetY());
-
+
m_dragLastPos = ev.GetY();
}
break;
-
+
case WXGRID_CURSOR_RESIZE_COL:
{
wxClientDC dc(this);
}
dc.DrawLine( ev.GetX(), m_top,
ev.GetX(), m_bottom );
-
+
m_dragLastPos = ev.GetX();
}
break;
}
m_isDragging = FALSE;
-
+
// ------------------------------------------------------------
//
// Left mouse button down
row = -1;
col = -1;
wxGridCellCoords cellCoords;
-
+
switch( XYToArea( x, y ) )
{
case WXGRID_ROWLABEL:
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 ) )
break;
default:
-#if 0
+#if 0
wxLogMessage( "outside grid area" );
-#endif
+#endif
break;
}
}
row = -1;
col = -1;
wxGridCellCoords cellCoords;
-
+
switch( XYToArea( x, y ) )
{
case WXGRID_ROWLABEL:
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 );
break;
default:
-#if 0
+#if 0
wxLogMessage( "outside grid area" );
-#endif
+#endif
break;
}
}
//
else if ( ev.LeftUp() )
{
- switch ( m_cursorMode )
- {
- case WXGRID_CURSOR_RESIZE_ROW:
- {
- if ( m_dragLastPos >= 0 )
- {
- // erase the last line and resize the row
- //
- wxClientDC dc( this );
- dc.SetLogicalFunction( wxINVERT );
- dc.DrawLine( m_left, m_dragLastPos,
- m_right, m_dragLastPos );
- HideCellEditControl();
- int top = m_top + m_colLabelHeight;
- if ( m_dragRowOrCol > 0 )
- top = m_rowBottoms[m_dragRowOrCol-1];
- m_rowHeights[m_dragRowOrCol] = wxMax( ev.GetY() - top,
- WXGRID_MIN_ROW_HEIGHT );
- 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 );
- }
- }
- break;
-
- case WXGRID_CURSOR_RESIZE_COL:
- {
- if ( m_dragLastPos >= 0 )
- {
- // erase the last line and resize the col
- //
- wxClientDC dc( this );
- dc.SetLogicalFunction( wxINVERT );
- dc.DrawLine( m_left, m_dragLastPos,
- m_right, m_dragLastPos );
- HideCellEditControl();
- int left = m_left + m_rowLabelWidth;
- if ( m_dragRowOrCol > 0 )
- left = m_colRights[m_dragRowOrCol-1];
- m_colWidths[m_dragRowOrCol] = wxMax( ev.GetX() - left,
- WXGRID_MIN_COL_WIDTH );
- 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 );
- }
- }
- break;
-
- case WXGRID_CURSOR_SELECT_CELL:
- {
- if ( IsSelection() )
- {
- // Note: we are ending the event *after* doing
- // default processing in this case
- //
- SendEvent( EVT_WXGRID_RANGE_SELECT, -1, -1, ev );
- }
- }
- break;
- }
-
- m_dragLastPos = -1;
+ switch ( m_cursorMode )
+ {
+ case WXGRID_CURSOR_RESIZE_ROW:
+ {
+ if ( m_dragLastPos >= 0 )
+ {
+ // erase the last line and resize the row
+ //
+ wxClientDC dc( this );
+ dc.SetLogicalFunction( wxINVERT );
+ dc.DrawLine( m_left, m_dragLastPos,
+ m_right, m_dragLastPos );
+ HideCellEditControl();
+ 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_GRID_ROW_SIZE, m_dragRowOrCol, -1, ev );
+ }
+ }
+ break;
+
+ case WXGRID_CURSOR_RESIZE_COL:
+ {
+ if ( m_dragLastPos >= 0 )
+ {
+ // erase the last line and resize the col
+ //
+ wxClientDC dc( this );
+ dc.SetLogicalFunction( wxINVERT );
+ dc.DrawLine( m_left, m_dragLastPos,
+ m_right, m_dragLastPos );
+ HideCellEditControl();
+ 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_GRID_COL_SIZE, -1, m_dragRowOrCol, ev );
+ }
+ }
+ break;
+
+ case WXGRID_CURSOR_SELECT_CELL:
+ {
+ if ( IsSelection() )
+ {
+ // Note: we are ending the event *after* doing
+ // default processing in this case
+ //
+ SendEvent( EVT_GRID_RANGE_SELECT, -1, -1, ev );
+ }
+ }
+ break;
+ }
+
+ m_dragLastPos = -1;
}
// ------------------------------------------------------------
//
//
else if ( ev.RightDown() )
{
- row = -1;
- col = -1;
- wxGridCellCoords cellCoords;
-
- switch( XYToArea( x, y ) )
- {
-
- case WXGRID_ROWLABEL:
- {
- row = YToRow(y);
- if ( !SendEvent( EVT_WXGRID_LABEL_RIGHT_CLICK, row, col, ev ) )
- {
+ row = -1;
+ col = -1;
+ wxGridCellCoords cellCoords;
+
+ switch( XYToArea( x, y ) )
+ {
+
+ case WXGRID_ROWLABEL:
+ {
+ row = YToRow(y);
+ 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 ) )
break;
default:
-#if 0
+#if 0
wxLogMessage( "outside grid area" );
-#endif
+#endif
break;
}
}
//
else if ( ev.RightDClick() )
{
- row = -1;
- col = -1;
- wxGridCellCoords cellCoords;
-
- switch( XYToArea( x, y ) )
- {
-
- case WXGRID_ROWLABEL:
- {
- row = YToRow(y);
- SendEvent( EVT_WXGRID_LABEL_RIGHT_DCLICK, row, col, ev );
+ row = -1;
+ col = -1;
+ wxGridCellCoords cellCoords;
+
+ switch( XYToArea( x, y ) )
+ {
+
+ case WXGRID_ROWLABEL:
+ {
+ row = YToRow(y);
+ 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 );
break;
default:
-#if 0
+#if 0
wxLogMessage( "outside grid area" );
-#endif
+#endif
break;
}
}
}
}
break;
- }
+ }
}
}
{
// 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;
-
+
// propagate the event up and see if it gets processed
//
wxWindow *parent = GetParent();
wxKeyEvent keyEvt( ev );
keyEvt.SetEventObject( parent );
-
+
if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
{
// try local handlers
MoveCursorUp();
}
break;
-
+
case WXK_DOWN:
if ( ev.ControlDown() )
{
ev.Skip();
}
break;
-
+
case WXK_END:
if ( ev.ControlDown() )
{
ev.Skip();
}
break;
-
+
+ case WXK_PRIOR:
+ MovePageUp();
+ break;
+
+ case WXK_NEXT:
+ MovePageDown();
+ break;
+
default:
// now try the cell edit control
//
// Text updated in an edit control - either a text control or a
// combo box
//
-void wxGrid::OnText( wxKeyEvent& ev )
+void wxGrid::OnText( wxCommandEvent& ev )
{
if ( !m_inOnText )
{
((wxTextCtrl *)m_topEditCtrl)->
SetValue(((wxTextCtrl *)ctrl)->GetValue());
break;
-
+
case wxGRID_COMBOBOX:
((wxComboBox *)m_topEditCtrl)->
SetValue(((wxComboBox *)ctrl)->GetValue());
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;
+ }
}
}
}
wxWindow *parent = GetParent();
wxScrollEvent scrollEvt( ev );
if (parent->GetEventHandler()->ProcessEvent( scrollEvt )) return;
-
+
HideCellEditControl();
if ( ev.GetEventObject() == m_horizScrollBar )
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 )
void wxGrid::ShowCellEditControl()
{
wxRect rect;
-
- if ( IsCellEditControlEnabled() )
+
+ if ( IsCellEditControlEnabled() )
{
if ( !IsVisible( m_currentCellCoords ) )
{
else
{
rect = CellToRect( m_currentCellCoords );
-
+
m_cellEditCtrl->SetSize( rect );
m_cellEditCtrl->Show( TRUE );
// TODO: anything ???
//
break;
-
+
case wxGRID_COMBOBOX:
// TODO: anything ???
//
if ( m_table )
{
wxString s;
- s = ( value == wxEmptyString ? GetCellValue(m_currentCellCoords) : value );
+ if ( !value )
+ s = GetCellValue(m_currentCellCoords);
+ else
+ s = value;
if ( IsTopEditControlEnabled() )
{
// TODO: implement this
//
break;
-
+
case wxGRID_COMBOBOX:
// TODO: implement this
//
// TODO: implement this
//
break;
-
+
case wxGRID_COMBOBOX:
// TODO: implement this
//
{
if ( m_table )
{
- wxWindow *ctrl = (wxWindow *)NULL;
+ wxWindow *ctrl = (wxWindow *)NULL;
if ( IsCellEditControlEnabled() )
{
{
return;
}
-
+
bool valueChanged = FALSE;
-
+
switch ( m_editCtrlType )
{
case wxGRID_TEXTCTRL:
// TODO: implement this
//
break;
-
+
case wxGRID_COMBOBOX:
// TODO: implement this
//
break;
}
-
+
if ( valueChanged )
{
- SendEvent( EVT_WXGRID_CELL_CHANGE,
+ SendEvent( EVT_GRID_CELL_CHANGE,
m_currentCellCoords.GetRow(),
m_currentCellCoords.GetCol() );
}
int wxGrid::YToRow( int y )
{
int i;
-
+
if ( y > m_top + m_colLabelHeight )
{
for ( i = m_scrollPosY; i < m_numRows; i++ )
int wxGrid::XToCol( int x )
{
int i;
-
+
if ( x > m_left + m_rowLabelWidth )
{
for ( i = m_scrollPosX; i < m_numCols; i++ )
int wxGrid::YToEdgeOfRow( int y )
{
int i, d;
-
+
if ( y > m_top + m_colLabelHeight )
{
for ( i = m_scrollPosY; i < m_numRows; i++ )
}
return -1;
-
+
}
int wxGrid::XToEdgeOfCol( int x )
{
int i, d;
-
+
if ( x > m_left + m_rowLabelWidth )
{
for ( i = m_scrollPosX; i < m_numCols; i++ )
}
return -1;
-
+
}
}
return rect;
-}
+}
bool wxGrid::MoveCursorUp()
if ( !IsVisible( m_currentCellCoords ) )
MakeCellVisible( m_currentCellCoords );
-
+
return TRUE;
}
if ( !IsVisible( m_currentCellCoords ) )
MakeCellVisible( m_currentCellCoords );
-
+
return TRUE;
}
if ( !IsVisible( m_currentCellCoords ) )
MakeCellVisible( m_currentCellCoords );
-
+
+ return TRUE;
+ }
+
+ 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;
}
{
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
-
+
if ( m_table->IsEmptyCell(row, col) )
{
// starting in an empty cell: find the next block of
}
}
}
-
+
SelectCell( row, col );
if ( !IsVisible( m_currentCellCoords ) )
{
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
-
+
if ( m_table->IsEmptyCell(row, col) )
{
// starting in an empty cell: find the next block of
}
}
}
-
+
SelectCell( row, col );
if ( !IsVisible( m_currentCellCoords ) )
{
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
-
+
if ( m_table->IsEmptyCell(row, col) )
{
// starting in an empty cell: find the next block of
}
}
}
-
+
SelectCell( row, col );
if ( !IsVisible( m_currentCellCoords ) )
{
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
-
+
if ( m_table->IsEmptyCell(row, col) )
{
// starting in an empty cell: find the next block of
}
}
}
-
+
SelectCell( row, col );
if ( !IsVisible( m_currentCellCoords ) )
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush( wxBrush(GetLabelBackgroundColour(), wxSOLID) );
-
+
dc.DrawRectangle( m_left, m_top,
cw - m_left, m_colLabelHeight );
-
+
dc.DrawRectangle( m_left, m_top,
m_rowLabelWidth, ch - m_top );
}
int labelLeft = m_left + m_rowLabelWidth;
int i;
-
+
for ( i = m_scrollPosX; i < m_numCols; i++ )
{
if ( labelLeft > cw) break;
rect.x = 1 + labelLeft;
rect.width = m_colWidths[i];
DrawColLabel( dc, rect, i );
-
+
labelLeft += m_colWidths[i];
}
}
GetClientSize( &cw, &ch );
dc.SetPen( *wxBLACK_PEN );
-
+
// horizontal lines
//
dc.DrawLine( m_left, m_top, cw, m_top );
dc.DrawLine(colLeft + 1, m_top + 1,
colLeft + 1, m_top + m_colLabelHeight);
-
+
colLeft += m_colWidths[i];
}
}
rect2.y += 2;
rect2.width -= 5;
rect2.height -= 4;
-
+
dc.SetBackgroundMode( wxTRANSPARENT );
dc.SetTextBackground( GetLabelBackgroundColour() );
dc.SetTextForeground( GetLabelTextColour() );
dc.SetFont( GetLabelFont() );
-
+
int hAlign, vAlign;
GetColLabelAlignment( &hAlign, &vAlign );
DrawTextRectangle( dc, GetColLabelValue( col ), rect2, hAlign, vAlign );
int labelTop = m_top + m_colLabelHeight;
int i;
-
+
for ( i = m_scrollPosY; i < m_numRows; i++ )
{
if ( labelTop > ch ) break;
rect.y = 1 + labelTop;
rect.height = m_rowHeights[i];
DrawRowLabel( dc, rect, i );
-
+
labelTop += m_rowHeights[i];
}
}
GetClientSize( &cw, &ch );
dc.SetPen( *wxBLACK_PEN );
-
+
// vertical lines
//
dc.DrawLine( m_left, m_top, m_left, ch );
dc.DrawLine( m_left + 1, rowTop + 1,
m_left + 1, rowTop + m_rowHeights[i] );
-
+
rowTop += m_rowHeights[i];
}
}
rect2.y += 2;
rect2.width -= 5;
rect2.height -= 4;
-
+
dc.SetBackgroundMode( wxTRANSPARENT );
dc.SetTextBackground( GetLabelBackgroundColour() );
dc.SetTextForeground( GetLabelTextColour() );
dc.SetFont( GetLabelFont() );
-
+
int hAlign, vAlign;
GetRowLabelAlignment( &hAlign, &vAlign );
DrawTextRectangle( dc, GetRowLabelValue( row ), rect2, hAlign, vAlign );
void wxGrid::DrawGridLines( wxDC& dc )
{
if ( !m_gridLinesEnabled || !m_numRows || !m_numCols ) return;
-
+
int i;
int cw, ch;
GetClientSize(&cw, &ch);
void wxGrid::DrawCells( wxDC& dc )
{
if ( !m_numRows || !m_numCols ) return;
-
+
int row, col;
-
+
int cw, ch;
GetClientSize( &cw, &ch );
-
+
wxRect rect;
if ( m_table )
rect2.y += 1;
rect2.width -= 2;
rect2.height -= 2;
-
+
dc.SetBackgroundMode( wxSOLID );
-
+
if ( IsInSelection( row, col ) )
{
// TODO: improve this
}
-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;
rect2.y += 2;
rect2.width -= 5;
rect2.height -= 4;
-
+
dc.SetBackgroundMode( wxTRANSPARENT );
if ( IsInSelection( row, col ) )
dc.SetTextForeground( GetCellTextColour(row, col) );
}
dc.SetFont( GetCellFont(row, col) );
-
+
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 );
+ }
}
int cw, ch;
GetClientSize( &cw, &ch );
-
+
x = m_colRights[col] - m_colWidths[col];
if ( x >= cw ) return;
-
+
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 );
}
if ( !GetBatchCount() )
{
if ( !IsVisible( wxGridCellCoords(row, col) ) ) return;
-
+
int cw, ch;
GetClientSize( &cw, &ch );
-
+
wxRect rect( CellToRect( row, col ) );
if ( m_table )
long textWidth, textHeight;
long lineWidth, lineHeight;
wxArrayString lines;
-
+
// see if we are already clipping
//
wxRect clipRect;
{
GetTextBoxSize( dc, lines, &textWidth, &textHeight );
dc.GetTextExtent( lines[0], &lineWidth, &lineHeight );
-
+
float x, y;
switch ( horizAlign )
{
case wxRIGHT:
- x = rect.x + (rect.width - textWidth - 1.0);
+ x = rect.x + (rect.width - textWidth - 1);
break;
case wxCENTRE:
- x = rect.x + ((rect.width - textWidth)/2.0);
+ x = rect.x + ((rect.width - textWidth)/2);
break;
case wxLEFT:
default:
- x = rect.x + 1.0;
+ x = rect.x + 1;
break;
}
break;
case wxCENTRE:
- y = rect.y + ((rect.height - textHeight)/2.0);
+ y = rect.y + ((rect.height - textHeight)/2);
break;
case wxTOP:
default:
- y = rect.y + 1.0;
+ y = rect.y + 1;
break;
}
y += lineHeight;
}
}
-
+
dc.DestroyClippingRegion();
if (alreadyClipping) dc.SetClippingRegion( clipRect );
}
bool wxGrid::SetModelValues()
{
int row, col;
-
+
if ( m_table )
{
for ( row = m_scrollPosY; row < m_numRows; row++ )
return TRUE;
}
-
+
return FALSE;
}
{
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
{
m_numRows = numRows;
m_numCols = numCols;
-
+
m_table = new wxGridStringTable( m_numRows, m_numCols );
m_table->SetView( this );
Init();
m_created = TRUE;
}
-
+
return m_created;
}
if ( !m_created )
{
- wxLogError( "Called wxGrid::InsertRows() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
return FALSE;
}
-
+
if ( m_table )
{
bool ok = m_table->InsertRows( pos, numRows );
//
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;
}
bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
{
// TODO: something with updateLabels flag
-
+
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_table && m_table->DeleteRows( pos, numRows ) )
{
// the table will have sent the results of the delete row
SetEditControlValue();
else
HideCellEditControl();
-
+
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
{
// TODO: something with updateLabels flag
-
+
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()" );
- return FALSE;
+ wxLogError( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
+ return FALSE;
}
if ( m_table && m_table->AppendCols( numCols ) )
{
- // the table will have sent the results of the append col
- // operation to this view object as a grid table message
- //
- if ( !GetBatchCount() ) Refresh();
- return TRUE;
+ // 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;
}
else
{
- return FALSE;
+ return FALSE;
}
}
bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
{
// TODO: something with updateLabels flag
-
+
if ( !m_created )
{
- wxLogError( "Called wxGrid::DeleteCols() before calling CreateGrid()" );
+ wxLogError( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
return FALSE;
}
-
+
if ( m_table && m_table->DeleteCols( pos, numCols ) )
{
// the table will have sent the results of the delete col
SetEditControlValue();
else
HideCellEditControl();
-
+
if ( !GetBatchCount() ) Refresh();
return TRUE;
}
return FALSE;
}
}
-
+
if ( !m_editable ) HideCellEditControl();
m_topEditCtrlEnabled = m_editable;
m_cellEditCtrlEnabled = m_editable;
- if ( !m_editable ) ShowCellEditControl();
+ if ( !m_editable ) ShowCellEditControl();
}
}
if ( m_currentCellCoords != wxGridNoCellCoords )
SetEditControlValue();
-
+
ShowCellEditControl();
if ( !GetBatchCount() ) Refresh();
}
if ( m_cellEditCtrl &&
enable != m_cellEditCtrlEnabled )
{
+ wxClientDC dc( this );
+
+ HideCurrentCellHighlight( dc );
HideCellEditControl();
SaveEditControlValue();
-
+
m_cellEditCtrlEnabled = enable;
SetEditControlValue();
ShowCellEditControl();
+ ShowCurrentCellHighlight( dc );
}
}
{
m_rowLabelHorizAlign = horiz;
}
-
+
if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
{
m_rowLabelVertAlign = vert;
{
m_colLabelHorizAlign = horiz;
}
-
+
if ( vert == wxTOP || vert == wxCENTRE || vert == wxBOTTOM )
{
m_colLabelVertAlign = vert;
void wxGrid::SetGridLineColour( const wxColour& colour )
{
m_gridLineColour = colour;
-
+
wxClientDC dc( this );
DrawGridLines( 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( 255, 255, 255 );
+ return wxColour( 255, 255, 255 );
}
wxColour wxGrid::GetDefaultCellTextColour()
{
// TODO: replace this temp test code
//
- return wxColour( 0, 0, 0 );
+ 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 wxColour( 0, 0, 0 );
+ return wxColour( 0, 0, 0 );
}
{
// TODO: replace this temp test code
//
- return wxColour( 0, 0, 0 );
+ return wxColour( 0, 0, 0 );
}
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 !!!
//
SetEditControlValue( s );
}
}
-}
+}
{
int lastX = m_scrollPosX;
int lastY = m_scrollPosY;
-
+
if ( row >= 0 && row < m_numRows &&
col >= 0 && col < m_numCols )
{
{
if ( m_selectedTopLeft.GetRow() > row )
m_selectedTopLeft.SetRow( row );
-
+
m_selectedTopLeft.SetCol( 0 );
-
+
if ( m_selectedBottomRight.GetRow() < row )
m_selectedBottomRight.SetRow( row );
-
+
m_selectedBottomRight.SetCol( m_numCols - 1 );
}
else
wxRect rect( SelectionToRect() );
if ( rect != wxGridNoCellRect ) Refresh( TRUE, &rect );
}
-
+
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 );
void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol )
{
int temp;
-
+
if ( topRow > bottomRow )
{
temp = topRow;
if ( !m_isDragging )
{
wxGridRangeSelectEvent gridEvt( GetId(),
- EVT_WXGRID_RANGE_SELECT,
+ EVT_GRID_RANGE_SELECT,
this,
m_selectedTopLeft,
m_selectedBottomRight );
-
+
GetEventHandler()->ProcessEvent(gridEvt);
}
}
m_selectedTopLeft = wxGridNoCellCoords;
m_selectedBottomRight = wxGridNoCellCoords;
}
-}
+}
wxRect wxGrid::SelectionToRect()
{
rect = wxRect( m_left, m_top, 0, 0 );
}
-
+
cellRect = CellToRect( m_selectedBottomRight );
if ( cellRect != wxGridNoCellRect )
{
m_shift = shift;
m_alt = alt;
m_meta = meta;
-
+
SetEventObject(obj);
}
m_shift = shift;
m_alt = alt;
m_meta = meta;
-
+
SetEventObject(obj);
}
IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxEvent )
wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
- const wxGridCellCoords& topLeft,
- const wxGridCellCoords& bottomRight,
- bool control, bool shift, bool alt, bool meta )
- : wxNotifyEvent( type, id )
+ const wxGridCellCoords& topLeft,
+ const wxGridCellCoords& bottomRight,
+ bool control, bool shift, bool alt, bool meta )
+ : wxNotifyEvent( type, id )
{
m_topLeft = topLeft;
m_bottomRight = bottomRight;
projects / wxWidgets.git / blobdiff