VuoRendererTypecastPort.cc

Go to the documentation of this file.

 
#include "VuoRendererTypecastPort.hh"
 
#include "VuoCompilerPortClass.hh"
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
#include "VuoRendererFonts.hh"
 
const qreal VuoRendererTypecastPort::textPadding = 7 /*VuoRendererPort::portRadius - 1*/;  
 
VuoRendererTypecastPort::VuoRendererTypecastPort(VuoRendererNode *uncollapsedTypecastNode,
                                                 VuoRendererPort *replacedPort,
                                                 VuoRendererSignaler *signaler)
    : VuoRendererPort(replacedPort->getBase(),
                      signaler,
                      false,
                      replacedPort->getRefreshPort(),
                      false)
{
    this->replacedPort = replacedPort;
    this->setPortNameToRender(replacedPort->getPortNameToRender());
    setUncollapsedTypecastNode(uncollapsedTypecastNode);
}
 
void VuoRendererTypecastPort::setUncollapsedTypecastNode(VuoRendererNode *uncollapsedTypecastNode)
{
    // @todo: Handle this elsewhere.
    //setToolTip(uncollapsedTypecastNode->generateNodeClassToolTip(uncollapsedTypecastNode->getBase()->getNodeClass()));
 
    VuoPort *typecastInPort = uncollapsedTypecastNode->getBase()->getInputPorts()[VuoNodeClass::unreservedInputPortStartIndex];
    VuoPort *typecastOutPort = uncollapsedTypecastNode->getBase()->getOutputPorts()[VuoNodeClass::unreservedOutputPortStartIndex];
 
    this->uncollapsedTypecastNode = uncollapsedTypecastNode;
    this->sourceType = QString::fromStdString(typecastInPort->getRenderer()->getPortNameToRenderWhenDisplayed());
    this->destinationType = QString::fromStdString(typecastOutPort->getRenderer()->getPortNameToRenderWhenDisplayed());
    this->childPort = typecastInPort->getRenderer();
    updateCachedBoundingRect();
}
 
QPainterPath VuoRendererTypecastPort::getPortPath(bool includeNormalPort, bool includeFlag) const
{
    QPainterPath p;
 
    // Draw a normal port...
    if (includeNormalPort)
        p += VuoRendererPort::getPortPath();
 
    // ...and add a rectangle connecting the host port to the child port.
    if (includeFlag)
    {
        qreal r = VuoRendererPort::portRadius - 2;
        p.addRoundedRect(getPortConstantTextRect().adjusted(-textPadding/2 - 1, .15, 0, -.85), r, r);
    }
 
    return p;
}
 
QRectF VuoRendererTypecastPort::getPortConstantTextRect(void) const
{
    return getPortConstantTextRectForText(getCanvasTypecastTitle())
            .adjusted(-VuoRendererPort::portRadius - textPadding/2 + 1, 0, -VuoRendererPort::portRadius, 0);
}
 
qreal VuoRendererTypecastPort::getChildPortXOffset(void) const
{
    return getPortConstantTextRect().width() + (VuoRendererPort::portRadius - 1)*2 - 1 + textPadding/2 + 1;
}
 
QString VuoRendererTypecastPort::getCanvasTypecastTitle(void) const
{
    return getTypecastTitleForNodeClass(uncollapsedTypecastNode->getBase()->getNodeClass(), false);
}
 
QString VuoRendererTypecastPort::getTypecastTitleForNodeClass(VuoNodeClass *typecastClass, bool inMenu)
{
    string typecastClassName = typecastClass->getClassName();
 
    // Check whether this typecast class has a custom title.
    map<string, string> customTypecastTitles;
    customTypecastTitles["vuo.type.real.boolean"] = "Real ≠ 0";
    customTypecastTitles["vuo.type.real.enum.VuoBoolean"] = "Real ≥ 0.5";
 
    map<string, string>::iterator typecastTitle = customTypecastTitles.find(typecastClassName);
    if (typecastTitle != customTypecastTitles.end())
        return typecastTitle->second.c_str();
 
    // If not, construct the typecast title from its input and output port names.
    VuoPortClass *typecastInPortClass = typecastClass->getInputPortClasses()[VuoNodeClass::unreservedInputPortStartIndex];
    VuoPortClass *typecastOutPortClass = typecastClass->getOutputPortClasses()[VuoNodeClass::unreservedOutputPortStartIndex];
 
    QString typecastInPortName = QString::fromStdString(static_cast<VuoCompilerPortClass *>(typecastInPortClass->getCompiler())->getDisplayName());
    QString typecastOutPortName = QString::fromStdString(static_cast<VuoCompilerPortClass *>(typecastOutPortClass->getCompiler())->getDisplayName());
 
    QString separator = (inMenu? QString::fromUtf8(" → ") : "     ");
    return typecastInPortName + separator + typecastOutPortName;
}
 
VuoRendererNode * VuoRendererTypecastPort::getUncollapsedTypecastNode(void) const
{
    return uncollapsedTypecastNode;
}
 
VuoRendererPort * VuoRendererTypecastPort::getChildPort(void) const
{
    return childPort;
}
 
VuoRendererPort * VuoRendererTypecastPort::getReplacedPort(void) const
{
    return replacedPort;
}
 
QRectF VuoRendererTypecastPort::boundingRect(void) const
{
    return cachedBoundingRect;
}
 
void VuoRendererTypecastPort::updateCachedBoundingRect()
{
    QPainterPath path = getPortPath(true, true);
    cachedBoundingRect = path.controlPointRect();
 
    if (!isRefreshPort)
        cachedBoundingRect = cachedBoundingRect.united(getNameRect());
 
    if (hasPortAction())
        cachedBoundingRect = cachedBoundingRect.united(getActionIndicatorRect());
 
    // Antialiasing bleed
    cachedBoundingRect.adjust(-1,-1,1,1);
 
    cachedBoundingRect = cachedBoundingRect.toAlignedRect();
}
 
void VuoRendererTypecastPort::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    if (getRenderedParentNode()->getProxyNode())
        return;
 
    // Draw the collapsed typecast...
 
    drawBoundingRect(painter);
 
    VuoRendererColors::SelectionType selectionType = (getRenderedParentNode()->isSelected()? VuoRendererColors::directSelection : VuoRendererColors::noSelection);
    qint64 timeOfLastActivity = ((! getRenderActivity())?   VuoRendererItem::notTrackingActivity :
                                                            getUncollapsedTypecastNode()->getTimeLastExecutionEnded());
 
    VuoRendererColors *colors = new VuoRendererColors(getRenderedParentNode()->getBase()->getTintColor(),
                                                      selectionType,
                                                      false,
                                                      eligibilityHighlight(),
                                                      timeOfLastActivity);
 
    // Fill
    QPainterPath innerTypecastPath = getPortPath(false, true);
    painter->fillPath(innerTypecastPath, colors->nodeFill());
 
    // Typecast description
    QRectF textRect = getPortConstantTextRect();
    painter->setPen(colors->portTitle());
    painter->setFont(VuoRendererFonts::getSharedFonts()->nodePortConstantFont());
    painter->drawText(textRect, Qt::AlignLeft, getCanvasTypecastTitle());
 
    // Draw the normal port.
    VuoRendererPort::paint(painter,option,widget);
 
    delete colors;
}