qt复杂插件系统的实现

#include "maininterfacewidget.h"
#include "ui_maininterfacewidget.h"
#include "processparam.h"
#include <windows.h>
#include <stdint.h>
#include <tlhelp32.h>
#include <stdio.h>
#include <iostream>
#include <vector>

MainInterfaceWidget::MainInterfaceWidget(QWidget *parent,QString str) :
    QMainWindow(parent),
    ui(new Ui::MainInterfaceWidget)
{
    ui->setupUi(this);

    //接收启动参数，不同的参数对应的启动界面不一样
    pluginflagstr = str;
    Com_api = new Common_Fun_API;
    CommonUdpSocket = new QUdpSocket;
    RecviceSocket = new QUdpSocket;
    RecviceSocket->bind(QHostAddress::AnyIPv4,11054);//主界面接收socket接口
    connect(RecviceSocket,&QUdpSocket::readyRead,this,&MainInterfaceWidget::recvicedataslot);
    switchtointerfacecommonsocket = new QUdpSocket;
    temosocket1 = new QUdpSocket;
    killVbsAllProcesssocket = new QUdpSocket;

    revcudpsocket1 = new QUdpSocket(this);
    revcudpsocket1->bind(QHostAddress::AnyIPv4,8080);
    connect(revcudpsocket1, &QUdpSocket::readyRead, this, &MainInterfaceWidget::passBack);

    VbsStartSocket = new QUdpSocket(this);
    VbsStartSocket->bind(QHostAddress::AnyIPv4,7750);
    connect(VbsStartSocket, &QUdpSocket::readyRead, this, &MainInterfaceWidget::VbsStartSlot);

    connect(this,&MainInterfaceWidget::BackClientIpsignal,this,&MainInterfaceWidget::ThanIPNumslot);

    //读取VBS路径下的pbo文件，刷新到combox上
    VbsdataToCombox();
   // writeTxt("123");
    InitMain_data();
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
//    QSizePolicy sp_retain = ui->SeatAllocationWidget->sizePolicy();
//    sp_retain.setRetainSizeWhenHidden(true);
//    ui->SeatAllocationWidget->setSizePolicy(sp_retain);
//    ui->SeatAllocationWidget->setHidden(true);
//    ui->SeatAllocationWidget->setStyleSheet("QWidget{border:1px solid red}");
    InitSqlData();
//    EnbleTabwidgetFalse();
//    IPlist.clear();
    //获取进程pid
    startProcessControl();
}

MainInterfaceWidget::~MainInterfaceWidget()
{
    delete ui;
}
void MainInterfaceWidget::InitMain_data()
{
    this->setWindowFlags(Qt::FramelessWindowHint);
//    QPalette palette;
//    QPixmap pixmap(":/resource/cssimage/background.png");
//    palette.setBrush(QPalette::Window,QBrush(pixmap));
//    ui->centralwidget->setPalette(palette);


    m_PluginInformationList.clear();
    m_configpluginlist.clear();
    m_pluginItenList.clear();
    loadpluginlist.clear();
    //ui->menu_left_widget->setFixedWidth(60);
    //ui->menu_left_widget->setFixedHeight(0);
   // ui->tableW->setFixedWidth(0);
    //ui->tableW->setFixedHeight(80);
    setmenunutablesize();

//    timer = new QTimer;
//    connect(timer,SIGNAL(timeout()),this,SLOT(Astronomical_time_show()));
//    connect(timer,SIGNAL(timeout()),this,SLOT(Combat_time_show()));
//    timer->start(1000);
    LoadPlugins();

    Analyze_Xml();

    loadInitdata();

    this->showMaximized();

    ui->MainInterface_widget->setProperty("MainInterfaceWidget","main");
    //ui->MainInterface_parentwidget->setProperty("MainInterfaceWidget","main");
    //ui->menu_left_widget->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_title_label->setProperty("MainInterfaceWidget","main");
    ui->maininterface_lab1->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_combit_time_label->setProperty("MainInterfaceWidget","main");
    ui->Maininterface_lab2->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_Astronomical_time_label->setProperty("MainInterfaceWidget","main");
   // ui->tableW->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_min_btn->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_full_btn->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_close_btn->setProperty("MainInterfaceWidget","main");
    ui->MainInterface_logo_label->setProperty("MainInterfaceWidget","main");
  //  ui->Maininterface_left_menu_btn_hide->setProperty("left_menu","unload");
  //  ui->MainInterface_btn_hide->setProperty("bottom_menu","unload");
  // style()->unpolish(ui->MainInterface_btn_hide);
   //style()->unpolish(ui->Maininterface_left_menu_btn_hide);
   //style()->polish(ui->MainInterface_btn_hide);
   //style()->polish(ui->Maininterface_left_menu_btn_hide);
   useStylefile();

}
void MainInterfaceWidget::LoadPlugins()
{
    //静态调用插件
    foreach(QObject *plugin,QPluginLoader::staticInstances())
    {
        //plugin 处理事件
        plugin;
    }
    //动态调用插件
    QDir pluginDir(qApp->applicationDirPath());
    if(pluginDir.dirName().toLower() == tr("debug") || pluginDir.dirName().toLower() == tr("release"))
    {
        pluginDir.cdUp();
        pluginDir.cdUp();
        pluginDir.cd("plugins");
    }
    //遍历当前文件夹下文件
    foreach(QString filename,pluginDir.entryList(QDir::Files))
    {
        QPluginLoader pluginLoader(pluginDir.absoluteFilePath(filename));
        QObject *plugin = pluginLoader.instance();
        if(plugin !=0)
        {

            QStringList Templist = filename.split(".",QString::SkipEmptyParts);
            Record_Plugins_information(plugin,Templist.at(0));
        }
    }
}
//根据插件的个数动态创建菜单栏按钮
void MainInterfaceWidget::DynamicCreateMenubar(QStringList list,BaseClassinterface *BClassinterface,QString menu_tip)
{
    if(list.size() == 4)
    {
        StrAdd(list);
        ADDButton(list,BClassinterface,menu_tip);
    }
    else
    {
        qDebug()<<"value error";
    }
}

//菜单栏按钮样式字符串拼接
void MainInterfaceWidget::StrAdd(QStringList list)
{
    StylesheetStr = "";
    StylesheetStr = QString("QPushButton{border-image:url(%1);}"
                            "QPushButton:hover{border-image:url(%2);}"
                            "QPushButton:pressed{border-image:url(%3);}").arg(list.at(1)).arg(list.at(2)).arg(list.at(3));
}
//监听菜单栏按钮槽
void MainInterfaceWidget::sender_btn_slot()
{
//    BaseClassinterface *BaselassInterface;
//    QPushButton *btn = dynamic_cast<QPushButton*>(this->sender());
//    for(int index=0;index<m_pluginItenList.size();index++)
//    {
//        if(btn == m_pluginItenList.at(index).btn)
//        {s
//            BaselassInterface = m_pluginItenList.at(index).plugin;
//        }

//    }
//    if(BaselassInterface != 0)
//    {
//        BaselassInterface->PluginStart(ui->MainInterface_parentwidget,this->geometry().x());
//    }
//    ui->menu_left_widget->raise();
//    ui->Maininterface_left_menu_btn_hide->raise();
//    ui->widget->raise();


}

void MainInterfaceWidget::Record_Plugins_information(QObject *pplugin,QString pluginlib_name)
{
         BaseClassinterface *BclassInte = qobject_cast <BaseClassinterface *>(pplugin);
         if(BclassInte !=0 )
         {
                PluginInformation plugindata;
                plugindata.Pluginlib_name = pluginlib_name;
                plugindata.plugin = BclassInte;
                //创建菜单栏的状态
//                bool MenuStatic= BclassInte->IsCreateMenubar();
//                if(MenuStatic)
//                {

//                    templist = BclassInte->PluginCreateMenu();

//                   plugindata.menudatalist = templist;
//                   plugindata.menustate = true;
//                   // DynamicCreateMenubar(templist,BclassInte);
//                    templist.clear();
//                }
//                else
//                {
//                    plugindata.menustate = false;
//                }
                m_PluginInformationList.push_back(plugindata);
         }

}


void MainInterfaceWidget::ADDButton(QStringList list,BaseClassinterface *BClassinterface,QString menu_tip)
{
//    ui->tableW->setFixedWidth(60*(tempNum+1)+10);
//    QWidget *widget = new QWidget(ui->tableW);
//    widget->setFixedHeight(70);
//    widget->setFixedWidth(50);

//    QPushButton* btn1 = new QPushButton();
//    btn1->setFixedHeight(40);
//    btn1->setFixedWidth(40);
//    btn1->setStyleSheet(StylesheetStr);
//    btn1->setToolTip(menu_tip);
//    PluginItem item;
//    item.btn = btn1;
//    item.plugin = BClassinterface;
//    m_pluginItenList.push_back(item);
//    connect(btn1,SIGNAL(clicked()),this,SLOT(sender_btn_slot()));

//    QLabel *label = new QLabel();
//    label->setText(list.at(0));
//    label->setFixedHeight(20);
//    label->setFixedWidth(40);

//    QVBoxLayout *vly = new QVBoxLayout();
//    vly->setContentsMargins(5,5,5,5);
//    vly->addWidget(btn1);
//    vly->addWidget(label);

//    widget->setLayout(vly);
//    widget->move(60*tempNum+10,5);

//    widget->show();
//    tempNum++;

}
void MainInterfaceWidget::setmenunutablesize()
{

}
void MainInterfaceWidget::showEvent(QShowEvent *event)
{


   // ui->MainInterface_tableMenu->setRowHeight(0,ui->tableW->height());




}
void MainInterfaceWidget::resizeEvent(QResizeEvent *event)
{

    qDebug()<<"parent"<<this->geometry()<<"widget"<<ui->MainInterface_parentwidget->geometry();

    ui->widget->setGeometry(3,ui->MainInterface_parentwidget->height()-90,1920,90);
}

void MainInterfaceWidget::useStylefile()
{
    QString Css_count_str = "";
    QDir dir(qApp->applicationDirPath());
    dir.cdUp();
    dir.cdUp();
    QString filepath = dir.absolutePath() + "/resource/StyleCss";
    //qDebug()<<filepath;
     QDir CssDir(filepath);
    //遍历当前文件夹下文件
    foreach(QString filename,CssDir.entryList(QDir::Files))
    {
      QString Tempstr = ReadCss_str(CssDir.absoluteFilePath(filename));
      Css_count_str = Css_count_str + Tempstr;
    }
    static_cast<QApplication*>(QApplication::instance())->setStyleSheet(Css_count_str);
}
QString MainInterfaceWidget::ReadCss_str(QString Csspath)
{
   QFile styleSheetfile;
   QString Css_str;
   styleSheetfile.setFileName(Csspath);
   if(styleSheetfile.open(QFile::ReadOnly))
   {
   Css_str = styleSheetfile.readAll();
   }
   styleSheetfile.close();
   return Css_str;
}

void MainInterfaceWidget::ServicePluginLoadWidget(QMap<QString, BaseClassinterface *>map)
{
    //针对不同插件进行界面设置
    QMapIterator<QString, BaseClassinterface *>i(map);
    while(i.hasNext())
    {
        i.next();
        if(pluginflagstr =="management")
        {
            ui->StackControlWidget->setCurrentIndex(1);
            if(i.key() == QString("UserLoginPlugin"))  //数据库录入
            {
               BaseClassinterface *Plugin  = i.value();
               Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->UserManagementWidget);
               break;
            }
        }
        else if(pluginflagstr =="worker")
        {
            ui->StackControlWidget->setCurrentIndex(2);
            if(i.key() == QString("InterfacialIntegration"))//席位分配
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->SeatAllocationWidget);
            }
            else if(i.key() == QString("TrainCtrlPlugin"))//任务选择
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->MissonSelectWidget);
            }
            else if(i.key() == QString("StartVbsService"))
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->MissonControlWidget);
            }
            else if(i.key() == QString("MissionDirectotCtrl"))//任务导控 显示VBS
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->MissonControlWidget);
            }
            else if(i.key() == QString("againsstplanplugin"))//课目编辑
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->CourseEditingWidget);
            }
            else if(i.key() == QString("ResultReview"))//成绩评定   需要做插件
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->ScoreEvaluationWidget);
            }
            else if(i.key() == QString("VbsMissionVedioPlugin"))//任务回放
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->MisstionVideoWidget);
            }
            else if(i.key() == QString("SystemSetting"))//系统设置------需要新建界面迁移杨博代码 工程：TrainCtrlPlugin下的 bgmanagewidget.ui
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->SystemSettingWidget);
            }
            else if(i.key() == QString("StartVbsService"))  //VBS服务
            {
                BaseClassinterface *Plugin  = i.value();
                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->SystemSettingWidget);
            }
//            if(i.key() == QString("PeripheralAccessPlugin"))//任务导控 显示VBS
//            {
//                BaseClassinterface *Plugin  = i.value();
//                Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->personnamelab,ui->MissonControlWidget);
//            }
        }

    }
}

void MainInterfaceWidget::ClientPluginLoadWidget(QMap<QString, BaseClassinterface *> map)
{
    QMapIterator<QString, BaseClassinterface *>i(map);
    while(i.hasNext())
    {
        i.next();
        qDebug()<<i.key()<<QString::fromLocal8Bit("界面已加载");
        if(i.key() == QString("PeripheralAccessPlugin"))//任务导控 显示VBS
        {
//                QSizePolicy sp_retain = ui->MainInterface_parentwidget->sizePolicy();
//                sp_retain.setRetainSizeWhenHidden(true);
//                ui->MainInterface_parentwidget->setSizePolicy(sp_retain);
//                ui->MainInterface_parentwidget->setHidden(true);
            ui->StackControlWidget->setCurrentIndex(3);
            BaseClassinterface *Plugin  = i.value();
            Plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x(),ui->personphoto,ui->StackControlWidget,ui->MainInterface_parentwidget);
        }
    }
}

void MainInterfaceWidget::Init_Udp_Socket(QString servicestr)
{
    TaskSendUDPSocket = new QUdpSocket;
    QString missionsendstr = QString("MissionExecute");
    quint64 num = TaskSendUDPSocket->writeDatagram(missionsendstr.toStdString().c_str(),QHostAddress::Broadcast,4456);
    if(num>0)
    {
       qDebug()<<"4456 send ok";
    }
    TaskSendSeatSocket = new QUdpSocket;
    quint64 num1 = TaskSendSeatSocket->writeDatagram(missionsendstr.toStdString().c_str(),QHostAddress::Broadcast,4457);
    if(num1>0)
    {
       qDebug()<<"4457 send ok";
    }

//    changecfgsocket = new QUdpSocket;
//    quint64 num2 = changecfgsocket->writeDatagram(servicestr.toStdString().c_str(),QHostAddress(serviceip),3369);
//    if(num2>0)
//    {
//       qDebug()<<"4457 send ok";
//    }
}

void MainInterfaceWidget::AnalysisAllotSeatXmlIpdata()
{
    //解析xml获取pbo文件的路径
    QDir dir(qApp->applicationDirPath());
    dir.cdUp();
    dir.cdUp();
    QString filepath = dir.absolutePath() + "/config/Allotseat.xml";
    QList<QDomElement> ment_list= Com_api->xml_visit(filepath);
    if(ment_list.size()>0)
    {
        OnLineIPlist.clear();
        for(int i=0;i<ment_list.size();i++)
        {
            QDomElement element = ment_list.at(i);
            qDebug()<<element.tagName();
            if(element.attribute("role") == QString::fromLocal8Bit("服务器"))
            {
                serviceip = element.attribute("ip");
            }
            if(element.tagName() == "IProle" && element.attribute("role") != QString::fromLocal8Bit("服务器"))
            {
                OnLineIPlist << element.attribute("ip");
            }
        }
    }
}

void MainInterfaceWidget::VbsdataToCombox()
{
    //遍历文件夹下的文件
  QString filepath = QString("C:/Program Files/Bohemia Interactive Simulations/VBS3 3.9.2 YYMEA_General/mpmissions/");
  if(filepath.isEmpty()) return;
  QStringList filenamelist = Com_api->visitfilename(filepath,"*.pbo");
  qDebug()<<"----------"<<filenamelist;
  if(filenamelist.size()>0)
  {
       ui->comboBox_5->addItems(filenamelist);
  }

}

void MainInterfaceWidget::writeTxt(QString replacestr)
{
    QString strall;
    QStringList strlist;
    qDebug()<<PATH;
    QFile ReadFile(PATH);
    if(ReadFile.open((QIODevice::ReadOnly | QIODevice::Text)))
    {
        //把文件所有信息读出来
        QTextStream stream(&ReadFile);
        strall = stream.readAll();
    }
    ReadFile.close();
    QFile WriteFile(PATH);
    if(WriteFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        QTextStream stream(&WriteFile);
        strlist = strall.split("\n");
        for(int i=0;i<strlist.count();i++)
        {
            QString tempstr = strlist.at(i);
            if(tempstr.contains("template"))
            {
                QStringList tlist = tempstr.split("=",QString::KeepEmptyParts);
                QString tstr = tlist.at(1);
                tstr.replace(0,tstr.length(),replacestr);
                QString strl = tlist.at(0) + QString("=") + tstr +QString(";");
                stream<<strl<<"\n";
            }
            else
            {
                if(i == strlist.count()-1)
                {
                    stream<<strlist.at(i);
                }
                else
                {
                    stream<<strlist.at(i)<<"\n";
                }
            }
        }
    }
    WriteFile.close();
}

void MainInterfaceWidget::hidewidget()
{
    ui->MainInterface_widget->setVisible(false);

//    ui->MainInterface_logo_label->setVisible(false);
//    ui->MainInterface_title_label->setVisible(false);
//    ui->personnamelab->setVisible(false);
//    ui->pushButton_6->setVisible(false);
//    ui->personphoto->setVisible(false);
//    ui->MainInterface_min_btn->setVisible(false);
//    ui->MainInterface_full_btn->setVisible(false);
//    ui->MainInterface_close_btn->setVisible(false);
//    ui->MainInterface_Astronomical_time_label->setVisible(false);
//    ui->MainInterface_combit_time_label->setVisible(false);
//    ui->Maininterface_lab2->setVisible(false);
    //    ui->maininterface_lab1->setVisible(false);
}




void MainInterfaceWidget::on_MainInterface_close_btn_clicked()
{
    //执行每个插件下的析构函数
    //杀死所有有关VBS的进程
    QString killProcessParamStr = "delVbsAllProcess";
    if(serviceip != "")
    {
        int sendStrSize = killVbsAllProcesssocket->writeDatagram(killProcessParamStr.toStdString().c_str(),QHostAddress(serviceip),5936);
        if(sendStrSize>0)
        {
            qDebug()<<"IP"<<serviceip<<"send port: 5936 data:"<<killProcessParamStr;
        }
    }
    if(OnLineIPlist.size()>0)
    {
        for(int i=0;i<OnLineIPlist.size();i++)
        {
            int sendStrSize = killVbsAllProcesssocket->writeDatagram(killProcessParamStr.toStdString().c_str(),QHostAddress(OnLineIPlist.at(i)),5936);
            if(sendStrSize>0)
            {
                qDebug()<<"IP"<<OnLineIPlist.at(i)<<"send port: 5936 data:"<<killProcessParamStr;
            }
        }
    }
    QString KillSelfProcessStr = "delSelfProcess";
    if(serviceip != "")
    {
        int sendStrSize = killVbsAllProcesssocket->writeDatagram(KillSelfProcessStr.toStdString().c_str(),QHostAddress(serviceip),5936);
        if(sendStrSize>0)
        {
            qDebug()<<"IP"<<serviceip<<"send port: 5936 data:"<<KillSelfProcessStr;
        }
    }
    if(OnLineIPlist.size()>0)
    {
        for(int i=0;i<OnLineIPlist.size();i++)
        {
            int sendStrSize = killVbsAllProcesssocket->writeDatagram(KillSelfProcessStr.toStdString().c_str(),QHostAddress(OnLineIPlist.at(i)),5936);
            if(sendStrSize>0)
            {
                qDebug()<<"IP"<<OnLineIPlist.at(i)<<"send port: 5936 data:"<<KillSelfProcessStr;
            }
        }
    }
    if(loadpluginlist.size()>0)
    {
        for(int i=0;i<loadpluginlist.size();i++)
        {
            loadpluginlist.at(i)->PluginStop();
        }
    }
    this->close();
}
void MainInterfaceWidget::mousePressEvent(QMouseEvent *event)
{
    if(event->y() < m_titleHeight && event->y() > m_frameShape)
    {
        m_mousePoint = event->globalPos();
        m_moveFlag = true;
    }
}
void MainInterfaceWidget::mouseMoveEvent(QMouseEvent *event)
{
    if((event->y() < m_titleHeight) && event->y() > m_frameShape && m_moveFlag)
    {
        int dx = event->globalX() - m_mousePoint.x();
        int dy = event->globalY() - m_mousePoint.y();
        m_mousePoint = event->globalPos();
        this->move(this->x() + dx,this->y() + dy);
    }
}
void MainInterfaceWidget::mouseReleaseEvent(QMouseEvent *event)
{
    if(event->y() < m_titleHeight && event->y() > m_frameShape && m_moveFlag)
    {
        int dx = event->globalX() - m_mousePoint.x();
        int dy = event->globalY() - m_mousePoint.y();
        m_mousePoint = event->globalPos();
        this->move(this->x() + dx,this->y() + dy);
        m_moveFlag = !m_moveFlag;
    }
}
void MainInterfaceWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    if(event->button() == Qt::LeftButton)
    {
        if(event->y() < m_titleHeight)
        {
            if(windowState() != Qt::WindowMaximized)
            {
                this->showMaximized();
            }
            else
            {
                this->showNormal();
            }
        }
    }
}
//解析xml获取初始化数据
void MainInterfaceWidget::Analyze_Xml()
{
    QDir dir(qApp->applicationDirPath());
    dir.cdUp();
    dir.cdUp();
    QString filepath = dir.absolutePath() + "/config/Plugin_Configure.xml";
    QFile file(filepath);
    if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return;
    QDomDocument doc;
    if(!doc.setContent(&file))
    {
        file.close();
    }
    file.close();
    QDomElement root = doc.documentElement();
    QDomNode node = root.firstChild();
    plugins_num = root.childNodes().size();
    while(!node.isNull())
    {
        if(node.isElement())
        {
            QDomElement e = node.toElement();
            if( e.tagName()== "MainWidget")
            {
                if(e.hasAttribute("system_name") && e.hasAttribute("development_company") && e.hasAttribute("system_version") && e.hasAttribute("release_time"))
                {
                    comsydata.system_name = e.attribute("system_name");
                    comsydata.development_company = e.attribute("development_company");
                    comsydata.system_version = e.attribute("system_version");
                    comsydata.release_time = e.attribute("release_time");
                    comsydata.start_mode = e.attribute("start_mode");
                }
            }
            else if(e.tagName().contains("plugin"))
            {
                if(e.hasAttribute("Plugin_name") && e.hasAttribute("Priority") && e.hasAttribute("Start_status") && e.hasAttribute("menu_location") && e.hasAttribute("menu_tip"))
                {
                    configplugin plugin;
                    plugin.Plugin_name = e.attribute("Plugin_name");
                    plugin.Priority = e.attribute("Priority");
                    plugin.Start_status = e.attribute("Start_status");
                    plugin.menu_location = e.attribute("menu_location");
                    plugin.menu_tip = e.attribute("menu_tip");
                    m_configpluginlist.push_back(plugin);
                }
            }

        }
        node=node.nextSibling();
    }
}
void MainInterfaceWidget::loadInitdata()
{
    //系统信息数据加载
    ui->Maininterface_company_label->setText(comsydata.development_company);
    ui->MainInterface_title_label->setText(comsydata.system_name);
    ui->Maininterface_version_label->setText(comsydata.release_time + QString("   ") + comsydata.system_version);
    //插件信息数据加载 遍历配置文件按优先级启动插件
    Plugins_Start(plugins_num);
}
void MainInterfaceWidget::Plugins_Start(int plugins_count)
{
//    for(int i=1;i<plugins_count;i++)
//    {
//        for(int index = 0;index<m_configpluginlist.count();index++)
//        {
//              if(m_configpluginlist.at(index).Start_status.toInt() == 1)               //确认插件是否启动
//              {
//                if(i ==m_configpluginlist.at(index).Priority.toInt())                  //根据插件的优先级去依次启动插件
//                {
//                    QString start_plugin_name = m_configpluginlist.at(index).Plugin_name;       //取出启动的插件名称
//                    for(int num=0;num<m_PluginInformationList.count();num++)
//                    {
//                        if(start_plugin_name == m_PluginInformationList.at(num).Pluginlib_name)
//                        {
//                            if(m_PluginInformationList.at(num).menustate)
//                            {
//                                if(m_configpluginlist.at(index).menu_location == "bottom")
//                                {
//                                     DynamicCreateMenubar(m_PluginInformationList.at(num).menudatalist,m_PluginInformationList.at(num).plugin,m_configpluginlist.at(index).menu_tip);      //需要创建菜单栏按钮的 根据配置文件的菜单栏类型去建立
//                                     qDebug()<<QString::fromLocal8Bit("底部菜单栏插件-----")<<m_PluginInformationList.at(num).Pluginlib_name<<QString::fromLocal8Bit("已启动..........");

//                                }
//                               else if(m_configpluginlist.at(index).menu_location == "left")
//                                {
//                                    add_left_menubtn(m_PluginInformationList.at(num).menudatalist,m_PluginInformationList.at(num).plugin,m_configpluginlist.at(index).menu_tip);
//                                    qDebug()<<QString::fromLocal8Bit("左侧菜单栏插件-----")<<m_PluginInformationList.at(num).Pluginlib_name<<QString::fromLocal8Bit("已启动..........");
//                                }
//                               //  m_PluginInformationList.at(num).plugin->PluginStart(ui->MainInterface_parentwidget);
//                            }
//                            else
//                            {
//                                qDebug()<<QString::fromLocal8Bit("服务级插件------")<<m_PluginInformationList.at(num).Pluginlib_name<<QString::fromLocal8Bit("已启动..........");
//                                m_PluginInformationList.at(num).plugin->PluginStart(ui->MainInterface_parentwidget,this->geometry().x());                            //服务类型的插件直接根据优先级去启动
//                            }
//                            loadpluginlist<<m_PluginInformationList.at(num).plugin;
//                        }
//                    }
//                }
//            }
//        }
//    }
    //分情况启动客户端还是服务端
    plugin_statr_count.clear();
    PluginNameAndSelf_map.clear();
    QStringList startpluginnamelist;
    startpluginnamelist.clear();
    bool flag =false;
    for(int name_num = 0;name_num<m_configpluginlist.count();name_num++)
    {
     if(m_configpluginlist.at(name_num).Start_status.toInt() == 1)               //确认插件是否启动
     {
            flag=true;
            startpluginnamelist<<m_configpluginlist.at(name_num).Plugin_name;
     }
      }
    //插件名与本身映射关系
    for(int start_num = 0;start_num < startpluginnamelist.count();start_num++)
    {
      QString namestr = startpluginnamelist.at(start_num);
      for(int num=0;num<m_PluginInformationList.count();num++)
      {
          if(namestr == m_PluginInformationList.at(num).Pluginlib_name)
          {
              PluginNameAndSelf_map.insert(m_PluginInformationList.at(num).Pluginlib_name,m_PluginInformationList.at(num).plugin);
          }
      }
    }
    QString start_str = comsydata.start_mode;
    if(start_str== QString("service"))
    {
        if(flag)
        {
            //有插件启动 加载界面并初始化VBS
            if(PluginNameAndSelf_map.size()>0)
            {
                ServicePluginLoadWidget(PluginNameAndSelf_map);
            }
        }
        else
        {
            //无插件启动 直接启动VBS并隐藏

        }
    }
    else if(start_str == QString("client"))
    {
        //仅开客户接受端
        if(flag)
        {
            //有插件启动 加载界面并初始化VBS
            if(PluginNameAndSelf_map.size()>0)
            {
                //ui->pushButton_6->setHidden(true);
                hidewidget();
                ClientPluginLoadWidget(PluginNameAndSelf_map);
            }
        }
        else
        {
            //无插件启动 直接启动VBS并隐藏

        }
    }
}

void MainInterfaceWidget::on_MainInterface_min_btn_clicked()
{
    this->showMinimized();
}

void MainInterfaceWidget::on_MainInterface_full_btn_clicked()
{
//    wchar_t *ch;
//    ch = L"VBS3_64.exe";
//    GetProcessIdtext(ch);
    //GetProcessCommand(1888);
    QString Str = "videoStatus";
    int num = temosocket1->writeDatagram(Str.toStdString().c_str(),QHostAddress("192.168.9.8"),6638);
    if(num>0)
    {
        qDebug()<<"send vedioStatus sucess port:6638";
    }
//QProcess p(this);
//p.start(str);
//process->waitForStarted();
//process->waitForFinished();


//    if(windowState() != Qt::WindowMaximized)
//    {
//        this->showMaximized();
//    }
//    else
//    {
//        this->showNormal();
//    }
}
void MainInterfaceWidget::Astronomical_time_show()
{
    QDateTime datetime;
    datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("yyyy-MM-dd hh:mm:ss");
    ui->MainInterface_Astronomical_time_label->setText(timestr + QString("  "));
}
void MainInterfaceWidget::Combat_time_show()
{
    QDateTime datetime;
    datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("yyyy-MM-dd hh:mm:ss");
    ui->MainInterface_combit_time_label->setText(timestr + QString("  "));
}

//测试动态添加菜单栏按钮按键
void MainInterfaceWidget::on_MainInterface_btn_hide_clicked()
{
    if(ui->tableW->isVisible())
    {
          ui->tableW->setVisible(false);
          //ui->MainInterface_btn_hide->setText(QString::fromLocal8Bit("<"));
              ui->MainInterface_btn_hide->setProperty("bottom_menu","packup");
    }
    else
    {
        ui->tableW->setVisible(true);
       // ui->MainInterface_btn_hide->setText(QString::fromLocal8Bit(">"));
        ui->MainInterface_btn_hide->setProperty("bottom_menu","unload");

    }
    style()->unpolish(ui->MainInterface_btn_hide);
    style()->polish(ui->MainInterface_btn_hide);
    update();
}
//动态添加菜单栏按钮
void MainInterfaceWidget::add_left_menubtn(QStringList list,BaseClassinterface *BClassinterface,QString menu_tip)
{
    QPushButton *btn = new QPushButton(ui->menu_left_widget);
    btn->setFixedWidth(40);
    btn->setFixedHeight(40);
    btn->setToolTip(menu_tip);
    StrAdd(list);
    btn->setStyleSheet(StylesheetStr);
    PluginItem item;
    item.btn = btn;
    item.plugin = BClassinterface;
    m_pluginItenList.push_back(item);
    connect(btn,SIGNAL(clicked()),this,SLOT(sender_btn_slot()));
    menu_btn_count++;
    ui->menu_left_widget->setFixedHeight(menu_btn_count*50+10);
    btn->move(10,10);
    if(menu_btn_count>1)
    {
    btn->move(10,(menu_btn_count-1)*50+10);
    }
    btn->show();
}

void MainInterfaceWidget::on_Maininterface_left_menu_btn_hide_clicked()
{
    style()->unpolish(ui->Maininterface_left_menu_btn_hide);
    if(ui->menu_left_widget->isVisible())
    {
          ui->Maininterface_left_menu_btn_hide->setProperty("left_menu","packup");
          ui->menu_left_widget->setVisible(false);
    }
    else
    {
        ui->Maininterface_left_menu_btn_hide->setProperty("left_menu","unload");
        ui->menu_left_widget->setVisible(true);
    }

    style()->polish(ui->Maininterface_left_menu_btn_hide);
    update();
}
//动态添加菜单栏的测试接口
void MainInterfaceWidget::add_menu_group()
{

}
void MainInterfaceWidget::paintEvent(QPaintEvent *event)
{
    QStyleOption opt;
    opt.init(this);
    QPainter p(this);
    style()->drawPrimitive(QStyle::PE_Widget,&opt,&p,this);
    QWidget::paintEvent(event);
}

void MainInterfaceWidget::on_pushButton_7_clicked()
{
    qDebug()<<"&&&&&&&&start";

    AnalysisAllotSeatXmlIpdata();

    //ui->SeatAllocationWidget->setHidden(false);
    //取combobox上的数据  更改vbs服务器的字符串
    QString str = ui->comboBox_5->currentText();
    if(str.isEmpty()||str.isNull())
    {
        QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("请选择一个任务"));
        return;
    }
    QStringList templ= str.split(".pbo");
    writeTxt(templ.at(0));
    QString servicestr = templ.at(0);
    Init_Udp_Socket(servicestr);
}

void MainInterfaceWidget::on_pushButton_6_clicked()
{
    //关闭当前界面，加载登录界面
    LoadWidget *loadwidget = new LoadWidget;
    loadwidget->show();
    this->close();
}

void MainInterfaceWidget::on_pushButton_8_clicked()
{
    //开始任务，读取在线以及分配电脑加载vbs的隐藏窗口
    startTaskSendUdpsocket = new QUdpSocket;
//    if(ui->checkBox_2->isChecked() == true)
//    {
//        QString vediostr = "MNLX3";
//        int num = startTaskSendUdpsocket->writeDatagram(vediostr.toStdString().c_str(),QHostAddress("127.0.0.1"),10023);
//        if(num>0)
//        {
//            qDebug()<<"4478 send data success:"<<vediostr;
//        }
//    }

    qDebug()<<OnLineIPlist;
    if(OnLineIPlist.size()>0)
    {
        for(int i=0;i<OnLineIPlist.count();i++)
        {
           // QString sendstr = QString("startmission") + QString(",") + OnLineIPlist.at(i);
            QString sendstr = QString("Clientstartmission") + QString(",") + OnLineIPlist.at(i);
            int num = startTaskSendUdpsocket->writeDatagram(sendstr.toStdString().c_str(),QHostAddress(OnLineIPlist.at(i)),4461);
            if(num>0)
            {
                qDebug()<<"4461 send data success:"<<sendstr;
            }
        }
    }
    if(serviceip != "")
    {
        startserviceUdpsocket = new QUdpSocket;
        QString missionsendstr = QString("MissionExecute");
        quint64 num2 = startserviceUdpsocket->writeDatagram(missionsendstr.toStdString().c_str(),QHostAddress(serviceip),4455);
        if(num2>0)
        {
           qDebug()<<serviceip<<"4455 send ok";
        }
    }
}

void MainInterfaceWidget::recvicedataslot()
{
//    while(udprecviceVbsStartSocket->hasPendingDatagrams())
//    {

//        QByteArray datagram;
//        datagram.resize(udprecviceVbsStartSocket->pendingDatagramSize());
//        QHostAddress peerAddr;
//        quint16 peerPort;
//        udprecviceVbsStartSocket->readDatagram(datagram.data(),datagram.size(),&peerAddr,&peerPort);
//        QString str = datagram.data();
//        qDebug()<<str;
//        QStringList templist = str.split(",",QString::SkipEmptyParts);
//        //使用串识别是启动服务器还是客户端
//        qDebug() << "Zhi111:" << str;
//        if(templist.at(0) == "UDPServiceVbs_Start_Client_command")
//        {

//        }
//     }
}


void MainInterfaceWidget::on_tabWidget_2_currentChanged(int index)
{
    qDebug()<<index;
    //通过udp告诉当前处于哪个界面
        QString strdata = QString("switch_to_interface") + QString(",") + QString::number(index);
        if(index == 0)
        {
            int num = switchtointerfacecommonsocket->writeDatagram(strdata.toStdString().c_str(),QHostAddress::Broadcast,11056);
            if(num > 0)
            {
                qDebug()<<"send ok data:"<<strdata;
                return;
            }
        }
        else if(index == 3)
        {
            int num = switchtointerfacecommonsocket->writeDatagram(strdata.toStdString().c_str(),QHostAddress::Broadcast,11057);
            if(num > 0)
            {
                qDebug()<<"send ok data:"<<strdata;
                return;
            }
        }
        else if(index == 4)
        {
            int num = switchtointerfacecommonsocket->writeDatagram(strdata.toStdString().c_str(),QHostAddress::Broadcast,11058);
            if(num > 0)
            {
                qDebug()<<"send ok data:"<<strdata;
                return;
            }
        }
}
void MainInterfaceWidget::passBack()
{
    while(revcudpsocket1->hasPendingDatagrams())
    {
        QByteArray datagram;
        datagram.resize(revcudpsocket1->pendingDatagramSize());
        QHostAddress peerAddr;
        quint16 peerPort;
        revcudpsocket1->readDatagram(datagram.data(),datagram.size(),&peerAddr,&peerPort);
        QString str = datagram.data();
        qDebug()<<str<<"8080";
        if ("vedio_status" == str)
        {
            if(serviceip != "")
            {
                if(ui->checkBox_2->isChecked() == true)
                {
                    Sleep(2000);
                    QString vediostr = "MNLX3";
                    int num = startTaskSendUdpsocket->writeDatagram(vediostr.toStdString().c_str(),QHostAddress("127.0.0.1"),10023);
                    if(num>0)
                    {
                        qDebug()<<"4478 send data success:"<<serviceip<<vediostr;
                    }
                }
            }
        }
    }
}
void MainInterfaceWidget::InitSqlData()
{
    QDir dir(qApp->applicationDirPath());
    dir.cdUp();
    dir.cdUp();
    QString filepath = dir.absolutePath() + "/config/Softwareconfig.xml";
    sql_back_up_path = dir.absolutePath() + "/resource/SqlBackUp/";
    QList<QDomElement> ment_list= Com_api->xml_visit(filepath);
    QString sqlpathstr="";
    if(ment_list.size()>0)
    {
        for(int i=0;i<ment_list.size();i++)
        {
            QDomElement element = ment_list.at(i);
            qDebug()<<element.tagName();
            if(element.tagName() == QString("sql"))
            {
              sqlpathstr = element.attribute("path");
            }
        }
    }
    if(sqlpathstr != "")
    {
        //解析数据库文件更新到表格中
        qDebug()<<sqlpathstr;
        QList<QString> dirlist  = Com_api->File_visit(sqlpathstr);

        if(dirlist.size()>0)
        {
            qDebug()<<"sql dir"<<dirlist;
            SqlDataInsertTable(dirlist);
        }
    }
}

void MainInterfaceWidget::SqlDataInsertTable(QList<QString> sql_name_list)
{
    if(sql_name_list.size()>0)
    {
        QVector<QStringList>sql_vec;
        sql_vec.clear();
        QString dis_str = QString::fromLocal8Bit("记录数据的库");
        qDebug()<<"sql_name_list size"<<sql_name_list.size();
        for(int i=0;i<sql_name_list.size();i++)
        {
            QStringList templist;
            templist.clear();
            templist<<sql_name_list.at(i)<<dis_str;
            sql_vec.push_back(templist);
        }
        qDebug()<<"sql_vec size"<<sql_vec.size();

        if(sql_vec.size()>0)
        {

            sqlveclist = sql_vec;
            ui->tableWidget->setRowCount(0);
            InitTableData(sql_vec);
        }
    }

}

void MainInterfaceWidget::BackUpSql(QStringList DBnameList)
{
    for(int i=0;i<DBnameList.size();i++)
    {
        QString Cmd = QString("mysqldump.exe --add-drop-table -uroot -padmin %1").arg(DBnameList.at(i));
        QString Path = QString("%1%2%3").arg(sql_back_up_path).arg(DBnameList.at(i)).arg(".Sql");
        QProcess *poc = new QProcess;
        poc->setStandardOutputFile(Path);
        poc->start(Cmd);
    }
    for(int i=0;i<ui->tableWidget->rowCount();i++)
    {
        QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
        QCheckBox *check = widget->findChild<QCheckBox *>("check");
        if(check->isChecked() == true)
        {
            check->setChecked(false);
        }
    }
    QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("数据库备份成功"));
    return;
}

void MainInterfaceWidget::ResetSql(QStringList DBnameList)
{
    //遍历文件夹

    for(int i=0;i<DBnameList.size();i++)
    {
        QString Cmd = QString("mysql.exe -uroot -padmin %1").arg(DBnameList.at(i));
        QString Path = QString("%1%2%3").arg(sql_back_up_path).arg(DBnameList.at(i)).arg(".Sql");
        QProcess *poc = new QProcess;
        poc->setStandardInputFile(Path);
        poc->start(Cmd);
    }
    for(int i=0;i<ui->tableWidget->rowCount();i++)
    {
        QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
        QCheckBox *check = widget->findChild<QCheckBox *>("check");
        if(check->isChecked() == true)
        {
            check->setChecked(false);
        }
    }
    QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("数据库还原成功"));
    return;
}

void MainInterfaceWidget::EnbleTabwidgetTrue()
{
    ui->tabWidget_2->setTabEnabled(0,true);
    ui->tabWidget_2->setTabEnabled(1,true);
    ui->tabWidget_2->setTabEnabled(2,true);
    ui->tabWidget_2->setTabEnabled(3,true);
    ui->tabWidget_2->setTabEnabled(4,true);
}

void MainInterfaceWidget::EnbleTabwidgetFalse()
{
    ui->tabWidget_2->setTabEnabled(0,false);
    ui->tabWidget_2->setTabEnabled(1,false);
    ui->tabWidget_2->setTabEnabled(2,false);
    ui->tabWidget_2->setTabEnabled(3,false);
    ui->tabWidget_2->setTabEnabled(4,false);
}
void MainInterfaceWidget::on_pushButton_2_clicked()
{
    QStringList templist;
    templist.clear();
    for(int i=0;i<ui->tableWidget->rowCount();i++)
    {
        QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
        QCheckBox *check = widget->findChild<QCheckBox *>("check");
        if(check->isChecked() == true)
        {
            templist<<ui->tableWidget->item(i,1)->text();
        }
    }
    if(templist.size()>0)
    {
        QMessageBox::StandardButton result = QMessageBox::information(NULL,"Title",QString::fromLocal8Bit("是否备份文件"),QMessageBox::Yes|QMessageBox::No);
        switch(result)
        {
            case QMessageBox::Yes:
            BackUpSql(templist);
            break;
        case QMessageBox::No:
            break;
        default:
            break;
        }
    }
    else
    {
        QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("请选择需要操作的数据库"));
        return;
    }
}

void MainInterfaceWidget::on_pushButton_4_clicked()
{
    //上一页
    if(current_page == 1)
    {
        return;
    }
    else
    {
            QStringList list;
            current_page--;

                ui->tableWidget->setRowCount(0);


            for(int i=(current_page-1)*page_row_count;i<page_row_count*current_page;i++)
            {
                list=TempListVec.at(i);
                addtabledata(list,ui->tableWidget);
            }
            ui->label_15->setText(QString::number(current_page) + QString("/") + QString::number(page_count_num));
    }
}

void MainInterfaceWidget::on_pushButton_5_clicked()
{
    //下一页
    if(current_page == page_count_num)
    {
        return;
    }
    else
    {
        QStringList list;
        current_page++;
        if(ceil_flag == false)
        {
            list.clear();

                ui->tableWidget->setRowCount(0);

            for(int i=(current_page-1)*page_row_count;i<page_row_count*current_page;i++)
            {
               list=TempListVec.at(i);
               addtabledata(list,ui->tableWidget);
            }
            ui->label_15->setText(QString::number(current_page) + QString("/") + QString::number(page_count_num));
        }
        else
        {
            if(current_page == page_count_num)
            {
                list.clear();

                    ui->tableWidget->setRowCount(0);

                for(int i=(current_page-1)*page_row_count;i<(current_page-1)*page_row_count+TempListVec.size()%page_row_count;i++)
                {
                    list=TempListVec.at(i);
                    addtabledata(list,ui->tableWidget);
                }
                ui->label_15->setText(QString::number(current_page) + QString("/") + QString::number(page_count_num));
            }
            else
            {
                list.clear();
                  ui->tableWidget->setRowCount(0);

                for(int i=(current_page-1)*page_row_count;i<page_row_count*current_page;i++)
                {
                    list=TempListVec.at(i);
                    addtabledata(list,ui->tableWidget);
                }
                ui->label_15->setText(QString::number(current_page) + QString("/") + QString::number(page_count_num));
            }
        }
    }
}
void MainInterfaceWidget::InitTableData(QVector<QStringList>DbListVec)
{
    qDebug()<<"-------"<<DbListVec.size();
    TempListVec.clear();
    TempListVec = DbListVec;
    if(DbListVec.size() > 0)
    {
        QStringList list;
        list.clear();
        int row_count = DbListVec.size();
        //取整
        if(row_count > page_row_count)
        {
            if(row_count % page_row_count == 0)
            {
              page_count_num = row_count/page_row_count;
              ceil_flag = false;
            }
            else
            {

                double tempnum = row_count/page_row_count;
                page_count_num = tempnum+1;
                qDebug()<<"--row--"<<row_count/page_row_count;
                ceil_flag = true;
            }
            //展示第一页

              ui->tableWidget->setRowCount(0);

            for(int i=0;i<page_row_count;i++)
            {
                //list<<tempnamelist.at(i);
                QStringList list  = DbListVec.at(i);
                qDebug()<<list;
                addtabledata(list,ui->tableWidget);
            }

        }
        else
        {
            page_count_num = 1;
            ui->tableWidget->setRowCount(0);
            for(int i=0;i<DbListVec.size();i++)
            {
                QStringList list  =DbListVec.at(i);
                addtabledata(list,ui->tableWidget);
            }
        }
        current_page = 1;
        ui->label_15->setText(QString::number(current_page) + QString("/") + QString::number(page_count_num));
    }
    else
    {

          ui->tableWidget->setRowCount(0);
    }
}

void MainInterfaceWidget::addtabledata(QStringList list, QTableWidget *tablewidget)
{
    if(list.size()>0)
    {
        tablewidget->insertRow(tablewidget->rowCount());
        QCheckBox *check = new QCheckBox;
        check->setObjectName("check");
        QWidget *widget1;
        QHBoxLayout *hlayout1;
        widget1 = new QWidget;
        hlayout1 = new QHBoxLayout();
        hlayout1->setMargin(0);
        hlayout1->addWidget(check);
        hlayout1->setAlignment(check,Qt::AlignCenter);
        widget1->setLayout(hlayout1);
        QVariant var;
        var.setValue(tablewidget->rowCount()-1);
        check->setProperty("rownum",var);
        tablewidget->setCellWidget(tablewidget->rowCount()-1,0,widget1);
        connect(check,&QCheckBox::clicked,this,&MainInterfaceWidget::checkboxslot);
        for(int i=0;i<list.size();i++)
        {
            tablewidget->setItem(tablewidget->rowCount()-1,i+1,new QTableWidgetItem(list.at(i)));
            tablewidget->item(tablewidget->rowCount()-1,i+1)->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
        }
    }
}

void MainInterfaceWidget::sql_test()
{
    QString Cmd = QString("mysqldump.exe --add-drop-table -uroot -padmin simulation_training_simulation_system");
    QString Path = QString("%1").arg("D://backup.Sql");
    QProcess *poc = new QProcess;
    poc->setStandardOutputFile(Path);
    poc->start(Cmd);
}

void MainInterfaceWidget::on_pushButton_3_clicked()
{
    //模糊搜索
    QVector<QStringList>filterlistVec;
    filterlistVec.clear();
    if(ui->lineEdit_4->text().isNull()||ui->lineEdit_4->text().isEmpty())
    {
        QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("请填入过滤信息"));
        return;
    }
    else
    {
        QString ratherstr = ui->lineEdit_4->text();
        qDebug()<<"---sql----"<<sqlveclist.size();
        if(sqlveclist.size()>0)
        {
            for(int i=0;i<sqlveclist.size();i++)
            {
                  QStringList list = sqlveclist.at(i);
                  qDebug()<<list;
                  QString tempstr=list.at(0);
                   if(tempstr.contains(ratherstr,Qt::CaseInsensitive))
                   {
                       filterlistVec.push_back(list);
                   }
            }
        }
        //重新刷表
        if(filterlistVec.size()>0)
        {
            ui->tableWidget->setRowCount(0);
            InitTableData(filterlistVec);
        }
    }
}

void MainInterfaceWidget::on_lineEdit_4_textEdited(const QString &arg1)
{
    if(ui->lineEdit_2->text().isNull()||ui->lineEdit_2->text().isEmpty())
    {
        //重新初始化数据
        InitSqlData();
    }
}

void MainInterfaceWidget::on_checkBox_clicked()
{
    if(ui->checkBox->isChecked() == true)
    {
        for(int i=0;i<ui->tableWidget->rowCount();i++)
        {
            QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
            QCheckBox *check = widget->findChild<QCheckBox *>("check");
            if(check->isChecked() == false)
            {
                check->setChecked(true);
            }
        }
    }
    else
    {
        for(int i=0;i<ui->tableWidget->rowCount();i++)
        {
            QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
            QCheckBox *check = widget->findChild<QCheckBox *>("check");
            if(check->isChecked() == true)
            {
                check->setChecked(false);
            }
        }
    }
}

void MainInterfaceWidget::checkboxslot()
{
    if(ui->checkBox->isChecked() == true)
    {
        ui->checkBox->setChecked(false);
    }
}


void MainInterfaceWidget::on_pushButton_9_clicked()
{
    QStringList filenamelist = Com_api->wenjian_visit(sql_back_up_path);
    QStringList noexistnamelist;
    QString str="";
    QStringList templist;
    templist.clear();
    for(int i=0;i<ui->tableWidget->rowCount();i++)
    {
        QWidget *widget = dynamic_cast<QWidget*>(ui->tableWidget->cellWidget(i,0));
        QCheckBox *check = widget->findChild<QCheckBox *>("check");
        if(check->isChecked() == true)
        {
            templist<<ui->tableWidget->item(i,1)->text();
        }
    }
    if(templist.size()>0)
    {
        for(int i=0;i<templist.size();i++)
        {
            bool flag = false;
            for(int k=0;k<filenamelist.size();k++)
            {
                QString tempstr = filenamelist.at(i);
                if(tempstr.contains(templist.at(i),Qt::CaseInsensitive))
                {
                    flag = true;
                }
            }
            if(flag == false)
            {
                noexistnamelist << templist.at(i);
                str = str + templist.at(i) + QString(" ");
            }
        }
    }
    if(noexistnamelist.size()>0)
    {
        if(templist.size()>0)
        {
            QString str = QString("%1").arg(str) + QString::fromLocal8Bit("数据库没有备份无法进行还原，其他数据库可以进行还原，是否还原其他数据库？");
            QMessageBox::StandardButton result = QMessageBox::information(NULL,"Title",str,QMessageBox::Yes|QMessageBox::No);
            switch(result)
            {
                case QMessageBox::Yes:
                ResetSql(templist);
                break;
            case QMessageBox::No:
                break;
            default:
                break;
            }
        }
        else
        {
            QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("请选择需要还原的数据库"));
            return;
        }
    }
    else
    {
        if(templist.size()>0)
        {
            QMessageBox::StandardButton result = QMessageBox::information(NULL,"Title",QString::fromLocal8Bit("是否还原文件"),QMessageBox::Yes|QMessageBox::No);
            switch(result)
            {
                case QMessageBox::Yes:
                ResetSql(templist);
                break;
            case QMessageBox::No:
                break;
            default:
                break;
            }
        }
        else
        {
            QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("请选择需要还原的数据库"));
            return;
        }
    }

}

void MainInterfaceWidget::VbsStartSlot()
{
    while(VbsStartSocket->hasPendingDatagrams())
    {

      QByteArray datagram;
      datagram.resize(VbsStartSocket->pendingDatagramSize());
      QHostAddress peerAddr;
      quint16 peerPort;
      VbsStartSocket->readDatagram(datagram.data(),datagram.size(),&peerAddr,&peerPort);
      QString str = datagram.data();
      qDebug()<<str;
      QStringList templist = str.split(",",QString::SkipEmptyParts);
      //使用串识别是启动服务器还是客户端
      if(templist.at(0) == "VbsStatus")
      {
          if(templist.at(1) == QString("true"))
          {
              if(IPlist.size()<1)
              {
                  //直接写入
                  IPlist<<peerAddr.toString();
                  //向客户端返回收到的一帧数据
    //             QString tempstr = QString("UDPService_mode_ip") +QString(",") + QString("reviceonline");
    //             quint64 num = udpsendsocket->writeDatagram(tempstr.toStdString().c_str(),peerAddr,10080);
    //             if(num>0)
    //             {
    //                qDebug()<<"service send ok";
    //             }
              }
              else
              {
                  //对比是否重复
                  if(!Check_ip(peerAddr.toString()))
                  {
                      IPlist<<templist.at(1);
                      //向客户端返回收到的一帧数据
    //                  QString tempstr = QString("UDPService_mode_ip") +QString(",") + QString("reviceonline");
    //                 quint64 num = udpsendsocket->writeDatagram(tempstr.toStdString().c_str(),peerAddr,10080);
    //                 if(num>0)
    //                 {
    //                    qDebug()<<"service send ok";
    //                 }
                     //触发一次信号将容器的值送到子线程中去做比较
                  }
              }
          }
         emit BackClientIpsignal(IPlist.size());
      }
     }
}

void MainInterfaceWidget::write_txt(QString serviceIpstr)
{
    QFile file("C:/Program Files/Bohemia Interactive Simulations/VBS3 3.9.2 YYMEA_General/MNXL_Rource/ServiceIp.txt");
    if(file.open(QIODevice::ReadWrite|QIODevice::Text))
    {
        QString tempstr = serviceIpstr;
        QTextStream out(&file);
        out<<tempstr;
        file.close();
    }
}

void MainInterfaceWidget::ThanIPNumslot(int num)
{
    if(OnLineIPlist.size()>0)
    {
        if(OnLineIPlist.size() == num)
        {
            for(int i=0;i<OnLineIPlist.size();i++)
            {
             QString tempstr = QString("StartInputWidget");
             quint64 num = CommonUdpSocket->writeDatagram(tempstr.toStdString().c_str(),QHostAddress(OnLineIPlist.at(i)),7783);
             if(num>0)
             {
              qDebug()<<"service send ok";
             }
            }
            //向客户端推送加载外设界面的协议
            EnbleTabwidgetTrue();
            QMessageBox::warning(NULL, QStringLiteral("提示"), QString::fromLocal8Bit("系统插件启动成功，可以进行下一步操作"));
            return;
        }
    }

}
bool MainInterfaceWidget::Check_ip(QString str)
{
    if(IPlist.size()>0)
    {
        bool flag = false;
        for(int i=0;i<IPlist.size();i++)
        {
            if(str == IPlist.at(i))
            {
                flag = true;
                break;
            }
        }
        return flag;
    }
}
DWORD MainInterfaceWidget::GetProcessIdtext(WCHAR* szProcessName)
{
    HANDLE hProcessSnapShot = NULL;
    PROCESSENTRY32 pe32 = { 0 };
    hProcessSnapShot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

    if (hProcessSnapShot == (HANDLE)-1) return NULL;

    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hProcessSnapShot, &pe32))
    {
        do {
            if (!wcscmp(szProcessName, pe32.szExeFile))
            {
                 qDebug()<<pe32.th32ProcessID ;
//                std::cout <<"\n"<< pe32.th32ProcessID <<"\n"<<std::endl;
//                GetProcessCommand(pe32.th32ProcessID);
                return pe32.th32ProcessID;
            }

            //return pe32.th32ProcessID;
        } while (Process32Next(hProcessSnapShot, &pe32));

    }
    else
        ::CloseHandle(hProcessSnapShot);

    return NULL;
}
void MainInterfaceWidget::GetProcessCommand(DWORD dwPid)
{
    qDebug()<<"1";

    HANDLE m_ProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);
    qDebug()<<"2";

    BOOL bTarget = FALSE;
    BOOL bSource = FALSE;
    PEB64 peb;
    PEB32 peb32;
    qDebug()<<"3";

    IsWow64Process(GetCurrentProcess(), &bSource);
    IsWow64Process(m_ProcessHandle, &bTarget);
    qDebug()<<"4";

    SYSTEM_INFO si;
    GetSystemInfo(&si);
    qDebug()<<"5";

    if (bTarget == FALSE && bSource == TRUE)
    {
        qDebug()<<"6";

        char *ch;
        char tempc[12] ="ntdll.dll";
        ch = tempc;

       // ch = L"ntdll.dll";
        HMODULE NtdllModule = GetModuleHandle(ch);

        pfnNtWow64QueryInformationProcess64 NtWow64QueryInformationProcess64 = (pfnNtWow64QueryInformationProcess64)GetProcAddress(NtdllModule, "NtWow64QueryInformationProcess64");
        pfnNtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = (pfnNtWow64ReadVirtualMemory64)GetProcAddress(NtdllModule, "NtWow64ReadVirtualMemory64");
        PROCESS_BASIC_INFORMATION64 pbi64 = { 0 };
        if (NT_SUCCESS(NtWow64QueryInformationProcess64(m_ProcessHandle, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL)))
        {

            if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(pbi64.PebBaseAddress), &peb, sizeof(peb), NULL)))
            {
                RTL_USER_PROCESS_PARAMETERS64 user_proc_params = { 0 };
                if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(peb.ProcessParameters), &user_proc_params, sizeof(user_proc_params), NULL)))
                {
                    wchar_t buf[4096] = { 0 };
                    DWORD data_size = user_proc_params.CommandLine.Length > 4090 ? 4090 : user_proc_params.CommandLine.Length;
                    if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(user_proc_params.CommandLine.Buffer), &buf, data_size, NULL)))
                    {
                        //std::wcout << buf;
                        std::string tempstr;
                        int pSize = WideCharToMultiByte(CP_OEMCP,0,buf,wcslen(buf),NULL,0,NULL,NULL);
                        char *charstr = new char[pSize+1];
                        WideCharToMultiByte(CP_OEMCP, 0, buf, wcslen(buf), charstr, pSize, NULL, NULL);
                        charstr[pSize] = '\0';
                        tempstr = charstr;

                        std::cout <<"--------"<< tempstr << std::endl;
                        if (m_ProcessHandle != NULL)
                        {
                            ::TerminateProcess(m_ProcessHandle, 0);
                        }
                        return;
                        //cmd_line = StringUtil::Easy_UnicodeToAnsi(buf + 1);
                    }
                }
            }
            //DWORD64 Ldr64 = 0;
            //LIST_ENTRY64 ListEntry64 = { 0 };
            //LDR_DATA_TABLE_ENTRY64 LDTE64 = { 0 };
            //wchar_t ProPath64[256];
            //if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(pbi64.PebBaseAddress + offsetof(PEB64, Ldr)), &Ldr64, sizeof(Ldr64), NULL)))
            //{
            //	if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(Ldr64 + offsetof(PEB_LDR_DATA64, InLoadOrderModuleList)), &ListEntry64, sizeof(LIST_ENTRY64), NULL)))
            //	{
            //		if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)(ListEntry64.Flink), &LDTE64, sizeof(_LDR_DATA_TABLE_ENTRY64), NULL)))
            //		{
            //			while (1)
            //			{
            //				if (LDTE64.InLoadOrderLinks.Flink == ListEntry64.Flink) break;
            //				if (NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)LDTE64.FullDllName.Buffer, ProPath64, sizeof(ProPath64), NULL)))
            //				{
            //					//printf("模块基址:0x%llX\n模块大小:0x%X\n模块路径:%ls\n", LDTE64.DllBase, LDTE64.SizeOfImage, ProPath64);
            //				}
            //				if (!NT_SUCCESS(NtWow64ReadVirtualMemory64(m_ProcessHandle, (PVOID64)LDTE64.InLoadOrderLinks.Flink, &LDTE64, sizeof(_LDR_DATA_TABLE_ENTRY64), NULL))) break;
            //			}
            //		}
            //	}
            //}
        }

    }
    else if (bTarget == TRUE && bSource == TRUE || si.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_AMD64 ||
        si.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_IA64)
    {
        qDebug()<<"7";

        char *ch;
        char tempc[12] ="ntdll.dll";
        ch = tempc;
        qDebug()<<"8";

        HMODULE NtdllModule = GetModuleHandle(ch);
        qDebug()<<"9";

        pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule, "NtQueryInformationProcess");
        PROCESS_BASIC_INFORMATION32 pbi32 = { 0 };
        if (NT_SUCCESS(NtQueryInformationProcess(m_ProcessHandle, ProcessBasicInformation, &pbi32, sizeof(pbi32), NULL)))
        {

            if (NT_SUCCESS(NtQueryInformationProcess(m_ProcessHandle, pbi32.PebBaseAddress, &peb32, sizeof(peb32), NULL)))
            {
                RTL_USER_PROCESS_PARAMETERS64 user_proc_params = { 0 };
                if (NT_SUCCESS(NtQueryInformationProcess(m_ProcessHandle, peb32.ProcessParameters, &user_proc_params, sizeof(user_proc_params), NULL)))
                {
                    wchar_t buf[4096] = { 0 };
                    DWORD data_size = user_proc_params.CommandLine.Length > 4090 ? 4090 : user_proc_params.CommandLine.Length;
                    if (NT_SUCCESS(NtQueryInformationProcess(m_ProcessHandle, user_proc_params.CommandLine.Buffer, &buf, data_size, NULL)))
                    {
                        //std::wcout << buf;
                        std::string tempstr;
                        int pSize = WideCharToMultiByte(CP_OEMCP,0,buf,wcslen(buf),NULL,0,NULL,NULL);
                        char *charstr = new char[pSize+1];
                        WideCharToMultiByte(CP_OEMCP, 0, buf, wcslen(buf), charstr, pSize, NULL, NULL);
                        charstr[pSize] = '\0';
                        qDebug()<<"8";
                        qDebug()<<QString(charstr);
                        std::cout <<"--------"<< tempstr << std::endl;
                        if (m_ProcessHandle != NULL)
                        {
                            ::TerminateProcess(m_ProcessHandle, 0);
                        }
                        return;
                        //cmd_line = StringUtil::Easy_UnicodeToAnsi(buf + 1);
                    }
                }
            }

//            DWORD Ldr32 = 0;
//            LIST_ENTRY32 ListEntry32 = { 0 };
//            LDR_DATA_TABLE_ENTRY32 LDTE32 = { 0 };
//            wchar_t ProPath32[256];
//            if (ReadProcessMemory(m_ProcessHandle, (PVOID)(pbi32.PebBaseAddress + offsetof(PEB32, Ldr)), &Ldr32, sizeof(Ldr32), NULL))
//            {
//                if (ReadProcessMemory(m_ProcessHandle, (PVOID)(Ldr32 + offsetof(PEB_LDR_DATA32, InLoadOrderModuleList)), &ListEntry32, sizeof(LIST_ENTRY32), NULL))
//                {
//                    if (ReadProcessMemory(m_ProcessHandle, (PVOID)(ListEntry32.Flink), &LDTE32, sizeof(_LDR_DATA_TABLE_ENTRY32), NULL))
//                    {
//                        while (1)
//                        {
//                            if (LDTE32.InLoadOrderLinks.Flink == ListEntry32.Flink) break;
//                            if (ReadProcessMemory(m_ProcessHandle, (PVOID)LDTE32.FullDllName.Buffer, ProPath32, sizeof(ProPath32), NULL))
//                            {
//                                printf("模块基址:0x%X\n模块大小:0x%X\n模块路径:%ls\n", LDTE32.DllBase, LDTE32.SizeOfImage, ProPath32);
//                            }
//                            if (!ReadProcessMemory(m_ProcessHandle, (PVOID)LDTE32.InLoadOrderLinks.Flink, &LDTE32, sizeof(_LDR_DATA_TABLE_ENTRY32), NULL)) break;
//                        }
//                    }
//                }
//            }
        }
    }
    CloseHandle(m_ProcessHandle);
    getchar();
}

void MainInterfaceWidget::startProcessControl()
{
    QDir dir(qApp->applicationDirPath());
    dir.cdUp();
    dir.cdUp();
    QString filepath = dir.absolutePath() + "/ProcessControl/processcommand.exe";
    QProcess *process = new QProcess(this);
    process->startDetached(filepath);
}