: _registry(registry)

{

setItemIndexMethod(QGraphicsScene::NoIndex);

ResetHistory();

auto UpdateLamda = [this](Node& n, const QPointF& newPosition, const QPointF &oldPosition)

{

resolveGroups(n);

QUuid id = n.id();

AddAction(

UndoRedoAction(

[this, id, oldPosition](void *)

{

UniqueNode n = _nodes[id];

n->nodeGraphicsObject().setPos(oldPosition);

return 0;

},

[this, id, newPosition](void *)

{

UniqueNode n = _nodes[id];

n->nodeGraphicsObject().setPos(newPosition);

return 0;

},

"Moved Node " + n.nodeDataModel()->name()

)

);

};

connect(this, &FlowScene::nodeMoveFinished, this, UpdateLamda);

auto GroupUpdateLamda = [this](Group& g, const QPointF& newPosition, const QPointF& oldPosition)

{

resolveGroups(g);

AddAction(UndoRedoAction(

[&g, oldPosition](void *ptr)

{

g.groupGraphicsObject().setPos(oldPosition);

return 0;

},

[&g, newPosition](void *ptr)

{

g.groupGraphicsObject().setPos(newPosition);

return 0;

},

"Moved Group " + g.GetName()

));

};

connect(this, &FlowScene::groupMoveFinished, this, GroupUpdateLamda);

anchors.resize(10);

Node& node,

PortIndex portIndex)

{

auto connection = std::make_shared<Connection>(connectedPort, node, portIndex);

auto cgo = std::make_unique<ConnectionGraphicsObject>(*this, *connection);

// after this function connection points are set to node port

connection->setGraphicsObject(std::move(cgo));

_connections[connection->id()] = connection;

connectionCreated(*connection);

return connection;

PortIndex portIndexIn,

Node& nodeOut,

PortIndex portIndexOut,

QUuid *id)

{

auto connection =

std::make_shared<Connection>(nodeIn,

portIndexIn,

nodeOut,

portIndexOut,

id);

auto cgo = std::make_unique<ConnectionGraphicsObject>(*this, *connection);

// after this function connection points are set to node port

connection->setGraphicsObject(std::move(cgo));

nodeIn.nodeState().setConnection(PortType::In, portIndexIn, *connection);

nodeOut.nodeState().setConnection(PortType::Out, portIndexOut, *connection);

// trigger data propagation

nodeOut.onDataUpdated(portIndexOut);

_connections[connection->id()] = connection;

connectionCreated(*connection);

return connection;

{

QUuid nodeInId = QUuid(connectionJson["in_id"].toString());

QUuid nodeOutId = QUuid(connectionJson["out_id"].toString());

PortIndex portIndexIn = connectionJson["in_index"].toInt();

PortIndex portIndexOut = connectionJson["out_index"].toInt();

auto nodeIn = _nodes[nodeInId].get();

auto nodeOut = _nodes[nodeOutId].get();

std::vector<NodeState::ConnectionPtrSet> connIn = nodeIn->nodeState().getEntries(PortType::In);

std::vector<NodeState::ConnectionPtrSet> connOut = nodeOut->nodeState().getEntries(PortType::Out);

int numConnectionsIn = connIn.size();

int numConnectionsOut = connOut.size();

portIndexIn = std::min(numConnectionsIn - 1, portIndexIn);

portIndexOut = std::min(numConnectionsOut - 1, portIndexOut);

nodeIn->currentInputConnections++;

return createConnection(*nodeIn, portIndexIn, *nodeOut, portIndexOut);

{

QUuid nodeInId = QUuid(connectionJson["in_id"].toString());

QUuid nodeOutId = QUuid(connectionJson["out_id"].toString());

PortIndex portIndexIn = connectionJson["in_index"].toInt();

PortIndex portIndexOut = connectionJson["out_index"].toInt();

auto nodeIn = _nodes[newIn].get();

auto nodeOut = _nodes[newOut].get();

if (!nodeIn || !nodeOut)

return;

createConnection(*nodeIn, portIndexIn, *nodeOut, portIndexOut);

{

connectionDeleted(connection);

connection.removeFromNodes();

_connections.erase(connection.id());

{

// connectionDeleted(connection);

connection->removeFromNodes();

_connections.erase(connection->id());

{

Connection *connection = _connections[id].get();

deleteConnection(connection);

QString modelName = nodeJson["model"].toObject()["name"].toString();

auto dataModel = registry().create(modelName);

if (!dataModel)

throw std::logic_error(std::string("No registered model with name ") +

modelName.toLocal8Bit().data());

auto node = std::make_unique<Node>(std::move(dataModel));

auto ngo = std::make_unique<NodeGraphicsObject>(*this, *node);

node->setGraphicsObject(std::move(ngo));

QUuid newId = QUuid::createUuid();

node->paste(nodeJson, newId);

QPointF pos = mousePos + (node->nodeGraphicsObject().pos() - nodeGroupCentroid);

node->nodeGraphicsObject().setPos(pos);

auto nodePtr = node.get();

_nodes[node->id()] = std::move(node);

nodeCreated(*nodePtr);

nodePtr->updateView();

return newId;

{

// call signal

nodeDeleted(node);

auto deleteConnections =

[&node, this] (PortType portType)

{

auto nodeState = node.nodeState();

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

for (auto &connections : nodeEntries)

{

for (auto const &pair : connections)

deleteConnection(*pair.second);

}

};

deleteConnections(PortType::In);

deleteConnections(PortType::Out);

_nodes.erase(node.id());

{

UniqueNode nodePtr = _nodes[id];

Node &node = *nodePtr;

// call signal

nodeDeleted(node);

auto deleteConnections =

[&node, this] (PortType portType)

{

auto nodeState = node.nodeState();

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

for (auto &connections : nodeEntries)

{

for (auto const &pair : connections)

deleteConnection(*pair.second);

}

};

deleteConnections(PortType::In);

deleteConnections(PortType::Out);

_nodes.erase(node.id());

{

GroupGraphicsObject &ggo = group.groupGraphicsObject();

for(int i=ggo.childItems().size()-1; i>=0; i--)

{

QGraphicsItem *child = ggo.childItems()[i];

NodeGraphicsObject* n = qgraphicsitem_cast<NodeGraphicsObject*>(child);

if(n != nullptr)

{

QPointF position = n->scenePos();

ggo.childItems()[i]->setParentItem(0);

n->setPos(position);

n->moveConnections();

}

}

_groups.erase(group.id());

{

for (const auto& _node : _nodes)

{

visitor(_node.second.get());

}

{

for (const auto& _node : _nodes)

{

visitor(_node.second->nodeDataModel());

}

{

std::set<QUuid> visitedNodesSet;

//A leaf node is a node with no input ports, or all possible input ports empty

auto isNodeLeaf =

[](Node const &node, NodeDataModel const &model)

{

for (size_t i = 0; i < model.nPorts(PortType::In); ++i)

{

auto connections = node.nodeState().connections(PortType::In, i);

if (!connections.empty())

{

return false;

}

}

return true;

};

//Iterate over "leaf" nodes

for (auto const &_node : _nodes)

{

auto const &node = _node.second;

auto model = node->nodeDataModel();

if (isNodeLeaf(*node, *model))

{

visitor(model);

visitedNodesSet.insert(node->id());

}

}

auto areNodeInputsVisitedBefore =

[&](Node const &node, NodeDataModel const &model)

{

for (size_t i = 0; i < model.nPorts(PortType::In); ++i)

{

auto connections = node.nodeState().connections(PortType::In, i);

for (auto& conn : connections)

{

if (visitedNodesSet.find(conn.second->getNode(PortType::Out)->id()) == visitedNodesSet.end())

{

return false;

}

}

}

return true;

};

//Iterate over dependent nodes

while (_nodes.size() != visitedNodesSet.size())

{

for (auto const &_node : _nodes)

{

auto const &node = _node.second;

if (visitedNodesSet.find(node->id()) != visitedNodesSet.end())

continue;

auto model = node->nodeDataModel();

if (areNodeInputsVisitedBefore(*node, *model))

{

visitor(model);

visitedNodesSet.insert(node->id());

}

}

}

{

node.nodeGraphicsObject().setPos(pos);

node.nodeGraphicsObject().moveConnections();

if(group.groupGraphicsObject().isCollapsed()) return;

GroupGraphicsObject& ggo = group.groupGraphicsObject();

QRectF groupRect = ggo.mapRectToScene(ggo.boundingRect());

//Check if the nodes that were inside the group still are (When resizing)

for(int i=ggo.childItems().size()-1; i>=0; i--) {

QGraphicsObject* node = (QGraphicsObject*) ggo.childItems()[i];

QRectF nodeRect = node->mapRectToScene(node->boundingRect());

if(!groupRect.contains(nodeRect)) {

QPointF scenePos = node->scenePos();

node->setParentItem(nullptr);

ggo.childItems().removeAt(i);

node->setPos(scenePos);

}

}

//Check all the the other things that collide the group at its new location

QList<QGraphicsItem*>others = collidingItems(&ggo, Qt::IntersectsItemBoundingRect);

for(int i=0; i<others.size(); i++) {

QGraphicsItem* other = others[i];

NodeGraphicsObject* ngo = dynamic_cast<NodeGraphicsObject*>(other);

GroupGraphicsObject* ggo1 = dynamic_cast<GroupGraphicsObject*>(other);

if(ngo || ggo1) {

QRectF otherRect = other->mapRectToScene(other->boundingRect());

//checks what is inside

if(groupRect.contains(otherRect)) {

QPointF scenePos = other->scenePos();

QPointF parentPos = ggo.mapFromScene(scenePos);

if(!other->isAncestorOf(&ggo)) {

other->setParentItem(&ggo);

other->setPos(parentPos);

}

} else if(otherRect.contains(groupRect)) { // Checks inside of what it is

QPointF scenePos = ggo.scenePos();

QPointF parentPos = other->mapFromScene(scenePos);

if(!ggo.isAncestorOf(other)) {

ggo.setParentItem(other);

ggo.setPos(parentPos);

}

}

} else {

}

}

ggo.moveConnections();

NodeGraphicsObject& c = n.nodeGraphicsObject();

bool hasIntersect = false;

//Check if the final position is inside a group

for (auto& group : _groups)

{

auto groupPtr = group.second.get();

GroupGraphicsObject* ggo = (GroupGraphicsObject*) groupPtr->_groupGraphicsObject.get();

QRectF groupRect = ggo->mapRectToScene(ggo->boundingRect());

QRectF nodeRect = c.mapRectToScene(c.boundingRect());

if(groupRect.contains(nodeRect)) {

hasIntersect = true;

if(c.parentItem() != ggo) {

QPointF scenePos = c.scenePos();

QPointF parentPos = ggo->mapFromScene(scenePos);

c.setParentItem(ggo);

c.setPos(parentPos);

}

}

}

//Check if it went out of a group

if(!hasIntersect && c.parentItem() != nullptr ) {

QPointF newPos = c.parentItem()->mapToScene(c.pos());

c.setParentItem(nullptr);

c.setPos(newPos);

}

{

QList<QGraphicsItem*> graphicsItems = selectedItems();

std::vector<Node*> ret;

ret.reserve(graphicsItems.size());

for (QGraphicsItem* item : graphicsItems)

{

auto ngo = qgraphicsitem_cast<NodeGraphicsObject*>(item);

if (ngo != nullptr)

{

Node* n = &(ngo->node());

ret.push_back(n);

}

}

return ret;

{

//Manual node cleanup. Simply clearing the holding datastructures doesn't work, the code crashes when

// there are both nodes and connections in the scene. (The data propagation internal logic tries to propagate

// data through already freed connections.)

std::vector<Node*> nodesToDelete;

for (auto& node : _nodes)

{

nodesToDelete.push_back(node.second.get());

}

for (auto& node : nodesToDelete)

{

removeNode(*node);

}

_groups.clear();

// for (auto& group : _groups)

// {

// _groups.erase(group.first);

// }

{

QString fileName =

QFileDialog::getSaveFileName(nullptr,

tr("Open Flow Scene"),

QDir::homePath(),

tr("Flow Scene Files (*.flow)"));

if (!fileName.isEmpty())

{

if (!fileName.endsWith("flow", Qt::CaseInsensitive))

fileName += ".flow";

QFile file(fileName);

if (file.open(QIODevice::WriteOnly))

{

file.write(saveToMemory());

}

}

{

clearScene();

//-------------

QString fileName =

QFileDialog::getOpenFileName(nullptr,

tr("Open Flow Scene"),

QDir::homePath(),

tr("Flow Scene Files (*.flow)"));

if (!QFileInfo::exists(fileName))

return;

QFile file(fileName);

if (!file.open(QIODevice::ReadOnly))

return;

QByteArray wholeFile = file.readAll();

loadFromMemory(wholeFile);

{

QJsonObject sceneJson;

QJsonArray groupsJsonArray;

for (auto const & pair : _groups)

{

auto const &group = pair.second;

groupsJsonArray.append(group->save());

}

sceneJson["groups"] = groupsJsonArray;

QJsonArray nodesJsonArray;

for (auto const & pair : _nodes)

{

auto const &node = pair.second;

nodesJsonArray.append(node->save());

}

sceneJson["nodes"] = nodesJsonArray;

QJsonArray connectionJsonArray;

std::set<std::tuple<QUuid, PortIndex, QUuid, PortIndex>> uniqueConnections;

for (auto const & pair : _connections)

{

auto const &connection = pair.second;

QJsonObject connectionJson = connection->save();

if (!connectionJson.isEmpty())

{

// Extract connection details for duplicate detection

QUuid nodeInId = QUuid(connectionJson["in_id"].toString());

QUuid nodeOutId = QUuid(connectionJson["out_id"].toString());

PortIndex portIndexIn = connectionJson["in_index"].toInt();

PortIndex portIndexOut = connectionJson["out_index"].toInt();

// Create a unique identifier tuple

auto connectionKey = std::make_tuple(nodeInId, portIndexIn, nodeOutId, portIndexOut);

// Only add if we haven't seen this connection before

if (uniqueConnections.find(connectionKey) == uniqueConnections.end())

{

uniqueConnections.insert(connectionKey);

connectionJsonArray.append(connectionJson);

}

}

}

sceneJson["connections"] = connectionJsonArray;

QJsonArray anchorsJsonArray;

for(int i=0; i<anchors.size(); i++) {

QJsonObject anchor;

anchor["position_x"] = anchors[i].position.x();

anchor["position_y"] = anchors[i].position.y();

anchor["scale"] = anchors[i].scale;

anchorsJsonArray.append(anchor);

}

sceneJson["anchors"] = anchorsJsonArray;

QJsonDocument document(sceneJson);

return document.toJson();

{

QJsonObject const jsonDocument = QJsonDocument::fromJson(data).object();

QJsonArray nodesJsonArray = jsonDocument["nodes"].toArray();

for (int i = 0; i < nodesJsonArray.size(); ++i)

{

restoreNode(nodesJsonArray[i].toObject());

}

QJsonArray connectionJsonArray = jsonDocument["connections"].toArray();

for (int i = 0; i < connectionJsonArray.size(); ++i)

{

QJsonObject jsonObject = connectionJsonArray[i].toObject();

QUuid nodeInId = QUuid(jsonObject["in_id"].toString());

auto nodeIn = _nodes[nodeInId].get();

nodeIn->targetInputConnections++;

}

std::stable_sort( connectionJsonArray.begin( ), connectionJsonArray.end( ), [this]( const auto& lhs, const auto& rhs )

{

QPointF posA, posB;

QString nameA, nameB;

{

QJsonObject objA = lhs.toObject();

QUuid nodeInId = QUuid(objA["in_id"].toString());

PortIndex portIndexIn = objA["in_index"].toInt();

auto nodeIn = _nodes[nodeInId].get();

NodeGraphicsObject & ngo = nodeIn->nodeGraphicsObject();

posA = ngo.scenePos();

NodeDataModel *dm = nodeIn->nodeDataModel();

nameA = dm->name();

}

{

QJsonObject objB = rhs.toObject();

QUuid nodeInId = QUuid(objB["in_id"].toString());

PortIndex portIndexIn = objB["in_index"].toInt();

auto nodeIn = _nodes[nodeInId].get();

NodeGraphicsObject & ngo = nodeIn->nodeGraphicsObject();

posB = ngo.scenePos();

NodeDataModel *dm = nodeIn->nodeDataModel();

nameB = dm->name();

}

//We put input variables at the end, so we only compute them when all the data is loaded.

if (QString::compare(nameA, QString("InputVariable")) == 0 && QString::compare(nameB, QString("InputVariable")) != 0) {

return false;

}

else if (QString::compare(nameB, QString("InputVariable")) == 0 && QString::compare(nameA, QString("InputVariable")) != 0) {

return true;

}

else {

return posA.x() < posB.x();

}

});

for (int i = 0; i < connectionJsonArray.size(); ++i)

{

restoreConnection(connectionJsonArray[i].toObject());

}

QJsonArray groupsJsonArray = jsonDocument["groups"].toArray();

for (int i = 0; i < groupsJsonArray.size(); ++i)

{

restoreGroup(groupsJsonArray[i].toObject());

}

if(jsonDocument.contains("anchors")) {

QJsonArray anchorsJsonArray = jsonDocument["anchors"].toArray();