master

分支 (1)

标签 (2)

管理

管理

master

v1.0.0

v0.1

NetAssistant
/
mainwindow.cpp

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

#include "define.h"
#include <QMessageBox>
#include <stdlib.h>
#include <QFileDialog>
#include <QFile>
#include <QString>
#include <QTimer>
#include <QInputDialog>
#include <QDateTime>

const char toHex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

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

    //设置程序的开启默认画面
    setUdpGuiExt();

    //获取本机的IP地址,并初始化相应的控件属性和变量
    QList<QHostAddress> ipAddressesList = QNetworkInterface::allAddresses();
    // use the first non-localhost IPv4 address
    for(int i = 0; i < ipAddressesList.size(); ++i) {
        if(ipAddressesList.at(i) != QHostAddress::LocalHost && ipAddressesList.at(i).toIPv4Address()) {
            m_ip = ipAddressesList.at(i).toString();
            break;
        }
    }
    // 设置获取的IP到相应文本框
    ui->lEditIpAddr->setText(m_ip);
    ui->lEditUdpIP->setText(m_ip);
    ui->SndProgressBar->setVisible(false);

    //初始化全局变量
    rmtServerIP = new QHostAddress();
    rcvDataCnt  = 0;
    sndDataCnt = 0;
    TcpClientLinkCnt = 0;
    //NetState = false;
    loopSending = false;
    CurIPPort = "";
    CurPath = "";
    curFile = 0;
}

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

/**********************************************************/
//Function for connection button
void MainWindow::on_pBtnNetCnnt_clicked(bool checked)
{
    if(checked) {     //切换到链接状态
        if(ui->cBoxNetType->currentIndex() == UDP_MODE) {
            //建立UDP链接
            udpSocket = new QUdpSocket(this);
            connect(udpSocket, SIGNAL(readyRead()), this, SLOT(udpDataReceived()));
            lhAddr.setAddress(ui->lEditIpAddr->text());
            lhPort = ui->lEditIpPort->text().toInt();
            rmtAddr.setAddress(ui->lEditUdpIP->text());
            rmtPort = ui->lEditUdpPort->text().toInt();
            bool result = udpSocket->bind(lhPort);
            if(!result)
            {
                ui->pBtnNetCnnt->setChecked(0);
                QMessageBox::information(this, tr("错误"), tr("UDP绑定端口失败!"));
                return;
            }
            ui->CurState->setText(tr("建立UDP连接成功"));

        } else if(ui->cBoxNetType->currentIndex() == TCP_SERVER_MODE) {
            //建立TCP服务器链接
            lhAddr.setAddress(ui->lEditIpAddr->text());
            lhPort = ui->lEditIpPort->text().toInt();

            if(! slotTryCreateTcpServer())
            {
                ui->pBtnNetCnnt->setChecked(0);
                QMessageBox::information(this, tr("错误"), tr("尝试建立服务器失败! 请确认网络状态和端口。"));
                return;
            }
            ui->CurState->setText(tr("建立TCP服务器成功"));
        } else if(ui->cBoxNetType->currentIndex() == TCP_CLIENT_MODE) {
            //建立TCP客户端
            QString ip = ui->lEditIpAddr->text();
            if(!rmtServerIP->setAddress(ip))
            {
                QMessageBox::information(this, tr("错误"), tr("TCP服务器IP设置失败!"));
                return;
            }
            tcpClientSocket = new QTcpSocket(this);
            connect(tcpClientSocket, SIGNAL(readyRead()), this, SLOT(tcpClientDataReceived()));
            tcpClientSocket->connectToHost(*rmtServerIP, ui->lEditIpPort->text().toInt());

            if(!tcpClientSocket->waitForConnected(2000)) {
                ui->lEditUdpPort->setText(QString::number(0, 10));
                ui->pBtnNetCnnt->setChecked(0);
                QMessageBox::information(this, tr("错误"), tr("尝试连接服务器失败! 请确认服务器状态。"));

                return;
            }

            ui->lEditUdpPort->setText(QString::number(tcpClientSocket->localPort(), 10));
            ui->CurState->setText(tr("连接TCP服务器成功"));
        }
        ui->pBtnNetCnnt->setText(tr("断开网络"));
        ui->pBtnSendData->setEnabled(true);
        //NetState = true;
    } else { //切换到断开状态
        if(ui->cBoxNetType->currentIndex() == UDP_MODE) {
            //断开UDP链接
            udpSocket->close();
            delete udpSocket;
        } else if(ui->cBoxNetType->currentIndex() == TCP_SERVER_MODE) {
            //断开TCP服务器链接
            slotDeleteTcpServer();
        } else if(ui->cBoxNetType->currentIndex() == TCP_CLIENT_MODE) {
            //断开TCP客户端链接
            tcpClientSocket->disconnectFromHost();
        }

        ui->pBtnNetCnnt->setText(tr("连接网络"));
        ui->pBtnSendData->setEnabled(false);
        ui->CurState->setText(tr(""));
        // NetState = false;
    }
}

/**********************************************************/
//funcions switch
void MainWindow::on_cBoxNetType_currentIndexChanged(int index)
{
    if(index == UDP_MODE) {
        setUdpGuiExt();
        ui->label_Port->setText(tr("本地端口"));
        ui->label_IP->setText(tr("本地IP地址"));
        ui->labelUdp->setText(tr("目标IP地址"));
        ui->labelUdp1->setText(tr("目标端口"));
        ui->lEditIpAddr->setText(m_ip);
    } else if(index == TCP_SERVER_MODE) {
        setTcpSvrGuiExt();
        // setTcpClientGuiExt();
        ui->label_Port->setText(tr("本地端口"));
        ui->label_IP->setText(tr("本地IP地址"));
        ui->lEditIpAddr->setText(m_ip);
    } else if(index == TCP_CLIENT_MODE) {
        setTcpClientGuiExt();
        ui->label_Port->setText(tr("服务器端口"));
        ui->label_IP->setText(tr("服务器IP地址"));
        ui->labelUdp->setText(tr("本地IP地址"));
        ui->labelUdp1->setText(tr("本地端口"));
        ui->lEditIpAddr->setText(tr("220.165.9.87"));
    }
}

/**********************************************************/
//set UDP mode
void MainWindow::setUdpGuiExt()
{
    ui->labelSpaceUdp->setVisible(true);
    ui->lEditUdpIP->setVisible(true);
    ui->labelUdp->setVisible(true);
    ui->labelUdp1->setVisible(true);
    ui->lEditUdpPort->setVisible(true);

    ui->labelClients->setVisible(false);
    ui->cBoxClients->setVisible(false);
    ui->labelSpaceClients->setVisible(false);
    ui->cBox_chatMode->setVisible(false);
    ui->cBox_echoMode->setVisible(false);
}

/**********************************************************/
//set TCP server
void MainWindow::setTcpSvrGuiExt()
{
    ui->labelSpaceUdp->setVisible(false);
    ui->lEditUdpIP->setVisible(false);
    ui->labelUdp->setVisible(false);
    ui->labelUdp1->setVisible(false);
    ui->lEditUdpPort->setVisible(false);

    ui->labelClients->setVisible(true);
    ui->cBoxClients->setVisible(true);
    ui->labelSpaceClients->setVisible(true);
    ui->cBox_chatMode->setVisible(true);
    ui->cBox_echoMode->setVisible(true);
}

/**********************************************************/
void MainWindow::setTcpClientGuiExt()
{
    ui->labelSpaceUdp->setVisible(true);
    ui->lEditUdpIP->setVisible(true);
    ui->labelUdp->setVisible(true);
    ui->labelUdp1->setVisible(true);
    ui->lEditUdpPort->setVisible(true);

    ui->labelClients->setVisible(false);
    ui->cBoxClients->setVisible(false);
    ui->labelSpaceClients->setVisible(false);
    ui->cBox_chatMode->setVisible(false);
    ui->cBox_echoMode->setVisible(false);
}

/**********************************************************/
//send data
void MainWindow::on_pBtnSendData_clicked()
{
    if(ui->cBoxStartSndFile->checkState()) {
        on_pBtnResetCnt_clicked();
        ui->pBtnSendData->setText(tr("正在发送"));
        ui->pBtnSendData->setEnabled(false);
        insertDateTimeInRcvDisp();
        ui->ReceiveTextEdit->appendPlainText(tr("开始发送..."));
        toSendFile();
        insertDateTimeInRcvDisp();
        ui->ReceiveTextEdit->appendPlainText(tr("发送完成！"));
        float hasSnd = sndDataCnt;
        hasSnd = hasSnd / 1024 / 1024;
        QString hasSndSz = QString("%1").arg(hasSnd);
        ui->ReceiveTextEdit->appendPlainText(tr("共发送数据：") + hasSndSz + "MB");

        ui->pBtnSendData->setText(tr("发送"));
        ui->pBtnSendData->setEnabled(true);
        return;
    }

    if(ui->tEditSendText->toPlainText().size() == 0) {
        QMessageBox::information(this, tr("提示"), tr("发送区为空，请输入内容。"));
        return;  //如果发送区为空则直接跳出
    }

    if(ui->cBoxLoopSnd->checkState())
    {
        if(!loopSending) {
            ui->pBtnSendData->setText(tr("停止发送"));
            timer->start();
            loopSending = true;
        } else {
            timer->stop();
            ui->pBtnSendData->setText(tr("发送"));
            loopSending = false;
        }
    } else {
        toSendData();
        if(ui->cBox_AntoClearSnd->checkState()) {
            ui->tEditSendText->clear();
        }
    }
}

/**********************************************************/
//send data
void MainWindow::toSendData()
{
    QByteArray datagram;

    if(ui->cBox_SndHexDisp->checkState()) {
        QStringList hexStr = ui->tEditSendText->toPlainText().split(" ", QString::SkipEmptyParts);
        int hexSize = hexStr.size();
        for(int i = 0; i < hexSize; i++) {
            QString hexSubStr = hexStr.at(i);
            datagram.append(ConvertHexStr(hexSubStr));
        }
        datagram.resize(hexSize);
    } else {
        datagram = ui->tEditSendText->toPlainText().toLocal8Bit();
    }

    if(datagram.size() == 0)
        return;

    if(ui->cBoxNetType->currentIndex() == UDP_MODE) {
        udpSocket->writeDatagram(datagram.data(), datagram.size(), rmtAddr, rmtPort);
    } else if(ui->cBoxNetType->currentIndex() == TCP_SERVER_MODE) {
        int idx = ui->cBoxClients->currentIndex() ;
        if(idx == 0) {
            emit sendDataToClient((char *)datagram.data(), datagram.size(), 0, 0);
        } else {
            emit sendDataToClient((char *)datagram.data(), datagram.size(), tcpClientSocketDescriptorList.at(idx), 0);
        }
    } else if(ui->cBoxNetType->currentIndex() == TCP_CLIENT_MODE) {
        tcpClientSocket->write(datagram.data(), datagram.size());
    }

    sndDataCnt += datagram.size();
    ui->lEdit_SndCnt->setText(QString::number(sndDataCnt, 10));
}

/**********************************************************/
void MainWindow::toSendFile()
{
    if(curFile == 0)
        return;
    char buf[1024];
    int rdLen = 0;
    ui->SndProgressBar->setMaximum(curFile->bytesAvailable());
    ui->SndProgressBar->setVisible(true);
    ui->SndProgressBar->setValue(0);
    if(ui->cBoxNetType->currentIndex() == UDP_MODE) {   //UDP 模式

        while(!curFile->atEnd())
        {
            rdLen = curFile->read(buf, 1024);
            udpSocket->writeDatagram(buf, rdLen, rmtAddr, rmtPort);
            sndDataCnt += rdLen;
            ui->lEdit_SndCnt->setText(QString::number(sndDataCnt, 10));
            ui->SndProgressBar->setValue(ui->SndProgressBar->value() + rdLen);
            msDelay(1);
        }
    } else if(ui->cBoxNetType->currentIndex() == TCP_SERVER_MODE) { //TCP服务器模式
        int idx = ui->cBoxClients->currentIndex() ;
        if(idx == 0) {
            while(!curFile->atEnd())
            {
                //msDelay(2);
                rdLen = curFile->read(buf, 1024);
                emit sendDataToClient(buf, rdLen, 0, 0);

                sndDataCnt += rdLen;
                ui->lEdit_SndCnt->setText(QString::number(sndDataCnt, 10));
                ui->SndProgressBar->setValue(ui->SndProgressBar->value() + rdLen);
                QCoreApplication::processEvents(QEventLoop::AllEvents, 1);
            }
        } else {
            while(!curFile->atEnd())
            {
                // msDelay(2);
                rdLen = curFile->read(buf, 1024);
                emit sendDataToClient(buf, rdLen, tcpClientSocketDescriptorList.at(idx), 0);
                sndDataCnt += rdLen;
                ui->lEdit_SndCnt->setText(QString::number(sndDataCnt, 10));
                ui->SndProgressBar->setValue(ui->SndProgressBar->value() + rdLen);
                QCoreApplication::processEvents(QEventLoop::AllEvents, 1);
            }
        }
    } else if(ui->cBoxNetType->currentIndex() == TCP_CLIENT_MODE) {
        while(!curFile->atEnd())
        {
            rdLen = curFile->read(buf, 1024);
            tcpClientSocket->write(buf, rdLen);
            //更新发送数据计数器
            sndDataCnt += rdLen;
            ui->lEdit_SndCnt->setText(QString::number(sndDataCnt, 10));
            ui->SndProgressBar->setValue(ui->SndProgressBar->value() + rdLen);
            QCoreApplication::processEvents(QEventLoop::AllEvents, 1);
        }
    }

    ui->SndProgressBar->setVisible(false);
}
/**********************************************************/
//udp data received
void MainWindow::udpDataReceived()
{
    QHostAddress address;
    quint16 port;
    QString tmpIPPort = "";

    while(udpSocket->hasPendingDatagrams())
    {
        QByteArray datagram;
        datagram.resize(udpSocket->pendingDatagramSize());
        udpSocket->readDatagram(datagram.data(), datagram.size(), &address, &port);

        if(ui->StartRcvFile->checkState()) {
            char *buf;
            buf = datagram.data();
            if(curFile != 0) {
                curFile->write(buf, datagram.size());
            }
        } else {
            if(!ui->cBox_PauseShowRcv->checkState()) {
                tmpIPPort = address.toString() + ":" + QString::number(port, 10);
                QString rcvMsg  = QString::fromUtf8(datagram, datagram.size());
                if(CurIPPort != tmpIPPort) {
                    CurIPPort = tmpIPPort;
                    if(ui->ReceiveTextEdit->toPlainText().size() != 0) {
                        ui->ReceiveTextEdit->insertPlainText("\n");
                    }
                    ui->ReceiveTextEdit->insertPlainText(tr("【数据来自") + CurIPPort + tr("】\n"));
                }
                //显示数据接收时间
                if(ui->cBox_ShowRcvTime->checkState())    insertDateTimeInRcvDisp();

                //输出数据到接收显示区
                if(!ui->cBox_RcvHexDisp->checkState()) {             //显示字符串
                    ui->ReceiveTextEdit->insertPlainText(rcvMsg);
                } else {                                              //显示十六进制字符串
                    for(int i = 0; i < datagram.size(); i++) {
                        char ch = datagram.at(i);
                        QString tmpStr = "";
                        tmpStr.append(toHex[(ch & 0xf0) / 16]);
                        tmpStr.append(toHex[ch & 0x0f]);
                        tmpStr.append(" ");
                        ui->ReceiveTextEdit->insertPlainText(tmpStr);
                    }
                }
            }
        }
        rcvDataCnt += datagram.size();
        ui->lEdit_RcvCnt->setText(QString::number(rcvDataCnt, 10));
    }
}

/**********************************************************/
//clear the receive editor
void MainWindow::on_pBtnClearRcvDisp_clicked()
{
    ui->ReceiveTextEdit->clear();
}

/**********************************************************/
//reset the conters
void MainWindow::on_pBtnResetCnt_clicked()
{
    sndDataCnt = 0;
    rcvDataCnt = 0;

    ui->lEdit_RcvCnt->setText(QString::number(0, 10));
    ui->lEdit_SndCnt->setText(QString::number(0, 10));
}

/**********************************************************/
//UDP port changed PRC
void MainWindow::on_lEditUdpPort_textChanged(QString text)
{
    rmtPort = text.toInt();
}

/**********************************************************/
//UDP IP  Adderess changed PRC
void MainWindow::on_lEditUdpIP_textChanged(QString text)
{
    rmtAddr.setAddress(text);
}

/**********************************************************/
// TCP Client data received
void MainWindow::tcpClientDataReceived()
{
    while(tcpClientSocket->bytesAvailable() > 0)
    {
        QByteArray datagram;
        datagram.resize(tcpClientSocket->bytesAvailable());
        tcpClientSocket->read(datagram.data(), datagram.size());
        if(ui->StartRcvFile->checkState()) {
            char *buf;
            buf = datagram.data();
            if(curFile != 0) {
                curFile->write(buf, datagram.size());
            }
        } else {
            if(!ui->cBox_PauseShowRcv->checkState()) {
                QString rcvMsg  = QString::fromUtf8(datagram, datagram.size());
                QString tmpIPPort = ui->lEditIpAddr->text() + ":" + ui->lEditIpPort->text();
                if(CurIPPort != tmpIPPort) {
                    CurIPPort = tmpIPPort;
                    if(ui->ReceiveTextEdit->toPlainText().size() != 0) {
                        ui->ReceiveTextEdit->insertPlainText("\n");
                    }
                    ui->ReceiveTextEdit->insertPlainText(tr("【数据来自") + CurIPPort + tr("】\n"));
                }
                //显示数据接收时间
                if(ui->cBox_ShowRcvTime->checkState())   insertDateTimeInRcvDisp();
                //输出数据到接收显示区
                if(!ui->cBox_RcvHexDisp->checkState()) {           //显示字符串
                    ui->ReceiveTextEdit->insertPlainText(rcvMsg);
                } else {                                            //显示十六进制字符串
                    for(int i = 0; i < datagram.size(); i++) {
                        char ch = datagram.at(i);
                        QString tmpStr = "";
                        tmpStr.append(toHex[(ch & 0xf0) / 16]);
                        tmpStr.append(toHex[ch & 0x0f]);
                        tmpStr.append(" ");
                        ui->ReceiveTextEdit->insertPlainText(tmpStr);
                    }
                }
            }
        }

        rcvDataCnt += datagram.size();
        ui->lEdit_RcvCnt->setText(QString::number(rcvDataCnt, 10));
    }
}

void MainWindow::insertDateTimeInRcvDisp()
{
    int year, month, day;
    QDateTime::currentDateTime().date().getDate(&year, &month, &day);
    QString date = QString::number(year, 10) + "-" + QString::number(month, 10) + "-" + QString::number(day, 10);
    ui->ReceiveTextEdit->appendPlainText(tr("【") + date + tr(" ") + QDateTime::currentDateTime().time().toString() + tr("】"));
}

/**********************************************************/
bool MainWindow::slotTryCreateTcpServer()
{
    mtcpServer = new TcpServer(this);

    if(! mtcpServer->listen(lhAddr, lhPort))
    {
        return false;
        QMessageBox::information(this, tr("错误"), tr("尝试建立服务器失败! 请确认网络状态和端口。"));
    }

    connect(mtcpServer, SIGNAL(updateTcpServer(char*, int, int)), this, SLOT(tcpServerDataReceived(char*, int, int)));
    connect(this, SIGNAL(sendDataToClient(char*, int, int, int)), mtcpServer, SLOT(sendDataToClient(char*, int, int, int)));
    connect(mtcpServer, SIGNAL(addClientLink(QString, int)), this, SLOT(addClientLink(QString, int)));
    connect(mtcpServer, SIGNAL(removeClientLink(QString, int)), this, SLOT(removeClientLink(QString, int)));

    return true;
}

/**********************************************************/
void MainWindow::slotDeleteTcpServer()
{
    //disconnect(mtcpServer,SIGNAL(updateTcpServer(char*,int,int)),this,SLOT(tcpServerDataReceived(char*,int,int)));
    mtcpServer->disconnect();
    mtcpServer->close();
    delete  mtcpServer;
}

/**********************************************************/
void MainWindow::tcpServerDataReceived(char *msg, int length, int socketDescriptorEx)
{
    if(ui->StartRcvFile->checkState()) {    //保存接收数据到文件
        if(curFile != 0) {
            curFile->write(msg, length);
        }
    } else {                                                 //显示接收数据
        if(!ui->cBox_PauseShowRcv->checkState()) {
            int idx = tcpClientSocketDescriptorList.indexOf(socketDescriptorEx);
            QString tmpIPPort = ui->cBoxClients->itemText(idx);
            if(CurIPPort != tmpIPPort) {
                CurIPPort = tmpIPPort;
                if(ui->ReceiveTextEdit->toPlainText().size() != 0) {
                    ui->ReceiveTextEdit->insertPlainText("\n");
                }
                ui->ReceiveTextEdit->insertPlainText(tr("【数据来自") + CurIPPort + tr("】\n"));
            }
            //显示数据接收时间
            if(ui->cBox_ShowRcvTime->checkState())  insertDateTimeInRcvDisp();

            //输出数据到接收显示区
            if(!ui->cBox_RcvHexDisp->checkState()) { //显示字符串
                ui->ReceiveTextEdit->insertPlainText(msg);
            } else {                                                           //显示十六进制字符串
                for(int i = 0; i < length; i++) {
                    char ch = *(msg + i);
                    QString tmpStr = "";
                    tmpStr.append(toHex[(ch & 0xf0) / 16]);
                    tmpStr.append(toHex[ch & 0x0f]);
                    tmpStr.append(" ");
                    ui->ReceiveTextEdit->insertPlainText(tmpStr);
                }
            }
        }
    }
    //群聊功能控制，转发数据
    if(ui->cBox_chatMode->checkState()) {
        if(ui->cBox_echoMode->checkState()) {
            emit sendDataToClient(msg, length, 0, 0);
        } else {
            emit sendDataToClient(msg, length, 0, socketDescriptorEx);
        }
    }

    //数据接收计数器更新
    rcvDataCnt += length;
    ui->lEdit_RcvCnt->setText(QString::number(rcvDataCnt, 10));
}

/**********************************************************/
void MainWindow::addClientLink(QString clientAddrPort, int socketDescriptor)
{
    if(TcpClientLinkCnt == 0) {
        tcpClientSocketDescriptorList.clear();
        tcpClientSocketDescriptorList.append(0);
        ui->cBoxClients->addItem(tr("全部连接"));
    }
    TcpClientLinkCnt++;
    tcpClientSocketDescriptorList.append(socketDescriptor);
    ui->cBoxClients->addItem(clientAddrPort);
}

/**********************************************************/
void MainWindow::removeClientLink(QString clientAddrPort, int socketDescriptor)
{
    if(socketDescriptor != -1)
        return;
    if(TcpClientLinkCnt <= 1) {
        tcpClientSocketDescriptorList.clear();
        ui->cBoxClients->clear();
    } else {
        TcpClientLinkCnt--;
        int idx = ui->cBoxClients->findText(clientAddrPort);
        ui->cBoxClients->removeItem(idx);
        tcpClientSocketDescriptorList.removeAt(idx);
    }
}

/***********************************************/
//保存接收区的文本文件的内容到文件
void MainWindow::on_pBtnSaveRcvData_clicked()
{
    QString path = QFileDialog::getSaveFileName(this, tr("保存接收区内容到文本文件"), tr(""), tr("文本文件(*.txt)"));

    QFile saveFile(path);
    if(saveFile.open(QFile::WriteOnly | QIODevice::Truncate)) {
        QTextStream out(&saveFile);
        QString  str = ui->ReceiveTextEdit->toPlainText();
        out << str;
    }
    saveFile.close();
}

/***********************************************/
//开启定时自动发送功能
void MainWindow::on_cBoxLoopSnd_toggled(bool checked)
{
    if(checked) {
        timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), this, SLOT(toSendData()));
        int msInterval = ui->lEdit_Interval_ms->text().toInt();
        if(msInterval > 0) {
            timer->setInterval(ui->lEdit_Interval_ms->text().toInt());
        } else {
            ui->cBoxLoopSnd->setChecked(false);
            delete timer;
        }
    } else {
        timer->stop();
        delete timer;
        ui->pBtnSendData->setEnabled(true);
    }
}

/***********************************************/
//修改发送间隔时间
void MainWindow::on_lEdit_Interval_ms_editingFinished()
{
    int msInterval = ui->lEdit_Interval_ms->text().toInt();
    if(msInterval > 0) {
        timer->setInterval(ui->lEdit_Interval_ms->text().toInt());
    }
}

/***********************************************/
//清空发送区
void MainWindow::on_pBtnClearSndDisp_clicked()
{
    ui->tEditSendText->clear();
}

/***********************************************/
//载入文本文件到发送区
void MainWindow::on_pBtnLoadSndData_clicked()
{
    QString path = QFileDialog::getOpenFileName(this, tr("载入文本文件到发送区"));
    QFile file(path);
    QByteArray str;
    if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QMessageBox::information(this, tr("错误"), tr("打开文件失败。"));
        return ;
    } else {
        while(!file.atEnd()) {
            str = file.readLine();
            ui->tEditSendText->insertPlainText(str);
        }
    }
    file.close();
}

/***********************************************/
//接收数据转存到文件
void MainWindow::on_StartRcvFile_clicked(bool checked)
{
    if(checked) {
        QFileDialog *qfd = new QFileDialog(this);
        qfd->setViewMode(QFileDialog::List);
        qfd->setFileMode(QFileDialog::AnyFile);
        qfd->setWindowTitle(tr("建立接收文件"));
        // qfd->setFilter(tr("所有文件(*.*)"));         //qt4.8
        qfd->setNameFilter(tr("所有文件(*.*)"));  //qt5

        if(qfd->exec() == QDialog::Accepted)     //如果成功的执行
        {
            QStringList slist = qfd->selectedFiles();
            CurPath = slist[0];
            curFile = new QFile(CurPath);

            if(!curFile->open(QFile::WriteOnly | QIODevice::Truncate)) {
                //打开文件失败
                ui->StartRcvFile->setChecked(false);
                return;
            }
            ui->ReceiveTextEdit->setPlainText(tr("接收数据保存到文件：\n") + CurPath + "\n");
            on_pBtnResetCnt_clicked();
        } else {
            ui->StartRcvFile->setChecked(false);
            return;
        }
    } else {
        ui->ReceiveTextEdit->clear();
        if(curFile) curFile->close();
        if(curFile) delete curFile;
    }
}

/***********************************************/
//发送数据源为文件
void MainWindow::on_cBoxStartSndFile_clicked(bool checked)
{
    if(checked) {
        QFileDialog *qfd = new QFileDialog(this);
        qfd->setViewMode(QFileDialog::List);
        qfd->setFileMode(QFileDialog::AnyFile);
        qfd->setWindowTitle(tr("选择发送文件"));
        // qfd->setFilter(tr("所有文件(*.*)"));            //qt4.8
        qfd->setNameFilter(tr("所有文件(*.*)"));   //qt5

        if(qfd->exec() == QDialog::Accepted)     //如果成功的执行
        {
            QStringList slist = qfd->selectedFiles();
            CurPath = slist[0];
            curFile = new QFile(CurPath);

            if(!curFile->open(QFile::ReadOnly | QIODevice::Truncate)) {
                //打开文件失败
                ui->cBoxStartSndFile->setChecked(false);
                return;
            }
            ui->ReceiveTextEdit->setPlainText(tr("从文件发送数据：\n") + CurPath + tr("\n"));
        } else {
            ui->cBoxStartSndFile->setChecked(false);
            return;
        }
    } else {
        ui->ReceiveTextEdit->clear();
        if(curFile) curFile->close();
        if(curFile) delete curFile;
    }
}

/***********************************************/
//发送区以十六进制与字符串间切换
void MainWindow::on_cBox_SndHexDisp_clicked(bool checked)
{
    QByteArray datagram;
    if(checked) {
        if(ui->tEditSendText->toPlainText().length() != 0) {
            datagram = ui->tEditSendText->toPlainText().toLocal8Bit();
            ui->tEditSendText->clear();
            for(int i = 0; i < datagram.size(); i++) {
                char ch = datagram.at(i);
                QString tmpStr = QString::number(ch, 16);
                ui->tEditSendText->insertPlainText(tmpStr + " ");
            }
        }
    } else {
        if(ui->tEditSendText->toPlainText().length() != 0) {
            QStringList hexStr = ui->tEditSendText->toPlainText().split(" ", QString::SkipEmptyParts);
            int hexSize = hexStr.size();
            qDebug() << QString::number(hexSize, 10);
            for(int i = 0; i < hexSize; i++) {
                QString hexSubStr = hexStr.at(i);
                datagram.append(ConvertHexStr(hexSubStr));
            }
            ui->tEditSendText->clear();
            QString msg = datagram.data();
            ui->tEditSendText->setPlainText(msg);
        }
    }
}

/***********************************************/
//转化十六进制中的字符到ASCII
char MainWindow::ConvertHexChar(char ch)
{
    if((ch >= '0') && (ch <= '9'))
        return ch - 0x30;
    else if((ch >= 'A') && (ch <= 'F'))
        return ch - 'A' + 10;
    else if((ch >= 'a') && (ch <= 'f'))
        return ch - 'a' + 10;
    else return (-1);
}

/***********************************************/
//转化十六进制字符到ASCII字母
char MainWindow::ConvertHexStr(QString hexSubStr)
{
    char ch = 0;
    if(hexSubStr.length() == 2) {
        // ch =  ConvertHexChar(hexSubStr.at(0).toAscii())*16+ ConvertHexChar(hexSubStr.at(1).toAscii()); //qt4.8
        ch =  ConvertHexChar(hexSubStr.at(0).toLatin1()) * 16 + ConvertHexChar(hexSubStr.at(1).toLatin1());
    } else if(hexSubStr.length() == 1) {
        //ch =  ConvertHexChar(hexSubStr.at(0).toAscii());  //qt4.8
        ch =  ConvertHexChar(hexSubStr.at(0).toLatin1());
    }
    return ch;
}

/***********************************************/
//毫秒级延时
void MainWindow::msDelay(unsigned int msec)
{
    QTime dieTime = QTime::currentTime().addMSecs(msec);
    while(QTime::currentTime() < dieTime)
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1);
}

void MainWindow::on_actionEnglish_triggered()
{
    translator.load(":/language/English.qm");
    qApp->installTranslator(&translator);
    ui->retranslateUi(this);
}

void MainWindow::on_actionChinese_triggered()
{
    translator.load(":/language/Chinese.qm");
    qApp->installTranslator(&translator);
    ui->retranslateUi(this);
}