{

// 1) Connection requires a port

PortType requiredPort = connectionRequiredPort();

if (requiredPort == PortType::NONE)

{

return false;

}

// 2) connection point is on top of the node port

QPointF connectionPoint = connectionEndScenePosition(requiredPort);

portIndex = nodePortIndexUnderScenePoint(requiredPort,

connectionPoint);

if (portIndex == INVALID)

{

return false;

}

// 3) Node port is vacant

// port should be empty

if (!nodePortIsEmpty(requiredPort, portIndex))

return false;

// 4) Connection type == node port type (not implemented yet)

return true;

{

// 1) Check conditions from 'canConnect'

PortIndex portIndex = INVALID;

if (!canConnect(portIndex))

{

return false;

}

// 2) Assign node to required port in Connection

PortType requiredPort = connectionRequiredPort();

_node->nodeState().setConnection(requiredPort,

portIndex,

_connection);

// 3) Assign Connection to empty port in NodeState

// The port is not longer required after this function

_connection->setNodeToPort(_node, requiredPort, portIndex);

// 4) Adjust Connection geometry

_node->nodeGraphicsObject()->moveConnections();

// 5) Poke model to intiate data transfer

auto outNode = _connection->getNode(PortType::OUT).lock();

if (outNode)

{

PortIndex outPortIndex = _connection->getPortIndex(PortType::OUT);

outNode->onDataUpdated(outPortIndex);

}

return true;

{

PortIndex portIndex =

_connection->getPortIndex(portToDisconnect);

NodeState &state = _node->nodeState();

// clear pointer to Connection in the NodeState

state.getEntries(portToDisconnect)[portIndex].reset();

// 4) Propagate invalid data to IN node

_connection->propagateEmptyData();

// clear Connection side

_connection->clearNode(portToDisconnect);

_connection->setRequiredPort(portToDisconnect);

_connection->getConnectionGraphicsObject()->grabMouse();

return true;

{

auto const &state = _connection->connectionState();

return state.requiredPort();

{

std::unique_ptr<ConnectionGraphicsObject> const &go =

_connection->getConnectionGraphicsObject();

ConnectionGeometry& geometry = _connection->connectionGeometry();

QPointF endPoint = geometry.getEndPoint(portType);

return go->mapToScene(endPoint);

{

NodeGeometry const &geom = _node->nodeGeometry();

QPointF p = geom.portScenePosition(portIndex, portType);

std::unique_ptr<NodeGraphicsObject> const & ngo =

_node->nodeGraphicsObject();

return ngo->sceneTransform().map(p);

QPointF const & scenePoint) const

{

NodeGeometry const &nodeGeom = _node->nodeGeometry();

QTransform sceneTransform =

_node->nodeGraphicsObject()->sceneTransform();

PortIndex portIndex = nodeGeom.checkHitScenePoint(portType,

scenePoint,

sceneTransform);

return portIndex;

{

NodeState const & nodeState = _node->nodeState();

auto const & entries = nodeState.getEntries(portType);

return (!entries[portIndex].lock());