#include "mainwindow.h"
#include "ui_mainwindow.h"
#include<QDateTime>


QStringList configList;
login * login_password;
changePassword * change_password;
MyInputPanelContext *winpanel;


int closeTime = 1000000;



MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),

    ui(new Ui::MainWindow)
{
    winpanel = new MyInputPanelContext;

    //    winpanel->ui->panelButton_BS->setText("asdasdasd");

    setConfigDataEnable = TRUE;
//    qDebug()<<setConfigDataEnable;
    ui->setupUi(this);
    system("echo 7 > /sys/devices/soc0/backlight.9/backlight/backlight.9/brightness"); //调节屏幕背光
    QMapInit();
    socketClientInit();
    timedGetStatusTimer();
    limitInput();
    qDebug()<<StrToStr.key("HDSMF");
    closeWindowTimer();
    ui->conPara->installEventFilter(this);
    ui->backWaterAirHeight->installEventFilter(this);
    ui->backWaterLimitConfig->installEventFilter(this);
    ui->backWaterOffset->installEventFilter(this);
    ui->tailWaterAirHeight->installEventFilter(this);
    ui->tailWaterLimitConfig->installEventFilter(this);
    ui->tailWaterOffset->installEventFilter(this);
    ui->frontWaterAirHeight->installEventFilter(this);
    ui->frontWaterLimitConfig->installEventFilter(this);
    ui->frontWaterOffset->installEventFilter(this);
    ui->totalFlowConfig->installEventFilter(this);

    ui->centralWidget->setMouseTracking(true);
    setMouseTracking(true);
    ui->autoControlBtn_index->setMouseTracking(true);

    connect(qApp, SIGNAL(focusChanged(QWidget*,QWidget*)),
            this, SLOT(timerUpdate(QWidget*,QWidget*)));
    //    ui->label_3->adjustSize();
    ui->frontNilometerTypeConfig->raise();



    //    readConfigFile();
    configList << "gateWidth" <<  "gatewayId" <<"limitType" << "motorType" << "wingWall";


    timeStatus = new QTimer;
    connect(timeStatus, SIGNAL(timeout()), this, SLOT(timeStatusEvent()));
    timeStatus->start(1000);

    //    ui->lineEdit_2->setStyleSheet("border-image: url(:/new/image/battery.svg)");
}

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


void MainWindow::tcpSocketServerInit(int port, QString address)     //tcpsocket服务端初始化
{
    /**
      *:param int port: 监听的socket端口号     //int型
      *:param QString address: 监听的socket ip地址，默认任意ip     //QString型
      */

    QHostAddress useAddress = QHostAddress(address);   // 定义一个指定ip，备用
    server = new QTcpServer();   // 声明一个TcpServer对象
    server->listen(useAddress, port);  // 监听
    connect(server, SIGNAL(newConnection()), this, SLOT(acceptConnection())); //连接接收连接函数
}

void MainWindow::acceptConnection()     //接受socket client连接
{
    clientConnection = server->nextPendingConnection();
    connect(clientConnection, SIGNAL(readyRead()), this, SLOT(readClient())); // 连接读取函数
}

void MainWindow::serverRecvData()       //sokcet server接收数据
{
    serverMsg = clientConnection->readAll(); // 读取socket所有数据
}

void MainWindow::socketClientInit(QString address, int port)    //socket client 初始化
{
    /**
      *:param QString address: 连接socket server服务器的ip地址，默认 “127.0.0.1”     //QString型
      *:param int port: 连接socket server服务器的端口号，默认“6666”     //int型
      */

    sendClient = new QTcpSocket(this); // 实例化一个Qtcpsocket对象
    sendClient->connectToHost(QHostAddress(address), port); //连接socket
    while(!sendClient->waitForConnected(30000) == true)
    {
        if(!sendClient->waitForConnected(30000))   //连接超时时间
        {
            QMessageBox::critical(this,"error~", "socket error, please check the server");
            sendClient->connectToHost(QHostAddress(address), port);

        }
    }
    connect(sendClient, SIGNAL(readyRead()), this, SLOT(clientRecvData()));  // 接收数据的槽函数
    getStatusMsgOrder();
}

void MainWindow::socketClientInitDebug(QString address, int port)
{
    /**
      *:param QString address: 连接socket server服务器的ip地址，默认 “127.0.0.1”     //QString型
      *:param int port: 连接socket Debug server服务器的端口号，默认“6000”     //int型
      *:socket客户端初始化给调试页面
      */

    sendDebugClient = new QTcpSocket(this); // 实例化一个Qtcpsocket对象
    sendDebugClient->connectToHost(QHostAddress(address), port); //连接socket
    while(!sendDebugClient->waitForConnected(30000) == true)
    {
        if(!sendDebugClient->waitForConnected(30000))   //连接超时时间
        {
            QMessageBox::critical(this,"error~", "socket error, please check the Debug server");
            sendDebugClient->connectToHost(QHostAddress(address), port);

        }
    }
    connect(sendDebugClient, SIGNAL(readyRead()), this, SLOT(clientRecvDataDebug()));  // 接收数据的槽函数

}

void MainWindow::clientRecvDataDebug()
{
    clientDebugMsg = sendDebugClient->readAll();
    ui->logInformation->append(clientDebugMsg);
}

void MainWindow::sendInfo(QString sendDate)     // client发送数据
{
    /**
      *:param QString sendDate: 需要发送的数据，json数据     //QString型
      */

    sendClient->write((sendDate).toLatin1());   //socket发送数据
}

void MainWindow::clientRecvData()       // Client接收数据
{

    clientMsg = sendClient->readAll();  // 读取所有数据

    bool err_rpt;    //声明一个json数据错误标识
    QJson::Parser parser;
    QVariantMap jsonData = parser.parse(clientMsg.toLocal8Bit().data(), &err_rpt).toMap();
    if(jsonData["cmd"] == "read.req.status")
    {
        analysisStatusMsg(clientMsg);
    }
    else if(jsonData["cmd"] == "read.req.config" & setConfigDataEnable == TRUE)
    {
        setConfigData(clientMsg);
    }
    else
    {

    }


    //    ui->lineEdit->setText(clientMsg.toLocal8Bit());

}

void MainWindow::analysisStatusMsg(QString recvDate)    //解析socket server的json数据
{
    bool err_rpt;    //声明一个json数据错误标识
    QJson::Parser parser;
    QVariantMap clientRecvDocDate = parser.parse(recvDate.toLocal8Bit().data(), &err_rpt).toMap();
    //    qDebug()<<clientRecvDocDate["data"];
    QVariantMap list = clientRecvDocDate["data"].toMap();

    QJson::Serializer serializer;
    bool ok;
    QByteArray json = serializer.serialize(list, &ok);
    int a = json.size();
    //    qDebug()<<list;
    //    json.remove(0,1);//去除多余字符，获取json字符串
    //    json.remove(a-2,1);//去除多余字符，获取json字符串
    //    qDebug()<<json;
    QVariantMap clientRecvDoc = parser.parse(json, &err_rpt).toMap();
    //    QJsonDocument::fromJson(recvDate.toLocal8Bit().data(), &err_rpt);//字符串格式化为JSON

    //    if(!err_rpt) // 判断Json数据是否错误
    //    {
    //        qDebug() << "JSON格式错误";
    //        QMessageBox::information(this, "socket通讯", "Json数据错误");
    //    }

    //    else{

    //    }
    totalFlow = clientRecvDoc.value("totalFlow").toDouble();                //累计流量
//    encoderType = clientRecvDoc.value("encoderType").toString();                      //编码器型号
    motorType = clientRecvDoc.value("motorType").toString();                      //闸门电机控制器型号
    motorControlMode = clientRecvDoc.value("motorControlMode").toString(); // 电机控制方式
    //    encoderValueRatio = clientRecvDoc.value("encoderValueRatio").toDouble();                      //编码器每圈对应的闸门开度
    //    ratedSpeed = clientRecvDoc.value("ratedSpeed").toDouble();                      //闸门额定速度
    //    gateOpenValue = clientRecvDoc.value("gateOpenValue").toDouble();                      //闸门全开编码器值
    //    gateCloseValue = clientRecvDoc.value("gateCloseValue").toDouble();                      //闸门全关编码器值
    //    gateCorrectingStatus = clientRecvDoc.value("gateCorrectingStatus").toInt(); //闸门校准状态
    chargerType = clientRecvDoc.value("chargerType").toString();                      //充电控制器型号
    //    videoEnable = clientRecvDoc.value("videoEnable").toInt();                      //视屏功能使能
    //    monitorEnable = clientRecvDoc.value("monitorEnable").toInt(); ////人员入侵检测使能
    devName = clientRecvDoc.value("devName").toString();                      //设备名称
    devType = clientRecvDoc.value("devType").toString();                      //设备类型
    devSn = clientRecvDoc.value("devSn").toString().remove(0,14);                      //设备序列号
    hwVersion = clientRecvDoc.value("hwVersion").toString();                      //设备硬件版本
    swVersion = clientRecvDoc.value("swVersion").toString();                      //设备软件版本
    mfDay = clientRecvDoc.value("mfDay").toString();                      //设备生产日期
    otaService = clientRecvDoc.value("otaService").toString();                      //设备固件远程升级服务器地址
    bootTime = clientRecvDoc.value("bootTime").toString();                      //设备开机时间
    currentTime = clientRecvDoc.value("currentTime").toString();                      //设备当前时间
    configSyncTime = clientRecvDoc.value("configSyncTime").toString();                      //配置同步时间
    netIp = clientRecvDoc.value("netIp").toString();                      //设备IP
    netDns = clientRecvDoc.value("netDns").toString();                      //DNS服务器
    netType = clientRecvDoc.value("netType").toString();                      //网络类型
    dhcp = clientRecvDoc.value("dhcp").toString();                      //IP获取方式
    netMask = clientRecvDoc.value("netMask").toString();                      //子网掩码
    gwIp = clientRecvDoc.value("gwIp").toString();                      //网关IP
    ispServer = clientRecvDoc.value("ispServer").toString();                      //设备ISP服务商
    apnName = clientRecvDoc.value("apnName").toString();                      //设备APN
    imei = clientRecvDoc.value("imei").toString();                      //设备IMEI
    iccid = clientRecvDoc.value("iccid").toString();                      //设备ICCID
    controlMode = clientRecvDoc.value("controlMode").toInt();                      //闸门控制模式
    flowPara = clientRecvDoc.value("flowPara").toString();                      //流量率定参数
    configSync = clientRecvDoc.value("configSync").toInt();                      //设备配置同步寄存器
    dataSync = clientRecvDoc.value("dataSync").toInt();                      //设备数据同步寄存器
    reboot = clientRecvDoc.value("reboot").toInt();                      //设备复位寄存器
    powerOff = clientRecvDoc.value("powerOff").toInt();                      //设备关机寄存器
    factoryReset = clientRecvDoc.value("factoryReset").toInt();                      //设备恢复出厂寄存器
    localDebug = clientRecvDoc.value("localDebug").toInt();                      //设备本地调试寄存器
    remoteDebug = clientRecvDoc.value("remoteDebug").toInt();                      //设备远程调试寄存器
    otaLocal = clientRecvDoc.value("otaLocal").toInt();                      //设备本地升级寄存器
    devOnline = clientRecvDoc.value("devOnline").toInt();                      //设备在线状态
    devFault = clientRecvDoc.value("devFault").toInt();                      //设备故障状态
    devAlarm = clientRecvDoc.value("devAlarm").toInt();                      //设备报警状态
    netAccess = clientRecvDoc.value("netAccess").toInt();                      //网络访问状态
    encoderFault = clientRecvDoc.value("encoderFault").toInt();                      //编码器故障
    upLimit = clientRecvDoc.value("upLimit").toInt();                      //闸门上限位状态
    downLimit = clientRecvDoc.value("downLimit").toInt();                      //闸门下限位状态
    motorFault = clientRecvDoc.value("motorFault").toInt();                      //闸门电机故障状态
    //    gateSelfCheck = clientRecvDoc.value("gateSelfCheck").toInt();                      //闸门自检/状态
    remoteForbidden = clientRecvDoc.value("remoteForbidden").toInt();                      //远程禁止
    gateOpen = clientRecvDoc.value("gateOpen").toInt();                      //闸门开
    gateClose = clientRecvDoc.value("gateClose").toInt();                      //闸门关
    gateStop = clientRecvDoc.value("gateStop").toInt();                      //闸门停止
    gateFault = clientRecvDoc.value("gateFault").toInt();                      //闸门故障状态
    gateAction = clientRecvDoc.value("gateAction").toInt();                      //闸门动作状态
    gateAlarm = clientRecvDoc.value("gateAlarm").toInt();                      //闸门报警状态
    doorOpenAlarm = clientRecvDoc.value("doorOpenAlarm").toInt();                      //开箱报警状态
    movementAlarm = clientRecvDoc.value("movementAlarm").toInt();                      //人员入侵报警状态
    videoSync = clientRecvDoc.value("videoSync").toInt();                      //视屏同步寄存器
    videoFault = clientRecvDoc.value("videoFault").toInt();                      //摄像机故障
    frontNilometerEnable = clientRecvDoc.value("frontNilometerEnable").toInt();                      //闸前水位采集使能
    frontNilometerFault = clientRecvDoc.value("frontNilometerFault").toInt();                      //闸前水位计故障
    frontNilometerAlarm = clientRecvDoc.value("frontNilometerAlarm").toInt();                      //闸前水位超限报警
    backNilometerEnable = clientRecvDoc.value("backNilometerEnable").toInt();                      //闸后水位采集使能
    backNilometerFault = clientRecvDoc.value("backNilometerFault").toInt();                      //闸后水位计故障
    backNilometerAlarm = clientRecvDoc.value("backNilometerAlarm").toInt();                      //闸后水位超限报警
    tailNilometerEnable = clientRecvDoc.value("tailNilometerEnable").toInt();                      //下游水位采集使能
    chargerEnable = clientRecvDoc.value("chargerEnable").toInt();                      //太阳能应用使能
    chargeStatus = clientRecvDoc.value("chargeStatus").toInt();                      //充电状态
    chargerFault = clientRecvDoc.value("chargerFault").toInt();                      //充电控制器故障
    batLowAlarm = clientRecvDoc.value("batLowAlarm").toInt();                      //电量低报警
    flowEnable = clientRecvDoc.value("flowEnable").toInt();                      //流量率定使能
    flowStatus = clientRecvDoc.value("flowStatus").toInt();                      //流量率定状态
    iot_id = clientRecvDoc.value("iot-id").toDouble();                      //设备iot-id
    pollCycle = clientRecvDoc.value("pollCycle").toDouble();                      //采集周期
    reportCycle = clientRecvDoc.value("reportCycle").toDouble();                      //上报周期
    cpuUsage = clientRecvDoc.value("cpuUsage").toDouble();                      //CPU使用率
    ramUsage = clientRecvDoc.value("ramUsage").toDouble();                      //内存使用率
    temp = clientRecvDoc.value("temp").toString();                      //设备温度
    rssi = clientRecvDoc.value("rssi").toString();                      //设备信号强度
    controlStatus = clientRecvDoc.value("controlStatus").toInt();                      //闸门控制状态
    conFlow = clientRecvDoc.value("conFlow").toDouble();                      //恒定流量设定（暂不支持闸门水工建筑物以外其他方式）
    conFrontWater = clientRecvDoc.value("conFrontWater").toDouble();                      //恒定闸前水位设定
    conBackWater = clientRecvDoc.value("conBackWater").toDouble();                      //恒定闸后水位设定
    conTailWater = clientRecvDoc.value("conTailWater").toDouble();                      //恒定下游水位设定(暂不支持)
    encoderValue = clientRecvDoc.value("encoderValue").toDouble();                      //编码器值
    gateOpening = clientRecvDoc.value("gateOpening").toDouble();                      //闸门开度
    gatePercent = clientRecvDoc.value("gatePercent").toDouble();                      //闸门开度百分比
    //    frontWaterLimit = clientRecvDoc.value("frontWaterLimit").toDouble();                      //闸前水位高限
    frontWaterLevel = clientRecvDoc.value("frontWaterLevel").toDouble();                      //闸前水位
    //    backWaterLimit = clientRecvDoc.value("backWaterLimit").toDouble();                      //闸后水位高限
    backWaterLevel = clientRecvDoc.value("backWaterLevel").toDouble();                      //闸后水位
    //    tailWaterLimit = clientRecvDoc.value("tailWaterLimit").toDouble();                      //下游水位高限
    tailWaterLevel = clientRecvDoc.value("tailWaterLevel").toDouble();                      //下游水位
    tailNilometerFault = clientRecvDoc.value("tailNilometerFault").toDouble();                      //下游水位计故障
    tailNilometerAlarm = clientRecvDoc.value("tailNilometerAlarm").toDouble();                      //下游水位超限报警
    batLowLimit = clientRecvDoc.value("batLowLimit").toDouble();                      //电量低阈值
    batVolt = clientRecvDoc.value("batVolt").toString();                      //设备电池电压
    batEnergy = clientRecvDoc.value("batEnergy").toString();                      //设备电池电量
    flowSpeed = clientRecvDoc.value("flowSpeed").toDouble();                      //瞬时流速
    flowRate = clientRecvDoc.value("flowRate").toDouble();                      //瞬时流量
    runTime = clientRecvDoc.value("runTime").toDouble();                            //运行时间
    gateClamping = clientRecvDoc.value("gateClamping").toInt();                 //闸门卡滞
    motorConnectFault = clientRecvDoc.value("motorConnectFault").toInt(); //电机通讯故障
    encoderConnectFault = clientRecvDoc.value("encoderConnectFault").toInt(); //编码器通讯故障
    chargerConnectFault = clientRecvDoc.value("chargerConnectFault").toInt(); // 充电器通讯故障
    conPara = clientRecvDoc.value("conPara").toDouble();


    qDebug()<<encoderType;

    setStatusData();
    channelFunctionGroup(); //映射数据


    //    QJsonObject clientRecvObj = clientRecvDoc.object(); //实例化一个json工程，数据是格式化的json
    //    qDebug()<<root_Doc<<endl;

    //    QStringList keyStr = (clientRecvDoc.keys());       //获取json数据所有的key
    //    int keyLength = keyStr.length();       //获取key的长度
    //    QList <QLineEdit*> QLineEdits = findChildren<QLineEdit *>();    //获取所有的QLineEdit控件
    //    QList <QLineEdit*>::size_type qlineEditSize = QLineEdits.size();    //获取控件的数量
    //    for(int keyIndex = 0; keyIndex < keyLength; keyIndex++)     //遍历控件
    //    {
    //        for(int qlineEditIndex = 0; qlineEditIndex < qlineEditSize; qlineEditIndex++) //遍历json key
    //            if(keyStr[keyIndex] == QLineEdits.at(qlineEditIndex)->objectName()){    //判断json key 是否和控件名相同
    //                QString setDate = clientRecvDoc.value(keyStr[keyIndex]).toString();
    //                QLineEdits.at(qlineEditIndex)->setText(setDate);

    //                if(clientRecvDoc.value(keyStr[keyIndex]).isDouble())    // 因为控件对数字的设置没有标准方法特殊处理
    //                {
    //                    // 处理数字，以方便设置到控件上展示
    //                    double setnum = clientRecvObj.value(keyStr[keyIndex]).toDouble();
    //                    QString setnumm;
    //                    setnumm.setNum(setnum);
    //                    QLineEdits.at(qlineEditIndex)->setText(setnumm);
    //                }
    //                else
    //                {
    //                    //字符串类型的展示
    //                    QString setDate = clientRecvObj.value(keyStr[keyIndex]).toString();
    //                    QLineEdits.at(qlineEditIndex)->setText(setDate);
    //                }
    //            }
    //    }
}

QString MainWindow::getConfigArg()      // 获取控件参数值
{
    //    bool flag=false;    //判断是否是数值型的标识位
    //    QVariantMap  configDate;     //声明一个json对象


    //    QList <QLineEdit*> QLineEdits = findChildren<QLineEdit *>();       //获取所有的QLineEdit控件
    //    QList <QLineEdit*>::size_type qlineEditSize = QLineEdits.size();        //获取控件的数量
    //    for(int item=0; item < qlineEditSize; item++)
    //    {
    //        if(configList.indexOf(QLineEdits.value(item)->objectName()) == -1)
    //        {
    //            //判断参数控件是否在列表中，如果没在，什么都不做
    //            // 如果在就添加到json数据里
    //        }
    //        else
    //        {
    //            QString configDateKey = QLineEdits.value(item)->objectName();       //获取控件名作为json的key
    //            QString configDateValue = QLineEdits.value(item)->text();       //获取控件的值作为json的value

    //            //        QByteArray ba = configDateValue.toLatin1();//QString 转换为 char*
    //            //        const char *s = ba.data();
    //            //        while(*s && *s>='0' && *s<='9') s++;
    //            //        if (*s)

    //            double flagNum = configDateValue.toDouble(&flag);  //做是否是纯数值的判断
    //            //因为QLineEdit的控件值均为字符串，但是根据要求纯数值为double型，所有做特殊处理
    //            if(!flagNum)
    //            { //纯数字
    //                //做特殊处理
    //                configDate.insert(configDateKey,configDateValue);       //插入到json对象中
    //            }
    //            else
    //            { //不是纯数字
    //                //不做特殊处理
    //                double configDateValueNum = configDateValue.toInt();     //纯数值字符串转换为double
    //                configDate.insert(configDateKey,configDateValueNum);    //插入到json对象中
    //                //            qDebug()<<configDateValue;
    //            }
    //            //        qDebug()<<configDate;
    //        }
    //    }
    //    QJson::Serializer serializer;
    //    QByteArray config_str = serializer.serialize(configDate);
    //    //    QJsonDocument configDoc; //声明json文档
    //    //    configDoc.parse(configDate.toStdMap());
    //    //    QByteArray config_str = configDoc.toJson(QJsonDocument::Compact);  //紧凑格式
    //    //    //    QByteArray config_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
    //    QString strJson(config_str);     //转换为json字符串
    //    return strJson;         //返回json字符串以供发送


    //    encoderValueRatio_configFile = ui->encoderValueRatio->text().toDouble();
    //    ratedSpeed_configFile = ui->ratedSpeed->text().toDouble();
    //    gateOpenValue_configFile = ui->gateOpenValue->text().toDouble();
    //    gateCloseValue_configFile = ui->gateCloseValue->text().toDouble();
    //    frontNilometerAirHight_configFile = ui->frontNilometerAirHight->text().toDouble();
    //    backNilometerAirHight_configFile = ui->backNilometerAirHight->text().toDouble();
    //    tailNilometerAirHight_configFile = ui->tailNilometerAirHight->text().toDouble();

    //    gateSelfCheck_configFile = ui->gateSelfCheck->text().toInt();
    dropStep_getConfig = StrToInt[ui->dropStep->currentText()];
    gateWidth_getConfig = ui->gateWidth->text().toDouble();
    wingWall_getConfig = StrToInt[ui->wingWall->currentText()];
    backWaterAirHeight_getConfig = ui->backWaterAirHeight->text().toDouble();
    backWaterOffset_getConfig = ui->backWaterOffset->text().toDouble();
    tailWaterAirHeight_getConfig = ui->tailWaterAirHeight->text().toDouble();
    tailWaterOffset_getConfig = ui->tailWaterOffset->text().toDouble();
    frontWaterAirHeight_getConfig = ui->frontWaterAirHeight->text().toDouble();
    frontWaterOffset_getConfig = ui->frontWaterOffset->text().toDouble();
    frontNilometerType_getConfig = ui->frontNilometerTypeConfig->currentText();
    backNilometerType_getConfig = ui->backNilometerTypeConfig->currentText();
    tailNilometerType_getConfig = ui->tailNilometerTypeConfig->currentText();
    totalFlow_getConfig = ui->totalFlowConfig->text().toDouble();
    frontWaterLimit_getConfig = ui->frontWaterLimitConfig->text().toDouble();
    backWaterLimit_getConfig = ui->backWaterLimitConfig->text().toDouble();
    tailWaterLimit_getConfig = ui->tailWaterLimitConfig->text().toDouble();

    QJson::Serializer serializer;
    serializer.setIndentMode(QJson::IndentFull);

    QVariantMap configDateSend;
    QVariantMap  configDate;     //声明一个json对象
    configDate.insert("dropStep",dropStep_getConfig);
    configDate.insert("gateWidth",gateWidth_getConfig);
    configDate.insert("wingWall",wingWall_getConfig);
    configDate.insert("backWaterAirHeight",backWaterAirHeight_getConfig);
    configDate.insert("backWaterOffset",backWaterOffset_getConfig);
    configDate.insert("tailWaterAirHeight",tailWaterAirHeight_getConfig);
    configDate.insert("tailWaterOffset",tailWaterOffset_getConfig);
    configDate.insert("frontWaterAirHeight",frontWaterAirHeight_getConfig);
    configDate.insert("frontWaterOffset",frontWaterOffset_getConfig);
    configDate.insert("frontNilometerType",frontNilometerType_getConfig);
    configDate.insert("backNilometerType",backNilometerType_getConfig);
    configDate.insert("tailNilometerType",tailNilometerType_getConfig);

    if(ui->totalFlowConfig->text() != "")
    {
        configDate.insert("totalFlow",totalFlow_getConfig);
    }
    else
    {

    }

    configDate.insert("frontWaterLimit",frontWaterLimit_getConfig);
    configDate.insert("backWaterLimit",backWaterLimit_getConfig);
    configDate.insert("tailWaterLimit",tailWaterLimit_getConfig);


    configDateSend.insert("cmd","write.req.cfg.save");
    configDateSend.insert("date",configDate);

    //    configDate.insert("ratedSpeed",ratedSpeed_configFile);
    //    configDate.insert("encoderValueRatio",encoderValueRatio_configFile);
    //    configDate.insert("gateOpenValue",gateOpenValue_configFile);
    //    configDate.insert("gateCloseValue",gateCloseValue_configFile);
    //    configDate.insert("gateSelfCheck",gateSelfCheck_configFile);
    //    configDate.insert("encoderType",encoderType_configFile);
    //    configDate.insert("motorType",motorType_configFile);
    //    configDate.insert("frontNilometerEnable",frontNilometerAirHight_configFile);
    //    configDate.insert("backNilometerEnable",backNilometerAirHight_configFile);
    //    configDate.insert("tailNilometerEnable",tailNilometerAirHight_configFile);
    //    configDate.insert("monitorEnable",monitorEnable_configFile);
    //    configDate.insert("videoEnable",videoEnable_configFile);
    //    configDate.insert("chargerType",chargerType_configFile);
    //    configDate.insert("frontNilometerType",frontNilometerType_configFile);
    //    configDate.insert("backNilometerType",backNilometerType_configFile);
    //    configDate.insert("tailNilometerType",tailNilometerType_configFile);
    //    configDate.insert("flowMode",flowMode_configFile);
    //    configDate.insert("gateWidth",gateWidth_configFile);
    //    configDate.insert("dropStep",dropStep_configFile);
    //    configDate.insert("wingWall",wingWall_configFile);



    //    qDebug()<<configDate;

    bool ok;
    QByteArray json = serializer.serialize(configDateSend,&ok);

    //    QFile file("/arm_show/arm_show/config/config");
    //    file.open( QIODevice::WriteOnly);
    ////    QTextStream out(&file);
    ////    out << json;
    ////    out << "\n";
    //    file.write(json);
    //    file.close();
    sendInfo(json);
        qDebug()<<json;
    //qDebug()<<StrToInt[ui->monitorEnableConfig->currentText()];
}

void MainWindow::QMapInit()
{
    StrToInt.insert(QString::fromUtf8("使能"), 0);
    StrToInt.insert(QString::fromUtf8("未使能"), 1);
    StrToInt.insert(QString::fromUtf8("已校准"), 0);
    StrToInt.insert(QString::fromUtf8("未校准"), 1);
    StrToInt.insert(QString::fromUtf8("有"), 0);
    StrToInt.insert(QString::fromUtf8("无" ), 1);
    StrToInt.insert(QString::fromUtf8("弯曲墙面" ), 1);
    StrToInt.insert(QString::fromUtf8("平整墙面" ), 2);
    StrToInt.insert(QString::fromUtf8("八字墙面" ), 3);
    StrToInt.insert(QString::fromUtf8("平行墙面" ), 4);
    StrToInt.insert(QString::fromUtf8("空闲模式" ),1);
    StrToInt.insert(QString::fromUtf8("恒定开度模式" ),2);
    StrToInt.insert(QString::fromUtf8("恒定流量模式" ),3);
    StrToInt.insert(QString::fromUtf8("恒定闸前水位模式" ),4);
    StrToInt.insert(QString::fromUtf8("恒定闸后水位模式" ),5);

    int i =StrToInt.value("有");

    StrToStr.insert(QString::fromUtf8("闸门水工建筑物测流"),"HDSMF");
    IntToStr_Fault.insert(1,QString::fromUtf8("闸门电机故障"));
    IntToStr_Fault.insert(2,QString::fromUtf8("编码器故障"));
    IntToStr_Fault.insert(4,QString::fromUtf8("闸前水位计故障"));
    IntToStr_Fault.insert(8,QString::fromUtf8("闸后水位计故障"));
    IntToStr_Fault.insert(16,QString::fromUtf8("下游水位计故障"));
    IntToStr_Fault.insert(32,QString::fromUtf8("闸门卡滞故障"));
    IntToStr_Fault.insert(64,QString::fromUtf8("充电控制器故障"));
    IntToStr_Fault.insert(128,QString::fromUtf8("视频故障"));
    IntToStr_Fault.insert(0x80000000,QString::fromUtf8("MQTT断开故障"));

    IntToStr_Alarm.insert(1,QString::fromUtf8("闸前水位计报警"));
    IntToStr_Alarm.insert(2,QString::fromUtf8("闸后水位计报警"));
    IntToStr_Alarm.insert(4,QString::fromUtf8("下游水位计报警"));
    IntToStr_Alarm.insert(8,QString::fromUtf8("电池电量过低报警"));
    IntToStr_Alarm.insert(16,QString::fromUtf8("闸门未校准报警"));
    IntToStr_Alarm.insert(32,QString::fromUtf8("编码器报警"));
    IntToStr_Alarm.insert(64,QString::fromUtf8("开门报警"));
    IntToStr_Alarm.insert(128,QString::fromUtf8("运动报警"));
    IntToStr_Alarm.insert(0x40000000,QString::fromUtf8("配置未同步报警"));
    IntToStr_Alarm.insert(0x80000000,QString::fromUtf8("ID丢失报警"));

    //    qDebug()<< IntToStr.key(QString::fromUtf8("配置未同步报警"));

    //    qDebug()<<i;
}

void MainWindow::readConfigFile()
{
    bool err_rpt;    //声明一个json数据错误标识
    QFile file("/arm_show/arm_show/config/config");
    file.open(QIODevice::ReadOnly);
    QString fd = file.readAll();
    QJson::Parser parser;
    QVariantMap configFile  = parser.parse(fd.toLocal8Bit().data(), &err_rpt).toMap();
    QVariantList list = configFile["devices"].toList();

    QJson::Serializer serializer;
    bool ok;
    QByteArray json = serializer.serialize(list, &ok);
    int a = json.size();
    //    qDebug()<<a;
    json.remove(0,1);//去除多余字符，获取json字符串
    json.remove(a-2,1);//去除多余字符，获取json字符串
    //    qDebug()<<json;
    QVariantMap clientRecvDocData = parser.parse(json, &err_rpt).toMap();


    //    encoderType = clientRecvDocData.value("encoderType").toString();                      //编码器型号
    //    motorType = clientRecvDocData.value("motorType").toString();                      //闸门电机控制器型号
    //    motorControlMode = clientRecvDocData.value("motorControlMode").toString(); // 电机控制方式
    //    encoderValueRatio = clientRecvDocData.value("encoderValueRatio").toDouble();                      //编码器每圈对应的闸门开度
    //    ratedSpeed = clientRecvDocData.value("ratedSpeed").toDouble();                      //闸门额定速度
    //    gateOpenValue = clientRecvDocData.value("gateOpenValue").toDouble();                      //闸门全开编码器值
    //    gateCloseValue = clientRecvDocData.value("gateCloseValue").toDouble();                      //闸门全关编码器值
    //    gateCorrectingStatus = clientRecvDocData.value("gateCorrectingStatus").toInt(); //闸门校准状态
    //    frontNilometerType = clientRecvDocData.value("frontNilometerType").toString();                      //闸前水位计型号
    //    backNilometerType = clientRecvDocData.value("backNilometerType").toString();                      //闸后水位计型号
    //    tailNilometerType = clientRecvDocData.value("tailNilometerType").toString();                      //下游水位计型号
    //    chargerType = clientRecvDocData.value("chargerType").toString();                      //充电控制器型号
    //    flowMode = clientRecvDocData.value("flowMode").toString();                      //流量率定模型
    //    videoEnable = clientRecvDocData.value("videoEnable").toInt();                      //视屏功能使能
    //    frontNilometerAirHight = clientRecvDocData.value("frontNilometerAirHight").toDouble(); //闸前水位计空高
    //    backNilometerAirHight = clientRecvDocData.value("backNilometerAirHight").toDouble();    //闸后水位计空高
    //    tailNilometerAirHight = clientRecvDocData.value("tailNilometerAirHight").toDouble();        //下游水位计空高
    //    gateWidth = clientRecvDocData.value("gateWidth").toDouble();    //闸门宽度
    //    wingWall = clientRecvDocData.value("wingWall").toString();  //翼墙类型
    //    dropStep = clientRecvDocData.value("dropStep").toInt();   //有无跌坎开
    //    monitorEnable = clientRecvDocData.value("dropStep").toInt(); ////人员入侵检测使能



    //    on_encoderTypeConfig_textChanged("Ture");
    //    on_motorControlModeConfig_textChanged("Ture");
    //    on_encoderValueRatio_textChanged("Ture");
    //    on_ratedSpeed_textChanged("Ture");
    //    on_gateOpenValue_textChanged("Ture");
    //    on_gateCloseValue_textChanged("Ture");
    //    on_gateSelfCheck_textChanged("Ture");
    //    on_frontNilometerTypeConfig_textChanged("Ture");
    //    on_backNilometerTypeConfig_textChanged("Ture");
    //    on_tailNilometerTypeConfig_textChanged("Ture");
    //    on_chargerTypeConfig_textChanged("Ture");
    //    on_flowModeConfig_2_textChanged("Ture");
    //    on_videoEnableConfig_textChanged("Ture");
    //    on_monitorEnableConfig_textChanged("Ture");
    //    on_frontNilometerAirHight_textChanged("Ture");
    //    on_backNilometerAirHight_textChanged("Ture");
    //    on_tailNilometerAirHight_textChanged("Ture");
    //    on_gateWidth_textChanged("Ture");
    //    on_wingWall_textChanged("Ture");
    //    on_dropStep_textChanged("Ture");
    //    on_totalFlowConfig_textChanged("Ture");


    //    qDebug()<<clientRecvDocData;
    file.close();

}

void MainWindow::getStatusMsgOrder()
{
    QString str = "{"
            "\"cmd\":\"read.req.status\""
            "\}";
    sendInfo(str);

}

void MainWindow::setConfigData(QString recvDate)
{

    bool err_rpt;    //声明一个json数据错误标识
    QJson::Parser parser;
    QVariantMap clientConfigDocDate = parser.parse(recvDate.toLocal8Bit().data(), &err_rpt).toMap();

    QVariantMap list = clientConfigDocDate["data"].toMap();

    QJson::Serializer serializer;
    bool ok;
    QByteArray json = serializer.serialize(list, &ok);
    int a = json.size();
    //    qDebug()<<list;
    //    json.remove(0,1);//去除多余字符，获取json字符串
    //    json.remove(a-2,1);//去除多余字符，获取json字符串
    //    qDebug()<<json;
    QVariantMap clientConfigDoc = parser.parse(json, &err_rpt).toMap();

    //    totalFlow = clientConfigDoc.value("totalFlow").toDouble();                      //累计流量
    encoderType = clientConfigDoc.value("encoderType").toString();                      //编码器型号
    dropStep = clientConfigDoc.value("dropStep").toInt();   //有无跌坎开
    flowMode = clientConfigDoc.value("flowMode").toString();                      //流量率定模型
    wingWall = clientConfigDoc.value("wingWall").toInt();  //翼墙类型
    gateWidth = clientConfigDoc.value("gateWidth").toDouble();    //闸门宽度
    backWaterOffset = clientConfigDoc.value("backWaterOffset").toDouble();
    tailWaterOffset = clientConfigDoc.value("tailWaterOffset").toDouble();
    frontWaterOffset = clientConfigDoc.value("frontWaterOffset").toDouble();
    frontNilometerType = clientConfigDoc.value("frontNilometerType").toString();                      //闸前水位计型号
    backNilometerType = clientConfigDoc.value("backNilometerType").toString();                      //闸后水位计型号
    tailNilometerType = clientConfigDoc.value("tailNilometerType").toString();                      //下游水位计型号
    frontWaterAirHeight = clientConfigDoc.value("frontWaterAirHeight").toDouble(); //闸前水位计空高
    backWaterAirHeight = clientConfigDoc.value("backWaterAirHeight").toDouble();    //闸后水位计空高
    tailWaterAirHeight = clientConfigDoc.value("tailWaterAirHeight").toDouble();        //下游水位计空高
    encoderValueRatio = clientConfigDoc.value("encoderValueRatio").toDouble();                      //编码器每圈对应的闸门开度
    ratedSpeed = clientConfigDoc.value("ratedSpeed").toDouble();                      //闸门额定速度
    gateOpenValue = clientConfigDoc.value("gateOpenValue").toDouble();                      //闸门全开编码器值
    gateCloseValue = clientConfigDoc.value("gateCloseValue").toDouble();                      //闸门全关编码器值
    gateSelfCheck = clientConfigDoc.value("gateSelfCheck").toInt();                      //闸门自检/状态
    videoEnable = clientConfigDoc.value("videoEnable").toInt();                      //视屏功能使能
    monitorEnable = clientConfigDoc.value("monitorEnable").toInt(); ////人员入侵检测使能
    frontWaterLimit = clientConfigDoc.value("frontWaterLimit").toDouble();                      //闸前水位高限
    tailWaterLimit = clientConfigDoc.value("tailWaterLimit").toDouble();                      //下游水位高限
    backWaterLimit = clientConfigDoc.value("backWaterLimit").toDouble();                      //闸后水位高限


    //    QString totalFlowConfig_str = QString::number(totalFlow,'f',4);
    //    ui->totalFlowConfig->setText(totalFlowConfig_str);

    if(dropStep == 1)
    {
        ui->dropStep->setCurrentIndex(0);  // 有跌坎
    }
    else if(dropStep == 0)
    {
        ui->dropStep->setCurrentIndex(1); //无跌坎
    }

    ui->flowModeConfig->setText(StrToStr.key(flowMode));
    ui->flowModeStatus->setText(StrToStr.key(flowMode));

    ui->wingWall->setCurrentIndex(wingWall);

    ui->encoderType->setText(encoderType);

     ui->encoderTypeConfig->setText(encoderType);

     ui->frontNilometerType->setText(frontNilometerType);

     ui->backNilometerType->setText(backNilometerType);

     ui->tailNilometerType->setText(tailNilometerType);

    QString gateWidth_str = QString::number(gateWidth,'f',4);
    ui->gateWidth->setText(gateWidth_str);

    QString backWaterOffset_str = QString::number(backWaterOffset,'f',4);
    ui->backWaterOffset->setText(backWaterOffset_str);

    QString tailWaterOffset_str = QString::number(tailWaterOffset,'f',4);
    ui->tailWaterOffset->setText(tailWaterOffset_str);

    QString frontWaterOffset_str = QString::number(frontWaterOffset,'f',4);
    ui->frontWaterOffset->setText(frontWaterOffset_str);

    ui->backNilometerTypeConfig->setItemText(0,backNilometerType);

    ui->tailNilometerTypeConfig->setItemText(0,tailNilometerType);

    ui->frontNilometerTypeConfig->setItemText(0,tailNilometerType);

    QString frontWaterAirHeight_str = QString::number(frontWaterAirHeight,'f',4);
    ui->frontWaterAirHeight->setText(frontWaterAirHeight_str);

    QString backWaterAirHeight_str = QString::number(backWaterAirHeight,'f',4);
    ui->backWaterAirHeight->setText(backWaterAirHeight_str);

    QString tailWaterAirHeight_str = QString::number(tailWaterAirHeight,'f',4);
    ui->tailWaterAirHeight->setText(tailWaterAirHeight_str);

    QString unitmm = QString::fromUtf8(" 毫米");
    QString encoderValueRatio_str = QString::number(encoderValueRatio,'f',4)+unitmm;
    ui->encoderValueRatio->setText(encoderValueRatio_str);

    QString ratedSpeed_str = QString::number(ratedSpeed,'f',4);
    ui->ratedSpeed->setText(ratedSpeed_str);

    QString gateCloseValue_str = QString::number(gateCloseValue,'f',4);
    ui->gateCloseValue->setText(gateCloseValue_str);

    QString gateOpenValue_str = QString::number(gateOpenValue,'f',4);
    ui->gateOpenValue->setText(gateOpenValue_str);

    QString frontWaterLimit_str = QString::number(frontWaterLimit,'f',4);
    ui->frontWaterLimitConfig->setText(frontWaterLimit_str);

    QString backWaterLimit_str = QString::number(backWaterLimit,'f',4);
    ui->backWaterLimitConfig->setText(backWaterLimit_str);

    QString tailWaterLimit_str = QString::number(tailWaterLimit,'f',4);
    ui->tailWaterLimitConfig->setText(tailWaterLimit_str);


    if(gateSelfCheck == 0)
    {
        ui->gateSelfCheck->setText(QString::fromUtf8("未校准"));
        ui->gateCorrectingStatus->setText(QString::fromUtf8("未校准"));
    }
    else if(gateSelfCheck == 1)
    {
        ui->gateSelfCheck->setText(QString::fromUtf8("已校准"));
        ui->gateCorrectingStatus->setText(QString::fromUtf8("已校准"));
    }

    if(videoEnable == 0)
    {
        ui->videoEnable->setText(QString::fromUtf8("未使能"));
    }
    else if(videoEnable == 1)
    {
        ui->videoEnable->setText(QString::fromUtf8("使能"));
    }

    if(monitorEnable == 0)
    {
        ui->monitorEnable->setText(QString::fromUtf8("未使能"));
    }
    else if(monitorEnable == 1)
    {
        ui->monitorEnable->setText(QString::fromUtf8("使能"));
    }
}

void MainWindow::setStatusData()
{
    setAlarmMsg();

    setFaultMsg();

    setOnlineIcon();

    setBatteryIcon();

    setRssiIcon();

    setImeiIccid();
    ui->devType->setText(devType);

    if(remoteForbidden == 1)
    {
        ui->remoteForbidden_data->setText(QString::fromUtf8("本地"));
    }
    if(remoteForbidden == 0)
    {
        ui->remoteForbidden_data->setText(QString::fromUtf8("远程"));
    }

    if(configSync == 1)
    {
        ui->configSync->setText(QString::fromUtf8("已同步"));
    }
    if(configSync == 0)
    {
        ui->configSync->setText(QString::fromUtf8("未同步"));
    }


}
void MainWindow::timedGetStatusTimer()
{
    statusTimer = new QTimer();
    connect(statusTimer, SIGNAL(timeout()), this, SLOT(sendMsgGroup()));
    statusTimer->start(1000);
}

void MainWindow::getConfigMsgOrder()
{
    QString str = "{"
            "\"cmd\":\"read.req.config\""
            "\}";
    //    qDebug()<<str;
    sendInfo(str);
}

void MainWindow::limitInput()
{
    QRegExp rx("^(-?[0]|-?[1-9][0-9]{0,5})(?:\\.\\d{1,3})?$|(^\\t?$)");
    ui->frontWaterAirHeight->setValidator(new  QRegExpValidator(rx, ui->frontWaterAirHeight));
    ui->tailWaterAirHeight->setValidator(new  QRegExpValidator(rx, ui->tailWaterAirHeight));
    ui->backWaterAirHeight->setValidator(new  QRegExpValidator(rx, ui->backWaterAirHeight));
    ui->frontWaterLimitConfig->setValidator(new  QRegExpValidator(rx, ui->frontWaterLimitConfig));
    ui->tailWaterLimitConfig->setValidator(new  QRegExpValidator(rx, ui->tailWaterLimitConfig));
    ui->backWaterLimitConfig->setValidator(new  QRegExpValidator(rx, ui->backWaterLimitConfig));
    ui->frontWaterOffset->setValidator(new  QRegExpValidator(rx, ui->frontWaterOffset));
    ui->tailWaterOffset->setValidator(new  QRegExpValidator(rx, ui->tailWaterOffset));
    ui->backWaterOffset->setValidator(new  QRegExpValidator(rx, ui->backWaterOffset));
    ui->totalFlowConfig->setValidator(new QRegExpValidator(rx,ui->totalFlowConfig));
    ui->conPara->setValidator(new QRegExpValidator(rx,ui->conPara));

}

void MainWindow::Delay_MSec(unsigned int msec)
{

    QTime _Timer = QTime::currentTime().addMSecs(msec);

    while( QTime::currentTime() < _Timer )

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

}

void MainWindow::setAlarmMsg()
{
    if(devAlarm == 0)
    {
        ui->alarm_indexBtn->hide();
    }
    else
    {
        ui->alarm_indexBtn->show();
    }

    ui->devAlarm_Browser->clear();

    int alarm_list[10] = {1,2,4,8,16,32,64,128,0x80000000};
    for(int i = 0;i <9;i++)
    {
        if(devAlarm & alarm_list[i])
        {
            ui->devAlarm_Browser->append(IntToStr_Alarm[alarm_list[i]]);
//            qDebug()<<IntToStr_Alarm[alarm_list[i]];
//            qDebug()<<alarm_list[i];
        }

    }
}

void MainWindow::setFaultMsg()
{
    if(devFault == 0)
    {
        ui->fault_indexBtn->hide();
    }
    else
    {
        ui->fault_indexBtn->show();
    }

    ui->devFault_Browser->clear();

    int fault_list[10] = {1,2,4,8,16,32,64,128,0x40000000,0x80000000};
    for(int i = 0;i <9;i++)
    {
        if(devFault & fault_list[i])
        {
            ui->devFault_Browser->append(IntToStr_Fault[fault_list[i]]);
//            qDebug()<<IntToStr_Fault[fault_list[i]];
        }

    }
}

void MainWindow::setOnlineIcon()
{
    if(devOnline == 1)
    {
        ui->OnlineIcon->setStyleSheet("border-image: url(:/icon_date/link/group1.png)");
    }
    else
    {
        ui->OnlineIcon->setStyleSheet("border-image: url(:/icon_date/link/group1.png)");
    }
}

void MainWindow::setRssiIcon()
{
    /* rssi 0-20;
     * 20-40
     * 40-60
     * 60-80
     *80-100
     */

    int rssi_int  = rssi.toInt();
    if(0 < rssi_int & rssi_int<= 20)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group1.png);");
    }
    else if(21 < rssi_int& rssi_int <= 40)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group2.png);");
    }
    else if(41 < rssi_int & rssi_int<= 60)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group3.png);");
    }
    else if(61 < rssi_int & rssi_int<= 80)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group4.png);");
    }
    else if(81 < rssi_int & rssi_int<= 100)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group5.png);");
    }
    else if(rssi_int == 0)
    {
        ui->RssiIcon->setStyleSheet("border-image: url(:/icon_date/signal/group0.png);");
    }
}

void MainWindow::setBatteryIcon()
{
    /*  batEnergy 0-20;
             * 20-40
             * 40-60
             * 60-80
             *80-100
             */
    int bat = batEnergy.toInt();
    //    qDebug()<<batEnergy;
    //    qDebug()<<bat;
    if(0 < bat & bat<= 17)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group1.png);");
    }
    else if(18 < bat& bat <= 34)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group2.png);");
    }
    else if(35 < bat & bat<= 51)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group3.png);");
    }
    else if(52 < bat & bat<= 68)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group4.png);");
    }
    else if(69 < bat & bat<= 85)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group5.png);");
    }
    else if(86 < bat & bat <=100)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group6.png);");
    }
    else if(bat == 0)
    {
        ui->BatteryIcon->setStyleSheet("border-image: url(:/icon_date/battery/group0.png);");
    }
}

void MainWindow::mousePressEvent(QMouseEvent *e)
{
    //    qDebug()<<"b";
    Q_UNUSED(e);
    closeTimer->stop();

}

void MainWindow::mouseReleaseEvent(QMouseEvent *e)
{
    //    qDebug()<<"e";
    Q_UNUSED(e);
    closeTimer->start(closeTime);

}


void MainWindow::closeWindowTimer()
{
    closeTimer = new QTimer;
    connect(closeTimer,SIGNAL(timeout()),this,SLOT(close()));
    closeTimer->start(closeTime);
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    system("echo 0 > /sys/devices/soc0/backlight.9/backlight/backlight.9/brightness");//调节屏幕背光
//    qDebug()<<"close windows";
    event->accept();
}

void MainWindow::setImeiIccid()
{
    if(imei == "")
    {
        ui->imei->hide();
        ui->label_imei->hide();
    }
    else if(imei !="")
    {
        ui->imei->show();
        ui->label_imei->show();
        ui->imei->setText(imei);
    }

    if(iccid == "")
    {
        ui->iccid->hide();
        ui->label_iccid->hide();
    }
    else if(iccid !="")
    {
        ui->iccid->show();
        ui->label_iccid->show();
        ui->iccid->setText(iccid);
    }
}





void MainWindow::closeWindow()
{
//    qDebug()<<"closeWindow!!!";
    //    ~MainWindow();


}

void MainWindow::data_password()
{
    QFile file_read("/root/wisfarm/config/qt_passwd");
    file_read.open(QIODevice::ReadOnly);
    QString fd = file_read.readAll();
    fd = fd.trimmed();
    file_read.close();
    bool ok;
    bool ok1;
    QString original_Password = login_password->ui->input_password->text();
    ui->parmConfigBtn_index->setEnabled(true);
    if (login_password->ui->input_password->text().isEmpty())
    {
        login_password->close();
        QMessageBox::critical(this,"error~", QString::fromUtf8("密码不能为空！"));

    }
    else if(login_password->ui->input_password->text() != "")
    {
        if(original_Password == fd)
        {
              login_password->close();
            ui->stackedWidget->setCurrentWidget(ui->parm_index);
            setConfigDataEnable == FALSE;

        }
        else
        {
             login_password->close();
            QMessageBox::critical(this,"error~", QString::fromUtf8("密码错误！"));

        }
    }


}

void MainWindow::login_passwordClose()
{
    login_password->close();
    ui->parmConfigBtn_index->setEnabled(true);

}

void MainWindow::change_passwd()
{
    QString inputData = change_password->ui->input_passwd->text();
    QString affirmData = change_password->ui->affirm_passwd->text();

    if(inputData == affirmData)
    {
        QFile file_write("/root/wisfarm/config/qt_passwd");
        file_write.open(QIODevice::WriteOnly);
        if(affirmData.length() >= 6)
        {
            file_write.write(affirmData.toUtf8());
            file_write.close();
            QMessageBox::information(this,"error~", QString::fromUtf8("密码修改成功"));
            change_password->close();
        }
        else
        {
            QMessageBox::critical(this,"error~", QString::fromUtf8("密码至少6位！"));
        }

    }
    else if(change_password->ui->input_passwd->text().isEmpty() || change_password->ui->affirm_passwd->text().isEmpty())
    {
        QMessageBox::critical(this,"error~", QString::fromUtf8("密码不能为空！"));
    }
    else
    {
        QMessageBox::critical(this,"error~", QString::fromUtf8("两次密码不一致错误！"));
    }
}

void MainWindow::change_passwdClose()
{
    change_password->close();
}

void MainWindow::warning_data()
{
    QString inputData = change_password->ui->input_passwd->text();
    QString affirmData = change_password->ui->affirm_passwd->text();

    if(inputData != affirmData)
    {
        change_password->ui->warning_LineEdit->setText(QString::fromUtf8("密码不一致"));
    }
    else{
        change_password->ui->warning_LineEdit->setText(QString::fromUtf8(""));
    }
}

void MainWindow::timeStatusEvent()
{
    QDateTime curDateTime=QDateTime::currentDateTime();
    int time_T = curDateTime.toTime_t();
    //    qDebug()<<time_T;
    QDateTime T_to_curDateTime = QDateTime::fromTime_t(time_T+28800);
    ui->label->setText(T_to_curDateTime.toString("yyyy-MM-dd hh:mm:ss"));
}

void MainWindow::sendMsgGroup()
{
    getConfigMsgOrder();
    Delay_MSec(20);
    getStatusMsgOrder();
}





void MainWindow::on_autoControlBtn_index_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->autoControl);
}

void MainWindow::on_deviceStatusBtn_index_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->deviceStatus);
}

void MainWindow::on_parmConfigBtn_index_clicked()
{
    login_password = new login(this);
    //    login_password->show();
    login_password->setWindowFlags(login_password->windowFlags() | Qt::WindowStaysOnTopHint);
    //    login_password->setWindowModality(Qt::ApplicationModal);
    ui->parmConfigBtn_index->setEnabled(false);
    login_password->setWindowTitle(QString::fromUtf8("密码验证"));
    login_password->move(400,200);
    login_password->setGeometry(QRect(300,200,430,310));
    login_password->showNormal();

    connect(login_password->ui->enter_Btn,SIGNAL(clicked()),this,SLOT(data_password()));
    connect(login_password->ui->cancle_Btn,SIGNAL(clicked()),this,SLOT(login_passwordClose()));

    //    QFile file_read("/arm_show/arm_show/config/config");
    //    file_read.open(QIODevice::ReadOnly);
    //    QString fd = file_read.readAll();
    //    fd = fd.trimmed();
    //    file_read.close();
    //    bool ok;
    //    bool ok1;
    //    QString original_Password = login_password->ui->input_password->text();

    //    if (login_password->ui->enter_Btn->click() && login_password->ui->input_password->text().isEmpty())
    //    {
    //        QMessageBox::critical(this,"error~", QString::fromUtf8("密码不能为空！"));
    //    }
    //    else if(login_password->ui->enter_Btn->click() && login_password->ui->input_password->text() != "")
    //    {
    //        if(original_Password == fd)
    //        {
    //            ui->stackedWidget->setCurrentWidget(ui->parm_index);
    //            setConfigDataEnable == FALSE;
    //        }
    //        else
    //        {
    //            QMessageBox::critical(this,"error~", QString::fromUtf8("密码错误！"));
    //        }


}

void MainWindow::on_deviceManageBtn_index_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->device_manage);
}


void MainWindow::on_backBtn_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->index);
}

void MainWindow::on_alarmEnquiriesBtn_status_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->alarmEnquiries);
}

void MainWindow::on_faultQueryBtn_status_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->faultQuery);
}

void MainWindow::on_backBtn_Status_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->index);
}

void MainWindow::on_faultQueryBtn_alarm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->faultQuery);
}

void MainWindow::on_backBtn_alarm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->deviceStatus);
}

void MainWindow::on_alarmEnquiriesBtn_fault_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->alarmEnquiries);
}

void MainWindow::on_faultQueryBtn_fault_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->faultQuery);
}

void MainWindow::on_backBtn_fault_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->deviceStatus);
}

void MainWindow::on_parmConfigBtn_parmIndex_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->parm_config);
}

void MainWindow::on_backBtn_parmIndex_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->index);
    setConfigDataEnable == TRUE;
}




void MainWindow::on_backBtn_gateParm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->parm_config);
}

void MainWindow::on_functionalConfigBtn_parmConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_config);
}

void MainWindow::on_gateSelfInspectionBtn_gateParm_clicked()
{
    QString str = "{"
            "\"cmd\":\"write.req.cfg.gate.cali\""
            "\}";
    QPushButton *okbtn = new QPushButton(QString::fromUtf8("确定"));
    QPushButton *cancelbtn = new QPushButton(QString::fromUtf8("取消"));
    QMessageBox *mymsgbox = new QMessageBox;

    mymsgbox->setIcon(QMessageBox::Warning);
    mymsgbox->setWindowTitle(QString::fromUtf8("提示"));
    mymsgbox->setText(QString::fromUtf8("自检闸门吗？"));
    mymsgbox->addButton(okbtn, QMessageBox::AcceptRole);
    mymsgbox->addButton(cancelbtn, QMessageBox::RejectRole);
    mymsgbox->show();

    mymsgbox->exec();//阻塞等待用户输入
    if (mymsgbox->clickedButton()==okbtn)//点击了OK按钮
    {
        sendInfo(str);
        QPushButton *okbtn1 = new QPushButton(QString::fromUtf8("确定"));
        QMessageBox *mymsgbox1 = new QMessageBox;

        mymsgbox1->setIcon(QMessageBox::Information);
        mymsgbox1->setWindowTitle(QString::fromUtf8("提示"));
        mymsgbox1->setText(QString::fromUtf8("稍后数据会进行自动刷新~"));
        mymsgbox1->addButton(okbtn1, QMessageBox::AcceptRole);
        mymsgbox1->show();
    }
    else{

    }
}

void MainWindow::on_functionalParmBtn_parmConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_parm);
}


void MainWindow::on_backBtn_parmConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->parm_index);
}


void MainWindow::on_functionalConfigBtn_functionalConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_config);
}

void MainWindow::on_gateParmBtn_functionalConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->gateParm);
}

void MainWindow::on_functionalParmBtn_functionalConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_parm);
}


void MainWindow::on_backBtn_functionalConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->parm_config);
}

void MainWindow::on_gateParmBtn_functionalParm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->gateParm);
}

void MainWindow::on_functionalConfigBtn_functionalParm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_config);
}

void MainWindow::on_functionalParmBtn_functionalParm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->functional_parm);
}


void MainWindow::on_backBtn_functionalParm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->parm_config);
}



void MainWindow::on_debugBtn_deviceManage_clicked()
{

    QString str = "{"
            "\"cmd\":\"write.req.dev.debug\","
            "\"data\":{"
            "\"localDebug\": 1"
            "\ }"
            "\}";

    sendInfo(str);


    ui->stackedWidget->setCurrentWidget(ui->debug_page);
    socketClientInitDebug();
}

void MainWindow::on_backBtn_deviceManage_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->index);
}



void MainWindow::on_backBtn_debugPage_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->device_manage);
    sendDebugClient->disconnectFromHost();
    delete sendDebugClient;
}

void MainWindow::on_gateConfigBtn_parmConfig_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->gateParm);
}

void MainWindow::on_alarmEnquiriesBtn_alarm_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->alarmEnquiries);
}



// ui date/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//void MainWindow::on_controlMode_textChanged(const QString &arg1)
//{
//    //    ui->controlMode->setText(controlMode);
//    if(controlMode == 1)
//    {
//        ui->controlMode->setText(QString::fromUtf8("空闲模式"));
//    }
//    else if(controlMode == 2)
//    {
//        ui->controlMode->setText(QString::fromUtf8("恒定开度模式"));
//    }
//    else if(controlMode == 3)
//    {
//        ui->controlMode->setText(QString::fromUtf8("恒定流量模式"));
//    }
//    else if(controlMode == 4)
//    {
//        ui->controlMode->setText(QString::fromUtf8("恒定闸前水位模式"));
//    }
//    else if(controlMode == 5)
//    {
//        ui->controlMode->setText(QString::fromUtf8("恒定闸后水位模式"));
//    }
//}



void MainWindow::on_limitStatus_textChanged(const QString &arg1)
{
    if(upLimit == 1 && downLimit == 0 )
    {
        ui->limitStatus->setText(QString::fromUtf8("上限位触发"));
    }
    else if(upLimit == 0 && downLimit ==1)
    {
        ui->limitStatus->setText(QString::fromUtf8("下限位触发"));
    }
    else
    {
        ui->limitStatus->setText(QString::fromUtf8("未触发"));
    }
}

void MainWindow::on_encoderValue_textChanged(const QString &arg1)
{
    QString str = QString::number(gateOpening, 'f', 4);
    ui->encoderValue->setText(str);
}

//void MainWindow::on_flowMode_textChanged(const QString &arg1)
//{
//    ui->flowMode->setText(flowMode);
//}

//void MainWindow::on_flowStatus_textChanged(const QString &arg1)
//{
//    if(flowStatus == 0)
//    {
//        ui->flowStatus->setText(QString::fromUtf8("未计量"));
//    }
//    else if(flowStatus == 1)
//    {
//        ui->flowStatus->setText(QString::fromUtf8("计量中"));
//    }
//}

void MainWindow::on_flowRate_textChanged(const QString &arg1)
{
    QString str = QString::number(flowRate, 'f', 4);
    ui->flowRate->setText(str);
}

void MainWindow::on_totalFlow_textChanged(const QString &arg1)
{
    QString str = QString::number(totalFlow, 'f', 4);
    ui->totalFlow->setText(str);
}

void MainWindow::on_frontWaterLevel_textChanged(const QString &arg1)
{
    QString str = QString::number(frontWaterLevel, 'f', 4);
    ui->frontWaterLevel->setText(str);
}

void MainWindow::on_backWaterLevel_textChanged(const QString &arg1)
{
    QString str = QString::number(backWaterLevel,'f',4);
    ui->backWaterLevel->setText(str);
}

void MainWindow::on_tailWaterLevel_textChanged(const QString &arg1)
{
    QString str = QString::number(tailWaterLevel,'f',4);
    ui->tailWaterLevel->setText(str);
}

void MainWindow::on_controlStatus_textChanged(const QString &arg1)
{
    if(controlStatus == 1)
    {
//        ui->controlStatus->setText(QString::fromUtf8("自动调整中"));
    }
    else
    {
//        ui->controlStatus->setText(QString::fromUtf8("静止中"));
    }
}






void MainWindow::on_iot_id_textChanged(const QString &arg1)
{
    QString str = QString::number(iot_id,'f',0);
    ui->iot_id->setText(str);
}

void MainWindow::on_devOnline_textChanged(const QString &arg1)
{
    if(devOnline == 0)
    {
        ui->devOnline->setText(QString::fromUtf8("离线"));
    }
    else if(devOnline == 1)
    {
        ui->devOnline->setText(QString::fromUtf8("在线"));
    }
}

void MainWindow::on_devAlarm_textChanged(const QString &arg1)
{
    if(devAlarm == 0)
    {
        ui->devAlarm->setText(QString::fromUtf8("无"));
    }
    else if(devAlarm != 0)
    {
        ui->devAlarm->setText(QString::fromUtf8("报警"));
    }
}


void MainWindow::on_devFault_textChanged(const QString &arg1)
{
    if(devFault == 0)
    {
        ui->devFault->setText(QString::fromUtf8("无"));
    }
    else if(devFault != 0)
    {
        ui->devFault->setText(QString::fromUtf8("故障"));
    }
}

void MainWindow::on_temp_textChanged(const QString &arg1)
{
    QString unit =QString::fromUtf8( " ℃");
    QString str = temp + unit;

    ui->temp->setText(str);
}

void MainWindow::on_chargeStatus_textChanged(const QString &arg1)
{
    if(chargeStatus == 0)
    {
        ui->chargeStatus->setText(QString::fromUtf8("未充电"));
    }
    else if(chargeStatus == 1)
    {
        ui->chargeStatus->setText(QString::fromUtf8("充电中"));
    }
}

void MainWindow::on_batVolt_textChanged(const QString &arg1)
{
    QString unit = " v";
    QString str = batVolt + unit;
    ui->batVolt->setText(str);
}


void MainWindow::on_batEnergy_textChanged(const QString &arg1)
{
    QString  unit =  " %";
    QString str = batEnergy + unit;
    ui->batEnergy->setText(str);
}

void MainWindow::on_rssi_textChanged(const QString &arg1)
{
    QString unit = " %";
    QString str = rssi +unit;
    ui->rssi->setText(str);
}

void MainWindow::on_videoSync_textChanged(const QString &arg1)
{
    if(videoSync == 0)
    {
        ui->videoSync->setText(QString::fromUtf8("未同步"));
    }
    else if(videoSync == 1)
    {
        ui->videoSync->setText(QString::fromUtf8("同步中"));
    }
}

void MainWindow::on_bootTime_textChanged(const QString &arg1)
{
    ui->bootTime->setText(bootTime);
}








void MainWindow::on_configSyncTime_textChanged(const QString &arg1)
{
    ui->configSyncTime->setText(configSyncTime);
}

void MainWindow::on_encoderType_textChanged(const QString &arg1)
{


}



void MainWindow::on_gateCorrectingStatus_textChanged(const QString &arg1)
{
    if(gateCorrectingStatus == 0)
    {
        ui->gateCorrectingStatus->setText(QString::fromUtf8("未校准"));
    }
    else if(gateCorrectingStatus == 1)
    {
        ui->gateCorrectingStatus->setText(QString::fromUtf8("已校准"));
    }
}

void MainWindow::on_frontNilometerType_textChanged(const QString &arg1)
{

}

void MainWindow::on_backNilometerType_textChanged(const QString &arg1)
{

}

void MainWindow::on_tailNilometerType_textChanged(const QString &arg1)
{

}




void MainWindow::on_flowModeConfig_textChanged(const QString &arg1)
{
    ui->flowModeConfig->setText(flowMode);
}

void MainWindow::on_videoEnable_textChanged(const QString &arg1)
{
}

void MainWindow::on_monitorEnable_textChanged(const QString &arg1)
{
}

void MainWindow::on_encoderTypeConfig_textChanged(const QString &arg1)
{

}



void MainWindow::on_encoderValueRatio_textChanged(const QString &arg1)
{

}

void MainWindow::on_ratedSpeed_textChanged(const QString &arg1)
{

}

void MainWindow::on_gateOpenValue_textChanged(const QString &arg1)
{
    QString str = QString::number(gateOpenValue,'f',4);
    ui->gateOpenValue->setText(str);
}

void MainWindow::on_gateCloseValue_textChanged(const QString &arg1)
{

}

void MainWindow::on_gateSelfCheck_textChanged(const QString &arg1)
{

}

void MainWindow::on_frontNilometerTypeConfig_textChanged(const QString &arg1)
{

}

void MainWindow::on_backNilometerTypeConfig_textChanged(const QString &arg1)
{

}

void MainWindow::on_tailNilometerTypeConfig_textChanged(const QString &arg1)
{

}

void MainWindow::on_wingWall_textChanged(const QString &arg1)
{

}

void MainWindow::on_dropStep_textChanged(const QString &arg1)
{

}

void MainWindow::on_devSn_textChanged(const QString &arg1)
{
    ui->devSn->setText(devSn);
}

void MainWindow::on_hwVersion_textChanged(const QString &arg1)
{
    ui->hwVersion->setText(hwVersion);
}

void MainWindow::on_swVersion_textChanged(const QString &arg1)
{
    ui->swVersion->setText(swVersion);
}

void MainWindow::on_mfDay_textChanged(const QString &arg1)
{
    ui->mfDay->setText(mfDay);
}




void MainWindow::channelFunctionGroup()
{
    on_encoderTypeConfig_textChanged("Ture");



    on_gateOpenValue_textChanged("Ture");


    on_frontNilometerTypeConfig_textChanged("Ture");
    on_backNilometerTypeConfig_textChanged("Ture");
    on_tailNilometerTypeConfig_textChanged("Ture");

    //    on_videoEnableConfig_textChanged("Ture");
    //    on_monitorEnableConfig_textChanged("Ture");





    //    on_controlMode_textChanged("Ture");
    on_limitStatus_textChanged("Ture");
    on_encoderValue_textChanged("Ture");

    //    on_flowStatus_textChanged("Ture");
    on_flowRate_textChanged("Ture");
    on_totalFlow_textChanged("Ture");
    on_frontWaterLevel_textChanged("Ture");
    on_backWaterLevel_textChanged("Ture");
    on_tailWaterLevel_textChanged("Ture");
    on_controlStatus_textChanged("Ture");



    on_iot_id_textChanged("Ture");
    on_devOnline_textChanged("Ture");
    on_devAlarm_textChanged("Ture");
    on_devFault_textChanged("Ture");
    on_temp_textChanged("Ture");
    on_chargeStatus_textChanged("Ture");
    on_batVolt_textChanged("Ture");
    on_batEnergy_textChanged("Ture");
    on_rssi_textChanged("Ture");
    on_videoSync_textChanged("Ture");
    on_bootTime_textChanged("Ture");



    on_configSyncTime_textChanged("Ture");
    on_encoderType_textChanged("Ture");
    on_gateCorrectingStatus_textChanged("Ture");
//    on_flowModeConfig_textChanged("Ture");
    //    on_videoEnable_textChanged("Ture");
    //    on_monitorEnable_textChanged("Ture");
    on_devSn_textChanged("Ture");
    on_hwVersion_textChanged("Ture");
    on_swVersion_textChanged("Ture");
    on_mfDay_textChanged("Ture");

}

void MainWindow::on_rebootBtn_deviceManage_clicked()
{
    QString str = "{"
            "\"cmd\":\"write.req.dev.rst\""
            "\}";
    QPushButton *okbtn = new QPushButton(QString::fromUtf8("确定"));
    QPushButton *cancelbtn = new QPushButton(QString::fromUtf8("取消"));
    QMessageBox *mymsgbox = new QMessageBox;

    mymsgbox->setIcon(QMessageBox::Warning);
    mymsgbox->setWindowTitle(QString::fromUtf8("提示"));
    mymsgbox->setText(QString::fromUtf8("确定重启设备吗？"));
    mymsgbox->addButton(okbtn, QMessageBox::AcceptRole);
    mymsgbox->addButton(cancelbtn, QMessageBox::RejectRole);
    mymsgbox->show();

    mymsgbox->exec();//阻塞等待用户输入
    if (mymsgbox->clickedButton()==okbtn)//点击了OK按钮
    {
        sendInfo(str);
    }
    else{

    }

}


void MainWindow::on_configSaveBtn_parmIndex_clicked()
{
    getConfigArg();

}

void MainWindow::on_saveBtn_clicked()
{
    QJson::Serializer serializer;
    serializer.setIndentMode(QJson::IndentFull);

    controlMode_getConfig = StrToInt[ui->controlMode_autoControl->currentText()];
    controlPara_getConfig = ui->conPara->text().toDouble();
    QVariantMap controlData;
    QVariantMap contolDoc;

    contolDoc.insert("controlMode",controlMode_getConfig);
    contolDoc.insert("controlPara",controlPara_getConfig);
    controlData.insert("cmd","write.req.control");
    controlData.insert("data",contolDoc);
    bool ok;
    QByteArray json = serializer.serialize(controlData,&ok);
    //    qDebug()<<json;
    sendInfo(json);

}

void MainWindow::on_remoteForbidden_clicked()
{
    QJson::Serializer serializer;
    serializer.setIndentMode(QJson::IndentFull);

    QVariantMap toRemoteData;
    QVariantMap toRemoteDoc;
    QVariantMap toLocalData;
    QVariantMap toLocalDoc;

    toRemoteDoc.insert("remoteForbidden",0);
    toRemoteData.insert("cmd","write.req.mode");
    toRemoteData.insert("data",toRemoteDoc);

    toLocalDoc.insert("remoteForbidden",1);
    toLocalData.insert("cmd","write.req.mode");
    toLocalData.insert("data",toLocalDoc);

    bool ok;
    QByteArray toRemoteData_json = serializer.serialize(toRemoteData,&ok);
    bool ok1;
    QByteArray toLocalData_json = serializer.serialize(toLocalData,&ok1);


    if(remoteForbidden == 1)
    {
        sendInfo(toRemoteData_json);
        //        ui->remoteForbidden->setText(QString::fromUtf8("远程\n(切换)"));
    }
    else if(remoteForbidden == 0)
    {
        sendInfo(toLocalData_json);
        //        ui->remoteForbidden->setText(QString::fromUtf8("本地\n(切换)"));
    }
    sendMsgGroup();
}

void MainWindow::on_passwordChangeBtn_parmIndex_clicked()
{
    change_password = new changePassword(this);
    //    login_password->show();
    change_password->setWindowFlags(change_password->windowFlags() | Qt::WindowStaysOnTopHint);
    //    login_password->setWindowModality(Qt::ApplicationModal);

    change_password->setWindowTitle(QString::fromUtf8("密码修改"));
    change_password->setGeometry(QRect(300,200,430,310));
    change_password->showNormal();
    connect(change_password->ui->affirm_passwd,SIGNAL(textChanged(QString)),this,SLOT(warning_data()));
    connect(change_password->ui->input_passwd,SIGNAL(textChanged(QString)),this,SLOT(warning_data()));
    connect(change_password->ui->enter_Btn,SIGNAL(clicked()),this,SLOT(change_passwd()));
    connect(change_password->ui->cancle_Btn,SIGNAL(clicked()),this,SLOT(change_passwdClose()));
}

void MainWindow::on_frontWaterAirHeight_textChanged(const QString &arg1)
{
    globaldata = ui->frontWaterAirHeight->text();

}

void MainWindow::on_frontWaterLimitConfig_textChanged(const QString &arg1)
{
    globaldata = ui->frontWaterLimitConfig->text();

}

void MainWindow::on_frontWaterOffset_textChanged(const QString &arg1)
{
    globaldata = ui->frontWaterOffset->text();

}

void MainWindow::on_backWaterAirHeight_textChanged(const QString &arg1)
{
    globaldata = ui->backWaterAirHeight->text();

}

void MainWindow::on_backWaterLimitConfig_textChanged(const QString &arg1)
{
    globaldata = ui->backWaterLimitConfig->text();

}

void MainWindow::on_backWaterOffset_textChanged(const QString &arg1)
{
    globaldata = ui->backWaterOffset->text();

}

void MainWindow::on_tailWaterAirHeight_textChanged(const QString &arg1)
{
    globaldata = ui->tailWaterAirHeight->text();

}

void MainWindow::on_tailWaterLimitConfig_textChanged(const QString &arg1)
{
    globaldata = ui->tailWaterLimitConfig->text();

}

void MainWindow::on_tailWaterOffset_textChanged(const QString &arg1)
{
    globaldata = ui->tailWaterOffset->text();

}

void MainWindow::on_conPara_textChanged(const QString &arg1)
{
    globaldata = ui->conPara->text();

}

void MainWindow::on_totalFlowConfig_textChanged(const QString &arg1)
{
    globaldata = ui->totalFlowConfig->text();

}


bool MainWindow::eventFilter(QObject *watched, QEvent *event)
{
    if (watched==ui->conPara)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->conPara->setText("");
        }
    }

    if (watched==ui->backWaterAirHeight)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->backWaterAirHeight->setText("");
        }
    }

    if (watched==ui->backWaterLimitConfig)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->backWaterLimitConfig->setText("");
        }
    }

    if (watched==ui->backWaterOffset)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->backWaterOffset->setText("");
        }
    }

    if (watched==ui->tailWaterAirHeight)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->tailWaterAirHeight->setText("");
        }
    }

    if (watched==ui->tailWaterLimitConfig)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->tailWaterLimitConfig->setText("");
        }
    }

    if (watched==ui->tailWaterOffset)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->tailWaterOffset->setText("");
        }
    }

    if (watched==ui->frontWaterAirHeight)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->frontWaterAirHeight->setText("");
        }
    }

    if (watched==ui->frontWaterLimitConfig)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->frontWaterLimitConfig->setText("");
        }
    }

    if (watched==ui->frontWaterOffset)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->frontWaterOffset->setText("");
        }
    }

    if (watched==ui->totalFlowConfig)         //首先判断控件(这里指 lineEdit1)
    {
        if (event->type()==Qt::ClickFocus)     //然后再判断控件的具体事件 (这里指获得焦点事件)
        {
            globaldata = "";
            ui->totalFlowConfig->setText("");
        }
    }

    return QWidget::eventFilter(watched,event);     // 最后将事件交给上层对话框
}

void MainWindow::timerUpdate(QWidget *, QWidget *)
{
    //    qDebug()<<"time update";
    closeTimer->stop();
    closeTimer->start(closeTime);
}