void wxlCanObj::Draw( wxDC& dc, double absx, double absy )
{
if ( m_brush.Ok() )
dc.SetBrush( m_brush );
if ( m_pen.Ok() )
dc.SetPen( m_pen );
wxBrush currentBrush = dc.GetBrush();
wxPen currentPen = dc.GetPen();
absx += m_x;
absy += m_y;
DoDraw( dc, absx, absy );
// iterate over the child list
for ( wxlCanObjList::Node *node = m_objects.GetFirst(); node; node = node->GetNext() )
{
wxlCanObj *drawobj = node->GetData();
// restore brush and pen
dc.SetBrush( currentBrush );
dc.SetPen( currentPen );
drawobj->Draw( dc , absx, absy );
}
}
bool RedHatchDrawlet::Draw(wxDC &dc)
{
#if wxCHECK_VERSION(2, 9, 0)
wxRasterOperationMode old_lf = dc.GetLogicalFunction();
#else
int old_lf = dc.GetLogicalFunction();
#endif
dc.SetLogicalFunction(wxXOR);
wxPen old_pen = dc.GetPen();
wxBrush old_brush = dc.GetBrush();
wxColor red = wxColor( ~wxRED->Red(), ~wxRED->Green(), ~wxRED->Blue());
#if wxCHECK_VERSION(2,9,0)
wxBrush brush = wxBrush(red, wxHATCHSTYLE_CROSSDIAG );
#else
wxBrush brush = wxBrush(red, wxCROSSDIAG_HATCH );
#endif
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(brush);
dc.DrawRectangle(m_rect);
dc.SetLogicalFunction(old_lf);
dc.SetPen(old_pen);
dc.SetBrush(old_brush);
return true;
}
// For some reason, drawing a rectangle on a memory DC has problems.
// Use this substitute if we can.
static void wxDrawRectangle(wxDC& dc, wxCoord x, wxCoord y, wxCoord width, wxCoord height)
{
wxBrush brush(dc.GetBrush());
wxPen pen(dc.GetPen());
if (brush.Ok() && brush.GetStyle() != wxTRANSPARENT)
{
HBRUSH hBrush = (HBRUSH) brush.GetResourceHandle() ;
if (hBrush)
{
RECT rect;
rect.left = x;
rect.top = y;
rect.right = x + width - 1;
rect.bottom = y + height - 1;
::FillRect((HDC) dc.GetHDC(), &rect, hBrush);
}
}
width --;
height --;
if (pen.Ok() && pen.GetStyle() != wxTRANSPARENT)
{
dc.DrawLine(x, y, x + width, y);
dc.DrawLine(x, y, x, y + height);
dc.DrawLine(x, y+height, x+width, y + height);
dc.DrawLine(x+width, y+height, x+width, y);
}
}
/* 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 CPathItem::DrawBG(wxDC &dc, wxRect &rc)
{
wxPen oldpen = dc.GetPen();
wxPen pen( IsSelected() ? *wxBLACK_PEN : *wxMEDIUM_GREY_PEN );
pen.SetWidth(IsSelected() ? 2 : 1);
dc.SetPen( pen );
wxBrush oldBrush = dc.GetBrush();
wxBrush brush(m_color, NULL!=m_pInput ? wxSOLID : wxTRANSPARENT);
dc.SetBrush(brush);
int x = rc.GetX();
int y = rc.GetY();
int w = rc.GetWidth();
int h = rc.GetHeight();
int n = 0;
wxPoint points[6];
if(NULL != m_pInput)
{
points[0] = wxPoint(x, y);
points[1] = wxPoint(x+w-GAP_LENGTH, y);
points[2] = wxPoint(x+w+CORNER_LENGTH-GAP_LENGTH, y+h/2);
points[3] = wxPoint(x+w-GAP_LENGTH, y+h);
points[4] = wxPoint(x, y+h);
points[5] = wxPoint(x+CORNER_LENGTH, y+h/2);
n = m_bFirst ? 5 : 6;
}
else
{
// Last component: mixer
points[0] = wxPoint(x, y);
points[1] = wxPoint(x+w, y);
points[2] = wxPoint(x+w, y+h);
points[3] = wxPoint(x, y+h);
points[4] = wxPoint(x+CORNER_LENGTH, y+h/2);
n = 5;
}
if(m_pRegion)
delete m_pRegion;
m_pRegion = new wxRegion(n, points);
dc.DrawPolygon(n, points);
dc.SetBrush( oldBrush );
dc.SetPen(oldpen);
}
void FloorTruss::draw(wxDC &dc, unsigned left, unsigned top, unsigned right,
unsigned bottom) {
// Trusses should be drawn 6" from the left side.
float six_inches = (right-left) / (60.0f*2);
float one_inch = (right-left) / 60.0f / 12.0f;
unsigned px_width = one_inch * width;
unsigned px_height = one_inch * height;
const wxBrush &old_brush = dc.GetBrush();
dc.SetBrush(*wxGREY_BRUSH);
dc.DrawRectangle(left + six_inches, bottom - px_height, px_width+1,
px_height+1);
dc.SetBrush(old_brush);
}
void CFloopyControl::DrawBG(wxDC& dc, wxRect& rc)
{
wxBrush oldBrush = dc.GetBrush();
wxPen oldpen = dc.GetPen();
wxPen pen( *wxLIGHT_GREY );
pen.SetWidth(1);
dc.SetPen( pen );
wxBrush brush(GetParent()->GetColor(), wxSOLID);
dc.SetBrush(brush);
dc.DrawRoundedRectangle(rc.GetX(), rc.GetTop(),
rc.GetWidth(), rc.GetHeight(), 2);
dc.SetPen(oldpen);
dc.SetBrush( oldBrush );
}
//---------------------------------------------------------
inline void CWKSP_Layer_Legend::_Draw_Box(wxDC &dc, int y, int dy, wxColour Color)
{
wxPen Pen;
wxBrush Brush;
//-----------------------------------------------------
_Set_Size(0, dy);
dy -= BOX_SPACE;
//-----------------------------------------------------
if( m_Box_bOutline == false )
{
Pen = dc.GetPen();
Pen.SetColour(Color);
dc.SetPen(Pen);
}
if( m_Box_bFill )
{
Brush = dc.GetBrush();
Brush.SetColour(Color);
dc.SetBrush(Brush);
}
//-----------------------------------------------------
switch( m_BoxStyle )
{
case BOXSTYLE_LINE:
dc.DrawLine(m_xBox , y + dy / 2, m_xBox + m_dxBox / 4, y);
dc.DrawLine(m_xBox + m_dxBox / 4, y , m_xBox + 3 * m_dxBox / 4, y + dy);
dc.DrawLine(m_xBox + 3 * m_dxBox / 4, y + dy , m_xBox + m_dxBox , y + dy / 2);
break;
case BOXSTYLE_CIRCLE:
dc.DrawCircle(m_xBox + m_dxBox / 2, y + dy / 2, dy / 2);
break;
case BOXSTYLE_RECT: default:
dc.DrawRectangle(m_xBox, y, m_dxBox, dy);
break;
}
}
void StateEvaluationTreePanel::drawIndicatorAtArea(wxDC &DC,
IndicatorStyle const &Style,
wxCoord X, wxCoord Y,
wxCoord W, wxCoord H)
{
auto const Kind = Style.GetKind();
auto const FG = Style.GetForeground();
wxPen const PrevPen = DC.GetPen();
wxBrush const PrevBrush = DC.GetBrush();
switch (Kind) {
case IndicatorStyle::EKind::Plain:
DC.SetPen(wxPen{FG, Settings.PenWidth});
DC.DrawLine(X, Y+H, X+W, Y+H);
break;
case IndicatorStyle::EKind::Box:
DC.SetPen(wxPen{FG, Settings.PenWidth});
DC.DrawRectangle(X, Y, W, H);
break;
case IndicatorStyle::EKind::StraightBox:
// Many DCs don't support alpha at all, so manually calculate an alpha
// against the background colour.
auto const BG = PrevBrush.GetColour();
double const Alpha = (double)Style.GetAlpha() / 255;
double const OutlineAlpha = (double)Style.GetOutlineAlpha() / 255;
DC.SetPen(wxPen{
wxColour(wxColour::AlphaBlend(FG.Red(), BG.Red(), OutlineAlpha),
wxColour::AlphaBlend(FG.Green(), BG.Green(), OutlineAlpha),
wxColour::AlphaBlend(FG.Blue(), BG.Blue(), OutlineAlpha)),
Settings.PenWidth});
DC.SetBrush(wxBrush{
wxColour(wxColour::AlphaBlend(FG.Red(), BG.Red(), Alpha),
wxColour::AlphaBlend(FG.Green(), BG.Green(), Alpha),
wxColour::AlphaBlend(FG.Blue(), BG.Blue(), Alpha))});
DC.DrawRectangle(X, Y, W, H);
break;
}
DC.SetPen(PrevPen);
DC.SetBrush(PrevBrush);
}
void DrawingUtils::PaintStraightGradientBox(wxDC& dc,
const wxRect& rect,
const wxColour& startColor,
const wxColour& endColor,
bool vertical)
{
int rd, gd, bd, high = 0;
rd = endColor.Red() - startColor.Red();
gd = endColor.Green() - startColor.Green();
bd = endColor.Blue() - startColor.Blue();
/// Save the current pen and brush
wxPen savedPen = dc.GetPen();
wxBrush savedBrush = dc.GetBrush();
if ( vertical )
high = rect.GetHeight()-1;
else
high = rect.GetWidth()-1;
if ( high < 1 )
return;
for (int i = 0; i <= high; ++i) {
int r = startColor.Red() + ((i*rd*100)/high)/100;
int g = startColor.Green() + ((i*gd*100)/high)/100;
int b = startColor.Blue() + ((i*bd*100)/high)/100;
wxPen p(wxColor(r, g, b));
dc.SetPen(p);
if ( vertical )
dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
else
dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
}
/// Restore the pen and brush
dc.SetPen( savedPen );
dc.SetBrush( savedBrush );
}
void ColourGridCellRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected)
{
//Call base class to clear the full drawing area and render the string
OffsetStringGridCellRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
//Get the old state
wxBrush oldBrush = dc.GetBrush();
wxPen oldPen = dc.GetPen();
//Set the new state
dc.SetBrush(wxBrush(renderColour));
dc.SetPen(wxPen(*wxBLACK));
//Render the color box
wxRect renderRect = wxRect(rect.x + 5,rect.y + 1, 17, 14).Intersect(rect);
dc.DrawRectangle(renderRect);
//Restore the old state
dc.SetBrush(oldBrush);
dc.SetPen(oldPen);
}
void SkinColor::Fill(wxDC& dc, const wxRect& rect)
{
if (IsOpaque()) {
if (rounded)
dc.DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, rounded);
else
dc.DrawRectangle(rect);
} else {
#if __WXMSW__
wxGraphicsContext* gc = wxGraphicsContext::Create(dc);
gc->SetBrush(dc.GetBrush());
gc->SetPen(*wxTRANSPARENT_PEN);
if (rounded)
gc->DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, rounded);
else
gc->DrawRectangle(rect.x, rect.y, rect.width, rect.height);
delete gc;
#endif
}
}
void TLView::SetBrushColour( wxDC& dc, wxColour colour )
{
wxBrush brush1 = dc.GetBrush();
brush1.SetColour( colour );
dc.SetBrush( brush1 );
}
void CLabel::DrawBG(wxDC& dc, wxRect& rc)
{
CTrack *track = getTrack();
m_rcLabel = rc;
wxBrush oldBrush = dc.GetBrush();
wxPen oldpen = dc.GetPen();
wxPen pen( *wxMEDIUM_GREY_PEN );
pen.SetWidth(1);
dc.SetPen( pen );
//wxBrush brush(m_color, (IsSelected() ? wxCROSSDIAG_HATCH : wxSOLID));
wxBrush brush(track->GetBGColor(), wxSOLID);
dc.SetBrush(brush);
int left, top, width, height;
if(m_bDrawAquaBG)
{
// Draw aqua background
left = 0;
top = rc.GetTop();
width = rc.GetWidth()-left;
height = rc.GetHeight();
//dc.DrawRectangle(left, top, width, height);
wxRect rc(left+1, top+1, width-2, height-2);
DrawAquaRect(dc, rc, 4);
}
else
{
// Draw background
left = 1;//m_nLevel*4+2;
top = rc.GetTop()+1;
width = rc.GetWidth()-1;//left-3;
height = rc.GetHeight()-2;
//dc.DrawRoundedRectangle(left, top, width, height, 4);
//DrawRect3D(dc, wxRect(left, top, width, height));
DrawRect3D(dc, rc);
}
dc.SetTextForeground( track->GetForeColor() );
wxFont oldFont = dc.GetFont();
wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
//wxFont font = oldFont;
//font.SetWeight(IsSelected() ? wxBOLD : wxNORMAL);
//font.SetPointSize(GetHeight() / 4);
font.SetPointSize( 9 );
dc.SetFont(font);
//wxFont font(12, wxDEFAULT, wxITALIC, (IsSelected() ? wxBOLD : wxNORMAL));
//dc.SetFont(font);
////dc.SetFont((IsSelected() ? *wxITALIC_FONT : *wxNORMAL_FONT));
// Get text dimensions
wxCoord w=0, h=0;
wxString csName;
track->GetName(csName);
dc.GetTextExtent(csName, &w, &h);
/*int ptSize = GetHeight() / 2;
// Get text dimensions
wxCoord w=0, h=0;
do {
font.SetPointSize(ptSize);
dc.GetTextExtent(m_name, &w, &h);
ptSize--;
} while (w>width && ptSize > 5);*/
// Draw text
int x = left + 5;//width/2 - w/2;
int y = (rc.GetTop() + (rc.GetHeight()/4) - h/2);
dc.DrawText( csName, x, y );
m_rcLabel.SetHeight(rc.GetHeight());
/*
int n = rc.GetHeight()/2-2;
if(n > 20)
n = 20;
drawLoopSign(dc, wxRect(5, top+height-n-2, n, n));
drawCacheSign(dc, wxRect(n+5+1, top+height-n-2, n, n));
*/
wxRect rcTmp = getPathRect(rc);
m_pPathCtrl->DrawBG(dc, rcTmp);
dc.SetFont(oldFont);
dc.SetPen(oldpen);
dc.SetBrush( oldBrush );
}
//---------------------------------------------------------
void CWKSP_Layer_Legend::_Draw_Point(wxDC &dc, CWKSP_Shapes_Point *pLayer)
{
bool bSize;
int min_Size, max_Size;
double min_Value, d_Value;
wxString Name, Name_Size;
wxPen Pen;
wxBrush Brush;
//-----------------------------------------------------
m_BoxStyle = BOXSTYLE_CIRCLE;
m_Box_bFill = true;
//-----------------------------------------------------
bSize = pLayer->Get_Style_Size(min_Size, max_Size, min_Value, d_Value, &Name_Size);
pLayer->Get_Style(Pen, Brush, m_Box_bOutline, &Name);
if( m_pClassify->Get_Mode() != CLASSIFY_UNIQUE || !bSize )
{
dc.SetBrush(Brush);
dc.SetPen(Pen);
if( Name.Length() > 0 )
{
_Draw_Title(dc, FONT_SUBTITLE, Name);
}
// _Draw_Boxes(dc, m_Position.y);
for(int i=m_pClassify->Get_Class_Count()-1, y=m_Position.y; i>=0; i--, y+=BOX_HEIGHT)
{
// _Draw_Box (dc, y, BOX_HEIGHT, Get_Color_asWX(m_pClassify->Get_Class_Color(i)));
_Set_Size(0, BOX_HEIGHT);
if( m_Box_bOutline == false )
{
Pen = dc.GetPen();
Pen.SetColour(Get_Color_asWX(m_pClassify->Get_Class_Color(i)));
dc.SetPen(Pen);
}
if( m_Box_bFill )
{
Brush = dc.GetBrush();
Brush.SetColour(Get_Color_asWX(m_pClassify->Get_Class_Color(i)));
dc.SetBrush(Brush);
}
pLayer->Draw_Symbol(dc, m_xBox + m_dxBox / 2, y + (BOX_HEIGHT - BOX_SPACE) / 2, (BOX_HEIGHT - BOX_SPACE) / 2);
_Draw_Label(dc, y, m_pClassify->Get_Class_Name(i), TEXTALIGN_TOP);
}
}
//-----------------------------------------------------
if( bSize )
{
dc.SetBrush(Brush);
dc.SetPen(Pen);
_Draw_Title(dc, FONT_SUBTITLE, Name_Size);
_Draw_Point_Sizes(dc, pLayer, min_Size, max_Size, min_Value, d_Value);
_Set_Size(0, SIZE_HEIGHT + dc.GetFont().GetPointSize());
}
}
void DataLayer::renderDC(wxDC& dc, PixelWorld& px)
{
Series& xdata = *(xdata_);
Series& ydata = *(ydata_);
auto savepen = dc.GetPen();
wxPen colpen(symbolBorder_);
dc.SetPen(colpen);
auto savefill = dc.GetBrush();
wxBrush fill(symbolFill_);
dc.SetBrush(fill);
const double& xscale = px.xScale_.scale_;
const double& yscale = px.yScale_.scale_;
const double& xoffset = px.xScale_.offset_;
const double& yoffset = px.yScale_.offset_;
const int radius = (this->symbolSize_)*2 + 1;
// draw lines first
wxPenStyle linepen = indexToPenStyle(lineStyle_);
wxRect clip(px.left_,px.top_, px.xspan_, px.yspan_);
{
if ((lineWidth_ > 0) && (linepen != wxPENSTYLE_TRANSPARENT))
{
wxPen linePen(lineColor_, lineWidth_, linepen);
auto savePen = dc.GetPen();
dc.SetPen(linePen);
dc.SetClippingRegion(clip);
int xprev = 0;
int yprev = 0;
for(size_t i = 0; i < xdata.size(); i++)
{
auto x = xdata[i];
auto y = ydata[i];
if (std::isnan(x) || std::isnan(y))
continue;
auto xpt = (int)( (x-xoffset)* xscale ) + px.left_;
auto ypt = (int)( (y-yoffset)* yscale ) + px.top_;
if (i > 0)
{
dc.DrawLine(xprev,yprev,xpt,ypt);
}
xprev = xpt;
yprev = ypt;
}
dc.SetPen(savePen);
}
auto sdraw = SymbolDraw::MakeSymbolDraw((PlotShape)symbolShape_, radius, dc);
wxPen sympen(this->symbolBorder_, 1, wxPENSTYLE_SOLID);
dc.SetPen(sympen);
dc.SetClippingRegion(clip);
auto errors = errorbar_;
for(size_t i = 0; i < xdata.size(); i++)
{
auto x = xdata[i];
auto y = ydata[i];
if (std::isnan(x) || std::isnan(y))
continue;
auto xpt = (int)( (x-xoffset)* xscale ) + px.left_;
auto ypt = (int)( (y-yoffset)* yscale ) + px.top_;
sdraw->draw(xpt,ypt);
if (errors != nullptr)
{
auto errorSize = (*errors)[i];
auto ept = (int)( errorSize*yscale);
dc.DrawLine(xpt,ypt-ept,xpt,ypt+ept);
dc.DrawLine(xpt-radius,ypt-ept,xpt+radius, ypt-ept);
dc.DrawLine(xpt-radius,ypt+ept,xpt+radius, ypt+ept);
}
}
}
dc.SetBrush(savefill);
dc.SetPen(savepen);
dc.DestroyClippingRegion();
}
//---------------------------------------------------------
void CWKSP_Layer_Legend::Draw(wxDC &dc, double Zoom, double Zoom_Map, wxPoint Position, wxSize *pSize, bool bVertical)
{
//-----------------------------------------------------
m_Zoom = Zoom > 0.0 ? Zoom : 1.0;
m_Position = Position;
m_Size = wxSize(BOX_WIDTH, 0);
m_Zoom_Map = Zoom_Map;
m_bVertical = bVertical;
//-----------------------------------------------------
m_oldPen = dc.GetPen();
m_oldBrush = dc.GetBrush();
m_oldFont = dc.GetFont();
//-----------------------------------------------------
m_xBox = m_Position.x;
m_dxBox = BOX_WIDTH;
m_xTick = m_xBox + m_dxBox;
m_dxTick = TICK_WIDTH;
m_xText = m_xTick + m_dxTick;
//-----------------------------------------------------
_Draw_Title(dc, FONT_TITLE, m_pLayer->Get_Object()->Get_Name());
//-----------------------------------------------------
switch( m_pLayer->Get_Type() )
{
case WKSP_ITEM_Shapes:
switch( ((CWKSP_Shapes *)m_pLayer)->Get_Shapes()->Get_Type() )
{
case SHAPE_TYPE_Point:
case SHAPE_TYPE_Points:
_Draw_Point (dc, (CWKSP_Shapes_Point *)m_pLayer);
break;
case SHAPE_TYPE_Line:
_Draw_Line (dc, (CWKSP_Shapes_Line *)m_pLayer);
break;
case SHAPE_TYPE_Polygon:
_Draw_Polygon (dc, (CWKSP_Shapes_Polygon *)m_pLayer);
break;
default:
break;
}
break;
case WKSP_ITEM_TIN:
_Draw_TIN (dc, (CWKSP_TIN *)m_pLayer);
break;
case WKSP_ITEM_PointCloud:
// _Draw_TIN (dc, (CWKSP_PointCloud *)m_pLayer);
break;
case WKSP_ITEM_Grid:
_Draw_Grid (dc, (CWKSP_Grid *)m_pLayer);
break;
default:
break;
}
//-----------------------------------------------------
dc.SetPen (m_oldPen);
dc.SetBrush (m_oldBrush);
dc.SetFont (m_oldFont);
//-----------------------------------------------------
if( pSize )
{
*pSize = m_Size;
}
}
void StateEvaluationTreePanel::drawNode(wxDC &DC,
ColourScheme const &Scheme,
NodeInfo const &Node,
NodeDecoration const Decoration)
{
auto const CharWidth = DC.GetCharWidth();
auto const CharHeight = DC.GetCharHeight();
wxCoord const PageBorderV = CharHeight * Settings.PageBorderVertical;
// Determine the indicator (if any).
IndicatorStyle const *Indicator = nullptr;
switch (Decoration) {
case NodeDecoration::None:
break;
case NodeDecoration::Active:
Indicator = &(Scheme.getActiveCode());
break;
case NodeDecoration::Highlighted:
Indicator = &(Scheme.getHighlightCode());
break;
}
// Set the background colour.
DC.SetPen(wxPen{Scheme.getDefault().GetForeground(), Settings.PenWidth});
DC.SetBrush(wxBrush{Scheme.getDefault().GetBackground()});
DC.SetTextForeground(Scheme.getDefault().GetForeground());
// Also highlight this node's area in the pretty-printed Stmt.
if (Indicator) {
drawIndicatorAtArea(DC, *Indicator,
Node.XStart, PageBorderV,
Node.XEnd - Node.XStart, CharHeight);
}
// Draw the background.
wxPen const PrevPen = DC.GetPen();
DC.SetPen(wxPen{DC.GetBrush().GetColour()});
DC.DrawRectangle(Node.XStart, Node.YStart,
Node.XEnd - Node.XStart, Node.YEnd - Node.YStart);
DC.SetPen(PrevPen);
// Draw the line over the node.
DC.DrawLine(Node.XStart, Node.YStart, Node.XEnd + 1, Node.YStart);
// Draw the base indicator on the node (if any).
if (Indicator) {
drawIndicatorAtArea(DC, *Indicator,
Node.XStart, Node.YStart,
Node.XEnd - Node.XStart, Node.YEnd - Node.YStart);
}
// Draw the error indicator if the node has an error.
if (Node.Error == NodeError::Error) {
drawIndicatorAtArea(DC, Scheme.getErrorCode(),
Node.XStart, Node.YStart,
Node.XEnd - Node.XStart, Node.YEnd - Node.YStart);
}
// Draw the node's value string.
if (Node.Value) {
auto const ValText = Node.ValueStringShort;
auto const TextWidth = CharWidth * ValText.size();
auto const NodeWidth = CharWidth * Node.RangeLength;
auto const Offset = (NodeWidth - TextWidth) / 2;
DC.DrawText(ValText, Node.XStart + Offset, Node.YStart);
}
}
