update

QFD/shemeFlow/FlowGraphNodeWidget.cpp

@@ -0,0 +1,46 @@
+#include "FlowGraphNodeWidget.h"
+
+#include <QBoxLayout>
+#include <QLabel>
+#include <QCheckBox>
+#include <QComboBox>
+
+FlowGraphNodeWidget::FlowGraphNodeWidget(NodeWidgetType type, QWidget *parent) : QWidget(parent), m_type(type)
+{
+    setFixedSize(QSize(100, 40));
+}
+
+FlowGraphNodeWidget::NodeWidgetType FlowGraphNodeWidget::type() const
+{
+    return m_type;
+}
+
+FlowGraphPlainNodeWidget::FlowGraphPlainNodeWidget(QWidget *parent) : FlowGraphNodeWidget(Plain, parent)
+{
+    m_label = new QLabel(this);
+    m_label->setText("test");
+    m_label->setAlignment(Qt::AlignCenter);
+
+    QBoxLayout *l = new QVBoxLayout(this);
+    l->addWidget(m_label);
+}
+
+FlowGraphCheckNodeWidget::FlowGraphCheckNodeWidget(QWidget *parent) : FlowGraphNodeWidget(CheckBox, parent)
+{
+    m_checkBox = new QCheckBox(this);
+
+    QBoxLayout *l = new QVBoxLayout(this);
+    l->addWidget(m_checkBox);
+}
+
+FlowGraphComboNodeWidget::FlowGraphComboNodeWidget(QWidget *parent) : FlowGraphNodeWidget(ComboBox, parent)
+{
+    m_combo = new QComboBox(this);
+    m_combo->addItem("算法一");
+    m_combo->addItem("算法二");
+    m_combo->addItem("算法三");
+    m_combo->addItem("算法四");
+
+    QBoxLayout *l = new QVBoxLayout(this);
+    l->addWidget(m_combo);
+}

QFD/shemeFlow/FlowGraphNodeWidget.h

@@ -0,0 +1,63 @@
+#ifndef FLOWGRAPHNODEWIDGET_H
+#define FLOWGRAPHNODEWIDGET_H
+
+#include <QWidget>
+
+class QLabel;
+class QCheckBox;
+class QComboBox;
+
+class FlowGraphNodeWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    enum NodeWidgetType
+    {
+        Plain,
+        CheckBox,
+        ComboBox,
+        DoubleComboBox,
+    };
+
+    explicit FlowGraphNodeWidget(NodeWidgetType type, QWidget *parent = nullptr);
+
+    NodeWidgetType type() const;
+
+signals:
+
+protected:
+    NodeWidgetType m_type = Plain;
+};
+
+class FlowGraphPlainNodeWidget : public FlowGraphNodeWidget
+{
+    Q_OBJECT
+public:
+    explicit FlowGraphPlainNodeWidget(QWidget *parent = nullptr);
+
+private:
+    QLabel *m_label = nullptr;
+};
+
+class FlowGraphCheckNodeWidget : public FlowGraphNodeWidget
+{
+    Q_OBJECT
+public:
+    explicit FlowGraphCheckNodeWidget(QWidget *parent = nullptr);
+
+private:
+    QCheckBox *m_checkBox = nullptr;
+};
+
+class FlowGraphComboNodeWidget : public FlowGraphNodeWidget
+{
+    Q_OBJECT
+public:
+    explicit FlowGraphComboNodeWidget(QWidget *parent = nullptr);
+
+private:
+    QComboBox *m_combo = nullptr;
+};
+
+#endif  // FLOWGRAPHNODEWIDGET_H

QFD/shemeFlow/FlowTemplateDataModel.cpp

@@ -1,3 +1,17 @@
 #include "FlowTemplateDataModel.h"
 
+#include "FlowGraphNodeWidget.h"
+
 FlowTemplateDataModel::FlowTemplateDataModel() : NodeDelegateModel() { }
+
+QWidget *FlowTemplateDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
+
+    return m_widget;
+}
+
+void FlowTemplateDataModel::setEmbeddedWidget(FlowGraphNodeWidget *w)
+{
+    m_widget = w;
+}

QFD/shemeFlow/FlowTemplateDataModel.h

@@ -4,6 +4,10 @@
 #include <QtNodes/NodeDelegateModel>
 
 #include <QObject>
+#include <QLabel>
+#include <QComboBox>
+#include <Widgets/ComboBox.h>
+#include <Widgets/Menu.h>
 
 using QtNodes::NodeData;
 using QtNodes::NodeDataType;
@@ -11,10 +15,12 @@ using QtNodes::NodeDelegateModel;
 using QtNodes::PortIndex;
 using QtNodes::PortType;
 
+class FlowGraphNodeWidget;
+
 class FlowTemplateData : public NodeData
 {
 public:
-    NodeDataType type() const override { return NodeDataType { "FlowTemplateData", "谢谢谢谢" }; }
+    NodeDataType type() const override { return NodeDataType { "FlowTemplateData", "" }; }
 };
 
 class FlowTemplateDataModel : public NodeDelegateModel
@@ -28,6 +34,10 @@ public:
 
     QString caption() const override { return QString("流程样板模型"); }
 
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType, PortIndex) const override { return "hello"; }
+
     QString name() const override { return QString("FlowTemplateData"); }
 
     unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
@@ -41,7 +51,57 @@ public:
 
     void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
 
-    QWidget *embeddedWidget() override { return nullptr; }
+    QWidget *embeddedWidget() override;
+
+    void setEmbeddedWidget(FlowGraphNodeWidget *w);
+
+private:
+    FlowGraphNodeWidget *m_widget = nullptr;
+};
+
+enum FlowDataType
+{
+    FlowDataTypeLabel,
+    FlowDataTypeCheckBox,
+    FlowDataTypeCombox,
+    FlowDataTypeDoubleComboBox,
+};
+
+class FlowTextDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowTextDataModel();
+
+    ~FlowTextDataModel() = default;
+
+    QString caption() const override { return QString("流程样板模型"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType, PortIndex) const override { return "hello"; }
+
+    QString name() const override { return QString("FlowTextData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowTemplateData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowTemplateData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowTextData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowTextData", "" }; }
 };
 
 #endif  // FLOWTEMPLARTEDATAMODEL_H

QFD/shemeFlow/ShemeFlowPanel.cpp

@@ -2,6 +2,7 @@
 #include "FlowGraphModel.h"
 #include "FlowTemplateDataModel.h"
 #include "ShemeFlowPanel.h"
+#include "FlowGraphNodeWidget.h"
 
 #include <QtNodes/BasicGraphicsScene>
 #include <QtNodes/ConnectionStyle>
@@ -99,6 +100,11 @@ ShemeFlowPanel::ShemeFlowPanel(QWidget *parent) : QWidget(parent)
         NodeId id1 = graphModel->addNode(FlowTemplateData().type().id);
         graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, 0));
 
+        FlowGraphNodeWidget *w1 = new FlowGraphPlainNodeWidget();
+        graphModel->setNodeData(id1, NodeRole::Widget, qVariantFromValue(w1));
+
+        graphModel->setNodeData(id1, NodeRole::Caption, qVariantFromValue(QString("构建指标体系")));
+
         NodeId id2 = graphModel->addNode(FlowTemplateData().type().id);
         graphModel->setNodeData(id2, NodeRole::Position, QPointF(300, 300));
 
@@ -117,7 +123,6 @@ ShemeFlowPanel::ShemeFlowPanel(QWidget *parent) : QWidget(parent)
 
     QCheckBox *cb1 = new QCheckBox("Nodes are locked");
     QCheckBox *cb2 = new QCheckBox("Connections detachable");
-    cb2->setChecked(true);
 
     QVBoxLayout *vbl = new QVBoxLayout;
     vbl->addWidget(cb1);
@@ -133,6 +138,12 @@ ShemeFlowPanel::ShemeFlowPanel(QWidget *parent) : QWidget(parent)
 
     l->addWidget(groupBox);
 
+    graphModel->setNodesLocked(true);
+    graphModel->setDetachPossible(false);
+
+    cb1->setChecked(true);
+    cb2->setChecked(false);
+
     this->setWindowTitle("Locked Nodes and Connections");
     this->resize(800, 600);
 #else

QFD/shemeFlow/shemeFlow.pri

@@ -1,10 +1,12 @@
 HEADERS += \
     $$PWD/DataFlowModel.h \
     $$PWD/FlowGraphModel.h \
+    $$PWD/FlowGraphNodeWidget.h \
     $$PWD/FlowTemplateDataModel.h \
     $$PWD/ShemeFlowPanel.h
 
 SOURCES += \
     $$PWD/FlowGraphModel.cpp \
+    $$PWD/FlowGraphNodeWidget.cpp \
     $$PWD/FlowTemplateDataModel.cpp \
     $$PWD/ShemeFlowPanel.cpp

QFD/widgets/SchemeFlowWidget.cpp

@@ -8,6 +8,10 @@
 #include <QBoxLayout>
 #include <QDebug>
 
+#include <QtNodes/GraphicsView>
+
+using QtNodes::GraphicsView;
+
 static std::shared_ptr<NodeDelegateModelRegistry> registerDataModels()
 {
     auto ret = std::make_shared<NodeDelegateModelRegistry>();
@@ -87,8 +91,6 @@ SchemeFlowWidget::~SchemeFlowWidget()
 void SchemeFlowWidget::initWidgets()
 {
 
-#if 1
-
     graphModel = new DataFlowModel(registerDataModels());
 
     // Initialize and connect two nodes.
@@ -97,9 +99,14 @@ void SchemeFlowWidget::initWidgets()
         graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, 0));
 
         NodeId id2 = graphModel->addNode(FlowTemplateData().type().id);
-        graphModel->setNodeData(id2, NodeRole::Position, QPointF(300, 300));
+        graphModel->setNodeData(id2, NodeRole::Position, QPointF(200, 0));
 
         graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });
+
+        NodeId id3 = graphModel->addNode(FlowTemplateData().type().id);
+        graphModel->setNodeData(id3, NodeRole::Position, QPointF(400, 0));
+
+        graphModel->addConnection(ConnectionId { id2, 0, id3, 0 });
     }
 
     auto scene = new DataFlowGraphicsScene(*graphModel);
@@ -132,44 +139,6 @@ void SchemeFlowWidget::initWidgets()
 
     this->setWindowTitle("Locked Nodes and Connections");
     this->resize(800, 600);
-
-#else
-
-    // Initialize and connect two nodes.
-    {
-        NodeId id1 = m_graphModel.addNode();
-        m_graphModel.setNodeData(id1, NodeRole::Position, QPointF(0, 0));
-
-        NodeId id2 = m_graphModel.addNode();
-        m_graphModel.setNodeData(id2, NodeRole::Position, QPointF(300, 300));
-
-        m_graphModel.addConnection(ConnectionId { id1, 0, id2, 0 });
-    }
-
-    auto scene = new BasicGraphicsScene(m_graphModel);
-
-    m_view = new GraphicsView(scene, this);
-
-    //    // Setup context menu for creating new nodes.
-    m_view->setContextMenuPolicy(Qt::ActionsContextMenu);
-    QAction *createNodeAction = new QAction(QStringLiteral("Create Node"), m_view);
-    QObject::connect(createNodeAction, &QAction::triggered, [&]() {
-        // Mouse position in scene coordinates.
-        QPointF posView = m_view->mapToScene(m_view->mapFromGlobal(QCursor::pos()));
-
-        NodeId const newId = m_graphModel.addNode();
-        m_graphModel.setNodeData(newId, NodeRole::Position, posView);
-    });
-    m_view->insertAction(m_view->actions().front(), createNodeAction);
-
-    m_view->setWindowTitle("Simple Node Graph");
-    m_view->resize(800, 600);
-
-#endif
 }
 
-void SchemeFlowWidget::initLayout()
-{
-    m_layout = new QHBoxLayout(this);
-    m_layout->addWidget(m_view);
-}
+void SchemeFlowWidget::initLayout() { }

QFD/widgets/SchemeFlowWidget.h

@@ -11,21 +11,22 @@
 #include <QtNodes/BasicGraphicsScene>
 #include <QtNodes/ConnectionStyle>
 #include <QtNodes/DataFlowGraphicsScene>
-#include <QtNodes/GraphicsView>
+//#include <QtNodes/GraphicsView>
 #include <QtNodes/GraphicsViewStyle>
 #include <QtNodes/NodeDelegateModelRegistry>
 
 using QtNodes::BasicGraphicsScene;
 using QtNodes::ConnectionStyle;
 using QtNodes::DataFlowGraphicsScene;
-using QtNodes::GraphicsView;
+// using QtNodes::GraphicsView;
 using QtNodes::GraphicsViewStyle;
 using QtNodes::NodeDelegateModelRegistry;
 using QtNodes::NodeRole;
 using QtNodes::NodeStyle;
 
+// class GraphicsView;
+
 class ProjectInfo;
-class FlowGraphModel;
 
 class QHBoxLayout;
 
@@ -47,8 +48,7 @@ private:
     ProjectInfo *m_proj = nullptr;
     int m_indexType     = 0;
 
-    GraphicsView *m_view = nullptr;
-    FlowGraphModel m_graphModel;
+    //    GraphicsView *m_view = nullptr;
 
     DataFlowModel *graphModel = nullptr;
 

QtNodes/include/QtNodes/internal/DataFlowGraphModel.hpp

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "AbstractGraphModel.hpp"
 #include "ConnectionIdUtils.hpp"
@@ -35,9 +35,7 @@ public:
 
     std::unordered_set<ConnectionId> allConnectionIds(NodeId const nodeId) const override;
 
-    std::unordered_set<ConnectionId> connections(NodeId nodeId,
-                                                 PortType portType,
-                                                 PortIndex portIndex) const override;
+    std::unordered_set<ConnectionId> connections(NodeId nodeId, PortType portType, PortIndex portIndex) const override;
 
     bool connectionExists(ConnectionId const connectionId) const override;
 
@@ -55,15 +53,9 @@ public:
 
     bool setNodeData(NodeId nodeId, NodeRole role, QVariant value) override;
 
-    QVariant portData(NodeId nodeId,
-                      PortType portType,
-                      PortIndex portIndex,
-                      PortRole role) const override;
+    QVariant portData(NodeId nodeId, PortType portType, PortIndex portIndex, PortRole role) const override;
 
-    bool setPortData(NodeId nodeId,
-                     PortType portType,
-                     PortIndex portIndex,
-                     QVariant const &value,
+    bool setPortData(NodeId nodeId, PortType portType, PortIndex portIndex, QVariant const &value,
                      PortRole role = PortRole::Data) override;
 
     bool deleteConnection(ConnectionId const connectionId) override;
@@ -79,9 +71,9 @@ public:
     void load(QJsonObject const &json) override;
 
     /**
-   * Fetches the NodeDelegateModel for the given `nodeId` and tries to cast the
-   * stored pointer to the given type
-   */
+     * Fetches the NodeDelegateModel for the given `nodeId` and tries to cast the
+     * stored pointer to the given type
+     */
     template<typename NodeDelegateModelType>
     NodeDelegateModelType *delegateModel(NodeId const nodeId)
     {
@@ -106,15 +98,15 @@ private:
 
 private Q_SLOTS:
     /**
-   * Fuction is called in three cases:
-   *
-   * - By underlying NodeDelegateModel when a node has new data to propagate.
-   *   @see DataFlowGraphModel::addNode
-   * - When a new connection is created.
-   *   @see DataFlowGraphModel::addConnection
-   * - When a node restored from JSON an needs to send data downstream.
-   *   @see DataFlowGraphModel::loadNode
-   */
+     * Fuction is called in three cases:
+     *
+     * - By underlying NodeDelegateModel when a node has new data to propagate.
+     *   @see DataFlowGraphModel::addNode
+     * - When a new connection is created.
+     *   @see DataFlowGraphModel::addConnection
+     * - When a node restored from JSON an needs to send data downstream.
+     *   @see DataFlowGraphModel::loadNode
+     */
     void onOutPortDataUpdated(NodeId const nodeId, PortIndex const portIndex);
 
     /// Function is called after detaching a connection.
@@ -130,6 +122,7 @@ private:
     std::unordered_set<ConnectionId> _connectivity;
 
     mutable std::unordered_map<NodeId, NodeGeometryData> _nodeGeometryData;
+    mutable std::unordered_map<NodeId, QString> _captionData;
 };
 
-} // namespace QtNodes
+}  // namespace QtNodes

QtNodes/src/DataFlowGraphModel.cpp

@@ -1,4 +1,4 @@
-#include "DataFlowGraphModel.hpp"
+#include "DataFlowGraphModel.hpp"
 #include "ConnectionIdHash.hpp"
 
 #include <QJsonArray>
@@ -8,9 +8,9 @@
 namespace QtNodes {
 
 DataFlowGraphModel::DataFlowGraphModel(std::shared_ptr<NodeDelegateModelRegistry> registry)
-    : _registry(std::move(registry))
-    , _nextNodeId{0}
-{}
+    : _registry(std::move(registry)), _nextNodeId { 0 }
+{
+}
 
 std::unordered_set<NodeId> DataFlowGraphModel::allNodeIds() const
 {
@@ -24,28 +24,20 @@ std::unordered_set<ConnectionId> DataFlowGraphModel::allConnectionIds(NodeId con
 {
     std::unordered_set<ConnectionId> result;
 
-    std::copy_if(_connectivity.begin(),
-                 _connectivity.end(),
-                 std::inserter(result, std::end(result)),
-                 [&nodeId](ConnectionId const &cid) {
-                     return cid.inNodeId == nodeId || cid.outNodeId == nodeId;
-                 });
+    std::copy_if(_connectivity.begin(), _connectivity.end(), std::inserter(result, std::end(result)),
+                 [&nodeId](ConnectionId const &cid) { return cid.inNodeId == nodeId || cid.outNodeId == nodeId; });
 
     return result;
 }
 
-std::unordered_set<ConnectionId> DataFlowGraphModel::connections(NodeId nodeId,
-                                                                 PortType portType,
+std::unordered_set<ConnectionId> DataFlowGraphModel::connections(NodeId nodeId, PortType portType,
                                                                  PortIndex portIndex) const
 {
     std::unordered_set<ConnectionId> result;
 
-    std::copy_if(_connectivity.begin(),
-                 _connectivity.end(),
-                 std::inserter(result, std::end(result)),
+    std::copy_if(_connectivity.begin(), _connectivity.end(), std::inserter(result, std::end(result)),
                  [&portType, &portIndex, &nodeId](ConnectionId const &cid) {
-                     return (getNodeId(portType, cid) == nodeId
-                             && getPortIndex(portType, cid) == portIndex);
+                     return (getNodeId(portType, cid) == nodeId && getPortIndex(portType, cid) == portIndex);
                  });
 
     return result;
@@ -63,35 +55,22 @@ NodeId DataFlowGraphModel::addNode(QString const nodeType)
     if (model) {
         NodeId newId = newNodeId();
 
-        connect(model.get(),
-                &NodeDelegateModel::dataUpdated,
-                [newId, this](PortIndex const portIndex) {
-                    onOutPortDataUpdated(newId, portIndex);
-                });
+        connect(model.get(), &NodeDelegateModel::dataUpdated,
+                [newId, this](PortIndex const portIndex) { onOutPortDataUpdated(newId, portIndex); });
 
-        connect(model.get(),
-                &NodeDelegateModel::portsAboutToBeDeleted,
-                this,
+        connect(model.get(), &NodeDelegateModel::portsAboutToBeDeleted, this,
                 [newId, this](PortType const portType, PortIndex const first, PortIndex const last) {
                     portsAboutToBeDeleted(newId, portType, first, last);
                 });
 
-        connect(model.get(),
-                &NodeDelegateModel::portsDeleted,
-                this,
-                &DataFlowGraphModel::portsDeleted);
+        connect(model.get(), &NodeDelegateModel::portsDeleted, this, &DataFlowGraphModel::portsDeleted);
 
-        connect(model.get(),
-                &NodeDelegateModel::portsAboutToBeInserted,
-                this,
+        connect(model.get(), &NodeDelegateModel::portsAboutToBeInserted, this,
                 [newId, this](PortType const portType, PortIndex const first, PortIndex const last) {
                     portsAboutToBeInserted(newId, portType, first, last);
                 });
 
-        connect(model.get(),
-                &NodeDelegateModel::portsInserted,
-                this,
-                &DataFlowGraphModel::portsInserted);
+        connect(model.get(), &NodeDelegateModel::portsInserted, this, &DataFlowGraphModel::portsInserted);
 
         _models[newId] = std::move(model);
 
@@ -106,26 +85,23 @@ NodeId DataFlowGraphModel::addNode(QString const nodeType)
 bool DataFlowGraphModel::connectionPossible(ConnectionId const connectionId) const
 {
     auto getDataType = [&](PortType const portType) {
-        return portData(getNodeId(portType, connectionId),
-                        portType,
-                        getPortIndex(portType, connectionId),
+        return portData(getNodeId(portType, connectionId), portType, getPortIndex(portType, connectionId),
                         PortRole::DataType)
-            .value<NodeDataType>();
+                .value<NodeDataType>();
     };
 
     auto portVacant = [&](PortType const portType) {
-        NodeId const nodeId = getNodeId(portType, connectionId);
+        NodeId const nodeId       = getNodeId(portType, connectionId);
         PortIndex const portIndex = getPortIndex(portType, connectionId);
-        auto const connected = connections(nodeId, portType, portIndex);
+        auto const connected      = connections(nodeId, portType, portIndex);
 
-        auto policy = portData(nodeId, portType, portIndex, PortRole::ConnectionPolicyRole)
-                          .value<ConnectionPolicy>();
+        auto policy = portData(nodeId, portType, portIndex, PortRole::ConnectionPolicyRole).value<ConnectionPolicy>();
 
         return connected.empty() || (policy == ConnectionPolicy::Many);
     };
 
-    return getDataType(PortType::Out).id == getDataType(PortType::In).id
-           && portVacant(PortType::Out) && portVacant(PortType::In);
+    return getDataType(PortType::Out).id == getDataType(PortType::In).id && portVacant(PortType::Out)
+            && portVacant(PortType::In);
 }
 
 void DataFlowGraphModel::addConnection(ConnectionId const connectionId)
@@ -134,16 +110,10 @@ void DataFlowGraphModel::addConnection(ConnectionId const connectionId)
 
     sendConnectionCreation(connectionId);
 
-    QVariant const portDataToPropagate = portData(connectionId.outNodeId,
-                                                  PortType::Out,
-                                                  connectionId.outPortIndex,
-                                                  PortRole::Data);
+    QVariant const portDataToPropagate =
+            portData(connectionId.outNodeId, PortType::Out, connectionId.outPortIndex, PortRole::Data);
 
-    setPortData(connectionId.inNodeId,
-                PortType::In,
-                connectionId.inPortIndex,
-                portDataToPropagate,
-                PortRole::Data);
+    setPortData(connectionId.inNodeId, PortType::In, connectionId.inPortIndex, portDataToPropagate, PortRole::Data);
 }
 
 void DataFlowGraphModel::sendConnectionCreation(ConnectionId const connectionId)
@@ -212,7 +182,7 @@ QVariant DataFlowGraphModel::nodeData(NodeId nodeId, NodeRole role) const
 
     case NodeRole::Style: {
         auto style = StyleCollection::nodeStyle();
-        result = style.toJson().toVariantMap();
+        result     = style.toJson().toVariantMap();
     } break;
 
     case NodeRole::InternalData: {
@@ -272,13 +242,14 @@ bool DataFlowGraphModel::setNodeData(NodeId nodeId, NodeRole role, QVariant valu
 
     case NodeRole::Size: {
         _nodeGeometryData[nodeId].size = value.value<QSize>();
-        result = true;
+        result                         = true;
     } break;
 
     case NodeRole::CaptionVisible:
         break;
 
     case NodeRole::Caption:
+        _captionData[nodeId] = value.value<QString>();
         break;
 
     case NodeRole::Style:
@@ -300,10 +271,7 @@ bool DataFlowGraphModel::setNodeData(NodeId nodeId, NodeRole role, QVariant valu
     return result;
 }
 
-QVariant DataFlowGraphModel::portData(NodeId nodeId,
-                                      PortType portType,
-                                      PortIndex portIndex,
-                                      PortRole role) const
+QVariant DataFlowGraphModel::portData(NodeId nodeId, PortType portType, PortIndex portIndex, PortRole role) const
 {
     QVariant result;
 
@@ -340,8 +308,8 @@ QVariant DataFlowGraphModel::portData(NodeId nodeId,
     return result;
 }
 
-bool DataFlowGraphModel::setPortData(
-    NodeId nodeId, PortType portType, PortIndex portIndex, QVariant const &value, PortRole role)
+bool DataFlowGraphModel::setPortData(NodeId nodeId, PortType portType, PortIndex portIndex, QVariant const &value,
+                                     PortRole role)
 {
     Q_UNUSED(nodeId);
 
@@ -385,8 +353,7 @@ bool DataFlowGraphModel::deleteConnection(ConnectionId const connectionId)
     if (disconnected) {
         sendConnectionDeletion(connectionId);
 
-        propagateEmptyDataTo(getNodeId(PortType::In, connectionId),
-                             getPortIndex(PortType::In, connectionId));
+        propagateEmptyDataTo(getNodeId(PortType::In, connectionId), getPortIndex(PortType::In, connectionId));
     }
 
     return disconnected;
@@ -420,8 +387,8 @@ QJsonObject DataFlowGraphModel::saveNode(NodeId const nodeId) const
         QPointF const pos = nodeData(nodeId, NodeRole::Position).value<QPointF>();
 
         QJsonObject posJson;
-        posJson["x"] = pos.x();
-        posJson["y"] = pos.y();
+        posJson["x"]         = pos.x();
+        posJson["y"]         = pos.y();
         nodeJson["position"] = posJson;
     }
 
@@ -467,11 +434,8 @@ void DataFlowGraphModel::loadNode(QJsonObject const &nodeJson)
     std::unique_ptr<NodeDelegateModel> model = _registry->create(delegateModelName);
 
     if (model) {
-        connect(model.get(),
-                &NodeDelegateModel::dataUpdated,
-                [restoredNodeId, this](PortIndex const portIndex) {
-                    onOutPortDataUpdated(restoredNodeId, portIndex);
-                });
+        connect(model.get(), &NodeDelegateModel::dataUpdated,
+                [restoredNodeId, this](PortIndex const portIndex) { onOutPortDataUpdated(restoredNodeId, portIndex); });
 
         _models[restoredNodeId] = std::move(model);
 
@@ -484,8 +448,7 @@ void DataFlowGraphModel::loadNode(QJsonObject const &nodeJson)
 
         _models[restoredNodeId]->load(internalDataJson);
     } else {
-        throw std::logic_error(std::string("No registered model with name ")
-                               + delegateModelName.toLocal8Bit().data());
+        throw std::logic_error(std::string("No registered model with name ") + delegateModelName.toLocal8Bit().data());
     }
 }
 
@@ -511,9 +474,7 @@ void DataFlowGraphModel::load(QJsonObject const &jsonDocument)
 
 void DataFlowGraphModel::onOutPortDataUpdated(NodeId const nodeId, PortIndex const portIndex)
 {
-    std::unordered_set<ConnectionId> const &connected = connections(nodeId,
-                                                                    PortType::Out,
-                                                                    portIndex);
+    std::unordered_set<ConnectionId> const &connected = connections(nodeId, PortType::Out, portIndex);
 
     QVariant const portDataToPropagate = portData(nodeId, PortType::Out, portIndex, PortRole::Data);
 
@@ -524,9 +485,9 @@ void DataFlowGraphModel::onOutPortDataUpdated(NodeId const nodeId, PortIndex con
 
 void DataFlowGraphModel::propagateEmptyDataTo(NodeId const nodeId, PortIndex const portIndex)
 {
-    QVariant emptyData{};
+    QVariant emptyData {};
 
     setPortData(nodeId, PortType::In, portIndex, emptyData, PortRole::Data);
 }
 
-} // namespace QtNodes
+}  // namespace QtNodes