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 <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);

    /* 设置可选的声卡通道信息 */
    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::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);
        }
    }
    /* 设置其他通道 */
    for(const auto& road : item.mapRoad)
    {
        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()
{
    /* 从3开始编号，1是主通道，2是第二通道 */
    int index = m_listOtherRoadWgt.size() + 3;
    addOneRoadWidget(index, true);
}

/* 删除通道 */
void CompareItemDialog::do_CompareRoadWgtDeleted(int nIndex)
{
    int nRealIndex = nIndex - 3;
    if(nRealIndex < m_listOtherRoadWgt.size())
    {
        SingleCompareRoadWidget *pWgt = m_listOtherRoadWgt.at(nRealIndex);
        m_listOtherRoadWgt.removeOne(pWgt);
        delete pWgt;
        pWgt = nullptr;
    }
    for(int i = nRealIndex; i < m_listOtherRoadWgt.size(); i++)
    {
        m_listOtherRoadWgt.at(i)->setIndex(i + 3);
    }
}

/* 静音、过载、反相检测条件开关 */
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
    /* 判断是否重复 */
    if(sender != ui->widget_mainRoad)
    {
        if(ui->widget_mainRoad->getCurrentPCMName() == strPCMName)
        {
            // 如果重复，则去掉重复的
            ui->widget_mainRoad->clearCurrentSelectRecordName();
        }
    }
    
    if(sender != ui->widget_secondRoad)
    {
        if(ui->widget_secondRoad->getCurrentPCMName() == strPCMName)
        {
            // 如果重复，则去掉重复的
            ui->widget_secondRoad->clearCurrentSelectRecordName();
        }
    }
    

    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);
}

/* 设置静音过载反相可编辑 */
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));
    ui->lineEditMuteThreshold->setValidator(new QIntValidator(40, 84, this));
    ui->lineEditMuteLen->setValidator(new QIntValidator(2, 90, this));
    ui->lineEditMuteSensibility->setValidator(new QIntValidator(22, 100, this));

    // 过载参数
    ui->lineEditOverloadThreshold->setValidator(new QIntValidator(0, 40, this));
    ui->lineEditOverloadLen->setValidator(new QIntValidator(2, 90, this));
    ui->lineEditOverloadSensibility->setValidator(new QIntValidator(22, 100, this));

    // 反相参数，阈值为浮点数，范围0.0~0.99
    ui->lineEditPhaseThreshold->setValidator(new StrictDoubleValidator(0.0, 0.99, 3, this));
    ui->lineEditPhaseLen->setValidator(new QIntValidator(10, 90, this));
    ui->lineEditPhaseSensibility->setValidator(new QIntValidator(20, 99, 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(), 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::isOKClicked()
{
    /* 先取消所有的报警 */
    cancelAllWarn();
    /* 获取对比项的信息 */
    if(!getCompareItemBaseInfo(m_compareItemInfo))
    {
        return false;
    }

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

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

    return true;
}

/* 获取对比项的基础信息 */
bool CompareItemDialog::getCompareItemBaseInfo(CompareItemInfo_t& compareItemInfo)
{
    if(ui->lineEdit_compareItmName->text().isEmpty())
    {
        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();
    /* 获取主通道信息 */
    CompareItemRoadInfo_t mainRoadInfo;
    mainRoadInfo.strCompareRoadName = ui->widget_mainRoad->getRoadName();
    mainRoadInfo.nCompareRoadNum = ui->widget_mainRoad->getIndex();
    mainRoadInfo.isEnableRecord = ui->widget_mainRoad->isRecordEnabled();
    mainRoadInfo.scRoadInfo = ui->widget_mainRoad->getSoundCardRoadInfo();
    if(mainRoadInfo.strCompareRoadName.isEmpty())
    {
        ui->widget_mainRoad->setRoadNameWarn(true);
        TipWidget::display(TipWidget::OPERATOR_WARN, "主通道名称不能为空", this);
        return false;
    }
    compareItemInfo.mapRoad.insert(mainRoadInfo.nCompareRoadNum, mainRoadInfo);
    /* 获取第二通道信息 */
    CompareItemRoadInfo_t secondRoadInfo;
    secondRoadInfo.strCompareRoadName = ui->widget_secondRoad->getRoadName();
    secondRoadInfo.nCompareRoadNum = ui->widget_secondRoad->getIndex();
    secondRoadInfo.isEnableRecord = ui->widget_secondRoad->isRecordEnabled();
    secondRoadInfo.scRoadInfo = ui->widget_secondRoad->getSoundCardRoadInfo();
    if(secondRoadInfo.strCompareRoadName.isEmpty())
    {
        ui->widget_secondRoad->setRoadNameWarn(true);
        TipWidget::display(TipWidget::OPERATOR_WARN, "第二通道名称不能为空", this);
        return false;
    }
    compareItemInfo.mapRoad.insert(secondRoadInfo.nCompareRoadNum, secondRoadInfo);

    /* 获取其他通道信息 */
    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);
    }

    return true;
}

/* 获取音频检测信息 */
bool CompareItemDialog::getAudioDetectInfo(CompareItemInfo_t& compareItemInfo)
{
    /* 静音检测，注意阈值是负数，在输入框中是正数，这里需要转换一下 */
    compareItemInfo.paramMute.isEnable = ui->checkBoxMute->isChecked();
    compareItemInfo.paramMute.threshold.nThreshold = -ui->lineEditMuteThreshold->text().toULongLong();
    compareItemInfo.paramMute.nLen = ui->lineEditMuteLen->text().toInt();
    compareItemInfo.paramMute.nSensitivity = ui->lineEditMuteSensibility->text().toInt();

    /* 过载检测 */
    compareItemInfo.paramOverload.isEnable = ui->checkBoxOverload->isChecked();
    compareItemInfo.paramOverload.threshold.nThreshold = -ui->lineEditOverloadThreshold->text().toULongLong();
    compareItemInfo.paramOverload.nLen = ui->lineEditOverloadLen->text().toInt();
    compareItemInfo.paramOverload.nSensitivity = ui->lineEditOverloadSensibility->text().toInt();

    /* 反相检测 */
    compareItemInfo.paramPhase.isEnable = ui->checkBoxPhase->isChecked();
    compareItemInfo.paramPhase.threshold.dThreshold = -ui->lineEditPhaseThreshold->text().toDouble();
    compareItemInfo.paramPhase.nLen = ui->lineEditPhaseLen->text().toInt();
    compareItemInfo.paramPhase.nSensitivity = ui->lineEditPhaseSensibility->text().toInt();

    return true;
}

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