if (isPlaying) {
    pause();
} else if (isPaused) {
    resume();
} else if (isStopped) {
    play();
}
// ... 各种if else嵌套，自己都快绕晕了

#include <QStateMachine>
#include <QState>
#include <QFinalState>
#include <QSignalTransition>

// 假设有以下按钮和播放器核心
QPushButton *playButton;
QPushButton *pauseButton;
QPushButton *stopButton;
// MyPlayerCore 是一个假想的播放器核心类
MyPlayerCore *player; 

// 1. 创建状态机和状态
QStateMachine *machine = new QStateMachine;

QState *stoppedState = new QState();      // 停止状态
QState *playingState = new QState();      // 播放状态
QState *pausedState = new QState();       // 暂停状态
QFinalState *finalState = new QFinalState(); // 最终状态（用于退出）

// 2. 为状态添加进入/退出操作
stoppedState->assignProperty(playButton, "enabled", true);
stoppedState->assignProperty(pauseButton, "enabled", false);
stoppedState->assignProperty(stopButton, "enabled", false);

playingState->assignProperty(playButton, "enabled", false);
playingState->assignProperty(pauseButton, "enabled", true);
playingState->assignProperty(stopButton, "enabled", true);
QObject::connect(playingState, &QState::entered, player, &MyPlayerCore::play);

pausedState->assignProperty(playButton, "enabled", true);
pausedState->assignProperty(pauseButton, "enabled", false);
pausedState->assignProperty(stopButton, "enabled", true);
QObject::connect(pausedState, &QState::entered, player, &MyPlayerCore::pause);

QObject::connect(stoppedState, &QState::entered, player, &MyPlayerCore::stop);

// 3. 定义状态转换
// 从停止状态 -> 播放状态：当按下播放按钮时
stoppedState->addTransition(playButton, &QPushButton::clicked, playingState);
// 从播放状态 -> 暂停状态：当按下暂停按钮时
playingState->addTransition(pauseButton, &QPushButton::clicked, pausedState);
// 从播放状态 -> 停止状态：当按下停止按钮时
playingState->addTransition(stopButton, &QPushButton::clicked, stoppedState);
// 从暂停状态 -> 播放状态：当按下播放按钮时
pausedState->addTransition(playButton, &QPushButton::clicked, playingState);
// 从暂停状态 -> 停止状态：当按下停止按钮时
pausedState->addTransition(stopButton, &QPushButton::clicked, stoppedState);

// 4. 设置初始状态并启动状态机
machine->addState(stoppedState);
machine->addState(playingState);
machine->addState(pausedState);
machine->addState(finalState);

machine->setInitialState(stoppedState);
machine->start();

#include <cpprest/http_client.h>

void insecure_request() {
    http_client_config config;
    config.set_validate_certificates(false); // 关闭所有证书验证

    http_client client(U("https://self-signed.badssl.com/"), config);

    // 此时会接受任何证书，包括自签名、过期或域名不匹配的证书。
    client.request(web::http::methods::GET)
        .then([](http_response response) {
            // ... 处理响应 ...
        }).wait();
}

#include <cpprest/http_client.h>

// 自定义证书验证回调函数
bool my_certificate_callback(web::http::client::native_handle_type handle, const std::string& host) {
    // 参数:
    // - handle: 底层SSL库的上下文句柄（如OpenSSL的X509_STORE_CTX*）
    // - host: 正在连接的主机名

    // 这是一个高级接口，需要直接操作底层SSL库的API（如OpenSSL）。
    // 示例逻辑（伪代码）:
    // 1. 从 `handle` 中获取服务器证书链。
    // 2. 提取叶子证书的公钥或指纹（如SHA-256）。
    // 3. 与代码中预埋的预期值进行比较（证书钉钉）。
    // 4. 如果匹配，返回 true；否则返回 false。

    // 注意：返回 true 将接受证书，返回 false 将拒绝连接并抛出异常。
    // 对于测试，可以简单返回 true 来接受所有证书（效果同set_validate_certificates(false)）。
    return true; // 谨慎使用！
}

void custom_validation_request() {
    http_client_config config;
    // 设置自定义回调函数。一旦设置，系统默认验证将被绕过。
    config.set_certificate_callback(my_certificate_callback);

    http_client client(U("https://example.com"), config);

    client.request(web::http::methods::GET)
        .then([](http_response response) {
            // ... 处理响应 ...
        }).wait();
}

void heifToQPixmap(const QString& filePath, QPixmap& pixmap) {
QString extension = QFileInfo(filePath).suffix().toLower();

if (extension == "jpg" || extension == "jpeg") {
if (!pixmap.load(filePath)) {
throw std::runtime_error("Failed to load JPG image.");
}
return;
}
std::string filePathStd = filePath.toStdString();

struct heif_context* ctx = heif_context_alloc();
if (!ctx) {
throw std::runtime_error("Failed to allocate HEIF context.");
}

struct heif_error err = heif_context_read_from_file(ctx, filePathStd.c_str(), nullptr);
if (err.code != heif_error_Ok) {
heif_context_free(ctx);
throw std::runtime_error("Failed to read HEIF file: " + std::string(err.message));
}

struct heif_image_handle* handle = nullptr;
err = heif_context_get_primary_image_handle(ctx, &handle);
if (err.code != heif_error_Ok) {
heif_context_free(ctx);
throw std::runtime_error("Failed to get primary image handle: " + std::string(err.message));
}

struct heif_image* img = nullptr;
err = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_RGBA, nullptr);
if (err.code != heif_error_Ok) {
heif_image_handle_release(handle);
heif_context_free(ctx);
throw std::runtime_error("Failed to decode HEIF image: " + std::string(err.message));
}

int width = heif_image_get_width(img, heif_channel_interleaved);
int height = heif_image_get_height(img, heif_channel_interleaved);
const uint8_t* data = heif_image_get_plane_readonly(img, heif_channel_interleaved, nullptr);

QVector<uchar> buffer(width * height * 4);
memcpy(buffer.data(), data, buffer.size());

QImage image(buffer.data(), width, height, QImage::Format_RGBA8888);
pixmap = QPixmap::fromImage(image);

heif_image_release(img);
heif_image_handle_release(handle);
heif_context_free(ctx);
}

bool loadHeicThumbnail(const QString& filePath, QPixmap& thumbnail) {
QString extension = QFileInfo(filePath).suffix().toLower();

if (extension == "jpg" || extension == "jpeg") {
QImageReader reader(filePath);
reader.setAutoTransform(true);

QSize originalSize = reader.size(); 
if (originalSize.isEmpty()) {
qDebug() << "Failed to read image size:" << reader.errorString() << filePath;
return false;
}
QSize scaledSize = originalSize.scaled(QSize(originalSize/20), Qt::KeepAspectRatio);

reader.setScaledSize(scaledSize);

QImage image = reader.read();
if (image.isNull()) {
qWarning() << "Failed to load image:" << reader.errorString() << filePath;
return false;
}

thumbnail = QPixmap::fromImage(image);
return true;
}

heif_context* ctx = heif_context_alloc();
heif_error err = heif_context_read_from_file(ctx, filePath.toStdString().c_str(), nullptr);
if (err.code != heif_error_Ok) {
qDebug() << "Failed to read HEIF file: ";
heif_context_free(ctx);
return false;
}

heif_image_handle* handle = nullptr;
err = heif_context_get_primary_image_handle(ctx, &handle);
if (err.code != heif_error_Ok) {
qDebug() << "Failed to get primary image handle: ";
heif_context_free(ctx);
return false;
}

heif_image_handle* thumbnail_handle = nullptr;
int num_thumbnails = heif_image_handle_get_number_of_thumbnails(handle);
if (num_thumbnails > 0) {
heif_item_id thumbnail_id;
heif_image_handle_get_list_of_thumbnail_IDs(handle, &thumbnail_id, 1);
err = heif_image_handle_get_thumbnail(handle, thumbnail_id, &thumbnail_handle);
if (err.code != heif_error_Ok) {
qDebug() << "Failed to get thumbnail handle: ";
heif_image_handle_release(handle);
heif_context_free(ctx);
return false;
}

// 解码缩略图
heif_image* thumbnail_image = nullptr;
err = heif_decode_image(thumbnail_handle, &thumbnail_image, heif_colorspace_RGB, heif_chroma_interleaved_RGB, nullptr);
if (err.code != heif_error_Ok) {
qDebug() << "Failed to decode thumbnail: " << err.message;
heif_image_handle_release(thumbnail_handle);
heif_image_handle_release(handle);
heif_context_free(ctx);
return false;
}
int width = heif_image_get_width(thumbnail_image, heif_channel_interleaved);
int height = heif_image_get_height(thumbnail_image, heif_channel_interleaved);
int stride;
const uint8_t* data = heif_image_get_plane_readonly(thumbnail_image, heif_channel_interleaved, &stride);
QImage image(data, width, height, stride, QImage::Format_RGB888); \

if (image.isNull()) {
qDebug() << "Failed to convert HEIF thumbnail to QImage.";
heif_image_release(thumbnail_image);
heif_image_handle_release(thumbnail_handle);
heif_image_handle_release(handle);
heif_context_free(ctx);
return false;
}

thumbnail = QPixmap::fromImage(image.copy());//不使用copy data释放掉后内存访问冲突

heif_image_release(thumbnail_image);
heif_image_handle_release(thumbnail_handle);
}
else {
qDebug() << "No thumbnails found in the HEIF file.";
heif_image_handle_release(handle);
heif_context_free(ctx);
return false;
}

heif_image_handle_release(handle);
heif_context_free(ctx);
return true;
}

#include <QApplication>
#include <QLabel>
#include <QImage>
#include <QPixmap>
#include <libheif/heif.h>
#include <iostream>

QImage heifToQImage(const std::string& filePath) {
    // 初始化 libheif 句柄
    struct heif_context* ctx = heif_context_alloc();
    if (!ctx) {
        throw std::runtime_error("Failed to allocate HEIF context.");
    }

    // 读取 HEIF 文件
    struct heif_error err = heif_context_read_from_file(ctx, filePath.c_str(), nullptr);
    if (err.code != heif_error_Ok) {
        heif_context_free(ctx);
        throw std::runtime_error("Failed to read HEIF file: " + std::string(err.message));
    }

    // 获取主图像句柄
    struct heif_image_handle* handle = nullptr;
    err = heif_context_get_primary_image_handle(ctx, &handle);
    if (err.code != heif_error_Ok) {
        heif_context_free(ctx);
        throw std::runtime_error("Failed to get primary image handle: " + std::string(err.message));
    }

    // 解码图像
    struct heif_image* img = nullptr;
    err = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_RGBA, nullptr);
    if (err.code != heif_error_Ok) {
        heif_image_handle_release(handle);
        heif_context_free(ctx);
        throw std::runtime_error("Failed to decode HEIF image: " + std::string(err.message));
    }

    // 获取图像数据
    int width = heif_image_get_width(img, heif_channel_interleaved);
    int height = heif_image_get_height(img, heif_channel_interleaved);
    const uint8_t* data = heif_image_get_plane_readonly(img, heif_channel_interleaved, nullptr);

    // 创建缓冲区并复制数据
    QVector<uchar> buffer(width * height * 4); // RGBA8888，每像素4字节
    memcpy(buffer.data(), data, buffer.size());

    // 转换为 QImage
    QImage qimage(buffer.data(), width, height, QImage::Format_RGBA8888);

    // 释放资源
    heif_image_release(img);
    heif_image_handle_release(handle);
    heif_context_free(ctx);

    return qimage.copy(); // 确保 QImage 独立持有数据
}


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

    try {
        QImage image = heifToQImage("C:/Users/lianx/Pictures/IMG_0001.HEIC");

        QLabel label;
        label.setPixmap(QPixmap::fromImage(image));
        label.setScaledContents(true);
        label.resize(image.size()/2);
        label.show();

        return app.exec();
    }
    catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return -1;
    }
}

type = (depth & 0x7) + ((channels - 1) << 3);

====================== OpenCV 图像类型解剖 ======================

类型格式：   CV_<bit-depth>{U|S|F}C<channels>
--------------------------------------------------------------
- CV         : OpenCV 类型前缀
- bit-depth  : 每个通道的位深（8/16/32/64）
- U/S/F      : 
    U = unsigned（无符号整数） → uchar/ushort
    S = signed（有符号整数）   → char/short/int
    F = float（浮点数）        → float/double
- C<channels>: 通道数（C1~C4）

====================== 常见类型举例 ========================

CV_8UC1  → 8位无符号灰度图       → uchar 灰度图
CV_8UC3  → 8位无符号彩色图（BGR）→ uchar 彩色图（BGR）
CV_8UC4  → 8位无符号4通道（BGRA）→ uchar BGRA 图

CV_16UC1 → 16位无符号灰度图      → ushort 深度图、医学图像
CV_16SC1 → 16位有符号灰度图      → short 常用于梯度图、滤波
CV_32FC1 → 32位浮点灰度图        → float 图像处理、光流
CV_64FC4 → 64位浮点4通道图        → double 高频计算图

==================== 底层编码机制 =======================

OpenCV 图像类型实际是一个整数，编码方式如下：

type = (depth & 0x7) + ((channels - 1) << 3)

depth 类型编码：
    CV_8U  = 0   → unsigned char
    CV_8S  = 1   → char
    CV_16U = 2   → unsigned short
    CV_16S = 3   → short
    CV_32S = 4   → int
    CV_32F = 5   → float
    CV_64F = 6   → double

通道数编码：(channels - 1) << 3
    C1 = 0 << 3 = 0
    C2 = 1 << 3 = 8
    C3 = 2 << 3 = 16
    C4 = 3 << 3 = 24

例：CV_16UC3 = 2(depth) + (3-1)<<3 = 2 + 16 = 18

==========================================================

小技巧：
int depth    = CV_MAT_DEPTH(mat.type());    // 数据类型
int channels = CV_MAT_CN(mat.type());       // 通道数

        ┌──────────────┐
        │ CV_16UC3     │
        └─────┬────────┘
              │
     ┌────────▼────────────┐
     │ CV_<Depth><C><N>    │
     │                    │
     │ Depth: 16U         │ → unsigned short（16位无符号）
     │ C: C3              │ → 三通道（一般 BGR）
     └────────────────────┘

底层编码：
    depth = CV_16U = 2（0000 0010）
    channels = 3 → (3-1)<<3 = 16（0001 0000）
    → 最终类型 = 2 + 16 = 18

    CV_16UC3 = 18

QImage Mat2QImage(const cv::Mat& mat)
{
    switch (mat.type()) {
    case CV_8UC1: // 灰度图
        return QImage(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_Grayscale8).copy();
    case CV_8UC3: // 彩色图（BGR）
        return QImage(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB888).rgbSwapped().copy();
    case CV_8UC4: // BGRA 图
        return QImage(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32).copy();
    default:
        return QImage(); // 不支持的格式
    }
}

cv::Mat QImage2Mat(const QImage& image)
{
    switch (image.format()) {
    case QImage::Format_RGB888:
        return cv::Mat(image.height(), image.width(), CV_8UC3,
                       const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
    case QImage::Format_BGR888:
        return cv::Mat(image.height(), image.width(), CV_8UC3,
                       const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
    case QImage::Format_ARGB32:
    case QImage::Format_RGB32:
        return cv::Mat(image.height(), image.width(), CV_8UC4,
                       const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
    case QImage::Format_Grayscale8:
    case QImage::Format_Indexed8:
        return cv::Mat(image.height(), image.width(), CV_8UC1,
                       const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
    case QImage::Format_Grayscale16: {
        return cv::Mat(image.height(), image.width(), CV_16UC1,
                       const_cast<uchar*>(image.bits()), image.bytesPerLine()).clone();
    }
    default:
        return cv::Mat();
    }
}

#include <QApplication>
#include <QLabel>
#include <QImage>
#include <QPixmap>
#include <libheif/heif.h>
#include <iostream>

QImage heifToQImage(const std::string& filePath) {
    // 初始化 libheif 句柄
    struct heif_context* ctx = heif_context_alloc();
    if (!ctx) {
        throw std::runtime_error("Failed to allocate HEIF context.");
    }

    // 读取 HEIF 文件
    struct heif_error err = heif_context_read_from_file(ctx, filePath.c_str(), nullptr);
    if (err.code != heif_error_Ok) {
        heif_context_free(ctx);
        throw std::runtime_error("Failed to read HEIF file: " + std::string(err.message));
    }

    // 获取主图像句柄
    struct heif_image_handle* handle = nullptr;
    err = heif_context_get_primary_image_handle(ctx, &handle);
    if (err.code != heif_error_Ok) {
        heif_context_free(ctx);
        throw std::runtime_error("Failed to get primary image handle: " + std::string(err.message));
    }

    // 解码图像
    struct heif_image* img = nullptr;
    err = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_RGBA, nullptr);
    if (err.code != heif_error_Ok) {
        heif_image_handle_release(handle);
        heif_context_free(ctx);
        throw std::runtime_error("Failed to decode HEIF image: " + std::string(err.message));
    }

    // 获取图像数据
    int width = heif_image_get_width(img, heif_channel_interleaved);
    int height = heif_image_get_height(img, heif_channel_interleaved);
    const uint8_t* data = heif_image_get_plane_readonly(img, heif_channel_interleaved, nullptr);

    // 创建缓冲区并复制数据
    QVector<uchar> buffer(width * height * 4); // RGBA8888，每像素4字节
    memcpy(buffer.data(), data, buffer.size());

    // 转换为 QImage
    QImage qimage(buffer.data(), width, height, QImage::Format_RGBA8888);

    // 释放资源
    heif_image_release(img);
    heif_image_handle_release(handle);
    heif_context_free(ctx);

    return qimage.copy(); // 确保 QImage 独立持有数据
}


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

    try {
        QImage image = heifToQImage("C:/Users/lianx/Pictures/IMG_0001.HEIC");

        QLabel label;
        label.setPixmap(QPixmap::fromImage(image));
        label.setScaledContents(true);
        label.resize(image.size()/2);
        label.show();

        return app.exec();
    }
    catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return -1;
    }
}

enum CheckState {
    Unchecked,
    PartiallyChecked,
    Checked
};

if (selectedItems == 0)
{
ui->checkBox_select->setCheckState(Qt::Unchecked);
}
else if (selectedItems < totalItems)
{
ui->checkBox_select->setCheckState(Qt::PartiallyChecked);
}
else
{
ui->checkBox_select->setCheckState(Qt::Checked);
}

connect(ui->checkBox_select, &QCheckBox::clicked, this, &MainWindow::selectAll);
void PhoneToPCPage::selectAll()
{
ui->checkBox_select->setTristate(false);
QListView* listView = getListView();
if (listView == nullptr)
{
return;
}
QItemSelectionModel* selectionModel = listView->selectionModel();
QAbstractItemModel* model = listView->model();
bool selectAll = ui->checkBox_select->checkState() == Qt::Checked;
if (selectAll) {
QItemSelection selection;
for (int row = 0; row < model->rowCount(); ++row) {
QModelIndex index = model->index(row, 0);
selection.select(index, index);
}
selectionModel->select(selection, QItemSelectionModel::Select);
}
else {
selectionModel->clearSelection();
}
}

//初始化QListView
QListView* photoListViewphotoListView = new QListView(this);
photoListView->setViewMode(QListView::IconMode);
photoListView->setResizeMode(QListView::Adjust);
photoListView->setIconSize(QSize(150, 150));
photoListView->setSpacing(10);
photoListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
photoListView->setUniformItemSizes(true);
photoListView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
photoListView->setAttribute(Qt::WA_Hover); // 启用 Hover 事件
photoListView->viewport()->setAttribute(Qt::WA_Hover);

//初始化QStandardItemModel
QStandardItemModel* m_photoModel = new QStandardItemModel(this);
ui->listView_Photos->setItemDelegate(new PhotoDelegate(ui->listView_Photos));//这是解决数据如何展示的
ui->listView_Photos->model()->removeRows(0, ui->listView_Photos->model()->rowCount(QModelIndex()));
//模拟数据
for (auto photoInfo : m_vecPhoto) {
QStandardItem* item = new QStandardItem;
item->setEditable(false);
item->setData(":/images/Demo.png", Qt::UserRole);
//item->setData(photoInfo.duration,Qt::UserRole);
item->setData(photoInfo.fileName, Qt::UserRole + 1);
item->setData(photoInfo.width + "x" + photoInfo.height, Qt::UserRole + 2);
item->setData(photoInfo.dateCreated, Qt::UserRole + 3);
item->setData(photoInfo.fileSize, Qt::UserRole + 4);
item->setData(photoInfo.dir, Qt::UserRole + 5);
//将数据存放到QStandardItemModel里面
m_photoModel->appendRow(item);
}

class PhotoDelegate : public QStyledItemDelegate {
Q_OBJECT

public:
enum ViewMode { ListMode, GridMode };
explicit PhotoDelegate(QListView* parent = nullptr)
: QStyledItemDelegate(parent) {
listView = parent;
};
void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
painter->save();
painter->setRenderHint(QPainter::Antialiasing);
QListView::ViewMode viewMode = listView->viewMode();
QPixmap pixmap(index.data(Qt::UserRole).toString());
//图片信息
QString fileName = index.data(Qt::UserRole + 1).toString();
QString fileReso = index.data(Qt::UserRole + 2).toString();
QString fileDate = index.data(Qt::UserRole + 3).toString();
QString fileSize = index.data(Qt::UserRole + 4).toString();

QRect iconRect = QRect(option.rect.left() + 5, option.rect.top() + 5, 50, 50); // 图标区域
QRect nameRect = QRect(iconRect.right() - 50, option.rect.top() + 100, option.rect.width(), 20); // 文件名
QRect dateRect = QRect(iconRect.right() - 50, option.rect.top() + 120, option.rect.width(), 20); // 日期
QRect sizeRect = QRect(iconRect.right() - 50, option.rect.top() + 140, option.rect.width(), 20); // 大小

bool isSelected = option.state & QStyle::State_Selected;
bool isHovered = option.state & QStyle::State_MouseOver;


if (viewMode == QListView::ViewMode::IconMode)
{
QString filePath = index.data(Qt::UserRole).value<QString>();
QRect imageRect = option.rect;

// 设置图片为正方形，填充区域
int size = qMin(imageRect.width(), imageRect.height());
QRect squareRect(imageRect.topLeft(), QSize(size, size));
squareRect.moveCenter(imageRect.center());

// 抗锯齿
painter->setRenderHint(QPainter::Antialiasing);

// 裁剪，绘图
QPainterPath clipPath;
clipPath.addRoundedRect(squareRect, 10, 10);
painter->setClipPath(clipPath);
painter->drawPixmap(squareRect, pixmap, pixmap.rect());
if (!isSelected)
{
// 图标
QPixmap checkIcon(":/images/unselect.png");
QRect checkRect(squareRect.topRight() - QPoint(SELECT_ICON_SIZE + 5, -5),
QSize(SELECT_ICON_SIZE, SELECT_ICON_SIZE));
painter->drawPixmap(checkRect, checkIcon);
}

// 绘制选中时的边框和勾选图标
if (isSelected) {
// 蓝框
painter->setPen(QPen(QColor(41, 95, 204), 3));
painter->drawRoundedRect(squareRect, 10, 10);

// 图标
QPixmap checkIcon(":/images/selected.png");
QRect checkRect(squareRect.topRight() - QPoint(SELECT_ICON_SIZE + 5, -5), QSize(SELECT_ICON_SIZE, SELECT_ICON_SIZE));
painter->drawPixmap(checkRect, checkIcon);
}
if (isHovered)
{
// 蓝框
painter->setPen(QPen(QColor(41, 95, 204), 3));
painter->drawRoundedRect(squareRect, 10, 10);


painter->setPen(Qt::black);
painter->drawText(nameRect, Qt::AlignLeft | Qt::AlignVCenter, fileName);
painter->drawText(dateRect, Qt::AlignLeft | Qt::AlignVCenter, fileDate);
painter->drawText(sizeRect, Qt::AlignLeft | Qt::AlignVCenter, fileSize);
}
}
else if (viewMode == QListView::ViewMode::ListMode)
{
//listView->setSpacing(5);
if (isHovered)
{
QRect fileRect(option.rect.topLeft(), option.rect.size());
int borderRadius = 10; // 圆角的半径

painter->setPen(Qt::NoPen); // 去掉边框
painter->setBrush(QColor(235, 241, 255)); // 设置填充颜色

// 圆角背景
painter->drawRoundedRect(fileRect, borderRadius, borderRadius);
}

// 选中状态边框
if (isSelected) {
QRect fileRect(option.rect.topLeft(), option.rect.size());
int borderRadius = 10; // 圆角的半径
painter->setPen(Qt::NoPen);
// 设置背景颜色
painter->setBrush(QColor(235, 241, 255));

// 绘制带圆角的背景
painter->drawRoundedRect(fileRect, borderRadius, borderRadius);

// 绘制选中图标
QRect checkIconRect = QRect(option.rect.left() + 15, option.rect.top() + 20, SELECT_ICON_SIZE, SELECT_ICON_SIZE);
QPixmap checkIcon(":/images/selected.png");
painter->drawPixmap(checkIconRect, checkIcon);
}
else
{
QRect checkIconRect = QRect(option.rect.left() + 15, option.rect.top() + 20, SELECT_ICON_SIZE, SELECT_ICON_SIZE);
QPixmap checkIcon(":/images/unselect.png");
painter->drawPixmap(checkIconRect, checkIcon);
}

// 绘制区域
QRect iconRect = QRect(option.rect.left() + 45, option.rect.top() + 7, 44, 44); // 图标区域
QRect nameRect = QRect(iconRect.right() + 40, option.rect.top() + 20, 200, 20); // 文件名
QRect resoRect = QRect(nameRect.right() + 40, option.rect.top() + 20, 100, 20); // 分辨率
QRect dateRect = QRect(resoRect.right() + 40, option.rect.top() + 20, 200, 20); // 日期
QRect sizeRect = QRect(dateRect.right() + 40, option.rect.top() + 20, 100, 20); // 大小

// 绘制圆角图标
int borderRadius = 10;
QPainterPath path;
path.addRoundedRect(iconRect, borderRadius, borderRadius);

painter->save();
// 抗锯齿
painter->setRenderHint(QPainter::Antialiasing, true);
// 裁剪区域
painter->setClipPath(path);
painter->drawPixmap(iconRect, pixmap);
painter->restore();

// 绘制文件名、日期和大小
painter->setPen(Qt::black);
painter->drawText(nameRect, Qt::AlignLeft | Qt::AlignVCenter, fileName);
painter->setPen(Qt::gray);
painter->drawText(resoRect, Qt::AlignLeft | Qt::AlignVCenter, fileReso);
painter->drawText(dateRect, Qt::AlignLeft | Qt::AlignVCenter, fileDate);

painter->drawText(sizeRect, Qt::AlignLeft | Qt::AlignVCenter, fileSize);

}


painter->restore();
}



QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override {
Q_UNUSED(index);
//固定大小
if (listView->viewMode() == QListView::ViewMode::IconMode) {
return QSize(170, 170);
}
else
{
return  QSize(50, 60);
}

}
bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option,
const QModelIndex& index) override {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
QListView::ViewMode viewMode = listView->viewMode();

QRect checkRect;
if (viewMode == QListView::ViewMode::IconMode) {
checkRect = QRect(option.rect.topRight() - QPoint(SELECT_ICON_SIZE + 5, -5),
QSize(SELECT_ICON_SIZE, SELECT_ICON_SIZE));
}
else {
checkRect = QRect(option.rect.left() + 15, option.rect.top() + 20, SELECT_ICON_SIZE, SELECT_ICON_SIZE);
}

if (checkRect.contains(mouseEvent->pos())) {
bool isSelected = index.data(Qt::UserRole + 15).toBool();
model->setData(index, !isSelected, Qt::UserRole + 15);
QItemSelectionModel* selectionModel = listView->selectionModel();
if (!isSelected) {
selectionModel->select(index, QItemSelectionModel::Select);
}
else {
selectionModel->select(index, QItemSelectionModel::Deselect);
}

return true;
}
}
return QStyledItemDelegate::editorEvent(event, model, option, index);
}
private:
QListView* listView;
};

#ifndef DIRECTIONALCONTROL_H
#define DIRECTIONALCONTROL_H

#include <QWidget>
#include <QMouseEvent>
#include <QPainter>
#include <QPushButton>
#include <QCheckBox>
#include <QPointF>
#include <QDebug>

class DirectionalControl : public QWidget {
Q_OBJECT

public:
enum DirectionButton
{
UpButton,
DownButton,
LeftButton,
RightButton,
StopButton
};
explicit DirectionalControl(QWidget* parent = nullptr);
void  resetDragPntPos();
public slots:
void sendDirectionChanged();

signals:
void directionChanged(double angle); // 信号：方向改变
void startMove();
void stopMove();
void handleClick();

protected:
void paintEvent(QPaintEvent* event) override;
void mousePressEvent(QMouseEvent* event) override;
void mouseMoveEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent* event) override;
void updateDragPntDirection();
void keyReleaseEvent(QKeyEvent* event) override;

void keyPressEvent(QKeyEvent* event)override;

private:
const int outerRadius = 80; // 外圈半径
const int innerRadius = 45;  // 内圈半径
QPointF center;              // 中心点
QPointF dragPoint;           // 当前拖动点
bool isDragging = false;     // 是否正在拖动
double m_angle;
bool m_moving = false;

QPushButton* stopButton;    //按钮


QTimer* m_timer;            //定时器，控制angleChange()发送频率

bool isInsideOuterCircle(const QPointF& point);
bool isInsideInnerCircle(const QPointF& point);
void calculateDirection(); // 计算当前方向
void setupButtons();       // 初始化按钮布局
};

#endif // DIRECTIONALCONTROL_H

#include "DirectionalControl.h"
#include "corecrt_math_defines.h"
#include <QtMath>
#include <QTimer>

DirectionalControl::DirectionalControl(QWidget* parent)
: QWidget(parent), center(100, 100) {

setFixedSize(200, 200);
setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
setAttribute(Qt::WA_TranslucentBackground);
setFocusPolicy(Qt::StrongFocus);
//this->setCursor(Qt::CursorShape::PointingHandCursor);
m_timer = new QTimer(this);
dragPoint.setX(center.x());
dragPoint.setY(center.y());

QSize size = this->size();
setupButtons();

QFile file(":/qss/resources/qss/DirectionControl.qss");
QByteArray style;
if (file.open(QIODevice::ReadOnly))
{
style += file.readAll();
file.close();
}
setStyleSheet(style);
}

void DirectionalControl::resetDragPntPos()
{
dragPoint.setX(center.x());
dragPoint.setY(center.y());
update();
}

void DirectionalControl::sendDirectionChanged()
{
emit directionChanged(m_angle);
}



void DirectionalControl::setupButtons() {
// 中心按钮：开始/暂停
stopButton = new QPushButton(this);
stopButton->move(90, 90);
stopButton->setObjectName("stopButton");
connect(stopButton, &QPushButton::clicked, [this]() {
emit stopMove();
m_moving = false;
dragPoint.setX(center.x());
dragPoint.setY(center.y());
stopButton->hide();
update();
});
stopButton->hide();
}

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

QPainter painter(this);
// 抗锯齿
painter.setRenderHint(QPainter::Antialiasing, true);



// 无边框,直接刷色
painter.setPen(Qt::NoPen);

const QColor outerCircleColor(200, 220, 255, 200); // 外圈颜色
const QColor innerCircleColor(249, 249, 249, 150); // 内圈颜色
const int centerDotRadius = 3; // 中心点半径
const int dragRadius = 15;     // 拖动点半径

// 绘制外圈
painter.setBrush(outerCircleColor);
painter.drawEllipse(center, outerRadius, outerRadius);

//绘制内内圈
painter.setPen(QPen(QColor(255, 255, 255, 150), 3));//外边框
painter.setBrush(innerCircleColor);
painter.drawEllipse(center, dragRadius, dragRadius);

// 绘制内圈
painter.setPen(QPen(QColor(255, 255, 255, 150), 3));//外边框
painter.setBrush(innerCircleColor);
painter.drawEllipse(center, innerRadius, innerRadius);
// 确保 dragPoint 不进入内圈且不超出外圈
double dx = dragPoint.x() - center.x();
double dy = dragPoint.y() - center.y();
double distance = std::sqrt(dx * dx + dy * dy);

// 如果 dragPoint 超出了外圈，修正到外圈边缘
if (distance > outerRadius) {
double scale = outerRadius / distance;
dragPoint.setX(center.x() + dx * scale);
dragPoint.setY(center.y() + dy * scale);
}

painter.setPen(QPen(QColor(255, 255, 255)));
QFont font("Arial", 20, QFont::Bold);
// 设置画笔的字体
painter.setFont(font);

painter.drawText(87, 50, "W");
painter.drawText(28, 110, "A");
painter.drawText(90, 172, "S");
painter.drawText(152, 110, "D");
// 设置画刷颜色为白色并绘制拖动点
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::white);
painter.drawEllipse(dragPoint, dragRadius, dragRadius);

// 在拖动点的中心绘制中心点
painter.setPen(QPen(QColor(0, 117, 255), 5));
painter.setBrush(QColor(0, 117, 255));
painter.drawEllipse(dragPoint, centerDotRadius, centerDotRadius);


}


void DirectionalControl::mousePressEvent(QMouseEvent* event) {
QPointF pos = event->pos();
//if (isInsideOuterCircle(pos) && isInsideInnerCircle(pos)) {
isDragging = true;
dragPoint = pos;
emit startMove();
m_moving = true;
calculateDirection();
sendDirectionChanged();
// 限制拖动点到外圈的范围
double dx = pos.x() - center.x();
double dy = pos.y() - center.y();
double distance = std::sqrt(dx * dx + dy * dy);

if (distance < innerRadius) {
emit handleClick();
}
m_timer->start(1000);
connect(m_timer, &QTimer::timeout, this, &DirectionalControl::sendDirectionChanged, Qt::ConnectionType(Qt::AutoConnection | Qt::UniqueConnection));
update();
//}
}

void DirectionalControl::mouseMoveEvent(QMouseEvent* event) {
if (isDragging) {
QPointF pos = event->pos();

// 限制拖动点到外圈的范围
double dx = pos.x() - center.x();
double dy = pos.y() - center.y();
double distance = std::sqrt(dx * dx + dy * dy);

if (distance > outerRadius) {
// 将拖动点限制在外圈的边界
double scale = outerRadius / distance;
dragPoint.setX(center.x() + dx * scale);
dragPoint.setY(center.y() + dy * scale);
}
/*else if (distance > innerRadius)
{
dragPoint.setX(center.x());
dragPoint.setY(center.y());
}*/
else {
dragPoint = pos;
}

calculateDirection();
update();
}
}

void DirectionalControl::mouseReleaseEvent(QMouseEvent* event) {
Q_UNUSED(event);
isDragging = false;
// TODO 点击内圈跑一步，点击外圈持续跑
// 释放时恢复到中心
// dragPoint = center;

QPointF pos = event->pos();

// 限制拖动点到外圈的范围
double dx = pos.x() - center.x();
double dy = pos.y() - center.y();
double distance = std::sqrt(dx * dx + dy * dy);

if (distance > innerRadius) {
// 将拖动点限制在外圈的边界
double distanceFromCenter = (outerRadius + innerRadius) / 2;
dragPoint.setX(center.x() +
distanceFromCenter * std::cos(qDegreesToRadians(m_angle)));
dragPoint.setY(center.y() -
distanceFromCenter * std::sin(qDegreesToRadians(m_angle)));
stopButton->show();
}
else if (distance < innerRadius)//拖动点释放前在内圈，就停止
{
calculateDirection();
dragPoint.setX(center.x());
dragPoint.setY(center.y());
stopButton->hide();
emit stopMove();
m_moving = false;
}
/*else {
dragPoint = pos;
}*/
/*double distanceFromCenter = (outerRadius + innerRadius) / 2;
dragPoint.setX(center.x() +
distanceFromCenter * std::cos(qDegreesToRadians(m_angle)));
dragPoint.setY(center.y() -
distanceFromCenter * std::sin(qDegreesToRadians(m_angle)));*/
m_timer->stop();
update();
}
void DirectionalControl::updateDragPntDirection()
{
double distanceFromCenter = (outerRadius + innerRadius) / 2;
dragPoint.setX(center.x() + distanceFromCenter * std::cos(qDegreesToRadians(m_angle)));
dragPoint.setY(center.y() - distanceFromCenter * std::sin(qDegreesToRadians(m_angle)));
update();
}
void DirectionalControl::keyPressEvent(QKeyEvent* event)
{
QWidget::keyPressEvent(event);

/* 
* 防止重复触发按键，这是官方文档的描述
* bool QKeyEvent::isAutoRepeat() const
* Returns true if this event comes from an auto-repeating key; 
* returns false if it comes from an initial key press.
* Note that if the event is a multiple-key compressed event that is partly due to auto-repeat,
* this function could return either true or false indeterminately.
*
*/
if (event->isAutoRepeat()) {
return;
}

switch (event->key()) {
case Qt::Key_W:
m_angle = 90;
sendDirectionChanged();
emit handleClick();
emit startMove();
stopButton->show();
m_moving = true;
updateDragPntDirection();
break;
case Qt::Key_A:
m_angle = 180;
sendDirectionChanged();
emit handleClick();
emit startMove();
stopButton->show();
m_moving = true;
updateDragPntDirection();
break;
case Qt::Key_S:
m_angle = 270;
sendDirectionChanged();
emit handleClick();
emit startMove();
stopButton->show();
m_moving = true;
updateDragPntDirection();
break;
case Qt::Key_D:
m_angle = 0;
sendDirectionChanged();
emit handleClick();
emit startMove();
stopButton->show();
m_moving = true;
updateDragPntDirection();
break;
default:
break;
}
// 标记事件为已处理
event->accept();
}

void DirectionalControl::keyReleaseEvent(QKeyEvent* event)
{
QWidget::keyReleaseEvent(event);

// 只处理非自动重复的松键事件
if (event->isAutoRepeat()) {
return;
}

switch (event->key()) {
case Qt::Key_W:
emit stopMove();
m_moving = false;
resetDragPntPos();
stopButton->hide();
break;
case Qt::Key_A:
emit stopMove();
m_moving = false;
resetDragPntPos();
stopButton->hide();
break;
case Qt::Key_S:
emit stopMove();
m_moving = false;
resetDragPntPos();
stopButton->hide();
break;
case Qt::Key_D:
emit stopMove();
m_moving = false;
resetDragPntPos();
stopButton->hide();
break;
case Qt::Key_Space:
emit stopMove();
m_moving = false;
resetDragPntPos();
stopButton->hide();
break;
default:
break;
}

// 标记事件为已处理
event->accept();
}
bool DirectionalControl::isInsideOuterCircle(const QPointF& point) {
double dx = point.x() - center.x();
double dy = point.y() - center.y();
return std::sqrt(dx * dx + dy * dy) <= outerRadius;
}

bool DirectionalControl::isInsideInnerCircle(const QPointF& point) {
double dx = point.x() - center.x();
double dy = point.y() - center.y();
return std::sqrt(dx * dx + dy * dy) <= innerRadius;
}

void DirectionalControl::calculateDirection() {
double dx = dragPoint.x() - center.x();
// Y 轴正方向向下，所以取反
double dy = center.y() - dragPoint.y();
double angle = std::atan2(dy, dx) * (180.0 / M_PI);
// 保证角度为 0-360 度
if (angle < 0) {
angle += 360.0;
}
m_angle = angle;

}