QFD2/QFD/widgets/EvalSchemeWidget.cpp

#include "EvalSchemeWidget.h"

#include <CCanvas/CSchemeView.h>
#include <CCanvas/CSchemeItem.h>

#include <Widgets/Button.h>
#include <Widgets/Menu.h>
#include <Widgets/CheckBox.h>

#include <QLabel>
#include <QLayout>
#include <QMetaEnum>

#include <QDebug>

QString EvalSchemeWidget::nameOfScheme(Scheme s)
{
    switch (s) {
    case Index:
        return "构建指标体系";
    case Collect:
        return "收集数据";
    case Process:
        return "处理数据";
    case Output:
        return "生成报告";
    }
}

QString EvalSchemeWidget::nameOfAlgorithm(EvalSchemeWidget::Algorithm a)
{
    switch (a) {
    case Alg1:
        return "层次分析法";
    case Alg2:
        return "集对分析法";
    case Alg3:
        return "熵值法";
    case Alg4:
        return "物元分析法";
    case Alg5:
        return "灰色聚类评估法";
    }
}

EvalSchemeWidget::EvalSchemeWidget(ProjectInfo *proj, int type, QWidget *parent) : EvalWidget(proj, type, parent)
{
    setTitle("评估方案规划");

    initWidgets();
    initLayout();
    connectSignalsAndSlots();

    testData();
}

void EvalSchemeWidget::initWidgets()
{
    m_schemeBtn = new PushButton("加载方案", this);
    m_index     = new CheckBox("指标体系", this);
    m_data      = new CheckBox("收集数据", this);
    m_algBtn    = new PushButton("数据处理", this);
    m_clear     = new PushButton("清空");

    // 按照方案枚举值添加按钮
    //    QMetaEnum sch = QMetaEnum::fromType<Scheme>();
    //    for (int i = 0; i < sch.keyCount(); i++) {
    //        Scheme s        = Scheme(sch.value(i));
    //        PushButton *btn = new PushButton(nameOfScheme(s), this);
    //        btn->setMinimumWidth(80);
    //        m_buttonLayout->addWidget(btn);
    //        connect(btn, &PushButton::clicked, [this, s, btn]() { slotSelectScheme(s, btn); });
    //    }
    //    m_buttonLayout->setSpacing(15);
    //    m_buttonLayout->addStretch();

    m_schemeView = new CSchemeView(this);
    m_schemeSep  = new QWidget(this);
    m_schemeSep->setFixedWidth(1);
    m_description = new QLabel("description", this);
    m_description->setFixedWidth(150);

    QMap<QString, SchemeAndAlg> schemes;
    schemes["指标体系"]           = { Index | Process | Output, Alg1 };
    schemes["收集数据"]           = { Collect | Process | Output, Alg1 };
    schemes["指标体系和收集数据"] = { Index | Collect | Process | Output, Alg1 };
    m_schemeMenu                  = new RoundMenu("scheme", this);
    m_schemeMenu->addAction(new QAction("方案一"));
    m_schemeMenu->addAction(new QAction("方案二"));
    m_schemeMenu->addAction(new QAction("方案三"));

    // 按照算法枚举值添加算法选项
    m_algMenu     = new RoundMenu("alg", this);
    QMetaEnum alg = QMetaEnum::fromType<Algorithm>();
    for (int i = 0; i < alg.keyCount(); i++) {
        Algorithm t  = Algorithm(alg.value(i));
        QAction *act = new QAction(nameOfAlgorithm(t));
        m_algMenu->addAction(act);
        connect(act, &QAction::triggered, [this, t]() { slotSelectAlgorithm(t); });
    }
}

void EvalSchemeWidget::initLayout()
{
    // 总体布局
    m_buttonLayout = new QHBoxLayout();
    m_contentLayout->addLayout(m_buttonLayout);
    m_schemeLayout = new QHBoxLayout();
    m_contentLayout->addLayout(m_schemeLayout);

    m_buttonLayout->addWidget(m_schemeBtn);
    m_buttonLayout->addSpacing(20);
    m_buttonLayout->addWidget(m_index);
    m_buttonLayout->addSpacing(20);
    m_buttonLayout->addWidget(m_data);
    m_buttonLayout->addSpacing(20);
    m_buttonLayout->addWidget(m_algBtn);
    m_buttonLayout->addSpacing(20);
    m_buttonLayout->addWidget(m_clear);
    m_buttonLayout->addStretch();

    m_schemeLayout->addWidget(m_schemeView);
    m_schemeLayout->addWidget(m_seperator);
    m_schemeLayout->addWidget(m_description);
}

void EvalSchemeWidget::connectSignalsAndSlots()
{
    connect(m_schemeBtn, &PushButton::clicked, this, &EvalSchemeWidget::slotShowSchemeMenu);
    connect(m_index, &CheckBox::clicked, this, &EvalSchemeWidget::slotIndexClicked);
    connect(m_data, &CheckBox::clicked, this, &EvalSchemeWidget::slotDataClicked);
    connect(m_algBtn, &PushButton::clicked, this, &EvalSchemeWidget::slotAlgBtnClicked);
    connect(m_clear, &PushButton::clicked, this, &EvalSchemeWidget::slotClearClicked);
}

void EvalSchemeWidget::refreshSchemeView()
{
    qDebug() << __FUNCTION__ << __LINE__ << m_scheme << endl;

    m_schemeView->clear();
    if (m_scheme > 0) {
        m_scheme |= Output;
    }
    QMetaEnum sch = QMetaEnum::fromType<Scheme>();
    for (int i = 0; i < sch.keyCount(); i++) {
        Scheme s = Scheme(sch.value(i));
        if (s == Process) {
            for (Algorithm a : m_algs) {
                CSchemeItem *item = new CSchemeItem(nameOfAlgorithm(a));
                m_schemeView->addItem(item);
            }

        } else {
            if ((m_scheme & s) == s) {
                CSchemeItem *item = new CSchemeItem(nameOfScheme(s));
                m_schemeView->addItem(item);
            }
        }
    }
}

void EvalSchemeWidget::testData()
{
    m_scheme = Index | Collect | Output;
    m_algs   = { Alg1 };
    refreshSchemeView();
}

void EvalSchemeWidget::slotShowSchemeMenu()
{
    QPoint pos = m_schemeBtn->mapToGlobal(QPoint()) + QPoint(m_schemeBtn->width(), -10);
    m_schemeMenu->exec(pos, true);
}

void EvalSchemeWidget::slotIndexClicked()
{
    m_scheme ^= Index;
    refreshSchemeView();
}

void EvalSchemeWidget::slotDataClicked()
{
    m_scheme ^= Collect;
    refreshSchemeView();
}

void EvalSchemeWidget::slotAlgBtnClicked()
{
    QPoint pos = m_algBtn->mapToGlobal(QPoint()) + QPoint(m_algBtn->width(), -10);
    m_algMenu->exec(pos, true);
}

void EvalSchemeWidget::slotClearClicked()
{
    m_scheme = 0;
    m_algs.clear();
    refreshSchemeView();
}

void EvalSchemeWidget::slotSelectAlgorithm(EvalSchemeWidget::Algorithm alg)
{
    if (m_algs.contains(alg)) {
        return;
    }
    m_algs.clear();
    m_algs.append(alg);
    refreshSchemeView();
}