ts/TransmitterSwitch/transmitterswitch.cpp

#include "transmitterswitch.h"
#include "importtemplate.h"
#include "ui_transmitterswitch.h"


#include <QFile>
#include <QList>
#include <memory>
#include <QLayout>
// #include <qlist.h>
// #include <qstringliteral.h>

#include "LHQLogAPI.h"
#include "widgetitems.h"
#include "UserData/pBtnUserData.h"
#include "AddItem/addnormalitem.h"
#include "AddItem/addspecialitem.h"
#include "WebAPI/FromWebAPI.h"
#include "TransmitterSwitchInfo.h"
#include "oneitem.h"
#include "ItemData.h"
#include "timewidget.h"
#include "cdate.h"
#include "savetotemplate.h"
#include "importtemplate.h"
#include "warning.h"

TransmitterSwitch::TransmitterSwitch(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::TransmitterSwitch)
{
    ui->setupUi(this);

    /* 创建一个布局 */
    QVBoxLayout* layout = new QVBoxLayout(parent);
    layout->setMargin(0);
    layout->setSpacing(0);
    layout->addWidget(this);

    /* 创建WebAPI实例 */
    m_fromWebAPI = new FromWebAPI;

    /* 设置“默认计划”按钮可点击 */
    ui->pBtn_defaultPlan->setCheckable(true);
    /* 创建一周8天的页面 */
    createWeekWidget();

    /* 设置提示文本 */
    m_tipText = new QLabel(this);
    m_tipText->resize(936,56);
    m_tipText->move(456,8);
    m_tipText->setObjectName("label_TipText");
    m_tipText->setText(R"(按时刻执行模式：即以时刻点为单位进行执行，若某日既为普通日和特殊日，在某一时刻皆有执行动作，将优先执行特殊日在此时刻所计划的动作。
按天执行模式：即以天为单位进行执行，若某日既为普通日和特殊日，则当日一整天优先执行特殊日所计划的动作，普通日计划当日不再执行。)");
    m_tipText->hide();
    ui->label_Tip->installEventFilter(this);

    /* 设置默认值 */
    ui->pBtn_defaultPlan->setChecked(true);
    ui->rBtn_moment->setChecked(true);
    /* 获取今天是周几，设置周几页面 */
    int day = QDate::currentDate().dayOfWeek() - 1;
    m_vecWeeks[day]->setChecked(true);
    ui->stackedWidget_items->setCurrentIndex(day);

    /* 连接信号和槽 */
    connect(ui->pBtn_addPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnAddExecPlan);
    connect(ui->pBtn_importPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_importData);
    connect(ui->pBtn_exportPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_exportData);
    connect(ui->pBtn_clearPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_clearCurrentPage);

    /* 设置QSS */
    // LHStyleManager::Instance()->AddWidget(this);
    connect(&EPConfig, &ExecPlanGlobalConfig::signal_qssChanged, this, &TransmitterSwitch::do_setUIStyle);
    /* 设置默认的皮肤 */
    EPConfig.setUIStyle(enum_UIStyle::UI_Light);
}

TransmitterSwitch::~TransmitterSwitch()
{
    if(m_tipText != nullptr)
    {
        delete m_tipText;
        m_tipText = nullptr;
    }
    delete ui;
}


/* 设置样式表路径，给弹窗页面使用，不需要包含最后的white，black */
void TransmitterSwitch::setQSSPath(const QString &qssPath)
{
    if(qssPath.isEmpty())
    {
        return;
    }
    /* 去掉最后的“/” */
    // if(qssPath.endsWith("/"))
    // {
    //     EPConfig.setQSSPath(qssPath.left(qssPath.length() - 1));
    // } else
    // {
    //     EPConfig.setQSSPath(qssPath);
    // }
}

/**
 * @brief 设置WebAPI信息
 * 
 * @param url WebAPI地址
 * @param serID 数据库ID
 * @param serKey 限制的关键字
 */
void TransmitterSwitch::setWebAPIInfo(const QString &url, const QString &serverID, const QString &serverKey)
{
    if(m_fromWebAPI == nullptr)
    {
        m_fromWebAPI = new FromWebAPI;
    }
    if(url.isEmpty() || serverID.isEmpty() || serverKey.isEmpty())
    {
        LH_WRITE_ERROR("WebAPI info is empty");
        return;
    }
    m_fromWebAPI->initWebApi(url, serverID, serverKey);
    /* 获取支持的设备 */
    m_fromWebAPI->getDeviceInfo(DeviceContainer.getMapDevice());
}

/* 初始化webAPI，重载版 */
void TransmitterSwitch::setWebAPIInfo(const InitData& data)
{
    if(m_fromWebAPI == nullptr)
    {
        m_fromWebAPI = new FromWebAPI;
    }
    m_fromWebAPI->initWebApi(data.url, data.serverID, data.serverKey);
    /* 获取支持的设备 */
    m_fromWebAPI->getDeviceInfo(DeviceContainer.getMapDevice());
}

/* 获取EQM数据库计划 */
void TransmitterSwitch::getExecPlanFromEQM()
{
    /* 清空本地的计划数据 */
    IData.clearAllItem();

    QList<ExecPlanItemInfo> list;
    m_fromWebAPI->getExecPlanData(list);

    /* 添加计划项 */
    for(const auto& it : list)
    {
        if (it.WeekDay < 8 && it.WeekDay >= 1)
        {
            addNormalOneItem(it.WeekDay - 1, it.devName, it.actionName, it.execTime);
        }
        else if(it.WeekDay == 8)
        {
            addSpecialOneItem(it.WeekDay - 1, it.devName, it.actionName, it.date, it.execTime);
        
        }
    }
    /* 排序 */
    for(int i = 0; i < 8; ++i)
    {
        sortLayout(i);
    }
}

/* 将计划保存到EQM数据库 */
void TransmitterSwitch::saveExecPlanToEQM()
{
    QList<ExecPlanItemInfo> list;
    /* 获取当前计划的执行模式 */
    int execType = 0;
    if(ui->rBtn_moment->isChecked())
    {
        execType = 0;
    } else
    {
        execType = 1;
    }
    for(const auto& it : IData.getMapItem())
    {
        for(const auto& it1 : *it)
        {
            ExecPlanItemInfo info;
            info.ExecType = execType;
            info.devName = it1->getDevName();
            info.actionID = it1->getActionNum();
            info.actionName = it1->getActionNum();
            info.execTime = it1->getExecTime();
            info.date = it1->getDate();
            info.WeekDay = it1->getWeekDay() + 1;
            list.push_back(info);
        }
    }
    /* 判断计划条数，如果为0就阻止 */
    if(list.size() == 0)
    {
        return;
    }
    m_fromWebAPI->insertData(list);
}

/* 亮/暗换肤，0是亮色，1是暗色 */
void TransmitterSwitch::setUIStyle(int style)
{
    if(style == 0)
    {
        EPConfig.setUIStyle(enum_UIStyle::UI_Light);
    }
    else if(style == 1)
    {
        EPConfig.setUIStyle(enum_UIStyle::UI_Dark);
    }else {
        LH_WRITE_ERROR(QString("错误的样式类型: %1").arg(style));
    }
}


/* 每周几的按钮点击了，设置stackedWidegt页面 */
void TransmitterSwitch::do_weekpBtn_clicked()
{
    auto pBtn = qobject_cast<QPushButton*>(sender());
    /* 清除所有选中效果 */
    for(const auto& it : m_vecWeeks)
    {
        if(it != pBtn)
        {
            it->setChecked(false);
        }
    }
    pBtn->setChecked(true);
    auto userData = pBtn->userData(0);
    auto pBtnUserData = static_cast<PBtnUserData*>(userData);
    if(pBtnUserData == nullptr)
    {
        return;
    }
    int index = pBtnUserData->getIndex();
    ui->stackedWidget_items->setCurrentIndex(index);
}


/* 点击了添加计划按钮 */
void TransmitterSwitch::do_pBtnAddExecPlan()
{
    /* 创建页面，判断是正常日还是特殊日 */
    if(ui->stackedWidget_items->currentIndex() < 7)
    {
        std::shared_ptr<AddNormalItem> atf = std::make_shared<AddNormalItem>(this);
        atf->setParentPointer(this);
        atf->setQSS(EPConfig.getQSSPath());
        /* 设置可选项 */
        atf->setDevice(DeviceContainer.getMapDevice());
        /* 设置是周几 */
        int weekDay = ui->stackedWidget_items->currentIndex();
        atf->setWeekDay(weekDay);
        atf->exec();
        /* 判断是否需要添加计划 */
        if(atf->isAddDev())
        {
            /* 添加计划 */
            addNormalOneItem(weekDay, atf->getDevName(), atf->getAction(), atf->getTime());
        }
    }
    else
    {
        /* 特殊日 */
        std::shared_ptr<AddSpecialItem> atf = std::make_shared<AddSpecialItem>(this);
        atf->setParentPointer(this);
        atf->setQSS(EPConfig.getQSSPath());
        /* 设置可选项 */
        atf->setDevice(DeviceContainer.getMapDevice());
        /* 设置是周几 */
        int weekDay = ui->stackedWidget_items->currentIndex();
        atf->setWeekDay(weekDay);
        atf->exec();
        /* 判断是否需要添加计划 */
        if(atf->isAddDev())
        {
            /* 添加计划 */
            addSpecialOneItem(weekDay, atf->getDevName(), atf->getAction(), atf->getDate(), atf->getTime());
        }
    }
    /* 排序 */
    sortLayout(ui->stackedWidget_items->currentIndex());
}


/* 删除一项正常日计划 */
void TransmitterSwitch::do_deleteOneItem(int week, int index)
{
    /* 删除该项 */
    IData.deleteOneItem(week, index);
    /* 重新排序 */
    sortLayout(week);
}

/* 一个计划修改了设备 */
void TransmitterSwitch::do_changeDev()
{
    /* 判断修改设备后时间是否冲突 */
    auto one = qobject_cast<OneItem*>(sender());
    if(one == nullptr)
    {
        return;
    }
    if(one->getWeekDay() > 0 && one->getWeekDay() < 7)
    {
        if(IData.judgeTimeRepetitionWithEdit(one->getWeekDay(), one, one->getExecTime()))
        {
            /* 设置时间报警 */
            one->setWarningText("设备执行时间冲突", -1);
            return;
        }
    }
    else if(one->getWeekDay() == 7)
    {
        if(IData.judgeDateTimeRepetitionWithEdit(one->getWeekDay(), one, one->getDate(), one->getExecTime()))
        {
            /* 设置时间报警 */
            one->setWarningText("设备执行日期时间冲突", -1);
            return;
        }
    }
    /* 取消报警 */
    one->hideWarn();
}

/* 点击修改执行时间 */
void TransmitterSwitch::do_editExecTime(QTime t)
{
    /* 获取信号发送者 */
    auto one = qobject_cast<OneItem*>(sender());
    /* 创建时间选择控件 */
    std::shared_ptr<TimeWidget> tw = std::make_shared<TimeWidget>(this, TimeWidget::ShowType::Dialog);
    /* 设置图标 */
    tw->setIcon(":/ICON/ICON/Time.png");
    tw->setIconShow(true);
    tw->setIconSize(16, 16);
    /* 重新设置大小 */
    tw->setEditLine(one->getExecTimeSize().width(), one->getExecTimeSize().height());
    /* 设置选择框大小 */
    tw->setTimeAreaWidth(140);
    /* 移动位置，覆盖显示时间的按钮，获取的坐标是相对于Dialog的位置 */
    auto pos = one->mapTo(this, one->getExecTimePos());
    pos.setX(pos.x() - 1);     /* 去掉阴影的宽度 */
    pos.setY(pos.y());     /* 去掉阴影的高度 */
    tw->move(pos);
    /* 设置默认的时间 */
    tw->setTime(t);

    tw->execShow();
    auto time = tw->getTime();
    /* 判断时间有没有修改 */
    if(time == t)
    {
        return;
    }
    LH_WRITE_LOG_DEBUG(QString("选择时间:%1").arg(time.toString("hh:mm:ss")));
    one->setExecTime(time);
    /* 判断时间是否重复 */
    if(IData.judgeTimeRepetitionWithEdit(one->getWeekDay(), one, time))
    {
        /* 设置时间报警 */
        one->setWarningText("设备执行时间冲突", -1);
        return;
    }
    /* 取消报警 */
    one->hideWarn();
    /* 重新排序 */
    sortLayout(one->getWeekDay());
}


/* 点击修改日期 */
void TransmitterSwitch::do_editExecDate(QDate d)
{
    /* 获取信号发送者 */
    auto one = qobject_cast<OneItem*>(sender());
    /* 创建时间选择控件 */
    // std::shared_ptr<CDate> cd = std::make_shared<CDate>(this);

    // /* 移动位置，日历弹窗没有编辑栏，只有选择日历的时间，日历弹窗自带16px的阴影 */
    // auto pos = one->mapTo(this, one->getExecDatePos());
    // pos.setY(pos.y() + 32);     /* 去掉时间显示栏的高度 */
    // pos.setX(pos.x() - 16);     /* 去掉阴影的宽度 */

    // cd->move(pos);
    // /* 设置默认的日期 */
    // cd->setDate(d);

    // cd->execShow();
    // /* 获取日期 */
    // auto date = cd->getDate();
    // LH_WRITE_LOG_DEBUG(QString("选择日期:%1").arg(date.toString("yyyy-MM-dd")));
    // /* 判断日期有没有修改 */
    // if(date == d)
    // {
    //     return;
    // }

    one->setDate(d);
    /* 判断日期时间是否重复 */
    if(IData.judgeDateTimeRepetitionWithEdit(one->getWeekDay(), one, d, one->getExecTime()))
    {
        /* 设置时间报警 */
        one->setWarningText("设备执行日期时间冲突", -1);
        return;
    }
    /* 取消报警 */
    one->hideWarn();
    /* 重新排序 */
    sortLayout(one->getWeekDay());

}

/* 导入数据 */
void TransmitterSwitch::do_importData()
{
    /* 获取当前周几 */
    int weekDay = ui->stackedWidget_items->currentIndex();

    QStringList tabList;
    // tabList << "模板1" << "模板2" << "模板3" << "模板4" << "模板5";
    m_fromWebAPI->getTemplateList(tabList);
    std::shared_ptr<ImportTemplate> itf = std::make_shared<ImportTemplate>(tabList, this);
    itf->setQSSPath(EPConfig.getQSSPath());

    /* 连接信号和槽 */
    connect(itf.get(), &ImportTemplate::signal_deleteTemplate, this, &TransmitterSwitch::do_deleteTemplate);


    itf->exec();
    if(itf->isOk())
    {
        /* 获取模板名称 */
        auto name = itf->getTemplateName();
        /* 获取模板内容 */
        QList<ExecPlanItemInfo> list;
        list.clear();
        if(!m_fromWebAPI->getTemplate(name, list))
        {
            return;
        }
        /* 清除当前页内容 */
        IData.clearOneDay(weekDay);
        /* 添加计划项 */
        if (weekDay < 7 && weekDay >= 0)
        {
            for(const auto& it : list)
            {
                // LH_WRITE_LOG_DEBUG(QString("DevName:%1, ExecTime:%2").arg(it.devName).arg(it.execTime.toString("hh:mm:ss")));
                addNormalOneItem(weekDay, it.devName, it.actionName, it.execTime);
            }
        }else if (weekDay == 7)
        {
            for(const auto& it : list)
            {
                addSpecialOneItem(weekDay, it.devName, it.actionName, it.date, it.execTime);
            }
        }
        /* 排序 */
        sortLayout(weekDay);
    }
}

/* 导出数据 */
void TransmitterSwitch::do_exportData()
{
    std::shared_ptr<SaveToTemplate> stt = std::make_shared<SaveToTemplate>(this);
    stt->setQSS(EPConfig.getQSSPath());
    /* 注册事件过滤器 */
    stt->installEventFilter(this);
    int weekDay = ui->stackedWidget_items->currentIndex();
    /* 设置周几 */
    stt->setWeekDay(weekDay);
    /* 判断当前页是否有计划 */
    if(IData.getOneDay(weekDay)->size() == 0)
    {
        stt->setItemEmpty(true);
    }else
    {
        stt->setItemEmpty(false);
    }
    /* 获取所有的模板名称，并设置 */
    // stt->setTemplateName();

    stt->exec();
    if(stt->isOk())
    {
        /* 获取一天的数据 */
        auto list = IData.getOneDayExecPlan(weekDay);
        /* 保存到模板 */
        m_fromWebAPI->saveTemplate(stt->getTemplateName(), list);
    }
}

/* 清空当前页计划 */
void TransmitterSwitch::do_clearCurrentPage()
{
    /* 跳出弹窗警告 */
    Warning w(this);
    w.setQSS(EPConfig.getQSSPath());
    w.setText("是否清空当前页计划？");
    bool flag = false;
    connect(&w,&Warning::signal_ok,this,[&](){
        flag = true;
    });
    w.exec();
    if(!flag)
    {
        return;
    }
    int weekDay = ui->stackedWidget_items->currentIndex();
    IData.clearOneDay(weekDay);
    sortLayout(weekDay);
}

/* 删除一个模板 */
void TransmitterSwitch::do_deleteTemplate(QString name)
{
    m_fromWebAPI->deleteTemplate(name);
}

/* 切换亮色/暗色外观 */
void TransmitterSwitch::do_setUIStyle()
{
    QString qssPath = EPConfig.getQSSPath() + "/transmitterswitch.qss";
    QFile file(qssPath);
    if(file.open(QFile::ReadOnly))
    {
        QString qss = file.readAll();
        this->setStyleSheet(qss);
        file.close();
    }else {
        LH_WRITE_ERROR(QString("打开样式表失败: %1").arg(qssPath));
    }
}

/* 创建一周8天的item页面 */
void TransmitterSwitch::createWeekWidget()
{
    /* 将8个按钮的指针存入到数组中，方便后续使用 */
    m_vecWeeks.push_back(ui->pBtn_Monday);
    m_vecWeeks.push_back(ui->pBtn_Tuesday);
    m_vecWeeks.push_back(ui->pBtn_Wednesday);
    m_vecWeeks.push_back(ui->pBtn_Thursday);
    m_vecWeeks.push_back(ui->pBtn_Friday);
    m_vecWeeks.push_back(ui->pBtn_Saturday);
    m_vecWeeks.push_back(ui->pBtn_Sunday);
    m_vecWeeks.push_back(ui->pBtn_SpecialDay);
    

    for(const auto& it : m_vecWeeks)
    {
        /* 设置每周的按钮可点击 */
        it->setCheckable(true);
        connect(it,&QPushButton::clicked,this,&TransmitterSwitch::do_weekpBtn_clicked);
    }
    /* 清空stackedWidget页面 */
    int wcount = ui->stackedWidget_items->count();
    for(int i = 0; i < wcount; ++i)
    {
        auto widgetItems = ui->stackedWidget_items->widget(i);
        ui->stackedWidget_items->removeWidget(widgetItems);
        delete widgetItems;
    }
    /* 创建Widget页面 */
    for(int i = 0; i < 7; ++i)
    {
        auto widgetItems = new WidgetItems(this);
        m_vecWidgetItems.push_back(widgetItems);
        ui->stackedWidget_items->addWidget(widgetItems);
        /* 设置正常日 */
        widgetItems->setDayType(false);
        /* 获取layout，这个才是存储item的区域 */
        auto layout = widgetItems->getLayout();
        m_vecLayouts.push_back(layout);
        /* 给按钮设置用户数据 */
        auto pBtnUserData = new PBtnUserData();
        pBtnUserData->setData(widgetItems);
        pBtnUserData->setIndex(i);
        m_vecWeeks[i]->setUserData(0, pBtnUserData);
    }
    /* 创建特殊日 */
    auto widgetItems = new WidgetItems(this);
    m_vecWidgetItems.push_back(widgetItems);
    ui->stackedWidget_items->addWidget(widgetItems);
    /* 设置特殊日 */
    widgetItems->setDayType(true);
    /* 获取layout，这个才是存储item的区域 */
    auto layout = widgetItems->getLayout();
    m_vecLayouts.push_back(layout);
    /* 给按钮设置用户数据 */
    auto pBtnUserData = new PBtnUserData();
    pBtnUserData->setData(widgetItems);
    pBtnUserData->setIndex(7);
    m_vecWeeks[7]->setUserData(0, pBtnUserData);

    // LH_WRITE_LOG("StackedWidget count: " + QString::number(ui->stackedWidget_items->count()));
}


/* 添加一个正常日的计划 */
void TransmitterSwitch::addNormalOneItem(int week, QString devName, QString action, QTime execTime)
{
    OneItem* one = new OneItem(false);
    /* 添加可选的设备 */
    one->addDevice();
    /* 设置最小高度 */
    // one->setMinimumHeight(48);
    one->setDevName(devName);
    one->setExecTime(execTime);
    one->setWeekDay(week);

    /* 连接删除项信号，执行时间改变信号 */
    connect(one, &OneItem::signal_OneItemDelete, this, &TransmitterSwitch::do_deleteOneItem);
    connect(one, &OneItem::signal_devChanged, this, &TransmitterSwitch::do_changeDev);
    connect(one, &OneItem::signal_execTimeClicked, this, &TransmitterSwitch::do_editExecTime);

    /* 添加到容器中 */
    IData.addOneItem(week, one);
}

/* 添加一项特殊日计划 */
void TransmitterSwitch::addSpecialOneItem(int week, QString devName, QString action, QDate date, QTime execTime)
{
    OneItem* one = new OneItem(true);
    /* 添加可选的设备 */
    one->addDevice();
    /* 设置最小高度 */
    // one->setMinimumHeight(48);
    one->setDevName(devName);
    one->setDate(date);
    one->setExecTime(execTime);
    one->setWeekDay(week);

    /* 连接删除项信号，执行时间改变信号 */
    connect(one, &OneItem::signal_OneItemDelete, this, &TransmitterSwitch::do_deleteOneItem);
    connect(one, &OneItem::signal_devChanged, this, &TransmitterSwitch::do_changeDev);
    connect(one, &OneItem::signal_execTimeClicked, this, &TransmitterSwitch::do_editExecTime);
    connect(one, &OneItem::signal_dateClicked, this, &TransmitterSwitch::do_editExecDate);

    /* 添加到容器中 */
    IData.addOneItem(week, one);
}

/* 重新排序布局 */
void TransmitterSwitch::sortLayout(int weekDay)
{
    if(weekDay < 8 && weekDay >= 0)
    {
        sortItemData(weekDay);
    }
    /* 重新布局 */
    sortLayoutUI(weekDay);
}

/* 排序正常日 */
void TransmitterSwitch::sortItemData(int weekDay)
{
    /* 获取当前页容器 */
    auto list = IData.getOneDay(weekDay);
    // LH_WRITE_LOG_DEBUG(QString("获取到的容器大小:%1").arg(list->size()));
    if(list == nullptr)
    {
        return;
    }
    /* 将当前页，按时间升序排序 */
    std::sort(list->begin(), list->end(), [&](OneItem* t1, OneItem* t2) 
    {
        /* 按照日期排序，再按照名称排序 */
        if(t1->getDate() < t2->getDate())
        {
            return true;
        }
        else if(t1->getDate() > t2->getDate())
        {
            return false;
        }
        else
        {
            if(t1->getExecTime() < t2->getExecTime())
            {
                return true;
            }
            else if(t1->getExecTime() > t2->getExecTime())
            {
                return false;
            }else
            {
                return t1->getDevName() < t2->getDevName();
            }
        }
    });
    /* 设置序号 */
    int num1 = 1;
    for(auto& it : *list)
    {
        it->setNum(num1);
        num1++;
    }
}


/* 重新布局项 */
void TransmitterSwitch::sortLayoutUI(int weekDay)
{
    /* 获取数据列表和layout */
    auto listItem = IData.getOneDay(weekDay);
    if(listItem == nullptr)
    {
        return;
    }
    auto layout = m_vecLayouts[weekDay];
    /* 刷新UI，先清空layout中的所有控件，就是将item的父指针设置为0 */
    int num1 = 0;
    for(auto& it : *listItem)
    {
        it->setParent(nullptr);
    }
    /* 将item重新加入到layout中 */
    for(auto& it : *listItem)
    {
        layout->addWidget(it);
    }
}

/* 事件过滤器 */
bool TransmitterSwitch::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->label_Tip)
    {
        if(event->type() == QEvent::Enter)
        {
            m_tipText->show();
            return true;
        }else if(event->type() == QEvent::Leave)
        {
            m_tipText->hide();
        }
    }
    return QWidget::eventFilter(watched,event);
}

/* 鼠标点击事件 */
// void TransmitterSwitch::mousePressEvent(QMouseEvent *event)
// {
//     if(event->button() == Qt::LeftButton)
//     {
//         LH_WRITE_LOG("鼠标点击了");
//     }
//     QWidget::mousePressEvent(event);
// }