VuoRendererPublishedPort.cc

Go to the documentation of this file.

 
#include "VuoRendererPublishedPort.hh"
 
#include "VuoCable.hh"
#include "VuoCompilerPort.hh"
 
VuoRendererPublishedPort::VuoRendererPublishedPort(VuoPublishedPort *basePublishedPort, bool isPublishedOutput)
    : VuoRendererPort(basePublishedPort,
                      NULL,
                      // "Published input" ports are *output* ports within the published input node,
                      // and vice versa.
                      !isPublishedOutput,
                      false,
                      false
                      )
{
    this->compositionViewportPos = QPoint();
    this->isActive = false;
    this->permanent = false;
 
    setFlag(QGraphicsItem::ItemIsSelectable, true);
    updateNameRect();
}
 
void VuoRendererPublishedPort::setName(string name)
{
    getBase()->getClass()->setName(name);
    updateNameRect();
}
 
bool VuoRendererPublishedPort::canAccommodateInternalPort(VuoRendererPort *internalPort, bool eventOnlyConnection)
{
    if (! isCompatibleAliasWithSpecializationForInternalPort(internalPort, eventOnlyConnection))
        return false;
 
    // If this is a published output port that already has has a connected data-carrying cable,
    // it cannot accommodate another data-carrying cable.
    bool isPublishedOutput = getInput();
    if (isPublishedOutput && !eventOnlyConnection)
    {
        foreach (VuoCable *connectedCable, getBase()->getConnectedCables(true))
            if (connectedCable->getRenderer()->effectivelyCarriesData() &&
                    connectedCable->getFromNode() &&
                    connectedCable->getToNode())
            {
                return false;
            }
    }
 
    return true;
}
 
bool VuoRendererPublishedPort::isCompatibleAliasWithoutSpecializationForInternalPort(VuoRendererPort *internalPort, bool eventOnlyConnection)
{
    // Temporarily disallow direct cable connections between published inputs and published outputs.
    // @todo: Allow for https://b33p.net/kosada/node/7756 .
    if (dynamic_cast<VuoRendererPublishedPort *>(internalPort))
        return false;
 
    bool isPublishedInput = !getInput();
    return (isPublishedInput? canConnectDirectlyWithoutSpecializationTo(internalPort, eventOnlyConnection) :
                              internalPort->canConnectDirectlyWithoutSpecializationTo(this, eventOnlyConnection));
}
 
bool VuoRendererPublishedPort::isCompatibleAliasWithSpecializationForInternalPort(VuoRendererPort *internalPort, bool eventOnlyConnection)
{
    VuoRendererPort *portToSpecialize = NULL;
    string specializedTypeName = "";
 
    return this->isCompatibleAliasWithSpecializationForInternalPort(internalPort, eventOnlyConnection, &portToSpecialize, specializedTypeName);
}
 
bool VuoRendererPublishedPort::isCompatibleAliasWithSpecializationForInternalPort(VuoRendererPort *internalPort,
                                                                                  bool eventOnlyConnection,
                                                                                  VuoRendererPort **portToSpecialize,
                                                                                  string &specializedTypeName)
{
    *portToSpecialize = NULL;
    specializedTypeName = "";
 
    if (this->isCompatibleAliasWithoutSpecializationForInternalPort(internalPort, eventOnlyConnection))
        return true;
 
    // Temporarily disallow direct cable connections between published inputs and published outputs.
    // @todo: Allow for https://b33p.net/kosada/node/7756 .
    if (dynamic_cast<VuoRendererPublishedPort *>(internalPort))
        return false;
 
    bool isPublishedInput = !getInput();
    return (isPublishedInput? canConnectDirectlyWithSpecializationTo(internalPort, eventOnlyConnection, portToSpecialize, specializedTypeName) :
                                   internalPort->canConnectDirectlyWithSpecializationTo(this, eventOnlyConnection, portToSpecialize, specializedTypeName));
}
 
bool VuoRendererPublishedPort::canBeMergedWith(VuoPublishedPort *otherExternalPort, bool mergeWillAddData)
{
    bool thisIsPublishedInput = !getInput();
 
    // For these two externally visible published ports to be eligible for merging, they must have the same type.
    if (!otherExternalPort->hasCompiler() ||
            (static_cast<VuoCompilerPort *>(otherExternalPort->getCompiler())->getDataVuoType() != this->getDataType()))
        return false;
 
    // If they are input published ports and their types match, go ahead and merge them.
    if (thisIsPublishedInput)
        return true;
 
    // If they are output published ports and their types match, make sure they will
    // have no more than one connected data-carrying cable between the two of them.
    if (!mergeWillAddData)
        return true;
 
    foreach (VuoCable *connectedCable, getBase()->getConnectedCables(true))
    {
        if (connectedCable->getRenderer()->effectivelyCarriesData())
            return false;
    }
 
    return true;
}
 
QPoint VuoRendererPublishedPort::getCompositionViewportPos(void) const
{
    return compositionViewportPos;
}
 
void VuoRendererPublishedPort::setCompositionViewportPos(QPoint pos)
{
    this->compositionViewportPos = pos;
}
 
void VuoRendererPublishedPort::setCurrentlyActive(bool active)
{
    this->isActive = active;
}
 
bool VuoRendererPublishedPort::getCurrentlyActive()
{
    return this->isActive;
}
 
void VuoRendererPublishedPort::setPermanent(bool permanent)
{
    this->permanent = permanent;
}
 
bool VuoRendererPublishedPort::isPermanent(void)
{
    return permanent;
}
 
QPainterPath VuoRendererPublishedPort::getWirelessAntennaPath() const
{
    return QPainterPath();
}