VuoNode.cc

Go to the documentation of this file.

 
#include "VuoNode.hh"
 
#include "VuoNodeClass.hh"
#include "VuoPort.hh"
#include "VuoStringUtilities.hh"
 
#include <stdio.h>
 
 
VuoNode::VuoNode(VuoNodeClass * nodeClass, string title, VuoPort * refreshPort, vector<VuoPort *> inputPorts, vector<VuoPort *> outputPorts, double x, double y, bool collapsed, VuoNode::TintColor tintColor)
    : VuoBase<VuoCompilerNode,VuoRendererNode>("VuoNode")
{
    this->nodeClass = nodeClass;
    this->title = title;
    this->refreshPort = refreshPort;
    this->inputPorts = inputPorts;
    this->outputPorts = outputPorts;
    this->x = x;
    this->y = y;
    this->collapsed = collapsed;
    this->tintColor = tintColor;
    this->forbidden = false;
}
 
VuoNodeClass * VuoNode::getNodeClass(void)
{
    return nodeClass;
}
 
VuoPort * VuoNode::getInputPortWithName(string portName)
{
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
        if (portName == (*i)->getClass()->getName())
            return *i;
 
    return NULL;
}
 
VuoPort * VuoNode::getOutputPortWithName(string portName)
{
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
        if (portName == (*i)->getClass()->getName())
            return *i;
 
    return NULL;
}
 
VuoPort * VuoNode::getRefreshPort(void)
{
    return refreshPort;
}
 
vector<VuoPort *> VuoNode::getInputPorts(void)
{
    return inputPorts;
}
 
vector<VuoPort *> VuoNode::getInputPortsBeforePort(VuoPort *port)
{
    vector<VuoPort *> foundPorts;
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
        if ((*i) == port)
            return foundPorts;
        else
            foundPorts.push_back(*i);
    return vector<VuoPort *>();
}
 
vector<VuoPort *> VuoNode::getInputPortsAfterPort(VuoPort *port)
{
    vector<VuoPort *> foundPorts;
    bool found = false;
    for (vector<VuoPort *>::iterator i = inputPorts.begin(); i != inputPorts.end(); ++i)
    {
        if (found)
            foundPorts.push_back(*i);
        if ((*i) == port)
            found = true;
    }
    return foundPorts;
}
 
vector<VuoPort *> VuoNode::getOutputPorts(void)
{
    return outputPorts;
}
 
vector<VuoPort *> VuoNode::getOutputPortsBeforePort(VuoPort *port)
{
    vector<VuoPort *> foundPorts;
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
        if ((*i) == port)
            return foundPorts;
        else
            foundPorts.push_back(*i);
    return vector<VuoPort *>();
}
 
vector<VuoPort *> VuoNode::getOutputPortsAfterPort(VuoPort *port)
{
    vector<VuoPort *> foundPorts;
    bool found = false;
    for (vector<VuoPort *>::iterator i = outputPorts.begin(); i != outputPorts.end(); ++i)
    {
        if (found)
            foundPorts.push_back(*i);
        if ((*i) == port)
            found = true;
    }
    return foundPorts;
}
 
string VuoNode::getTitle(void)
{
    return title;
}
 
void VuoNode::setTitle(string title)
{
    this->title = title;
}
 
bool VuoNode::isTypecastNode(void)
{
    return nodeClass->isTypecastNodeClass();
}
 
int VuoNode::getX(void)
{
    return x;
}
 
int VuoNode::getY(void)
{
    return y;
}
 
void VuoNode::setX(int x)
{
    this->x = x;
}
 
void VuoNode::setY(int y)
{
    this->y = y;
}
 
bool VuoNode::isCollapsed(void)
{
    return collapsed;
}
 
void VuoNode::setCollapsed(bool collapsed)
{
    this->collapsed = collapsed;
}
 
enum VuoNode::TintColor VuoNode::getTintColor(void)
{
    return tintColor;
}
 
string VuoNode::getTintColorGraphvizName(void)
{
    return getGraphvizNameForTint(tintColor);
}
 
void VuoNode::setTintColor(enum VuoNode::TintColor tintColor)
{
    this->tintColor = tintColor;
}
 
bool VuoNode::isForbidden(void)
{
    return forbidden;
}
 
void VuoNode::setForbidden(bool forbidden)
{
    this->forbidden = forbidden;
}
 
void VuoNode::setRawGraphvizDeclaration(string declaration)
{
    this->rawGraphvizDeclaration = declaration;
}
 
string VuoNode::getRawGraphvizDeclaration(void)
{
    return rawGraphvizDeclaration;
}
 
string VuoNode::getRawGraphvizIdentifier(void)
{
    string identifier;
    for (int j = 0; j < rawGraphvizDeclaration.length() && VuoStringUtilities::isValidCharInIdentifier(rawGraphvizDeclaration[j]); ++j)
        identifier += rawGraphvizDeclaration[j];
    return identifier;
}
 
void VuoNode::print(void)
{
    printf("VuoNode(%p,\"%s\")",this,title.c_str());
    if (hasCompiler())
        printf(" VuoCompilerNode(%p)",getCompiler());
    if (hasRenderer())
        printf(" VuoRendererNode(%p)",getRenderer());
    printf("\n");
 
    printf("\tposition (%d,%d)\n", x, y);
    printf("\tcollapsed %s\n", collapsed ? "true" : "false");
    printf("\ttintColor %s\n", getTintColorGraphvizName().c_str());
 
    for (vector<VuoPort *>::iterator it = inputPorts.begin(); it != inputPorts.end(); ++it)
    {
        printf("\tinput ");
        (*it)->print();
    }
 
    for (vector<VuoPort *>::iterator it = outputPorts.begin(); it != outputPorts.end(); ++it)
    {
        printf("\toutput ");
        (*it)->print();
    }
 
    fflush(stdout);
}
 
string VuoNode::getGraphvizNameForTint(enum TintColor tintColor)
{
    switch (tintColor)
    {
        case VuoNode::TintYellow:
            return "yellow";
        case VuoNode::TintTangerine:
            return "tangerine";
        case VuoNode::TintOrange:
            return "orange";
        case VuoNode::TintMagenta:
            return "magenta";
        case VuoNode::TintViolet:
            return "violet";
        case VuoNode::TintBlue:
            return "blue";
        case VuoNode::TintCyan:
            return "cyan";
        case VuoNode::TintGreen:
            return "green";
        case VuoNode::TintLime:
            return "lime";
        default:
            return "";
    }
}
 
enum VuoNode::TintColor VuoNode::getTintWithGraphvizName(string tintName)
{
    if (tintName == "yellow")
        return VuoNode::TintYellow;
    else if (tintName == "tangerine")
        return VuoNode::TintTangerine;
    else if (tintName == "orange")
        return VuoNode::TintOrange;
    else if (tintName == "magenta")
        return VuoNode::TintMagenta;
    else if (tintName == "violet")
        return VuoNode::TintViolet;
    else if (tintName == "blue")
        return VuoNode::TintBlue;
    else if (tintName == "cyan")
        return VuoNode::TintCyan;
    else if (tintName == "green")
        return VuoNode::TintGreen;
    else if (tintName == "lime")
        return VuoNode::TintLime;
    else
        return VuoNode::TintNone;
}