VuoNodeClass.cc

Go to the documentation of this file.

 
#include "VuoNodeClass.hh"
 
#include "VuoNode.hh"
 
#include "VuoPort.hh"
 
#include "VuoStringUtilities.hh"
 
const int VuoNodeClass::unreservedInputPortStartIndex = 1;  // 0 is refresh port
const int VuoNodeClass::unreservedOutputPortStartIndex = 0;
const string VuoNodeClass::publishedInputNodeClassName = "vuo.in";
const string VuoNodeClass::publishedOutputNodeClassName = "vuo.out";
const string VuoNodeClass::publishedInputNodeIdentifier = "PublishedInputs";
const string VuoNodeClass::publishedOutputNodeIdentifier = "PublishedOutputs";
 
VuoNodeClass::VuoNodeClass(string className, vector<string> inputPortClassNames, vector<string> outputPortClassNames)
    : VuoBase<VuoCompilerNodeClass,void>("VuoNodeClass with string ports"),
      VuoModule(className)
{
    updateTypecastNodeClassStatus();
 
    this->refreshPortClass = new VuoPortClass("refresh", VuoPortClass::eventOnlyPort);
    inputPortClasses.push_back(this->refreshPortClass);
    this->deprecated = false;
 
    for (vector<string>::iterator i = inputPortClassNames.begin(); i != inputPortClassNames.end(); ++i)
    {
        VuoPortClass *portClass = new VuoPortClass(*i, VuoPortClass::dataAndEventPort);
        inputPortClasses.push_back(portClass);
    }
    for (vector<string>::iterator i = outputPortClassNames.begin(); i != outputPortClassNames.end(); ++i)
    {
        VuoPortClass *portClass = new VuoPortClass(*i, VuoPortClass::dataAndEventPort);
        outputPortClasses.push_back(portClass);
    }
}
 
VuoNodeClass::VuoNodeClass(string className, VuoPortClass * refreshPortClass, vector<VuoPortClass *> inputPortClasses, vector<VuoPortClass *> outputPortClasses)
    : VuoBase<VuoCompilerNodeClass,void>("VuoNodeClass with actual ports"),
      VuoModule(className)
{
    updateTypecastNodeClassStatus();
 
    this->refreshPortClass = refreshPortClass;
    this->inputPortClasses = inputPortClasses;
    this->outputPortClasses = outputPortClasses;
}
 
VuoNodeClass::~VuoNodeClass(void)
{
    for (vector<VuoPortClass *>::iterator i = inputPortClasses.begin(); i != inputPortClasses.end(); ++i)
        delete *i;
 
    for (vector<VuoPortClass *>::iterator i = outputPortClasses.begin(); i != outputPortClasses.end(); ++i)
        delete *i;
}
 
VuoNode * VuoNodeClass::newNode(string title, double x, double y)
{
    string nodeTitle = title.empty() ? getDefaultTitle() : title;
 
    vector<VuoPort *> inputPorts;
    VuoPort * refreshPort = NULL;
    for (vector<VuoPortClass *>::iterator it = inputPortClasses.begin(); it != inputPortClasses.end(); ++it)
    {
        VuoPort * p = new VuoPort(*it);
        inputPorts.push_back(p);
        if (*it == refreshPortClass)
            refreshPort = p;
    }
 
    vector<VuoPort *> outputPorts;
    for (vector<VuoPortClass *>::iterator it = outputPortClasses.begin(); it != outputPortClasses.end(); ++it)
    {
        VuoPort * p = new VuoPort(*it);
        outputPorts.push_back(p);
    }
 
    return new VuoNode(this, nodeTitle, refreshPort, inputPorts, outputPorts, x, y);
}
 
VuoNode * VuoNodeClass::newNode(VuoNode *nodeToCopyMetadataFrom)
{
    VuoNode *clonedNode = newNode();
 
    clonedNode->setTitle(nodeToCopyMetadataFrom->getTitle());
    clonedNode->setX(nodeToCopyMetadataFrom->getX());
    clonedNode->setY(nodeToCopyMetadataFrom->getY());
    clonedNode->setTintColor(nodeToCopyMetadataFrom->getTintColor());
 
    return clonedNode;
}
 
string VuoNodeClass::getClassName(void)
{
    return getModuleKey();
}
 
bool VuoNodeClass::isTypecastNodeClass(void)
{
    return _isTypecastNodeClass;
}
 
void VuoNodeClass::updateTypecastNodeClassStatus()
{
    string nodeClassName = getClassName();
    _isTypecastNodeClass = (VuoStringUtilities::beginsWith(nodeClassName, "vuo.type")
            || (VuoStringUtilities::beginsWith(nodeClassName, "vuo.data.summarize") && nodeClassName != "vuo.data.summarize.VuoData")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.math.round")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.count.")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.get.first.")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.get.last.")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.populated.")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.get.random.")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.point.length")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.scene.frameRequest.get")
            || VuoStringUtilities::beginsWith(nodeClassName, "vuo.transform.get.")
            || nodeClassName == "vuo.audio.mix"
            || nodeClassName == "vuo.audio.populated"
            || nodeClassName == "vuo.image.get.height"
            || nodeClassName == "vuo.image.get.width"
            || nodeClassName == "vuo.image.populated"
            || nodeClassName == "vuo.layer.combine.group"
            || nodeClassName == "vuo.layer.get.child"
            || nodeClassName == "vuo.layer.populated"
            || nodeClassName == "vuo.mesh.populated"
            || nodeClassName == "vuo.scene.combine.group"
            || nodeClassName == "vuo.scene.get.child"
            || nodeClassName == "vuo.scene.populated"
            || nodeClassName == "vuo.text.populated"
            || nodeClassName == "vuo.window.cursor.populated");
 
#if 0
    if (inputPortClasses.size() != VuoNodeClass::unreservedInputPortStartIndex+1)
        return false;
    if (inputPortClasses[VuoNodeClass::unreservedInputPortStartIndex]->getPortType() != VuoPortClass::dataAndEventPort)
        return false;
 
    if (outputPortClasses.size() != VuoNodeClass::unreservedOutputPortStartIndex+1)
        return false;
    VuoPortClass::PortType outputPortType = outputPortClasses[VuoNodeClass::unreservedOutputPortStartIndex]->getPortType();
    if ( !(outputPortType == VuoPortClass::dataAndEventPort || outputPortType == VuoPortClass::eventOnlyPort) )
        return false;
 
    return true;
#endif
}
 
bool VuoNodeClass::isDrawerNodeClass(void)
{
    string nodeClassName = getClassName();
    return (VuoStringUtilities::beginsWith(nodeClassName, "vuo.list.make.") ||
            VuoStringUtilities::beginsWith(nodeClassName, "vuo.dictionary.make."));
}
 
vector<string> VuoNodeClass::getExampleCompositionFileNames(void)
{
    return exampleCompositionFileNames;
}
 
void VuoNodeClass::setExampleCompositionFileNames(vector<string> exampleCompositionFileNames)
{
    this->exampleCompositionFileNames = exampleCompositionFileNames;
}
 
bool VuoNodeClass::getDeprecated(void)
{
    return deprecated;
}
 
void VuoNodeClass::setDeprecated(bool deprecated)
{
    this->deprecated = deprecated;
}
 
VuoPortClass * VuoNodeClass::getRefreshPortClass(void)
{
    return refreshPortClass;
}
 
void VuoNodeClass::setRefreshPortClass(VuoPortClass * refreshPortClass)
{
    this->refreshPortClass = refreshPortClass;
}
 
vector<VuoPortClass *> &VuoNodeClass::getInputPortClasses(void)
{
    return inputPortClasses;
}
 
void VuoNodeClass::setInputPortClasses(vector<VuoPortClass *> inputPortClasses)
{
    this->inputPortClasses = inputPortClasses;
}
 
vector<VuoPortClass *> &VuoNodeClass::getOutputPortClasses(void)
{
    return outputPortClasses;
}
 
void VuoNodeClass::setOutputPortClasses(vector<VuoPortClass *> outputPortClasses)
{
    this->outputPortClasses = outputPortClasses;
}
 
void VuoNodeClass::print(void)
{
    printf("VuoNodeClass(%p,\"%s\")",this,getModuleKey().c_str());
    if (hasCompiler())
        printf(" VuoCompilerNodeClass(%p)",getCompiler());
    if (hasRenderer())
        printf(" VuoRendererNodeClass(%p)",getRenderer());
    printf("\n");
 
    for (vector<VuoPortClass *>::iterator it = inputPortClasses.begin(); it != inputPortClasses.end(); ++it)
    {
        printf("\tinput ");
        (*it)->print();
    }
 
    for (vector<VuoPortClass *>::iterator it = outputPortClasses.begin(); it != outputPortClasses.end(); ++it)
    {
        printf("\toutput ");
        (*it)->print();
    }
 
    fflush(stdout);
}