QFD2/QFD/widgets/SchemeFlowWidget.cpp

#include "SchemeFlowWidget.h"

#include "shemeFlow/FlowGraphNodeWidget.h"
#include "ProjectManager.h"

#include <dbService/ClassSet.h>

#include <QGroupBox>
#include <QCheckBox>

#include <QBoxLayout>
#include <QDebug>

#include <QtNodes/GraphicsView>

using QtNodes::GraphicsView;

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>();
    ret->registerModel<FlowSchemeDataModel>();
    ret->registerModel<FlowEffiDataModel>();
    ret->registerModel<FlowCommonDataModel>();

    return ret;
}

static void setStyle_()
{
    GraphicsViewStyle::setStyle(
            R"(
  {
    "GraphicsViewStyle": {
      "BackgroundColor": [255, 255, 255],
      "FineGridColor": [255, 255, 255],
      "CoarseGridColor": [255, 255, 255]
    }
  }
  )");

    NodeStyle::setNodeStyle(
            R"(
  {
    "NodeStyle": {
      "NormalBoundaryColor": "darkgray",
      "SelectedBoundaryColor": "deepskyblue",
      "GradientColor0": "mintcream",
      "GradientColor1": "mintcream",
      "GradientColor2": "mintcream",
      "GradientColor3": "mintcream",
      "ShadowColor": [200, 200, 200],
      "FontColor": [10, 10, 10],
      "FontColorFaded": [100, 100, 100],
      "ConnectionPointColor": "white",
      "PenWidth": 2.0,
      "HoveredPenWidth": 2.5,
      "ConnectionPointDiameter": 10.0,
      "Opacity": 1.0
    }
  }
  )");

    ConnectionStyle::setConnectionStyle(
            R"(
  {
    "ConnectionStyle": {
      "ConstructionColor": "gray",
      "NormalColor": "black",
      "SelectedColor": "gray",
      "SelectedHaloColor": "deepskyblue",
      "HoveredColor": "deepskyblue",

      "LineWidth": 3.0,
      "ConstructionLineWidth": 2.0,
      "PointDiameter": 10.0,

      "UseDataDefinedColors": false
    }
  }
  )");
}

SchemeFlowWidget::SchemeFlowWidget(ProjectInfo *proj, int indexType, QWidget *parent) : QWidget(parent), m_proj(proj)
{
    setStyle_();

    initWidget();

    setType(indexType);
}

SchemeFlowWidget::~SchemeFlowWidget()
{
    delete m_graphModel;
}

void SchemeFlowWidget::setType(int t)
{
    m_indexType = t;
    refresh();
}

void SchemeFlowWidget::initWidget()
{
    m_graphModel = new DataFlowModel(registerDataModels());
    m_graphModel->setNodesLocked(true);
    m_graphModel->setDetachPossible(false);

    auto scene         = new DataFlowGraphicsScene(*m_graphModel);
    GraphicsView *view = new GraphicsView(scene);
    scene->setOrientation(Qt::Vertical);

    QHBoxLayout *l = new QHBoxLayout(this);
    l->addWidget(view);
}

void SchemeFlowWidget::clearAllNodes()
{
    for (int id : m_graphModel->allNodeIds()) {
        m_graphModel->deleteNode(id);
    }
}

void SchemeFlowWidget::refresh()
{
    clearAllNodes();

    qreal h = 200;

    switch (m_indexType) {
    case ProjectManager::AbilityIndex:
        break;
    case ProjectManager::TechIndex: {
        NodeId id11 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id11, NodeRole::Position, QPointF(0, h * 0));
        FlowGraphCommonNodeWidget *w11 = new FlowGraphCommonNodeWidget();
        SchemePlanManager::SchemeProcessInfo process11;
        process11.indexType = m_indexType;
        process11.type      = SchemePlanManager::IndexSystem;
        w11->setProcess(process11);
        m_graphModel->setNodeData(id11, NodeRole::Widget, QVariant::fromValue(w11));

        NodeId id12 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id12, NodeRole::Position, QPointF(0, h * 1));
        FlowGraphCommonNodeWidget *w12 = new FlowGraphCommonNodeWidget();
        SchemePlanManager::SchemeProcessInfo process12;
        process12.indexType = m_indexType;
        process12.type      = SchemePlanManager::ImportEvalData;
        process12.dSource   = SchemePlanManager::FromExpert;
        w12->setProcess(process12);
        if (w12->isTitleHidden()) {
            m_graphModel->setNodeData(id12, NodeRole::Caption, SchemePlanManager::processName(process12));
        }
        m_graphModel->setNodeData(id12, NodeRole::Widget, QVariant::fromValue(w12));

        m_graphModel->addConnection(ConnectionId { id11, 0, id12, 0 });

        break;

        NodeId id1 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, h * 0));
        FlowGraphPlainNodeWidget *w1 = new FlowGraphPlainNodeWidget();
        w1->setText("构建权重分析指标体系");
        m_graphModel->setNodeData(id1, NodeRole::Widget, QVariant::fromValue(w1));

        NodeId id2 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id2, NodeRole::Position, QPointF(0, h * 1));
        m_graphModel->setNodeData(id2, NodeRole::Caption, QString("收集权重分析数据"));
        m_graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });

        NodeId id3 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id3, NodeRole::Position, QPointF(0, h * 2));
        m_graphModel->setNodeData(id3, NodeRole::Caption, QString("指标体系优化"));
        m_graphModel->addConnection(ConnectionId { id2, 0, id3, 0 });

        NodeId id4 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id4, NodeRole::Position, QPointF(0, h * 3));
        m_graphModel->setNodeData(id4, NodeRole::Caption, QString("指标权重计算"));
        m_graphModel->addConnection(ConnectionId { id3, 0, id4, 0 });

        NodeId id5 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id5, NodeRole::Position, QPointF(0, h * 4));
        FlowGraphPlainNodeWidget *w5 = new FlowGraphPlainNodeWidget();
        w5->setText("分析结果展示");
        m_graphModel->setNodeData(id5, NodeRole::Widget, QVariant::fromValue(w5));
        m_graphModel->addConnection(ConnectionId { id4, 0, id5, 0 });

        NodeId id6 = m_graphModel->addNode(FlowCommonData().type().id);
        m_graphModel->setNodeData(id6, NodeRole::Position, QPointF(0, h * 5));
        m_graphModel->setNodeData(id6, NodeRole::Caption, QString("生成分析评估报告"));
        m_graphModel->addConnection(ConnectionId { id5, 0, id6, 0 });
        break;
    }
    case ProjectManager::OptimalIndex: {
        NodeId id1 = m_graphModel->addNode(FlowIndexData().type().id);
        m_graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, h * 0));

        NodeId id2 = m_graphModel->addNode(FlowSampleData().type().id);
        m_graphModel->setNodeData(id2, NodeRole::Position, QPointF(0, h * 1));
        m_graphModel->addConnection(ConnectionId { id1, 0, id2, 0 });

        NodeId id8 = m_graphModel->addNode(FlowSchemeData().type().id);
        m_graphModel->setNodeData(id8, NodeRole::Position, QPointF(0, h * 2));
        m_graphModel->addConnection(ConnectionId { id2, 0, id8, 0 });

        NodeId id5 = m_graphModel->addNode(FlowResultData().type().id);
        m_graphModel->setNodeData(id5, NodeRole::Position, QPointF(0, h * 3));
        m_graphModel->addConnection(ConnectionId { id8, 0, id5, 0 });

        NodeId id6 = m_graphModel->addNode(FlowReportData().type().id);
        m_graphModel->setNodeData(id6, NodeRole::Position, QPointF(0, h * 4));
        m_graphModel->addConnection(ConnectionId { id5, 0, id6, 0 });

        break;
    }
    case ProjectManager::EfficiencyIndex: {
        NodeId id1 = m_graphModel->addNode(FlowIndexData().type().id);
        m_graphModel->setNodeData(id1, NodeRole::Position, QPointF(0, h * 0));

        NodeId id7 = m_graphModel->addNode(FlowEffiLevData().type().id);
        m_graphModel->setNodeData(id7, NodeRole::Position, QPointF(0, h * 1));
        m_graphModel->addConnection(ConnectionId { id1, 0, id7, 0 });

        NodeId id9 = m_graphModel->addNode(FlowEffiData().type().id);
        m_graphModel->setNodeData(id9, NodeRole::Position, QPointF(0, h * 2));
        m_graphModel->addConnection(ConnectionId { id7, 0, id9, 0 });

        NodeId id5 = m_graphModel->addNode(FlowResultData().type().id);
        m_graphModel->setNodeData(id5, NodeRole::Position, QPointF(0, h * 3));
        m_graphModel->addConnection(ConnectionId { id9, 0, id5, 0 });

        NodeId id6 = m_graphModel->addNode(FlowReportData().type().id);
        m_graphModel->setNodeData(id6, NodeRole::Position, QPointF(0, h * 4));
        m_graphModel->addConnection(ConnectionId { id5, 0, id6, 0 });
        break;
    }
    }

    //    std::unordered_set<NodeId> set = m_graphModel->allNodeIds();
    //    for (auto iter = set.begin(); iter != set.end(); ++iter) { }
}