VuoEditorComposition.hh

Go to the documentation of this file.

 
#pragma once
 
#include "VuoCompilerCompositionDiff.hh"
#include "VuoRendererComposition.hh"
#include "VuoRunner.hh"
#ifdef VUO_PRO
#include "VuoMovieExporter.hh"
#endif
 
#include <dispatch/dispatch.h>
 
class VuoCompilerInputEventPort;
class VuoCompilerPort;
class VuoEditorWindow;
class VuoErrorMark;
class VuoErrorPopover;
class VuoInputEditorManager;
class VuoMainWindow;
class VuoModuleManager;
class VuoNodeAndPortIdentifierCache;
class VuoPortPopover;
class VuoProtocol;
 
class VuoEditorComposition : public VuoRendererComposition, public VuoRunnerDelegateAdapter
{
    Q_OBJECT
 
public:
    enum targetComponentType
    {
        targetTypePort,
        targetTypeNodeHeader,
        targetTypeAny
    };
 
    static const qreal componentCollisionRange;  
 
    explicit VuoEditorComposition(VuoMainWindow *window, VuoComposition *baseComposition);
    ~VuoEditorComposition();
    void setCompiler(VuoCompiler *compiler);
    VuoCompiler *getCompiler();
    void setModuleManager(VuoModuleManager *moduleManager);
    VuoModuleManager * getModuleManager(void);
    void setColor(bool isDark);
    void setInputEditorManager(VuoInputEditorManager *inputEditorManager);
    VuoInputEditorManager * getInputEditorManager();
    VuoRendererNode * createNode(QString nodeClassName, string title="", double x=0, double y=0);
    VuoNode * createBaseNode(VuoCompilerNodeClass *nodeClass, VuoNode *modelNode, string title="", double x=0, double y=0);
    VuoNode * createNodeWithMissingImplementation(VuoNodeClass *modelNodeClass, VuoNode *modelNode, string title="", double x=0, double y=0);
    void updateNodeImplementationInPlace(VuoRendererNode *oldNode, VuoNode *newNode);
    void addNode(VuoNode *node, bool nodeShouldBeRendered=true, bool nodeShouldBeGivenUniqueIdentifier=true);
    void removeNode(VuoRendererNode *rn, bool resetState=true);
    void replaceNode(VuoRendererNode *oldNode, VuoNode *newNode);
    void addCable(VuoCable *cable, bool emitHiddenCableNotification=true);
    void removeCable(VuoRendererCable *rc, bool emitHiddenCableNotification=true);
    VuoRendererNode * createAndConnectMakeListNode(VuoNode *toNode, VuoPort *toPort, VuoRendererCable *&rendererCable);
    void createAndConnectDictionaryAttachmentsForNode(VuoNode *node, set<VuoRendererNode *> &createdRendererNodes, set<VuoRendererCable *> &createdRendererCables);
    QList<QGraphicsItem *>  createAndConnectInputAttachments(VuoRendererNode *node, bool createButDoNotAdd=false);
    void modifyComponents(void (^modify)(void));
    bool requiresStructuralChangesAfterValueChangeAtPort(VuoRendererPort *port);
    QAction * getContextMenuDeleteSelectedAction(void);
    QMenu * getContextMenuTints(QMenu *parent = 0);
    void populateChangeNodeMenu(QMenu *menu, VuoRendererNode *node, int matchLimit=0);
    set<VuoRendererCable *> getCablesInternalToSubcomposition(QList<QGraphicsItem *> subcompositionComponents);
    VuoCable * getCableInProgress();
    bool getCableInProgressWasNew();
    bool getMenuSelectionInProgress();
    VuoRendererNode * findNearbyNodeHeader(QPointF scenePos);
    QGraphicsItem * findNearbyComponent(QPointF scenePos, targetComponentType componentType=VuoEditorComposition::targetTypeAny, bool limitPortCollisionRange=true);
    VuoRendererPort * findTargetPortForCableDroppedOnNodeHeader(VuoRendererNode *node);
    VuoRendererPort * findDefaultPortForEventOnlyConnection(VuoRendererNode *node, bool inputPort);
    QRectF internalItemsBoundingRect() const;
    QRectF internalSelectedItemsBoundingRect() const;
    QRectF internalSelectedItemsChildrenBoundingRect() const;
    set<VuoRendererNode *> getSelectedNodes();
    set<VuoRendererComment *> getSelectedComments();
    set<VuoRendererCable *> getSelectedCables(bool includePublishedCables);
    void cancelCableDrag(void);
    void revertCableDrag(void);
    void clearCableEndpointEligibilityHighlighting();
    void clearHoverHighlighting();
    void repaintFeedbackErrorMarks();
    void setIgnoreApplicationStateChangeEvents(bool ignore);
    json_object * getPortValueInRunningComposition(VuoPort *port);
    static string getIdentifierForStaticPort(VuoPort *staticPort, VuoNode *parentNode=NULL);
    VuoPort * getPortWithStaticIdentifier(string portID);
    void updateInternalPortConstant(string portID, string newValue, bool updateInRunningComposition);
    void updatePublishedPortConstant(string portName, string newValue, bool updateInRunningComposition);
    void updatePortConstant(VuoCompilerPort *port, string newValue, bool updateInRunningComposition=true);
    void updateGenericPortTypes(void);
    void createReplacementsToUnspecializePort(VuoPort *port, bool shouldOutputNodesToReplace, map<VuoNode *, string> &nodesToReplace, set<VuoCable *> &cablesToDelete);
    void run(string compositionSnapshot);
    void stop(void);
    bool isRunning(void);
    void updateRunningComposition(string oldCompositionSnapshot, string newCompositionSnapshot, VuoCompilerCompositionDiff *diffInfo = nullptr, set<string> dependenciesUninstalled = set<string>());
    void updateCompositionsThatContainThisSubcomposition(string newCompositionSnapshot);
    void syncInternalPortConstantInRunningComposition(string runningPortID);
    void syncPublishedPortConstantInRunningComposition(string portName);
    void updateInternalPortConstantInRunningComposition(VuoCompilerInputEventPort *port, string constant);
    void updateInternalPortConstantInSubcompositionInstances(string subcompositionPath, string portIdentifier, string constant);
    void updatePublishedInputPortConstantInRunningComposition(VuoPublishedPort *port, string constant);
    VuoRendererPublishedPort * publishInternalPort(VuoPort *port, bool forceEventOnlyPublication, string name="", VuoType *type=NULL, bool attemptMerge=false, bool *mergePerformed=NULL);
    VuoCable * createPublishedCable(VuoPort *externalPort, VuoPort *internalPort, bool forceEventOnlyPublication);
    void addActiveProtocol(VuoProtocol *protocol, bool useUndoStack);
    bool removeActiveProtocol(VuoProtocol *protocol, VuoProtocol *replacementProtocol);
    void removeActiveProtocolWithoutModifyingPorts(VuoProtocol *protocol);
    map<string, string> publishPorts(set<string> portsToPublish);
    string generateSpecialPublishedNameForPort(VuoPort *port);
    VuoProtocol * getActiveProtocol();
    VuoCompilerDriver * getDriverForActiveProtocol();
    bool validateProtocol(VuoEditorWindow *window, bool isExportingMovie);
    void addPublishedPort(VuoPublishedPort *publishedPort, bool isPublishedInput, bool shouldUpdateUi=true);
    int removePublishedPort(VuoPublishedPort *publishedPort, bool isPublishedInput, bool shouldUpdateUi=true);
    void setPublishedPortName(VuoRendererPublishedPort *publishedPort, string name);
    void leftMousePressEventAtNearbyItem(QGraphicsItem *nearbyItem, QGraphicsSceneMouseEvent *event);
    static VuoNode * getUnderlyingParentNodeForPort(VuoPort *runningPort, VuoEditorComposition *composition);
    QGraphicsItem * findNearbyPort(QPointF scenePos, bool limitPortCollisionRange=true);
    VuoRendererColors::HighlightType getEligibilityHighlightingForPort(VuoRendererPort *portToHighlight, VuoRendererPort *fixedPort, bool eventOnlyConnection, map<string, VuoCompilerType *> &types);
    vector<string> findBridgingSolutions(VuoRendererPort *fromPort, VuoRendererPort *toPort, bool toPortIsDragDestination, map<string, VuoCompilerType *> &types);
    bool selectBridgingSolution(VuoRendererPort *fromPort, VuoRendererPort *toPort, bool toPortIsDragDestination, VuoRendererPort **portToSpecialize, string &specializedTypeName, string &typecastToInsert);
    QList<QAction *> getCompatibleTypesForMenu(VuoRendererPort *genericPort, set<string> compatibleTypesInIsolation, set<string> compatibleTypesInContext, bool limitToNodeSet, string nodeSetName="", QMenu *menu=NULL);
    void addTypeActionsToMenu(QList<QAction *> actionList, QMenu *menu);
    vector<string> getAllSpecializedTypeOptions(bool lists);
    void deleteSelectedNodes(string commandDescription="");
    void clear();
 
    // Popovers
    VuoPortPopover * getActivePopoverForPort(string portID);
    void enablePopoverForPort(VuoRendererPort *rp);
    void updatePortPopovers(VuoRendererNode *node=NULL);
    void updateDataInPortPopoverFromRunningTopLevelComposition(VuoEditorComposition *popoverComposition, string popoverCompositionIdentifier, string portID);
    void updateDataInPortPopover(string portID);
    void movePopoversBy(int dx, int dy);
    void disableNondetachedPortPopovers(VuoRendererNode *node=NULL, bool recordWhichPopoversClosed=false);
    void disableStrandedPortPopovers();
    void disableErrorPopovers();
    void disablePopovers();
    void emitCompositionOnTop(bool top);
    void emitPublishedPortNameEditorRequested(VuoRendererPublishedPort *port);
 
    void receivedTelemetryInputPortUpdated(string compositionIdentifier, string portIdentifier, bool receivedEvent, bool receivedData, string dataSummary);
    void receivedTelemetryOutputPortUpdated(string compositionIdentifier, string portIdentifier, bool sentEvent, bool sentData, string dataSummary);
    void receivedTelemetryEventDropped(string compositionIdentifier, string portIdentifier);
    void receivedTelemetryNodeExecutionStarted(string compositionIdentifier, string nodeIdentifier);
    void receivedTelemetryNodeExecutionFinished(string compositionIdentifier, string nodeIdentifier);
    void lostContactWithComposition(void);
 
    bool getShowEventsMode();
    void setShowEventsMode(bool showEventsMode);
    bool hasHiddenInternalCables();
    bool hasHiddenPublishedCables();
    void setTriggerPortToRefire(VuoPort *port);
    VuoPort * getTriggerPortToRefire();
    void refireTriggerPortEvent();
 
    string takeSnapshot(void);
    string generateCompositionHeader();
 
    static string getDefaultNameForPath(const string &compositionPath);
    QString getFormattedName();
    static QString formatCompositionFileNameForDisplay(QString unformattedCompositionFileName);
    static QString formatNodeSetNameForDisplay(QString nodeSetName);
    QString formatTypeNameForDisplay(VuoType *type);
    string getDefaultPublishedPortNameForType(VuoType *type);
 
    void beginDisplayingActivity(bool includePorts=true);
    void stopDisplayingActivity();
 
#ifdef VUO_PRO
#include "pro/VuoEditorComposition_Pro.hh"
#endif
 
public slots:
    void updateFeedbackErrors(VuoRendererPort *targetPort=NULL);
    void renameSelectedNodes();
    void deleteSelectedCompositionComponents();
    void deleteSelectedCompositionComponents(string commandDescription);
    void togglePortPublicationStatus();
    void tintSelectedItems(int tintColor);
    void selectAllCompositionComponents();
    void selectAllComments();
    void deselectAllCompositionComponents();
    void moveSelectedItemsBy(qreal dx, qreal dy);
    void updateGeometryForAllComponents();
    void emitNodeSourceEditorRequested();
 
    // Popovers
    void setPopoverEventsEnabled(bool enable);
    void disablePopoverForPort(string);
 
signals:
    void leftMouseButtonReleased(void); 
    void emptyCanvasLocationLeftClicked(); 
    void itemsMoved(set<VuoRendererNode *> nodes, set<VuoRendererComment *> comments, qreal dx, qreal dy, bool movedByDragging); 
    void commentResized(VuoRendererComment *comment, qreal dx, qreal dy);  
    void selectedComponentsDuplicated(); 
    void componentsAdded(QList<QGraphicsItem *> addedComponents, VuoEditorComposition *target); 
    void componentsRemoved(QList<QGraphicsItem *> removedComponents, string commandDescription="Remove"); 
    void cablesHidden(set<VuoRendererCable *> cables); 
    void selectedInternalCablesHidden();  
    void cablesUnhidden(set<VuoRendererCable *> cables); 
    void changeInHiddenCables(); 
    void portPublicationRequested(VuoPort *port, bool forceEventOnlyPublication);  
    void portPublicationRequested(VuoPort *internalPort, VuoPublishedPort *externalPort, bool forceEventOnlyPublication, VuoPort *portToSpecialize, string specializedTypeName, string typecastToInsert, bool useUndoStackMacro);  
    void portUnpublicationRequested(VuoPort *port);  
    void publishedPortNameEditorRequested(VuoRendererPublishedPort *port, bool useUndoStack);  
    void publishedPortModified();  
    void protocolPortChangesRequested(map<VuoPublishedPort *, string> publishedPortsToRename, set<VuoPublishedPort *> publishedPortsToRemove, vector<VuoPublishedPort *> publishedPortsToAdd, bool beginUndoStackMacro, bool endUndoStackMacro);  
    void activeProtocolChanged();  
    void triggerThrottlingUpdated(VuoPort *port, enum VuoPortClass::EventThrottling eventThrottling);  
    void inputPortCountAdjustmentRequested(VuoRendererNode *node, int inputPortCountDelta, bool requestedByDragging);  
    void commentEditorRequested(VuoRendererComment *comment);  
    void commentZoomRequested(VuoRendererComment *comment);  
    void nodeSwapRequested(VuoRendererNode *node, string newNodeClassName);   
    void specializePort(VuoRendererPort *port, string specializedTypeName);  
    void respecializePort(VuoRendererPort *port, string specializedTypeName);  
    void unspecializePort(VuoRendererPort *port);  
    void highlightPublishedSidebarDropLocationsRequested(VuoRendererPort *port, bool eventOnlyConnection); 
    void clearPublishedSidebarDropLocationHighlightingRequested(); 
    void connectionCompletedByDragging(VuoRendererCable *cableInProgress, VuoRendererPort *targetPort, pair<VuoRendererCable *, VuoRendererCable *> cableArgs, VuoRendererNode *typecastNodeToDelete, pair<string, string> typeArgs, pair<VuoRendererPort *, VuoRendererPort *> portArgs); 
    void duplicationOperationCancelled(); 
    void inputEditorRequested(VuoRendererPort *port); 
    void portConstantChangeRequested(VuoRendererPort *port, string value); 
    void nodeTitleEditorRequested(VuoRendererNode *node); 
    void nodeSourceEditorRequested(VuoRendererNode *node); 
    void subcompositionInsertionRequested(QPointF scenePos); 
    void commentInsertionRequested(QPointF scenePos); 
    void tintSelectedItemsRequested(VuoNode::TintColor tintColor); 
    void compositionStoppedItself(); 
    void buildStarted(); 
    void buildFinished(QString error); 
    void stopFinished(); 
    void nodePopoverRequestedForClass(VuoNodeClass *nodeClass); 
    void popoverDetached(); 
    void compositionOnTop(bool); 
    void applicationActive(bool); 
    void refirePortChanged(); 
    void cableDragInitiated(); 
    void cableDragEnded();
    void undoStackMacroBeginRequested(QString commandName); 
    void undoStackMacroEndRequested(); 
    void refactorRequested(); 
 
protected:
    void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
    void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
    void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
    void dropEvent(QGraphicsSceneDragDropEvent *event);
 
    void mouseDoubleClickEvent (QGraphicsSceneMouseEvent *event);
    void mousePressEvent(QGraphicsSceneMouseEvent *event);
    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
    void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
    void keyPressEvent(QKeyEvent *event);
    void keyReleaseEvent(QKeyEvent *event);
    void contextMenuEvent(QGraphicsSceneContextMenuEvent* event);
 
private:
    void setPortConstantToValue(VuoRendererPort *port, string value);
    void setCustomConstantsForNewNode(VuoRendererNode *newNode);
    void openSelectedEditableNodes();
    string getNonProtocolVariantForPortName(string portName);
    set<string> getRespecializationOptionsForPortInNetwork(VuoRendererPort *port);
    bool canConnectDirectlyWithRespecializationNondestructively(VuoRendererPort *fromPort,
                                                                VuoRendererPort *toPort,
                                                                bool eventOnlyConnection,
                                                                bool forwardConnection);
    bool canConnectDirectlyWithRespecializationNondestructively(VuoRendererPort *fromPort,
                                                                VuoRendererPort *toPort,
                                                                bool eventOnlyConnection,
                                                                bool forwardConnection,
                                                                VuoRendererPort **portToRespecialize,
                                                                string &respecializedTypeName);
    bool canConnectDirectlyWithRespecialization(VuoRendererPort *fromPort,
                                                VuoRendererPort *toPort,
                                                bool eventOnlyConnection,
                                                bool forwardConnection,
                                                VuoRendererPort **portToRespecialize,
                                                string &respecializedTypeName);
    bool canSwapWithoutBreakingCables(VuoRendererNode *origNode, VuoNodeClass *newNodeClass);
    bool portCanBeUnspecializedNondestructively(VuoPort *port);
    bool portsPassSanityCheckToBridge(VuoRendererPort *fromPort, VuoRendererPort *toPort);
    bool portsPassSanityCheckToTypeconvert(VuoRendererPort *fromPort, VuoRendererPort *toPort, VuoType *candidateFromType=NULL, VuoType *candidateToType=NULL);
 
    void fireTriggerPortEvent(VuoPort *port);
    QList<QAction *> promoteSingletonsFromSubmenus(QList<QAction *> actionList);
    static bool nodeSetMenuActionLessThan(QAction *action1, QAction *action2);
    static bool itemHigherOnCanvas(QGraphicsItem *item1, QGraphicsItem *item2);
    static double calculateNodeSimilarity(VuoNodeClass *node1, VuoNodeClass *node2);
 
    // Popovers
    void enableInactivePopoverForPort(VuoRendererPort *rp);
    void disablePopoverForPortThreadSafe(string portID);
    void disablePortPopovers(VuoRendererNode *node=NULL);
    void moveDetachedPortPopoversBy(int dx, int dy);
    void moveErrorPopoversBy(int dx, int dy);
    VuoErrorMark *errorMark;
    set<VuoErrorPopover *> errorPopovers;
    bool errorMarkingUpdatesEnabled;
 
private slots:
    void moveNodesBy(set<VuoRendererNode *> nodes, qreal dx, qreal dy, bool movedByDragging);
    void moveCommentsBy(set<VuoRendererComment *> comments, qreal dx, qreal dy, bool movedByDragging);
    void resizeCommentBy(VuoRendererComment *comment, qreal dx, qreal dy);
    void editSelectedComments();
    void insertNode();
    void insertComment();
    void insertSubcomposition();
    void deleteConnectedCables();
    void hideConnectedCables();
    void unhideConnectedCables();
    void fireTriggerPortEvent();
    void setPortConstant();
    void setTriggerThrottling(int eventThrottling);
    void specializeGenericPortType();
    void unspecializePortType();
    void addInputPort();
    void removeInputPort();
    void swapNode();
    void setDisableDragStickiness(bool disable);
    void updatePortAnimation(qreal value);
    void endPortAnimation(void);
    void expandChangeNodeMenu();
 
    // Popovers
    void updatePopoversForActiveWindowChange(QWidget *old, QWidget *now);
    void updatePopoversForApplicationStateChange(bool active);
    void enablePopoverForNode(VuoRendererNode *rn);
    void repositionPopover();
 
private:
    static const qreal nodeMoveRate;
    static const qreal nodeMoveRateMultiplier;
    static const qreal showEventsModeUpdateInterval;
    static const int initialChangeNodeSuggestionCount;
    VuoMainWindow *window;
    VuoCompiler *compiler;
    VuoModuleManager *moduleManager;
    VuoInputEditorManager *inputEditorManager;
    VuoProtocol *activeProtocol;
    VuoRunner *runner;
    VuoCompilerComposition *runningComposition;
    VuoCompilerDriver *runningCompositionActiveDriver;
    dispatch_queue_t runCompositionQueue;  
    dispatch_queue_t activePortPopoversQueue;  
    bool stopRequested;
    string linkedCompositionPath;
    std::shared_ptr<VuoRunningCompositionLibraries> runningCompositionLibraries;
    QAction *contextMenuDeleteSelected;
    QAction *contextMenuHideSelectedCables;
    QAction *contextMenuRenameSelected;
    QAction *contextMenuRefactorSelected;
    QAction *contextMenuPublishPort;
    QAction *contextMenuDeleteCables;
    QAction *contextMenuHideCables;
    QAction *contextMenuUnhideCables;
    QAction *contextMenuFireEvent;
    QAction *contextMenuAddInputPort;
    QAction *contextMenuRemoveInputPort;
    QAction *contextMenuSetPortConstant;
    QAction *contextMenuEditSelectedComments;
    QMenu *contextMenuChangeNode;
    QList<QAction *> contextMenuThrottlingActions;
    QList<QAction *> contextMenuTintActions;
    bool duplicateOnNextMouseMove;
    bool duplicationDragInProgress;
    bool duplicationCancelled;
    QPointF cursorPosBeforeDuplicationDragMove;
    VuoCable *cableInProgress;
    bool cableInProgressWasNew;
    bool cableInProgressShouldBeWireless;
    VuoRendererPort *portWithDragInitiated;
    VuoRendererCable *cableWithYankInitiated;
    bool menuSelectionInProgress;
    QGraphicsItem *previousNearbyItem;
    VuoNodeAndPortIdentifierCache *identifierCache;
    bool dragStickinessDisabled;
    bool ignoreApplicationStateChangeEvents;
    bool showEventsMode;
    QTimer *refreshComponentAlphaLevelTimer;
    set<QGraphicsItemAnimation *> preparedAnimations;
    map<QTimeLine *, QGraphicsItemAnimation *> animationForTimeline;
    string triggerPortToRefire;
 
    // Popovers
    bool popoverEventsEnabled;
    map<string, VuoPortPopover *> activePortPopovers;
    set<string> portsWithPopoversClosedAtLastEvent;
 
    bool isPortCurrentlyRevertible(VuoRendererPort *port);
    void addActionToMenuAndMapper(QMenu *menu, QSignalMapper *mapper, QString name, int index);
    void mousePressEventNonLeftButton(QGraphicsSceneMouseEvent *event);
    void correctForCancelledDuplication(QGraphicsSceneMouseEvent *event);
    void initiateCableDrag(VuoRendererPort *currentPort, VuoRendererCable *cableYankedDirectly, QGraphicsSceneMouseEvent *event);
    void concludeCableDrag(QGraphicsSceneMouseEvent *event);
    void concludePublishedCableDrag(QGraphicsSceneMouseEvent *event);
    void updateHoverHighlighting(QPointF scenePos, bool disablePortHoverHighlighting=false);
    void highlightEligibleEndpointsForCable(VuoCable *cable);
    void highlightInternalPortsConnectableToPort(VuoRendererPort *port, VuoRendererCable *cable);
    void updateEligibilityHighlightingForPort(VuoRendererPort *portToHighlight, VuoRendererPort *fixedPort, bool eventOnlyConnection, map<string, VuoCompilerType *> &types);
    void updateEligibilityHighlightingForNode(VuoRendererNode *node);
    bool selectBridgingSolutionFromOptions(vector<string> suitableTypecasts, map<string, VuoRendererPort *> portToSpecializeForTypecast, map<string, string> specializedTypeNameForTypecast, string &selectedTypecast);
    vector<string> findBridgingSolutions(VuoRendererPort *fromPort, VuoRendererPort *toPort, bool toPortIsDragDestination, map<string, VuoRendererPort *> &portToSpecializeForTypecast, map<string, string> &specializedTypeNameForTypecast, map<string, VuoCompilerType *> &types);
    bool promptForBridgingSelectionFromOptions(vector<string> suitableTypecasts, map<string, VuoRendererPort *> portToSpecializeForTypecast, map<string, string> specializedTypeNameForTypecast, string &selectedTypecast);
    QString getDisplayTextForSpecializationOption(VuoRendererPort *portToSpecialize, string specializedTypeName);
    bool hasFeedbackErrors(void);
    void buildComposition(string compositionSnapshot, const set<string> &dependenciesUninstalled = set<string>());
    bool isRunningThreadUnsafe(void);
    string getIdentifierForRunningPort(VuoPort *port);
    void moveItemsBy(set<VuoRendererNode *> nodes, set<VuoRendererComment *> comments, qreal dx, qreal dy, bool movedByDragging);
    void setPopoversHideOnDeactivate(bool shouldHide);
 
    QGraphicsItemAnimation * setUpAnimationForPort(QGraphicsItemAnimation *animation, VuoRendererPort *port);
    void animatePort(VuoRendererPort *port);
    QGraphicsItemAnimation * getAvailableAnimationForPort(VuoRendererPort *port);
 
    friend class TestVuoEditor;
};