VuoRendererValueListForReadOnlyDictionary.cc

Go to the documentation of this file.

 
#include "VuoRendererValueListForReadOnlyDictionary.hh"
#include "VuoRendererReadOnlyDictionary.hh"
#include "VuoCompilerMakeListNodeClass.hh"
#include "VuoCompilerInputEventPort.hh"
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
#include "VuoRendererPort.hh"
 
VuoRendererValueListForReadOnlyDictionary::VuoRendererValueListForReadOnlyDictionary(VuoNode *baseNode, VuoRendererSignaler *signaler)
    : VuoRendererInputDrawer(baseNode, signaler)
{
    VuoNode *makeKeyListNode = getKeyListNode();
    vector<VuoPort *> makeKeyListNodeInputs;
    if (makeKeyListNode)
        makeKeyListNodeInputs = makeKeyListNode->getInputPorts();
 
    vector<VuoPort *> inputPorts = this->getBase()->getInputPorts();
    for (int i = VuoNodeClass::unreservedInputPortStartIndex; i < inputPorts.size(); ++i)
    {
        string keyName = " ";
        if (i < makeKeyListNodeInputs.size())
        {
            VuoCompilerInputEventPort *keyPort= static_cast<VuoCompilerInputEventPort *>(makeKeyListNodeInputs[i]->getCompiler());
            keyName = keyPort->getData()->getInitialValue();
        }
 
        inputPorts[i]->getRenderer()->setPortNameToRender(getRenderedPortNameFormForText(keyName));
    }
}
 
string VuoRendererValueListForReadOnlyDictionary::getRenderedPortNameFormForText(string text)
{
    json_object *js = json_tokener_parse(text.c_str());
    string textWithoutQuotes;
    if (json_object_get_type(js) == json_type_string)
        textWithoutQuotes = json_object_get_string(js);
    json_object_put(js);
 
    return textWithoutQuotes;
}
 
void VuoRendererValueListForReadOnlyDictionary::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    if (!isSelected())
    {
        VuoNode *renderedHostNode = getRenderedHostNode();
        if (renderedHostNode && renderedHostNode->hasRenderer() && renderedHostNode->getRenderer()->isSelected())
            this->setSelected(true);
 
        else
        {
            set<VuoNode *> coattachments = getCoattachments();
            foreach (VuoNode *coattachment, coattachments)
            {
                if (coattachment->hasRenderer() && coattachment->getRenderer()->isSelected())
                {
                    this->setSelected(true);
                    break;
                }
            }
        }
    }
 
    drawBoundingRect(painter);
 
    VuoRendererColors::SelectionType selectionType = (isSelected()? VuoRendererColors::directSelection : VuoRendererColors::noSelection);
    qint64 timeOfLastActivity = (getRenderActivity()? timeLastExecutionEnded : VuoRendererItem::notTrackingActivity);
    VuoRendererColors *drawerColors = new VuoRendererColors(getBase()->getTintColor(),
                                                      selectionType,
                                                      false,
                                                      VuoRendererColors::noHighlight,
                                                      timeOfLastActivity);
 
 
    // Drawer frame
    painter->fillPath(getDrawerPath(false), drawerColors->nodeFill());
 
    // Child input ports
    layoutPorts();
 
    delete drawerColors;
}
 
QRectF VuoRendererValueListForReadOnlyDictionary::boundingRect(void) const
{
    QRectF r = getDrawerPath(false).boundingRect();
 
    // Antialiasing bleed
    r.adjust(-1,-1,1,1);
 
    return r.toAlignedRect();
}
 
QPainterPath VuoRendererValueListForReadOnlyDictionary::shape() const
{
    QPainterPath p;
    p.addPath(getDrawerPath(false));
 
    return p;
}
 
bool VuoRendererValueListForReadOnlyDictionary::isValueListForReadOnlyDictionary(VuoNode *baseNode)
{
    if (!VuoCompilerMakeListNodeClass::isMakeListNodeClassName(baseNode->getNodeClass()->getClassName()))
        return false;
 
    VuoPort *hostPort = getUnderlyingHostPortForNode(baseNode);
    VuoNode *hostNode = getUnderlyingHostNodeForNode(baseNode);
    bool providesValuesToMakeReadOnlyDictionaryNode = (hostPort &&
                                                (hostPort->getClass()->getName() == "values") &&
                                                (VuoRendererReadOnlyDictionary::isReadOnlyDictionary(hostNode)));
    return providesValuesToMakeReadOnlyDictionaryNode;
}
 
VuoNode * VuoRendererValueListForReadOnlyDictionary::getKeyListNode()
{
    VuoNode *hostNode = getUnderlyingHostNode();
    if (!hostNode)
        return NULL;
 
    VuoPort *keyListInputPort = hostNode->getInputPortWithName("keys");
    return getListNodeConnectedToInputPort(keyListInputPort);
}
 
VuoPort * VuoRendererValueListForReadOnlyDictionary::getRenderedHostPort()
{
    // The port that will ultimately make use of this node's output values is two nodes downstream.
    return getUnderlyingHostPortForNode(getUnderlyingHostNodeForNode(this->getBase()));
}
 
VuoNode * VuoRendererValueListForReadOnlyDictionary::getRenderedHostNode()
{
    // The node that will ultimately make use of this node's output values is two nodes downstream.
    return getUnderlyingHostNodeForNode(getUnderlyingHostNodeForNode(this->getBase()));
}
 
QRectF VuoRendererValueListForReadOnlyDictionary::getOuterNodeFrameBoundingRect(void) const
{
    return getDrawerPath(false).boundingRect();
}
 
set<VuoNode *> VuoRendererValueListForReadOnlyDictionary::getCoattachments(void)
{
    VuoNode *dictionaryNode = getUnderlyingHostNode();
    VuoNode *keyListNode = getKeyListNode();
 
    set<VuoNode *> coattachments;
    if (dictionaryNode)
        coattachments.insert(dictionaryNode);
    if (keyListNode)
        coattachments.insert(keyListNode);
    return coattachments;
}