（二）Qt 那些事儿：事件循环机制

// 事件过滤器类 MyFilter
bool MyFilter::eventFilter(QObject *watched, QEvent *event) {
    if (event->type() == QEvent::KeyPress) {
        qDebug() << "Key pressed!";
        return true; // 返回 true 表示拦截该事件
    }
    return false; // 返回 false 表示不处理，将事件交给目标对象
}

// 在主代码中安装事件过滤器
targetWidget->installEventFilter(myFilter);
// 注意：此行为不会对子对象生效，如需对子对象安装eventFilter，需要找到子对象调用此方法

void MainWindow::onLoadClicked() {
    // UI显示"正在加载"
    ui->label->setText("Loading...");

    // 这里不调用 processEvents，UI 可能不会立即刷新
    // 开始加载一个大文件（阻塞主线程）
    loadBigFile();

    // 加载完再刷新 UI
    ui->label->setText("Load done");
}

void MainWindow::onLoadClicked() {
    ui->label->setText("Loading...");
    qApp->processEvents();  // 立即处理事件，刷新界面

    loadBigFile(); // 阻塞操作

    ui->label->setText("Load done");
}

QMouseEvent event(QEvent::MouseButtonPress, QPointF(10, 10), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(widget, &event);  // 立即调用 widget->event(&event)

QMouseEvent *event = new QMouseEvent(QEvent::MouseButtonPress, QPointF(10, 10), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::postEvent(widget, event);  // 放入事件队列，稍后执行

StartDrawLineCommand();
auto pnt1 = GetPoint("请选择起点");  // 等待用户点击
auto pnt2 = GetPoint("请选择终点");  // 再等待用户点击
DrawLine(pnt1, pnt2);

QPoint GetPoint(MyCanvas *viewport, const QString &hint) {
    QPoint point;
    if (!viewport) return point;

    QEventLoop loop;
    QPointer<MyCanvas> vp(viewport);
    QMetaObject::Connection conn;

    conn = QObject::connect(vp.data(), &MyCanvas::clicked, [&](QPoint pt){
        point = pt;
        QObject::disconnect(conn);
        loop.quit();
    });

    showHint(hint);
    loop.exec();
    return point;
}

#include <coroutine>
#include <optional>
#include <QEventLoop>
#include <QTimer>
#include <QMouseEvent>
#include <QWidget>
#include <QApplication>

// 协程任务类型
template<typename T>
struct Task {
    struct promise_type {
        T value{};
        std::exception_ptr exception = nullptr;

        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }

        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }

        void return_value(T val) { value = std::move(val); }

        void unhandled_exception() {
            exception = std::current_exception();
        }
    };

    std::coroutine_handle<promise_type> coro;

    Task(std::coroutine_handle<promise_type> h) : coro(h) {}

    ~Task() {
        if (coro) coro.destroy();
    }

    // 移动语义
    Task(Task&& other) noexcept : coro(std::exchange(other.coro, {})) {}
    Task& operator=(Task&& other) noexcept {
        if (this != &other) {
            if (coro) coro.destroy();
            coro = std::exchange(other.coro, {});
        }
        return *this;
    }

    // 禁止拷贝
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;

    T get_result() {
        if (coro.promise().exception) {
            std::rethrow_exception(coro.promise().exception);
        }
        return coro.promise().value;
    }
};

// 等待用户点击的 awaiter
class PointAwaiter : public QObject {
    Q_OBJECT

public:
    PointAwaiter(QWidget* widget, const QString& hint)
        : widget_(widget), hint_(hint) {}

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> handle) {
        handle_ = handle;
        showHint(hint_);
        installEventFilter();
    }

    QPoint await_resume() {
        removeEventFilter();
        return result_point_;
    }

private slots:
    void onTimeout() {
        removeEventFilter();
        cancelled_ = true;
        if (handle_) {
            handle_.resume();
        }
    }

private:
    QWidget* widget_;
    QString hint_;
    QPoint result_point_;
    std::coroutine_handle<> handle_;
    bool cancelled_ = false;
    QTimer* timeout_timer_ = nullptr;

    void showHint(const QString& text) {
        if (widget_) {
            widget_->setToolTip(text);
            widget_->setStatusTip(text);
        }
    }

    void installEventFilter() {
        if (widget_) {
            widget_->installEventFilter(this);

            // 设置超时机制
            timeout_timer_ = new QTimer(this);
            timeout_timer_->setSingleShot(true);
            connect(timeout_timer_, &QTimer::timeout, this, &PointAwaiter::onTimeout);
            timeout_timer_->start(30000); // 30秒超时
        }
    }

    void removeEventFilter() {
        if (widget_) {
            widget_->removeEventFilter(this);
        }
        if (timeout_timer_) {
            timeout_timer_->stop();
            timeout_timer_->deleteLater();
            timeout_timer_ = nullptr;
        }
    }

    bool eventFilter(QObject* obj, QEvent* event) override {
        if (event->type() == QEvent::MouseButtonPress) {
            QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
            if (mouseEvent->button() == Qt::LeftButton) {
                result_point_ = mouseEvent->pos();
                removeEventFilter();
                if (handle_) {
                    handle_.resume();
                }
                return true; // 事件已处理
            }
        } else if (event->type() == QEvent::KeyPress) {
            QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
            if (keyEvent->key() == Qt::Key_Escape) {
                cancelled_ = true;
                removeEventFilter();
                if (handle_) {
                    handle_.resume();
                }
                return true;
            }
        }
        return QObject::eventFilter(obj, event);
    }
};

// 等待按键的 awaiter
class KeyAwaiter : public QObject {
    Q_OBJECT

public:
    KeyAwaiter(QWidget* widget, const QString& hint)
        : widget_(widget), hint_(hint) {}

    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> handle) {
        handle_ = handle;
        showHint(hint_);
        installEventFilter();
    }

    int await_resume() {
        removeEventFilter();
        if (cancelled_) {
            throw std::runtime_error("用户取消操作");
        }
        return result_key_;
    }

private:
    QWidget* widget_;
    QString hint_;
    int result_key_;
    std::coroutine_handle<> handle_;
    bool cancelled_ = false;

    void showHint(const QString& text) {
        if (widget_) {
            widget_->setStatusTip(text);
        }
    }

    void installEventFilter() {
        if (widget_) {
            widget_->installEventFilter(this);
        }
    }

    void removeEventFilter() {
        if (widget_) {
            widget_->removeEventFilter(this);
        }
    }

    bool eventFilter(QObject* obj, QEvent* event) override {
        if (event->type() == QEvent::KeyPress) {
            QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
            result_key_ = keyEvent->key();
            removeEventFilter();
            if (handle_) {
                handle_.resume();
            }
            return true;
        }
        return QObject::eventFilter(obj, event);
    }
};

// 绘制线条的协程函数 - 代码看起来是同步的！
Task<bool> drawLineCommand(QWidget* canvas) {
    try {
        // 获取起点
        QPoint startPoint = co_await PointAwaiter(canvas, "请选择起点");
        // 显示临时标记
        showTemporaryMarker(startPoint);
        // 获取终点
        QPoint endPoint = co_await PointAwaiter(canvas, "请选择终点");
        // 绘制线条
        drawLine(startPoint, endPoint);
        co_return true;

    } catch (const std::exception& e) {
        qDebug() << "绘制线条被取消:" << e.what();
        co_return false;
    }
}

// 复杂的多步骤交互
Task<bool> drawRectangleCommand(QWidget* canvas) {
    try {
        // 第一个角点
        QPoint corner1 = co_await PointAwaiter(canvas, "选择矩形第一个角点");
        // 对角点
        QPoint corner2 = co_await PointAwaiter(canvas, "选择矩形对角点");
        // 让用户确认
        int key = co_await KeyAwaiter(canvas, "按回车确认，按ESC取消");
        if (key == Qt::Key_Return) {
            drawRectangle(corner1, corner2);
            co_return true;
        } else {
            co_return false; // 用户取消
        }

    } catch (const std::exception& e) {
        qDebug() << "绘制矩形被取消:" << e.what();
        co_return false;
    }
}

// 嵌套命令的例子 - 组合多个协程
Task<bool> complexDrawingCommand(QWidget* canvas) {
    // 先画一条线
    bool lineResult = co_await drawLineCommand(canvas);
    if (!lineResult) {
        co_return false;
    }

    // 再画一个矩形
    bool rectResult = co_await drawRectangleCommand(canvas);

    co_return lineResult && rectResult;
}

class CoroutineScheduler : public QObject {
    Q_OBJECT

public:
    template<typename T>
    void schedule(Task<T> task) {
        // 使用QTimer让协程在事件循环中执行
        QTimer::singleShot(0, this, [this, task = std::move(task)]() mutable {
            try {
                // 协程会在需要等待时自动暂停
                // 当用户操作完成时会自动恢复
                T result = task.get_result();
                emit taskCompleted(QVariant::fromValue(result));
            } catch (const std::exception& e) {
                qDebug() << "协程执行异常:" << e.what();
                emit taskFailed(QString::fromStdString(e.what()));
            }
        });
    }

signals:
    void taskCompleted(const QVariant& result);
    void taskFailed(const QString& error);

private:
    std::vector<std::unique_ptr<QObject>> activeTasks_;
};

// 在主窗口中使用
class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow(QWidget* parent = nullptr) : QMainWindow(parent) {
        setupUI();

        connect(&scheduler_, &CoroutineScheduler::taskCompleted,
                this, &MainWindow::onTaskCompleted);
        connect(&scheduler_, &CoroutineScheduler::taskFailed,
                this, &MainWindow::onTaskFailed);
    }

private slots:
    void onDrawLineClicked() {
        scheduler_.schedule(drawLineCommand(ui->canvas));
    }

    void onDrawRectClicked() {
        scheduler_.schedule(drawRectangleCommand(ui->canvas));
    }

    void onComplexDrawClicked() {
        scheduler_.schedule(complexDrawingCommand(ui->canvas));
    }

    void onTaskCompleted(const QVariant& result) {
        statusBar()->showMessage("操作完成", 2000);
    }

    void onTaskFailed(const QString& error) {
        statusBar()->showMessage(QString("操作失败: %1").arg(error), 5000);
    }

private:
    CoroutineScheduler scheduler_;
    // UI 组件...
};

// 传统状态机方式 - 分散的逻辑
class TraditionalLineDrawer {
    enum State { WaitingStart, WaitingEnd };
    State state_ = WaitingStart;
    QPoint startPoint_;

    void onMouseClick(QPoint p) {
        switch(state_) {
            case WaitingStart:
                startPoint_ = p;
                state_ = WaitingEnd;
                showHint("选择终点");
                break;
            case WaitingEnd:
                drawLine(startPoint_, p);
                state_ = WaitingStart;
                showHint("选择起点");
                break;
        }
    }

    void onKeyPress(int key) {
        if (key == Qt::Key_Escape) {
            state_ = WaitingStart;
            showHint("操作已取消");
        }
    }
};

// QEventLoop方式 - 需要手动管理循环
class EventLoopLineDrawer {
    QPoint getPoint(const QString& hint) {
        QEventLoop loop;
        QPoint result;
        bool got_point = false;

        auto connection = connect(canvas, &Canvas::clicked,
                                [&](QPoint p) {
                                    result = p;
                                    got_point = true;
                                    loop.quit();
                                });

        showHint(hint);
        loop.exec();

        disconnect(connection);
        return result;
    }

    void drawLine() {
        QPoint start = getPoint("选择起点");
        QPoint end = getPoint("选择终点");
        drawLine(start, end);
    }
};

// 协程方式 - 自然的线性逻辑
Task<void> coroutineLineDrawer(QWidget* canvas) {
    QPoint start = co_await PointAwaiter(canvas, "选择起点");
    QPoint end = co_await PointAwaiter(canvas, "选择终点");
    drawLine(start, end);
}

// 协程方式的异常处理更自然
Task<bool> robustDrawCommand(QWidget* canvas) {
    try {
        QPoint p1 = co_await PointAwaiter(canvas, "选择起点");
        QPoint p2 = co_await PointAwaiter(canvas, "选择终点");

        if (isValidLine(p1, p2)) {
            drawLine(p1, p2);
            co_return true;
        } else {
            throw std::invalid_argument("无效的线条参数");
        }

    } catch (const std::runtime_error& e) {
        showError(QString("操作失败: %1").arg(e.what()));
        co_return false;
    } catch (const std::invalid_argument& e) {
        showWarning(QString("参数错误: %1").arg(e.what()));
        co_return false;
    }
}

// 确保协程对象的生命周期管理
class SafeCoroutineScheduler {
    struct TaskWrapper {
        virtual ~TaskWrapper() = default;
        virtual void execute() = 0;
    };

    template<typename T>
    struct TypedTaskWrapper : TaskWrapper {
        Task<T> task;
        TypedTaskWrapper(Task<T> t) : task(std::move(t)) {}
        void execute() override { /* 执行逻辑 */ }
    };

    std::vector<std::unique_ptr<TaskWrapper>> activeTasks_;

public:
    template<typename T>
    void schedule(Task<T> task) {
        auto wrapper = std::make_unique<TypedTaskWrapper<T>>(std::move(task));
        activeTasks_.push_back(std::move(wrapper));
        // 任务完成后自动清理
    }
};

// 确保协程恢复在正确的线程中执行
void await_suspend(std::coroutine_handle<> handle) {
    handle_ = handle;

    // 使用 QMetaObject::invokeMethod 确保在主线程恢复
    QMetaObject::invokeMethod(qApp, [this, handle]() {
        // 设置事件过滤器等操作
        installEventFilter();
    }, Qt::QueuedConnection);
}

// 支持取消的协程框架
class CancellableTask {
    std::atomic<bool> cancelled_{false};

public:
    void cancel() { cancelled_ = true; }
    bool isCancelled() const { return cancelled_; }

    template<typename Awaiter>
    auto operator co_await(Awaiter awaiter) {
        struct CancellableAwaiter {
            Awaiter inner;
            CancellableTask* task;

            bool await_ready() {
                return task->isCancelled() || inner.await_ready();
            }

            void await_suspend(std::coroutine_handle<> h) {
                if (!task->isCancelled()) {
                    inner.await_suspend(h);
                }
            }

            auto await_resume() {
                if (task->isCancelled()) {
                    throw std::runtime_error("操作被取消");
                }
                return inner.await_resume();
            }
        };

        return CancellableAwaiter{std::move(awaiter), this};
    }
};

#define qApp (static_cast<QCoreApplication *>(QCoreApplication::instance()))

QFont font("宋体");
qApp->setFont(font);

GlobalEventFilter filter;
qApp->installEventFilter(&filter);

void SubModule::exitApp() {
    qApp->quit();
}

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    // 主程序其他代码
    return app.exec();
}

#include <QApplication>
#include <QWidget>
#include <QLabel>
#include <QVBoxLayout>
#include <QThread>
#include <QMetaObject>

class WorkerThread : public QThread {
    Q_OBJECT
signals:
    void updateSignal(const QString&);

public:
    void run() override {
        QThread::sleep(2);
        emit updateSignal("Updated from thread");
    }
};

class MainWindow : public QWidget {
    Q_OBJECT

public:
    MainWindow() {
        QLabel* label = new QLabel("Initial text");
        QVBoxLayout* layout = new QVBoxLayout(this);
        layout->addWidget(label);

        WorkerThread* thread = new WorkerThread(this);
        connect(thread, &WorkerThread::updateSignal, [label](const QString& text) {
            label->setText(text);
        });
        thread->start();
    }
};

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}