Qt编程：QNodeEditor中的Node类

于 2025-07-14 08:29:38 发布
阅读量437 收藏 3
点赞数 13
CC 4.0 BY-SA版权
分类专栏： 可视化编程 文章标签： qt QNodeEditor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WaitingHereFor/article/details/149322341

Node 类是 QtNodes 框架中的核心类之一，代表流程图中的一个节点。它负责管理节点的数据模型、图形表示、状态和连接关系。

主要功能

  1. 节点管理：创建、保存和恢复节点

  2. 数据传播：处理节点间的数据流动

  3. 图形表示：管理节点的可视化部分

  4. 连接处理：管理与该节点相关的连接

#pragma once
#include "ConnectionGraphicsObject.hpp"
#include "Export.hpp"
#include "NodeData.hpp"
#include "NodeGeometry.hpp"
#include "NodeGraphicsObject.hpp"
#include "NodeState.hpp"
#include "PortType.hpp"
#include "Serializable.hpp"
#include "memory.hpp"

#include <QtCore/QJsonObject>
#include <QtCore/QObject>
#include <QtCore/QUuid>
namespace QtNodes
{
    class Connection;
    class ConnectionState;
    class NodeGraphicsObject;
    class NodeDataModel;
    class NODE_EDITOR_PUBLIC Node
        : public QObject
        , public Serializable
    {
        Q_OBJECT
      public:
        /// NodeDataModel should be an rvalue and is moved into the Node
        Node(std::unique_ptr<NodeDataModel> &&dataModel);
        virtual ~Node();

      public:
        QJsonObject save() const override;
        void restore(QJsonObject const &json) override;

      public:
        QUuid id() const;
        void reactToPossibleConnection(PortType, std::shared_ptr<NodeDataType>, QPointF const &scenePoint);
        void resetReactionToConnection();

      public:
        NodeGraphicsObject const &nodeGraphicsObject() const;
        NodeGraphicsObject &nodeGraphicsObject();
        void setGraphicsObject(std::unique_ptr<NodeGraphicsObject> &&graphics);
        NodeGeometry &nodeGeometry();
        NodeGeometry const &nodeGeometry() const;
        NodeState const &nodeState() const;
        NodeState &nodeState();
        NodeDataModel *nodeDataModel() const;
      public Q_SLOTS: // data propagation
        /// Propagates incoming data to the underlying model.
        void propagateData(PortIndex inPortIndex) const;
        /// Fetches data from model's OUT #index port
        /// and propagates it to the connection
        void onDataUpdated(PortIndex index);
        /// update the graphic part if the size of the embeddedwidget changes
        void onNodeSizeUpdated();

      private:
        // addressing
        QUuid _uid;
        // data
        std::unique_ptr<NodeDataModel> _nodeDataModel;
        NodeState _nodeState;
        // painting
        NodeGeometry _nodeGeometry;
        std::unique_ptr<NodeGraphicsObject> _nodeGraphicsObject;
    };
} // namespace QtNodes

#include "Node.hpp"

#include "ConnectionGraphicsObject.hpp"
#include "ConnectionState.hpp"
#include "FlowScene.hpp"
#include "NodeDataModel.hpp"
#include "NodeGraphicsObject.hpp"

#include <QtCore/QObject>
#include <iostream>
#include <utility>
using QtNodes::Node;
using QtNodes::NodeData;
using QtNodes::NodeDataModel;
using QtNodes::NodeDataType;
using QtNodes::NodeGeometry;
using QtNodes::NodeGraphicsObject;
using QtNodes::NodeState;
using QtNodes::PortIndex;
using QtNodes::PortType;
Node::Node(std::unique_ptr<NodeDataModel> &&dataModel)
    : _uid(QUuid::createUuid()), _nodeDataModel(std::move(dataModel)), _nodeState(_nodeDataModel), _nodeGeometry(_nodeDataModel),
      _nodeGraphicsObject(nullptr)
{
    _nodeGeometry.recalculateSize();
    // propagate data: model => node
    connect(_nodeDataModel.get(), &NodeDataModel::dataUpdated, this, &Node::onDataUpdated);
    connect(_nodeDataModel.get(), &NodeDataModel::embeddedWidgetSizeUpdated, this, &Node::onNodeSizeUpdated);
}
Node::~Node() = default;
QJsonObject Node::save() const
{
    QJsonObject nodeJson;
    nodeJson["id"] = _uid.toString();
    nodeJson["model"] = _nodeDataModel->save();
    QJsonObject obj;
    obj["x"] = _nodeGraphicsObject->pos().x();
    obj["y"] = _nodeGraphicsObject->pos().y();
    nodeJson["position"] = obj;
    return nodeJson;
}
void Node::restore(QJsonObject const &json)
{
    _uid = QUuid(json["id"].toString());
    QJsonObject positionJson = json["position"].toObject();
    QPointF point(positionJson["x"].toDouble(), positionJson["y"].toDouble());
    _nodeGraphicsObject->setPos(point);
    _nodeDataModel->restore(json["model"].toObject());
}
QUuid Node::id() const
{
    return _uid;
}
void Node::reactToPossibleConnection(PortType reactingPortType, std::shared_ptr<NodeDataType> reactingDataType, QPointF const &scenePoint)
{
    QTransform const t = _nodeGraphicsObject->sceneTransform();
    QPointF nodePoint = t.inverted().map(scenePoint);
    _nodeGeometry.setDraggingPosition(nodePoint);
    _nodeGraphicsObject->update();
    _nodeState.setReaction(NodeState::REACTING, reactingPortType, reactingDataType);
}
void Node::resetReactionToConnection()
{
    _nodeState.setReaction(NodeState::NOT_REACTING);
    _nodeGraphicsObject->update();
}
NodeGraphicsObject const &Node::nodeGraphicsObject() const
{
    return *_nodeGraphicsObject.get();
}
NodeGraphicsObject &Node::nodeGraphicsObject()
{
    return *_nodeGraphicsObject.get();
}
void Node::setGraphicsObject(std::unique_ptr<NodeGraphicsObject> &&graphics)
{
    _nodeGraphicsObject = std::move(graphics);
    _nodeGeometry.recalculateSize();
}
NodeGeometry &Node::nodeGeometry()
{
    return _nodeGeometry;
}
NodeGeometry const &Node::nodeGeometry() const
{
    return _nodeGeometry;
}
NodeState const &Node::nodeState() const
{
    return _nodeState;
}
NodeState &Node::nodeState()
{
    return _nodeState;
}
NodeDataModel *Node::nodeDataModel() const
{
    return _nodeDataModel.get();
}
void Node::propagateData(PortIndex inPortIndex) const
{
    NodeState const &state = nodeState();
    NodeState::ConnectionPtrSet connections = state.connections(PortType::In, inPortIndex);
    std::vector<std::shared_ptr<NodeData>> nodeData;
    nodeData.reserve(connections.size());
    for (const auto &connection : connections)
    {
        Connection *c = connection.second;
        Node *outNode = c->getNode(PortType::Out);
        PortIndex outNodeIndex = c->getPortIndex(PortType::Out);
        std::shared_ptr<NodeData> outData = outNode->nodeDataModel()->outData(outNodeIndex);
        TypeConverter converter = c->getTypeConverter();
        if (converter != nullptr)
        {
            outData = converter(outData);
        }
        nodeData.push_back(outData);
    }
    _nodeDataModel->setInData(std::move(nodeData), inPortIndex);
    // Recalculate the nodes visuals. A data change can result in the node taking
    // more space than before, so this forces a recalculate+repaint on the affected
    // node
    _nodeGraphicsObject->setGeometryChanged();
    _nodeGeometry.recalculateSize();
    _nodeGraphicsObject->update();
    _nodeGraphicsObject->moveConnections();
}
void Node::onDataUpdated(PortIndex index)
{
    auto connections = _nodeState.connections(PortType::Out, index);
    for (auto const &c : connections) c.second->propagateData();
}
void Node::onNodeSizeUpdated()
{
    if (nodeDataModel()->embeddedWidget())
    {
        nodeDataModel()->embeddedWidget()->adjustSize();
    }
    nodeGeometry().recalculateSize();
    for (PortType type : { PortType::In, PortType::Out })
    {
        for (auto &conn_set : nodeState().getEntries(type))
        {
            for (auto &pair : conn_set)
            {
                Connection *conn = pair.second;
                conn->getConnectionGraphicsObject().move();
            }
        }
    }
}

类成员详解

构造函数

Node(std::unique_ptr<NodeDataModel> &&dataModel)

  • 使用给定的 NodeDataModel 创建一个新节点

  • 自动生成唯一 ID (QUuid)

  • 初始化节点状态、几何信息和图形对象

  • 设置数据模型信号与节点槽的连接

序列化方法

QJsonObject save() const override
void restore(QJsonObject const &json) override

  • save(): 将节点状态保存为 JSON 对象，包括 ID、模型数据和位置

  • restore(): 从 JSON 对象恢复节点状态

节点标识

QUuid id() const

  • 返回节点的唯一标识符

连接反应处理

void reactToPossibleConnection(PortType, std::shared_ptr<NodeDataType>, QPointF const &scenePoint)
void resetReactionToConnection()

  • 处理可能的连接操作时的视觉反馈

  • 重置连接反应状态

访问器方法

// 图形对象访问
NodeGraphicsObject const &nodeGraphicsObject() const
NodeGraphicsObject &nodeGraphicsObject()
void setGraphicsObject(std::unique_ptr<NodeGraphicsObject> &&graphics)

// 几何信息访问
NodeGeometry &nodeGeometry()
NodeGeometry const &nodeGeometry() const

// 状态访问
NodeState const &nodeState() const
NodeState &nodeState()

// 数据模型访问
NodeDataModel *nodeDataModel() const

数据传播槽

void propagateData(PortIndex inPortIndex) const
void onDataUpdated(PortIndex index)
void onNodeSizeUpdated()

  • propagateData(): 将输入端口的数据传播到模型

  • onDataUpdated(): 当模型数据更新时通知连接的连接

  • onNodeSizeUpdated(): 当节点大小变化时更新几何信息和连接位置

内部实现细节

数据成员

  • _uid: 节点的唯一标识符

  • _nodeDataModel: 节点数据模型的唯一指针

  • _nodeState: 节点状态对象，管理连接状态

  • _nodeGeometry: 节点几何信息对象

  • _nodeGraphicsObject: 节点图形对象的唯一指针

数据传播机制

propagateData() 方法实现了从输入连接获取数据并传递给模型的核心逻辑：

  1. 获取指定输入端口的连接集合

  2. 从每个连接的输出节点获取数据

  3. 应用类型转换器（如果有）

  4. 将数据集合传递给模型的 setInData() 方法

  5. 更新节点的视觉表示

使用场景

  1. 创建新节点：通过传入数据模型创建节点

  2. 保存/加载流程图：使用序列化方法保存和恢复节点状态

  3. 处理用户交互：通过图形对象处理鼠标事件

  4. 数据流处理：当连接建立或数据更新时自动传播数据

与其他类的关系

  • NodeDataModel: 包含节点的业务逻辑和数据

  • NodeGraphicsObject: 处理节点的可视化表示

  • NodeGeometry: 管理节点的几何信息

  • NodeState: 跟踪节点的连接状态

  • Connection: 表示节点间的连接关系

Node 类作为这些组件的协调者，将它们整合为一个完整的节点功能单元。

程序执行过程中的堆与栈
键盘与猴子
12-25 2332
1.概念 与数据结构中的栈、堆概念不同。 堆：程序执行过程中的堆是可以动态地扩展和搜索的内存空间，不是连续的内存空间。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。当程序调用malloc、new、free之类的库函数时，堆的大小会变化。 栈：与堆不同，栈的地址是从大到小的连续内存空间，栈顶在底地址端。栈
云原生：详解｜K8s技术栈解析 —--- 一文读懂K8s工作原理
weixin_39552004的博客
10-29 3107
文章比较长，但通俗易懂的工作原理解析： K8s学习办法、K8s标准对象、K8s核心组件、K8s分层架构、K8s架构原则 上一节我们详解了容器的核心技术：详解｜容器核心技术解析 回顾容器主要技术 有 name space做隔离，有Cgroup的资源控制，可以很安全地把一个应用丢到某个隔离环境中去运行，并且不对整个主机产生影响。这个应用要跑起来，需要所支撑的文件系统是overlayFS。上一节主要解析了这些技术。 容器技术，从原理上了解，它是用什么样的方式让容器运行起来的。 K8s学习办法 了
堆与栈的区别（非常经典）
12-02
堆与栈的区别（非常经典），总结的非常全面，共6页！
堆与栈的区别是什么？
08-19
本文主要总结了一下堆与栈的区别。
栈（Stack）与堆（Heap）：内存管理的核心差异与选择指南
最新发布
弘羽
06-12 840
堆和栈是两种不同的内存管理方式。栈由操作系统自动管理，采用后进先出原则，适合局部变量和函数调用，速度快但容量有限。堆需手动分配/释放，适合动态数据和跨函数共享，灵活但速度较慢且可能产生内存碎片。选择依据包括生命周期、数据大小和性能需求。现代语言如Java/Python通过垃圾回收机制自动管理堆内存，而C++可通过智能指针优化堆操作。实际开发中应优先使用栈变量，并借助工具监控内存使用情况。
读书笔记，一文读懂如何调优JAVA程序
04-11
多年经验总结加读书笔记
堆、堆栈、栈、堆和栈这些概念你还分的清楚吗？
让学习成为一种习惯
08-02 1336
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。，是一种运算受限的线性表。
堆栈的定义与实现
z20051118的博客
10-17 310
具有一定约束的线性表，插入和删除操作都作用在一个称为栈顶(Top)的端点位置后入先出/先入后出。
嵌入式开发中的堆与栈
李肖遥的专栏
07-19 5220
关注、星标公众号，直达精彩内容文章内容出处：网路素材整理：李肖遥0.前言堆（Heap）与栈（Stack）是开发人员必须面对的两个概念，在理解这两个概念时，需要放到具体的场景下，因为不同场景下，堆与栈代表不同的含义。一般情况下，有两层含义：（1）程序内存布局场景下，堆与栈表示两种内存管理方式；（2）数据结构场景下，堆与栈表示两种常用的数据结构。1.程序内存分区中的堆...
什么是堆和栈，它们在哪儿？
Joey_zoe的专栏
08-16 1652
什么是堆和栈，它们在哪儿？ 2014/08/15 | 分类： 开发 | 0 条评论 | 标签： 数据结构 分享到：3 原文出处： StackOverflow   译文出处：独酌逸醉   欢迎分享原创到伯乐头条 问题描述 编程语言书籍中经常解释值类型被创建在栈上，引用类型被创建在堆上，但是并没有本质上解释这堆和栈是什么。我仅有高级语言编程经验，没有看
堆和栈
java的天空
11-06 232
理解堆与栈 一、引言：    一直不太明白堆与栈到底是什么，是指一块内存区呢，还是指一种数据结构？编写程序中总提到内存分配的栈与堆的区别，静态与动态分配等，总也弄不明白，隐约知道一点，但总分不清堆与栈到底是一块内存区还是内存分配的方式，或者只是一种数据结构？？？跟杨惠讨论如何建立决策树的时候，她说实际上就是进栈出栈，当时真是一头雾水呀。隐约知道《TIJ》中说栈是存放数据的一个地方（实际是RAM）...
堆和栈的区别
kou2796506061的博客
11-19 166
栈是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；局部值类型变量、值类型 参数等都在栈内存中。 堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小。 ...
一文读懂什么是JVM内存区域
01-20
本地方法栈与虚拟机栈类似，但它服务于Java虚拟机的本地接口，用于支持native方法的调用。每当调用一个本地方法时，就会在此栈上分配栈帧。 6、直接内存（Direct Memory） 直接内存并不是JVM规范中定义的内存区域，...
堆排序VS其他排序：一文读懂如何选择最佳排序策略
排序算法的基本概念与分类 排序算法是计算机科学中的基础算法之一，它涉及将一组数据按照特定的顺序（如数值大小或字典顺序）进行排列。在IT行业中，排序算法被广泛应用于数据处理、数据库管理、文件系统优化以及...
一文读懂JVM虚拟机原理
VampireSF的博客
09-30 737
JVM虚拟机底层原理详解 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 这里写目录标题JVM虚拟机底层原理详解第一章：概述二级目录三级目录第二章：Class文件结构二级目录三级目录第三章：类加载机制二级目录三级目录第四章：JVM内存区域二级目录三级目录第五章：垃圾回收算法（器）二级目录三级目录第六章：JVM调优二级目录三级目录前言一、pandas是什么？二、使
“堆”和“栈”
2301_80355452的博客
05-14 418
堆就像一个灵活的大仓库或仓库的货架，任何时候你都可以存放或取出你需要的东西，没有限制你放在哪里。想象你在超市买了好多东西，堆满了你的购物车。想象你在厨房里做饭，有一堆碗盘，一次只拿一个放进去，拿出来也是“后进先出”的（后放进去的先拿出来），这就像“栈”。
关于“堆栈”的含义及理解
qq_61870465的博客
07-13 8259
其实平时所讲的堆栈一般都指栈，为了好听我们叫它堆栈==1.什么是堆栈？堆栈是一段连续的存储器空间，主要有两个动作：推入push和取出pull，遵循先入后出，后入先出原则，堆栈可以用来完成参数传递和返回值的传递（函数调用），也可以用来保存局部变量、寄存器的值，典型用处是中断，保存案发现场(函数执行断点)。栈：栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量、函数返回地址、寄存器内容等。函数中定义的局部变量按照先后定义的顺序依次压入栈中(从高地址开始放)，栈中存储的数据的生命周期随着函数的执行完成而结
堆、栈，它们到底是什么？看完这篇文章你就明白了！
热门推荐
青轩桃李能几何，流光欺人忽蹉跎
06-26 2万+
特征堆栈定义程序运行时自由存储的内存空间由操作系统自动分配和管理的内存空间管理方式由程序员手动进行分配和释放自动分配和管理内存大小空间较大，动态申请和释放由操作系统指定大小，固定存储方式存储动态分配的对象和复杂数据结构存储基本数据类型和引用类型的地址，用于存储函数调用栈、内存的分配操作、表达式求值的临时变量以及与程序中的控制流相关的数据应用用于动态分配和管理内存，例如创建对象、数组等用于存储函数调用栈、临时变量等优缺点空间较大，但由程序员管理，容易发生内存泄漏或溢出。
Java中内存中的Heap、Stack与程序运行的关系
weixin_30954265的博客
08-18 168
堆和栈的内存管理 栈的内存管理是顺序分配的，而且定长，不存在内存回收问题；而堆 则是随机分配内存，不定长度，存在内存分配和回收的问题；堆内存和栈内存的区别可以用如下的比喻来看出：使用堆内存就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。使用栈内存就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值