Qt字符转换、文件操作、加密、电脑操作

置顶今汐我大老婆

已于 2024-01-29 10:18:32 修改

阅读量534

点赞数

文章标签： qt c++ 开发语言

于 2022-06-08 15:20:39 首次发布

本文链接：https://blog.csdn.net/weixin_46246664/article/details/125184407

版权

文章目录

前言
- 1.fhelper.h
- 2.fhelper .cpp

前言

记录下Qt下常用的一些字符串格式转换和对文件的操作以及简单的加密算法。

提示：以下是本篇文章正文内容，下面案例可供参考

1.fhelper.h

代码如下（示例）：

#ifndef FHELPER_H
#define FHELPER_H

#include <QDir>
#include <QMap>
#include <QFile>
#include <QTime>
#include <QLine>
#include <QLabel>
#include <QColor>
#include <QMovie>
#include <QDebug>
#include <QTimer>
#include <QScreen>
#include <QDialog>
#include <QObject>
#include <QWidget>
#include <QBitmap>
#include <QSpinBox>
#include <QPolygon>
#include <QPalette>
#include <QPainter>
#include <QSqlError>
#include <QSqlQuery>
#include <QComboBox>
#include <QCheckBox>
#include <QAxObject>
#include <QKeyEvent>
#include <QLineEdit>
#include <QDirModel>
#include <QDateTime>
#include <QSettings>
#include <QDateEdit>
#include <QSqlRecord>
#include <QTableView>
#include <QEventLoop>
#include <QTcpSocket>
#include <QCompleter>
#include <QTextCodec>
#include <QUdpSocket>
#include <QHeaderView>
#include <QTreeWidget>
#include <QTranslator>
#include <QMessageBox>
#include <QMouseEvent>
#include <QSerialPort>
#include <QSpacerItem>
#include <QPushButton>
#include <QGridLayout>
#include <QFontDialog>
#include <QWheelEvent>
#include <QModelIndex>
#include <QPaintEvent>
#include <QToolButton>
#include <QScrollArea>
#include <QSqlDatabase>
#include <QProgressBar>
#include <QTableWidget>
#include <QHostAddress>
#include <QColorDialog>
#include <QApplication>
#include <QDateTimeEdit>
#include <QStyleFactory>
#include <QJsonDocument>
#include <QSplashScreen>
#include <QElapsedTimer>
#include <QMdiSubWindow>
#include <QSqlTableModel>
#include <QSqlQueryModel>
#include <QDesktopWidget>
#include <QStackedWidget>
#include <QModelIndexList>
#include <QGuiApplication>
#include <QJsonParseError>
#include <QLinearGradient>
#include <QCalendarWidget>
#include <QDesktopServices>
#include <QCoreApplication>
#include <QDataWidgetMapper>
#include <QNetworkInterface>
#include <QStandardItemModel>
#include <QPropertyAnimation>
#include <QStyledItemDelegate>
#include <QParallelAnimationGroup>
#include <QtSerialPort/QSerialPort>
#include <QGraphicsDropShadowEffect>
#include <QAbstractNativeEventFilter>
#include <QtSerialPort/QSerialPortInfo>
#include <QtConcurrent>
//注册不可识别的参数需要的头文件
#include <QMetaType>

#ifdef Q_OS_WIN
#include "Windows.h"
#endif

#pragma comment(lib, "dwmapi")
#pragma comment(lib,"user32.lib")
#include <qmath.h>
#include <dwmapi.h>
#include <windowsx.h>

class FHelper
{
public:
    //创建文件夹
    QString mkMutiDir(const QString path);
    //获取串口名和描述
    QStringList Get_SerialPortNumber();
    //获取串口名
    QStringList Get_SerialPortName();
    //设置为开机启动
    static void AutoRunWithSystem(bool IsAutoRun, QString AppName, QString AppPath);
    //设置编码
    static void SetCodeFormat(const char *codeFormat);
    //设置为简体中文字符
    static void setChineseSimp();
    //设置为繁体中文字符
    static void setChineseTrad();
    //设置为英文字符
    static void setEnglish();
    //设置皮肤样式 strSkinFileName 皮肤样式表文件名(包含路径)
    static void SetSkin(QString strSkinFileName = Q_NULLPTR, QWidget *widget = Q_NULLPTR);
    //获取qss文件内容
    static QString getQssFromFile(QString filename);
    //读取文件
    static QString readFile(const QString filename);
    //判断是否是IP 地址
    static bool IsIP(QString IP);
    //字符串转16进制字节数组
    QByteArray QString2Hex(QString str);
    //16进制字符串转字节数组
    static QByteArray HexStrToByteArray(QString str);
    static char ConvertHexChar(char ch);
    //字节数组转16进制字符串 中间添加空格
    static QString ByteArrayToHexStr(QByteArray data);
    //字节数组转16进制字符串 不添加空格
    static QString ByteArrayToHexStr2(QByteArray data);
    //字符串2个长度添加1个字符
    static QString strAddChar(QString str, QChar sep = ' ');
    //字符串转16进制字符串
    static QString StrToHexStr(QString str, int nBytes = 0);
    //16进制字符串转字符串
    static QString StrHexToStr(QString str);
    //16进制字符串转10进制
    static int StrHexToDecimal(QString strHex);
    //10进制字符串转10进制
    static int StrDecimalToDecimal(QString strDecimal);
    //2进制字符串转10进制
    static int StrBinToDecimal(QString strBin);
    //10进制字符串转2进制数字
    static int StrDecimalToBin(QString strDecimal);
    //10进制转2进制字符串
    static QString DecimalToStrBin(int decimal, int nBytes = 1);
    //16进制字符串转2进制字符串
    static QString StrHexToStrBin(QString strHex);
    //2进制字符串转16进制字符串 11111111->FF
    static QString StrBinToStrHex(QString strBin);
    //10进制转16进制字符串,补零.needCount需要返回的长度
    static QString DecimalToStrHex(int decimal, int needCount = 2);
    //qreal 10进制转16进制字符串,补零.needCount需要返回的长度	0 <= dDecimal <=1的小数
    static QString qrealDecimalToStrHex(qreal dDecimal, int needCount = 2);
    //字符串列表转Latin1字符串列表
    static QStringList StrListToLatinStrList(const QStringList strList);
    //字节数组转Ascii字符串
    static QString ByteArrayToAsciiStr(QByteArray data);
    //Ascii字符串转字节数组
    static QByteArray AsciiStrToByteArray(QString str);
    //截取中英文混合字符串的指定字节长度内容
    static QString getLimitString(QString str, int nBytes);
    //延时 至少100ms
    static void Sleep(int nMSecs);
    //延时精确到ms
    static void Sleep2(int nMSecs);
    //设置系统日期时间
    static void SetSystemDateTime(int year, int month, int day, int hour, int min, int sec);
    //窗体居中显示
    static void FormInCenter(QWidget *frm, int nParentWidth = 0, int nParentHeigth = 0);
    //窗体居中显示
    static void CenterWindow(QWidget &frm, QWidget *Center = nullptr);
    //获取选择的文件
    static QString GetFileName(QString filter);
    //获取选择的文件集合
    static QStringList GetFileNames(QString filter);
    //获取选择的目录
    static QString GetFolderName();
    //获取文件名,含拓展名
    static QString GetFileNameWithExtension(QString strFilePath);
    //获取选择资料库中的文件
    static QStringList GetFolderFileNames(QStringList filter);
    //资料库是否存在
    static bool FolderIsExist(QString strFolder);
    //文件是否存在
    static bool FileIsExist(QString strFile);
    //复制文件
    //static bool CopyFile(QString sourceFile, QString targetFile);
    /********************************************************************************
    clearFiles():仅清空文件夹内的文件(不包括子文件夹内的文件)
    folderFullPath:文件夹全路径
    *********************************************************************************/
    static void clearFiles(const QString &folderFullPath);
    /********************************************************************************
    clearFolder():删除非空文件夹
    folderFullPath:文件夹全路径
    *********************************************************************************/
    static void clearFolder(const QString &folderFullPath);
    //异或加密算法
    static QString getXorEncryptDecrypt(QString str, char key);
    //MD5加密
    static QString CryptoQstring(QString str);
    //ping IP
    static bool Ping(QString Addr, int timeout = 3000);
    static bool Ping(QString Addr, int interval, int n);
    //检查IP和对应端口是否通畅
    static bool DeviceOnLine(QString Addr, int port = 80, int timeout = 3000);
    //获取电脑MAC
    static QString getHostMacAddress();
    //获取电脑IP
    static QString getHostIpAddress();
    //获取电脑IP对应的子网掩码
    static QString getBroadcastAddress(QString ip, QString subnetMask);
    static void strToCharArray(char* _Destination, const QString &_Source, int _SizeInBytes = 100);		//QString转char*
    static QColor initialItemColor(int nIndex, int nCount);
    static QString addCommand(QString);
    static bool DeleteDirectory(const QString &);
    /*
     * 生成 [ 0 - nMax ]范围内不重复的数据 nCount 个
     * 注意， nMax 不小于 nCount
     *
     */
    static QList<int> getRandom(int nCount, int nMax = 255);

    /*
     * 生成 [ 0 - nMax ]范围内不重复的数据 nCount 个，转十六进制字符串
     * 注意， nMax 不小于 nCount
     *
     */
    static QString getRandomStrHex(int nCount, int nMax = 255);
    static int getJpegBitDepth(const QString &imagePath);
    static void WriteToCSV(QWidget *parent, QString savefileName, QTableView *tableView);
    static QList<QStringList> ReadFromCSV(QString PathName);
};
#endif // FHELPER_H

2.fhelper .cpp

代码如下（示例）：

#include "fhelper.h"

//创建文件夹
QString FHelper::mkMutiDir(const QString path)
{
    QDir dir(path);
    if ( dir.exists(path))
    {
        return path;
    }
    QString parentDir = mkMutiDir(path.mid(0,path.lastIndexOf('/')));
    QString dirname = path.mid(path.lastIndexOf('/') + 1);
    QDir parentPath(parentDir);
    if ( !dirname.isEmpty() )
        parentPath.mkpath(dirname);
    return parentDir + "/" + dirname;
}

//获取串口名和描述
QStringList FHelper::Get_SerialPortNumber()
{
    QStringList SerialPortNumberlist;

    //实例化一个类型参数为QSerialPortInfo模板类链表
    QList<QSerialPortInfo> serialList;
    //给链表赋值为获取到的当前设备的所有串口信息的链表
    serialList = QSerialPortInfo::availablePorts();
    if(serialList.isEmpty())
        return SerialPortNumberlist;
    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
    {
        QSerialPort serial;
        serial.setPort(info);
        if (serial.open(QIODevice::ReadWrite))
        {
            SerialPortNumberlist.append(serial.portName() + " " + serialList.first().description());
            serial.close();
        }
    }
    //输出链表头节点的一些信息
    return SerialPortNumberlist;
}

//获取串口名
QStringList FHelper::Get_SerialPortName()
{
    QStringList SerialPortNumberlist;
    SerialPortNumberlist.clear();
    //实例化一个类型参数为QSerialPortInfo模板类链表
    QList<QSerialPortInfo> serialList;
    //给链表赋值为获取到的当前设备的所有串口信息的链表
    serialList = QSerialPortInfo::availablePorts();
    if(serialList.isEmpty())
        return SerialPortNumberlist;
    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
    {
        QSerialPort serial;
        serial.setPort(info);
        if (serial.open(QIODevice::ReadWrite))
        {
            SerialPortNumberlist.append(serialList.first().portName());
            serial.close();
        }
    }
    return SerialPortNumberlist;
}

//设置为开机启动
void FHelper::AutoRunWithSystem(bool IsAutoRun, QString AppName, QString AppPath) {
    QSettings reg("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat);
    if (IsAutoRun)
        reg.setValue(AppName, AppPath);
    else
        reg.setValue(AppName, "");
}

//设置编码
void FHelper::SetCodeFormat(const char *codeFormat) {
#if (QT_VERSION <= QT_VERSION_CHECK(5,0,0))
#if _MSC_VER
    QTextCodec *codec = QTextCodec::codecForName("gbk");
#else
    QTextCodec *codec = QTextCodec::codecForName("utf-8");
#endif
    QTextCodec::setCodecForLocale(codec);
    QTextCodec::setCodecForCStrings(codec);
    QTextCodec::setCodecForTr(codec);
#else
    QTextCodec *codec = QTextCodec::codecForName(codeFormat);
    QTextCodec::setCodecForLocale(codec);
#endif
}

//设置为简体中文字符
void FHelper::setChineseSimp()
{
    QTranslator *translatorSys = new QTranslator(qApp);
    translatorSys->load(":/Lang/qt_zh_cn");
    qApp->installTranslator(translatorSys);
    QTranslator *translatorWidgets = new QTranslator(qApp);
    translatorWidgets->load(":/Lang/widgets_zh_cn");
    qApp->installTranslator(translatorWidgets);
    QTranslator *translatorQFramer = new QTranslator(qApp);
    translatorQFramer->load(":/Framer/framer_zh_cn");
    qApp->installTranslator(translatorQFramer);
    QTranslator *translatorApp = new QTranslator(qApp);
    translatorApp->load(QString(":/App/%1_zh_cn").arg(QCoreApplication::applicationName()));
    qApp->installTranslator(translatorApp);
    QFont font;
    font.setFamily("思源黑体 Arial");
    font.setPixelSize(12);
    qApp->setFont(font);
}

//设置为繁体中文字符
void FHelper::setChineseTrad()
{
    QTranslator *translatorSys = new QTranslator(qApp);
    translatorSys->load(":/Framer/qt_zh_tw");
    qApp->installTranslator(translatorSys);
    QTranslator *translatorWidgets = new QTranslator(qApp);
    translatorWidgets->load(":/Framer/widgets_zh_tw");
    qApp->installTranslator(translatorWidgets);
    QTranslator *translatorQFramer = new QTranslator(qApp);
    translatorQFramer->load(":/Framer/framer_zh_tw");
    qApp->installTranslator(translatorQFramer);
    QTranslator *translatorApp = new QTranslator(qApp);
    translatorApp->load(QString(":/App/%1_zh_tw").arg(QCoreApplication::applicationName()));
    qApp->installTranslator(translatorApp);
    QFont font;
    font.setFamily("思源黑体 Arial");
    font.setPixelSize(12);
    qApp->setFont(font);
}

//设置为英文字符
void FHelper::setEnglish()
{
    QTranslator *translatorQFramer = new QTranslator(qApp);
    translatorQFramer->load(":/Lang/framer_en_us");
    qApp->installTranslator(translatorQFramer);
    QTranslator *translatorApp = new QTranslator(qApp);
    translatorApp->load(QString(":/Lang/%1_en_us").arg(QCoreApplication::applicationName()));
    qApp->installTranslator(translatorApp);
    QFont font;
    font.setFamily("思源黑体 Arial");
    font.setPixelSize(12);
    qApp->setFont(font);
}

//设置皮肤样式
/*
    *strSkinFileName 皮肤样式表文件名(包含路径)
*/
void FHelper::SetSkin(QString strSkinFileName, QWidget *widget)
{
    if (strSkinFileName.isEmpty())
        strSkinFileName = QString("skin/qss/Blue.qss");
    QString qss = getQssFromFile(strSkinFileName);
    if (widget)
        widget->setStyleSheet(qss);
    else
        qApp->setStyleSheet(qss);
}

//获取qss文件内容
QString FHelper::getQssFromFile(QString filename)
{
    QFile f(filename);
    QString qss = "";
    if (f.open(QFile::ReadOnly))
    {
#if (QT_VERSION <= QT_VERSION_CHECK(5,0,0))
        qss = QLatin1String(f.readAll());
#else
        qss = QString::fromLatin1(f.readAll());
#endif
        f.close();
    }
    return qss;
}

//读取文件
QString FHelper::readFile(const QString filename)
{
    QFile f(filename);
    if (!f.open(QFile::ReadOnly | QFile::Text)) {
        return QString();
    }
    else {
        QTextStream in(&f);
        return in.readAll();
    }
}
//删除文件夹
bool FHelper::DeleteDirectory(const QString &path)
{
    if (path.isEmpty())
    {
        return false;
    }
    QDir dir(path);
    if (!dir.exists())
    {
        return true;
    }
    dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
    QFileInfoList fileList = dir.entryInfoList();
    foreach(QFileInfo fi, fileList)
    {
        if (fi.isFile())
        {
            fi.dir().remove(fi.fileName());
        }
        else
        {
            DeleteDirectory(fi.absoluteFilePath());
        }
    }
    return dir.rmpath(dir.absolutePath());
}
//判断是否是IP 地址
bool FHelper::IsIP(QString IP) {
    QRegExp RegExp("((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)");
    return RegExp.exactMatch(IP);
}

//字符串转16进制字节数组
QByteArray FHelper::QString2Hex(QString str)
{
    QByteArray senddata;
    int hexdata,lowhexdata;
    int hexdatalen = 0;
    int len = str.length();
    senddata.resize(len/2);
    char lstr,hstr;
    for(int i=0; i<len; )
    {
        hstr=str[i].toLatin1();
        if(hstr == ' ')
        {
            i++;
            continue;
        }
        i++;
        if(i >= len)
        break;
        lstr = str[i].toLatin1();
        hexdata = ConvertHexChar(hstr);
        lowhexdata = ConvertHexChar(lstr);
        if((hexdata == 16) || (lowhexdata == 16))
            break;
        else
            hexdata = hexdata*16+lowhexdata;
        i++;
        senddata[hexdatalen] = (char)hexdata;
        hexdatalen++;
    }
    senddata.resize(hexdatalen);
    return senddata;
}

//16进制字符串转字节数组
QByteArray FHelper::HexStrToByteArray(QString str) {
    QByteArray senddata;
    int hexdata, lowhexdata;
    int hexdatalen = 0;
    int len = str.length();
    senddata.resize(len / 2);
    char lstr, hstr;
    for (int i = 0; i < len; ) {
        hstr = str[i].toLatin1();
        if (hstr == ' ') {
            i++;
            continue;
        }
        i++;
        if (i >= len) {
            break;
        }
        lstr = str[i].toLatin1();
        hexdata = ConvertHexChar(hstr);
        lowhexdata = ConvertHexChar(lstr);
        if ((hexdata == 16) || (lowhexdata == 16)) {
            break;
        }
        else {
            hexdata = hexdata * 16 + lowhexdata;
        }
        i++;
        senddata[hexdatalen] = (char)hexdata;
        hexdatalen++;
    }
    senddata.resize(hexdatalen);
    return senddata;
}

char FHelper::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);
    }
}

QString FHelper::strAddChar(QString str, QChar sep)
{
    QString temp = "";
    for (int i = 0; i < str.length(); i += 2) {
        temp.append(str.mid(i, 2));
        temp.append(sep);
    }
    temp.chop(1);       //移除最后添加的一个sep
    return temp;
}

//字节数组转16进制字符串
QString FHelper::ByteArrayToHexStr(QByteArray data) {
    QString strHex = data.toHex();
    strHex = strAddChar(strHex);
    return strHex.trimmed().toUpper();
}

//字节数组转16进制字符串
QString FHelper::ByteArrayToHexStr2(QByteArray data)
{
    QString strHex = data.toHex();
    return strHex.trimmed().toUpper();
}

//字符串转16进制字符串
QString FHelper::StrToHexStr(QString str, int nBytes)
{
    QString strHex;
    QByteArray byteArrayTemp = str.toLocal8Bit();
    strHex = FHelper::ByteArrayToHexStr2(byteArrayTemp);
    if (nBytes == 0)
        return strHex;
    strHex = strHex.right(nBytes * 2);
    while (strHex.length() < nBytes * 2)
        strHex += "00";
    return strHex;
}

//16进制字符串转字符串
QString FHelper::StrHexToStr(QString str)
{
    QByteArray byteArrayTemp = FHelper::HexStrToByteArray(str);
    return QString::fromLocal8Bit(byteArrayTemp);
}

//16进制字符串转10进制
int FHelper::StrHexToDecimal(QString strHex) {
    int nRtn = 0;
    QByteArray byteArray = HexStrToByteArray(strHex);
    int nSize = byteArray.size();
    for (int i = 0; i < nSize; i++)
        nRtn |= (unsigned char)byteArray[i] << (8 * (nSize - i - 1));
    return nRtn;
}

//10进制字符串转10进制
int FHelper::StrDecimalToDecimal(QString strDecimal) {
    bool ok;
    return strDecimal.toInt(&ok, 10);
}

//2进制字符串转10进制
int FHelper::StrBinToDecimal(QString strBin) {
    bool ok;
    return strBin.toInt(&ok, 2);
}

int FHelper::StrDecimalToBin(QString strDecimal)
{
    return QString::number(strDecimal.toInt(),2).toInt();
}

//16进制字符串转2进制字符串
QString FHelper::StrHexToStrBin(QString strHex) {
    uchar decimal = StrHexToDecimal(strHex);
    QString bin = QString::number(decimal, 2);
    uchar len = bin.length();
    if (len < 8) {
        for (int i = 0; i < 8 - len; i++) {
            bin = "0" + bin;
        }
    }
    return bin;
}

//2进制字符串转16进制字符串 11111111->FF
QString FHelper::StrBinToStrHex(QString strBin)
{
    while (strBin.size() < 8)
        strBin = "0" + strBin;
    int x = strBin.at(0).digitValue() * 128 + strBin.at(1).digitValue() * 64 + strBin.at(2).digitValue() * 32 + strBin.at(3).digitValue() * 16\
        + strBin.at(4).digitValue() * 8 + strBin.at(5).digitValue() * 4 + strBin.at(6).digitValue() * 2 + strBin.at(7).digitValue();
    return FHelper::DecimalToStrHex(x);
}

//10进制转2进制字符串
QString FHelper::DecimalToStrBin(int decimal, int nBytes)
{
    QString strBin = QString::number(decimal, 2).right(nBytes * 8);
    while (strBin.length() < nBytes * 8)
        strBin.prepend('0');
    return strBin;
}

//10进制转16进制字符串,补零,
QString FHelper::DecimalToStrHex(int decimal, int needCount)
{
    QString temp = QString::number(decimal, 16);
    temp = temp.right(needCount);
    while (temp.length() < needCount)
        temp = "0" + temp;
    return temp;
}

QString FHelper::qrealDecimalToStrHex(qreal dDecimal, int needCount)
{
    unsigned int nDecimal = qRound(dDecimal * qPow(2, 15));
    QString temp = QString::number(nDecimal, 16);
    bool ok;
    temp.toInt(&ok, -16);
    if (nDecimal < 0)
        temp = temp.right(needCount);
    int len = needCount - temp.length();
    while (len > 0 && len--)
    {
        temp = "0" + temp;
    }
    return temp;
}

QStringList FHelper::StrListToLatinStrList(const QStringList strList)
{
    QStringList strList2;
    foreach(const QString str, strList)
        strList2.append(str.toLatin1());
    return strList2;
}

//延时ms
void FHelper::Sleep(int nMSecs) {
    QTime dieTime = QTime::currentTime().addMSecs(nMSecs);
    while (QTime::currentTime() < dieTime) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 10);
    }
}

//延时ms
void FHelper::Sleep2(int nMSecs) {
    QMutex mutex;
    QWaitCondition sleep;
    mutex.lock();
    sleep.wait(&mutex, nMSecs);
    mutex.unlock();
}

//设置系统日期时间
void FHelper::SetSystemDateTime(int year, int month, int day, int hour, int min, int sec)
{
#ifdef Q_OS_WIN
    QProcess p(0);
    p.start("cmd");
    p.waitForStarted();
    p.write(QString("date %1-%2-%3\n").arg(year).arg(month).arg(day).toLatin1());
    p.closeWriteChannel();
    p.waitForFinished(1000);
    p.close();
    p.start("cmd");
    p.waitForStarted();
    p.write(QString("time %1:%2:%3.00\n").arg(hour).arg(min).arg(sec).toLatin1());
    p.closeWriteChannel();
    p.waitForFinished(1000);
    p.close();
#else
    QString cmd = QString("date %1%2%3%4%5.%6").arg(month).arg(day).arg(hour).arg(min).arg(year).arg(sec);
    system(cmd.toLatin1());
    system("hwclock -w");
#endif
}

//窗体居中显示
void FHelper::FormInCenter(QWidget *frm, int nParentWidth /*= 0*/, int nParentHeigth /*= 0*/)
{
    int nWidth = frm->width();
    int nHieght = frm->height();
    QWidget *parentWin;
    if (frm->parentWidget())
        parentWin = frm->parentWidget();
    else
        parentWin = QApplication::desktop();

    if (nParentWidth == 0 && nParentHeigth == 0){
        nParentWidth = parentWin->width();
        nParentHeigth = parentWin->height();
    }
    int x = qRound((nParentWidth - nWidth) / 2.0);
    int y = qRound((nParentHeigth - nHieght) / 2.0);
    QPoint movePoint(qAbs(x), qAbs(y));
    frm->move(movePoint);
}

void FHelper::CenterWindow(QWidget &frm, QWidget *Center)
{
    int nWidth = frm.width();
    int nHieght = frm.height();
    QWidget *parentWin;
    if (Center != nullptr)
        parentWin = Center;
    else
        parentWin = QApplication::desktop();
    int nParentWidth = parentWin->width();
    int nParentHeigth = parentWin->height();
    int x = qRound((nParentWidth - nWidth) / 2.0);
    int y = qRound((nParentHeigth - nHieght) / 2.0);
    QPoint movePoint(qAbs(x), qAbs(y));
    frm.move(movePoint);
}

//获取选择的文件
QString FHelper::GetFileName(QString filter) {
    return QFileDialog::getOpenFileName(0, "选择文件", QCoreApplication::applicationDirPath(), filter);
}

//获取选择的文件集合
QStringList FHelper::GetFileNames(QString filter) {
    return QFileDialog::getOpenFileNames(0, "选择文件", QCoreApplication::applicationDirPath(), filter);
}

//获取选择的目录
QString FHelper::GetFolderName() {
    return QFileDialog::getExistingDirectory();
}

//获取文件名,含拓展名
QString FHelper::GetFileNameWithExtension(QString strFilePath) {
    QFileInfo fileInfo(strFilePath);
    return fileInfo.fileName();
}

//获取选择资料库中的文件
QStringList FHelper::GetFolderFileNames(QStringList filter) {
    QStringList fileList;
    QString strFolder = QFileDialog::getExistingDirectory();
    if (!strFolder.length() == 0) {
        QDir myFolder(strFolder);
        if (myFolder.exists()) {
            fileList = myFolder.entryList(filter);
        }
    }
    return fileList;
}

//资料库是否存在
bool FHelper::FolderIsExist(QString strFolder) {
    QDir tempFolder(strFolder);
    return tempFolder.exists();
}

//文件是否存在
bool FHelper::FileIsExist(QString strFile) {
    QFile tempFile(strFile);
    return tempFile.exists();
}

void FHelper::clearFolder(const QString &folderFullPath)
{
    QDir             dir(folderFullPath);
    QFileInfoList    fileList;
    QFileInfo        curFile;
    QFileInfoList    fileListTemp;
    int				 infoNum;
    int				 i;
    int				 j;
    /* 首先获取目标文件夹内所有文件及文件夹信息 */
    fileList = dir.entryInfoList(QDir::Dirs | QDir::Files
        | QDir::Readable | QDir::Writable
        | QDir::Hidden | QDir::NoDotAndDotDot
        , QDir::Name);

    while (fileList.size() > 0)
    {
        infoNum = fileList.size();

        for (i = infoNum - 1; i >= 0; i--)
        {
            curFile = fileList[i];
            if (curFile.isFile()) /* 如果是文件，删除文件 */
            {
                QFile fileTemp(curFile.filePath());
                fileTemp.remove();
                fileList.removeAt(i);
            }

            if (curFile.isDir()) /* 如果是文件夹 */
            {
                QDir dirTemp(curFile.filePath());
                fileListTemp = dirTemp.entryInfoList(QDir::Dirs | QDir::Files
                    | QDir::Readable | QDir::Writable
                    | QDir::Hidden | QDir::NoDotAndDotDot
                    , QDir::Name);
                if (fileListTemp.size() == 0) /* 下层没有文件或文件夹 则直接删除*/
                {
                    dirTemp.rmdir(".");
                    fileList.removeAt(i);
                }
                else /* 下层有文件夹或文件 则将信息添加到列表*/
                {
                    for (j = 0; j < fileListTemp.size(); j++)
                    {
                        if (!(fileList.contains(fileListTemp[j])))
                        {
                            fileList.append(fileListTemp[j]);
                        }
                    }
                }
            }
        }
    }
    dir.rmdir(".");/*删除目标文件夹,如果只是清空文件夹folderFullPath的内容而不删除folderFullPath本身,则删掉本行即可*/
}

void FHelper::clearFiles(const QString &folderFullPath)
{
    QDir dir(folderFullPath);
    dir.setFilter(QDir::Files);
    int fileCount = dir.count();
    for (int i = 0; i < fileCount; i++)
        dir.remove(dir[i]);
}

//异或加密算法
QString FHelper::getXorEncryptDecrypt(QString str, char key) {
    QByteArray data = str.toLatin1();
    int size = data.size();
    for (int i = 0; i < size; i++) {
        data[i] = data[i] ^ key;
    }
    return QLatin1String(data);
}

QString FHelper::CryptoQstring(QString str)
{
    QByteArray hash_byte_array = QCryptographicHash::hash(str.toLatin1(), QCryptographicHash::Md5);
    QString md5 = hash_byte_array.toHex();
    return md5;
}

bool FHelper::Ping(QString Addr, int timeout)
{
    QProcess *cmd = new QProcess;
    cmd->start(QString("ping %1").arg(Addr));
    Sleep2(100);
    // 等待ping 的结果
    while (cmd->waitForReadyRead(timeout))
    {
        QString readData = cmd->readAll();
        if (readData.contains("TTL")) {
            return true;
        }
    }
    return false;
}

bool FHelper::Ping(QString Addr, int timeout, int n)
{
    bool bReturn = true;
    QString cmd = "ping %1 -n 1";
    // 等待ping 的结果
    int i = 0;
    while (i < n)
    {
        if (QProcess::execute(cmd.arg(Addr)) == 0) {
            break;
        }
        i++;
        Sleep(timeout);
    }
    if (i == n)
        bReturn = false;
    return bReturn;
}
//检查IP和对应端口是否通畅
bool FHelper::DeviceOnLine(QString Addr, int port, int timeout)
{
    QTcpSocket tcpClient;
    tcpClient.abort();
    tcpClient.connectToHost(Addr, port);
    //timeout毫秒没有连接上则判断该设备不在线
    bool ok = tcpClient.waitForConnected(timeout);
    return ok;
}

QString FHelper::getHostMacAddress()
{
    QList<QNetworkInterface> nets = QNetworkInterface::allInterfaces();// 获取所有网络接口列表
    int nCnt = nets.count();
    QString strMacAddr = "";
    for (int i = 0; i < nCnt; i++)
    {
        // 如果此网络接口被激活并且正在运行并且不是回环地址，则就是我们需要找的Mac地址
        if (nets[i].flags().testFlag(QNetworkInterface::IsUp) && nets[i].flags().testFlag(QNetworkInterface::IsRunning) && !nets[i].flags().testFlag(QNetworkInterface::IsLoopBack))
        {
            strMacAddr = nets[i].hardwareAddress();
            break;
        }
    }
    return strMacAddr;
}

QString FHelper::getHostIpAddress()
{
    QString strIpAddress;
    QList<QHostAddress> ipAddressesList = QNetworkInterface::allAddresses();
    // 获取第一个本主机的IPv4地址
    int nListSize = ipAddressesList.size();
    for (int i = 0; i < nListSize; ++i)
    {
        if (ipAddressesList.at(i) != QHostAddress::LocalHost &&
            ipAddressesList.at(i).toIPv4Address()) {
            strIpAddress = ipAddressesList.at(i).toString();
            break;
        }
    }
    // 如果没有找到，则以本地IP地址为IP
    if (strIpAddress.isEmpty())
        strIpAddress = QHostAddress(QHostAddress::LocalHost).toString();
    return strIpAddress;
}

QString FHelper::getBroadcastAddress(QString ip, QString subnetMask)
{
    QString BroadcastAddress = "";
    qDebug()<< "ip = " << ip << "subnetMask = " << subnetMask;
    QStringList ipList = ip.split(".");
    QStringList subnetMaskList = subnetMask.split(".");
    if(ipList.count() != subnetMaskList.count())
        return BroadcastAddress;
    for (int i = 0; i < ipList.count(); i++){
        QString ip = ipList.at(i);
        QString Mask = subnetMaskList.at(i);
        BroadcastAddress.append(QString("%1.").arg(ip.toInt() & Mask.toInt()));
    }
    BroadcastAddress.remove(BroadcastAddress.length()-1, 1);
    return BroadcastAddress;
}

QString FHelper::ByteArrayToAsciiStr(QByteArray data)
{
    QString temp;
    int len = data.size();

    for (int i = 0; i < len; i++) {
        //0x20为空格,空格以下都是不可见字符
        char b = data.at(i);

        if (0x00 == b) {
            temp += QString("\\NUL");
        }
        else if (0x01 == b) {
            temp += QString("\\SOH");
        }
        else if (0x02 == b) {
            temp += QString("\\STX");
        }
        else if (0x03 == b) {
            temp += QString("\\ETX");
        }
        else if (0x04 == b) {
            temp += QString("\\EOT");
        }
        else if (0x05 == b) {
            temp += QString("\\ENQ");
        }
        else if (0x06 == b) {
            temp += QString("\\ACK");
        }
        else if (0x07 == b) {
            temp += QString("\\BEL");
        }
        else if (0x08 == b) {
            temp += QString("\\BS");
        }
        else if (0x09 == b) {
            temp += QString("\\HT");
        }
        else if (0x0A == b) {
            temp += QString("\\LF");
        }
        else if (0x0B == b) {
            temp += QString("\\VT");
        }
        else if (0x0C == b) {
            temp += QString("\\FF");
        }
        else if (0x0D == b) {
            temp += QString("\\CR");
        }
        else if (0x0E == b) {
            temp += QString("\\SO");
        }
        else if (0x0F == b) {
            temp += QString("\\SI");
        }
        else if (0x10 == b) {
            temp += QString("\\DLE");
        }
        else if (0x11 == b) {
            temp += QString("\\DC1");
        }
        else if (0x12 == b) {
            temp += QString("\\DC2");
        }
        else if (0x13 == b) {
            temp += QString("\\DC3");
        }
        else if (0x14 == b) {
            temp += QString("\\DC4");
        }
        else if (0x15 == b) {
            temp += QString("\\NAK");
        }
        else if (0x16 == b) {
            temp += QString("\\SYN");
        }
        else if (0x17 == b) {
            temp += QString("\\ETB");
        }
        else if (0x18 == b) {
            temp += QString("\\CAN");
        }
        else if (0x19 == b) {
            temp += QString("\\EM");
        }
        else if (0x1A == b) {
            temp += QString("\\SUB");
        }
        else if (0x1B == b) {
            temp += QString("\\ESC");
        }
        else if (0x1C == b) {
            temp += QString("\\FS");
        }
        else if (0x1D == b) {
            temp += QString("\\GS");
        }
        else if (0x1E == b) {
            temp += QString("\\RS");
        }
        else if (0x1F == b) {
            temp += QString("\\US");
        }
        else if (0x7F == b) {
            temp += QString("\\x7F");
        }
        else if (0x5C == b) {
            temp += QString("\\x5C");
        }
        else if (0x20 >= b) {
            temp += QString("\\x%1").arg(DecimalToStrHex((quint8)b));
        }
        else {
            temp += QString("%1").arg(b);
        }
    }
    return temp.trimmed();
}

QByteArray FHelper::AsciiStrToByteArray(QString str)
{
    QByteArray buffer;
    int len = str.length();
    QString letter;
    QString hex;

    for (int i = 0; i < len; i++) {
        letter = str.at(i);

        if (letter == "\\") {
            i++;
            letter = str.mid(i, 1);

            if (letter == "x") {
                i++;
                hex = str.mid(i, 2);
                buffer.append(StrHexToDecimal(hex));
                i++;
                continue;
            }
            else if (letter == "N") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "U") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "L") {           //NUL=0x00
                        buffer.append((char)0x00);
                        continue;
                    }
                }
                else if (hex == "A") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "K") {           //NAK=0x15
                        buffer.append(0x15);
                        continue;
                    }
                }
            }
            else if (letter == "S") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "O") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "H") {           //SOH=0x01
                        buffer.append(0x01);
                        continue;
                    }
                    else {                    //SO=0x0E
                        buffer.append(0x0E);
                        i--;
                        continue;
                    }
                }
                else if (hex == "T") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "X") {           //STX=0x02
                        buffer.append(0x02);
                        continue;
                    }
                }
                else if (hex == "I") {        //SI=0x0F
                    buffer.append(0x0F);
                    continue;
                }
                else if (hex == "Y") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "N") {           //SYN=0x16
                        buffer.append(0x16);
                        continue;
                    }
                }
                else if (hex == "U") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "B") {           //SUB=0x1A
                        buffer.append(0x1A);
                        continue;
                    }
                }
            }
            else if (letter == "E") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "T") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "X") {           //ETX=0x03
                        buffer.append(0x03);
                        continue;
                    }
                    else if (hex == "B") {    //ETB=0x17
                        buffer.append(0x17);
                        continue;
                    }
                }
                else if (hex == "O") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "T") {           //EOT=0x04
                        buffer.append(0x04);
                        continue;
                    }
                }
                else if (hex == "N") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "Q") {           //ENQ=0x05
                        buffer.append(0x05);
                        continue;
                    }
                }
                else if (hex == "M") {        //EM=0x19
                    buffer.append(0x19);
                    continue;
                }
                else if (hex == "S") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "C") {           //ESC=0x1B
                        buffer.append(0x1B);
                        continue;
                    }
                }
            }
            else if (letter == "A") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "C") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "K") {           //ACK=0x06
                        buffer.append(0x06);
                        continue;
                    }
                }
            }
            else if (letter == "B") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "E") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "L") {           //BEL=0x07
                        buffer.append(0x07);
                        continue;
                    }
                }
                else if (hex == "S") {        //BS=0x08
                    buffer.append(0x08);
                    continue;
                }
            }
            else if (letter == "C") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "R") {               //CR=0x0D
                    buffer.append(0x0D);
                    continue;
                }
                else if (hex == "A") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "N") {           //CAN=0x18
                        buffer.append(0x18);
                        continue;
                    }
                }
            }
            else if (letter == "D") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "L") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "E") {           //DLE=0x10
                        buffer.append(0x10);
                        continue;
                    }
                }
                else if (hex == "C") {
                    i++;
                    hex = str.mid(i, 1);

                    if (hex == "1") {           //DC1=0x11
                        buffer.append(0x11);
                        continue;
                    }
                    else if (hex == "2") {    //DC2=0x12
                        buffer.append(0x12);
                        continue;
                    }
                    else if (hex == "3") {    //DC3=0x13
                        buffer.append(0x13);
                        continue;
                    }
                    else if (hex == "4") {    //DC2=0x14
                        buffer.append(0x14);
                        continue;
                    }
                }
            }
            else if (letter == "F") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "F") {               //FF=0x0C
                    buffer.append(0x0C);
                    continue;
                }
                else if (hex == "S") {        //FS=0x1C
                    buffer.append(0x1C);
                    continue;
                }
            }
            else if (letter == "H") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "T") {               //HT=0x09
                    buffer.append(0x09);
                    continue;
                }
            }
            else if (letter == "L") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "F") {               //LF=0x0A
                    buffer.append(0x0A);
                    continue;
                }
            }
            else if (letter == "G") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "S") {               //GS=0x1D
                    buffer.append(0x1D);
                    continue;
                }
            }
            else if (letter == "R") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "S") {               //RS=0x1E
                    buffer.append(0x1E);
                    continue;
                }
            }
            else if (letter == "U") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "S") {               //US=0x1F
                    buffer.append(0x1F);
                    continue;
                }
            }
            else if (letter == "V") {
                i++;
                hex = str.mid(i, 1);

                if (hex == "T") {               //VT=0x0B
                    buffer.append(0x0B);
                    continue;
                }
            }
            else if (letter == "\\") {
                //如果连着的是多个\\则对应添加\对应的16进制0x5C
                buffer.append(0x5C);
                continue;
            }
            else {
                //将对应的\[前面的\\也要加入
                buffer.append(0x5C);
                buffer.append(letter.toLatin1());
                continue;
            }
        }
        buffer.append(str.mid(i, 1).toLatin1());
    }
    return buffer;
}

QString FHelper::getLimitString(QString str, int nBytes)
{
    QString temp = str;
    QRegExp rx("[\u4e00-\u9fa5]");
    if (temp.replace(rx, "zz").length() <= nBytes) {
        return str;
    }

    for (int i = str.length(); i >= 0; i--) {
        temp = str.mid(0, i);
        if (temp.replace(rx, "zz").length() <= nBytes) {
            return str.mid(0, i);
        }
    }
    return QString("");
}

void FHelper::strToCharArray(char* _Destination, const QString& _Source, int _SizeInBytes)
{
    QByteArray ba;
    ba = _Source.toUtf8();
    strcpy_s(_Destination, _SizeInBytes, ba.data());
}

QColor FHelper::initialItemColor(int nIndex, int nCount)
{
    int nH = ((nIndex + 1) * 2560 / nCount) % 256;
    int nS = ((nIndex + 1) * 1780 / nCount) % 256;
    int nV = 200;
    return QColor::fromHsv(nH, nS, nV);
}

QString FHelper::addCommand(QString comd)
{
    QString tempStr = comd;
    tempStr.insert(0, '(');
    tempStr.append(')');
    tempStr += "\r\n";
    return tempStr;
}

QList<int> FHelper::getRandom(int nCount, int nMax)
{
    QList<int> intList;
    int   i = 0, m = 0;
    QTime time;
    for (i = 0;;)
    {
        if (intList.count() >= nCount)
            break;
        int randn;
        time = QTime::currentTime();
        qsrand(time.msec()*qrand()*qrand()*qrand()*qrand()*qrand()*qrand());
        randn = qrand() % nMax;
        m = 0;
        while (m < i && intList.at(m) != randn)
            m++;
        if (m == i) { intList.append(randn); i++; }
        else if (i == nMax)
        	break;
        else
        	continue;
    }
    return intList;
}

QString FHelper::getRandomStrHex(int nCount, int nMax)
{
    QString strHex;
    QList<int> intList = getRandom(nCount, nMax);
    foreach (int i, intList)
        strHex.append(DecimalToStrHex(i));
    return strHex;
}

//获取Jpeg图片位深
int FHelper::getJpegBitDepth(const QString &imagePath)
{
    QFile imageFile(imagePath);
    if(!imageFile.open(QIODevice::ReadWrite)){
        return -1;
    }
    QByteArray ba = imageFile.readAll();
    int i = 2;
    int bitsPerPixel = 0;
    while(true){
        int marker =(ba[i] & 0xff) << 8| (ba[i+ 1] & 0xff);
        int size =(ba[i +2] & 0xff) << 8| (ba[i+ 3] & 0xff);
        if(marker >= 0xffc0 && marker <= 0xffcf && marker != 0xffc4 && marker !=0xffc8){
            bitsPerPixel = (ba[i+ 4]& 0xff)* (ba[i+ 9]& 0xff);
            return bitsPerPixel;
            break;
        }else{
            i+= size+ 2;
        }
    }
}

void FHelper::WriteToCSV(QWidget *parent, QString savefileName, QTableView *tableView)
{
    //获取系统时间
    QString currentDateTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh-mm-ss");
    //设置保存的文件名
    QString fileName = QFileDialog::getSaveFileName(parent, QObject::tr("导出表格"), QString("%1-%2.csv").arg(savefileName).arg(currentDateTime), QObject::tr("file (*.csv)"));
    if (!fileName.isEmpty()){
        QFile file(fileName);
        bool ret = file.open( QIODevice::Truncate | QIODevice::WriteOnly);
        if(!ret) return;
        QTextStream stream(&file);
        QString conTents;
        int rowCount = tableView->model()->rowCount();
        int columnCount = tableView->model()->columnCount();
        for ( int i = 0; i < columnCount; i++ ){
            QString headerData = tableView->model()->headerData(i,Qt::Horizontal,Qt::DisplayRole).toString();
            conTents += headerData + ",";
        }
        conTents += "\n";
        for ( int i = 0 ; i < rowCount; i++ ){
            if(tableView->isRowHidden(i)) continue;
            for ( int j = 0; j < columnCount; j++ ){
                QString itemText = tableView->model()->data(tableView->model()->index(i, j)).toString();
                itemText.replace(","," ");
                conTents += itemText + ",";
            }
            conTents += "\n";
        }
        stream << conTents;
        file.close();
        qDebug()<< "表格导出成功!";
    }
    else{
        qDebug()<< "文件保存失败!";
    }
}

QList<QStringList> FHelper::ReadFromCSV(QString PathName)
{
    QList<QStringList> retList;
    QFile file(PathName);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return retList;
    while (!file.atEnd()) {
        QString line = file.readLine();
        line.replace('\n',"");
        QStringList lineList = line.split(',');
        lineList.removeLast();
        retList.append(lineList);
    }
    file.close();
    return retList;
}