VuoRendererCable.cc

Go to the documentation of this file.

 
#include "VuoRendererCable.hh"
#include "VuoRendererFonts.hh"
#include "VuoRendererPublishedPort.hh"
#include "VuoCable.hh"
#include "VuoCompilerCable.hh"
#include "VuoNodeClass.hh"
 
 
const qreal VuoRendererCable::cableWidth = 5;  // VuoRendererFonts::thickPenWidth / 4.;
 
const qreal VuoRendererCable::cableYankRadius = 20;  // VuoRendererFonts::thickPenWidth;
 
VuoRendererCable::VuoRendererCable(VuoCable *baseCable)
    : VuoBaseDetail<VuoCable>("VuoRendererCable", baseCable)
{
    getBase()->setRenderer(this);
 
    portConstantsChangedSinceLastCachedOutline = true;
 
    setZValue(cableZValue);
 
    VuoNode *fromNode = getBase()->getFromNode();
    VuoRendererNode *fromRN = ((fromNode && fromNode->hasRenderer())? fromNode->getRenderer() : NULL);
 
    if (fromRN)
        getBase()->getFromPort()->getRenderer()->updateGeometry();
 
    VuoNode *toNode = getBase()->getToNode();
    VuoRendererNode * toRN = ((toNode && toNode->hasRenderer())? toNode->getRenderer() : NULL);
 
    if (toRN)
        getBase()->getToPort()->getRenderer()->updateGeometry();
 
    floatingEndpointLoc = QPointF();
    floatingEndpointPreviousToPort = NULL;
    previouslyAlwaysEventOnly = false;
    floatingEndpointAboveEventPort = false;
    isHovered = false;
    _eligibilityHighlight = VuoRendererColors::noHighlight;
 
    this->setAcceptHoverEvents(true);
    this->setFlags(QGraphicsItem::ItemIsSelectable);
    resetTimeLastEventPropagated();
}
 
QRectF VuoRendererCable::boundingRect(void) const
{
    if (paintingDisabled())
        return QRectF();
 
    QPainterPath cablePath = getCablePath();
    QRectF r = cablePath.boundingRect();
 
    if (r.isNull())
        return r;
 
    // Include thick width of cable.
    r.adjust(-cableWidth/2., -cableWidth/2., cableWidth/2., cableWidth/2.);
 
    // Antialiasing bleed
    r.adjust(-1,-1,1,1);
 
    return r.toAlignedRect();
}
 
QPainterPath VuoRendererCable::shape() const
{
    if (paintingDisabled())
        return QPainterPath();
 
    QPainterPath p;
    p.addPath(getCablePath());
 
    QPainterPathStroker s;
    s.setWidth(cableWidth);
 
    return s.createStroke(p);
}
 
QPointF VuoRendererCable::getStartPoint(void) const
{
    VuoNode *fromNode = getBase()->getFromNode();
    VuoPort *fromPort = getBase()->getFromPort();
 
    if (fromPort && fromPort->hasRenderer())
    {
        VuoRendererPublishedPort *sidebarPort = dynamic_cast<VuoRendererPublishedPort *>(fromPort->getRenderer());
        if (sidebarPort)
        {
            QList<QGraphicsView *> views = scene()->views();
            return (views.empty()? QPointF(0,0) : views[0]->mapToScene(sidebarPort->getCompositionViewportPos()));
        }
 
        else if (fromNode && fromNode->hasRenderer())
            return fromNode->getRenderer()->pos() + fromPort->getRenderer()->pos() + QPointF(0, -.35);
    }
 
    return floatingEndpointLoc;
}
 
QPointF VuoRendererCable::getEndPoint(void) const
{
    VuoCable *cable = getBase();
    VuoNode *toNode = cable->getToNode();
    VuoPort *toPort = cable->getToPort();
 
    if (toNode && toPort && toPort->hasRenderer())
    {
        VuoRendererPublishedPort *sidebarPort = dynamic_cast<VuoRendererPublishedPort *>(toPort->getRenderer());
        if (sidebarPort)
        {
            QList<QGraphicsView *> views = scene()->views();
            return (views.empty()? QPointF(0,0) : views[0]->mapToScene(sidebarPort->getCompositionViewportPos()));
        }
 
        else if (toNode->hasRenderer())
        {
            VuoRendererNode *rn = toNode->getRenderer();
            VuoRendererNode *toNodeProxy = rn->getProxyNode();
            if (toNodeProxy)
                return toNodeProxy->pos() + toPort->getRenderer()->pos() + QPointF(0, -.35);
            else
                return rn->pos() + toPort->getRenderer()->pos() + QPointF(0, -.35);
        }
    }
 
    return floatingEndpointLoc;
}
 
QPainterPath VuoRendererCable::getCablePath(void) const
{
    if (paintingDisabled())
        return QPainterPath();
 
    return getCablePathForEndpoints(getStartPoint(), getEndPoint());
}
 
void VuoRendererCable::arclineTo(QPainterPath &cablePath, QPointF to, float radius, float fromCableStandoff) const
{
    QPointF from = cablePath.currentPosition();
    float direction = from.y() < to.y() ? 1 : -1;
 
    QRectF fromRect(from - QPointF(radius, -radius*2*direction), from + QPointF(radius, 0));
 
    if (to.x() >= from.x() + radius*2)
    {
        // Cable is going left-to-right.
        // Draw an arc at the cable's start and end.
 
        // Cable start:
        float stopAngle = -atan2(to.y() - from.y(), to.x() - from.x()) * 180/M_PI;
        cablePath.arcTo(fromRect, -90, -stopAngle*direction);
 
        // Cable end:
        QRectF toRect(to - QPointF(radius, radius*2*direction), to + QPointF(radius, 0));
        cablePath.arcTo(toRect, -90 + stopAngle*direction, -stopAngle*direction);
    }
    else
    {
        // Cable is going right-to-left.
        // At the cable's start and end, draw an arc, then draw a line to escape the node height, then draw another arc.
 
        // Cable start:
        cablePath.arcTo(fromRect, -90, 90);
 
        float fromNodeEscape = 0;
        {
            VuoNode *fromNode = getBase()->getFromNode();
            VuoPort *fromPort = getBase()->getFromPort();
            if (fromNode && fromNode->hasRenderer()
             && fromPort && fromPort->hasRenderer())
            {
                VuoRendererNode *rn = fromNode->getRenderer();
                if (rn->getProxyNode())
                    rn = rn->getProxyNode();
 
                QRectF nodeRect = rn->sceneBoundingRect();
                QRectF portRect = fromPort->getRenderer()->sceneBoundingRect();
                if (from.y() < to.y())
                    // Cable is going downward, so escape the part of the node below the `from` port.
                    fromNodeEscape = nodeRect.bottom() - portRect.bottom();
                else
                    // Cable is going upward.
                    fromNodeEscape = portRect.top() - nodeRect.top();
            }
 
            fromNodeEscape += fromCableStandoff;
        }
 
        float toNodeEscape = 0;
        VuoNode *toNode = getBase()->getToNode();
        {
            VuoPort *toPort = getBase()->getToPort();
            if (toNode && toNode->hasRenderer()
             && toPort && toPort->hasRenderer())
            {
                VuoRendererNode *rn = toNode->getRenderer();
                if (rn->getProxyNode())
                    rn = rn->getProxyNode();
 
                QRectF nodeRect = rn->sceneBoundingRect();
                QRectF portRect = toPort->getRenderer()->sceneBoundingRect();
                if (from.y() < to.y())
                    // Cable is going downward, so escape the part of the node above the `to` port.
                    toNodeEscape = portRect.top() - nodeRect.top();
                else
                    // Cable is going upward.
                    toNodeEscape = nodeRect.bottom() - portRect.bottom();
            }
        }
 
        // When a cable connects 2 nodes that are 1 grid spacing apart,
        // make the horizontal section of the cable exactly horizontal.
        fromNodeEscape += direction>0 ? 4.85 : 3.15;
        if (toNode && toNode->getNodeClass()->isDrawerNodeClass())
            toNodeEscape   += direction>0 ? 8 : -1.75;
        else
            toNodeEscape   += direction>0 ? 4.15 : 4.85;
 
        // If the ports are so close that the escapement would look loopy, forget it.
        if (fromNodeEscape + toNodeEscape + radius*3 >= fabs(from.y() - to.y()))
            fromNodeEscape = toNodeEscape = 0;
 
        QPointF fromEscaped = cablePath.currentPosition() + QPointF(0, fromNodeEscape*direction);
        QPointF toEscaped = to - QPointF(radius, (radius + toNodeEscape)*direction);
 
        QRectF fromEscapedRect(fromEscaped - QPointF(radius*2, radius*direction),
                               fromEscaped + QPointF(0, radius*direction));
 
        float stopAngle = atan2(fromEscaped.x() - toEscaped.x(), fromEscaped.y() - toEscaped.y()) * 180/M_PI;
        if (to.y() > from.y())
            stopAngle = 180-stopAngle;
 
        cablePath.arcTo(fromEscapedRect, 0, -stopAngle);
 
 
        // Cable end:
        QRectF toEscapedRect(toEscaped - QPointF(0, radius*direction), toEscaped + QPointF(radius*2, radius*direction));
        cablePath.arcTo(toEscapedRect, 180 - stopAngle, stopAngle);
 
        QRectF toRect(to-QPointF(radius, radius*2*direction), to + QPointF(radius, 0));
        cablePath.arcTo(toRect, 180, 90);
    }
}
 
QPainterPath VuoRendererCable::getCablePathForEndpoints(QPointF from, QPointF to) const
{
    QPainterPath cablePath(from);
 
    // The `from` node's other output ports (besides the port it's connected to)
    // may have cables, so escape them to avoid overlapping.
    float fromStandoff = 0; // Total standoff
    float fromCableStandoff = 0; // Standoff due to routed cables (excluding hidden cables)
    VuoNode *fromNode = getBase()->getFromNode();
    VuoPort *fromPort = getBase()->getFromPort();
    if (fromNode && fromPort)
    {
        vector<VuoPort *> outputs = (from.y() < to.y())
                ? fromNode->getOutputPortsAfterPort(fromPort)
                : fromNode->getOutputPortsBeforePort(fromPort);
        for (vector<VuoPort *>::iterator i = outputs.begin(); i != outputs.end(); ++i)
        {
            vector<VuoCable *> cables = (*i)->getConnectedCables();
            if ((*i)->hasRenderer() && !cables.empty())
            {
                bool hasOnlyWireless = true;
                for (vector<VuoCable *>::iterator cable = cables.begin(); cable != cables.end(); ++cable)
                    if ((*cable)->hasRenderer())
                    {
                        VuoRendererCable *cableR = (*cable)->getRenderer();
                        if (!cableR->getEffectivelyWireless())
                        {
                            hasOnlyWireless = false;
                            break;
                        }
                    }
 
                if (hasOnlyWireless)
                    // We only need to escape the wireless antenna once (we don't need to escape every port's antenna).
                    fromStandoff = fmax(fromStandoff, VuoRendererPort::portSpacing);
                else
                {
                    fromStandoff += VuoRendererPort::portSpacing;
                    fromCableStandoff += VuoRendererPort::portSpacing;
                }
            }
        }
    }
    fromStandoff += VuoRendererPort::portSpacing / 2.;
 
    // The `to` node's other input ports (besides the port it's connected to)
    // may have constant flags, so escape them.
    float toStandoff = 0;
    VuoNode *toNode = getBase()->getToNode();
    VuoPort *toPort = getBase()->getToPort();
    if (toNode && toPort)
    {
        vector<VuoPort *> inputs = (from.y() < to.y())
                ? toNode->getInputPortsBeforePort(toPort)
                : toNode->getInputPortsAfterPort(toPort);
        for (vector<VuoPort *>::iterator i = inputs.begin(); i != inputs.end(); ++i)
            if ((*i)->hasRenderer() && (*i)->getRenderer()->isConstant())
            {
                float constantFlagWidth = (*i)->getRenderer()->getPortConstantTextRect().width();
                toStandoff = fmax(toStandoff, constantFlagWidth);
            }
    }
 
    // Move the cable attachment point to the left of the port constant.
    if (!effectivelyCarriesData() && toPort)
        toStandoff = fmax(toStandoff, toPort->getRenderer()->getPortConstantTextRect().width());
 
    toStandoff += VuoRendererPort::portSpacing / 2.;
 
    QPointF fromWithStandoff(from.x() + fromStandoff, from.y());
    QPointF   toWithStandoff(  to.x() -   toStandoff,   to.y());
 
    float length = (from - to).manhattanLength();
    if (length < fromStandoff + toStandoff + VuoRendererPort::portSpacing * 3)
    {
        // Cable is very short; just draw a single line.
    }
    else
    {
        cablePath.lineTo(fromWithStandoff);
        arclineTo(cablePath, toWithStandoff, VuoRendererPort::portSpacing / 2., fromCableStandoff);
    }
 
    cablePath.lineTo(to);
 
    return cablePath;
}
 
VuoNode::TintColor VuoRendererCable::getTintColor(void)
{
    VuoPort *fromPort = getBase()->getFromPort();
    if (fromPort && fromPort->hasRenderer())
        return fromPort->getRenderer()->getPortTint();
 
    return VuoNode::TintNone;
}
 
bool VuoRendererCable::isConnectedToSelectedNode(void)
{
    VuoNode *fromNode = getBase()->getFromNode();
    VuoNode *toNode = getBase()->getToNode();
 
    bool fromNodeIsSelected = (fromNode && fromNode->hasRenderer() && fromNode->getRenderer()->isSelected());
    bool toNodeIsSelected = (toNode && toNode->hasRenderer() && toNode->getRenderer()->isSelected());
    bool toNodeViaTypeconverterIsSelected = toNode && toNode->hasRenderer() && toNode->getRenderer()->getProxyNode() && toNode->getRenderer()->getProxyNode()->isEffectivelySelected();
    bool toNodeViaAttachmentIsSelected = toNode && toNode->hasRenderer() &&
            dynamic_cast<VuoRendererInputAttachment *>(toNode->getRenderer()) &&
            dynamic_cast<VuoRendererInputAttachment *>(toNode->getRenderer())->getRenderedHostNode() &&
            dynamic_cast<VuoRendererInputAttachment *>(toNode->getRenderer())->getRenderedHostNode()->getRenderer()->isSelected();
 
    return (fromNodeIsSelected || toNodeIsSelected || toNodeViaTypeconverterIsSelected || toNodeViaAttachmentIsSelected);
}
 
void VuoRendererCable::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    if (paintingDisabled())
        return;
 
    bool hoverHighlightingEnabled = isHovered;
    drawBoundingRect(painter);
 
    VuoNode::TintColor tintColor = getTintColor();
    VuoRendererColors::SelectionType selectionType =    (isSelected()?                  VuoRendererColors::directSelection :
                                                        (isConnectedToSelectedNode()?   VuoRendererColors::indirectSelection :
                                                                                        VuoRendererColors::noSelection));
 
    qint64 timeOfLastActivity = (getRenderActivity()? timeLastEventPropagated : VuoRendererItem::notTrackingActivity);
    VuoRendererColors colors(tintColor,
                                                      selectionType,
                                                      (selectionType != VuoRendererColors::noSelection? false : hoverHighlightingEnabled),
                                                      _eligibilityHighlight,
                                                      timeOfLastActivity
                                                      );
 
    VuoRendererColors yankZoneColors(tintColor,
                                                              selectionType,
                                                              true,
                                                              VuoRendererColors::standardHighlight,
                                                              timeOfLastActivity);
 
    QPointF startPoint = getStartPoint();
    QPointF endPoint = getEndPoint();
    bool renderAsIfCableCarriesData = effectivelyCarriesData() && !floatingEndpointAboveEventPort;
 
    // Etch the highlight out of the main cable.
    QPainterPath outline = getOutline(startPoint, endPoint, renderAsIfCableCarriesData);
    if (outline.isEmpty())
        return;
 
    // Fill the cable.
    painter->fillPath(outline, QBrush(colors.cableMain()));
 
    // Highlight the yank zone when hovering.
    if (hoverHighlightingEnabled)
    {
        bool toPortSupportsYanking = getBase()->getToPort() &&
                                     getBase()->getToPort()->getRenderer()->supportsDisconnectionByDragging();
 
        QPainterPath yankZone;
        getYankZonePath(startPoint, endPoint, renderAsIfCableCarriesData, toPortSupportsYanking, yankZone);
 
        painter->setClipPath(yankZone);
        painter->fillPath(outline, QBrush(yankZoneColors.cableMain()));
 
        painter->setClipping(false);
    }
}
 
QPainterPath VuoRendererCable::getOutline(QPointF startPoint,
                                          QPointF endPoint,
                                          bool cableCarriesData)
{
    if ((qMakePair(startPoint, endPoint) != this->cachedEndpointsForOutlines)
     || (cableCarriesData != this->cachedCarriesDataValueForOutlines)
     || portConstantsChangedSinceLastCachedOutline)
    {
        qreal cableWidth;
        getCableSpecs(cableCarriesData, cableWidth);
 
        QPainterPath cablePath = getCablePathForEndpoints(startPoint, endPoint);
 
        QPainterPathStroker mainStroker;
        mainStroker.setWidth(cableWidth);
        mainStroker.setCapStyle(Qt::RoundCap);
        QPainterPath mainOutline = mainStroker.createStroke(cablePath);
 
        this->cachedEndpointsForOutlines = qMakePair(startPoint, endPoint);
        this->cachedCarriesDataValueForOutlines = cableCarriesData;
        this->cachedOutline = mainOutline;
        this->portConstantsChangedSinceLastCachedOutline = false;
    }
 
    return this->cachedOutline;
}
 
void VuoRendererCable::getYankZonePath(QPointF startPoint,
                                        QPointF endPoint,
                                        bool cableCarriesData,
                                        bool toPortSupportsYanking,
                                        QPainterPath &yankZone
                                        )
{
    if ((qMakePair(startPoint, endPoint) != this->cachedEndpointsForYankZone) ||
        (toPortSupportsYanking != this->cachedToPortSupportsYankingValueForYankZone) ||
        (cableCarriesData != this->cachedCarriesDataValueForYankZone))
    {
        // Calculate the yank zone.
        QPainterPath yankZone;
        if (getBase()->getToPort() && toPortSupportsYanking)
            yankZone.addEllipse(endPoint, VuoRendererCable::cableYankRadius, VuoRendererCable::cableYankRadius);
 
        this->cachedEndpointsForYankZone = qMakePair(startPoint, endPoint);
        this->cachedCarriesDataValueForYankZone = cableCarriesData;
        this->cachedToPortSupportsYankingValueForYankZone = toPortSupportsYanking;
        this->cachedYankZonePath = yankZone;
    }
 
    yankZone = this->cachedYankZonePath;
}
 
void VuoRendererCable::getCableSpecs(bool cableCarriesData, qreal &cableWidth)
{
    const qreal dataCableToEventCableWidthRatio = 4;
 
    cableWidth = (cableCarriesData? VuoRendererCable::cableWidth :
                                     VuoRendererCable::cableWidth/dataCableToEventCableWidthRatio);
}
 
bool VuoRendererCable::paintingDisabled() const
{
    VuoCable *cable = getBase();
    VuoNode *fromNode = cable->getFromNode();
 
    // If the cable is an outgoing cable from a collapsed typecast, disable painting.
    if (fromNode && fromNode->hasRenderer() && fromNode->getRenderer()->getProxyNode())
        return true;
 
    // If the cable is an outgoing cable from an input port attachment, disable painting.
    if (fromNode && fromNode->hasRenderer() && dynamic_cast<VuoRendererInputAttachment *>(fromNode->getRenderer()))
        return true;
 
    // If the cable is a published cable and published port sidebars are not currently displayed, disable painting.
    if (isPublishedInputCableWithoutVisiblePublishedPort() || isPublishedOutputCableWithoutVisiblePublishedPort())
        return true;
 
    // If the cable is an internal wireless cable, disable painting unless the composition is currently
    // in show-hidden-cables mode.
    if (cable->getCompiler()->getHidden() && !getRenderHiddenCables())
        return true;
 
    return false;
}
 
bool VuoRendererCable::isPublishedInputCableWithoutVisiblePublishedPort() const
{
    VuoPort *fromPort = getBase()->getFromPort();
 
    // If the cable is connected to a published input port withn the published input sidebar,
    // but the sidebar is not currently displayed, disable painting.
    if (fromPort)
    {
        VuoRendererPublishedPort *publishedPort = dynamic_cast<VuoRendererPublishedPort *>(fromPort->getRenderer());
 
        if (publishedPort)
        {
            bool proxyPublishedInputSidebarPortHidden = (! publishedPort->isVisible());
            if (proxyPublishedInputSidebarPortHidden)
                return true;
        }
    }
 
    return false;
}
 
bool VuoRendererCable::isPublishedOutputCableWithoutVisiblePublishedPort() const
{
    VuoPort *toPort = getBase()->getToPort();
 
    // If the cable is connected to a published output port within the published output sidebar,
    // but the sidebar is not currently displayed, disable painting.
    if (toPort)
    {
        VuoRendererPublishedPort *publishedPort = dynamic_cast<VuoRendererPublishedPort *>(toPort->getRenderer());
 
        if (publishedPort)
        {
            bool proxyPublishedOutputSidebarPortHidden = (! publishedPort->isVisible());
            if (proxyPublishedOutputSidebarPortHidden)
                return true;
        }
    }
 
    return false;
}
 
bool VuoRendererCable::getEffectivelyWireless() const
{
    if (isPublishedInputCableWithoutVisiblePublishedPort() || isPublishedOutputCableWithoutVisiblePublishedPort())
        return true;
 
    return getBase()->getCompiler()->getHidden();
}
 
void VuoRendererCable::setWireless(bool wireless)
{
    VuoRendererPort *fromPort = ((getBase()->getFromPort() && getBase()->getFromPort()->hasRenderer())?
                                    getBase()->getFromPort()->getRenderer() : NULL);
    VuoRendererPort *toPort = ((getBase()->getToPort() && getBase()->getToPort()->hasRenderer())?
                                    getBase()->getToPort()->getRenderer() : NULL);
 
    updateGeometry();
 
    if (fromPort)
        fromPort->updateGeometry();
 
    if (toPort)
        toPort->updateGeometry();
 
    QGraphicsItem::CacheMode normalCacheMode = cacheMode();
    setCacheModeForCableAndConnectedPorts(QGraphicsItem::NoCache);
 
    getBase()->getCompiler()->setHidden(wireless);
 
    setCacheModeForCableAndConnectedPorts(normalCacheMode);
}
 
void VuoRendererCable::setCacheModeForCableAndConnectedPorts(QGraphicsItem::CacheMode mode)
{
    this->setCacheMode(mode);
 
    VuoRendererPort *fromPort = ((getBase()->getFromPort() && getBase()->getFromPort()->hasRenderer())?
                                    getBase()->getFromPort()->getRenderer() : NULL);
    VuoRendererPort *toPort = ((getBase()->getToPort() && getBase()->getToPort()->hasRenderer())?
                                    getBase()->getToPort()->getRenderer() : NULL);
 
    if (fromPort)
        fromPort->setCacheMode(mode);
 
    if (toPort)
        toPort->setCacheMode(mode);
}
 
void VuoRendererCable::setPortConstantsChanged()
{
    portConstantsChangedSinceLastCachedOutline = true;
}
 
QPointF VuoRendererCable::getFloatingEndpointLoc()
{
    return floatingEndpointLoc;
}
 
void VuoRendererCable::setFrom(VuoNode *fromNode, VuoPort *fromPort)
{
    VuoPort *origFromPort = getBase()->getFromPort();
 
    QGraphicsItem::CacheMode normalCacheMode = cacheMode();
 
    // Prepare affected ports and cable for geometry changes
    updateGeometry();
 
    if (origFromPort && origFromPort->hasRenderer())
    {
        origFromPort->getRenderer()->setCacheModeForPortAndChildren(QGraphicsItem::NoCache);
        origFromPort->getRenderer()->updateGeometry();
    }
 
    if (fromPort && fromPort->hasRenderer())
    {
        fromPort->getRenderer()->setCacheModeForPortAndChildren(QGraphicsItem::NoCache);
        fromPort->getRenderer()->updateGeometry();
    }
 
    getBase()->setFrom(fromNode, fromPort);
 
    if (origFromPort && origFromPort->hasRenderer())
        origFromPort->getRenderer()->setCacheModeForPortAndChildren(normalCacheMode);
 
    if (fromPort && fromPort->hasRenderer())
        fromPort->getRenderer()->setCacheModeForPortAndChildren(normalCacheMode);
}
 
void VuoRendererCable::setTo(VuoNode *toNode, VuoPort *toPort)
{
    VuoPort *origToPort = getBase()->getToPort();
 
    QGraphicsItem::CacheMode normalCacheMode = cacheMode();
 
    // Prepare affected ports and cable for geometry changes
    updateGeometry();
 
    if (origToPort && origToPort->hasRenderer())
    {
        origToPort->getRenderer()->setCacheModeForPortAndChildren(QGraphicsItem::NoCache);
        origToPort->getRenderer()->updateGeometry();
    }
 
    if (toPort && toPort->hasRenderer())
    {
        toPort->getRenderer()->setCacheModeForPortAndChildren(QGraphicsItem::NoCache);
        toPort->getRenderer()->updateGeometry();
    }
 
    getBase()->setTo(toNode, toPort);
 
    // Re-lay out any drawers connected to the original and updated "To" nodes.
    if (origToPort && origToPort->hasRenderer())
    {
        origToPort->getRenderer()->updateGeometry();
 
        if (origToPort->getRenderer()->getRenderedParentNode())
            origToPort->getRenderer()->getRenderedParentNode()->layoutConnectedInputDrawersAtAndAbovePort(origToPort->getRenderer());
 
        origToPort->getRenderer()->setCacheModeForPortAndChildren(normalCacheMode);
    }
 
    if (toPort && toPort->hasRenderer())
    {
        toPort->getRenderer()->updateGeometry();
 
        if (toPort->getRenderer()->getRenderedParentNode())
            toPort->getRenderer()->getRenderedParentNode()->layoutConnectedInputDrawersAtAndAbovePort(toPort->getRenderer());
 
        toPort->getRenderer()->setCacheModeForPortAndChildren(normalCacheMode);
    }
}
 
void VuoRendererCable::setFloatingEndpointLoc(QPointF loc)
{
    floatingEndpointLoc = loc;
}
 
void VuoRendererCable::setFloatingEndpointAboveEventPort(bool aboveEventPort)
{
    floatingEndpointAboveEventPort = aboveEventPort;
}
 
bool VuoRendererCable::isFloatingEndpointAboveEventPort(void)
{
    return floatingEndpointAboveEventPort;
}
 
void VuoRendererCable::removeFromScene()
{
    if (scene())
    {
        this->prepareGeometryChange();
 
        VuoPort *rcFromPort = this->getBase()->getFromPort();
        VuoPort *rcToPort = this->getBase()->getToPort();
 
        if (rcFromPort && rcFromPort->hasRenderer())
        {
            rcFromPort->getRenderer()->updateGeometry();
        }
 
        if (rcToPort && rcToPort->hasRenderer())
        {
            rcToPort->getRenderer()->updateGeometry();
        }
 
        scene()->removeItem(this);
    }
}
 
void VuoRendererCable::extendedHoverEnterEvent()
{
    extendedHoverMoveEvent();
}
 
void VuoRendererCable::extendedHoverMoveEvent()
{
    setHovered(true);
}
 
void VuoRendererCable::extendedHoverLeaveEvent()
{
    setHovered(false);
}
 
bool VuoRendererCable::yankZoneIncludes(QPointF scenePos)
{
    qreal yankDistance = QLineF(scenePos, getEndPoint()).length();
    return (yankDistance <= cableYankRadius);
}
 
VuoPort * VuoRendererCable::getFloatingEndpointPreviousToPort()
{
    return floatingEndpointPreviousToPort;
}
 
void VuoRendererCable::setFloatingEndpointPreviousToPort(VuoPort *port)
{
    this->floatingEndpointPreviousToPort = port;
}
 
bool VuoRendererCable::getPreviouslyAlwaysEventOnly()
{
    return this->previouslyAlwaysEventOnly;
}
 
void VuoRendererCable::setPreviouslyAlwaysEventOnly(bool eventOnly)
{
    this->previouslyAlwaysEventOnly = eventOnly;
}
 
void VuoRendererCable::setHovered(bool hovered)
{
    QGraphicsItem::CacheMode normalCacheMode = cacheMode();
    setCacheMode(QGraphicsItem::NoCache);
 
    prepareGeometryChange();
 
    this->isHovered = hovered;
 
    setCacheMode(normalCacheMode);
}
 
void VuoRendererCable::setEligibilityHighlight(VuoRendererColors::HighlightType eligibility)
{
    _eligibilityHighlight = eligibility;
}
 
void VuoRendererCable::updateGeometry(void)
{
    this->prepareGeometryChange();
}
 
void VuoRendererCable::resetTimeLastEventPropagated()
{
    this->timeLastEventPropagated = VuoRendererColors::getVirtualPropagatedEventOrigin();
}
 
bool VuoRendererCable::effectivelyCarriesData(void) const
{
    return (getBase()->hasCompiler() ?
                getBase()->getCompiler()->carriesData() :
                false);
}