wxSize TimeRenderer::GetBestSize(wxGrid &grid,
wxGridCellAttr & WXUNUSED(attr),
wxDC & WXUNUSED(dc),
int row,
int col)
{
wxGridTableBase *table = grid.GetTable();
TimeEditor *te = (TimeEditor *) grid.GetCellEditor(row, col);
wxSize sz;
if (te) {
double value;
table->GetValue(row, col).ToDouble(&value);
NumericTextCtrl tt(NumericConverter::TIME, &grid,
wxID_ANY,
te->GetFormat(),
value,
te->GetRate(),
wxPoint(10000, 10000), // create offscreen
wxDefaultSize,
true);
sz = tt.GetSize();
te->DecRef();
}
return sz;
}
wxSize NumericRenderer::GetBestSize(wxGrid &grid,
wxGridCellAttr & WXUNUSED(attr),
wxDC & WXUNUSED(dc),
int row,
int col)
{
wxGridTableBase *table = grid.GetTable();
NumericEditor *ne =
static_cast<NumericEditor *>(grid.GetCellEditor(row, col));
wxSize sz;
if (ne) {
double value;
table->GetValue(row, col).ToDouble(&value);
NumericTextCtrl tt(mType, &grid,
wxID_ANY,
ne->GetFormat(),
value,
ne->GetRate(),
wxPoint(10000, 10000), // create offscreen
wxDefaultSize,
true);
sz = tt.GetSize();
ne->DecRef();
}
return sz;
}
void wxGridCellRenderer::Draw(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rect,
int WXUNUSED(row), int WXUNUSED(col),
bool isSelected)
{
dc.SetBackgroundMode( wxBRUSHSTYLE_SOLID );
wxColour clr;
if ( grid.IsThisEnabled() )
{
if ( isSelected )
{
if ( grid.HasFocus() )
clr = grid.GetSelectionBackground();
else
clr = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW);
}
else
{
clr = attr.GetBackgroundColour();
}
}
else // grey out fields if the grid is disabled
{
clr = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
}
dc.SetBrush(clr);
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle(rect);
}
wxSize TimeRenderer::GetBestSize(wxGrid &grid,
wxGridCellAttr &attr,
wxDC &dc,
int row,
int col)
{
wxGridTableBase *table = grid.GetTable();
TimeEditor *te = (TimeEditor *) grid.GetCellEditor(row, col);
wxSize sz;
if (te) {
double value;
table->GetValue(row, col).ToDouble(&value);
TimeTextCtrl tt(&grid,
wxID_ANY,
wxT(""),
value,
te->GetRate(),
wxPoint(10000, 10000), // create offscreen
wxDefaultSize,
true);
tt.SetFormatString(tt.GetBuiltinFormat(te->GetFormat()));
sz = tt.GetSize();
te->DecRef();
}
return sz;
}
/* draws alternating background colours */
void CBOINCGridCellRenderer::DrawBackground(wxGrid& grid,
wxDC& dc,
const wxRect& rect,
int row,
bool isSelected)
{
dc.SetBackgroundMode( wxSOLID );
// grey out fields if the grid is disabled
if( grid.IsEnabled() )
{
if ( isSelected )
{
dc.SetBrush( wxBrush(grid.GetSelectionBackground(), wxSOLID) );
}
else
{
//alternate background colours
if(row % 2 == 0) {
dc.SetBrush(wxBrush(wxColour(240,240,240)));
}
else {
dc.SetBrush(*wxWHITE_BRUSH);
}
}
}
else
{
dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE), wxSOLID));
}
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle(rect);
}
/**
* @brief Returns 0-based index of the first free row in the grid
*/
int firstFreeRow(const wxGrid &grid) {
using cit = boost::counting_iterator<int>;
const auto size = grid.GetNumberRows();
const auto row = find_if(cit(0), cit(size), [&grid](int x) {
return "" == grid.GetCellValue(x, 0) && "" == grid.GetCellValue(x, 1);
});
return *row;
}
/* paints the progress bar */
void CBOINCGridCellProgressRenderer::DoProgressDrawing(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rectCell, int row, int col, bool isSelected) {
wxRect rect = rectCell;
rect.Inflate(-1);
// erase only this cells background, overflow cells should have been erased
this->DrawBackground(grid, dc, rectCell, row, isSelected);
// set text attributes
int hAlign, vAlign;
attr.GetAlignment(&hAlign, &vAlign);
SetTextColoursAndFont(grid, attr, dc, isSelected);
//calculate the two parts of the progress rect
//
double dv = 0.0;
wxString strValue = grid.GetCellValue(row,col);
if(m_bDoPercentAppending) {
strValue = strValue + wxT(" %");
}
// Project view uses the format: %0.0f (%0.2f%%)
// Everyone else uses: %.3f%%
if (strValue.Find(wxT("(")) != wxNOT_FOUND) {
strValue.SubString(strValue.Find(wxT("(")) + 1, strValue.Find(wxT(")")) - 1).ToDouble( &dv );
} else {
strValue.ToDouble ( &dv ); // NOTE: we should do error-checking/reporting here!!
}
wxRect p1(rect);
wxRect p2(rect);
int r = (int)((rect.GetRight()-rect.GetLeft())*dv / 100.0);
p1.SetRight(rect.GetLeft()+r);
p2.SetLeft(rect.GetLeft()+r+1);
p2.SetRight(rect.GetRight()-1);
//start drawing
dc.SetClippingRegion(rect);
wxBrush old = dc.GetBrush();
wxColour progressColour = wxTheColourDatabase->Find(wxT("LIGHT BLUE"));
wxBrush* progressBrush = wxTheBrushList->FindOrCreateBrush(progressColour);
wxPen* progressPen = wxThePenList->FindOrCreatePen(progressColour,1,wxSOLID);
//draw the outline rectangle
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.SetPen(*progressPen);
dc.DrawRectangle(rect);
// Draw the left part
dc.SetBrush(*progressBrush);
dc.DrawRectangle(p1);
//draw the right part
dc.SetBrush(old);
dc.DrawRectangle(p2);
//
dc.DestroyClippingRegion();
// draw the text
grid.DrawTextRectangle(dc, strValue, rect, hAlign, vAlign);
}
void CellRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected)
{
dc.SetClippingRegion(rect);
wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, false);
if( m_Renderer != NULL && imageName != NULL && StrOp.len(imageName) > 0 ) {
int cx = 0;
int cy = 0;
if( imageBitmap == NULL ) {
wxMemoryDC tmpDC;
m_Renderer->sizeSvgSym( imageName, wItem.west, &cx, &cy );
if( imageBitmap != NULL )
delete imageBitmap;
imageBitmap = new wxBitmap();
imageBitmap->Create(cx * 32 * m_Scale, cy * 32 * m_Scale , -1);
tmpDC.SelectObject(*imageBitmap);
tmpDC.SetBackground(*wxWHITE_BRUSH);
tmpDC.Clear();
tmpDC.SetUserScale( m_Scale, m_Scale );
m_Renderer->drawSvgSym( (wxPaintDC&)tmpDC, 0, 0, imageName, wItem.west, &cx, &cy );
tmpDC.SelectObject(wxNullBitmap);
m_RowSize = cy * 32 * m_Scale + 4;
if( grid.GetColSize(col) < cx * 32 * m_Scale )
grid.SetColSize(col, cx * 32 * m_Scale );
if( grid.GetRowSize(row) < m_RowSize )
grid.SetRowSize(row, m_RowSize );
TraceOp.trc( "cellrenderer", TRCLEVEL_DEBUG, __LINE__, 9999, "image: %s dc=%X row=%d col=%d cx=%d cy=%d rowsize=%d", imageName,
&dc, row, col, cx, cy, m_RowSize );
}
dc.DrawBitmap(*imageBitmap, rect.x, rect.y + 2);
}
else if( imageName != NULL && StrOp.len(imageName) > 0 ) {
if( imageBitmap == NULL )
updateImage(rect);
if( imageBitmap != NULL ) {
dc.DrawBitmap(*imageBitmap, rect.x, rect.y);
if( !m_bDidResize ) {
grid.AutoSizeColumn(col);
m_bDidResize = true;
}
}
}
dc.DestroyClippingRegion();
}
wxSize
wxGridCellAutoWrapStringRenderer::GetBestSize(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
int row, int col)
{
wxCoord x,y, height , width = grid.GetColSize(col) -20;
// for width, subtract 20 because ColSize includes a magin of 10 pixels
// that we do not want here and because we always start with an increment
// by 10 in the loop below.
int count = 250; //Limit iterations..
wxRect rect(0,0,width,10);
// M is a nice large character 'y' gives descender!.
dc.GetTextExtent(wxT("My"), &x, &y);
do
{
width+=10;
rect.SetWidth(width);
height = y * (wx_truncate_cast(wxCoord, GetTextLines(grid,dc,attr,rect,row,col).GetCount()));
count--;
// Search for a shape no taller than the golden ratio.
} while (count && (width < (height*1.68)) );
return wxSize(width,height);
}
wxSize
wxGridCellAutoWrapStringRenderer::GetBestSize(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
int row, int col)
{
wxCoord x,y, height , width = grid.GetColSize(col) -10;
int count = 250; //Limit iterations..
wxRect rect(0,0,width,10);
// M is a nice large character 'y' gives descender!.
dc.GetTextExtent(wxT("My"), &x, &y);
do
{
width+=10;
rect.SetWidth(width);
height = y * (wx_truncate_cast(wxCoord, GetTextLines(grid,dc,attr,rect,row,col).GetCount()));
count--;
// Search for a shape no taller than the golden ratio.
} while (count && (width < (height*1.68)) );
return wxSize(width,height);
}
wxSize wxGridCellStringRenderer::GetBestSize(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
int row, int col)
{
return DoGetBestSize(attr, dc, grid.GetCellValue(row, col));
}
wxString wxGridCellDateTimeRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
bool hasDatetime = false;
wxDateTime val;
wxString text;
if ( table->CanGetValueAs(row, col, wxGRID_VALUE_DATETIME) )
{
void * tempval = table->GetValueAsCustom(row, col,wxGRID_VALUE_DATETIME);
if (tempval)
{
val = *((wxDateTime *)tempval);
hasDatetime = true;
delete (wxDateTime *)tempval;
}
}
if (!hasDatetime )
{
text = table->GetValue(row, col);
const char * const end = val.ParseFormat(text, m_iformat, m_dateDef);
hasDatetime = end && !*end;
}
if ( hasDatetime )
text = val.Format(m_oformat, m_tz );
// If we failed to parse string just show what we where given?
return text;
}
wxArrayString
wxGridCellAutoWrapStringRenderer::GetTextLines(wxGrid& grid,
wxDC& dc,
const wxGridCellAttr& attr,
const wxRect& rect,
int row, int col)
{
dc.SetFont(attr.GetFont());
const wxCoord maxWidth = rect.GetWidth();
// Transform logical lines into physical ones, wrapping the longer ones.
const wxArrayString
logicalLines = wxSplit(grid.GetCellValue(row, col), '\n', '\0');
wxArrayString physicalLines;
for ( wxArrayString::const_iterator it = logicalLines.begin();
it != logicalLines.end();
++it )
{
const wxString& line = *it;
if ( dc.GetTextExtent(line).x > maxWidth )
{
// Line does not fit, break it up.
BreakLine(dc, line, maxWidth, physicalLines);
}
else // The entire line fits as is
{
physicalLines.push_back(line);
}
}
return physicalLines;
}
wxString wxGridCellFloatRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
bool hasDouble;
double val;
wxString text;
if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
{
val = table->GetValueAsDouble(row, col);
hasDouble = true;
}
else
{
text = table->GetValue(row, col);
hasDouble = text.ToDouble(&val);
}
if ( hasDouble )
{
if ( !m_format )
{
if ( m_width == -1 )
{
if ( m_precision == -1 )
{
// default width/precision
m_format = wxT("%");
}
else
{
m_format.Printf(wxT("%%.%d"), m_precision);
}
}
else if ( m_precision == -1 )
{
// default precision
m_format.Printf(wxT("%%%d."), m_width);
}
else
{
m_format.Printf(wxT("%%%d.%d"), m_width, m_precision);
}
bool isUpper = ( ( m_style & wxGRID_FLOAT_FORMAT_UPPER ) == wxGRID_FLOAT_FORMAT_UPPER);
if ( ( m_style & wxGRID_FLOAT_FORMAT_SCIENTIFIC ) == wxGRID_FLOAT_FORMAT_SCIENTIFIC)
m_format += isUpper ? wxT('E') : wxT('e');
else if ( ( m_style & wxGRID_FLOAT_FORMAT_COMPACT ) == wxGRID_FLOAT_FORMAT_COMPACT)
m_format += isUpper ? wxT('G') : wxT('g');
else
m_format += wxT('f');
}
text.Printf(m_format, val);
}
//else: text already contains the string
return text;
}
wxArrayString
wxGridCellAutoWrapStringRenderer::GetTextLines(wxGrid& grid,
wxDC& dc,
const wxGridCellAttr& attr,
const wxRect& rect,
int row, int col)
{
wxString data = grid.GetCellValue(row, col);
wxArrayString lines;
dc.SetFont(attr.GetFont());
//Taken from wxGrid again!
wxCoord x = 0, y = 0, curr_x = 0;
wxCoord max_x = rect.GetWidth();
dc.SetFont(attr.GetFont());
wxStringTokenizer tk(data , wxT(" \n\t\r"));
wxString thisline = wxEmptyString;
while ( tk.HasMoreTokens() )
{
wxString tok = tk.GetNextToken();
//FIXME: this causes us to print an extra unnecesary
// space at the end of the line. But it
// is invisible , simplifies the size calculation
// and ensures tokens are separated in the display
tok += wxT(" ");
dc.GetTextExtent(tok, &x, &y);
if ( curr_x + x > max_x)
{
if ( curr_x == 0 )
{
// this means that a single token is wider than the maximal
// width -- still use it as is as we need to show at least the
// part of it which fits
lines.Add(tok);
}
else
{
lines.Add(thisline);
thisline = tok;
curr_x = x;
}
}
else
{
thisline+= tok;
curr_x += x;
}
}
//Add last line
lines.Add( wxString(thisline) );
return lines;
}
void CBOINCGridCellMessageRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected) {
wxString szError(wxT("Error"));
if(grid.GetCellValue(row,column).Trim(false).IsSameAs(szError)) {
attr.SetTextColour(*wxRED);
}
else {
attr.SetTextColour(*wxBLACK);
}
CBOINCGridCellRenderer::Draw(grid,attr,dc,rect,row,col,isSelected);
}
wxString wxGridCellFloatRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
bool hasDouble;
double val;
wxString text;
if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
{
val = table->GetValueAsDouble(row, col);
hasDouble = true;
}
else
{
text = table->GetValue(row, col);
hasDouble = text.ToDouble(&val);
}
if ( hasDouble )
{
if ( !m_format )
{
if ( m_width == -1 )
{
if ( m_precision == -1 )
{
// default width/precision
m_format = wxT("%f");
}
else
{
m_format.Printf(wxT("%%.%df"), m_precision);
}
}
else if ( m_precision == -1 )
{
// default precision
m_format.Printf(wxT("%%%d.f"), m_width);
}
else
{
m_format.Printf(wxT("%%%d.%df"), m_width, m_precision);
}
}
text.Printf(m_format, val);
}
//else: text already contains the string
return text;
}
void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid& grid,
const wxGridCellAttr& attr,
wxDC& dc,
bool isSelected)
{
dc.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT );
// TODO some special colours for attr.IsReadOnly() case?
// different coloured text when the grid is disabled
if ( grid.IsThisEnabled() )
{
if ( isSelected )
{
wxColour clr;
if ( grid.HasFocus() )
clr = grid.GetSelectionBackground();
else
clr = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW);
dc.SetTextBackground( clr );
dc.SetTextForeground( grid.GetSelectionForeground() );
}
else
{
dc.SetTextBackground( attr.GetBackgroundColour() );
dc.SetTextForeground( attr.GetTextColour() );
}
}
else
{
dc.SetTextBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT));
}
dc.SetFont( attr.GetFont() );
}
wxString wxGridCellNumberRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
wxString text;
if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
{
text.Printf(wxT("%ld"), table->GetValueAsLong(row, col));
}
else
{
text = table->GetValue(row, col);
}
return text;
}
/* -------------------------- implementation place -------------------------- */
void CellRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected) {
#if 0
DocTable* t = (DocTable*)grid.GetTable();
if ( t->GetDocument().GetColumnDescriptor(t->Map(col)).IsRequired() && t->GetDocument().IsValidValue(row, t->Map(col))) {
attr.SetBackgroundColour(REQUIRED_COL);
} else if ( !t->GetDocument().IsValidValue(row, t->Map(col))) {
attr.SetBackgroundColour(NOT_VALID_COL);
} else {
attr.SetBackgroundColour(VALID_COL);
}
#endif
wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
};
wxString wxGridCellEnumRenderer::GetString(const wxGrid& grid, int row, int col)
{
wxGridTableBase *table = grid.GetTable();
wxString text;
if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
{
int choiceno = table->GetValueAsLong(row, col);
text.Printf(wxT("%s"), m_choices[ choiceno ].c_str() );
}
else
{
text = table->GetValue(row, col);
}
//If we faild to parse string just show what we where given?
return text;
}
void wxGridCellFloatRenderer::Draw(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rectCell,
int row, int col,
bool isSelected)
{
wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
SetTextColoursAndFont(grid, attr, dc, isSelected);
// draw the text right aligned by default
int hAlign = wxALIGN_RIGHT,
vAlign = wxALIGN_INVALID;
attr.GetNonDefaultAlignment(&hAlign, &vAlign);
wxRect rect = rectCell;
rect.Inflate(-1);
grid.DrawTextRectangle(dc, GetString(grid, row, col), rect, hAlign, vAlign);
}
ptree getMappingJsonSerialized(const wxGrid &grid) {
ptree root;
ptree mappingArray;
const int size = firstFreeRow(grid);
for (int i = 0; i < size; ++i) {
ptree child;
std::vector<std::string> strings2d;
std::vector<std::string> strings3d;
string cellValue2d = string(grid.GetCellValue(i, 0));
string cellValue3d = string(grid.GetCellValue(i, 1));
boost::split(strings2d, cellValue2d, boost::is_any_of(";"));
boost::split(strings3d, cellValue3d, boost::is_any_of(";"));
child.put("2d-X", strings2d[0]);
child.put("2d-Y", strings2d[1]);
child.put("3d-X", strings3d[0]);
child.put("3d-Y", strings3d[1]);
child.put("3d-Z", strings3d[2]);
mappingArray.push_back(make_pair("", child));
}
root.add_child("mapping", mappingArray);
return root;
}
void
wxGridCellAutoWrapStringRenderer::Draw(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rectCell,
int row, int col,
bool isSelected) {
wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
// now we only have to draw the text
SetTextColoursAndFont(grid, attr, dc, isSelected);
int horizAlign, vertAlign;
attr.GetAlignment(&horizAlign, &vertAlign);
wxRect rect = rectCell;
rect.Inflate(-1);
grid.DrawTextRectangle(dc, GetTextLines(grid,dc,attr,rect,row,col),
rect, horizAlign, vertAlign);
}
//------------------------------------------------------------------------------
// custom renderer
//------------------------------------------------------------------------------
void CustomRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected)
{
dc.SetPen(wxPen(attr.GetBackgroundColour(), 1));
dc.SetBrush(wxBrush( attr.GetBackgroundColour(), wxBRUSHSTYLE_SOLID ));
dc.DrawRectangle( rect );
if( m_IsDigit || m_dDir == GRIB_NOTDEF ) { //digital format
wxString text(wxEmptyString);
if( m_dDir != GRIB_NOTDEF )
text.Printf(_T("%03d\u00B0"), (int)m_dDir);
dc.DrawLabel(text, rect, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL);
} else { //graphical format
double si = sin( (m_dDir - 90) * M_PI / 180. );
double co = cos( (m_dDir - 90) * M_PI / 180. );
int i = rect.GetTopLeft().x + (rect.GetWidth() / 2);
int j = rect.GetTopLeft().y + (rect.GetHeight() / 2);
int arrowSize = rect.GetHeight() - 3;
int dec = -arrowSize / 2;
#if wxUSE_GRAPHICS_CONTEXT
wxGraphicsContext *gdc;
wxClientDC *cdc = new wxClientDC(wxDynamicCast( &grid, wxWindow));
cdc = wxDynamicCast(&dc, wxClientDC);
if( cdc ) {
gdc = wxGraphicsContext::Create(*cdc);
#ifdef __WXGTK__
/*platforms don't manage the same way the gdc origin
for linux, we have to re-compute the good one.
To DO : verify it works on all other plateforms (done for MSW*/
bool vis = false;
int r = 0;
for( int c = 0; c < grid.GetNumberCols(); c++){
for(r = 0; r < grid.GetNumberRows(); r++) {
if(grid.IsVisible(r, c)){ //find the first row/col
vis = true;
i -= (c * grid.GetColSize(0));
j -= (r * grid.GetRowHeight(0));
break;
}
}
if(vis) break;
}
#endif
gdc->SetPen(wxPen(attr.GetTextColour(), 3));
gdc->SetBrush(wxBrush( attr.GetBackgroundColour(), wxBRUSHSTYLE_SOLID ));
double ii, jj, kk, ll;
GetArrowsPoints( si, co, i, j, dec, 0, dec + arrowSize, 0, ii, jj, kk, ll );
gdc->StrokeLine( ii, jj, kk, ll );
GetArrowsPoints( si, co, i, j, dec - 3, 0, dec + 5, 3, ii, jj, kk, ll );
gdc->StrokeLine( ii, jj, kk, ll );
GetArrowsPoints( si, co, i, j, dec - 3, 0, dec + 5, -3, ii, jj, kk, ll );
gdc->StrokeLine( ii, jj, kk, ll );
delete gdc;
} else
#endif
{
dc.SetPen(wxPen(attr.GetTextColour(), 3));
double ii, jj, kk, ll;
GetArrowsPoints( si, co, i, j, dec, 0, dec + arrowSize, 0, ii, jj, kk, ll );
dc.DrawLine( (int)ii, (int)jj, (int)kk, (int)ll );
GetArrowsPoints( si, co, i, j, dec - 3, 0, dec + 5, 3, ii, jj, kk, ll );
dc.DrawLine( (int)ii, (int)jj, (int)kk, (int)ll );
GetArrowsPoints( si, co, i, j, dec - 3, 0, dec + 5, -3, ii, jj, kk, ll );
dc.DrawLine( (int)ii, (int)jj, (int)kk, (int)ll );
}
}
}
void wxGridCellChoiceRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
const wxRect& rectCell, int row, int col, bool isSelected)
{
wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
// first calculate button size
// don't draw outside the cell
int nButtonWidth = 17;
if (rectCell.height < 2) return;
wxRect rectButton;
rectButton.x = rectCell.x + rectCell.width - nButtonWidth;
rectButton.y = rectCell.y + 1;
int cell_rows, cell_cols;
attr.GetSize(&cell_rows, &cell_cols);
rectButton.width = nButtonWidth;
if (cell_rows == 1)
rectButton.height = rectCell.height-2;
else
rectButton.height = nButtonWidth;
SetTextColoursAndFont(grid, attr, dc, isSelected);
int hAlign, vAlign;
attr.GetAlignment(&hAlign, &vAlign);
// leave room for button
wxRect rect = rectCell;
rect.SetWidth(rectCell.GetWidth() - rectButton.GetWidth()-2);
rect.Inflate(-1);
grid.DrawTextRectangle(dc, grid.GetCellValue(row, col), rect, hAlign, vAlign);
// don't bother drawing if the cell is too small
if (rectButton.height < 4 || rectButton.width < 4) return;
// draw 3-d button
wxColour colourBackGround = wxColour(COLORBASE);
dc.SetBrush(wxBrush(colourBackGround, wxSOLID));
dc.SetPen(wxPen(colourBackGround, 1, wxSOLID));
dc.DrawRectangle(rectButton);
dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT), 1, wxSOLID));
dc.DrawLine(rectButton.GetLeft(), rectButton.GetBottom(),
rectButton.GetRight(), rectButton.GetBottom());
dc.DrawLine(rectButton.GetRight(), rectButton.GetBottom(),
rectButton.GetRight(), rectButton.GetTop()-1);
dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW),
1, wxSOLID));
dc.DrawLine(rectButton.GetLeft()+1, rectButton.GetBottom()-1,
rectButton.GetRight()-1, rectButton.GetBottom()-1);
dc.DrawLine(rectButton.GetRight()-1, rectButton.GetBottom()-1,
rectButton.GetRight()-1, rectButton.GetTop());
dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT),
1, wxSOLID));
dc.DrawLine(rectButton.GetRight()-2, rectButton.GetTop()+1,
rectButton.GetLeft()+1, rectButton.GetTop()+1);
dc.DrawLine(rectButton.GetLeft()+1, rectButton.GetTop()+1,
rectButton.GetLeft()+1, rectButton.GetBottom()-1);
// Draw little triangle
int nTriWidth = 7;
int nTriHeight = 4;
wxPoint point[3];
point[0] = wxPoint(rectButton.GetLeft() + (rectButton.GetWidth()-nTriWidth)/2,
rectButton.GetTop()+(rectButton.GetHeight()-nTriHeight)/2);
point[1] = wxPoint(point[0].x+nTriWidth-1, point[0].y);
point[2] = wxPoint(point[0].x+3, point[0].y+nTriHeight-1);
dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT), wxSOLID));
dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT), 1, wxSOLID));
dc.DrawPolygon(3, point);
if (m_border == wxLAYOUT_TOP)
{
dc.SetPen(wxPen(*wxBLACK, 1, wxDOT));
dc.DrawLine(rectCell.GetRight(), rectCell.GetTop(),
rectCell.GetLeft(), rectCell.GetTop());
}
}
void GlyphCellRenderer::Draw(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected)
{
wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, false);
wxString value = grid.GetTable()->GetValue(row, col);
wxString label;
auto it = glyphs.find(value);
if (it == glyphs.end()) return;
const SvgGlyph &glyph = it->second;
if (!glyph.IsOk())
return;
if (showGlyphNames) label = glyph.glyphName;
else label.Printf("%04x", glyph.unicode[0]);
std::unique_ptr<wxGraphicsContext> gc(wxGraphicsContext::Create(static_cast<wxPaintDC&>(dc)));
wxRect newRect = rect;
// replace with gc->GetRenderer()->GetName() == L"cairo" after wx 3.1
bool isCairo = false;
#if wxUSE_CAIRO
isCairo = true;
#endif
// Oh, crap
if (isCairo)
{
newRect.x += dc.GetDeviceOrigin().x;
newRect.y += dc.GetDeviceOrigin().y;
}
std::map<wxString, wxBitmap>::iterator findIt = glyphCache.find(glyph.unicode);
if (findIt == glyphCache.end())
{
bool result;
std::tie(findIt, result) = glyphCache.emplace(glyph.unicode, GetBitmapForGlyph(glyph, fontSize, glyphColor, attr.GetBackgroundColour(), false));
if (!result) return;
}
if (hlCellCoords.GetCol() == col && hlCellCoords.GetRow() == row)
{
gc->SetPen(wxPen(hlColor, 1));
gc->DrawRoundedRectangle(newRect.x + 1, newRect.y + 1, newRect.width - 2, newRect.height - 2, 5);
}
newRect.height -= labelFont.GetPixelSize().GetHeight() + 2 * padding;
const wxBitmap &glyphBitmap = findIt->second;
if (glyphBitmap.IsOk())
{
gc->DrawBitmap(glyphBitmap,
newRect.x + (newRect.width - glyphBitmap.GetWidth()) / 2,
newRect.y + (newRect.height - glyphBitmap.GetHeight()) / 2,
glyphBitmap.GetWidth(), glyphBitmap.GetHeight());
}
double maxTextWidth = std::max(0, newRect.width - 2);
double width, height, descent, externalLeading;
gc->SetFont(labelFont, labelColor);
gc->GetTextExtent(label, &width, &height, &descent, &externalLeading);
wxString origLabel = label;
size_t cutCntr = 1;
while (width > maxTextWidth && !label.IsEmpty())
{
label = origLabel.Left(origLabel.Length() - cutCntr++) + L"\u2026";
gc->GetTextExtent(label, &width, &height, &descent, &externalLeading);
}
gc->DrawText(label, newRect.x + (newRect.width - width) / 2, newRect.y + newRect.height + padding);
}
void wxGridCellBoolRenderer::Draw(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rect,
int row, int col,
bool isSelected)
{
wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
// draw a check mark in the centre (ignoring alignment - TODO)
wxSize size = GetBestSize(grid, attr, dc, row, col);
// don't draw outside the cell
wxCoord minSize = wxMin(rect.width, rect.height);
if ( size.x >= minSize || size.y >= minSize )
{
// and even leave (at least) 1 pixel margin
size.x = size.y = minSize;
}
// draw a border around checkmark
int vAlign, hAlign;
attr.GetAlignment(&hAlign, &vAlign);
wxRect rectBorder;
if (hAlign == wxALIGN_CENTRE)
{
rectBorder.x = rect.x + rect.width / 2 - size.x / 2;
rectBorder.y = rect.y + rect.height / 2 - size.y / 2;
rectBorder.width = size.x;
rectBorder.height = size.y;
}
else if (hAlign == wxALIGN_LEFT)
{
rectBorder.x = rect.x + 2;
rectBorder.y = rect.y + rect.height / 2 - size.y / 2;
rectBorder.width = size.x;
rectBorder.height = size.y;
}
else if (hAlign == wxALIGN_RIGHT)
{
rectBorder.x = rect.x + rect.width - size.x - 2;
rectBorder.y = rect.y + rect.height / 2 - size.y / 2;
rectBorder.width = size.x;
rectBorder.height = size.y;
}
bool value;
if ( grid.GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
{
value = grid.GetTable()->GetValueAsBool(row, col);
}
else
{
wxString cellval( grid.GetTable()->GetValue(row, col) );
value = wxGridCellBoolEditor::IsTrueValue(cellval);
}
int flags = 0;
if (value)
flags |= wxCONTROL_CHECKED;
wxRendererNative::Get().DrawCheckBox( &grid, dc, rectBorder, flags );
}
void TimeRenderer::Draw(wxGrid &grid,
wxGridCellAttr &attr,
wxDC &dc,
const wxRect &rect,
int row,
int col,
bool isSelected)
{
wxGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
wxGridTableBase *table = grid.GetTable();
TimeEditor *te = (TimeEditor *) grid.GetCellEditor(row, col);
wxString tstr;
if (te) {
double value;
table->GetValue(row, col).ToDouble(&value);
NumericTextCtrl tt(NumericConverter::TIME, &grid,
wxID_ANY,
te->GetFormat(),
value,
te->GetRate(),
wxPoint(10000, 10000), // create offscreen
wxDefaultSize,
true);
tstr = tt.GetString();
te->DecRef();
}
dc.SetBackgroundMode(wxTRANSPARENT);
if (grid.IsEnabled())
{
if (isSelected)
{
dc.SetTextBackground(grid.GetSelectionBackground());
dc.SetTextForeground(grid.GetSelectionForeground());
}
else
{
dc.SetTextBackground(attr.GetBackgroundColour());
dc.SetTextForeground(attr.GetTextColour());
}
}
else
{
dc.SetTextBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT));
}
dc.SetFont(attr.GetFont());
int hAlign, vAlign;
attr.GetAlignment(&hAlign, &vAlign);
grid.DrawTextRectangle(dc, tstr, rect, hAlign, vAlign);
}
void wxGridCellStringRenderer::Draw(wxGrid& grid,
wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rectCell,
int row, int col,
bool isSelected)
{
wxRect rect = rectCell;
rect.Inflate(-1);
// erase only this cells background, overflow cells should have been erased
wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected);
int hAlign, vAlign;
attr.GetAlignment(&hAlign, &vAlign);
int overflowCols = 0;
if (attr.GetOverflow())
{
int cols = grid.GetNumberCols();
int best_width = GetBestSize(grid,attr,dc,row,col).GetWidth();
int cell_rows, cell_cols;
attr.GetSize( &cell_rows, &cell_cols ); // shouldn't get here if <= 0
if ((best_width > rectCell.width) && (col < cols) && grid.GetTable())
{
int i, c_cols, c_rows;
for (i = col+cell_cols; i < cols; i++)
{
bool is_empty = true;
for (int j=row; j < row + cell_rows; j++)
{
// check w/ anchor cell for multicell block
grid.GetCellSize(j, i, &c_rows, &c_cols);
if (c_rows > 0)
c_rows = 0;
if (!grid.GetTable()->IsEmptyCell(j + c_rows, i))
{
is_empty = false;
break;
}
}
if (is_empty)
{
rect.width += grid.GetColSize(i);
}
else
{
i--;
break;
}
if (rect.width >= best_width)
break;
}
overflowCols = i - col - cell_cols + 1;
if (overflowCols >= cols)
overflowCols = cols - 1;
}
if (overflowCols > 0) // redraw overflow cells w/ proper hilight
{
hAlign = wxALIGN_LEFT; // if oveflowed then it's left aligned
wxRect clip = rect;
clip.x += rectCell.width;
// draw each overflow cell individually
int col_end = col + cell_cols + overflowCols;
if (col_end >= grid.GetNumberCols())
col_end = grid.GetNumberCols() - 1;
for (int i = col + cell_cols; i <= col_end; i++)
{
clip.width = grid.GetColSize(i) - 1;
dc.DestroyClippingRegion();
dc.SetClippingRegion(clip);
SetTextColoursAndFont(grid, attr, dc,
grid.IsInSelection(row,i));
grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
rect, hAlign, vAlign);
clip.x += grid.GetColSize(i) - 1;
}
rect = rectCell;
rect.Inflate(-1);
rect.width++;
dc.DestroyClippingRegion();
}
}
// now we only have to draw the text
SetTextColoursAndFont(grid, attr, dc, isSelected);
grid.DrawTextRectangle(dc, grid.GetCellValue(row, col),
rect, hAlign, vAlign);
}
