VuoSubcompositionMessageRouter.cc

Go to the documentation of this file.

 
#include "VuoFileUtilities.hh"
#include "VuoStringUtilities.hh"
#include "VuoCompiler.hh"
#include "VuoCompilerComposition.hh"
#include "VuoCompilerNode.hh"
#include "VuoEditorComposition.hh"
#include "VuoEditorWindow.hh"
 
#include "VuoSubcompositionMessageRouter.hh"
 
VuoSubcompositionMessageRouter::CompositionInfo::CompositionInfo(void)
{
    window = NULL;
    topLevelComposition = NULL;
    supercomposition = NULL;
    nodeIdentifierInSupercomposition = "";
    compositionIdentifier = "";
}
 
VuoSubcompositionMessageRouter::CompositionInfo::CompositionInfo(VuoEditorWindow *window)
{
    this->window = window;
    reset();
}
 
void VuoSubcompositionMessageRouter::CompositionInfo::reset(void)
{
    topLevelComposition = window->getComposition();
    supercomposition = NULL;
    nodeIdentifierInSupercomposition = "";
    compositionIdentifier = VuoCompilerComposition::topLevelCompositionIdentifier;
}
 
VuoSubcompositionMessageRouter::VuoSubcompositionMessageRouter(void)
{
}
 
VuoSubcompositionMessageRouter::~VuoSubcompositionMessageRouter(void)
{
    compositionInfosMutex.lock();
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::addComposition(VuoEditorWindow *window)
{
    compositionInfosMutex.lock();
 
    compositionInfos[window->getComposition()] = CompositionInfo(window);
 
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::removeComposition(VuoEditorWindow *window)
{
    compositionInfosMutex.lock();
 
    map<VuoEditorComposition *, CompositionInfo> *cis[] = { &compositionInfos, &unlinkedCompositionInfos };
    for (int i = 0; i < 2; ++i)
    {
        auto curr = (*cis[i]).find(window->getComposition());
        if (curr != (*cis[i]).end())
            (*cis[i]).erase(curr);
 
        for (auto &c : *cis[i])
            if (c.second.topLevelComposition == window->getComposition())
                c.second.reset();
    }
 
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::linkSubcompositionToNodeInSupercomposition(VuoEditorComposition *subcompositionInstance,
                                                                                VuoEditorComposition *supercomposition,
                                                                                VuoRendererNode *nodeInSupercomposition)
{
    compositionInfosMutex.lock();
 
    auto sub = compositionInfos.find(subcompositionInstance);
    if (sub != compositionInfos.end())
    {
        auto super = compositionInfos.find(supercomposition);
        if (super != compositionInfos.end())
        {
            sub->second.topLevelComposition = super->second.topLevelComposition;
            sub->second.supercomposition = supercomposition;
            sub->second.nodeIdentifierInSupercomposition = nodeInSupercomposition->getBase()->getCompiler()->getIdentifier();
            sub->second.compositionIdentifier = VuoStringUtilities::buildCompositionIdentifier(super->second.compositionIdentifier,
                                                                                              nodeInSupercomposition->getBase()->getCompiler()->getIdentifier());
        }
    }
 
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::unlinkSubcompositionFromNodeInSupercomposition(VuoEditorComposition *subcompositionInstance)
{
    compositionInfosMutex.lock();
 
    auto sub = compositionInfos.find(subcompositionInstance);
    if (sub != compositionInfos.end())
        compositionInfos[sub->first].reset();
 
    sub = unlinkedCompositionInfos.find(subcompositionInstance);
    if (sub != unlinkedCompositionInfos.end())
        unlinkedCompositionInfos.erase(sub);
 
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::unlinkNodeInSupercompositionFromSubcomposition(VuoEditorComposition *supercomposition,
                                                                                    const string &nodeIdentifier)
{
    compositionInfosMutex.lock();
 
    for (auto &c : compositionInfos)
    {
        if (c.second.supercomposition == supercomposition && c.second.nodeIdentifierInSupercomposition == nodeIdentifier)
        {
            unlinkedCompositionInfos[c.first] = c.second;
            c.second.reset();
        }
    }
 
    compositionInfosMutex.unlock();
}
 
void VuoSubcompositionMessageRouter::relinkNodeInSupercompositionToSubcomposition(VuoEditorComposition *supercomposition,
                                                                                  const string &nodeIdentifier)
{
    compositionInfosMutex.lock();
 
    for (map<VuoEditorComposition *, CompositionInfo>::iterator i = unlinkedCompositionInfos.begin(); i != unlinkedCompositionInfos.end(); ++i)
    {
        if (i->second.supercomposition == supercomposition && i->second.nodeIdentifierInSupercomposition == nodeIdentifier)
        {
            compositionInfos[i->first] = i->second;
            unlinkedCompositionInfos.erase(i);
            break;
        }
    }
 
    compositionInfosMutex.unlock();
}
 
string VuoSubcompositionMessageRouter::getCompositionIdentifier(VuoEditorComposition *composition)
{
    compositionInfosMutex.lock();
 
    string compositionIdentifier;
    auto curr = compositionInfos.find(composition);
    if (curr != compositionInfos.end())
        compositionIdentifier = curr->second.compositionIdentifier;
 
    compositionInfosMutex.unlock();
 
    return compositionIdentifier;
}
 
void VuoSubcompositionMessageRouter::applyToLinkedTopLevelComposition(VuoEditorComposition *currComposition,
                                                                      CompositionCallbackWithIdentifier doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    auto curr = compositionInfos.find(currComposition);
    if (curr != compositionInfos.end())
        doForComposition(curr->second.topLevelComposition, curr->second.compositionIdentifier);
 
    compositionInfosMutex.unlock_shared();
}
 
void VuoSubcompositionMessageRouter::applyToLinkedCompositionWithIdentifier(VuoEditorComposition *currComposition,
                                                                            string compositionIdentifier,
                                                                            CompositionCallback doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    auto curr = compositionInfos.find(currComposition);
    if (curr != compositionInfos.end())
        for (auto c : compositionInfos)
            if (c.second.topLevelComposition == curr->second.topLevelComposition && c.second.compositionIdentifier == compositionIdentifier)
                doForComposition(c.first);
 
    compositionInfosMutex.unlock_shared();
}
 
void VuoSubcompositionMessageRouter::applyToAllLinkedCompositions(VuoEditorComposition *currComposition,
                                                                  CompositionCallbackWithIdentifier doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    auto curr = compositionInfos.find(currComposition);
    if (curr != compositionInfos.end())
        for (auto c : compositionInfos)
            if (c.second.topLevelComposition == curr->second.topLevelComposition)
                doForComposition(c.first, c.second.compositionIdentifier);
 
    compositionInfosMutex.unlock_shared();
}
 
void VuoSubcompositionMessageRouter::applyToAllOtherTopLevelCompositions(VuoEditorComposition *currComposition,
                                                                         CompositionCallback doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    for (auto c : compositionInfos)
        if (c.first != currComposition && c.first == c.second.topLevelComposition)
            doForComposition(c.first);
 
    compositionInfosMutex.unlock_shared();
}
 
void VuoSubcompositionMessageRouter::applyIfInstalledAsSubcomposition(VuoEditorComposition *currComposition,
                                                                      CompositionCallbackWithPath doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    auto curr = compositionInfos.find(currComposition);
    if (curr != compositionInfos.end())
    {
        string compositionPath = curr->second.window->windowFilePath().toStdString();
        if (VuoFileUtilities::isInstalledAsModule(compositionPath))
            doForComposition(currComposition, compositionPath);
    }
 
    compositionInfosMutex.unlock_shared();
}
 
void VuoSubcompositionMessageRouter::applyToAllOtherCompositionsInstalledAsSubcompositions(VuoEditorComposition *currComposition,
                                                                                           CompositionCallbackWithPath doForComposition)
{
    compositionInfosMutex.lock_shared();
 
    for (auto c : compositionInfos)
        if (c.first != currComposition)
            applyIfInstalledAsSubcomposition(c.first, doForComposition);
 
    compositionInfosMutex.unlock_shared();
}