ts/TransmitterSwitch/ManagerPlan/managerplan.cpp

#include "managerplan.h"
#include "ui_managerplan.h"


#include <QMouseEvent>
#include <QDesktopWidget>
#include "UIStyleManager.h"
#include "OneShadowEffect.h"
#include "TransmitterSwitchInfo.h"
#include "warning.h"
#include "tipwidget.h"
#include "LHQLogAPI.h"
#include "savetotemplate.h"


ManagerPlan::ManagerPlan(Enum_Mode mode, QDialog *parent) :
    m_mode(mode),
    QDialog(parent),
    ui(new Ui::ManagerPlan)
{
    ui->setupUi(this);

    /* 设置隐藏边框 */
    this->setWindowFlags(Qt::Dialog | Qt::FramelessWindowHint);
    /* 设置底层样式表 */
    this->setAttribute(Qt::WA_TranslucentBackground);

    /* 创建阴影 */
    auto pShadow = new OneShadowEffect(this);
    ui->widget_background->setGraphicsEffect(pShadow);

    /* 获取屏幕大小 */
    auto screenRect = QApplication::desktop()->availableGeometry();
    this->resize(screenRect.width(), screenRect.height());
    /* 设置设置区域居中显示 */
    ui->widget_background->move(screenRect.width() / 2 - ui->widget_background->width() / 2,
        screenRect.height() / 2 - ui->widget_background->height() / 2);

    /* 设置Card最小宽度 */
    ui->pCard->setMinimumWidth(300);
    ui->pCard->setFixedWidth(300);

    /* 注册事件过滤器 */
    ui->cBox_selectChn->installEventFilter(this);
    ui->pBtn_close->installEventFilter(this);

    /* 设置时间和日期选择Tab */
    setTabWidget();

    /* 设置默认时间和日期 */
    auto date = QDate::currentDate();
    auto time = QTime::fromString("00:00:00", "hh:mm:ss");
    ui->timeEdit_weekStart->setTime(time);
    ui->timeEdit_weekEnd->setTime(time);
    ui->timeEdit_specialStart->setTime(time);
    ui->timeEdit_specialEnd->setTime(time);

    ui->dateEdit_specialStart->setDisplayFormat("yy-MM-dd");
    ui->dateEdit_specialEnd->setDisplayFormat("yy-MM-dd");
    ui->dateEdit_specialStart->setDate(date);
    ui->dateEdit_specialEnd->setDate(date);

    /* 设置时间图标 */
    ui->timeEdit_weekStart->setIcon(":/ICON/ICON/Time.png");
    ui->timeEdit_weekEnd->setIcon(":/ICON/ICON/Time.png");
    ui->timeEdit_specialStart->setIcon(":/ICON/ICON/Time.png");
    ui->timeEdit_specialEnd->setIcon(":/ICON/ICON/Time.png");

    ui->timeEdit_weekStart->SetMainWindow(this);
    ui->timeEdit_weekEnd->SetMainWindow(this);
    ui->timeEdit_specialStart->SetMainWindow(this);
    ui->timeEdit_specialEnd->SetMainWindow(this);

    /* 需要设置这个属性，qss设置的图标才会生效 */
    ui->dateEdit_specialStart->setCalendarPopup(true);
    ui->dateEdit_specialEnd->setCalendarPopup(true);

    /* 设置可选择的频率 */
    setSelectFrequency();

    /* 设置可选择的周几 */
    setWeekDay();

    /* 连接信号和槽 */
    connect(ui->pBtn_cancel, &QPushButton::clicked, this, &ManagerPlan::close);
    connect(ui->pBtn_close, &QPushButton::clicked, this, &ManagerPlan::close);
    connect(ui->cBox_selectChn, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &ManagerPlan::do_selectFrequency);
    connect(&EPUIStyle, &UIStyleManager::signal_qssChanged, this, &ManagerPlan::do_setUIStyle);
    connect(ui->pBtn_addPlan, &QPushButton::clicked, this, &ManagerPlan::do_addPlanItem);
    connect(ui->pBtn_editPlan, &QPushButton::clicked, this, &ManagerPlan::do_modifyPlanItem);
    connect(ui->pBtn_deletePlan, &QPushButton::clicked, this, &ManagerPlan::do_deletePlanItem);
    connect(ui->pBtn_ok, &QPushButton::clicked, this, &ManagerPlan::do_pBtn_ok);
    connect(ui->pCard, &PlanCard::signal_clickedItem, this, &ManagerPlan::do_tableView_clicked);
    connect(ui->pBtn_saveTotemplate, &QPushButton::clicked, this, &ManagerPlan::do_saveTemplate);

    /* 设置皮肤样式 */
    do_setUIStyle();

    /* 设置下拉框阴影 */
    ui->cBox_selectChn->setViewShadowEffect();
    ui->cBox_selectWeekStart->setViewShadowEffect();
    ui->cBox_selectWeekEnd->setViewShadowEffect();

    /* 注册事件过滤器 */
    ui->cBox_selectChn->installEventFilter(this);
    ui->cBox_selectWeekStart->installEventFilter(this);
    ui->cBox_selectWeekEnd->installEventFilter(this);

    /* 默认显示周计划 */
    ui->tabWidget->setCurrentIndex(0);

    /* 设置显示模式 */
    setMode(mode);
}

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

/* 设置频率信息 */
void ManagerPlan::setFrequencyID(ChannelInfo& info)
{
    m_channelInfo = info;
    /* 设置当前频率选项 */
    if(ui->cBox_selectChn->count() > 0)
    {
        for(int i = 0; i < ui->cBox_selectChn->count(); i++)
        {
            if(ui->cBox_selectChn->itemData(i).toInt() == info.ChannelID)
            {
                ui->cBox_selectChn->setCurrentIndex(i);
                break;
            }
        }
    }
    /* 设置当前频率的计划列表 */
    ui->pCard->setChannelInfo(info);
    if((m_mode == Enum_Mode::Mode_Add) || (m_mode == Enum_Mode::Mode_Modify))
    {
        /* 设置当前频率的计划列表 */
        auto list = findPlanList(info.ChannelID);
        /* 设置计划列表 */  
        ui->pCard->setPlanList(list);
    }

    if(ui->pCard->isPlanEmpty())
    {
        /* 没有计划，隐藏按钮 */
        setButtonVisible(false);
    }else
    {
        /* 有计划，显示按钮 */
        setButtonVisible(true);
    }
}


/* 设置计划列表，给修改模版使用 */
void ManagerPlan::setPlanList(QList<OnePlanItemInfo>& listPlan)
{
    /* 设置当前频率的计划列表 */
    ui->pCard->setPlanList(listPlan);
    /* 转换为PlanInfo */
    QList<PlanInfo> list;
    ui->pCard->getPlanList(list);
    /* 设置计划列表 */
    m_mapPlanInfo.insert(m_channelInfo.ChannelID, list);
}


/* 修改UI样式 */
void ManagerPlan::do_setUIStyle()
{
    this->setStyleSheet(EPUIStyle.StrQSS_ManagerPlan);
}


/* 设置显示模式，需要在执行exec()之前调用 */
void ManagerPlan::setMode(Enum_Mode mode)
{
    if(mode == Enum_Mode::Mode_Add)
    {
        ui->label_title->setText("新增");                   /* 修改标题 */
        ui->widget_background->resize(this->width(), 740);  /* 修改窗口大小 */
    }
    else if(mode == Enum_Mode::Mode_Modify)
    {
        ui->widget_addPlan->setVisible(false);              /* 隐藏添加计划区域 */
        ui->label_title->setText("编辑");                   /* 修改标题 */
        ui->widget_background->resize(this->width(), 600);  /* 修改窗口大小 */
    }
    else if(mode == Enum_Mode::Mode_ModifyTemplate)
    {
        ui->widget_addPlan->setVisible(false);              /* 隐藏添加计划区域 */
        ui->label_title->setText("修改模板");                /* 修改标题 */
        ui->widget_background->resize(this->width(), 600);  /* 修改窗口大小 */
        ui->pBtn_saveTotemplate->setVisible(false);         /* 隐藏保存模版按钮 */
    }
    m_mode = mode;

}


/* 设置时间和日期选择Tab */
void ManagerPlan::setTabWidget()
{
    /* 设置Tab的大小 */
    QSize size(ui->tabWidget->width(), ui->tabWidget->height() - ui->tabWidget->tabBar()->height() - 2);
    /* 设置正常日的Tab */
    ui->tab_week->resize(size);
    auto vLayout1 = new QVBoxLayout(ui->tab_week);
    vLayout1->setContentsMargins(0, 24, 0, 0);
    vLayout1->setSpacing(12);
    ui->tab_week->setLayout(vLayout1);
    vLayout1->addWidget(ui->widget_weekStart);
    vLayout1->addWidget(ui->widget_weekEnd);

    /* 设置特殊日的Tab */
    ui->tab_special->resize(size);
    auto vLayout2 = new QVBoxLayout(ui->tab_special);
    vLayout2->setContentsMargins(0, 24, 0, 0);
    vLayout2->setSpacing(12);
    ui->tab_special->setLayout(vLayout2);
    vLayout2->addWidget(ui->widget_specialStart);
    vLayout2->addWidget(ui->widget_specialEnd);
}

/* 设置可选择的周几 */
void ManagerPlan::setWeekDay()
{
    ui->cBox_selectWeekStart->addItem("星期一", static_cast<int>(enum_WeekDay::WeekDay_Mon));
    ui->cBox_selectWeekStart->addItem("星期二", static_cast<int>(enum_WeekDay::WeekDay_Tue));
    ui->cBox_selectWeekStart->addItem("星期三", static_cast<int>(enum_WeekDay::WeekDay_Wed));
    ui->cBox_selectWeekStart->addItem("星期四", static_cast<int>(enum_WeekDay::WeekDay_Thu));
    ui->cBox_selectWeekStart->addItem("星期五", static_cast<int>(enum_WeekDay::WeekDay_Fri));
    ui->cBox_selectWeekStart->addItem("星期六", static_cast<int>(enum_WeekDay::WeekDay_Sat));
    ui->cBox_selectWeekStart->addItem("星期天", static_cast<int>(enum_WeekDay::WeekDay_Sun));

    ui->cBox_selectWeekEnd->addItem("星期一", static_cast<int>(enum_WeekDay::WeekDay_Mon));
    ui->cBox_selectWeekEnd->addItem("星期二", static_cast<int>(enum_WeekDay::WeekDay_Tue));
    ui->cBox_selectWeekEnd->addItem("星期三", static_cast<int>(enum_WeekDay::WeekDay_Wed));
    ui->cBox_selectWeekEnd->addItem("星期四", static_cast<int>(enum_WeekDay::WeekDay_Thu));
    ui->cBox_selectWeekEnd->addItem("星期五", static_cast<int>(enum_WeekDay::WeekDay_Fri));
    ui->cBox_selectWeekEnd->addItem("星期六", static_cast<int>(enum_WeekDay::WeekDay_Sat));
    ui->cBox_selectWeekEnd->addItem("星期天", static_cast<int>(enum_WeekDay::WeekDay_Sun));
}

/* 设置可选频率 */
void ManagerPlan::setSelectFrequency()
{
    for(const auto& chnInfo : ChnContainer.getMapChannel())
    {
        ui->cBox_selectChn->addItem(chnInfo.ChannelName, chnInfo.ChannelID);
    }
    /* 设置默认的频率 */
    if(ui->cBox_selectChn->count() > 0)
    {
        ui->cBox_selectChn->setCurrentIndex(0);
        do_selectFrequency(0);
    }
    
}

/* 查找本地计划列表，这个频率不存在则添加 */
QList<PlanInfo>& ManagerPlan::findPlanList(const int chnID)
{
    auto list = m_mapPlanInfo.find(chnID);
    /* 如果没有这个频率的计划列表，则创建一个新的列表 */
    if(list == m_mapPlanInfo.end())
    {
        QList<PlanInfo> listPlan;
        /* 如果是修改模版，则不从全局获取数据，插入一个空的即可 */
        if(m_mode != Enum_Mode::Mode_ModifyTemplate)
        {
            /* 将PData的计划拷贝过来 */
            auto pCard = PData.findPlanCard(chnID);
            if(pCard != nullptr)
            {
                pCard->getPlanList(listPlan);
            }
        }
        m_mapPlanInfo.insert(chnID, listPlan);
    }
    /* 再次查找这个频率的列表 */
    list = m_mapPlanInfo.find(chnID);
    return *list;
}


/* 添加计划，同时添加ui的卡片计划和计划列表 */
void ManagerPlan::addPlanItem(const int chnID, const PlanInfo& info)
{
    /*  添加到UI*/
    ui->pCard->addPlanItem(info);
    /* 添加到计划列表 */
    QList<PlanInfo>& list = findPlanList(chnID);
    list.append(info);
}

/* 修改容器中的计划 */
void ManagerPlan::modifyPlanItem(const int chnID, const PlanInfo& nowInfo, const PlanInfo& newInfo)
{
    auto& list = findPlanList(chnID);
    for(int i = 0; i < list.count(); i++)
    {
        if(list.at(i) == nowInfo)
        {
            list.replace(i, newInfo);
            break;
        }
    }
}


/**
 * @brief 判断开机和关机时间是否冲突
 * 
 * @param info 
 * @return true 冲突
 * @return false 不冲突
 */
bool ManagerPlan::checkOnAndOffTime(const PlanInfo& info)
{
    if(info.onWeekDay != enum_WeekDay::WeekDay_Special)
    {
        /* 正常日判断 */
        if(info.onWeekDay > info.offWeekDay)
        {
            /* 开机时间大于关机时间，冲突 */
            return true;
        }
        else if(info.onWeekDay == info.offWeekDay)
        {
            /* 开机和关机在同一天 */
            if(info.onDateTime.time() >= info.offDateTime.time())
            {
                /* 开机时间大于等于关机时间，冲突 */
                return true;
            }else
            {
                /* 开机时间小于关机时间，不冲突 */
                return false;
            }
        }
        return false;
    } 
    else
    {
        /* 特殊日判断 */ 
        /* 开机和关机在不同天 */
        if(info.onDateTime.date() > info.offDateTime.date())
        {
            /* 开机时间大于关机时间，冲突 */
            return true;
        }
        else if(info.onDateTime.date() == info.offDateTime.date())
        {
            /* 开机和关机在同一天 */
            if(info.onDateTime.time() >= info.offDateTime.time())
            {
                /* 开机时间大于等于关机时间，冲突 */
                return true;
            }else
            {
                /* 开机时间小于关机时间，不冲突 */
                return false;
            }
        }
        return false; 
    }
}

/**
 * @brief 比较两个时间点的大小，正常日和特殊日都可以比较
 * 
 * @param info1 
 * @param info2 
 * @return true info1 > info2
 * @return false info1 < info2
 */
bool ManagerPlan::timeIsGerater(const enum_WeekDay weekDay1, const QDateTime& time1,
    const enum_WeekDay weekDay2, const QDateTime& time2)
{
    /* 正常日 */
    if(weekDay1 != enum_WeekDay::WeekDay_Special)
    {
        /* 先比较日期 */
        if(weekDay1 > weekDay2)
        {
            return true;
        }
        else if(weekDay1 == weekDay2)
        {
            /* 日期相同，比较时间 */
            if(time1.time() > time2.time())
            {
                return true;
            }else
            {
                return false;
            }
        }
        return false;
    } 
    else /* 特殊日 */
    {
        /* 先比较日期 */
        if(time1.date() > time2.date())
        {
            return true;
        }
        else if(time1.date() == time2.date())
        {
            /* 日期相同，比较时间 */
            if(time1.time() > time2.time())
            {
                return true;
            }else
            {
                return false;
            }
        }
        return false;
    }
}

/**
 * @brief 判断计划时间和列表中的时间是否冲突
 *        判断规则是只要时间段不和任何一个时间段重合就不冲突
 * 
 * @param chnID 
 * @param info 
 * @return true 时间冲突
 * @return false 时间不冲突
 */
bool ManagerPlan::checkPlanTimeConflict(const int chnID, const PlanInfo& info)
{
    QList<PlanInfo>& list = findPlanList(chnID);

    bool isConflict = false;
    int weekDayStart = static_cast<int>(info.onWeekDay);
    int weekDayEnd = static_cast<int>(info.offWeekDay);
    for(const auto& it : list)
    {
        /* info结束时间小于开始时间，或者info开始时间大于结束时间，就不冲突 */
        bool isLess = timeIsGerater(it.onWeekDay, it.onDateTime, info.offWeekDay, info.offDateTime);
        bool isGreater = timeIsGerater(info.onWeekDay, info.onDateTime, it.offWeekDay, it.offDateTime);
        if(isLess || isGreater)
        {
            /* 时间不冲突 */
            continue;
        }
        isConflict = true; /* 时间冲突 */
        break;
    }

    return isConflict;
}


/* 判断计划时间和列表中的时间是否冲突，添加排除的计划，用于比较修改的计划 */
bool ManagerPlan::checkPlanTimeConflict(const int chnID, const PlanInfo& newInfo, const PlanInfo& exInfo)
{
    /* 这里采用拷贝的方式获取，后续不需要再把排除的项放回去 */
    QList<PlanInfo> list = findPlanList(chnID);
    /* 先去掉需要排除的项 */
    list.removeOne(exInfo);

    bool isConflict = false;
    int weekDayStart = static_cast<int>(newInfo.onWeekDay);
    int weekDayEnd = static_cast<int>(newInfo.offWeekDay);
    for(const auto& it : list)
    {
        /* info结束时间小于开始时间，或者info开始时间大于结束时间，就不冲突 */
        bool isLess = timeIsGerater(it.onWeekDay, it.onDateTime, newInfo.offWeekDay, newInfo.offDateTime);
        bool isGreater = timeIsGerater(newInfo.onWeekDay, newInfo.onDateTime, it.offWeekDay, it.offDateTime);
        if(isLess || isGreater)
        {
            /* 时间不冲突 */
            continue;
        }
        isConflict = true; /* 时间冲突 */
        break;
    }

    return isConflict;
}


/* 设置按钮显示或隐藏 */
void ManagerPlan::setButtonVisible(bool isVisible)
{
    if(isVisible)
    {
        ui->pBtn_editPlan->show();
        ui->pBtn_deletePlan->show();
    }else
    {
        ui->pBtn_editPlan->hide();
        ui->pBtn_deletePlan->hide();
    }
}


/* 选择了一个频率 */
void ManagerPlan::do_selectFrequency(int index)
{
    auto chnID = ui->cBox_selectChn->itemData(index).toInt();
    m_channelInfo = ChnContainer.getChannel(chnID);
    
    QList<PlanInfo>& list = findPlanList(chnID);
    /* 设置频率信息 */
    ui->pCard->setChannelInfo(ChnContainer.getChannel(chnID));
    /* 设置计划列表 */
    ui->pCard->setPlanList(list);
    
    if(list.isEmpty())
    {
        /* 没有计划，隐藏按钮 */
        setButtonVisible(false);
    }else
    {
        /* 有计划，显示按钮 */
        setButtonVisible(true);
    }
}

/* 点击了添加按钮 */
void ManagerPlan::do_addPlanItem()
{
    int chnID = ui->pCard->getChannelInfo().ChannelID;
    PlanInfo one;
    /* 判断是正常日还是特殊日 */
    if(ui->tabWidget->currentIndex() == 0)
    {
        /* 正常日 */
        one.onWeekDay = static_cast<enum_WeekDay>(ui->cBox_selectWeekStart->itemData(ui->cBox_selectWeekStart->currentIndex()).toInt());
        one.onDateTime.setTime(ui->timeEdit_weekStart->getTime());

        one.offWeekDay = static_cast<enum_WeekDay>(ui->cBox_selectWeekEnd->itemData(ui->cBox_selectWeekEnd->currentIndex()).toInt());
        one.offDateTime.setTime(ui->timeEdit_weekEnd->getTime());
    }else {
        /* 特殊日 */
        one.onWeekDay = enum_WeekDay::WeekDay_Special;
        one.onDateTime.setDate(ui->dateEdit_specialStart->date());
        one.onDateTime.setTime(ui->timeEdit_specialStart->getTime());

        one.offWeekDay = enum_WeekDay::WeekDay_Special;
        one.offDateTime.setDate(ui->dateEdit_specialEnd->date());
        one.offDateTime.setTime(ui->timeEdit_specialEnd->getTime());
    }
    

    /* 先判断开机时间和关机时间是否冲突 */
    if(checkOnAndOffTime(one))
    {
        /* 开始和结束时间冲突 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "开机时间早于或等于关机时间!", this);
        return;
    }

    /* 判断时间段是否和历史时间段冲突 */
    if(checkPlanTimeConflict(chnID, one))
    {
        /* 时间段冲突 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "时间段冲突!", this);
        return;
    }

    /* 添加计划 */
    addPlanItem(chnID, one);

    setButtonVisible(true); /* 显示按钮 */

}

/* 点击修改按钮 */
void ManagerPlan::do_modifyPlanItem()
{
    int chnID = ui->pCard->getChannelInfo().ChannelID;
    auto& list = findPlanList(chnID);

    /* 获取选中的行 */
    auto index = ui->pCard->getSelectedRow();
    if(index < 0 || index >= list.size())
    {
        /* 没有选中行 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "没有选中行!", this);
        return;
    }
    // LH_WRITE_LOG_DEBUG(QString("修改行: %1").arg(index));

    /* 获取修改后的日期 */
    PlanInfo one;
    if(ui->tabWidget->currentIndex() == 0)
    {
        /* 正常日 */
        one.onWeekDay = static_cast<enum_WeekDay>(ui->cBox_selectWeekStart->itemData(ui->cBox_selectWeekStart->currentIndex()).toInt());
        one.onDateTime.setTime(ui->timeEdit_weekStart->getTime());
        one.offWeekDay = static_cast<enum_WeekDay>(ui->cBox_selectWeekEnd->itemData(ui->cBox_selectWeekEnd->currentIndex()).toInt());
        one.offDateTime.setTime(ui->timeEdit_weekEnd->getTime());
    }else {
        /* 特殊日 */
        one.onWeekDay = enum_WeekDay::WeekDay_Special;
        one.onDateTime.setDate(ui->dateEdit_specialStart->date());
        one.onDateTime.setTime(ui->timeEdit_specialStart->getTime());
        one.offWeekDay = enum_WeekDay::WeekDay_Special;
        one.offDateTime.setDate(ui->dateEdit_specialEnd->date());
        one.offDateTime.setTime(ui->timeEdit_specialEnd->getTime());
    }
    /* 先判断设置的时间是否和当前选中的行的时间相同 */
    auto nowPlan = ui->pCard->getSelectedPlan();
    if(nowPlan == one)
    {
        return;
    }
    /* 先判断开机时间和关机时间是否冲突 */
    if(checkOnAndOffTime(one))
    {
        /* 开始和结束时间冲突 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "开机时间早于或等于关机时间!", this);
        return;
    }
    auto exPlan = ui->pCard->getSelectedPlan();
    /* 判断时间段是否和历史时间段冲突 */
    if(checkPlanTimeConflict(chnID, one, exPlan))
    {
        /* 时间段冲突 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "时间段冲突!", this);
        return;
    }

    /* 修改选中的行 */
    auto oldPlan = ui->pCard->modifyPlanItem(index, one);    
    /* 修改数据容器中的计划 */
    modifyPlanItem(chnID, oldPlan, one);
}

/* 点击了删除按钮 */
void ManagerPlan::do_deletePlanItem()
{
    int chnID = ui->pCard->getChannelInfo().ChannelID;
    auto& list = findPlanList(chnID);

    /* 获取选中的行 */
    auto index = ui->pCard->getSelectedRow();
    if(index < 0 || index >= list.size())
    {
        /* 没有选中行 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "没有选中行!", this);
        return;
    }
    LH_WRITE_LOG_DEBUG(QString("删除行: %1").arg(index));
    /* 删除选中的行 */
    auto plan = ui->pCard->deletePlanItem(index);
    /* 删除UI的计划 */
    list.removeOne(plan);

    /* 判断删除后是否还有计划，没有就隐藏修改和删除按钮 */
    if(list.isEmpty())
    {
        /* 没有计划，隐藏按钮 */
        setButtonVisible(false);
    }
}

/* 点击了保存模版按钮 */
void ManagerPlan::do_saveTemplate()
{
    /* 判断卡片有没有计划 */
    if(ui->pCard->isPlanEmpty())
    {
        /* 没有计划 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "该频率没有计划!", this);
        return;
    }
    
    emit signal_saveTemplate(ui->pCard->getChannelInfo());

}

/* 点击了OK按钮 */
void ManagerPlan::do_pBtn_ok()
{
    m_isOK = true;
    this->close();
}

/* 选中了一项，回显到编辑页面 */
void ManagerPlan::do_tableView_clicked(PlanInfo& info)
{
    /* 设置时间和日期 */
    if(info.onWeekDay != enum_WeekDay::WeekDay_Special)
    {
        /* 正常日 */
        ui->cBox_selectWeekStart->setCurrentIndex(static_cast<int>(info.onWeekDay) - 1);
        ui->timeEdit_weekStart->setTime(info.onDateTime.time());
        ui->cBox_selectWeekEnd->setCurrentIndex(static_cast<int>(info.offWeekDay) - 1);
        ui->timeEdit_weekEnd->setTime(info.offDateTime.time());
    }else
    {
        /* 特殊日 */
        ui->dateEdit_specialStart->setDate(info.onDateTime.date());
        ui->timeEdit_specialStart->setTime(info.onDateTime.time());
        ui->dateEdit_specialEnd->setDate(info.offDateTime.date());
        ui->timeEdit_specialEnd->setTime(info.offDateTime.time());
    }
}



/* 鼠标点击事件 */
void ManagerPlan::mousePressEvent(QMouseEvent *event)
{
    m_lastPos = event->globalPos();
    event->accept();
}

/* 鼠标移动事件 */
void ManagerPlan::mouseMoveEvent(QMouseEvent *event)
{
    auto point = ui->widget_top->mapToGlobal(QPoint(0, 0));
    QRect rect(point, ui->widget_top->size());

    if(!rect.contains(m_lastPos))
    {
        event->accept();
        return;
    }

    int dx = event->globalX() - m_lastPos.x();
    int dy = event->globalY() - m_lastPos.y();
    ui->widget_background->move(ui->widget_background->x() + dx, ui->widget_background->y() + dy);
    m_lastPos = event->globalPos();
    event->accept();
}

/* 鼠标释放事件 */
void ManagerPlan::mouseReleaseEvent(QMouseEvent *event)
{
    event->accept();
}

/* 事件过滤器 */
bool ManagerPlan::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->cBox_selectChn)
    {
        if(event->type() == QEvent::Wheel)
        {
            return true;
        }
    }
    else if(watched == ui->cBox_selectChn)
    {
        if(event->type() == QEvent::Wheel)
        {
            return true;
        }
    }
    else if(watched == ui->cBox_selectWeekStart)
    {
        if(event->type() == QEvent::Wheel)
        {
            return true;
        }
    }
    else if(watched == ui->cBox_selectWeekEnd)
    {
        if(event->type() == QEvent::Wheel)
        {
            return true;
        }
    }
    else if(watched == ui->pBtn_close)
    {
        if(event->type() == QEvent::Enter)
        {
            ui->pBtn_close->setProperty("Hover", true);
            ui->pBtn_close->style()->unpolish(ui->pBtn_close);
            ui->pBtn_close->style()->polish(ui->pBtn_close);
            return true;
        }else if(event->type() == QEvent::Leave)
        {
            ui->pBtn_close->setProperty("Hover", false);
            ui->pBtn_close->style()->unpolish(ui->pBtn_close);
            ui->pBtn_close->style()->polish(ui->pBtn_close);
            return true;
        }
    }
    return QDialog::eventFilter(watched, event);
}