// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "grid.h"
-#endif
-
// For compilers that support precompilatixon, includes "wx/wx.h".
#include "wx/wxprec.h"
#include "wx/combobox.h"
#include "wx/valtext.h"
#include "wx/intl.h"
+ #include "wx/math.h"
#endif
#include "wx/textfile.h"
wxGridRowLabelWindow *rowLblWin,
wxGridColLabelWindow *colLblWin,
wxWindowID id, const wxPoint &pos, const wxSize &size );
- ~wxGridWindow(){}
+ ~wxGridWindow() {}
void ScrollWindow( int dx, int dy, const wxRect *rect );
};
-
class wxGridCellEditorEvtHandler : public wxEvtHandler
{
public:
- wxGridCellEditorEvtHandler()
- : m_grid(0), m_editor(0)
- { }
wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
- : m_grid(grid), m_editor(editor)
- { }
+ : m_grid(grid),
+ m_editor(editor),
+ m_inSetFocus(false)
+ {
+ }
+ void OnKillFocus(wxFocusEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnChar(wxKeyEvent& event);
+ void SetInSetFocus(bool inSetFocus) { m_inSetFocus = inSetFocus; }
+
private:
wxGrid* m_grid;
wxGridCellEditor* m_editor;
- DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
+
+ // Work around the fact that a focus kill event can be sent to
+ // a combobox within a set focus event.
+ bool m_inSetFocus;
+
DECLARE_EVENT_TABLE()
+ DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
};
-IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler, wxEvtHandler )
+IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler, wxEvtHandler)
+
BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
+ EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus )
EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
END_EVENT_TABLE()
// through in that case.
if ((ctrl || alt) && !(ctrl && alt))
return false;
-
+
#if wxUSE_UNICODE
int key = event.GetUnicodeKey();
bool keyOk = true;
return keyOk;
#else // !wxUSE_UNICODE
int key = event.GetKeyCode();
- if (key <= 255)
+ if (key <= 255)
return true;
return false;
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
wxTextCtrl* tc = Text();
wxChar ch;
long pos;
-
+
#if wxUSE_UNICODE
ch = event.GetUnicodeKey();
if (ch <= 127)
void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
{
+ int keycode = event.GetKeyCode();
if ( !HasRange() )
{
- int keycode = event.GetKeyCode();
if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')
{
wxGridCellTextEditor::StartingKey(event);
return;
}
}
-
+#if wxUSE_SPINCTRL
+ else
+ {
+ if ( wxIsdigit(keycode) )
+ {
+ wxSpinCtrl* spin = (wxSpinCtrl*)m_control;
+ spin->SetValue(keycode - '0');
+ spin->SetSelection(1,1);
+ return;
+ }
+ }
+#endif
event.Skip();
}
wxString s;
#if wxUSE_SPINCTRL
- if( HasRange() )
+ if ( HasRange() )
{
long value = Spin()->GetValue();
s.Printf(wxT("%ld"), value);
double value = 0.0;
wxString text(Text()->GetValue());
- if ( (text.empty() || text.ToDouble(&value)) && (value != m_valueOld) )
+ if ( (text.empty() || text.ToDouble(&value)) &&
+ !wxIsSameDouble(value, m_valueOld) )
{
if (grid->GetTable()->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT))
grid->GetTable()->SetValueAsDouble(row, col, value);
tmpbuf[0] = (char) keycode;
tmpbuf[1] = '\0';
wxString strbuf(tmpbuf, *wxConvCurrent);
-#if wxUSE_INTL
+#if wxUSE_INTL
bool is_decimal_point = ( strbuf ==
wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );
#else
tmpbuf[0] = (char) keycode;
tmpbuf[1] = '\0';
wxString strbuf(tmpbuf, *wxConvCurrent);
-#if wxUSE_INTL
+#if wxUSE_INTL
bool is_decimal_point =
( strbuf == wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
wxLOCALE_CAT_NUMBER) );
#else
bool is_decimal_point = ( strbuf == _T(".") );
#endif
- if ( (keycode < 128) &&
+ if ( (keycode < 128) &&
(wxIsdigit(keycode) || tolower(keycode) == 'e' ||
is_decimal_point || keycode == '+' || keycode == '-') )
return true;
case WXK_SPACE:
CBox()->SetValue(!CBox()->GetValue());
break;
-
+
case '+':
CBox()->SetValue(true);
break;
-
+
case '-':
CBox()->SetValue(false);
break;
wxASSERT_MSG(m_control,
wxT("The wxGridCellEditor must be Created first!"));
+ wxGridCellEditorEvtHandler* evtHandler = NULL;
+ if (m_control)
+ evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);
+
+ // Don't immediately end if we get a kill focus event within BeginEdit
+ if (evtHandler)
+ evtHandler->SetInSetFocus(true);
+
m_startValue = grid->GetTable()->GetValue(row, col);
if (m_allowOthers)
{
// find the right position, or default to the first if not found
int pos = Combo()->FindString(m_startValue);
- if (pos == -1)
+ if (pos == wxNOT_FOUND)
pos = 0;
Combo()->SetSelection(pos);
}
Combo()->SetInsertionPointEnd();
Combo()->SetFocus();
+
+ if (evtHandler)
+ evtHandler->SetInSetFocus(false);
}
bool wxGridCellChoiceEditor::EndEdit(int row, int col,
// wxGridCellEditorEvtHandler
// ----------------------------------------------------------------------------
+void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent& event)
+{
+ // Don't disable the cell if we're just starting to edit it
+ if (m_inSetFocus)
+ return;
+
+ // accept changes
+ m_grid->DisableCellEditControl();
+
+ event.Skip();
+}
+
void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
{
switch ( event.GetKeyCode() )
dc.SetBackgroundMode( wxSOLID );
// grey out fields if the grid is disabled
- if( grid.IsEnabled() )
+ if ( grid.IsEnabled() )
{
if ( isSelected )
{
// wxGridCellStringRenderer
// ----------------------------------------------------------------------------
-void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid& grid,
- wxGridCellAttr& attr,
+void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid& grid,
+ const wxGridCellAttr& attr,
wxDC& dc,
bool isSelected)
{
// TODO some special colours for attr.IsReadOnly() case?
// different coloured text when the grid is disabled
- if( grid.IsEnabled() )
+ if ( grid.IsEnabled() )
{
if ( isSelected )
{
dc.SetFont( attr.GetFont() );
}
-wxSize wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr& attr,
+wxSize wxGridCellStringRenderer::DoGetBestSize(const wxGridCellAttr& attr,
wxDC& dc,
const wxString& text)
{
i--;
break;
}
- if (rect.width >= best_width) break;
+ if (rect.width >= best_width)
+ break;
}
overflowCols = i - col - cell_cols + 1;
- if (overflowCols >= cols) overflowCols = cols - 1;
+ if (overflowCols >= cols)
+ overflowCols = cols - 1;
}
if (overflowCols > 0) // redraw overflow cells w/ proper hilight
// wxGridCellNumberRenderer
// ----------------------------------------------------------------------------
-wxString wxGridCellNumberRenderer::GetString(wxGrid& grid, int row, int col)
+wxString wxGridCellNumberRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
wxString text;
return renderer;
}
-wxString wxGridCellFloatRenderer::GetString(wxGrid& grid, int row, int col)
+wxString wxGridCellFloatRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
{
wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params.c_str());
}
-
}
- tmp = params.AfterFirst(_T(','));
- if ( !tmp.empty() )
- {
- long precision;
+ tmp = params.AfterFirst(_T(','));
+ if ( !tmp.empty() )
+ {
+ long precision;
if ( tmp.ToLong(&precision) )
- {
+ {
SetPrecision((int)precision);
- }
- else
- {
+ }
+ else
+ {
wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params.c_str());
- }
-
+ }
}
}
}
SetBackgroundColour(mergefrom->GetBackgroundColour());
if ( !HasFont() && mergefrom->HasFont() )
SetFont(mergefrom->GetFont());
- if ( !HasAlignment() && mergefrom->HasAlignment() ){
+ if ( !HasAlignment() && mergefrom->HasAlignment() )
+ {
int hAlign, vAlign;
mergefrom->GetAlignment( &hAlign, &vAlign);
SetAlignment(hAlign, vAlign);
}
-
- mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
+ if ( !HasSize() && mergefrom->HasSize() )
+ mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
// Directly access member functions as GetRender/Editor don't just return
// m_renderer/m_editor
{
if (HasAlignment())
{
- if ( hAlign ) *hAlign = m_hAlign;
- if ( vAlign ) *vAlign = m_vAlign;
+ if ( hAlign )
+ *hAlign = m_hAlign;
+ if ( vAlign )
+ *vAlign = m_vAlign;
}
else if (m_defGridAttr && m_defGridAttr != this)
m_defGridAttr->GetAlignment(hAlign, vAlign);
void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
{
- if ( num_rows ) *num_rows = m_sizeRows;
- if ( num_cols ) *num_cols = m_sizeCols;
+ if ( num_rows )
+ *num_rows = m_sizeRows;
+ if ( num_cols )
+ *num_cols = m_sizeCols;
}
// GetRenderer and GetEditor use a slightly different decision path about
// No need to DecRef the attribute itself since this is
// done be wxGridCellWithAttr's destructor!
m_attrs.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
m_rowsOrCols.RemoveAt(n);
m_attrs[n]->DecRef();
m_attrs.RemoveAt(n);
- n--; count--;
+ n--;
+ count--;
}
}
}
//Get cached merge attributes.
// Currenlty not used as no cache implemented as not mutiable
// attr = m_data->m_mergeAttr.GetAttr(row, col);
- if(!attr)
+ if (!attr)
{
- //Basicaly implement old version.
+ //Basically implement old version.
//Also check merge cache, so we don't have to re-merge every time..
wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
- if((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol)){
+ if ((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol))
+ {
// Two or more are non NULL
attr = new wxGridCellAttr;
attr->SetKind(wxGridCellAttr::Merged);
//Order important..
- if(attrcell){
+ if (attrcell)
+ {
attr->MergeWith(attrcell);
attrcell->DecRef();
}
- if(attrcol){
+ if (attrcol)
+ {
attr->MergeWith(attrcol);
attrcol->DecRef();
}
- if(attrrow){
+ if (attrrow)
+ {
attr->MergeWith(attrrow);
attrrow->DecRef();
}
else
{
// one or none is non null return it or null.
- if(attrrow) attr = attrrow;
- if(attrcol)
+ if (attrrow)
+ attr = attrrow;
+ if (attrcol)
{
if(attr)
attr->DecRef();
attr = attrcol;
}
- if(attrcell)
+ if (attrcell)
{
- if(attr)
+ if (attr)
attr->DecRef();
attr = attrcell;
}
}
}
break;
+
case (wxGridCellAttr::Cell):
attr = m_data->m_cellAttrs.GetAttr(row, col);
break;
+
case (wxGridCellAttr::Col):
attr = m_data->m_colAttrs.GetAttr(col);
break;
+
case (wxGridCellAttr::Row):
attr = m_data->m_rowAttrs.GetAttr(row);
break;
+
default:
// unused as yet...
// (wxGridCellAttr::Default):
RegisterDataType(wxGRID_VALUE_STRING,
new wxGridCellStringRenderer,
new wxGridCellTextEditor);
- } else
+ }
+ else
#endif // wxUSE_TEXTCTRL
#if wxUSE_CHECKBOX
if ( typeName == wxGRID_VALUE_BOOL )
RegisterDataType(wxGRID_VALUE_BOOL,
new wxGridCellBoolRenderer,
new wxGridCellBoolEditor);
- } else
+ }
+ else
#endif // wxUSE_CHECKBOX
#if wxUSE_TEXTCTRL
if ( typeName == wxGRID_VALUE_NUMBER )
RegisterDataType(wxGRID_VALUE_FLOAT,
new wxGridCellFloatRenderer,
new wxGridCellFloatEditor);
- } else
+ }
+ else
#endif // wxUSE_TEXTCTRL
#if wxUSE_COMBOBOX
if ( typeName == wxGRID_VALUE_CHOICE )
RegisterDataType(wxGRID_VALUE_CHOICE,
new wxGridCellStringRenderer,
new wxGridCellChoiceEditor);
- } else
+ }
+ else
#endif // wxUSE_COMBOBOX
{
return wxNOT_FOUND;
return (wxGridCellAttr *)NULL;
}
+
void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
{
if ( m_attrProvider )
return false;
}
-
wxString wxGridTableBase::GetRowLabelValue( int row )
{
wxString s;
{
s += (wxChar) (_T('A') + (wxChar)( col%26 ));
col = col/26 - 1;
- if ( col < 0 ) break;
+ if ( col < 0 )
+ break;
}
// reverse the string...
return s2;
}
-
wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
{
return wxGRID_VALUE_STRING;
bool wxGridStringTable::AppendRows( size_t numRows )
{
size_t curNumRows = m_data.GetCount();
- size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
- ( GetView() ? GetView()->GetNumberCols() : 0 ) );
+ size_t curNumCols = ( curNumRows > 0
+ ? m_data[0].GetCount()
+ : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
wxArrayString sa;
if ( curNumCols > 0 )
{
m_data.RemoveAt( pos, numRows );
}
+
if ( GetView() )
{
wxGridTableMessage msg( this,
size_t row, col;
size_t curNumRows = m_data.GetCount();
- size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
- ( GetView() ? GetView()->GetNumberCols() : 0 ) );
+ size_t curNumCols = ( curNumRows > 0
+ ? m_data[0].GetCount()
+ : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
if ( pos >= curNumCols )
{
m_data[row].Insert( wxEmptyString, col );
}
}
+
if ( GetView() )
{
wxGridTableMessage msg( this,
m_data[row].RemoveAt( pos, numCols );
}
}
+
if ( GetView() )
{
wxGridTableMessage msg( this,
}
-
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
m_owner->DrawRowLabels( dc , rows );
}
-
void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
{
m_owner->ProcessRowLabelMouseEvent( event );
}
-
void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
{
m_owner->GetEventHandler()->ProcessEvent(event);
}
-
// This seems to be required for wxMotif otherwise the mouse
// cursor must be in the cell edit control to get key events
//
}
-
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
m_owner->DrawColLabels( dc , cols );
}
-
void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
{
m_owner->ProcessColLabelMouseEvent( event );
m_owner->GetEventHandler()->ProcessEvent(event);
}
-
// This seems to be required for wxMotif otherwise the mouse
// cursor must be in the cell edit control to get key events
//
void wxGridColLabelWindow::OnKeyDown( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
void wxGridColLabelWindow::OnKeyUp( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
void wxGridColLabelWindow::OnChar( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
int client_width = 0;
GetClientSize( &client_width, &client_height );
-#if __WXGTK__
+ // VZ: any reason for this ifdef? (FIXME)
+#ifdef __WXGTK__
wxRect rect;
rect.SetX( 1 );
rect.SetY( 1 );
rect.SetHeight( client_height - 2 );
wxRendererNative::Get().DrawHeaderButton( this, dc, rect, 0 );
-#else
+#else // !__WXGTK__
dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
dc.DrawLine( client_width-1, client_height-1, client_width-1, 0 );
dc.DrawLine( client_width-1, client_height-1, 0, client_height-1 );
dc.SetPen( *wxWHITE_PEN );
dc.DrawLine( 1, 1, client_width-1, 1 );
dc.DrawLine( 1, 1, 1, client_height-1 );
-#endif
+#endif // __WXGTK__/!__WXGTK__
}
-
void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
{
m_owner->ProcessCornerLabelMouseEvent( event );
}
-
void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
{
m_owner->GetEventHandler()->ProcessEvent(event);
const wxSize &size )
: wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN|wxFULL_REPAINT_ON_RESIZE,
wxT("grid window") )
-
{
m_owner = parent;
m_rowLabelWin = rowLblWin;
m_colLabelWin = colLblWin;
}
-
void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
{
wxPaintDC dc( this );
m_owner->DrawHighlight( dc , DirtyCells );
}
-
void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
{
wxWindow::ScrollWindow( dx, dy, rect );
m_colLabelWin->ScrollWindow( dx, 0, rect );
}
-
void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
{
+ if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
+ SetFocus();
+
m_owner->ProcessGridCellMouseEvent( event );
}
//
void wxGridWindow::OnKeyDown( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
void wxGridWindow::OnKeyUp( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
void wxGridWindow::OnChar( wxKeyEvent& event )
{
- if ( !m_owner->GetEventHandler()->ProcessEvent( event ) ) event.Skip();
+ if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
+ event.Skip();
}
void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
// take into account editor if shown
- if( IsCellEditControlShown() )
+ if ( IsCellEditControlShown() )
{
int w2, h2;
int r = m_currentCellCoords.GetRow();
editor->GetControl()->GetSize(&w2, &h2);
w2 += x;
h2 += y;
- if( w2 > w ) w = w2;
- if( h2 > h ) h = h2;
+ if ( w2 > w )
+ w = w2;
+ if ( h2 > h )
+ h = h2;
editor->DecRef();
attr->DecRef();
}
if ( m_selection )
m_selection->UpdateRows( pos, -((int)numRows) );
wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
- if (attrProvider) {
+ if (attrProvider)
+ {
attrProvider->UpdateAttrRows( pos, -((int)numRows) );
// ifdef'd out following patch from Paul Gammans
#if 0
if ( m_selection )
m_selection->UpdateCols( pos, -((int)numCols) );
wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
- if (attrProvider) {
+ if (attrProvider)
+ {
attrProvider->UpdateAttrCols( pos, -((int)numCols) );
// ifdef'd out following patch from Paul Gammans
#if 0
break;
case WXGRID_CURSOR_SELECT_ROW:
+ {
if ( (row = YToRow( y )) >= 0 )
{
if ( m_selection )
event.MetaDown() );
}
}
+ }
+ break;
// default label to suppress warnings about "enumeration value
// 'xxx' not handled in switch
//
else if (event.LeftDClick() )
{
- int row = YToEdgeOfRow(y);
+ row = YToEdgeOfRow(y);
if ( row < 0 )
{
row = YToRow(y);
break;
case WXGRID_CURSOR_SELECT_COL:
+ {
if ( (col = XToCol( x )) >= 0 )
{
if ( m_selection )
event.MetaDown() );
}
}
+ }
+ break;
// default label to suppress warnings about "enumeration value
// 'xxx' not handled in switch
//
if ( event.LeftDClick() )
{
- int col = XToEdgeOfCol(x);
+ col = XToEdgeOfCol(x);
if ( col < 0 )
{
col = XToCol(x);
if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
{
// Hide the edit control, so it
- // won't interfer with drag-shrinking.
+ // won't interfere with drag-shrinking.
if ( IsCellEditControlShown() )
{
HideCellEditControl();
//
else if ( event.Moving() && !event.IsButton() )
{
- if( coords.GetRow() < 0 || coords.GetCol() < 0 )
+ if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
{
// out of grid cell area
ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
}
// A Veto'd event may not be `claimed' so test this first
- if (vetoed) return -1;
+ if (vetoed)
+ return -1;
+
return claimed ? 1 : 0;
}
}
// A Veto'd event may not be `claimed' so test this first
- if (vetoed) return -1;
+ if (vetoed)
+ return -1;
+
return claimed ? 1 : 0;
}
-
void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this); // needed to prevent zillions of paint events on MSW
if (! GetBatchCount())
{
// Refresh to get correct scrolled position:
- wxScrolledWindow::Refresh(eraseb,rect);
+ wxScrolledWindow::Refresh(eraseb, rect);
if (rect)
{
rectHeight = rect->GetHeight();
width_label = m_rowLabelWidth - rect_x;
- if (width_label > rectWidth) width_label = rectWidth;
+ if (width_label > rectWidth)
+ width_label = rectWidth;
height_label = m_colLabelHeight - rect_y;
if (height_label > rectHeight) height_label = rectHeight;
//
void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
{
- if ( !m_numRows || !m_numCols ) return;
+ if ( !m_numRows || !m_numCols )
+ return;
int i, numCells = cells.GetCount();
int row, col, cell_rows, cell_cols;
break;
}
}
- if (!marked) redrawCells.Add( cell );
+ if (!marked)
+ redrawCells.Add( cell );
}
continue; // don't bother drawing this cell
}
for (int k = 0; k < int(redrawCells.GetCount()); k++)
if ((redrawCells[k].GetCol() < left) &&
(redrawCells[k].GetRow() == row))
- left=redrawCells[k].GetCol();
+ left = redrawCells[k].GetCol();
- if (left == col) left = 0; // oh well
+ if (left == col)
+ left = 0; // oh well
for (int j = col-1; j >= left; j--)
{
break;
}
}
+
if (!marked)
{
int count = redrawCells.GetCount();
break;
}
}
- if (!marked) redrawCells.Add( cell );
+ if (!marked)
+ redrawCells.Add( cell );
}
}
break;
}
}
}
+
DrawCell( dc, cells[i] );
}
// reduce the size of the rectangle to compensate for the thickness of
// the line. If this is too strange on non wxMSW platforms then
// please #ifdef this appropriately.
- rect.x += penWidth/2;
- rect.y += penWidth/2;
- rect.width -= penWidth-1;
- rect.height -= penWidth-1;
+ rect.x += penWidth / 2;
+ rect.y += penWidth / 2;
+ rect.width -= penWidth - 1;
+ rect.height -= penWidth - 1;
// Now draw the rectangle
// use the cellHighlightColour if the cell is inside a selection, this
// will ensure the cell is always visible.
- dc.SetPen(wxPen(IsInSelection(row,col)?m_selectionForeground:m_cellHighlightColour, penWidth, wxSOLID));
+ dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground : m_cellHighlightColour, penWidth, wxSOLID));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(rect);
}
// how to properly set colours for arbitrary bg?
wxCoord x1 = rect.x,
y1 = rect.y,
- x2 = rect.x + rect.width -1,
- y2 = rect.y + rect.height -1;
+ x2 = rect.x + rect.width - 1,
+ y2 = rect.y + rect.height - 1;
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(x1, y1, x2, y1);
if ( !m_gridLinesEnabled ||
!m_numRows ||
- !m_numCols ) return;
+ !m_numCols )
+ return;
int top, bottom, left, right;
int topRow = internalYToRow(top);
int rightCol = internalXToCol(right);
int bottomRow = internalYToRow(bottom);
- wxRegion clippedcells(0, 0, cw, ch);
+#ifndef __WXMAC__
+ // CS: I don't know why suddenly unscrolled coordinates are used for clipping
+ wxRegion clippedcells(0, 0, cw, ch);
int i, j, cell_rows, cell_cols;
wxRect rect;
}
}
}
+#else
+ wxRegion clippedcells( left , top, right - left, bottom - top);
+
+ int i, j, cell_rows, cell_cols;
+ wxRect rect;
+
+ for (j=topRow; j<bottomRow; j++)
+ {
+ for (i=leftCol; i<rightCol; i++)
+ {
+ GetCellSize( j, i, &cell_rows, &cell_cols );
+ if ((cell_rows > 1) || (cell_cols > 1))
+ {
+ rect = CellToRect(j,i);
+ clippedcells.Subtract(rect);
+ }
+ else if ((cell_rows < 0) || (cell_cols < 0))
+ {
+ rect = CellToRect(j+cell_rows, i+cell_cols);
+ clippedcells.Subtract(rect);
+ }
+ }
+ }
+#endif
dc.SetClippingRegion( clippedcells );
dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
}
}
-
// vertical grid lines
//
for ( i = internalXToCol(left); i < m_numCols; i++ )
dc.DestroyClippingRegion();
}
-
void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
{
- if ( !m_numRows ) return;
+ if ( !m_numRows )
+ return;
size_t i;
size_t numLabels = rows.GetCount();
}
}
-
void wxGrid::DrawRowLabel( wxDC& dc, int row )
{
- if ( GetRowHeight(row) <= 0 )
+ if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
return;
wxRect rect;
-#ifdef __WXGTK__
+#ifdef __WXGTK20__
rect.SetX( 1 );
rect.SetY( GetRowTop(row) + 1 );
rect.SetWidth( m_rowLabelWidth - 2 );
DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
}
-
void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
{
- if ( !m_numCols ) return;
+ if ( !m_numCols )
+ return;
size_t i;
size_t numLabels = cols.GetCount();
}
}
-
void wxGrid::DrawColLabel( wxDC& dc, int col )
{
- if ( GetColWidth(col) <= 0 )
+ if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
return;
int colLeft = GetColLeft(col);
wxRect rect;
-#ifdef __WXGTK__
+#ifdef __WXGTK20__
rect.SetX( colLeft + 1 );
rect.SetY( 1 );
rect.SetWidth( GetColWidth(col) - 2 );
StringToLines( value, lines );
-
//Forward to new API.
DrawTextRectangle( dc,
lines,
dc.SetClippingRegion( rect );
nLines = lines.GetCount();
- if( nLines > 0 )
+ if ( nLines > 0 )
{
int l;
float x = 0.0, y = 0.0;
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
GetTextBoxSize(dc, lines, &textWidth, &textHeight);
else
GetTextBoxSize( dc, lines, &textHeight, &textWidth );
switch( vertAlign )
{
case wxALIGN_BOTTOM:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
y = rect.y + (rect.height - textHeight - 1);
else
x = rect.x + rect.width - textWidth;
break;
case wxALIGN_CENTRE:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
y = rect.y + ((rect.height - textHeight)/2);
else
x = rect.x + ((rect.width - textWidth)/2);
case wxALIGN_TOP:
default:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
y = rect.y + 1;
else
x = rect.x + 1;
}
// Align each line of a multi-line label
- for( l = 0; l < nLines; l++ )
+ for ( l = 0; l < nLines; l++ )
{
dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
switch( horizAlign )
{
case wxALIGN_RIGHT:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
x = rect.x + (rect.width - lineWidth - 1);
else
y = rect.y + lineWidth + 1;
break;
case wxALIGN_CENTRE:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
x = rect.x + ((rect.width - lineWidth)/2);
else
y = rect.y + rect.height - ((rect.height - lineWidth)/2);
case wxALIGN_LEFT:
default:
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
x = rect.x + 1;
else
y = rect.y + rect.height - 1;
break;
}
- if( textOrientation == wxHORIZONTAL )
+ if ( textOrientation == wxHORIZONTAL )
{
dc.DrawText( lines[l], (int)x, (int)y );
y += lineHeight;
}
}
}
+
dc.DestroyClippingRegion();
}
{
lines.Add( value.Mid(startPos, pos) );
}
- startPos += pos+1;
+ startPos += pos + 1;
}
+
if ( startPos < (int)value.Length() )
{
lines.Add( value.Mid( startPos ) );
}
-void wxGrid::GetTextBoxSize( wxDC& dc,
+void wxGrid::GetTextBoxSize( const wxDC& dc,
const wxArrayString& lines,
long *width, long *height )
{
return true;
}
+
//
// ------ Edit control functions
//
-
void wxGrid::EnableEditing( bool edit )
{
// TODO: improve this ?
//
if ( edit != m_editable )
{
- if(!edit) EnableCellEditControl(edit);
+ if (!edit)
+ EnableCellEditControl(edit);
m_editable = edit;
}
}
-
void wxGrid::EnableCellEditControl( bool enable )
{
if (! m_editable)
NULL, NULL, &attr->GetFont());
if (maxWidth < rect.width) maxWidth = rect.width;
}
+
int client_right = m_gridWin->GetClientSize().GetWidth();
if (rect.x+maxWidth > client_right)
maxWidth = client_right - rect.x;
else
break;
}
+
if (rect.GetRight() > client_right)
- rect.SetRight(client_right-1);
+ rect.SetRight(client_right - 1);
}
editor->SetCellAttr(attr);
}
}
-
void wxGrid::HideCellEditControl()
{
if ( IsCellEditControlEnabled() )
editor->Show( false );
editor->DecRef();
attr->DecRef();
+
m_gridWin->SetFocus();
+
// refresh whole row to the right
wxRect rect( CellToRect(row, col) );
CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
+#ifdef __WXMAC__
+ // ensure that the pixels under the focus ring get refreshed as well
+ rect.Inflate(10, 10);
+#endif
m_gridWin->Refresh( false, &rect );
}
}
-
void wxGrid::SaveEditControlValue()
{
if ( IsCellEditControlEnabled() )
int row = m_currentCellCoords.GetRow();
int col = m_currentCellCoords.GetCol();
- wxString oldval = GetCellValue(row,col);
+ wxString oldval = GetCellValue(row, col);
wxGridCellAttr* attr = GetCellAttr(row, col);
wxGridCellEditor* editor = attr->GetEditor(this, row, col);
{
if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
m_currentCellCoords.GetRow(),
- m_currentCellCoords.GetCol() ) < 0 ) {
-
+ m_currentCellCoords.GetCol() ) < 0 )
+ {
// Event has been vetoed, set the data back.
- SetCellValue(row,col,oldval);
+ SetCellValue(row, col, oldval);
}
}
}
const wxArrayInt& BorderArray, int nMax,
bool clipToMinMax)
{
-
if (coord < 0)
return clipToMinMax && (nMax > 0) ? 0 : -1;
-
if (!defaultDist)
defaultDist = 1;
if (BorderArray.IsEmpty())
{
- if((int) i_max < nMax)
+ if ((int) i_max < nMax)
return i_max;
return clipToMinMax ? nMax - 1 : -1;
}
else
i_max = BorderArray.GetCount() - 1;
}
+
if ( i_max >= BorderArray.GetCount())
i_max = BorderArray.GetCount() - 1;
}
+
if ( coord >= BorderArray[i_max])
return clipToMinMax ? (int)i_max : -1;
if ( coord < BorderArray[0] )
else
i_min = median;
}
+
return i_max;
}
m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
}
-
int wxGrid::XToCol( int x )
{
return CoordToRowOrCol(x, m_defaultColWidth,
m_minAcceptableColWidth, m_colRights, m_numCols, false);
}
-
// return the row number that that the y coord is near the edge of, or
// -1 if not near an edge
//
// close enough to lower or upper border, respectively.
if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
return i;
- else if( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
+ else if ( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
return i - 1;
}
return -1;
}
-
// return the col number that that the x coord is near the edge of, or
// -1 if not near an edge
//
// close enough to right or left border, respectively.
if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
return i;
- else if( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
+ else if ( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
return i - 1;
}
return -1;
}
-
wxRect wxGrid::CellToRect( int row, int col )
{
wxRect rect( -1, -1, -1, -1 );
}
// if grid lines are enabled, then the area of the cell is a bit smaller
- if (m_gridLinesEnabled) {
+ if (m_gridLinesEnabled)
+ {
rect.width -= 1;
rect.height -= 1;
}
+
return rect;
}
-
bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
{
// get the cell rectangle in logical coords
}
}
-
// make the specified cell location visible by doing a minimal amount
// of scrolling
//
void wxGrid::MakeCellVisible( int row, int col )
{
-
int i;
int xpos = -1, ypos = -1;
}
else
return false;
+
return true;
}
}
else
return false;
+
return true;
}
return false;
}
-
bool wxGrid::MoveCursorLeft( bool expandSelection )
{
if ( m_currentCellCoords != wxGridNoCellCoords &&
}
else
return false;
+
return true;
}
return false;
}
-
bool wxGrid::MoveCursorRight( bool expandSelection )
{
if ( m_currentCellCoords != wxGridNoCellCoords &&
}
else
return false;
+
return true;
}
return false;
}
-
bool wxGrid::MovePageUp()
{
- if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ return false;
int row = m_currentCellCoords.GetRow();
if ( row > 0 )
bool wxGrid::MovePageDown()
{
- if ( m_currentCellCoords == wxGridNoCellCoords ) return false;
+ if ( m_currentCellCoords == wxGridNoCellCoords )
+ return false;
int row = m_currentCellCoords.GetRow();
if ( (row+1) < m_numRows )
while ( row > 0 )
{
row-- ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else if ( m_table->IsEmptyCell(row-1, col) )
while ( row > 0 )
{
row-- ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else
ClearSelection();
SetCurrentCell( row, col );
}
+
return true;
}
while ( row < m_numRows-1 )
{
row++ ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else if ( m_table->IsEmptyCell(row+1, col) )
while ( row < m_numRows-1 )
{
row++ ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else
while ( col > 0 )
{
col-- ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else if ( m_table->IsEmptyCell(row, col-1) )
while ( col > 0 )
{
col-- ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else
while ( col < m_numCols-1 )
{
col++ ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else if ( m_table->IsEmptyCell(row, col+1) )
while ( col < m_numCols-1 )
{
col++ ;
- if ( !(m_table->IsEmptyCell(row, col)) ) break;
+ if ( !(m_table->IsEmptyCell(row, col)) )
+ break;
}
}
else
//
void wxGrid::SetColLabelTextOrientation( int textOrientation )
{
- if( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
+ if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
{
m_colLabelTextOrientation = textOrientation;
}
void wxGrid::SetCellHighlightPenWidth(int width)
{
- if (m_cellHighlightPenWidth != width) {
+ if (m_cellHighlightPenWidth != width)
+ {
m_cellHighlightPenWidth = width;
// Just redrawing the cell highlight is not enough since that won't
void wxGrid::SetCellHighlightROPenWidth(int width)
{
- if (m_cellHighlightROPenWidth != width) {
+ if (m_cellHighlightROPenWidth != width)
+ {
m_cellHighlightROPenWidth = width;
// Just redrawing the cell highlight is not enough since that won't
wxGridCellEditor *wxGrid::GetDefaultEditor() const
{
- return m_defaultCellAttr->GetEditor(NULL,0,0);
+ return m_defaultCellAttr->GetEditor(NULL, 0, 0);
}
// ----------------------------------------------------------------------------
wxGridCellAttr *attr = GetCellAttr(row, col);
bool allow = attr->GetOverflow();
attr->DecRef();
+
return allow;
}
wxGridCellAttr* attr = GetCellAttr(row, col);
bool isReadOnly = attr->IsReadOnly();
attr->DecRef();
+
return isReadOnly;
}
#ifdef DEBUG_ATTR_CACHE
gs_nAttrCacheMisses++;
#endif
+
return false;
}
}
CacheAttr(row, col, attr);
}
}
+
if (attr)
{
attr->SetDefAttr(m_defaultCellAttr);
void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
{
wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
- if(!attr)
+ if (!attr)
attr = new wxGridCellAttr;
wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
attr->SetRenderer(renderer);
int index = m_typeRegistry->FindOrCloneDataType(typeName);
if ( index == wxNOT_FOUND )
{
- wxFAIL_MSG(wxT("Unknown data type name"));
+ wxString errStr;
+
+ errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
+ wxFAIL_MSG(errStr.c_str());
return NULL;
}
int index = m_typeRegistry->FindOrCloneDataType(typeName);
if ( index == wxNOT_FOUND )
{
- wxFAIL_MSG(wxT("Unknown data type name"));
+ wxString errStr;
+
+ errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
+ wxFAIL_MSG(errStr.c_str());
return NULL;
}
m_canDragRowSize = enable;
}
-
void wxGrid::EnableDragColSize( bool enable )
{
m_canDragColSize = enable;
wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
// See comment in SetColSize
- if ( height < GetRowMinimalAcceptableHeight()) { return; }
+ if ( height < GetRowMinimalAcceptableHeight())
+ return;
if ( m_rowHeights.IsEmpty() )
{
//
// This test then fixes sf.net bug #645734
- if ( width < GetColMinimalAcceptableWidth()) { return; }
+ if ( width < GetColMinimalAcceptableWidth())
+ return;
if ( m_colWidths.IsEmpty() )
{
}
// if < 0 calc new width from label
- if( width < 0 )
+ if ( width < 0 )
{
long w, h;
wxArrayString lines;
CalcDimensions();
}
-
void wxGrid::SetColMinimalWidth( int col, int width )
{
- if (width > GetColMinimalAcceptableWidth()) {
+ if (width > GetColMinimalAcceptableWidth())
+ {
wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
m_colMinWidths[key] = width;
}
void wxGrid::SetRowMinimalHeight( int row, int width )
{
- if (width > GetRowMinimalAcceptableHeight()) {
+ if (width > GetRowMinimalAcceptableHeight())
+ {
wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
m_rowMinHeights[key] = width;
}
{
// We do allow a width of 0 since this gives us
// an easy way to temporarily hidding columns.
- if ( width<0 )
+ if ( width < 0 )
return;
m_minAcceptableColWidth = width;
}
{
// We do allow a height of 0 since this gives us
// an easy way to temporarily hidding rows.
- if ( height<0 )
+ if ( height < 0 )
return;
m_minAcceptableRowHeight = height;
-};
+}
int wxGrid::GetColMinimalAcceptableWidth() const
{
if ( column )
{
dc.GetTextExtent( GetColLabelValue(col), &w, &h );
- if( GetColLabelTextOrientation() == wxVERTICAL )
+ if ( GetColLabelTextOrientation() == wxVERTICAL )
w = h;
}
else
long w, h;
// Hide the edit control, so it
- // won't interfer with drag-shrinking.
- if( IsCellEditControlShown() )
+ // won't interfere with drag-shrinking.
+ if ( IsCellEditControlShown() )
{
HideCellEditControl();
SaveEditControlValue();
StringToLines( GetRowLabelValue( row ), lines );
wxClientDC dc( m_rowLabelWin );
GetTextBoxSize( dc, lines, &w, &h);
- if( h < m_defaultRowHeight )
+ if ( h < m_defaultRowHeight )
h = m_defaultRowHeight;
SetRowSize(row, h);
ForceRefresh();
// Hide the edit control, so it
// won't interfer with drag-shrinking.
- if( IsCellEditControlShown() )
+ if ( IsCellEditControlShown() )
{
HideCellEditControl();
SaveEditControlValue();
// autosize column width depending on label text
StringToLines( GetColLabelValue( col ), lines );
wxClientDC dc( m_colLabelWin );
- if( GetColLabelTextOrientation() == wxHORIZONTAL )
+ if ( GetColLabelTextOrientation() == wxHORIZONTAL )
GetTextBoxSize( dc, lines, &w, &h);
else
GetTextBoxSize( dc, lines, &h, &w);
- if( w < m_defaultColWidth )
+ if ( w < m_defaultColWidth )
w = m_defaultColWidth;
SetColSize(col, w);
ForceRefresh();
width = self->SetOrCalcColumnSizes(true);
height = self->SetOrCalcRowSizes(true);
- if (!width) width=100;
- if (!height) height=80;
+ if (!width)
+ width = 100;
+ if (!height)
+ height = 80;
- // Round up to a multiple the scroll rate NOTE: this still doesn't get rid
- // of the scrollbars, is there any magic incantaion for that?
+ // Round up to a multiple the scroll rate
+ // NOTE: this still doesn't get rid of the scrollbars;
+ // is there any magic incantation for that?
int xpu, ypu;
GetScrollPixelsPerUnit(&xpu, &ypu);
if (xpu)
// limit to 1/4 of the screen size
int maxwidth, maxheight;
- wxDisplaySize( & maxwidth, & maxheight );
+ wxDisplaySize( &maxwidth, &maxheight );
maxwidth /= 2;
maxheight /= 2;
- if ( width > maxwidth ) width = maxwidth;
- if ( height > maxheight ) height = maxheight;
-
+ if ( width > maxwidth )
+ width = maxwidth;
+ if ( height > maxheight )
+ height = maxheight;
wxSize best(width, height);
// NOTE: This size should be cached, but first we need to add calls to
AutoSize();
}
-
wxPen& wxGrid::GetDividerPen() const
{
return wxNullPen;
m_selection->SelectRow( row, false, addToSelected );
}
-
void wxGrid::SelectCol( int col, bool addToSelected )
{
if ( IsSelection() && !addToSelected )
m_selection->SelectCol( col, false, addToSelected );
}
-
void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
bool addToSelected )
{
false, addToSelected );
}
-
void wxGrid::SelectAll()
{
if ( m_numRows > 0 && m_numCols > 0 )
wxGridCellCoordsArray wxGrid::GetSelectedCells() const
{
- if (!m_selection) { wxGridCellCoordsArray a; return a; }
+ if (!m_selection)
+ {
+ wxGridCellCoordsArray a;
+ return a;
+ }
+
return m_selection->m_cellSelection;
}
+
wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
{
- if (!m_selection) { wxGridCellCoordsArray a; return a; }
+ if (!m_selection)
+ {
+ wxGridCellCoordsArray a;
+ return a;
+ }
+
return m_selection->m_blockSelectionTopLeft;
}
+
wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
{
- if (!m_selection) { wxGridCellCoordsArray a; return a; }
+ if (!m_selection)
+ {
+ wxGridCellCoordsArray a;
+ return a;
+ }
+
return m_selection->m_blockSelectionBottomRight;
}
+
wxArrayInt wxGrid::GetSelectedRows() const
{
- if (!m_selection) { wxArrayInt a; return a; }
+ if (!m_selection)
+ {
+ wxArrayInt a;
+ return a;
+ }
+
return m_selection->m_rowSelection;
}
+
wxArrayInt wxGrid::GetSelectedCols() const
{
- if (!m_selection) { wxArrayInt a; return a; }
+ if (!m_selection)
+ {
+ wxArrayInt a;
+ return a;
+ }
+
return m_selection->m_colSelection;
}
-
void wxGrid::ClearSelection()
{
m_selectingTopLeft = wxGridNoCellCoords;
left = right;
right = i;
i = leftCol;
- leftCol=rightCol;
+ leftCol = rightCol;
rightCol = i;
}
{
for ( i = leftCol; i <= rightCol; i++ )
{
- if ((j==topRow) || (j==bottomRow) || (i==leftCol) || (i==rightCol))
+ if ((j == topRow) || (j == bottomRow) || (i == leftCol) || (i == rightCol))
{
cellRect = CellToRect( j, i );
if (cellRect.y + cellRect.height > bottom)
bottom = cellRect.y + cellRect.height;
}
- else i = rightCol; // jump over inner cells.
+ else
+ {
+ i = rightCol; // jump over inner cells.
+ }
}
}
projects / wxWidgets.git / blobdiff