: _node(&node)

, _connection(&connection)

, _scene(&scene)

{

// 1) Connection requires a port

PortType requiredPort = connectionRequiredPort();

if (requiredPort == PortType::None)

{

return false;

}

// 1.5) Forbid connecting the node to itself

Node* node = _connection->getNode(oppositePort(requiredPort));

if (node == _node)

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 equals node port type, or there is a registered type conversion that can translate between the two

auto connectionDataType =

_connection->dataType(oppositePort(requiredPort));

auto const &modelTarget = _node->nodeDataModel();

NodeDataType candidateNodeDataType = modelTarget->dataType(requiredPort, portIndex);

if (connectionDataType.id != candidateNodeDataType.id)

{

if (requiredPort == PortType::In)

{

converter = _scene->registry().getTypeConverter(connectionDataType, candidateNodeDataType);

}

else if (requiredPort == PortType::Out)

{

converter = _scene->registry().getTypeConverter(candidateNodeDataType , connectionDataType);

}

return (converter != nullptr);

}

return true;

{

// 1) Check conditions from 'canConnect'

PortIndex portIndex = INVALID;

TypeConverter converter;

if (!canConnect(portIndex, converter))

{

return false;

}

// 1.5) If the connection is possible but a type conversion is needed,

// assign a convertor to connection

if (converter)

{

_connection->setTypeConverter(converter);

}

// 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);

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].clear();

// 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();

{

auto &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);

NodeGraphicsObject& 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);

if (entries[portIndex].empty()) return true;

const auto outPolicy = _node->nodeDataModel()->portOutConnectionPolicy(portIndex);

return ( portType == PortType::Out && outPolicy == NodeDataModel::ConnectionPolicy::Many);