VuoErrorMark.cc

Go to the documentation of this file.

 
#include "VuoErrorMark.hh"
#include "VuoRendererCable.hh"
#include "VuoRendererFonts.hh"
#include "VuoRendererTypecastPort.hh"
 
VuoErrorMark::VuoErrorMark()
{
    setZValue(errorMarkZValue);
    this->errorMarkPath = QPainterPath();
}
 
void VuoErrorMark::addMarkedComponents(set<VuoRendererNode *> markedNodes, set<VuoRendererCable *> markedCables)
{
    foreach (VuoRendererNode *node, markedNodes)
        this->nodes.insert(node);
 
    foreach (VuoRendererCable *cable, markedCables)
        this->cables.insert(cable);
 
    updateErrorMarkPath();
}
 
QRectF VuoErrorMark::boundingRect(void) const
{
    QPainterPath errorMarkPath = getErrorMarkPath();
    QRectF r = errorMarkPath.boundingRect();
 
    // Antialiasing bleed
    r.adjust(-1,-1,1,1);
 
    return r.toAlignedRect();
}
 
void VuoErrorMark::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    // Workaround to prevent items that have been removed from the scene from being painted on the scene anyway.
    // https://b33p.net/kosada/node/8267
    if (!scene())
        return;
 
    drawBoundingRect(painter);
 
    QPainterPath path = getErrorMarkPath();
 
    VuoRendererColors colors;
    painter->fillPath(path, colors.errorMark());
}
 
void VuoErrorMark::removeFromScene()
{
    QGraphicsScene *itemScene = scene();
    if (itemScene)
    {
        this->prepareGeometryChange();
        itemScene->removeItem(this);
    }
}
 
void VuoErrorMark::updateErrorMarkPath(void)
{
    this->prepareGeometryChange();
 
    QPainterPath path;
    const qreal markWidth = VuoRendererFonts::thickPenWidth / 2.;
    const qreal cornerRadius = VuoRendererNode::cornerRadius + markWidth;
 
    foreach (VuoRendererNode *node, nodes)
    {
        QPainterPath nodeSimplifiedOutline;
 
        VuoRendererTypecastPort *typecastPort = node->getProxyCollapsedTypecast();
        if (typecastPort)
        {
            QRectF typecastPortRect = typecastPort->boundingRect();
            if (!typecastPortRect.isNull())
            {
                QPainterPath typecastPath;
                typecastPath.addRoundedRect( typecastPortRect.adjusted(-0.5*markWidth, -0.5*markWidth, 0.5*markWidth, 0.5*markWidth),
                                                      cornerRadius, cornerRadius );
                typecastPath.translate( typecastPort->scenePos() );
                path = path.united( typecastPath );
            }
        }
 
        else
        {
            QRectF nodeOuterFrameRect = node->boundingRect();
            if (!nodeOuterFrameRect.isNull())
            {
                nodeSimplifiedOutline.addRoundedRect( nodeOuterFrameRect.adjusted(-markWidth, -markWidth, markWidth, markWidth),
                                                      cornerRadius, cornerRadius );
 
                nodeSimplifiedOutline.translate( node->getBase()->getX(), node->getBase()->getY() );
                path = path.united( nodeSimplifiedOutline );
            }
        }
    }
 
    foreach (VuoRendererCable *cable, cables)
    {
        QPainterPathStroker stroker;
        stroker.setWidth(markWidth);
        QPainterPath cableCurve = stroker.createStroke( cable->getCablePath() );
        path = path.united( cableCurve );
    }
 
    this->errorMarkPath = path;
}
 
QPainterPath VuoErrorMark::getErrorMarkPath() const
{
    return this->errorMarkPath;
}