smms/supermarket/quiwidget.cpp

这段代码是一个Qt应用程序的实现文件，包含了`QUIWidget`、`QUIMessageBox`、`QUIInputBox`和`IconHelper`类的定义。以下是对代码中的关键部分的详细注释：

```cpp
// 包含头文件
#include "quiwidget.h"

// 定义获取桌面宽度和高度的静态方法
int QUIWidget::deskWidth() {
    return qApp->desktop()->availableGeometry().width();
}

int QUIWidget::deskHeight() {
    return qApp->desktop()->availableGeometry().height();
}

// 定义获取应用程序名称和路径的静态方法
QString QUIWidget::appName() {
    QString name = qApp->applicationFilePath();
    QStringList list = name.split("/");
    name = list.at(list.count() - 1).split(".").at(0);
    return name;
}

QString QUIWidget::appPath() {
#ifdef __arm__
    // Android平台的特定路径
    return "/sdcard/Android/lys";
#else
    // 其他平台返回应用程序的路径
    return qApp->applicationDirPath();
#endif
}

// 定义创建新目录的静态方法
void QUIWidget::newDir(const QString &dirName) {
    QString strDir = dirName;

    // 如果路径不是绝对路径，则添加应用程序的路径
    if (!strDir.startsWith("/") && !strDir.contains(":/")) {
        strDir = QString("%1/%2").arg(QUIWidget::appPath()).arg(strDir);
    }

    QDir dir(strDir);

    // 如果目录不存在，则创建目录
    if (!dir.exists()) {
        dir.mkpath(strDir);
    }
}

// 定义写入日志信息的静态方法
void QUIWidget::writeInfo(const QString &info, const QString &filePath) {
    QString fileName = QString("%1/%2/%3_runinfo_%4.txt").arg(QUIWidget::appPath())
                       .arg(filePath).arg(QUIWidget::appName()).arg(QDate::currentDate().year());

    QFile file(fileName);
    file.open(QIODevice::WriteOnly | QIODevice::Append | QFile::Text);
    QTextStream stream(&file);
    stream << DATETIME << info << NEWLINE;
    file.close();
}

// 定义设置全局样式的静态方法
void QUIWidget::setStyle(QUIWidget::Style style) {
    QString qssFile = ":/qss/blue.css";

    // 根据样式选择对应的qss文件
    switch (style) {
        // ... 省略了其他样式的设置
        default:
            break;
    }

    QFile file(qssFile);

    // 读取qss文件并应用样式
    if (file.open(QFile::ReadOnly)) {
        QString qss = QLatin1String(file.readAll());
        QString paletteColor = qss.mid(20, 7);
        qApp->setPalette(QPalette(QColor(paletteColor)));
        qApp->setStyleSheet(qss);
        file.close();
    }
}

// 定义设置窗体居中显示的静态方法
void QUIWidget::setFormInCenter(QWidget *frm) {
    int frmX = frm->width();
    int frmY = frm->height();
    QDesktopWidget w;
    int deskWidth = w.availableGeometry().width();
    int deskHeight = w.availableGeometry().height();
    QPoint movePoint(deskWidth / 2 - frmX / 2, deskHeight / 2 - frmY / 2);
    frm->move(movePoint);
}

// 定义设置翻译文件的静态方法
void QUIWidget::setTranslator(const QString &qmFile) {
    QTranslator *translator = new QTranslator(qApp);
    translator->load(qmFile);
    qApp->installTranslator(translator);
}

// 定义设置编码的静态方法
void QUIWidget::setCode() {
#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("utf-8");
    QTextCodec::setCodecForLocale(codec);
#endif
}

// 定义设置延时的静态方法
void QUIWidget::sleep(int sec) {
    QTime dieTime = QTime::currentTime().addMSecs(sec);

    while (QTime::currentTime() < dieTime) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }
}

// 定义设置系统日期和时间的静态方法
void QUIWidget::setSystemDateTime(const QString &year, const QString &month, const QString &day,
                                  const QString &hour, const QString &min, const QString &sec) {
#ifdef Q_OS_WIN
    // Windows平台的设置方法
    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
    // Linux平台的设置方法
    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 QUIWidget::runWithSystem(const QString &strName, const QString &strPath, bool autoRun) {
#ifdef Q_OS_WIN
    // Windows平台的设置方法
    QSettings reg("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", QSettings::NativeFormat);

    if (autoRun) {
        reg.setValue(strName, strPath);
    } else {
        reg.setValue(strName, "");
    }
#endif
}

// 定义判断IP地址是否合法的静态方法
bool QUIWidget::isIP(const 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);
}

// 定义判断MAC地址是否合法的静态方法
bool QUIWidget::isMac(const QString &mac) {
    QRegExp RegExp("^[A-F0-9]{2}(-[A-F0-9]{2}){5}$");
    return RegExp.exactMatch(mac);
}

// 定义判断电话号码是否合法的静态方法
bool QUIWidget::isTel(const QString &tel) {
    if (tel.length() != 11) {
        return false;
    }

    if (!tel.startsWith("13") && !tel.startsWith("14") && !tel.startsWith("15") && !tel.startsWith("18")) {
        return false;
    }

    return true;
}

// 定义判断邮箱地址是否合法的静态方法
bool QUIWidget::isEmail(const QString &email) {
    if (!email.contains("@") || !email.contains(".com")) {
        return false;
    }

    return true;
}

// 定义字符串转换为十进制数的静态方法
int QUIWidget::strHexToDecimal(const QString &strHex) {
    bool ok;
    return strHex.toInt(&ok, 16);
}

// 定义字符串转换为十进制数的静态方法
int QUIWidget::strDecimalToDecimal(const QString &strDecimal) {
    bool ok;
    return strDecimal.toInt(&ok, 10);
}

// 定义字符串转换为二进制数的静态方法
int QUIWidget::strBinToDecimal(const QString &strBin) {
    bool ok;
    return strBin.toInt(&ok, 2);
}

// 定义十六进制字符串转换为二进制字符串的静态方法
QString QUIWidget::strHexToStrBin(const 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;
}

// 定义十进制数转换为二进制字符串的静态方法（一个字节）
QString QUIWidget::decimalToStrBin1(int decimal) {
    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;
}

// 定义十进制数转换为二进制字符串的静态方法（两个字节）
QString QUIWidget::decimalToStrBin2(int decimal) {
    QString bin = QString::number(decimal, 2);
    uchar len = bin.length();

    if (len <= 16) {
        for (int i = 0; i < 16 - len; i++) {
            bin = "0" + bin;
        }
    }

    return bin;
}

// 定义十进制数转换为十六进制字符串的静态方法
QString QUIWidget::decimalToStrHex(int decimal) {
    QString temp = QString::number(decimal, 16);

    if (temp.length() == 1) {
        temp = "0" + temp;
    }

    return temp;
}

// 定义整数转换为字节数组的静态方法
QByteArray QUIWidget::intToByte(int i) {
    QByteArray result;
    result.resize(4);
    result[3] = (uchar)(0x000000ff & i);
    result[2] = (uchar)((0x0000ff00 & i) >> 8);
    result[1] = (uchar)((0x00ff0000 & i) >> 16);
    result[0] = (uchar)((0xff000000 & i) >> 24);
    return result;
}

// 定义字节数组转换为整数的静态方法
int QUIWidget::byteToInt(const QByteArray &data) {
    int i = data.at(3) & 0x000000FF;
    i |= ((data.at(2) << 8) & 0x0000FF00);
    i |= ((data.at(1) << 16) & 0x00FF0000);
    i |= ((data.at(0) << 24) & 0xFF000000);
    return i;
}

// 定义短整数转换为字节数组的静态方法
QByteArray QUIWidget::ushortToByte(ushort i) {
    QByteArray result;
    result.resize(2);
    result[1] = (uchar)(0x000000ff & i);
    result[0] = (uchar)((0x0000ff00 & i) >> 8);
    return result;
}

// 定义字节数组转换为短整数的静态方法
int QUIWidget::byteToUShort(const QByteArray &data) {
    int i = data.at(1) & 0x000000FF;
    i |= ((data.at(0) << 8) & 0x0000FF00);
    return i;
}

// 定义异或加密解密的静态方法
QString QUIWidget::getXorEncryptDecrypt(const QString &str, char key) {
    QByteArray data = str.toLatin1();
    int size = data.size();

    for (int i = 0; i < size; i++) {
        data[i] = data.at(i) ^ key;
    }

    return QLatin1String(data);
}

// 定义异或校验的静态方法
uchar QUIWidget::getOrCode(const QByteArray &data) {
    int len = data.length();
    uchar result = 0;

    for (int i = 0; i < len; i++) {
        result ^= data.at(i);
    }

    return result;
}

// 定义计算校验码的静态方法
uchar QUIWidget::getCheckCode(const QByteArray &data) {
    int len = data.length();
    uchar temp = 0;

    for (uchar i = 0; i < len; i++) {
        temp += data.at(i);
    }

    return temp % 256;
}

// 定义字节数组转换为ASCII字符串的静态方法
QString QUIWidget::byteArrayToAsciiStr(const 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 QUIWidget::hexStrToByteArray(const 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.at(i).toLatin1();

        if (hstr == ' ') {
            i++;
            continue;
        }

        i++;

        if (i >= len) {
            break;
        }

        lstr = str.at(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 QUIWidget::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') &&