VuoCommandCommon.cc

Go to the documentation of this file.

 
#include "VuoCommandCommon.hh"
#include "VuoCompilerComposition.hh"
#include "VuoCompilerNode.hh"
#include "VuoCompilerPort.hh"
#include "VuoCompilerPortClass.hh"
#include "VuoCompositionMetadata.hh"
#include "VuoEditor.hh"
#include "VuoEditorComposition.hh"
#include "VuoEditorWindow.hh"
#include "VuoNodeClass.hh"
#include "VuoRendererCable.hh"
#include "VuoSubcompositionMessageRouter.hh"
#include "VuoPublishedPort.hh"
 
void VuoCommandCommon::addCable(VuoRendererCable *rc, VuoPort *fromPortAfterAdding, VuoPort *toPortAfterAdding,
                                VuoEditorComposition *composition)
{
    // Case: The cable had already been disconnected from its 'To' port at the time it was deleted.
    if (! toPortAfterAdding)
        toPortAfterAdding = rc->getFloatingEndpointPreviousToPort();
 
    bool willBePublishedInputCable = dynamic_cast<VuoPublishedPort *>(fromPortAfterAdding);
    bool willBePublishedOutputCable = dynamic_cast<VuoPublishedPort *>(toPortAfterAdding);
 
    VuoNode *fromNode = (willBePublishedInputCable?
                             composition->getPublishedInputNode() :
                             fromPortAfterAdding->getRenderer()->getUnderlyingParentNode()->getBase()
                        );
    VuoNode *toNode = (willBePublishedOutputCable?
                           composition->getPublishedOutputNode() :
                           toPortAfterAdding->getRenderer()->getUnderlyingParentNode()->getBase()
                           );
 
    rc->setFrom(fromNode, fromPortAfterAdding);
    rc->setTo(toNode, toPortAfterAdding);
 
    composition->addCable(rc->getBase());
}
 
void VuoCommandCommon::removeCable(VuoRendererCable *rc, VuoEditorComposition *composition)
{
    if (rc->scene() != composition)
        return;
 
    composition->removeCable(rc);
}
 
void VuoCommandCommon::updateCable(VuoRendererCable *rc, VuoPort *updatedFromPort, VuoPort *updatedToPort,
                                    VuoEditorComposition *composition, bool preserveDanglingCables)
{
    VuoNode *updatedFromNode = (updatedFromPort? composition->getUnderlyingParentNodeForPort(updatedFromPort, composition):NULL);
    VuoNode *updatedToNode = (updatedToPort? composition->getUnderlyingParentNodeForPort(updatedToPort, composition):NULL);
 
    // Perform port updates
    rc->setFrom(updatedFromNode, updatedFromPort);
    rc->setTo(updatedToNode, updatedToPort);
 
    // Add cable to composition if appropriate
    if (updatedFromPort && updatedToPort &&
        compositionContainsNode(composition, updatedFromNode) &&
        compositionContainsNode(composition, updatedToNode) &&
        (rc->scene() != composition))
    {
        composition->addCable(rc->getBase());
    }
 
    // Remove cable from composition if appropriate
    else if ((! (preserveDanglingCables ||
                (updatedFromPort && updatedToPort &&
                compositionContainsNode(composition, updatedFromNode) &&
                compositionContainsNode(composition, updatedToNode)))
              )
             && (rc->scene() == composition))
    {
        composition->removeCable(rc);
    }
}
 
bool VuoCommandCommon::compositionContainsNode(VuoEditorComposition *composition, VuoNode *node)
{
    if (node->hasRenderer() && node->getRenderer()->scene() == composition)
        return true;
 
    else if (node->getNodeClass()->getClassName() == VuoNodeClass::publishedInputNodeClassName)
        return true;
 
    else if (node->getNodeClass()->getClassName() == VuoNodeClass::publishedOutputNodeClassName)
        return true;
 
    return false;
}
 
VuoPublishedPort * VuoCommandCommon::publishInternalPort(VuoPort *internalPort, bool forceEventOnlyPublication, string publishedPortName, VuoEditorComposition *composition, bool attemptMerge)
{
    internalPort->getRenderer()->updateGeometry();
    VuoType *publishedPortType = (forceEventOnlyPublication? NULL : ((VuoCompilerPortClass *)(internalPort->getClass()->getCompiler()))->getDataVuoType());
 
    bool mergePerformed = false;
    VuoRendererPublishedPort *externalPort = composition->publishInternalPort(internalPort,
                                                                              forceEventOnlyPublication,
                                                                              publishedPortName,
                                                                              publishedPortType,
                                                                              attemptMerge,
                                                                              &mergePerformed);
    if (!mergePerformed)
        composition->emitPublishedPortNameEditorRequested(externalPort);
 
    return dynamic_cast<VuoPublishedPort *>(externalPort->getBase());
}
 
VuoPublishedPort * VuoCommandCommon::publishInternalExternalPortCombination(VuoPort *internalPort, VuoPublishedPort *externalPort, bool forceEventOnlyPublication, VuoEditorComposition *composition)
{
    bool isInput = internalPort->getRenderer()->getInput();
    composition->addPublishedPort(externalPort, isInput);
 
    // @todo Make use of retrieved mergePerformed value? https://b33p.net/node/7659
    bool mergePerformed;
    VuoPublishedPort *actualExternalPort = dynamic_cast<VuoPublishedPort *>(composition->publishInternalPort(internalPort, forceEventOnlyPublication,
                                                                    externalPort->getClass()->getName(),
                                                                    static_cast<VuoCompilerPortClass *>(externalPort->getClass()->getCompiler())->getDataVuoType(),
                                                                    true, &mergePerformed)->getBase());
 
    return actualExternalPort;
}
 
void VuoCommandCommon::unpublishInternalExternalPortCombination(VuoPort *internalPort, VuoPublishedPort *externalPort, VuoEditorComposition *composition, bool unpublishIsolatedExternalPorts)
{
    bool isInput = internalPort->getRenderer()->getInput();
    internalPort->getRenderer()->updateGeometry();
 
    // Remove the published cable associated with this internal-external port combination, if it has not been
    // removed already.
    VuoCable *publishedCable = internalPort->getCableConnecting(externalPort);
    if (!publishedCable)
    {
        // The cable might have been disconnected by dragging.  Look for a dangling cable that fits the description.
        if (isInput)
        {
        VuoCable *danglingCable = externalPort->getCableConnecting(NULL);
        if (danglingCable && (danglingCable->getRenderer()->getFloatingEndpointPreviousToPort() == internalPort))
            publishedCable = danglingCable;
        }
        else // if (!isInput)
        {
            VuoCable *danglingCable = internalPort->getCableConnecting(NULL);
            if (danglingCable && (danglingCable->getRenderer()->getFloatingEndpointPreviousToPort() == externalPort))
                publishedCable = danglingCable;
        }
    }
 
    if (publishedCable)
        composition->removeCable(publishedCable->getRenderer());
 
    bool noConnectedPorts = externalPort->getConnectedCables().empty();
    if (unpublishIsolatedExternalPorts && noConnectedPorts)
        composition->removePublishedPort(externalPort, isInput);
}
 
VuoCompilerCompositionDiff * VuoCommandCommon::addNodeReplacementToDiff(VuoCompilerCompositionDiff *diffInfo,
                                                                        VuoRendererNode *oldNode, VuoRendererNode *newNode,
                                                                        map<VuoPort *, VuoPort *> updatedPortForOriginalPort,
                                                                        VuoEditorComposition *composition)
{
        if (!oldNode->getBase()->hasCompiler() || !newNode->getBase()->hasCompiler())
            return diffInfo;
 
        // Tell VuoCompositionDiff about the node replacements, since some information can't be inferred from the composition snapshot:
        //  - the fact that a node was replaced if its node class hasn't changed
        //  - for `Calculate` nodes, the mapping from old to new ports on the `Make List` node that holds the variable values
        map<string, string> oldAndNewPortIdentifiers;
        for (VuoPort *oldPort : oldNode->getBase()->getInputPorts())
        {
            VuoPort *newPort = updatedPortForOriginalPort[oldPort];
            if (newPort)
            {
                string oldPortIdentifier = static_cast<VuoCompilerPort *>(oldPort->getCompiler())->getIdentifier();
                string newPortIdentifier = static_cast<VuoCompilerPort *>(newPort->getCompiler())->getIdentifier();
                oldAndNewPortIdentifiers[oldPortIdentifier] = newPortIdentifier;
            }
        }
 
        string oldNodeIdentifier = oldNode->getBase()->getCompiler()->getIdentifier();
        string newNodeIdentifier = newNode->getBase()->getCompiler()->getIdentifier();
 
        string compositionIdentifier = static_cast<VuoEditor *>(qApp)->getSubcompositionRouter()->getCompositionIdentifier(composition);
        diffInfo->addNodeReplacement(compositionIdentifier, oldNodeIdentifier, newNodeIdentifier, oldAndNewPortIdentifiers);
 
        return diffInfo;
}
 
VuoCommandCommon::VuoCommandCommon(VuoEditorWindow *window)
{
    this->window = window;
    this->description = nullptr;
}
 
VuoCommandCommon::~VuoCommandCommon()
{
    free(description);
}
 
void VuoCommandCommon::setDescription(const char *formatString, ...)
{
    va_list args;
    va_start(args, formatString);
    vasprintf(&description, formatString, args);
    va_end(args);
}