Create models in graph

QFD/shemeFlow/FlowGraphNodeWidget.cpp

@@ -27,9 +27,10 @@ FlowGraphPlainNodeWidget::FlowGraphPlainNodeWidget(QWidget *parent) : FlowGraphN
 
 FlowGraphCheckNodeWidget::FlowGraphCheckNodeWidget(QWidget *parent) : FlowGraphNodeWidget(CheckBox, parent)
 {
-    m_checkBox = new QCheckBox(this);
+    m_checkBox = new QCheckBox("执行", this);
 
     QBoxLayout *l = new QVBoxLayout(this);
+    l->setAlignment(Qt::AlignCenter);
     l->addWidget(m_checkBox);
 }
 

QFD/shemeFlow/FlowTemplateDataModel.cpp

@@ -7,11 +7,51 @@ FlowTemplateDataModel::FlowTemplateDataModel() : NodeDelegateModel() { }
 QWidget *FlowTemplateDataModel::embeddedWidget()
 {
     return new FlowGraphComboNodeWidget();
+}
+
+FlowIndexDataModel::FlowIndexDataModel() : NodeDelegateModel() { }
+
+QWidget *FlowIndexDataModel::embeddedWidget()
+{
+    return new FlowGraphPlainNodeWidget();
+}
 
-    return m_widget;
+QWidget *FlowSampleDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
 }
 
-void FlowTemplateDataModel::setEmbeddedWidget(FlowGraphNodeWidget *w)
+QWidget *FlowPCADataModel::embeddedWidget()
 {
-    m_widget = w;
+    return new FlowGraphCheckNodeWidget();
+}
+
+QWidget *FlowWeightDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
+}
+
+QWidget *FlowResultDataModel::embeddedWidget()
+{
+    return nullptr;
+}
+
+QWidget *FlowReportDataModel::embeddedWidget()
+{
+    return new FlowGraphCheckNodeWidget();
+}
+
+QWidget *FlowEffiLevDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
+}
+
+QWidget *FlowSchemeDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
+}
+
+QWidget *FlowEffiDataModel::embeddedWidget()
+{
+    return new FlowGraphComboNodeWidget();
 }

QFD/shemeFlow/FlowTemplateDataModel.h

@@ -15,8 +15,6 @@ using QtNodes::NodeDelegateModel;
 using QtNodes::PortIndex;
 using QtNodes::PortType;
 
-class FlowGraphNodeWidget;
-
 class FlowTemplateData : public NodeData
 {
 public:
@@ -36,7 +34,15 @@ public:
 
     bool portCaptionVisible(PortType, PortIndex) const override { return false; }
 
-    QString portCaption(PortType, PortIndex) const override { return "hello"; }
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
 
     QString name() const override { return QString("FlowTemplateData"); }
 
@@ -52,56 +58,411 @@ public:
     void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
 
     QWidget *embeddedWidget() override;
+};
+
+class FlowIndexData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowIndexData", "" }; }
+};
+
+class FlowIndexDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowIndexDataModel();
+
+    ~FlowIndexDataModel() = default;
+
+    QString caption() const override { return QString("构建指标体系"); }
 
-    void setEmbeddedWidget(FlowGraphNodeWidget *w);
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
 
-private:
-    FlowGraphNodeWidget *m_widget = nullptr;
+    QString name() const override { return QString("FlowIndexData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowIndexData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowIndexData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
 };
 
-enum FlowDataType
+class FlowSampleData : public NodeData
 {
-    FlowDataTypeLabel,
-    FlowDataTypeCheckBox,
-    FlowDataTypeCombox,
-    FlowDataTypeDoubleComboBox,
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowSampleData", "" }; }
 };
 
-class FlowTextDataModel : public NodeDelegateModel
+class FlowSampleDataModel : public NodeDelegateModel
 {
     Q_OBJECT
 
 public:
-    FlowTextDataModel();
+    FlowSampleDataModel() : NodeDelegateModel() { }
 
-    ~FlowTextDataModel() = default;
+    ~FlowSampleDataModel() = default;
 
-    QString caption() const override { return QString("流程样板模型"); }
+    QString caption() const override { return QString("收集数据"); }
 
     bool portCaptionVisible(PortType, PortIndex) const override { return false; }
 
-    QString portCaption(PortType, PortIndex) const override { return "hello"; }
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
 
-    QString name() const override { return QString("FlowTextData"); }
+    QString name() const override { return QString("FlowSampleData"); }
 
     unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
 
     NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
     {
-        return FlowTemplateData().type();
+        return FlowSampleData().type();
     }
 
-    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowTemplateData>(); }
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowSampleData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowPCAData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowPCAData", "" }; }
+};
+
+class FlowPCADataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowPCADataModel() : NodeDelegateModel() { }
+
+    ~FlowPCADataModel() = default;
+
+    QString caption() const override { return QString("主成分分析法"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowPCAData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowPCAData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowPCAData>(); }
 
     void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
 
     QWidget *embeddedWidget() override;
 };
 
-class FlowTextData : public NodeData
+class FlowWeightData : public NodeData
 {
 public:
-    NodeDataType type() const override { return NodeDataType { "FlowTextData", "" }; }
+    NodeDataType type() const override { return NodeDataType { "FlowWeightData", "" }; }
+};
+
+class FlowWeightDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowWeightDataModel() : NodeDelegateModel() { }
+
+    ~FlowWeightDataModel() = default;
+
+    QString caption() const override { return QString("权重计算"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowWeightData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowWeightData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowWeightData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowSchemeData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowSchemeData", "" }; }
+};
+
+class FlowSchemeDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowSchemeDataModel() : NodeDelegateModel() { }
+
+    ~FlowSchemeDataModel() = default;
+
+    QString caption() const override { return QString("算法"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowSchemeData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowSchemeData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowSchemeData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowEffiData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowEffiData", "" }; }
+};
+
+class FlowEffiDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowEffiDataModel() : NodeDelegateModel() { }
+
+    ~FlowEffiDataModel() = default;
+
+    QString caption() const override { return QString("算法"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowEffiData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowEffiData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowEffiData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowResultData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowResultData", "" }; }
+};
+
+class FlowResultDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowResultDataModel() : NodeDelegateModel() { }
+
+    ~FlowResultDataModel() = default;
+
+    QString caption() const override { return QString("结果展示"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowResultData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowResultData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowResultData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowReportData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowReportData", "" }; }
+};
+
+class FlowReportDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowReportDataModel() : NodeDelegateModel() { }
+
+    ~FlowReportDataModel() = default;
+
+    QString caption() const override { return QString("生成报告"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowReportData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowReportData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowReportData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
+};
+
+class FlowEffiLevData : public NodeData
+{
+public:
+    NodeDataType type() const override { return NodeDataType { "FlowEffiLevData", "" }; }
+};
+
+class FlowEffiLevDataModel : public NodeDelegateModel
+{
+    Q_OBJECT
+
+public:
+    FlowEffiLevDataModel() : NodeDelegateModel() { }
+
+    ~FlowEffiLevDataModel() = default;
+
+    QString caption() const override { return QString("效能分级"); }
+
+    bool portCaptionVisible(PortType, PortIndex) const override { return false; }
+
+    QString portCaption(PortType pt, PortIndex) const override
+    {
+        if (pt == PortType::In) {
+            return "输入";
+        } else if (pt == PortType::Out) {
+            return "输出";
+        }
+        return "";
+    }
+
+    QString name() const override { return QString("FlowEffiLevData"); }
+
+    unsigned int nPorts(PortType const /*portType*/) const override { return 1; }
+
+    NodeDataType dataType(PortType const portType, PortIndex const portIndex) const override
+    {
+        return FlowEffiLevData().type();
+    }
+
+    std::shared_ptr<NodeData> outData(PortIndex const port) override { return std::make_shared<FlowEffiLevData>(); }
+
+    void setInData(std::shared_ptr<NodeData>, PortIndex const) override { }
+
+    QWidget *embeddedWidget() override;
 };
 
 #endif  // FLOWTEMPLARTEDATAMODEL_H

QFD/shemeFlow/ShemeFlowPanel.cpp

@@ -29,6 +29,13 @@ static std::shared_ptr<NodeDelegateModelRegistry> registerDataModels()
     auto ret = std::make_shared<NodeDelegateModelRegistry>();
 
     ret->registerModel<FlowTemplateDataModel>();
+    ret->registerModel<FlowIndexDataModel>();
+    ret->registerModel<FlowSampleDataModel>();
+    ret->registerModel<FlowPCADataModel>();
+    ret->registerModel<FlowWeightDataModel>();
+    ret->registerModel<FlowResultDataModel>();
+    ret->registerModel<FlowReportDataModel>();
+    ret->registerModel<FlowEffiLevDataModel>();
 
     return ret;
 }
@@ -97,18 +104,32 @@ ShemeFlowPanel::ShemeFlowPanel(QWidget *parent) : QWidget(parent)
 
     // Initialize and connect two nodes.
     {
-        NodeId id1 = graphModel->addNode(FlowTemplateData().type().id);
+        NodeId id1 = graphModel->addNode(FlowIndexData().type().id);
         graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, 0));
 
-        FlowGraphNodeWidget *w1 = new FlowGraphPlainNodeWidget();
-        graphModel->setNodeData(id1, NodeRole::Widget, qVariantFromValue(w1));
+        NodeId id2 = graphModel->addNode(FlowSampleData().type().id);
+        graphModel->setNodeData(id2, NodeRole::Position, QPointF(200, 0));
+        graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });
 
-        graphModel->setNodeData(id1, NodeRole::Caption, qVariantFromValue(QString("构建指标体系")));
+        NodeId id3 = graphModel->addNode(FlowPCAData().type().id);
+        graphModel->setNodeData(id3, NodeRole::Position, QPointF(400, 0));
+        graphModel->addConnection(ConnectionId { id2, 0, id3, 0 });
 
-        NodeId id2 = graphModel->addNode(FlowTemplateData().type().id);
-        graphModel->setNodeData(id2, NodeRole::Position, QPointF(300, 300));
+        NodeId id4 = graphModel->addNode(FlowWeightData().type().id);
+        graphModel->setNodeData(id4, NodeRole::Position, QPointF(600, 0));
+        graphModel->addConnection(ConnectionId { id3, 0, id4, 0 });
 
-        graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });
+        NodeId id5 = graphModel->addNode(FlowResultData().type().id);
+        graphModel->setNodeData(id5, NodeRole::Position, QPointF(0, 200));
+        graphModel->addConnection(ConnectionId { id4, 0, id5, 0 });
+
+        NodeId id6 = graphModel->addNode(FlowReportData().type().id);
+        graphModel->setNodeData(id6, NodeRole::Position, QPointF(200, 200));
+        graphModel->addConnection(ConnectionId { id5, 0, id6, 0 });
+
+        NodeId id7 = graphModel->addNode(FlowEffiLevData().type().id);
+        graphModel->setNodeData(id7, NodeRole::Position, QPointF(400, 200));
+        graphModel->addConnection(ConnectionId { id6, 0, id7, 0 });
     }
 
     auto scene = new DataFlowGraphicsScene(*graphModel);

QFD/widgets/SchemeFlowWidget.cpp

@@ -16,7 +16,7 @@ static std::shared_ptr<NodeDelegateModelRegistry> registerDataModels()
 {
     auto ret = std::make_shared<NodeDelegateModelRegistry>();
 
-    ret->registerModel<FlowTemplateDataModel>();
+    ret->registerModel<FlowIndexDataModel>();
 
     return ret;
 }
@@ -95,15 +95,15 @@ void SchemeFlowWidget::initWidgets()
 
     // Initialize and connect two nodes.
     {
-        NodeId id1 = graphModel->addNode(FlowTemplateData().type().id);
+        NodeId id1 = graphModel->addNode(FlowIndexData().type().id);
         graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, 0));
 
-        NodeId id2 = graphModel->addNode(FlowTemplateData().type().id);
+        NodeId id2 = graphModel->addNode(FlowIndexData().type().id);
         graphModel->setNodeData(id2, NodeRole::Position, QPointF(200, 0));
 
         graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });
 
-        NodeId id3 = graphModel->addNode(FlowTemplateData().type().id);
+        NodeId id3 = graphModel->addNode(FlowIndexData().type().id);
         graphModel->setNodeData(id3, NodeRole::Position, QPointF(400, 0));
 
         graphModel->addConnection(ConnectionId { id2, 0, id3, 0 });