Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "nodeview.h"
++ #include "effectmanager.h"
++
++ NodeView::NodeView(QQuickItem *parent)
++ : QQuickItem(parent)
++ {
++ setAcceptedMouseButtons(Qt::AllButtons);
++ setAcceptHoverEvents(true);
++ m_nodesModel = new NodesModel();
++ m_arrowsModel = new ArrowsModel();
++
++ // Create main and output nodes
++ // These always exist
++ NodesModel::Node n1{0, 0, 220, 50, 80, 80, "Main"};
++ NodesModel::Node n2{1, 1, 220, 400, 80, 80, "Output"};
++ initializeNodeSize(n1);
++ initializeNodeSize(n2);
++ n1.nextNodeId = 1;
++ m_nodesModel->m_nodesList << n1;
++ m_nodesModel->m_nodesList << n2;
++
++ // Connect source & output by default
++ ArrowsModel::Arrow a1{0, 0, 0, 0, 0, 1};
++ m_arrowsModel->m_arrowsList << a1;
++
++ updateArrowsPositions();
++ m_activeArrow.startNodeId = -1;
++ m_activeArrow.endNodeId = -1;
++
++ connect(m_nodesModel, &QAbstractItemModel::modelReset,
++ this, &NodeView::updateCodeSelectorModel);
++ }
++
++ void NodeView::mouseMoveEvent(QMouseEvent *event)
++ {
++ // Nodes not moved with right button
++ if (event->buttons() & Qt::RightButton)
++ return;
++
++ m_nodesModel->beginResetModel();
++ QPointF movement = event->position() - m_pressPosition;
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.selected) {
++ float newX = node.startX + movement.x();
++ float newY = node.startY + movement.y();
++ // Don't allow dragging outside the visible nodeview area.
++ newX = std::max(newX, float(-node.width / 2.0f));
++ newX = std::min(newX, float(width() - node.width / 2.0f));
++ newY = std::max(newY, float(-node.height / 2.0f));
++ newY = std::min(newY, float(height() - node.height / 2.0f));
++ node.x = newX;
++ node.y = newY;
++ }
++ }
++ m_nodesModel->endResetModel();
++
++ updateArrowsPositions();
++ }
++
++ void NodeView::mousePressEvent(QMouseEvent *event)
++ {
++ m_mousePressed = true;
++
++ setFocus(true);
++
++ QPointF p = event->position();
++ m_pressPosition = p;
++ bool shiftPressed = (event->modifiers() & Qt::ShiftModifier);
++
++ m_nodesModel->beginResetModel();
++ m_arrowsModel->beginResetModel();
++
++ // Reset the nodes starting positions
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.selected) {
++ node.startX = node.x;
++ node.startY = node.y;
++ }
++ }
++
++ bool connectorPressed = false;
++ if (!m_activeArrowEnabled) {
++ m_activeArrow.startNodeId = -1;
++ m_activeArrow.endNodeId = -1;
++ }
++ // Check node connectors first
++ for (auto &node : m_nodesModel->m_nodesList) {
++ float size = 20;
++ // Start is bottom side and end top side of the node.
++ QPointF startConnectorCenter = { node.x + node.width / 2, node.y + node.height};
++ QPointF endConnectorCenter = { node.x + node.width / 2, node.y };
++ QRectF startConnector(startConnectorCenter.x() - size / 2, startConnectorCenter.y() - size / 2, size, size);
++ QRectF endConnector(endConnectorCenter.x() - size / 2, endConnectorCenter.y() - size / 2, size, size);
++ if (startConnector.contains(p)) {
++ m_activeArrowStartPoint = startConnectorCenter;
++ emit activeArrowStartPointChanged();
++ m_activeArrowEndPoint = startConnectorCenter;
++ emit activeArrowEndPointChanged();
++ connectorPressed = true;
++ m_activeArrow.startNodeId = node.nodeId;
++ // Remove possible already existing arrow
++ for (auto &arrow : m_arrowsModel->m_arrowsList) {
++ if (arrow.startNodeId == node.nodeId) {
++ // Update nextNode
++ node.nextNodeId = -1;
++ m_arrowsModel->m_arrowsList.removeAll(arrow);
++ }
++ }
++ } else if (endConnector.contains(p)) {
++ m_activeArrowStartPoint = endConnectorCenter;
++ emit activeArrowStartPointChanged();
++ m_activeArrowEndPoint = endConnectorCenter;
++ emit activeArrowEndPointChanged();
++ connectorPressed = true;
++ m_activeArrow.endNodeId = node.nodeId;
++ // Remove possible already existing arrow
++ for (auto &arrow : m_arrowsModel->m_arrowsList) {
++ if (arrow.endNodeId == node.nodeId) {
++ // Update nextNode
++ if (auto n = m_nodesModel->getNodeWithId(arrow.startNodeId))
++ n->nextNodeId = -1;
++ m_arrowsModel->m_arrowsList.removeAll(arrow);
++ }
++ }
++ }
++ // Don't allow connecting same node out & in together
++ if (m_activeArrow.startNodeId != -1 && m_activeArrow.startNodeId == m_activeArrow.endNodeId) {
++ m_activeArrow.startNodeId = -1;
++ m_activeArrow.endNodeId = -1;
++ }
++ }
++
++ // True when pressing a node that was already selected
++ bool selectedNodeUnderMouse = false;
++ NodesModel::Node newlySelectedNode;
++ if (!connectorPressed) {
++ for (auto &node : m_nodesModel->m_nodesList) {
++ node.startX = node.x;
++ node.startY = node.y;
++ QRectF nodeArea(node.x, node.y, node.width, node.height);
++ if (nodeArea.contains(p)) {
++ if (node.selected)
++ selectedNodeUnderMouse = true;
++ if (shiftPressed)
++ node.selected = !node.selected;
++ else
++ node.selected = true;
++ if (node.selected) {
++ newlySelectedNode = node;
++ break;
++ }
++ }
++ }
++ }
++
++ // Deselected previous nodes
++ if (!shiftPressed && !selectedNodeUnderMouse) {
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (newlySelectedNode != node)
++ node.selected = false;
++ }
++ }
++
++ // Check if both arrow ends are connected
++ if (m_activeArrow.startNodeId >= 0 && m_activeArrow.endNodeId >= 0) {
++ m_arrowsModel->m_arrowsList.append(m_activeArrow);
++ connectorPressed = false;
++ updateArrowsPositions();
++ // Update nextNode
++ auto n1 = m_nodesModel->getNodeWithId(m_activeArrow.startNodeId);
++ if (n1)
++ n1->nextNodeId = m_activeArrow.endNodeId;
++ }
++
++ if (m_activeArrowEnabled != connectorPressed) {
++ m_activeArrowEnabled = connectorPressed;
++ emit activeArrowEnabledChanged();
++ }
++
++ // Check first selected node
++ NodesModel::Node *selectedNode = nullptr;
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.selected) {
++ selectedNode = &node;
++ break;
++ }
++ }
++ setSelectedNode(selectedNode);
++
++ m_nodesModel->endResetModel();
++ m_arrowsModel->endResetModel();
++
++ // Right button opens the context menu
++ if (m_effectNodeSelected && event->button() == Qt::RightButton)
++ Q_EMIT openNodeContextMenu();
++
++ // Check if active (connected) nodes have changed
++ updateActiveNodesList();
++ }
++
++ void NodeView::mouseReleaseEvent(QMouseEvent *event)
++ {
++ Q_UNUSED(event)
++ m_mousePressed = false;
++ }
++
++ void NodeView::mouseDoubleClickEvent(QMouseEvent *event)
++ {
++ Q_UNUSED(event)
++ // When double clicking custom nodes or main node
++ if (m_selectedNodeId != -1 && m_selectedNodeId != 1)
++ Q_EMIT doubleClickNode();
++ }
++
++ void NodeView::hoverMoveEvent(QHoverEvent *event)
++ {
++ // If start/end is connected, other side follows mouse
++ if (m_activeArrow.startNodeId >= 0) {
++ m_activeArrowEndPoint = event->position();
++ emit activeArrowEndPointChanged();
++ } else if (m_activeArrow.endNodeId >= 0) {
++ m_activeArrowStartPoint = event->position();
++ emit activeArrowStartPointChanged();
++ }
++
++ // Pass event forward, to e.g. keep SplitView mouse cursor
++ // changes functioning correctly.
++ event->setAccepted(false);
++ }
++
++ void NodeView::keyPressEvent(QKeyEvent *event)
++ {
++ Q_UNUSED(event)
++ }
++
++ void NodeView::keyReleaseEvent(QKeyEvent *event)
++ {
++ Q_UNUSED(event)
++ }
++
++ // Selects the node with \a nodeId and deselects other nodes.
++ void NodeView::selectSingleNode(int nodeId)
++ {
++ m_nodesModel->beginResetModel();
++ // Check first selected node
++ NodesModel::Node *selectedNode = nullptr;
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.nodeId == nodeId) {
++ node.selected = true;
++ selectedNode = &node;
++ } else {
++ node.selected = false;
++ }
++ }
++ setSelectedNode(selectedNode);
++ m_nodesModel->endResetModel();
++ }
++
++ // Selects the Main node and deselects other nodes.
++ void NodeView::selectMainNode()
++ {
++ m_nodesModel->beginResetModel();
++ NodesModel::Node *selectedNode = nullptr;
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.type == 0) {
++ node.selected = true;
++ selectedNode = &node;
++ } else {
++ node.selected = false;
++ }
++ }
++ setSelectedNode(selectedNode);
++ m_nodesModel->endResetModel();
++ }
++
++ void NodeView::setSelectedNode(NodesModel::Node *selectedNode)
++ {
++ if (m_nodesModel->m_selectedNode == selectedNode)
++ return;
++
++ m_nodesModel->setSelectedNode(selectedNode);
++ bool effectNodeSelected = (selectedNode != nullptr && selectedNode->type == 2);
++ if (effectNodeSelected != m_effectNodeSelected) {
++ m_effectNodeSelected = effectNodeSelected;
++ Q_EMIT effectNodeSelectedChanged();
++ }
++
++ bool mainNodeSelected = (selectedNode != nullptr && selectedNode->type == 0);
++ if (mainNodeSelected != m_mainNodeSelected) {
++ m_mainNodeSelected = mainNodeSelected;
++ Q_EMIT mainNodeSelectedChanged();
++ }
++
++ m_selectedNodeId = selectedNode ? selectedNode->nodeId : -1;
++ Q_EMIT selectedNodeIdChanged();
++
++ updateCodeSelectorIndex();
++
++ Q_EMIT selectedNodeFragmentCodeChanged();
++ Q_EMIT selectedNodeVertexCodeChanged();
++ Q_EMIT selectedNodeQmlCodeChanged();
++ Q_EMIT selectedNodeNameChanged();
++ Q_EMIT selectedNodeDescriptionChanged();
++ }
++
++ NodesModel *NodeView::nodesModel() const
++ {
++ return m_nodesModel;
++ }
++
++ ArrowsModel *NodeView::arrowsModel() const
++ {
++ return m_arrowsModel;
++ }
++
++ QPointF NodeView::activeArrowStartPoint() const
++ {
++ return m_activeArrowStartPoint;
++ }
++
++ QPointF NodeView::activeArrowEndPoint() const
++ {
++ return m_activeArrowEndPoint;
++ }
++
++ bool NodeView::activeArrowEnabled() const
++ {
++ return m_activeArrowEnabled;
++ }
++
++ void NodeView::updateArrowsPositions()
++ {
++ m_arrowsModel->beginResetModel();
++ for (auto &arrow : m_arrowsModel->m_arrowsList) {
++ auto node = m_nodesModel->getNodeWithId(arrow.startNodeId);
++ auto node2 = m_nodesModel->getNodeWithId(arrow.endNodeId);
++ if (node && node2) {
++ arrow.startX = node->x + node->width / 2;
++ arrow.startY = node->y + node->height;
++ arrow.endX = node2->x + node2->width / 2;
++ arrow.endY = node2->y;
++ }
++ }
++ m_arrowsModel->endResetModel();
++ }
++
++ void NodeView::updateActiveNodesList()
++ {
++ QList<NodesModel::Node *> nodes;
++ QList<int> nodesIds;
++ auto node = m_nodesModel->getNodeWithId(0);
++ if (!node)
++ return;
++ nodes << node;
++ int nodeId = node ? node->nextNodeId : -1;
++ while (nodeId > 0) {
++ auto n = m_nodesModel->getNodeWithId(nodeId);
++ if (n) {
++ nodes << n;
++ if (!n->disabled)
++ nodesIds << n->nodeId;
++ nodeId = n->nextNodeId;
++ } else {
++ break;
++ }
++ }
++ m_activeNodesIds = nodesIds;
++
++ // Update info of graph being complete (source -> output)
++ bool nodeGraphComplete = false;
++ if (!nodes.isEmpty() && nodes.last()->type == 1)
++ nodeGraphComplete = true;
++
++ if (nodeGraphComplete != m_nodeGraphComplete) {
++ m_nodeGraphComplete = nodeGraphComplete;
++ Q_EMIT nodeGraphCompleteChanged();
++ }
++
++ if (m_activeNodesList != nodes) {
++ m_activeNodesList = nodes;
++ // Don't emit until fully initialized to avoid shader errors
++ if (m_initialized)
++ Q_EMIT activeNodesListChanged();
++ }
++ }
++
++ void NodeView::deleteSelectedNodes()
++ {
++ QList<int> nodes;
++ for (auto &node : m_nodesModel->m_nodesList) {
++ if (node.selected && node.type == 2)
++ nodes << node.nodeId;
++ }
++ m_effectManager->deleteEffectNodes(nodes);
++ }
++
++ QString NodeView::selectedNodeName() const {
++ if (auto selectedNode = m_nodesModel->m_selectedNode)
++ return selectedNode->name;
++ return QString();
++ }
++
++ void NodeView::setSelectedNodeName(const QString &name) {
++ if (auto selectedNode = m_nodesModel->m_selectedNode) {
++ if (selectedNode->name == name)
++ return;
++
++ // Make sure the name is unique
++ QString newName = getUniqueNodeName(name);
++ m_nodesModel->beginResetModel();
++ selectedNode->name = newName;
++ m_nodesModel->endResetModel();
++ Q_EMIT selectedNodeNameChanged();
++ }
++ }
++
++ QString NodeView::selectedNodeDescription() const {
++ if (auto selectedNode = m_nodesModel->m_selectedNode)
++ return selectedNode->description;
++ return QString();
++ }
++
++ void NodeView::setSelectedNodeDescription(const QString &description) {
++ if (auto selectedNode = m_nodesModel->m_selectedNode) {
++ if (selectedNode->description == description)
++ return;
++
++ m_nodesModel->beginResetModel();
++ selectedNode->description = description;
++ m_nodesModel->endResetModel();
++ Q_EMIT selectedNodeDescriptionChanged();
++ }
++ }
++
++ QString NodeView::selectedNodeFragmentCode() const
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode)
++ return selectedNode->fragmentCode;
++ return QString();
++ }
++
++ void NodeView::setSelectedNodeFragmentCode(const QString &newSelectedNodeFragmentCode)
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode) {
++ if (selectedNode->fragmentCode == newSelectedNodeFragmentCode)
++ return;
++ selectedNode->fragmentCode = newSelectedNodeFragmentCode;
++ Q_EMIT selectedNodeFragmentCodeChanged();
++ }
++ }
++
++ QString NodeView::selectedNodeVertexCode() const
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode)
++ return selectedNode->vertexCode;
++ return QString();
++ }
++
++ void NodeView::setSelectedNodeVertexCode(const QString &newSelectedNodeVertexCode)
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode) {
++ if (selectedNode->vertexCode == newSelectedNodeVertexCode)
++ return;
++ selectedNode->vertexCode = newSelectedNodeVertexCode;
++ Q_EMIT selectedNodeVertexCodeChanged();
++ }
++ }
++
++ QString NodeView::selectedNodeQmlCode() const
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode)
++ return selectedNode->qmlCode;
++ return QString();
++ }
++
++ void NodeView::setSelectedNodeQmlCode(const QString &newSelectedNodeQmlCode)
++ {
++ if (auto selectedNode = m_nodesModel->m_selectedNode) {
++ if (selectedNode->qmlCode == newSelectedNodeQmlCode)
++ return;
++ selectedNode->qmlCode = newSelectedNodeQmlCode;
++ Q_EMIT selectedNodeQmlCodeChanged();
++ }
++ }
++
++ bool NodeView::nodeGraphComplete() const
++ {
++ return m_nodeGraphComplete;
++ }
++
++ bool NodeView::effectNodeSelected() const
++ {
++ return m_effectNodeSelected;
++ }
++
++ bool NodeView::mainNodeSelected() const
++ {
++ return m_mainNodeSelected;
++ }
++
++ int NodeView::selectedNodeId() const
++ {
++ return m_selectedNodeId;
++ }
++
++ // Layout the nodes currently in active list
++ void NodeView::layoutNodes(bool distribute)
++ {
++ if (m_activeNodesList.size() < 2)
++ return;
++
++ // Make sure that also non-connected nodes
++ // are inside the visible nodeview area.
++ if (!distribute) {
++ for (auto &node : m_nodesModel->m_nodesList) {
++ float newX = node.x;
++ float newY = node.y;
++ newX = std::max(newX, float(-node.width / 2.0f));
++ newX = std::min(newX, float(width() - node.width / 2.0f));
++ newY = std::max(newY, float(-node.height / 2.0f));
++ newY = std::min(newY, float(height() - node.height / 2.0f));
++ node.x = newX;
++ node.y = newY;
++ }
++ }
++
++ const int nodeCount = m_activeNodesList.size();
++ const float areaHeight = height();
++ const float sideMargin = areaHeight * 0.05f;
++ const float marginY = areaHeight * 0.02f;
++ const float areaWCenter = width() / 2.0f;
++ float origFullHeight = m_activeNodesList.last()->y - m_activeNodesList.first()->y;
++ origFullHeight = std::max(origFullHeight, 100.0f);
++ const float firstY = sideMargin;
++ const float lastY = areaHeight - firstY - m_activeNodesList.last()->height;
++ const float newFullHeight = lastY - firstY;
++ const float yScaling = newFullHeight / origFullHeight;
++ int i = 0;
++ m_nodesModel->beginResetModel();
++ for (const auto &n : m_activeNodesList) {
++ if (!distribute)
++ n->x = areaWCenter - n->width / 2.0f;
++
++ if (i == 0) {
++ n->y = firstY;
++ } else if (i == nodeCount - 1) {
++ n->y = lastY;
++ } else {
++ if (distribute) {
++ n->y = sideMargin + (float(i) / (nodeCount - 1)) * (areaHeight - sideMargin * 2.0f - n->height);
++ } else {
++ n->y = yScaling * n->y;
++ // Make sure that middle nodes Y are between some limits
++ if (auto previousNode = m_activeNodesList.at(i - 1))
++ n->y = std::max(n->y, previousNode->y + previousNode->height + marginY);
++ n->y = std::max(n->y, firstY + marginY + m_activeNodesList.first()->height);
++ n->y = std::min(n->y, lastY - marginY - n->height);
++ }
++ }
++ i++;
++ }
++
++ m_nodesModel->endResetModel();
++ updateArrowsPositions();
++ }
++
++ QStringList NodeView::codeSelectorModel() const
++ {
++ return m_codeSelectorModel;
++ }
++
++ int NodeView::codeSelectorIndex() const
++ {
++ return m_codeSelectorIndex;
++ }
++
++ int NodeView::getNodeIdWithName(const QString &name)
++ {
++ for (const auto &node : m_nodesModel->m_nodesList) {
++ if (node.name == name)
++ return node.nodeId;
++ }
++ return -1;
++ }
++
++ // Update the code selector (combobox) model
++ void NodeView::updateCodeSelectorModel()
++ {
++ QStringList codeSelectorModel;
++ for (const auto &node : m_nodesModel->m_nodesList) {
++ // Hide "Output" node as it currently doesn't contain code
++ if (node.type == NodesModel::DestinationNode)
++ continue;
++ codeSelectorModel << node.name;
++ }
++ if (codeSelectorModel != m_codeSelectorModel) {
++ m_codeSelectorModel = codeSelectorModel;
++ Q_EMIT codeSelectorModelChanged();
++ }
++ }
++
++ // Update the index of code selector (combobox) to match the currectly selected node
++ void NodeView::updateCodeSelectorIndex() {
++ int index = -1;
++ int i = 0;
++ for (const auto &node : m_nodesModel->m_nodesList) {
++ if (node.nodeId == m_selectedNodeId && node.type != NodesModel::DestinationNode) {
++ index = i;
++ break;
++ }
++ if (node.type != NodesModel::DestinationNode)
++ i++;
++ }
++ index = std::min(index, int(m_codeSelectorModel.size() - 1));
++ if (index != m_codeSelectorIndex) {
++ m_codeSelectorIndex = index;
++ Q_EMIT codeSelectorIndexChanged();
++ }
++ }
++
++ void NodeView::toggleNodeDisabled()
++ {
++ if (auto node = m_nodesModel->m_selectedNode) {
++ m_nodesModel->beginResetModel();
++ node->disabled = !node->disabled;
++ m_nodesModel->endResetModel();
++ }
++ updateActiveNodesList();
++ }
++
++
++ // This will return node id, which is not already in use
++ int NodeView::getUniqueNodeId()
++ {
++ if (!m_nodesModel)
++ return 0;
++
++ int id = 0;
++ // Get biggest id + 1
++ for (const auto &node : m_nodesModel->m_nodesList)
++ id = std::max(id, node.nodeId);
++ id++;
++
++ return id;
++ }
++
++ void NodeView::initializeNode(NodesModel::Node &node)
++ {
++ node.type = 2;
++ node.x = 20;
++ node.y = 60;
++ node.nodeId = getUniqueNodeId();
++ initializeNodeSize(node);
++ }
++
++ void NodeView::initializeNodeSize(NodesModel::Node &node)
++ {
++ if (node.type == NodesModel::CustomNode) {
++ node.width = 150;
++ node.height = 50;
++ } else {
++ node.width = 80;
++ node.height = 80;
++ }
++ }
++
++ // Returns unique node name, so name appended with a number.
++ // "Custom" -> "Custom2" -> "Custom3" etc.
++ QString NodeView::getUniqueNodeName(const QString &origName, int counter)
++ {
++ if (!m_nodesModel)
++ return origName;
++
++ // Initially try name as is, then first counter '2'.
++ QString counterString = (counter == 0) ? "" : QString::number(counter + 1);
++ QString name = origName + counterString;
++ counter++;
++ // Bail out just in case
++ if (counter > 99)
++ return name;
++ for (const auto &node : m_nodesModel->m_nodesList) {
++ if (node.name == name) {
++ name = getUniqueNodeName(origName, counter);
++ }
++ }
++ return name;
++ }