ts/TransmitterSwitch/ManagerPlan/managerplan.cpp

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


#include <QMouseEvent>
#include <QDesktopWidget>
#include <QScreen>

#include "UIStyleManager.h"
#include "OneShadowEffect.h"
#include "TransmitterSwitchInfo.h"
#include "warning.h"
#include "tipwidget.h"
#include "LHQLogAPI.h"
#include "savetotemplate.h"
#include "FromWebAPI.h"
#include "FromSQLite.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();
    auto screenRect = QGuiApplication::screenAt(QCursor::pos())->geometry();
    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);
    
    if(ui->pCard->isPlanEmpty())
    {
        /* 没有计划，隐藏按钮 */
        setButtonVisible(false);
    }else
    {
        /* 有计划，显示按钮 */
        setButtonVisible(true);
    }
}

/* 设置FromWebAPI地址，复用主窗口的WebAPI */
void ManagerPlan::setFromWebAPI(FromWebAPI* fromWebAPI)
{
    if(fromWebAPI == nullptr)
    {
        // LH_WRITE_ERROR("传入的FromWebAPI指针为空");
        return;
    }
    m_fromWebAPI = fromWebAPI;
}

/* 设置FromSQLite地址，复用主窗口的SQLite */
void ManagerPlan::setFromSQLite(FromSQLite* fromSQLite)
{
    if(fromSQLite == nullptr)
    {
        // LH_WRITE_ERROR("传入的FromSQLite指针为空");
        return;
    }
    m_fromSQLite = fromSQLite;
}


/* 修改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;
}

/* 查找全局计划列表，没有被修改过的计划列表 */
void ManagerPlan::findGlobalPlanList(const int chnID, QList<PlanInfo>& list)
{
    /* 将PData的计划拷贝过来 */
    auto pCard = PData.findPlanCard(chnID);
    if(pCard != nullptr)
    {
        pCard->getPlanList(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;
        }
    }
}


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

/* 判断是否跨周了，判断方法就是开机时间比关机时间大 */
bool ManagerPlan::isCrossWeek(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;
    }

    return false;
}


/**
 * @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;
    }
}


/* 比较两个时间点的大小，这个兼容下一周的结束时间，下一周就顺延7天 */
bool ManagerPlan::timeIsGerater(int weekDay1, const QDateTime& time1,
                            int weekDay2, const QDateTime& time2, bool isSpecialDay)
{
    if(isSpecialDay)
    {
        /* 特殊日 */
        if(time1 > time2)
        {
            return true;
        }else
        {
            return false;
        }
    }else 
    {
        /* 正常日 */
        if(weekDay1 > weekDay2)
        {
            return true;
        }
        else if(weekDay1 == weekDay2)
        {
            /* 日期相同，比较时间 */
            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)
{
    PlanInfo newInfo = info;
    /* 判断是否跨周了 */
    newInfo.isNextWeek = isCrossWeek(newInfo);
    QList<PlanInfo>& list = findPlanList(chnID);

    for(const auto& it : list)
    {
        /* 判断是否同为正常日或者特殊日 */
        if( (it.onWeekDay == enum_WeekDay::WeekDay_Special && info.onWeekDay != enum_WeekDay::WeekDay_Special) ||
            (it.onWeekDay != enum_WeekDay::WeekDay_Special && info.onWeekDay == enum_WeekDay::WeekDay_Special) )
        {
            /* 一个是特殊日，一个是正常日，不冲突 */
            continue;
        }
        PlanInfo tmpInfo = it;
        /* 判断是否跨周了 */
        tmpInfo.isNextWeek = isCrossWeek(tmpInfo);
        if(tmpInfo.isNextWeek)
        {
            if(newInfo.isNextWeek)
            {
                /* 不会有两个都跨周的情况，直接返回冲突 */
                return true;
            }
        }

        int tmpWeekDayOn = static_cast<int>(tmpInfo.onWeekDay);
        int tmpWeekDayOff = static_cast<int>(tmpInfo.offWeekDay);
        int newWeekDayOn = static_cast<int>(newInfo.onWeekDay);
        int newWeekDayOff = static_cast<int>(newInfo.offWeekDay);
        /* info结束时间小于开始时间，或者info开始时间大于结束时间，就不冲突 */
        bool isLess = false;
        bool isGreater = false;
        if(it.onWeekDay == enum_WeekDay::WeekDay_Special)
        {
            isLess = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, true);
            isGreater = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, true);
        }else 
        {
            /* 普通日，先判断tmpInfo是否跨周了 */
            if(tmpInfo.isNextWeek)
            {
                /* 拆分成两个时间段分别判断 */
                int tmpWeekDayOn1 = tmpWeekDayOn;
                int tmpWeekDayOff1 = 7; /* 这一周的最后一天 */
                int tmpWeekDayOn2 = 1; /* 下一周的第一天 */
                int tmpWeekDayOff2 = tmpWeekDayOff;
                /* 判断两个时间段是否冲突 */
                bool isLess1 = timeIsGerater(tmpWeekDayOn1, tmpInfo.onDateTime, newWeekDayOn, newInfo.offDateTime, false);
                bool isGreater1 = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff1, tmpInfo.offDateTime, false);
                if(isLess1 || isGreater1)
                {
                }else {
                    return true; /* 时间冲突 */
                }

                bool isLess2 = timeIsGerater(tmpWeekDayOn2, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, false);
                bool isGreater2 = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff2, tmpInfo.offDateTime, false);
                if(isLess2 || isGreater2)
                {
                }else {
                    return true; /* 时间冲突 */
                }
            }
            else if(newInfo.isNextWeek)
            {
                /* 拆分成两个时间段分别判断 */
                int newWeekDayOn1 = newWeekDayOn;
                int newWeekDayOff1 = 7; /* 这一周的最后一天 */
                int newWeekDayOn2 = 1; /* 下一周的第一天 */
                int newWeekDayOff2 = newWeekDayOff;
                /* 判断两个时间段是否冲突 */
                bool isLess1 = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff1, newInfo.offDateTime, false);
                bool isGreater1 = timeIsGerater(newWeekDayOn1, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess1 || isGreater1)
                {
                }else {
                    return true; /* 时间冲突 */
                }

                bool isLess2 = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff2, newInfo.offDateTime, false);
                bool isGreater2 = timeIsGerater(newWeekDayOn2, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess2 || isGreater2)
                {
                }else {
                    return true; /* 时间冲突 */
                }
            }
            else
            {
                isLess = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, false);
                isGreater = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess || isGreater)
                {
                    /* 时间不冲突 */
                    continue;
                }else {
                    return true; /* 时间冲突 */
                }
            }
        }
        
    }

    return false;
}


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

    PlanInfo newInfo = info;
    /* 判断是否跨周了 */
    newInfo.isNextWeek = isCrossWeek(newInfo);
    
    for(const auto& it : list)
    {
        /* 判断是否同为正常日或者特殊日 */
        if( (it.onWeekDay == enum_WeekDay::WeekDay_Special && info.onWeekDay != enum_WeekDay::WeekDay_Special) ||
            (it.onWeekDay != enum_WeekDay::WeekDay_Special && info.onWeekDay == enum_WeekDay::WeekDay_Special) )
        {
            /* 一个是特殊日，一个是正常日，不冲突 */
            continue;
        }
        PlanInfo tmpInfo = it;
        /* 判断是否跨周了 */
        tmpInfo.isNextWeek = isCrossWeek(tmpInfo);
        if(tmpInfo.isNextWeek)
        {
            if(newInfo.isNextWeek)
            {
                /* 不会有两个都跨周的情况，直接返回冲突 */
                return true;
            }
        }

        int tmpWeekDayOn = static_cast<int>(tmpInfo.onWeekDay);
        int tmpWeekDayOff = static_cast<int>(tmpInfo.offWeekDay);
        int newWeekDayOn = static_cast<int>(newInfo.onWeekDay);
        int newWeekDayOff = static_cast<int>(newInfo.offWeekDay);
        /* info结束时间小于开始时间，或者info开始时间大于结束时间，就不冲突 */
        bool isLess = false;
        bool isGreater = false;
        if(it.onWeekDay == enum_WeekDay::WeekDay_Special)
        {
            isLess = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, true);
            isGreater = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, true);
        }else 
        {
            /* 普通日，先判断tmpInfo是否跨周了 */
            if(tmpInfo.isNextWeek)
            {
                /* 拆分成两个时间段分别判断 */
                int tmpWeekDayOn1 = tmpWeekDayOn;
                int tmpWeekDayOff1 = 7; /* 这一周的最后一天 */
                int tmpWeekDayOn2 = 1; /* 下一周的第一天 */
                int tmpWeekDayOff2 = tmpWeekDayOff;
                /* 判断两个时间段是否冲突 */
                bool isLess1 = timeIsGerater(tmpWeekDayOn1, tmpInfo.onDateTime, newWeekDayOn, newInfo.offDateTime, false);
                bool isGreater1 = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff1, tmpInfo.offDateTime, false);
                if(isLess1 || isGreater1)
                {
                }else {
                    return true; /* 时间冲突 */
                }

                bool isLess2 = timeIsGerater(tmpWeekDayOn2, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, false);
                bool isGreater2 = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff2, tmpInfo.offDateTime, false);
                if(isLess2 || isGreater2)
                {
                }else {
                    return true; /* 时间冲突 */
                }
            }
            else if(newInfo.isNextWeek)
            {
                /* 拆分成两个时间段分别判断 */
                int newWeekDayOn1 = newWeekDayOn;
                int newWeekDayOff1 = 7; /* 这一周的最后一天 */
                int newWeekDayOn2 = 1; /* 下一周的第一天 */
                int newWeekDayOff2 = newWeekDayOff;
                /* 判断两个时间段是否冲突 */
                bool isLess1 = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff1, newInfo.offDateTime, false);
                bool isGreater1 = timeIsGerater(newWeekDayOn1, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess1 || isGreater1)
                {
                }else {
                    return true; /* 时间冲突 */
                }

                bool isLess2 = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff2, newInfo.offDateTime, false);
                bool isGreater2 = timeIsGerater(newWeekDayOn2, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess2 || isGreater2)
                {
                }else {
                    return true; /* 时间冲突 */
                }
            }
            else
            {
                isLess = timeIsGerater(tmpWeekDayOn, tmpInfo.onDateTime, newWeekDayOff, newInfo.offDateTime, false);
                isGreater = timeIsGerater(newWeekDayOn, newInfo.onDateTime, tmpWeekDayOff, tmpInfo.offDateTime, false);
                if(isLess || isGreater)
                {
                    /* 时间不冲突 */
                    continue;
                }else {
                    return true; /* 时间冲突 */
                }
            }
        }
        
    }


    return false;
}

/**
 * @brief 判断新添加的计划是否在即将要执行的计划附近
 *        1、运行这个函数之前会先进行时间冲突监测，如果有冲突，新计划的关机计划必定在即将执行的计划之前
 *        2、新添加计划主要判断新计划的结束时间是否在即将执行的计划开始时间之前的10分钟内
 * 
 * @param chnID 
 * @param newInfo 
 * @return true 
 * @return false 
 */
bool ManagerPlan::checkNewPlanNear(const int chnID, const PlanInfo& newInfo)
{
    QList<PlanInfo> list;
    findGlobalPlanList(chnID, list);
    /* 先寻找是否有即将执行的计划 */
    QDateTime nowTime = QDateTime::currentDateTime();
    /* 先判断关机时间是否在当前时间点到之后十分钟之内 */
    if(!isNearTime(nowTime, newInfo.offWeekDay, newInfo.offDateTime))
    {
        /* 关机时间不在当前时间点到之后十分钟之内，不冲突 */
        return false;
    }
    /* 关机时间在当前时间之后的十分钟内，再查找已有的计划开机时间是否有在十分钟之内的 */
    bool isConflict = false;
    // PlanInfo tmpInfo;
    for(const auto& it : list)
    {
        if(isNearTime(nowTime, it.onWeekDay, it.onDateTime))
        {
            isConflict = true;
            // tmpInfo = it;           /* 记录即将执行的计划 */
            break;
        }
    }

    return isConflict;
}

/* 判断修改的计划是否对即将要执行的计划有影响 */
bool ManagerPlan::checkModifyPlanNear(const int chnID, const PlanInfo& oldInfo, const PlanInfo& newInfo)
{
    /* 先判断旧数据是否在原始数据列表中 */
    QList<PlanInfo> list;
    findGlobalPlanList(chnID, list);
    bool isExist = false;
    for(const auto& it : list)
    {
        if(it == oldInfo)
        {
            isExist = true;
            break;
        }
    }
    if(!isExist)
    {
        /* 旧数据不在原始数据列表中，直接返回 */
        return false;
    }
    /*--------------------------------------------------------------
     * 判断修改的计划有没有在倒计时附近
     * 1、如果被修改的计划在倒计时附近，不能修改
     * 2、如果被修改的计划不在倒计时附近，判断修改完成后的计划是否在倒计时附近
     *   判断方法：先判断修改完成后的计划是否在当前十分钟之内，如果在，再查找
     *   当前十分钟之内是否有即将执行的计划，如果有，则冲突
     *--------------------------------------------------------------*/
    QDateTime nowTime = QDateTime::currentDateTime();
    /* 先判断被修改的计划是否在倒计时附近 */
    if(isNearTime(nowTime, oldInfo.onWeekDay, oldInfo.onDateTime) ||
       isNearTime(nowTime, oldInfo.offWeekDay, oldInfo.offDateTime))
    {
        /* 被修改的计划在倒计时附近，不能修改 */
        TipWidget::display(TipWidget::OPERATOR_WARN, "被修改的计划正在倒计时，不能修改!", this);
        return true;
    }
    /* 判断修改完成后的计划是否在当前时间附近 */
    if(isNearTime(nowTime, newInfo.onWeekDay, newInfo.onDateTime) ||
    isNearTime(nowTime, newInfo.offWeekDay, newInfo.offDateTime))
    {
        /* 查找附近有无倒计时 */
        if(findNearPlan(chnID, nowTime))
        {
            TipWidget::display(TipWidget::OPERATOR_WARN, "修改后的计划在倒计时范围内，不能修改!", this);
            return true;
        }
    }

    return false;
}


/**
 * @brief 判断这个时间点附近有没有即将要执行的计划
 *        1、先寻找特殊日，特殊日会覆盖正常日的计划，十分钟内既有特殊日又有正常日，返回的是特殊日
 *        2、这个查找的是原始的没有被修改过的计划列表
 * 
 * @param chnID 
 * @param nearInfo 
 * @return true 
 * @return false 
 */
bool ManagerPlan::findNearPlan(const int chnID, const QDateTime& nowTime)
{
    QList<PlanInfo> list;
    findGlobalPlanList(chnID, list);

    bool isNear = false;
    /* 先判断特殊日 */
    for(const auto& it : list)
    {
        if(it.onWeekDay == enum_WeekDay::WeekDay_Special)
        {
            if(isNearTime(nowTime, it.onWeekDay, it.onDateTime))
            {
                /* 找到特殊日的计划 */
                isNear = true;
                break;
            }
            if(isNearTime(nowTime, it.offWeekDay, it.offDateTime))
            {
                /* 找到特殊日的计划 */
                isNear = true;
                break;
            }
        }
    }
    if(isNear)
    {
        /* 找到特殊日的计划，直接返回 */
        return true;
    }
    /* 判断正常日 */
    for(const auto& it : list)
    {
        if(it.onWeekDay != enum_WeekDay::WeekDay_Special)
        {
            if(isNearTime(nowTime, it.onWeekDay, it.onDateTime))
            {
                /* 找到正常日的计划 */
                isNear = true;
                break;
            }
            if(isNearTime(nowTime, it.offWeekDay, it.offDateTime))
            {
                /* 找到正常日的计划 */
                isNear = true;
                break;
            }
        }
    }

    return isNear;
}

/* 判断两个时间点是否在十分钟之内 */
bool ManagerPlan::isNearTime(const QDateTime& nowTime, const enum_WeekDay weekDay, const QDateTime& time)
{
    // 10分钟后
    QDateTime tmpTime = nowTime.addSecs(10 * 60);
    enum_WeekDay nowWeekDay = static_cast<enum_WeekDay>(nowTime.date().dayOfWeek());
    enum_WeekDay tmpWeekDay = static_cast<enum_WeekDay>(tmpTime.date().dayOfWeek());
    /* 先判断是否是特殊日 */
    if(weekDay == enum_WeekDay::WeekDay_Special)
    {
        if(time <= tmpTime && time > nowTime)
        {
            /* 在10分钟之内 */
            return true;
        }
    }

    /* 正常日，先判断有没有跨天 */
    if(nowWeekDay == tmpWeekDay)
    {
        /* 在同一天 */
        if(time.time() <= tmpTime.time() && time.time() > nowTime.time())
        {
            /* 在10分钟之内 */
            return true;
        }
    }else {
        /* 跨天了，判断时间 */
        if(weekDay == nowWeekDay)
        {
            /* 在今天 */
            if(time.time() >= nowTime.time())
            {
                /* 在今天的10分钟之内 */
                return true;
            }else {
                /* 在明天的10分钟之内 */
                if(time.time() <= tmpTime.time())
                {
                    return true;
                }
            }
        }
    }

    return false; /* 不在10分钟之内 */
}


/* 设置按钮显示或隐藏 */
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::saveTemplateToEQM()
{
    if(m_fromWebAPI == nullptr && m_fromSQLite == nullptr)
    {
        LH_WRITE_ERROR("没有初始化FromWebAPI或FromSQLite");
        return;
    }
    auto chnInfo = ui->pCard->getChannelInfo();
    /* 获取所有的模板名称 */
    QList<OneTemplateInfo> list;
    if(!m_fromWebAPI->getTemplateList(chnInfo.ChannelID, list))
    {
        LH_WRITE_ERROR(QString("获取频率ID为%1的模版列表失败").arg(chnInfo.ChannelID));
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取模版列表失败", this);
        return;
    }
    /* 弹出导出页面 */
    std::shared_ptr<SaveToTemplate> stt = std::make_shared<SaveToTemplate>();
    stt->setQSS(EPUIStyle.getQSSPath());
    stt->setTemplateList(list);
    stt->exec();
    if(!stt->isOk())
    {
        return;
    }
    /* 获取一天的数据 */
    QList<OnePlanItemInfo> listTmp;
    ui->pCard->getAllPlanInfo(listTmp);
    /* 保存到模板 */
    bool isSuccess = false;
    if(GInfo.isOnlineDB())
    {
        isSuccess = m_fromWebAPI->saveTemplate(stt->getTemplateName(), listTmp);
    }else {
        isSuccess = m_fromSQLite->saveTemplate(stt->getTemplateName(), listTmp);
    }

    if(isSuccess)
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "保存模版成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "保存模版失败", this);
    }
    /* 调用回调函数 */
    emit signal_callBack(3);
}


/* 选择了一个频率 */
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());
        /* 判断时间是否相等 */
        if(isEqualTime(one))
        {
            /* 开机时间等于关机时间，相等 */
            TipWidget::display(TipWidget::OPERATOR_WARN, "开机时间不能等于关机时间!", this);
            return;
        }
    }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;
    }

    /* 判断新计划是否在即将要执行的计划时间点附近 */
    // if(checkNewPlanNear(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 slectRow = ui->pCard->getSelectedRow();
    if(slectRow < 0 || slectRow >= 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());
        /* 判断时间是否相等 */
        if(isEqualTime(one))
        {
            /* 开机时间等于关机时间，相等 */
            TipWidget::display(TipWidget::OPERATOR_WARN, "开机时间不能等于关机时间!", this);
            return;
        }
    }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;
        }
    }
    /* 先判断设置的时间是否和当前选中的行的时间相同 */
    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;
    }
    /* 判断修改的计划是否在即将要执行的计划时间点附近 */
    // if(checkModifyPlanNear(chnID, exPlan, one))
    // {
    //     return;
    // }
    

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

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

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

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

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

}

/* 点击了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());
    }
    /* 判断是正常日还是特殊日，自动切换显示的页面 */
    if(info.onWeekDay != enum_WeekDay::WeekDay_Special)
    {
        /* 正常日 */
        ui->tabWidget->setCurrentIndex(0);
    }else {
        /* 特殊日 */
        ui->tabWidget->setCurrentIndex(1);
    }
}



/* 鼠标点击事件 */
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);
}