server1/SettingLibrary/Modules/Basic/compareitemdialog.cpp

#include "compareitemdialog.h"
#include "GlobalVariable.h"
#include "ui_compareitemwidget.h"

#include "UIStyleManager.h"
#include "SoundCardData.h"
#include "tipwidget.h"
#include "commonFunc.h"
#include "commonFunc.h"

#include <QIntValidator>


CompareItemDialog::CompareItemDialog(QWidget *parent)
    : DialogBase(parent)
    , ui(new Ui::CompareItemWidget)
{
    QWidget *widgetContent = new QWidget(this);
    ui->setupUi(widgetContent);

    /* 设置内容 */
    setContentWidget(widgetContent);
    /* 设置标题 */
    setTitle("对比项信息", QSize(120, 18));

    /* 对输入做一些限制 */
    setDetectParamInputOnlyNumber();

    /* 限制对比项名称长度 */
    ui->lineEdit_compareItmName->setMaxLength(15);

    /* 设置默认开启 */
    ui->checkBoxMute->setChecked(true);
    ui->checkBoxOverload->setChecked(true);
    ui->checkBoxPhase->setChecked(true);

    m_listOtherRoadWgt.clear();
    m_listOtherRoadWgt.push_back(ui->widget_mainRoad);
    m_listOtherRoadWgt.push_back(ui->widget_secondRoad);

    /* 设置可选的声卡通道信息 */
    setSoundCardRoadList(SoundCards.getCurrentSoundCardInfo());

    /* 连接信号和槽 */
    connect(ui->pBtn_add, &QPushButton::clicked, this, &CompareItemDialog::do_pBtn_add_clicked);
    /* 连接静音、过载、反相三个按钮的开关 */
    connect(ui->checkBoxMute, &QCheckBox::clicked, this, &CompareItemDialog::do_checkBox_MOP_clicked);
    connect(ui->checkBoxOverload, &QCheckBox::clicked, this, &CompareItemDialog::do_checkBox_MOP_clicked);
    connect(ui->checkBoxPhase, &QCheckBox::clicked, this, &CompareItemDialog::do_checkBox_MOP_clicked);
    
    /* 连接通道的选择信号 */
    connect(ui->widget_mainRoad, &SingleCompareRoadWidget::signal_selectRecordRoad, this, &CompareItemDialog::do_selectOneRecordRoad);
    connect(ui->widget_secondRoad, &SingleCompareRoadWidget::signal_selectRecordRoad, this, &CompareItemDialog::do_selectOneRecordRoad);

    /* 设置样式 */
    setQSS();
}

CompareItemDialog::~CompareItemDialog()
{
    delete ui;
}

/* 设置可选的声卡通道信息 */
void CompareItemDialog::setSoundCardRoadList(const SoundCardPCMInfo_t& soundCardInfo)
{
    m_soundCardInfo = soundCardInfo;

    /* 设置已有两个通道的可选录音通道 */
    ui->widget_mainRoad->setSoundCardRoadList(m_soundCardInfo);
    ui->widget_secondRoad->setSoundCardRoadList(m_soundCardInfo);
}


/* 设置模式，是否是多项编辑 */
void CompareItemDialog::setMultiEditMode(bool multiEdit)
{
    m_isMultiEdit = multiEdit;
    if(!multiEdit)
    {
        return;
    }
    /* 设置对比项名称输入框不可编辑 */
    ui->lineEdit_compareItmName->setEnabled(false);
    /* 设置通道不可编辑 */
    // ui->widget_mainRoad->setMultiEditMode(false);
    // ui->widget_secondRoad->setMultiEditMode(false);
    /* 删除多余的通道 */
    for(auto& widget : m_listOtherRoadWgt)
    {
        if(widget == ui->widget_mainRoad || widget == ui->widget_secondRoad)
        {
            widget->setMultiEditMode(false);
            continue;
        }
        delete widget;
        widget = nullptr;
    }
    /* 清空其他自定义选项 */
    ui->lineEdit_compareItmName->clear();

    m_listOtherRoadWgt.clear();
    m_listOtherRoadWgt.push_back(ui->widget_mainRoad);
    m_listOtherRoadWgt.push_back(ui->widget_secondRoad);
}


/* 设置对比项名称列表。查重时使用 */
void CompareItemDialog::setCompareItemNameList(const QList<QString>& listItemNames)
{
    m_listCompareItemNames = listItemNames;
    /* 先去掉自身名称，防止编辑的时候直接报错 */
    QString currentName = ui->lineEdit_compareItmName->text();
    if(!currentName.isEmpty())
    {
        m_listCompareItemNames.removeAll(currentName);
    }
}


/* 设置默认的参数 */
void CompareItemDialog::setDefaultParams(const CompareItemInfo_t& item)
{
    m_compareItemInfo = item; // 保存对比项信息
    /* 设置对比项名称 */
    ui->lineEdit_compareItmName->setText(item.strName);
    /* 设置对比项状态 */
    ui->checkBox_enable->setChecked(item.isEnable);

    /* 设置静音检测参数，设置文本需要取绝对值 */
    ui->checkBoxMute->setChecked(item.paramMute.isEnable);
    ui->lineEditMuteLen->setText(QString::number(item.paramMute.nLen));
    ui->lineEditMuteSensibility->setText(QString::number(item.paramMute.nSensitivity));
    ui->lineEditMuteThreshold->setText(QString::number(std::abs(item.paramMute.threshold.nThreshold)));

    /* 设置过载检测参数 */
    ui->checkBoxOverload->setChecked(item.paramOverload.isEnable);
    ui->lineEditOverloadLen->setText(QString::number(item.paramOverload.nLen));
    ui->lineEditOverloadSensibility->setText(QString::number(item.paramOverload.nSensitivity));
    ui->lineEditOverloadThreshold->setText(QString::number(std::abs(item.paramOverload.threshold.nThreshold)));

    /* 设置反相检测参数 */
    ui->checkBoxPhase->setChecked(item.paramPhase.isEnable);
    ui->lineEditPhaseLen->setText(QString::number(item.paramPhase.nLen));
    ui->lineEditPhaseSensibility->setText(QString::number(item.paramPhase.nSensitivity));
    ui->lineEditPhaseThreshold->setText(QString::number(std::abs(item.paramPhase.threshold.dThreshold)));


    /* 设置其他通道 */
    for(const auto& road : item.mapRoad)
    {
        if(road.nCompareRoadNum == 1) // 主通道
        {
            /* 阻塞这个comBoBox发送信号 */
            ui->widget_mainRoad->blockSignals(true);
            ui->widget_mainRoad->setSoundCardRoadList(m_soundCardInfo);
            ui->widget_mainRoad->blockSignals(false);
            ui->widget_mainRoad->setDefaultParams(road);
        }
        else if(road.nCompareRoadNum == 2) // 第二通道
        {
            ui->widget_secondRoad->blockSignals(true);
            ui->widget_secondRoad->setSoundCardRoadList(m_soundCardInfo);
            ui->widget_secondRoad->blockSignals(false);
            ui->widget_secondRoad->setDefaultParams(road);
        }
        else if(road.nCompareRoadNum > 2) // 其他通道
        {
            auto pWgt = addOneRoadWidget(road.nCompareRoadNum, true);
            /* 设置默认参数 */
            pWgt->setDefaultParams(road);
        }
    }
}



/* 获取生成的对比项信息 */
CompareItemInfo_t& CompareItemDialog::getCompareItemInfo()
{
    return m_compareItemInfo;
}



/* 新增通道 */
void CompareItemDialog::do_pBtn_add_clicked()
{
    /* 判断数目是否已经达到最大值，最大就5个通道 */
    if(m_listOtherRoadWgt.size() >= 5)
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, "对比通道数目已达上限", this);
        return;
    }
    /* 从3开始编号，1是主通道，2是第二通道 */
    int index = m_listOtherRoadWgt.size() + 1;
    addOneRoadWidget(index, true);
}

/* 删除通道 */
void CompareItemDialog::do_CompareRoadWgtDeleted(int nIndex)
{
    for(auto& it : m_listOtherRoadWgt)
    {
        if(it->getIndex() == nIndex)
        {
            it->setParent(nullptr);
            m_listOtherRoadWgt.removeOne(it);
            break;
        }
    }
    /* 剩下的重新排序，不排主通道和2通道 */
    for(auto& it : m_listOtherRoadWgt)
    {
        if(it == ui->widget_mainRoad || it == ui->widget_secondRoad)
        {
            continue;
        }
        int currentIndex = it->getIndex();
        if(currentIndex > nIndex)
        {
            it->setIndex(currentIndex - 1);
        }
    }
}

/* 静音、过载、反相检测条件开关 */
void CompareItemDialog::do_checkBox_MOP_clicked(bool checked)
{
    /* 获取信号发送者 */
    QCheckBox *checkBox = qobject_cast<QCheckBox*>(sender());
    checkBox->setText(checked ? "开启" : "关闭");
    if(checkBox == ui->checkBoxMute)
    {
        setMOPEditable(EDBType::DBType_Mute, checked);
    }
    else if(checkBox == ui->checkBoxOverload)
    {
        setMOPEditable(EDBType::DBType_Overload, checked);
    }
    else if(checkBox == ui->checkBoxPhase)
    {
        setMOPEditable(EDBType::DBType_Phase, checked);
    }
}


/* 选择了一个录音通道，判断有没有重复的，有则去掉重复的 */
void CompareItemDialog::do_selectOneRecordRoad(QString strPCMName)
{
    auto sender = qobject_cast<SingleCompareRoadWidget*>(QObject::sender());
    /* 只在release模式下生效，debug可以设置重复的，方便测试 */
#if C_RELEASE
    /* 判断是否重复 */
    for(auto& it : m_listOtherRoadWgt)
    {
        if(it == sender)
        {
            continue;
        }
        if(it->getCurrentPCMName() == strPCMName)
        {
            it->clearCurrentSelectRecordName();
        }
    }

#endif

}

/* 设置样式表 */
void CompareItemDialog::setQSS()
{
    QString qssPath = UIStyle.getQSSPath() + "/compareitemwidget.qss";
    QFile file(qssPath);
    if(file.open(QFile::ReadOnly))
    {
        QString qss = file.readAll();
        file.close();
        /* 这里设置的是内容容器样式表，this是最外层的 */
        getContentWidget()->setStyleSheet(qss);
        ui->scrollArea->setStyleSheet(qss);
        ui->scrollAreaWidgetContents->setStyleSheet(qss);
    } else
    {
        SPDLOG_LOGGER_ERROR(m_logger, "打开QSS文件失败: {}", qssPath.toStdString());
        SPDLOG_LOGGER_ERROR(m_logger, "错误信息: {}", file.errorString().toStdString());
    }

    /* 打开对比项通道的qss */
    file.setFileName(UIStyle.getQSSPath() + "/singlecompareroadwidget.qss");
    if(file.open(QFile::ReadOnly))
    {
        m_qssRecordRoad = file.readAll();
        file.close();
    } else
    {
        SPDLOG_LOGGER_ERROR(m_logger, "打开QSS文件失败: {}", file.fileName().toStdString());
        SPDLOG_LOGGER_ERROR(m_logger, "错误信息: {}", file.errorString().toStdString());
    }
    ui->widget_mainRoad->setQSS(m_qssRecordRoad);
    ui->widget_secondRoad->setQSS(m_qssRecordRoad);
}


/* 重载按下关闭按钮之前的操作 */
bool CompareItemDialog::isOKClicked()
{
    /* 先取消所有的报警 */
    cancelAllWarn();
    /* 获取对比项的信息 */
    if(!getCompareItemBaseInfo(m_compareItemInfo))
    {
        return false;
    }

    /* 获取录音通道信息 */
    if(!getCompareRoadInfo(m_compareItemInfo))
    {
        return false;
    }

    /* 获取音频检测信息 */
    if(!getAudioDetectInfo(m_compareItemInfo))
    {
        return false;
    }

    return true;
}


/* 设置静音过载反相可编辑 */
void CompareItemDialog::setMOPEditable(EDBType type, bool editable)
{
    if(type == EDBType::DBType_Mute)
    {
        if(editable)
        {
            ui->lineEditMuteLen->setEnabled(true);
            ui->lineEditMuteSensibility->setEnabled(true);
            ui->lineEditMuteThreshold->setEnabled(true);
        }else {
            ui->lineEditMuteLen->setEnabled(false);
            ui->lineEditMuteSensibility->setEnabled(false);
            ui->lineEditMuteThreshold->setEnabled(false);
        }
    }
    else if(type == EDBType::DBType_Overload)
    {
        if(editable)
        {
            ui->lineEditOverloadLen->setEnabled(true);
            ui->lineEditOverloadSensibility->setEnabled(true);
            ui->lineEditOverloadThreshold->setEnabled(true);
        }else {
            ui->lineEditOverloadLen->setEnabled(false);
            ui->lineEditOverloadSensibility->setEnabled(false);
            ui->lineEditOverloadThreshold->setEnabled(false);
        }
    }
    else if(type == EDBType::DBType_Phase)
    {
        if(editable)
        {
            ui->lineEditPhaseLen->setEnabled(true);
            ui->lineEditPhaseSensibility->setEnabled(true);
            ui->lineEditPhaseThreshold->setEnabled(true);
        }else {
            ui->lineEditPhaseLen->setEnabled(false);
            ui->lineEditPhaseSensibility->setEnabled(false);
            ui->lineEditPhaseThreshold->setEnabled(false);
        }
    }
}

/* 设置检测参数输入栏只能输入数字 */
void CompareItemDialog::setDetectParamInputOnlyNumber()
{
    // 静音参数，只允许输入1~1000的整数
    // QRegularExpression rx1("-[4-8][0-9]");
    // ui->lineEditMuteThreshold->setValidator(new QRegularExpressionValidator(rx1, this));
    // StrictDoubleValidator
    ui->lineEditMuteThreshold->setValidator(new StrictIntValidator(m_silenceThresholdLow, m_silenceThresholdHigh, this));
    ui->lineEditMuteLen->setValidator(new StrictIntValidator(m_silenceDurationLow, m_silenceDurationHigh, this));
    ui->lineEditMuteSensibility->setValidator(new StrictIntValidator(m_silenceSensitivityLow, m_silenceSensitivityHigh, this));

    // 过载参数
    ui->lineEditOverloadThreshold->setValidator(new StrictIntValidator(m_overloadThresholdLow, m_overloadThresholdHigh, this));
    ui->lineEditOverloadLen->setValidator(new StrictIntValidator(m_overloadDurationLow, m_overloadDurationHigh, this));
    ui->lineEditOverloadSensibility->setValidator(new StrictIntValidator(m_overloadSensitivityLow, m_overloadSensitivityHigh, this));

    // 反相参数，阈值为浮点数，范围0.0~0.99
    ui->lineEditPhaseThreshold->setValidator(new StrictDoubleValidator(m_phaseThresholdLow, m_phaseThresholdHigh, 3, this));
    ui->lineEditPhaseLen->setValidator(new QIntValidator(m_phaseDurationLow, m_phaseDurationHigh, this));
    ui->lineEditPhaseSensibility->setValidator(new QIntValidator(m_phaseSensitivityLow, m_phaseSensitivityHigh, this));

}

/* 新增一个通道 */
SingleCompareRoadWidget* CompareItemDialog::addOneRoadWidget(int nIndex, bool bDelBtnVisible)
{
    QVBoxLayout* pLayout = qobject_cast<QVBoxLayout*>(ui->scrollAreaWidgetContents->layout());
    if(pLayout == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "滚动区域内容布局未设置，无法添加通道");
        return nullptr;
    }
    SingleCompareRoadWidget *pWgt = new SingleCompareRoadWidget(this);
    pWgt->setIndex(nIndex);
    pWgt->setDelBtnVisible(bDelBtnVisible);
    /* 设置可选通道列表 */
    pWgt->setSoundCardRoadList(m_soundCardInfo);
    pWgt->setQSS(m_qssRecordRoad);
    pLayout->insertWidget(m_listOtherRoadWgt.size() - 2, pWgt);

    connect(pWgt, &SingleCompareRoadWidget::deleted, this, &CompareItemDialog::do_CompareRoadWgtDeleted);
    connect(pWgt, &SingleCompareRoadWidget::signal_selectRecordRoad, this, &CompareItemDialog::do_selectOneRecordRoad);
    m_listOtherRoadWgt.append(pWgt);
    
    return pWgt;
}



/* 获取对比项的基础信息 */
bool CompareItemDialog::getCompareItemBaseInfo(CompareItemInfo_t& compareItemInfo)
{
    if(!m_isMultiEdit)
    {
        if(ui->lineEdit_compareItmName->text().isEmpty())
        {
            setWarn(ui->lineEdit_compareItmName, true);
            TipWidget::display(TipWidget::OPERATOR_WARN, "对比项名称不能为空", this);
            return false;
        }
        /* 检查名称和现有的是否重复 */
        if(m_listCompareItemNames.contains(ui->lineEdit_compareItmName->text()))
        {
            setWarn(ui->lineEdit_compareItmName, true);
            TipWidget::display(TipWidget::OPERATOR_WARN, "对比项名称已存在", this);
            return false;
        }
    }
    compareItemInfo.strName = ui->lineEdit_compareItmName->text();
    compareItemInfo.isEnable = ui->checkBox_enable->isChecked();

    return true;
}

/* 获取各个通道信息 */
bool CompareItemDialog::getCompareRoadInfo(CompareItemInfo_t& compareItemInfo)
{
    compareItemInfo.mapRoad.clear();

    /* 获取其他通道信息 */
    for(SingleCompareRoadWidget* roadWgt : m_listOtherRoadWgt)
    {
        CompareItemRoadInfo_t otherRoadInfo;
        otherRoadInfo.strCompareRoadName = roadWgt->getRoadName();
        otherRoadInfo.nCompareRoadNum = roadWgt->getIndex();
        otherRoadInfo.isEnableRecord = roadWgt->isRecordEnabled();
        otherRoadInfo.scRoadInfo = roadWgt->getSoundCardRoadInfo();
        if(otherRoadInfo.strCompareRoadName.isEmpty())
        {
            roadWgt->setRoadNameWarn(true);
            TipWidget::display(TipWidget::OPERATOR_WARN, QString("第%1通道名称不能为空").arg(otherRoadInfo.nCompareRoadNum), this);
            return false;
        }
        compareItemInfo.mapRoad.insert(otherRoadInfo.nCompareRoadNum, otherRoadInfo);
    }

    /* 判断通道名称是否重复 */
    bool isDuplicate = false;
    for(auto& widget1 : m_listOtherRoadWgt)
    {
        for(auto& widget2 : m_listOtherRoadWgt)
        {
            if(widget1 == widget2)
            {
                continue;
            }
            if(widget1->getRoadName() == widget2->getRoadName())
            {
                isDuplicate = true;
                widget1->setRoadNameWarn(true);
                widget2->setRoadNameWarn(true);
                break;
            }
        }
    }
    if(isDuplicate)
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, QString("通道名称重复"), this);
        return false;
    }

    /* 判断是否选择声卡通道信息 */
    bool isSelectSoundCard = true;
    for(auto& widget : m_listOtherRoadWgt)
    {
        if(widget->getCurrentPCMName().isEmpty())
        {
            widget->setSoundCardWarn(true);
            TipWidget::display(TipWidget::OPERATOR_WARN, QString("请选择%1通道的声卡录音通道").arg(widget->getIndex()), this);
            isSelectSoundCard = false;
        }
    }
    if(isSelectSoundCard == false)
    {
        return false;
    }

    return true;
}

/* 获取音频检测信息 */
bool CompareItemDialog::getAudioDetectInfo(CompareItemInfo_t& compareItemInfo)
{
    int silenceThreshold = ui->lineEditMuteThreshold->text().toULongLong();
    int silenceDuration = ui->lineEditMuteLen->text().toInt();
    int silenceSensitivity = ui->lineEditMuteSensibility->text().toInt();

    int overloadThreshold = ui->lineEditOverloadThreshold->text().toULongLong();
    int overloadDuration = ui->lineEditOverloadLen->text().toInt();
    int overloadSensitivity = ui->lineEditOverloadSensibility->text().toInt();

    double phaseThreshold = ui->lineEditPhaseThreshold->text().toDouble();
    int phaseDuration = ui->lineEditPhaseLen->text().toInt();
    int phaseSensitivity = ui->lineEditPhaseSensibility->text().toInt();

    /* 检测是否在范围内 */
    bool isOverThreshold = false;

    /* 检查静音参数 */
    if(silenceThreshold < m_silenceThresholdLow || silenceThreshold > m_silenceThresholdHigh)
    {
        setWarn(ui->lineEditMuteThreshold, true);
        isOverThreshold = true;
    }

    if(silenceDuration < m_silenceDurationLow || silenceDuration > m_silenceDurationHigh)
    {
        setWarn(ui->lineEditMuteLen, true);
        isOverThreshold = true;
    }
    if(silenceSensitivity < m_silenceSensitivityLow || silenceSensitivity > m_silenceSensitivityHigh)
    {
        setWarn(ui->lineEditMuteSensibility, true);
        isOverThreshold = true;
    }

    /* 检查过载参数 */
    if(overloadThreshold < m_overloadThresholdLow || overloadThreshold > m_overloadThresholdHigh)
    {
        setWarn(ui->lineEditOverloadThreshold, true);
        isOverThreshold = true;
    }
    if(overloadDuration < m_overloadDurationLow || overloadDuration > m_overloadDurationHigh)
    {
        setWarn(ui->lineEditOverloadLen, true);
        isOverThreshold = true;
    }
    if(overloadSensitivity < m_overloadSensitivityLow || overloadSensitivity > m_overloadSensitivityHigh)
    {
        setWarn(ui->lineEditOverloadSensibility, true);
        isOverThreshold = true;
    }

    /* 检查反向参数 */
    if(phaseThreshold < m_phaseThresholdLow || phaseThreshold > m_phaseThresholdHigh)
    {
        setWarn(ui->lineEditPhaseThreshold, true);
        isOverThreshold = true;
    }
    if(phaseDuration < m_phaseDurationLow || phaseDuration > m_phaseDurationHigh)
    {
        setWarn(ui->lineEditPhaseLen, true);
        isOverThreshold = true;
    }
    if(phaseSensitivity < m_phaseSensitivityLow || phaseSensitivity > m_phaseSensitivityHigh)
    {
        setWarn(ui->lineEditPhaseSensibility, true);
        isOverThreshold = true;
    }

    if(isOverThreshold)
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, QString("检测参数超出范围"), this);
        return false;
    }


    /* 静音检测，注意阈值是负数，在输入框中是正数，这里需要转换一下 */
    compareItemInfo.paramMute.isEnable = ui->checkBoxMute->isChecked();
    compareItemInfo.paramMute.threshold.nThreshold = -silenceThreshold;
    compareItemInfo.paramMute.nLen = silenceDuration;
    compareItemInfo.paramMute.nSensitivity = silenceSensitivity;

    /* 过载检测 */
    compareItemInfo.paramOverload.isEnable = ui->checkBoxOverload->isChecked();
    compareItemInfo.paramOverload.threshold.nThreshold = -overloadThreshold;
    compareItemInfo.paramOverload.nLen = overloadDuration;
    compareItemInfo.paramOverload.nSensitivity = overloadSensitivity;

    /* 反相检测 */
    compareItemInfo.paramPhase.isEnable = ui->checkBoxPhase->isChecked();
    compareItemInfo.paramPhase.threshold.dThreshold = -phaseThreshold;
    compareItemInfo.paramPhase.nLen = phaseDuration;
    compareItemInfo.paramPhase.nSensitivity = phaseSensitivity;

    return true;
}

/* 取消所有的报警 */
void CompareItemDialog::cancelAllWarn()
{
    setWarn(ui->lineEdit_compareItmName, false);
    for(SingleCompareRoadWidget* roadWgt : m_listOtherRoadWgt)
    {
        roadWgt->setRoadNameWarn(false);
        roadWgt->setSoundCardWarn(false);
    }

    /* 取消检测参数的报警红框 */
    setWarn(ui->lineEditMuteThreshold, false);
    setWarn(ui->lineEditMuteLen, false);
    setWarn(ui->lineEditMuteSensibility, false);

    setWarn(ui->lineEditOverloadThreshold, false);
    setWarn(ui->lineEditOverloadLen, false);
    setWarn(ui->lineEditOverloadSensibility, false);

    setWarn(ui->lineEditPhaseThreshold, false);
    setWarn(ui->lineEditPhaseLen, false);
    setWarn(ui->lineEditPhaseSensibility, false);
}