IT学习

Qt5 C++环境下多模块独立线程运行与通信

Sun, 15 Feb 2026 22:54:53 +0800

在 Qt5.15 + C++ 环境下，将子模块（A、B、C）放入独立线程中运行，并通过主模块 M 的界面按钮控制其启停，同时支持模块间通信，推荐使用 QObject + moveToThread 模式（而非继承 QThread），Qt 官方推荐的线程使用方式。

下面是一个完整的简化示例：

主窗口（M）提供“启动/停止”按钮；
子模块 A、B、C 各自封装为 QObject 子类；
每个子模块运行在独立的 QThread 中；
使用信号与槽实现线程安全的跨模块通信；
所有资源在退出时正确释放。

1. 子模块基类（可选，用于统一接口）

// SubModuleBase.h
#pragma once
#include <QObject>

class SubModuleBase : public QObject
{
    Q_OBJECT
public:
    explicit SubModuleBase(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    virtual void startWork() = 0;
    virtual void stopWork() = 0;

signals:
    void finished(); // 工作完成信号（可用于通知主线程）
    void logMessage(const QString &msg); // 日志输出
};

2. 子模块 A（B、C 类似）

// ModuleA.h
#pragma once
#include "SubModuleBase.h"
#include <QTimer>

class ModuleA : public SubModuleBase
{
    Q_OBJECT
public:
    explicit ModuleA(QObject *parent = nullptr);

public slots:
    void startWork() override;
    void stopWork() override;

private slots:
    void doWork(); // 实际工作函数

private:
    QTimer *m_timer; // 模拟周期性任务
    volatile bool m_running = false;
};


// ------------------------------------------------------------------------------


// ModuleA.cpp
#include "ModuleA.h"
#include <QDebug>

ModuleA::ModuleA(QObject *parent)
    : SubModuleBase(parent)
{
    m_timer = new QTimer(this);
    connect(m_timer, &QTimer::timeout, this, &ModuleA::doWork);
}

void ModuleA::startWork()
{
    if (m_running) return;
    m_running = true;
    m_timer->start(1000); // 每秒执行一次
    emit logMessage("ModuleA started");
}

void ModuleA::stopWork()
{
    if (!m_running) return;
    m_running = false;
    m_timer->stop();
    emit logMessage("ModuleA stopped");
    emit finished(); // 可选：通知主线程已停止
}

void ModuleA::doWork()
{
    if (!m_running) return;
    static int count = 0;
    QString msg = QString("ModuleA working... count=%1").arg(++count);
    qDebug() << msg;
    emit logMessage(msg);

    // 示例：向其他模块发送消息（通过主模块中转或直接连接）
    // 此处假设主模块会连接此信号到其他模块的槽
}

3. 主模块（M）

// MainWindow.h
#pragma once
#include <QMainWindow>
#include <QThread>
#include "ModuleA.h"
#include "ModuleB.h"
#include "ModuleC.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void on_btnStartA_clicked();
    void on_btnStopA_clicked();
    // B、C 类似...

    void onLogReceived(const QString &msg);

private:
    Ui::MainWindow *ui;

    // 子模块对象
    ModuleA *m_moduleA;
    ModuleB *m_moduleB;
    ModuleC *m_moduleC;

    // 线程
    QThread *m_threadA;
    QThread *m_threadB;
    QThread *m_threadC;
};

// ------------------------------------------------------------------------------

// MainWindow.cpp
#include "MainWindow.h"
#include "ui_MainWindow.h"
#include <QMessageBox>
#include <QMetaObject>

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

    // 创建子模块对象（尚未移动到线程）
    m_moduleA = new ModuleA();
    m_moduleB = new ModuleB();
    m_moduleC = new ModuleC();

    // 创建线程
    m_threadA = new QThread(this);
    m_threadB = new QThread(this);
    m_threadC = new QThread(this);

    // 将子模块移动到对应线程
    m_moduleA->moveToThread(m_threadA);
    m_moduleB->moveToThread(m_threadB);
    m_moduleC->moveToThread(m_threadC);

    // 启动线程（线程开始运行事件循环）
    m_threadA->start();
    m_threadB->start();
    m_threadC->start();

    // 连接 UI 按钮信号到槽
    connect(ui->btnStartA, &QPushButton::clicked, this, &MainWindow::on_btnStartA_clicked);
    connect(ui->btnStopA,  &QPushButton::clicked, this, &MainWindow::on_btnStopA_clicked);
    // B、C 按钮类似...

    // 连接日志信号到主界面显示（线程安全！）
    connect(m_moduleA, &ModuleA::logMessage, this, &MainWindow::onLogReceived, Qt::QueuedConnection);
    connect(m_moduleB, &ModuleB::logMessage, this, &MainWindow::onLogReceived, Qt::QueuedConnection);
    connect(m_moduleC, &ModuleC::logMessage, this, &MainWindow::onLogReceived, Qt::QueuedConnection);

    // 示例：模块间通信（A → B）
    connect(m_moduleA, &ModuleA::logMessage, m_moduleB, &ModuleB::receiveFromA, Qt::QueuedConnection);
    // 注意：m_moduleB 的 receiveFromA 必须是槽函数，且定义在 ModuleB 中
}

MainWindow::~MainWindow()
{
    // 先请求停止工作
    QMetaObject::invokeMethod(m_moduleA, "stopWork", Qt::QueuedConnection);
    QMetaObject::invokeMethod(m_moduleB, "stopWork", Qt::QueuedConnection);
    QMetaObject::invokeMethod(m_moduleC, "stopWork", Qt::QueuedConnection);

    // 等待线程结束（可加超时）
    m_threadA->quit();
    m_threadB->quit();
    m_threadC->quit();

    m_threadA->wait(2000);
    m_threadB->wait(2000);
    m_threadC->wait(2000);

    delete ui;
    // QObject parent-child 机制会自动 delete m_moduleX（因为它们没有 parent，需手动 delete 或设 parent）
    delete m_moduleA;
    delete m_moduleB;
    delete m_moduleC;
}

void MainWindow::on_btnStartA_clicked()
{
    // 通过 invokeMethod 调用线程中的槽（线程安全）
    QMetaObject::invokeMethod(m_moduleA, "startWork", Qt::QueuedConnection);
}

void MainWindow::on_btnStopA_clicked()
{
    QMetaObject::invokeMethod(m_moduleA, "stopWork", Qt::QueuedConnection);
}

void MainWindow::onLogReceived(const QString &msg)
{
    // 在主线程更新 UI（如 QTextEdit）
    ui->textLog->append(msg);
}

4. 模块间通信补充说明

直接连接：如 connect(A, SIGNAL(x), B, SLOT(y)) 是线程安全的，Qt 会自动使用 QueuedConnection；
避免直接调用对方方法：应通过信号/槽或 QMetaObject::invokeMethod； (？？如果直接调用对方方法意味着什么？？)
共享数据：若需共享状态，建议使用 QMutex 保护，或通过信号传递副本（推荐后者，更安全）；

5. 注意事项

所有子模块的槽函数在线程中执行；
不要在子模块构造函数中启动定时器或做耗时操作（此时还未 moveToThread）；
析构顺序很重要：先 quit + wait 线程，再 delete 对象；
使用 Qt::QueuedConnection 确保跨线程调用安全（Qt 默认对跨线程连接使用 Queued）；
避免在子线程中操作 GUI（如 QLabel、QTextEdit 等），所有 UI 更新必须在主线程。

Qt5.15.2 C++ 使用 UDP 发送 Wake-on-LAN（WOL）魔术包唤醒远端计算机

Sat, 24 Jan 2026 08:15:55 +0800

#include <QCoreApplication>
#include <QUdpSocket>
#include <QHostAddress>
#include <QByteArray>
#include <QDebug>
#include <QStringList>

// 将 MAC 地址字符串（如 "AA:BB:CC:DD:EE:FF"）转换为 QByteArray
QByteArray macAddressToByteArray(const QString &macStr)
{
    QByteArray mac;
    QStringList parts = macStr.split(':');
    if (parts.size() != 6) {
        qWarning() << "Invalid MAC address format!";
        return QByteArray();
    }

    for (const QString &part : parts) {
        bool ok;
        int byte = part.toInt(&ok, 16);
        if (!ok || byte < 0 || byte > 255) {
            qWarning() << "Invalid MAC byte:" << part;
            return QByteArray();
        }
        mac.append(static_cast<char>(byte));
    }
    return mac;
}

// 发送 Wake-on-LAN 魔术包
bool sendWakeOnLan(const QString &macAddress, const QHostAddress &broadcastAddress = QHostAddress::Broadcast, quint16 port = 9)
{
    QByteArray macBytes = macAddressToByteArray(macAddress);
    if (macBytes.isEmpty() || macBytes.size() != 6) {
        qWarning() << "Invalid MAC address.";
        return false;
    }

    // 构造 Magic Packet:
    // 6 bytes of 0xFF followed by 16 repetitions of the MAC address
    QByteArray magicPacket;
    magicPacket.fill(0xFF, 6);
    for (int i = 0; i < 16; ++i) {
        magicPacket.append(macBytes);
    }

    QUdpSocket udpSocket;
    udpSocket.setSocketOption(QAbstractSocket::MulticastTtlOption, 255); // 可选：设置 TTL

    bool success = udpSocket.writeDatagram(magicPacket, broadcastAddress, port) == magicPacket.size();

    if (success) {
        qDebug() << "Magic packet sent to" << macAddress << "at" << broadcastAddress.toString() << ":" << port;
    } else {
        qWarning() << "Failed to send magic packet:" << udpSocket.errorString();
    }

    udpSocket.close();
    return success;
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    // 示例：替换为你想唤醒的设备的 MAC 地址
    QString targetMac = "AA:BB:CC:DD:EE:FF"; // ←← 修改这里！

    // 可选：指定广播地址（通常 255.255.255.255 即可）
    QHostAddress broadcastAddr("255.255.255.255");

    // 发送魔术包（默认端口 9）
    sendWakeOnLan(targetMac, broadcastAddr, 9);

    return 0;
}

注意事项：

目标计算机必须支持并启用 Wake-on-LAN（通常在 BIOS/UEFI 和网卡驱动中设置）。
发送方和目标必须在同一局域网（除非路由器支持转发 WOL 包）。
防火墙不能阻止 UDP 端口 7/9 的广播。
MAC 地址格式必须为 XX:XX:XX:XX:XX:XX（不区分大小写，也可用 -，但需修改解析逻辑）。
在某些系统上，可能需要管理员权限才能发送广播包（尤其是 Windows）。

使用子网定向广播地址

如果你知道目标计算机所在的子网（例如 192.168.1.0/24），可以将广播地址设为 192.168.1.255，而不是全局广播 255.255.255.255。这在某些网络环境中更可靠（尤其当路由器隔离了全局广播）。

修改后的代码（指定子网广播地址）：

替换 broadcastAddr
QHostAddress broadcastAddr("192.168.1.255"); // ← 替换为你的子网广播地址
sendWakeOnLan(targetMac, broadcastAddr, 9);

为什么不能用 TCP？

TCP 是一种面向连接、基于 IP 层（网络层）的可靠传输协议，而 WOL 的工作机制完全依赖于数据链路层（Layer 2）的广播帧。以下是关键原因：

1. 目标设备在关机/睡眠状态下没有 TCP/IP 协议栈运行

当计算机关闭或处于 S3/S4/S5 睡眠状态时：

操作系统已停止运行。

TCP/IP 协议栈不工作，无法监听任何 TCP 端口。

网卡仅以极低功耗运行，只监听特定格式的以太网帧（即魔术包）。

TCP 需要三次握手、端口监听、ACK 确认等机制——这些在关机设备上完全不可用。

2. TCP 无法广播

TCP 是点对点（单播）协议，不支持广播或多播。

魔术包必须以广播形式发送到整个局域网（或子网），才能被目标网卡捕获。

即使你知道 MAC 地址，TCP 也无法直接寻址到 MAC（它工作在更高层）。

3. 魔术包必须是 UDP + 广播 + 特定二进制格式

标准 WOL 魔术包要求：

使用 UDP 协议（无连接、可广播）。

目标端口通常为 7（Echo）或 9（Discard）（也可自定义，但需网卡支持）。

数据内容为：6 字节 0xFF + 16 次重复的目标 MAC 地址（共 102 字节）。

必须通过二层广播（如 255.255.255.255 或子网广播地址）发送。

Qt5.15.2 C++ 在一个 .h 头文件中定义多个类

Sat, 24 Jan 2026 08:01:41 +0800

MyClasses.h

#ifndef MYCLASSES_H
#define MYCLASSES_H

#include <QObject>
#include <QString>

// 第一个类：继承自 QObject，使用 Q_OBJECT 宏
class MyClassA : public QObject
{
    Q_OBJECT

public:
    explicit MyClassA(QObject *parent = nullptr);
    QString getName() const;

public slots:
    void setName(const QString &name);

signals:
    void nameChanged(const QString &newName);

private:
    QString m_name;
};

// 第二个类：普通 C++ 类（不继承 QObject）
class MyClassB
{
public:
    MyClassB(int value = 0);
    int getValue() const;
    void setValue(int value);

private:
    int m_value;
};

// 第三个类：另一个 QObject 子类
class MyClassC : public QObject
{
    Q_OBJECT

public:
    explicit MyClassC(QObject *parent = nullptr);
    void doSomething();

signals:
    void somethingDone();
};

#endif // MYCLASSES_H

MyClasses.cpp

#include "MyClasses.h"
#include <QDebug>

// MyClassA 实现
MyClassA::MyClassA(QObject *parent)
    : QObject(parent), m_name("Default")
{
}

QString MyClassA::getName() const
{
    return m_name;
}

void MyClassA::setName(const QString &name)
{
    if (m_name != name) {
        m_name = name;
        emit nameChanged(m_name);
    }
}

// MyClassB 实现
MyClassB::MyClassB(int value)
    : m_value(value)
{
}

int MyClassB::getValue() const
{
    return m_value;
}

void MyClassB::setValue(int value)
{
    m_value = value;
}

// MyClassC 实现
MyClassC::MyClassC(QObject *parent)
    : QObject(parent)
{
}

void MyClassC::doSomething()
{
    qDebug() << "Doing something...";
    emit somethingDone();
}

注意事项：

每个使用 Q_OBJECT 宏的类：

必须继承自 QObject（直接或间接）。
必须单独声明，不能嵌套在其他类内部（除非是嵌套但不使用信号/槽）。
需要被 MOC（Meta-Object Compiler）处理。Qt 的构建系统（qmake 或 CMake）会自动处理包含 Q_OBJECT 的头文件。

头文件防护（Include Guards）：

使用 #ifndef / #define / #endif 防止重复包含。
也可以用 #pragma once（大多数现代编译器支持），但在跨平台项目中传统写法更稳妥。

命名规范：

类名应清晰、唯一，避免冲突。
如果类之间关系紧密（如一个主类 + 若干辅助类），放在一起是合理的；否则建议拆分到不同文件以提高可维护性。

MOC 兼容性：

所有带 Q_OBJECT 的类必须在头文件中定义（不能只在 .cpp 中），因为 MOC 需要解析头文件。

Qt中QSettings类读取INI配置文件

Tue, 06 Jan 2026 23:08:41 +0800

#include <QCoreApplication>
#include <QSettings>
#include <QDebug>
#include <QFile>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 检查配置文件是否存在
    QString configPath = "config.ini";
    if (!QFile::exists(configPath)) {
        qDebug() << "配置文件不存在，创建默认配置...";
        QSettings createConfig(configPath, QSettings::IniFormat);
        createConfig.setValue("Database/host", "localhost");
        createConfig.setValue("Database/port", 3306);
        createConfig.setValue("Database/username", "admin");
        createConfig.setValue("Database/password", "123456");
        createConfig.setValue("AppSettings/theme", "dark");
        createConfig.setValue("AppSettings/language", "zh_CN");
        createConfig.sync(); // 立即写入文件
    }

    // 读取配置文件
    QSettings config(configPath, QSettings::IniFormat);
    config.setIniCodec("UTF-8"); // 设置编码防止中文乱码

    // 读取数据库配置
    qDebug() << "\n[数据库配置]";
    qDebug() << "主机:" << config.value("Database/host").toString();
    qDebug() << "端口:" << config.value("Database/port").toInt();
    qDebug() << "用户名:" << config.value("Database/username").toString();
    qDebug() << "密码:" << config.value("Database/password").toString();

    // 读取应用设置
    qDebug() << "\n[应用设置]";
    qDebug() << "主题:" << config.value("AppSettings/theme").toString();
    qDebug() << "语言:" << config.value("AppSettings/language").toString();

    // 分组读取示例
    config.beginGroup("Database");
    qDebug() << "\n[分组读取]";
    qDebug() << "主机(分组):" << config.value("host").toString();
    config.endGroup();

    return a.exec();
}

[Database]
host=localhost
port=3306
username=admin
password=123456

[AppSettings]
theme=dark
language=zh_CN

配置文件创建与初始化

QSettings createConfig(configPath, QSettings::IniFormat);
createConfig.setValue("Database/host", "localhost");
createConfig.sync(); // 强制写入磁盘

分组读取的实现

config.beginGroup("Database");
QString host = config.value("host").toString();
config.endGroup();

单摆实验模拟探索简谐运动与物理原理

Wed, 12 Nov 2025 09:00:00 +0800

由于单摆的运动方程是非线性的，但对于小角度( ≤5° ) 可以使用近似简谐运动，大角度则需要数值解法。(文末有下载，可下载独立使用，在线使用或嵌入wps演示文稿使用)

单摆的运动方程：d²θ/dt² = - (g/L) * sin(θ)

单摆实验模拟应用具有以下特点：

交互式模拟：实时显示单摆运动；摆球运动轨迹可视化；平滑的动画效果
参数调节：摆长：0.5m 到 3.0m；初始角度：5° 到 80°；重力加速度：5m/s² 到 15m/s²；摆球质量：0.1到0.5
实时数据显示：单摆周期；最大速度；当前位置；当前速度；运动轨迹和方向
控制功能：开始/暂停/重置按钮；参数调节时实时更新
物理原理说明：单摆运动方程；能量转换原理；实际应用场景

html源码（以下代码由 deepseek 根据人工指令生成）

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>单摆实验模拟</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
        
        body {
            background: linear-gradient(135deg, #1a2a6c, #2a4cb3, #4a7bff);
            color: white;
            min-height: 100vh;
            padding: 15px;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
        }
        
        header {
            text-align: center;
            padding: 15px 0;
            margin-bottom: 20px;
        }
        
        h1 {
            font-size: clamp(1.8rem, 5vw, 2.5rem);
            margin-bottom: 8px;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
        }
        
        .subtitle {
            font-size: clamp(1rem, 3vw, 1.2rem);
            opacity: 0.9;
        }
        
        .content {
            display: flex;
            flex-wrap: wrap;
            gap: 20px;
            background: rgba(255, 255, 255, 0.1);
            backdrop-filter: blur(10px);
            border-radius: 15px;
            padding: 20px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
        }
        
        .simulation-area {
            flex: 1;
            min-width: 280px;
            display: flex;
            flex-direction: column;
            align-items: center;
        }
        
        .canvas-container {
            width: 100%;
            max-width: 500px;
            margin: 0 auto;
            position: relative;
        }
        
        #pendulumCanvas {
            width: 100%;
            height: auto;
            background: rgba(255, 255, 255, 0.9);
            border-radius: 10px;
            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
            margin-bottom: 15px;
            display: block;
        }
        
        .angle-display {
            background: rgba(255, 255, 255, 0.15);
            padding: 12px 20px;
            border-radius: 10px;
            margin-bottom: 15px;
            text-align: center;
            width: 100%;
        }
        
        .angle-display h3 {
            margin-bottom: 8px;
            color: white;
            font-size: clamp(1rem, 3vw, 1.2rem);
        }
        
        .angle-value {
            font-size: clamp(1.8rem, 6vw, 2.5rem);
            font-weight: bold;
            color: white;
        }
        
        .controls {
            flex: 1;
            min-width: 280px;
        }
        
        .control-group {
            background: rgba(255, 255, 255, 0.1);
            border-radius: 10px;
            padding: 15px;
            margin-bottom: 15px;
        }
        
        h2 {
            font-size: clamp(1.2rem, 4vw, 1.5rem);
            margin-bottom: 12px;
            border-bottom: 2px solid rgba(255, 255, 255, 0.3);
            padding-bottom: 6px;
        }
        
        .slider-container {
            margin-bottom: 12px;
        }
        
        label {
            display: block;
            margin-bottom: 6px;
            font-weight: 500;
            font-size: clamp(0.9rem, 2.5vw, 1rem);
        }
        
        input[type="range"] {
            width: 100%;
            height: 10px;
            border-radius: 5px;
            background: rgba(255, 255, 255, 0.2);
            outline: none;
            -webkit-appearance: none;
        }
        
        input[type="range"]::-webkit-slider-thumb {
            -webkit-appearance: none;
            width: 22px;
            height: 22px;
            border-radius: 50%;
            background: #4a7bff;
            cursor: pointer;
        }
        
        .value-display {
            display: flex;
            justify-content: space-between;
            margin-top: 5px;
            font-size: clamp(0.8rem, 2.5vw, 0.9rem);
        }
        
        .data-display {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(130px, 1fr));
            gap: 12px;
            margin-top: 15px;
        }
        
        .data-item {
            background: rgba(255, 255, 255, 0.15);
            padding: 12px;
            border-radius: 8px;
            text-align: center;
        }
        
        .data-value {
            font-size: clamp(1.4rem, 4vw, 1.8rem);
            font-weight: bold;
            margin: 8px 0;
            color: white;
        }
        
        .data-label {
            font-size: clamp(0.8rem, 2.5vw, 0.9rem);
            opacity: 0.8;
        }
        
        .buttons {
            display: flex;
            gap: 8px;
            margin-top: 15px;
        }
        
        button {
            flex: 1;
            padding: 12px;
            border: none;
            border-radius: 8px;
            background: #4a7bff;
            color: white;
            font-weight: bold;
            cursor: pointer;
            transition: all 0.3s ease;
            font-size: clamp(0.9rem, 2.5vw, 1rem);
            min-height: 44px;
        }
        
        button:hover {
            background: #5d8cff;
            transform: translateY(-2px);
        }
        
        button:active {
            transform: translateY(0);
        }
        
        .theory {
            margin-top: 25px;
            background: rgba(255, 255, 255, 0.1);
            border-radius: 15px;
            padding: 20px;
        }
        
        .theory-content {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
            gap: 15px;
            margin-top: 15px;
        }
        
        .theory-card {
            background: rgba(255, 255, 255, 0.1);
            padding: 15px;
            border-radius: 10px;
        }
        
        .theory-card h3 {
            margin-bottom: 12px;
            color: white;
            font-size: clamp(1rem, 3vw, 1.2rem);
        }
        
        footer {
            text-align: center;
            margin-top: 30px;
            padding: 15px;
            opacity: 0.8;
            font-size: clamp(0.8rem, 2.5vw, 0.9rem);
        }
        
        .conclusion {
            background: rgba(255, 255, 255, 0.15);
            padding: 12px;
            border-radius: 10px;
            margin-top: 15px;
            border-left: 4px solid #4a7bff;
        }
        
        /* 移动端特定样式 */
        @media (max-width: 768px) {
            body {
                padding: 10px;
            }
            
            .content {
                flex-direction: column;
                padding: 15px;
                gap: 15px;
            }
            
            .simulation-area, .controls {
                width: 100%;
            }
            
            .canvas-container {
                max-width: 100%;
            }
            
            .buttons {
                flex-wrap: wrap;
            }
            
            button {
                min-width: 120px;
            }
        }
        
        /* 小屏幕手机特定样式 */
        @media (max-width: 480px) {
            .content {
                padding: 12px;
            }
            
            .control-group {
                padding: 12px;
            }
            
            .data-display {
                grid-template-columns: 1fr 1fr;
            }
            
            .theory-content {
                grid-template-columns: 1fr;
            }
        }
    </style>
</head>
<body>
    <div>
        <header>
            <h1>单摆实验模拟</h1>
            <p>探索简谐运动与物理原理</p>
        </header>
        
        <div>
            <div>
                <div>
                    <canvas id="pendulumCanvas" width="500" height="500"></canvas>
                </div>
                
                <div>
                    <h3>当前角度</h3>
                    <div id="currentAngle">0.00°</div>
                </div>
                
                <div>
                    <button id="startBtn">开始</button>
                    <button id="pauseBtn">暂停</button>
                    <button id="resetBtn">重置</button>
                </div>
            </div>
            
            <div>
                <div>
                    <h2>实验参数</h2>
                    
                    <div>
                        <label for="lengthSlider">摆长 (m)</label>
                        <input type="range" id="lengthSlider" min="0.5" max="3.0" step="0.1" value="2.0">
                        <div>
                            <span>0.5</span>
                            <span id="lengthValue">2.0</span>
                            <span>3.0</span>
                        </div>
                    </div>
                    
                    <div>
                        <label for="angleSlider">初始角度 (°)</label>
                        <input type="range" id="angleSlider" min="5" max="80" step="5" value="30">
                        <div>
                            <span>5</span>
                            <span id="angleValue">30</span>
                            <span>80</span>
                        </div>
                    </div>
                    
                    <div>
                        <label for="massSlider">摆球质量 (kg)</label>
                        <input type="range" id="massSlider" min="0.1" max="5.0" step="0.1" value="1.0">
                        <div>
                            <span>0.1</span>
                            <span id="massValue">1.0</span>
                            <span>5.0</span>
                        </div>
                    </div>
                    
                    <div>
                        <label for="gravitySlider">重力加速度 (m/s²)</label>
                        <input type="range" id="gravitySlider" min="5" max="15" step="0.1" value="9.8">
                        <div>
                            <span>5.0</span>
                            <span id="gravityValue">9.8</span>
                            <span>15.0</span>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h2>实时数据</h2>
                    <div>
                        <div>
                            <div>周期</div>
                            <div id="periodValue">2.84 s</div>
                        </div>
                        <div>
                            <div>最大速度</div>
                            <div id="maxSpeedValue">2.38 m/s</div>
                        </div>
                        <div>
                            <div>当前位置</div>
                            <div id="positionValue">0.00 m</div>
                        </div>
                        <div>
                            <div>当前速度</div>
                            <div id="speedValue">0.00 m/s</div>
                        </div>
                    </div>
                </div>
                
                <div>
                    <h3>实验观察</h3>
                    <p>通过调节摆球质量，观察周期是否发生变化。可以发现：<strong>单摆的周期与摆球质量无关</strong>，只与摆长和重力加速度有关。</p>
                </div>
            </div>
        </div>
        
        <div>
            <h2>单摆原理</h2>
            <div>
                <div>
                    <h3>单摆运动方程</h3>
                    <p>单摆的运动遵循简谐运动规律，其周期公式为：</p>
                    <p style="text-align: center; margin: 12px 0; font-size: clamp(1rem, 3vw, 1.2rem);">T = 2π√(L/g)</p>
                    <p>其中 T 是周期，L 是摆长，g 是重力加速度。</p>
                </div>
                
                <div>
                    <h3>能量转换</h3>
                    <p>单摆运动过程中，势能和动能相互转换：</p>
                    <ul style="margin-left: 18px; margin-top: 8px;">
                        <li>最高点：势能最大，动能为零</li>
                        <li>最低点：动能最大，势能最小</li>
                        <li>总机械能守恒（忽略空气阻力）</li>
                    </ul>
                </div>
                
                <div>
                    <h3>应用与意义</h3>
                    <p>单摆是物理学中研究简谐运动的经典模型，广泛应用于：</p>
                    <ul style="margin-left: 18px; margin-top: 8px;">
                        <li>测量重力加速度</li>
                        <li>钟表计时机制</li>
                        <li>地震仪等科学仪器</li>
                    </ul>
                </div>
            </div>
        </div>
        
        <footer>
            <p>单摆实验模拟 &copy; 2023 | 物理教学工具</p>
        </footer>
    </div>

    <script>
        // 获取Canvas和上下文
        const canvas = document.getElementById('pendulumCanvas');
        const ctx = canvas.getContext('2d');
        
        // 获取控制元素
        const lengthSlider = document.getElementById('lengthSlider');
        const angleSlider = document.getElementById('angleSlider');
        const massSlider = document.getElementById('massSlider');
        const gravitySlider = document.getElementById('gravitySlider');
        const startBtn = document.getElementById('startBtn');
        const pauseBtn = document.getElementById('pauseBtn');
        const resetBtn = document.getElementById('resetBtn');
        
        // 获取数据显示元素
        const lengthValue = document.getElementById('lengthValue');
        const angleValue = document.getElementById('angleValue');
        const massValue = document.getElementById('massValue');
        const gravityValue = document.getElementById('gravityValue');
        const periodValue = document.getElementById('periodValue');
        const maxSpeedValue = document.getElementById('maxSpeedValue');
        const positionValue = document.getElementById('positionValue');
        const speedValue = document.getElementById('speedValue');
        const currentAngle = document.getElementById('currentAngle');
        
        // 单摆参数
        let pendulum = {
            length: parseFloat(lengthSlider.value),
            angle: parseFloat(angleSlider.value) * Math.PI / 180, // 转换为弧度
            mass: parseFloat(massSlider.value),
            gravity: parseFloat(gravitySlider.value),
            angularVelocity: 0,
            time: 0,
            isRunning: false,
            animationId: null,
            pivotX: canvas.width / 2,
            pivotY: 100,
            bobRadius: 15,
            trail: [],
            direction: 1 // 1表示向右，-1表示向左
        };
        
        // 更新显示值
        function updateDisplayValues() {
            lengthValue.textContent = pendulum.length.toFixed(1);
            angleValue.textContent = (pendulum.angle * 180 / Math.PI).toFixed(0);
            massValue.textContent = pendulum.mass.toFixed(1);
            gravityValue.textContent = pendulum.gravity.toFixed(1);
            
            // 计算周期
            const period = 2 * Math.PI * Math.sqrt(pendulum.length / pendulum.gravity);
            periodValue.textContent = period.toFixed(2) + " s";
            
            // 计算最大速度
            const height = pendulum.length * (1 - Math.cos(pendulum.angle));
            const maxSpeed = Math.sqrt(2 * pendulum.gravity * height);
            maxSpeedValue.textContent = maxSpeed.toFixed(2) + " m/s";
            
            // 更新当前角度显示
            currentAngle.textContent = (Math.abs(pendulum.angle) * 180 / Math.PI).toFixed(2) + "°";
        }
        
        // 绘制箭头函数
        function drawArrow(ctx, fromX, fromY, toX, toY) {
            const headLength = 10;
            const dx = toX - fromX;
            const dy = toY - fromY;
            const angle = Math.atan2(dy, dx);
            
            ctx.beginPath();
            ctx.moveTo(fromX, fromY);
            ctx.lineTo(toX, toY);
            ctx.stroke();
            
            ctx.beginPath();
            ctx.moveTo(toX, toY);
            ctx.lineTo(toX - headLength * Math.cos(angle - Math.PI/6), toY - headLength * Math.sin(angle - Math.PI/6));
            ctx.moveTo(toX, toY);
            ctx.lineTo(toX - headLength * Math.cos(angle + Math.PI/6), toY - headLength * Math.sin(angle + Math.PI/6));
            ctx.stroke();
        }
        
        // 绘制单摆
        function drawPendulum() {
            // 清除画布
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // 绘制支点
            ctx.beginPath();
            ctx.arc(pendulum.pivotX, pendulum.pivotY, 8, 0, Math.PI * 2);
            ctx.fillStyle = '#1a2a6c';
            ctx.fill();
            
            // 计算摆球位置
            const bobX = pendulum.pivotX + pendulum.length * 150 * Math.sin(pendulum.angle);
            const bobY = pendulum.pivotY + pendulum.length * 150 * Math.cos(pendulum.angle);
            
            // 绘制轨迹 - 虚线
            if (pendulum.trail.length > 1) {
                ctx.beginPath();
                ctx.setLineDash([5, 5]); // 设置虚线样式
                ctx.moveTo(pendulum.trail[0].x, pendulum.trail[0].y);
                
                for (let i = 1; i < pendulum.trail.length; i++) {
                    ctx.lineTo(pendulum.trail[i].x, pendulum.trail[i].y);
                }
                
                ctx.strokeStyle = 'rgba(74, 123, 255, 0.5)';
                ctx.lineWidth = 2;
                ctx.stroke();
                ctx.setLineDash([]); // 重置为实线
                
                // 在轨迹上添加箭头表示方向
                if (pendulum.trail.length > 10) {
                    // 每隔一定距离添加箭头
                    const arrowSpacing = 15;
                    let arrowCount = 0;
                    
                    for (let i = 0; i < pendulum.trail.length - 1; i += arrowSpacing) {
                        if (arrowCount >= 3) break; // 最多添加3个箭头
                        
                        const currentPoint = pendulum.trail[i];
                        const nextPoint = pendulum.trail[i + 1];
                        
                        // 确定运动方向
                        const direction = nextPoint.x > currentPoint.x ? 1 : -1;
                        
                        // 只有当方向与当前运动方向一致时才绘制箭头
                        if (direction === pendulum.direction) {
                            ctx.strokeStyle = '#4a7bff';
                            ctx.lineWidth = 2;
                            drawArrow(ctx, currentPoint.x, currentPoint.y, nextPoint.x, nextPoint.y);
                            arrowCount++;
                        }
                    }
                }
            }
            
            // 绘制摆线
            ctx.beginPath();
            ctx.moveTo(pendulum.pivotX, pendulum.pivotY);
            ctx.lineTo(bobX, bobY);
            ctx.strokeStyle = '#1a2a6c';
            ctx.lineWidth = 2;
            ctx.stroke();
            
            // 绘制摆球
            ctx.beginPath();
            // 根据质量调整摆球大小
            const radius = pendulum.bobRadius + (pendulum.mass - 1) * 2;
            ctx.arc(bobX, bobY, radius, 0, Math.PI * 2);
            const gradient = ctx.createRadialGradient(
                bobX - 5, bobY - 5, 5,
                bobX, bobY, radius
            );
            gradient.addColorStop(0, '#4a7bff');
            gradient.addColorStop(1, '#1a2a6c');
            ctx.fillStyle = gradient;
            ctx.fill();
            ctx.strokeStyle = '#1a2a6c';
            ctx.lineWidth = 1;
            ctx.stroke();
            
            // 更新数据显示
            const currentSpeed = Math.abs(pendulum.angularVelocity * pendulum.length);
            speedValue.textContent = currentSpeed.toFixed(2) + " m/s";
            
            const currentPosition = pendulum.length * Math.sin(pendulum.angle);
            positionValue.textContent = currentPosition.toFixed(2) + " m";
            
            // 更新当前角度显示
            currentAngle.textContent = (Math.abs(pendulum.angle) * 180 / Math.PI).toFixed(2) + "°";
            
            // 更新运动方向
            if (pendulum.angularVelocity !== 0) {
                pendulum.direction = pendulum.angularVelocity > 0 ? 1 : -1;
            }
            
            // 添加轨迹点
            pendulum.trail.push({x: bobX, y: bobY});
            if (pendulum.trail.length > 50) {
                pendulum.trail.shift();
            }
        }
        
        // 更新单摆状态
        function updatePendulum() {
            if (!pendulum.isRunning) return;
            
            // 使用数值积分更新角度和角速度
            const timeStep = 0.016; // 约60FPS
            
            // 计算角加速度
            const angularAcceleration = -pendulum.gravity / pendulum.length * Math.sin(pendulum.angle);
            
            // 更新角速度
            pendulum.angularVelocity += angularAcceleration * timeStep;
            
            // 更新角度
            pendulum.angle += pendulum.angularVelocity * timeStep;
            
            // 更新时间
            pendulum.time += timeStep;
            
            // 绘制单摆
            drawPendulum();
            
            // 继续动画
            pendulum.animationId = requestAnimationFrame(updatePendulum);
        }
        
        // 开始模拟
        startBtn.addEventListener('click', function() {
            if (!pendulum.isRunning) {
                pendulum.isRunning = true;
                updatePendulum();
            }
        });
        
        // 暂停模拟
        pauseBtn.addEventListener('click', function() {
            pendulum.isRunning = false;
            if (pendulum.animationId) {
                cancelAnimationFrame(pendulum.animationId);
            }
        });
        
        // 重置模拟
        resetBtn.addEventListener('click', function() {
            pendulum.isRunning = false;
            if (pendulum.animationId) {
                cancelAnimationFrame(pendulum.animationId);
            }
            
            pendulum.angle = parseFloat(angleSlider.value) * Math.PI / 180;
            pendulum.angularVelocity = 0;
            pendulum.time = 0;
            pendulum.trail = [];
            pendulum.direction = 1;
            
            updateDisplayValues();
            drawPendulum();
        });
        
        // 更新参数
        lengthSlider.addEventListener('input', function() {
            pendulum.length = parseFloat(this.value);
            updateDisplayValues();
            if (!pendulum.isRunning) {
                drawPendulum();
            }
        });
        
        angleSlider.addEventListener('input', function() {
            pendulum.angle = parseFloat(this.value) * Math.PI / 180;
            updateDisplayValues();
            if (!pendulum.isRunning) {
                drawPendulum();
            }
        });
        
        massSlider.addEventListener('input', function() {
            pendulum.mass = parseFloat(this.value);
            updateDisplayValues();
            if (!pendulum.isRunning) {
                drawPendulum();
            }
        });
        
        gravitySlider.addEventListener('input', function() {
            pendulum.gravity = parseFloat(this.value);
            updateDisplayValues();
        });
        
        // 响应式Canvas调整
        function handleResize() {
            const container = document.querySelector('.canvas-container');
            const containerWidth = container.clientWidth;
            
            // 设置Canvas显示尺寸
            canvas.style.width = containerWidth + 'px';
            canvas.style.height = containerWidth + 'px';
            
            // 更新单摆支点位置
            pendulum.pivotX = containerWidth / 2;
            
            // 重新绘制单摆
            if (!pendulum.isRunning) {
                drawPendulum();
            }
        }
        
        // 初始调整Canvas大小
        handleResize();
        
        // 监听窗口大小变化
        window.addEventListener('resize', handleResize);
        
        // 初始化
        updateDisplayValues();
        drawPendulum();
    </script>
</body>
</html>

单摆实验模拟_SimplePendulum_deepseek.html (点击打开或右键另存)

Doc批量离线转PDF

Tue, 11 Nov 2025 12:23:45 +0800

虽然WPS和Office都自带转Pdf功能，但是批量转对于普通用户来说有一定难度，所以写此小应用（文末有下载）

软件运行需要调用 wps文字或 word 组件，优先调用wps文字

支持文件拖拽放入，最大测试量500个 doc或docx 。

转换后pdf文件与源文件对比无任何格式失真。

widget.cpp

#include "widget.h"
#include "ui_widget.h"

#include <QAxObject>
#include <QDebug>
#include <QMessageBox>

#include <QTextCodec>

#include <QFileDialog>
#include <QDir>
#include <QMenu>
#include <QPoint>
#include <QMimeData>
#include <QDropEvent>
#include <QProgressBar>
#include "about.h"

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

    ui->listWidget->setDragDropMode(QAbstractItemView::InternalMove);
    ui->listWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
    this->setAcceptDrops(true);
    ui->topWidget->installEventFilter(this);

    ui->listWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->lineEdit->setPlaceholderText("选择文件保存路径");

    connect(ui->setPathBtn,&QPushButton::clicked,this,&Widget::setPdfPath);
    connect(ui->listWidget,SIGNAL(customContextMenuRequested(const QPoint &)),this,SLOT(onCustomContextMenuRequested(const QPoint &)));
    connect(ui->lineEdit,&QLineEdit::textChanged,this,&Widget::isReady);
    connect(ui->coverBtn,&QPushButton::clicked,this,&Widget::coverToPdf);
    connect(ui->closeBtn,&QPushButton::clicked,this,&Widget::close);
    connect(ui->helpBtn,&QPushButton::clicked,this,&Widget::openAbout);
}

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

void Widget::initUI(){
    this->setWindowFlags(Qt::FramelessWindowHint);
    this->setMaximumHeight(591);
    this->setMinimumHeight(591);
    this->setMaximumWidth(511);
    this->setMinimumWidth(511);
    ui->lineEdit->setFocusPolicy(Qt::NoFocus);
    ui->coverBtn->setEnabled(false);
    ui->progressBar->setOrientation(Qt::Horizontal);  // 水平方向
    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(100);
    ui->progressBar->setMaximumHeight(22);
    ui->progressBar->setMaximumWidth(401);
    QPixmap pixmap(":/res/bg.png"); //通过构造函数载入图片方式
    pixmap.scaled(ui->bgLabel->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
    ui->bgLabel->setScaledContents(true);
    ui->bgLabel->setPixmap(pixmap);
    QFile file(":/res/style.qss");
    file.open(QFile::ReadOnly);
    QString styleSheet = QLatin1String(file.readAll());
    this->setStyleSheet(styleSheet);
    file.close();
    ui->coverLabel->setAlignment(Qt::AlignLeft);
}

void Widget::setPdfPath(){

    QString defaultPath = QDir::currentPath();
    QString dirPath = QFileDialog::getExistingDirectory(this,tr("浏览选择文件夹"),defaultPath);

    QTextCodec *code = QTextCodec::codecForName("UTF-8");
    QString filename = QString::fromStdString(code->fromUnicode(dirPath).data());
    dirPath = QDir::toNativeSeparators(dirPath);

    if(dirPath.isEmpty())
    {
        return;
    }
    else
    {
        ui->lineEdit->setText(dirPath);
    }
}

void Widget::convertWpsToPdf(const QString &docFilePath, const QString &pdfFilePath) {
    QAxObject wpsApp("KWPS.Application");
    wpsApp.dynamicCall("SetVisible(bool)", false);
    QAxObject* docs = wpsApp.querySubObject("Documents");
    QAxObject* doc = docs->querySubObject("Open(const QString&)", docFilePath);
    if (doc) {
        doc->dynamicCall("ExportAsFixedFormat(const QString&, WdExportFormat)", pdfFilePath, 17); 
        doc->dynamicCall("Close()");
    }
    wpsApp.dynamicCall("Quit()");
}

void Widget::convertDocToPdf(const QString &docFilePath, const QString &pdfFilePath) {
    QAxObject wordApp("Word.Application");
    wordApp.dynamicCall("SetVisible(bool)", false); // 隐藏Word界面
    QAxObject* docs = wordApp.querySubObject("Documents");
    QAxObject* doc = docs->querySubObject("Open(const QString&)", docFilePath);
    if (doc) {
        doc->dynamicCall("ExportAsFixedFormat(const QString&, WdExportFormat)", pdfFilePath, 17); 
        doc->dynamicCall("Close()");
    }
    wordApp.dynamicCall("Quit()");
}

//右键删除
void Widget::onCustomContextMenuRequested(const QPoint &pos)
{
    QListWidgetItem* curItem = ui->listWidget->itemAt(pos);
    if( curItem == NULL )
        return;

    QIcon icon3 = QIcon(":/res/del.png");
    QMenu *popMenu = new QMenu(ui->listWidget);
    QAction *Menu3 = new QAction(icon3,"删除");
    popMenu->addAction(Menu3);
    connect(Menu3, SIGNAL(triggered(bool)), this, SLOT(onDelItem()));
    popMenu->exec(QCursor::pos());
}

//删除选中
void Widget::onDelItem()
{
    QList<QListWidgetItem*> list = ui->listWidget->selectedItems();
    if(list.size() == 0)
        return;
    for(int i=0;i<list.count();i++){
        QListWidgetItem *sel = list[i];
        if(sel){
            ui->listWidget->removeItemWidget(sel);
            delete sel;

            this->listWidgetChanged();
            this->isReady();
        }
    }
}

void Widget::dragEnterEvent(QDragEnterEvent *event)
{
    if(event->mimeData()->hasUrls())
    {
        event->acceptProposedAction(); //事件数据中存在路径，方向事件
    }
    else
    {
        event->ignore();
    }
}

//拖动文件到窗口释放文件，触发
void Widget::dropEvent(QDropEvent *event)
{
    const QMimeData *mimeData = event->mimeData();
    if(mimeData->hasUrls())
    {
        QList<QUrl> urls = mimeData->urls();
        for(int i=0;i<urls.count();i++)
        {
            QListWidgetItem *item = new QListWidgetItem;
            item->setSizeHint(QSize(0,24));
            QString fileName = urls.at(i).toLocalFile();
            QFileInfo fileinfo = QFileInfo(fileName);
            item->setText(fileinfo.fileName());
            QString suf = fileinfo.suffix();
            if(suf == "doc" || suf == "docx" || suf == "DOC" || suf == "DOCX")
            {
                ui->listWidget->addItem(item);
                item->setData(Qt::UserRole,fileName);
                this->listWidgetChanged();
                this->isReady();
            }
        }
    }
}

void Widget::listWidgetChanged(){
    int itemCount = ui->listWidget->count();
    if(itemCount==0){
        ui->statusLabel->setVisible(false);
        ui->coverLabel->setVisible(false);
        ui->progressBar->setValue(0);
    }
    else{
        ui->statusLabel->setAlignment(Qt::AlignLeft);
        QString countInfo = QString("文件数：%1").arg(itemCount);
        ui->statusLabel->setVisible(true);
        ui->statusLabel->setText(countInfo);
        ui->coverLabel->setVisible(true);
    }
}

void Widget::isReady(){
    if(ui->lineEdit->text().isEmpty() || ui->listWidget->count()==0){
        ui->coverBtn->setEnabled(false);
    }
    else{
        ui->coverBtn->setEnabled(true);
    }
}

void Widget::coverToPdf(){
    if(!(ui->lineEdit->text().isEmpty() || ui->listWidget->count()==0)){
        ui->coverLabel->setVisible(true);
        ui->coverLabel->setText("准备转换 ......");
        QAxObject wpsApp("KWPS.Application");
        QAxObject wordApp("Word.Application");
        ui->progressBar->setValue(0);
        int docCount = ui->listWidget->count();
        int coverCount = 0;
        QString currentInfo;
        int currentPro = 0;
        int appFlag = 0;
        for(int i = 0; i< docCount; i++){
            QString docFullName = ui->listWidget->item(i)->data(Qt::UserRole).toString();
            QFileInfo docInfo(docFullName);
            QString pdfPath = ui->lineEdit->text();
            QString pdfFullName = pdfPath +"\\"+ docInfo.baseName()+".pdf";

            QTextCodec *code = QTextCodec::codecForName("UTF-8");
            docFullName = QString::fromStdString(code->fromUnicode(docFullName).data());
            docFullName = QDir::toNativeSeparators(docFullName); 

            pdfPath = QString::fromStdString(code->fromUnicode(pdfPath).data()); 
            pdfPath = QDir::toNativeSeparators(pdfPath); 

            ui->listWidget->setCurrentRow(i);
            if(!wpsApp.isNull()){
               convertWpsToPdf(docFullName, pdfFullName);
               coverCount = coverCount + 1;
               appFlag = 1;
            }
            else if(!wordApp.isNull()){
               convertDocToPdf(docFullName, pdfFullName);
               coverCount = coverCount + 1;
               appFlag = 2;
            }
            else{
               QMessageBox msgbox;
               msgbox.setWindowTitle("出错提示");
               msgbox.setInformativeText("无法进行格式转换，程序将正常退出！");
               msgbox.setStandardButtons(QMessageBox::Ok);
               msgbox.setButtonText(QMessageBox::Ok, QStringLiteral("确定"));
               int reply = msgbox.exec();
               if(reply == QMessageBox::Ok)
               {
                   break;
                   this->close();
               }
            }
            currentInfo = QString("完成数：%1").arg(coverCount);
            ui->coverLabel->setText(currentInfo);
            currentPro = int((i+1)*100/docCount);
            ui->progressBar->setValue(currentPro);
        }


        if(appFlag>0){
            if(appFlag == 1){
                wpsApp.clear();
                //wpsApp.dynamicCall("Quit()");
            }
            else{
                wordApp.clear();
                //wordApp.dynamicCall("Quit()");
            }
        }
    }
}

void Widget::closeEvent(QCloseEvent *event)
{
        event->accept();
        Widget::deleteLater();
}

void Widget::openAbout()
{
    about *a = new about(this);
    a->setModal(false);
    a->show();
}

void Widget::mouseMoveEvent(QMouseEvent *event)
{
    if(m_leftButtonPressed && !this->window()->isMaximized())
    {
        this->window()->move(this->window()->geometry().topLeft()+event->globalPos()-m_start);
        m_start = event->globalPos();
    }
}

void Widget::mouseReleaseEvent(QMouseEvent *event)
{
    if(event->button()==Qt::LeftButton){
        m_leftButtonPressed = false;
    }
}

bool Widget::eventFilter(QObject *watched, QEvent * event)
{
    if(event->type()==QEvent::MouseButtonDblClick)
    {
        QMouseEvent * e = static_cast<QMouseEvent *>(event);
        if(e->button() == Qt::LeftButton)
        {
            if(watched==ui->topWidget)
                //ui->restoreBtn->click();
            return true;
        }
    }
    return QWidget::eventFilter(watched, event);
}
void Widget::mousePressEvent(QMouseEvent *event)
{
    if(event->button()==Qt::LeftButton)
    {
        m_leftButtonPressed = true;
        m_start = event->globalPos();
    }
}

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QAxWidget>


QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void dragEnterEvent(QDragEnterEvent *event);
    void dropEvent(QDropEvent *event);

    void mousePressEvent(QMouseEvent *event);
    void mouseMoveEvent(QMouseEvent *event);
    void mouseReleaseEvent(QMouseEvent *event);
    bool eventFilter(QObject *watched, QEvent *event);

private slots:
    void convertWpsToPdf(const QString &docFilePath, const QString &pdfFilePath);
    void convertDocToPdf(const QString &docFilePath, const QString &pdfFilePath);
    void setPdfPath();
    void onDelItem();
    void onCustomContextMenuRequested(const QPoint &pos);
    void listWidgetChanged();
    void isReady();
    void coverToPdf();
    void closeEvent(QCloseEvent *event);
    void openAbout();

private:
    Ui::Widget *ui;

    void initUI();
    QPoint m_start;  //起始点
    QPoint m_end;    //结束点
    bool m_leftButtonPressed;   //鼠标左键按下标记




};
#endif // WIDGET_H

widget.ui

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Widget</class>
 <widget class="QWidget" name="Widget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>511</width>
    <height>591</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Doc批量转Pdf</string>
  </property>
  <widget class="QLabel" name="label">
   <property name="geometry">
    <rect>
     <x>20</x>
     <y>502</y>
     <width>51</width>
     <height>16</height>
    </rect>
   </property>
   <property name="text">
    <string>保存位置</string>
   </property>
  </widget>
  <widget class="QLineEdit" name="lineEdit">
   <property name="geometry">
    <rect>
     <x>80</x>
     <y>500</y>
     <width>331</width>
     <height>23</height>
    </rect>
   </property>
  </widget>
  <widget class="QPushButton" name="setPathBtn">
   <property name="geometry">
    <rect>
     <x>420</x>
     <y>500</y>
     <width>71</width>
     <height>23</height>
    </rect>
   </property>
   <property name="text">
    <string>选择</string>
   </property>
  </widget>
  <widget class="QProgressBar" name="progressBar">
   <property name="geometry">
    <rect>
     <x>20</x>
     <y>530</y>
     <width>391</width>
     <height>23</height>
    </rect>
   </property>
   <property name="value">
    <number>0</number>
   </property>
   <property name="alignment">
    <set>Qt::AlignCenter</set>
   </property>
   <property name="textVisible">
    <bool>true</bool>
   </property>
   <property name="orientation">
    <enum>Qt::Horizontal</enum>
   </property>
   <property name="textDirection">
    <enum>QProgressBar::TopToBottom</enum>
   </property>
  </widget>
  <widget class="QPushButton" name="coverBtn">
   <property name="geometry">
    <rect>
     <x>420</x>
     <y>530</y>
     <width>71</width>
     <height>23</height>
    </rect>
   </property>
   <property name="text">
    <string>开始</string>
   </property>
  </widget>
  <widget class="QLabel" name="statusLabel">
   <property name="geometry">
    <rect>
     <x>10</x>
     <y>572</y>
     <width>91</width>
     <height>16</height>
    </rect>
   </property>
   <property name="text">
    <string/>
   </property>
   <property name="alignment">
    <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
   </property>
  </widget>
  <widget class="QListWidget" name="listWidget">
   <property name="geometry">
    <rect>
     <x>20</x>
     <y>50</y>
     <width>471</width>
     <height>441</height>
    </rect>
   </property>
  </widget>
  <widget class="QLabel" name="coverLabel">
   <property name="geometry">
    <rect>
     <x>110</x>
     <y>572</y>
     <width>391</width>
     <height>16</height>
    </rect>
   </property>
   <property name="text">
    <string/>
   </property>
   <property name="alignment">
    <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
   </property>
  </widget>
  <widget class="QLabel" name="bgLabel">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>511</width>
     <height>591</height>
    </rect>
   </property>
   <property name="text">
    <string/>
   </property>
  </widget>
  <widget class="QPushButton" name="closeBtn">
   <property name="geometry">
    <rect>
     <x>480</x>
     <y>7</y>
     <width>22</width>
     <height>22</height>
    </rect>
   </property>
   <property name="text">
    <string/>
   </property>
  </widget>
  <widget class="QPushButton" name="helpBtn">
   <property name="geometry">
    <rect>
     <x>450</x>
     <y>7</y>
     <width>22</width>
     <height>22</height>
    </rect>
   </property>
   <property name="text">
    <string/>
   </property>
  </widget>
  <widget class="QWidget" name="topWidget" native="true">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>511</width>
     <height>33</height>
    </rect>
   </property>
  </widget>
  <zorder>topWidget</zorder>
  <zorder>bgLabel</zorder>
  <zorder>label</zorder>
  <zorder>lineEdit</zorder>
  <zorder>setPathBtn</zorder>
  <zorder>progressBar</zorder>
  <zorder>coverBtn</zorder>
  <zorder>statusLabel</zorder>
  <zorder>listWidget</zorder>
  <zorder>coverLabel</zorder>
  <zorder>closeBtn</zorder>
  <zorder>helpBtn</zorder>
 </widget>
 <resources/>
 <connections/>
</ui>

下载： Doc批量离线转Pdf

LNMP环境搭建

Mon, 10 Nov 2025 09:44:35 +0800

RockyLinux 9.4 ； Nginx 1.20.1； Mariadb 10.5.27 ； PHP 8.0.30

1. Nginx 安装

dnf update
dnf install nginx

1.1 Nginx 自启服务配置

systemctl enable nginx.service

1.2 Nginx 启动、停止、重启、状态查看

systemctl start nginx.service
systemctl stop nginx.service
systemctl restart nginx.service
systemctl status nginx.service

2. Mariadb Server 安装

dnf install mariadb mariadb-serve

2.1 Mariadb Server 自启服务配置

systemctl enable mariadb.service

2.2 Mariadb-Server 启动、停止、重启、状态查看

systemctl start mariadb.service
systemctl stop mariadb.service
systemctl restart mariadb.service
systemctl status mariadb.service

3. PHP 安装

dnf install php php-fpm php-mysqlnd php-gd php-xml php-pdo php-pcre php-zlib

3.1 php-fpm自启服务配置

systemctl enable php-fpm.service

3.2 php-fpm Nginx 启动、停止、重启、状态查看

systemctl start php-fpm.service
systemctl stop php-fpm.service
systemctl restart php-fpm.service
systemctl status php-fpm.service

4. Mariadb 常用配置（默认端3306，某些操作需要设置防火墙相关）

4.1 运行安全脚本配置

mysql_secure_installation

设置root密码。
是否删除匿名用户。
是否禁止root远程登录。
是否删除测试数据库和访问权限。
重新加载权限表。

4.2 登录到 Mariadb （以root身份登录）

mysql -u root -p;

4.3 创建数据库、用户、授权

CREATE DATABASE mydatabase;    //创建数据库
CREATE USER 'myuser'@'localhost' IDENTIFIED BY 'password';    //创建用户和设置密码，允许本地登录；"localhost" 更换为 "%" :允许从任何位置登录； 
GRANT ALL PRIVILEGES ON mydatabase.* TO 'myuser'@'localhost';    //授权操作权限
FLUSH PRIVILEGES;    //刷新权限

图片轮播应用_imgShow

Sun, 09 Nov 2025 20:36:51 +0800

一个用于图片轮播的工具，支持自定义图片播放时间，开始和结束播放时间（不在播放时间范围内黑屏），开始播放后屏蔽除了ESC以外的常用按键。写该小应用是为了简化LED大屏播放图片的操作。

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QSystemTrayIcon>
#include <QTime>

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

    void dragEnterEvent(QDragEnterEvent*event) Q_DECL_OVERRIDE;
    void dropEvent(QDropEvent *event) Q_DECL_OVERRIDE;

    void readConfigIni();


private slots:
    void onAddImg();
    void onCustomContextMenuRequested(const QPoint &);
    void onDelItem();
    void itemUp();
    void itemDown();

    void saveConfigIni();

    void startPlay();
protected:


private:
    Ui::MainWindow *ui;
    QString duration;

    QTime startTime;
    QTime endTime;



};
#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QFileDialog>
#include <QDebug>
#include <QMenu>
#include <QPoint>
#include <QListWidget>
#include <QDropEvent>
#include <QMimeData>
#include <QPainter>
#include <QSettings>
#include <QTextCodec>
#include <QStandardPaths>
#include <QList>
#include <QTime>

#include "imgplayer.h"

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

    this->setWindowFlags(Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint);

    ui->imgListWidget->setDragDropMode(QAbstractItemView::InternalMove);
    ui->imgListWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);

    this->readConfigIni();
    QObject::connect(ui->addImgBtn,SIGNAL(clicked(bool)),this,SLOT(onAddImg()));
    QObject::connect(ui->saveBtn,SIGNAL(clicked(bool)),this,SLOT(saveConfigIni()));
    QObject::connect(ui->imgListWidget,SIGNAL(customContextMenuRequested(const QPoint &)),this,SLOT(onCustomContextMenuRequested(const QPoint &)));
    this->setAcceptDrops(true); //必须设置，不然无法接收拖放事件
    ui->imgListWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    QObject::connect(ui->startBtn,SIGNAL(clicked(bool)),this,SLOT(startPlay()));

    //ui->durationSpinBox->setFocusPolicy(Qt::NoFocus);

}

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


void MainWindow::onAddImg()
{
    QStringList FileNames = QFileDialog::getOpenFileNames(this, QStringLiteral("选择图片文件！"), QStandardPaths::writableLocation(QStandardPaths::PicturesLocation),QStringLiteral("图片文件(*.png *.jpg *.bmp)"));
    int index=0,count=0;
    count = FileNames.count();
    for(index=0;index<=count-1;index++)
    {
        QListWidgetItem *item = new QListWidgetItem;
        item->setSizeHint(QSize(0,24));
        item->setText(QFileInfo(FileNames.at(index)).absoluteFilePath());
        QString suf = QFileInfo(FileNames.at(index)).suffix();
        ui->imgListWidget->addItem(item);
    }
    int itemCount = ui->imgListWidget->count();
    ui->countLabel->setText("图片数：" + QString::number(itemCount));
    itemCount>0?ui->startBtn->setEnabled(true):ui->startBtn->setEnabled(false);
}


//图片项右键
void MainWindow::onCustomContextMenuRequested(const QPoint &pos)
{
    QListWidgetItem* curItem = ui->imgListWidget->itemAt(pos);
    if( curItem == NULL )
        return;
    QMenu *popMenu = new QMenu(ui->imgListWidget);
    QAction *Menu1 = new QAction("上移");
    QAction *Menu2 = new QAction("下移");
    QAction *Menu3 = new QAction("删除");
    popMenu->addAction(Menu1);
    popMenu->addAction(Menu2);
    popMenu->addAction(Menu3);
    connect(Menu1, SIGNAL(triggered(bool)), this, SLOT(itemUp()));
    connect(Menu2, SIGNAL(triggered(bool)), this, SLOT(itemDown()));
    connect(Menu3, SIGNAL(triggered(bool)), this, SLOT(onDelItem()));
    popMenu->exec( QCursor::pos());
}

//删除选中
void MainWindow::onDelItem()
{
    QList<QListWidgetItem*> list = ui->imgListWidget->selectedItems();
    if(list.size() == 0)
        return;
    for(int i=0;i<list.count();i++){
        QListWidgetItem *sel = list[i];
        if(sel){
            ui->imgListWidget->removeItemWidget(sel);
            delete sel;
        }
    }
    int itemCount = ui->imgListWidget->count();
    ui->countLabel->setText("图片数：" + QString::number(itemCount));
    itemCount>0?ui->startBtn->setEnabled(true):ui->startBtn->setEnabled(false);
}

void MainWindow::itemUp()
{
    QList<QListWidgetItem*> list = ui->imgListWidget->selectedItems();
    if(list.size() == 0)
        return;
    for(int i=0;i<list.count();i++){
        QListWidgetItem *sel = list[i];
        if (sel)
        {
            ui->imgListWidget->setCurrentItem(sel);
            int currentRow = ui->imgListWidget->currentRow();
            if (currentRow == -1)
                return;
            int arriveRow = currentRow - 1 < 0 ? 0 : currentRow - 1;
            ui->imgListWidget->insertItem(std::min(currentRow, arriveRow), ui->imgListWidget->takeItem(std::max(currentRow, arriveRow)));
            ui->imgListWidget->setCurrentRow(arriveRow);
        }
    }
    ui->imgListWidget->setCurrentItem(NULL);
}

void MainWindow::itemDown()
{
    QList<QListWidgetItem*> list = ui->imgListWidget->selectedItems();
    if(list.size() == 0)
        return;
    for(int i=0;i<list.count();i++){
        QListWidgetItem *sel = list[i];
        if (sel)
        {
            ui->imgListWidget->setCurrentItem(sel);
            int currentRow = ui->imgListWidget->currentRow();
            if (currentRow == -1)
                return;
            int arriveRow = currentRow + 1 >= ui->imgListWidget->count() ? ui->imgListWidget->count() - 1 : currentRow + 1;
            ui->imgListWidget->insertItem(std::min(currentRow, arriveRow), ui->imgListWidget->takeItem(std::max(currentRow, arriveRow)));
            ui->imgListWidget->setCurrentRow(arriveRow);
        }
    }
    ui->imgListWidget->setCurrentItem(NULL);
}


//拖动文件到窗口，触发
void MainWindow::dragEnterEvent(QDragEnterEvent *event)
{
    if(event->mimeData()->hasUrls())
    {
        event->acceptProposedAction(); //事件数据中存在路径，方向事件
    }
    else
    {
        event->ignore();
    }
}


//拖动文件到窗口释放文件，触发
void MainWindow::dropEvent(QDropEvent *event)
{
    const QMimeData *mimeData = event->mimeData();
    if(mimeData->hasUrls())
    {
        QList<QUrl> urls = mimeData->urls();
        for(int i=0;i<urls.count();i++)
        {
            QListWidgetItem *item = new QListWidgetItem;
            item->setSizeHint(QSize(0,24));
            QString fileName = urls.at(i).toLocalFile();
            QFileInfo fileinfo = QFileInfo(fileName);
            item->setText(fileName);
            QString suf = fileinfo.suffix();
            if(suf == "jpg" || suf == "JPG")
            {
                ui->imgListWidget->addItem(item);
                item->setData(Qt::UserRole,fileName);
            }
            if(suf == "png" || suf == "PNG")
            {
                ui->imgListWidget->addItem(item);
                item->setData(Qt::UserRole,fileName);
            }
            if(suf == "bmp" || suf=="BMP")
            {
                ui->imgListWidget->addItem(item);
                item->setData(Qt::UserRole,fileName);
            }
        }
    }
    int itemCount = ui->imgListWidget->count();
    ui->countLabel->setText("图片数：" + QString::number(itemCount));
    itemCount>0?ui->startBtn->setEnabled(true):ui->startBtn->setEnabled(false);
}


void MainWindow::readConfigIni(){
    QString fullFileName= QDir::currentPath()+"/playconfig.ini";
    QFileInfo fileInfo(fullFileName);
    if(fileInfo.isFile()){
        QSettings *configIni = new QSettings(fullFileName, QSettings::IniFormat);
        configIni->setIniCodec(QTextCodec::codecForName("UTF_8")); //解决读取Ini文件中中文乱码的情况
        configIni->beginGroup("config");

        duration = configIni->value("duration").toString();
        ui->durationSpinBox->setValue(duration.toInt());

        QString startTime = configIni->value("starttime").toString();
        ui->startTimeTxt->setTime(QTime::fromString(startTime,"HH:mm:ss"));

        QString endTime = configIni->value("endtime").toString();
        ui->endTimeTxt->setTime(QTime::fromString(endTime,"HH:mm:ss"));

        configIni->endGroup();
        configIni->beginGroup("imgList");
        QStringList groupKeys = configIni->allKeys();
        for (const QString &key : groupKeys) {
            QString value = configIni->value(key).toString();
            QListWidgetItem *item = new QListWidgetItem;
            item->setText(value);
            ui->imgListWidget->addItem(item);
        }
        configIni->endGroup();
        int itemCount = ui->imgListWidget->count();
        ui->countLabel->setText("图片数：" + QString::number(itemCount));
    }
    else{
        ui->infoLabel->setText("配置文件读取失败 ");
    }
}

void MainWindow::saveConfigIni(){
    startTime = ui->startTimeTxt->time();
    endTime = ui->endTimeTxt->time();
    if(endTime<startTime){
        ui->infoLabel->setText("<font color='#ff0000'>时间不正确，配置文件保存失败 </font>");
        return;
    }

    QString fullFileName= QDir::currentPath()+"/playconfig.ini";
    QFileInfo fileInfo(fullFileName);
    if(fileInfo.isFile() && endTime>startTime){
        QSettings *configIni = new QSettings(fullFileName, QSettings::IniFormat);
        configIni->beginGroup("config");
        configIni->setValue("duration",ui->durationSpinBox->value());
        configIni->setValue("starttime",ui->startTimeTxt->time().toString());
        configIni->setValue("endtime",ui->endTimeTxt->time().toString());
        configIni->endGroup();

        configIni->beginGroup("imgList");
        QString  imgKey;
        if(ui->imgListWidget->count()==0){
            configIni->clear();
        }
        else{
            for(int i=0; i<ui->imgListWidget->count();i++){
                imgKey = QString("img%1").arg(i);
                configIni->setValue(imgKey,ui->imgListWidget->item(i)->text());
            }
        }
        configIni->endGroup();
        ui->infoLabel->setText("配置文件保存完毕 ");
    }
    else{
        ui->infoLabel->setText("<font color='#ff0000'>配置文件保存失败 </font>");
    }
}

void MainWindow::startPlay(){
    QStringList imgList;
    int duration = (ui->durationSpinBox->value())*1000;
    int imgCount = ui->imgListWidget->count();

    startTime = ui->startTimeTxt->time();
    endTime = ui->endTimeTxt->time();
    if(endTime<startTime){
        ui->infoLabel->setText("<font color='#ff0000'>时间不正确，无法开始！</font>");
        return;
    }

    if(imgCount>0 && endTime>startTime){
        for(int i=0; i<imgCount;i++){
            imgList.append(ui->imgListWidget->item(i)->text());
        }
        imgPlayer *mp = new imgPlayer(imgList, duration, startTime, endTime);
        mp->show();
        this->setWindowState(Qt::WindowMinimized);
        ui->infoLabel->setText("");
    }
}

imgplayer.h

#ifndef IMGPLAYER_H
#define IMGPLAYER_H

#include <QWidget>
#include <QTimer>

#include <QPixmap>
#include <QSystemTrayIcon>
#include <QDateTime>

#include <windows.h>

namespace Ui {
class imgPlayer;
}

class imgPlayer : public QWidget
{
    Q_OBJECT

public:
    explicit imgPlayer(const QStringList &m_imgList, const int &m_duration, const QTime &m_startTime, const QTime &m_endTime, QWidget *parent = nullptr);
    ~imgPlayer();

protected:
    void keyPressEvent(QKeyEvent *event) override;
    void enterEvent(QEvent *event) override;
    void cleanup();

private slots:
    void nextImage();
    void checkTask();

private:
    Ui::imgPlayer *ui;
    QTimer *imageTimer;
    QTimer *checkTimer;
    int duration;
    QPixmap pixmap;
    QStringList imgPathList;
    int currentImageIndex;
    QTime startTime;
    QTime endTime;

    bool taskFlag;
    bool runOnce;

    QDateTime now;

    static HHOOK hKeyboardHook;
    static LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);

};

#endif // IMGPLAYER_H

imgplayer.cpp

#include "imgplayer.h"
#include "ui_imgplayer.h"

#include <QFileInfo>
#include <QSettings>
#include <QDir>
#include <QTextCodec>
#include <QPixmap>
#include <QDebug>
#include <QKeyEvent>
#include <QCursor>
#include <QDateTime>
#include <QTime>

HHOOK imgPlayer::hKeyboardHook = nullptr;

imgPlayer::imgPlayer(const QStringList &m_imgList, const int &m_duration, const QTime &m_startTime, const QTime &m_endTime, QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::imgPlayer)
{

    // 安装低级键盘钩子
    hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(nullptr), 0);
    if (!hKeyboardHook) {
        return;
    }

    ui->setupUi(this);
    this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
    this->showFullScreen();

    ui->imgLabel->setText("等待播放中...");
    ui->imgLabel->setAlignment(Qt::AlignCenter);
    this->imgPathList = m_imgList;
    this->duration = m_duration;
    this->startTime = m_startTime;
    this->endTime = m_endTime;

    currentImageIndex = 0;
    taskFlag = false;
    runOnce = true;


    checkTimer = new QTimer(this);
    connect(checkTimer,&QTimer::timeout,this,&imgPlayer::checkTask);
    checkTimer->start(1000);

    imageTimer = new QTimer(this);
    connect(imageTimer,&QTimer::timeout,this,&imgPlayer::nextImage);
    imageTimer->start(duration);
}

imgPlayer::~imgPlayer()
{
    if (hKeyboardHook) {
        UnhookWindowsHookEx(hKeyboardHook);
    }
    cleanup();
    delete ui;
}

void imgPlayer::checkTask(){
    now = QDateTime::currentDateTime();
    if (now.time() >= startTime && now.time() < endTime){
        taskFlag = true;
        if(runOnce){
            currentImageIndex = 0;
            pixmap.load(imgPathList[currentImageIndex]);
            //ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::KeepAspectRatio,Qt::SmoothTransformation));
            ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation));
            ui->imgLabel->show();
            runOnce =false;
        }
    }
    else{
        taskFlag = false;
    }
}

void imgPlayer::nextImage()
{
    if (taskFlag){
        if(currentImageIndex >=imgPathList.size()){
            currentImageIndex = 0;
        }
        currentImageIndex = (currentImageIndex + 1) % imgPathList.size(); // 循环显示图片
        pixmap.load(imgPathList[currentImageIndex]);
        //ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::KeepAspectRatio,Qt::SmoothTransformation));
        ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation));
        ui->imgLabel->show();
    }
    else{
        pixmap.load(":/black.png");
        //ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::KeepAspectRatio,Qt::FastTransformation));
        ui->imgLabel->setPixmap(pixmap.scaled(ui->imgLabel->size(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation));
        ui->imgLabel->show();
    }
}

void imgPlayer::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Escape) {
        cleanup();
        this->close();
    }
}

void imgPlayer::cleanup()
{
    if (imageTimer) {
        imageTimer->stop();
        delete imageTimer;
        imageTimer = nullptr;
    }
    if (checkTimer) {
        checkTimer->stop();
        delete checkTimer;
        checkTimer = nullptr;
    }
}


void imgPlayer::enterEvent(QEvent *event) {
    if (event->type() == QEvent::Enter) {
        QCursor cursor(Qt::BlankCursor); // 创建一个透明的光标
        setCursor(cursor); // 将光标设置为当前窗口
    }
}


LRESULT CALLBACK imgPlayer::LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode == HC_ACTION) {
        KBDLLHOOKSTRUCT *pKeyInfo = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);

        // 拦截以下按键组合：
        bool isAltTab = pKeyInfo->vkCode == VK_TAB && (GetAsyncKeyState(VK_MENU) & 0x8000);
        bool isWinKey = pKeyInfo->vkCode == VK_LWIN || pKeyInfo->vkCode == VK_RWIN;
        bool isAltEsc = pKeyInfo->vkCode == VK_ESCAPE && (GetAsyncKeyState(VK_MENU) & 0x8000);
        bool isCtrlEsc = pKeyInfo->vkCode == VK_ESCAPE && (GetAsyncKeyState(VK_CONTROL) & 0x8000);

        bool isAltF4 = pKeyInfo->vkCode == VK_F4 && (GetAsyncKeyState(VK_MENU) & 0x8000);

        // 根据需要添加其他热键检测
        if (isAltTab || isWinKey || isAltEsc || isCtrlEsc || isAltF4) {
            return 1; // 拦截该事件
        }
    }
    // 传递其他事件
    return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
}

imgShow下载

Qt C++中生成验证码

Fri, 07 Nov 2025 00:24:41 +0800

verificationcode.h

#ifndef VERIFICATIONCODE_H
#define VERIFICATIONCODE_H
#include <QLabel>
#include <QPainter>
#include <QMouseEvent>
#include <QTime>

class VerificationCode : public QLabel
{
    Q_OBJECT
public:
    explicit VerificationCode(QWidget *parent = nullptr);

    // 获取当前验证码
    QString getCode() const;

    // 验证用户输入
    bool validate(const QString& input) const;

    // 公共方法：刷新验证码
    void refreshCode();

signals:
    void clicked();

protected:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;

private:
    void generateCode();
    void drawCode(QPainter &painter);

    QString m_code; // 存储当前验证码
    const int m_codeLength = 4; // 验证码长度
};

#endif // VERIFICATIONCODE_H

verificationcode.cpp

#include "verificationcode.h"
#include <QTime>
#include <QtMath>
#include <QDebug>
#include <QRandomGenerator>

VerificationCode::VerificationCode(QWidget *parent) : QLabel(parent)
{
    // 设置初始大小
    setFixedSize(120, 40);

    // 设置样式
    setStyleSheet("background-color: white; border: 1px solid gray;");

    // 生成初始验证码
    generateCode();

    // 启用鼠标跟踪
    setMouseTracking(true);

    // 设置光标形状为手型，提示可点击
    setCursor(Qt::PointingHandCursor);
}

QString VerificationCode::getCode() const
{
    return m_code;
}

bool VerificationCode::validate(const QString &input) const
{
    return input.toUpper() == m_code.toUpper(); // 不区分大小写比较
}

void VerificationCode::refreshCode()
{
    generateCode();
    update(); // 触发重绘
}

void VerificationCode::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);

    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);

    // 绘制背景
    painter.fillRect(rect(), Qt::white);

    // 绘制验证码
    drawCode(painter);
}

void VerificationCode::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        refreshCode();
        emit clicked();
    }
    QLabel::mousePressEvent(event);
}

void VerificationCode::generateCode()
{
    const QString charSet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    m_code.clear();
    QRandomGenerator::global()->bounded(QTime::currentTime().msec()); // 设置随机种子
    for (int i = 0; i < m_codeLength; ++i) {
        int index = QRandomGenerator::global()->bounded(0,100) % charSet.length();
        m_code.append(charSet.at(index));
    }
}

void VerificationCode::drawCode(QPainter &painter)
{
    // 绘制干扰点
    for (int i = 0; i < 100; ++i) {
        int x = QRandomGenerator::global()->bounded(0,100) % width();
        int y = QRandomGenerator::global()->bounded(0,100) % height();
        painter.setPen(QColor(QRandomGenerator::global()->bounded(0,100) % 256, QRandomGenerator::global()->bounded(0,100) % 256, QRandomGenerator::global()->bounded(0,100) % 256, 100));
        painter.drawPoint(x, y);
    }

    // 绘制干扰线
    for (int i = 0; i < 5; ++i) {
        painter.setPen(QColor(QRandomGenerator::global()->bounded(0,256), QRandomGenerator::global()->bounded(0,256), QRandomGenerator::global()->bounded(0,256), 100));
        painter.drawLine(QRandomGenerator::global()->bounded(0,100) % width(), QRandomGenerator::global()->bounded(0,100) % height(), QRandomGenerator::global()->bounded(0,100) % width(), QRandomGenerator::global()->bounded(0,100) % height());
    }

    // 绘制验证码文本
    for (int i = 0; i < m_code.length(); ++i) {
        // 设置随机颜色
        painter.setPen(QColor(QRandomGenerator::global()->bounded(0,128) + 64, QRandomGenerator::global()->bounded(0,128) + 64, QRandomGenerator::global()->bounded(0,128) + 64));

        // 设置随机字体大小
        QFont font;
        font.setPointSize(18 + QRandomGenerator::global()->bounded(0,5));
        font.setBold(QRandomGenerator::global()->bounded(0,5));
        painter.setFont(font);

        // 计算字符位置（稍微随机偏移）
        int x = 10 + i * (width() - 20) / m_codeLength;
        int y = height() / 2 + 10 - QRandomGenerator::global()->bounded(0,8);

        // 添加随机旋转
        painter.save();
        painter.translate(x, y);
        painter.rotate(QRandomGenerator::global()->bounded(-15,15)); // -15到15度随机旋转
        painter.drawText(0, 0, QString(m_code[i]));
        painter.restore();
    }
}

网络唤醒魔术包构建和应用

Thu, 06 Nov 2025 20:58:19 +0800

“网络唤醒（Wake-on-LAN, WOL）是一种通过局域网发送特殊数据包（魔术包）远程唤醒处于休眠或关机状态计算机的技术“（摘自百度百科）

下面代码用于构建和发送魔术包唤醒远端设备

void onSendMagicPacket(QString strMac,QString targetAddr, quint16 targetPort)
{
  char cstrMacAddr[6];
  bool isOK;
  for(int j = 0;j < 6; j++){
      if(j < 5){
          cstrMacAddr[j] = strMac.mid(strMac.indexOf(":",j*3) - 2,2).toInt(&isOK,16);
          if(false == isOK)
              return ;
      }else if(j == 5){
          cstrMacAddr[j] = strMac.mid(strMac.indexOf(":",j*3 - 1) + 1,2).toInt(&isOK,16);
          if(false == isOK)
              return ;
      }
  }
  /*构建一个魔术唤醒包  6字节0xFF和16次的Mac地址*/
  QByteArray magicPacket;
  /*6个 0xFF*/
  for(int i = 0;i < 6; i++){
      magicPacket[i] = 0xFF;
  }
  /*16个 MAC*/
  for(int k = 0; k < 16; k++)
  {
      for(int l = 0; l < 6; l++)
          magicPacket[(k+1)*6 + l] = cstrMacAddr[l];
  }
  udpSocket->writeDatagram(magicPacket,QHostAddress(targetAddr),quint16(targetPort)); //发出数据报
  udpSocket->writeDatagram(magicPacket,QHostAddress("255.255.255.255"),quint16(9)); //发出数据报
}