Qt 的focusout事件

在 Qt 中，focusOutEvent() 事件是当一个控件失去焦点时被触发的事件。当用户从一个控件中离开时，控件会失去焦点并触发 focusOutEvent() 事件。在这个事件中，可以实现控件失去焦点时需要执行的操作。

在 QWidget 类中，focusOutEvent() 函数是一个虚函数，可以在自定义控件中进行重载。例如，如果想要在 QLineEdit 控件失去焦点时，清空控件中的文本，可以实现如下代码：

void MyLineEdit::focusOutEvent(QFocusEvent *event)
{
    QLineEdit::focusOutEvent(event);
    this->clear();  // 清空控件中的文本
}

在上面的代码中，我们通过继承 QLineEdit 类并重载它的 focusOutEvent() 函数，实现了控件失去焦点时清空文本的操作。注意，在重载函数中，需要先调用基类的 focusOutEvent() 函数，以确保其他相关的操作也能够正常执行。

相关问题

qt 鼠标 键盘 录制 及 回放 代码

以下是一个简单的 Qt 鼠标键盘录制及回放的示例代码：

#include <QApplication>
#include <QWidget>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QTimer>
#include <QFile>
#include <QDataStream>

class Recorder : public QObject
{
    Q_OBJECT

public:
    Recorder(QObject *parent = nullptr)
        : QObject(parent)
    {
        connect(qApp, &QApplication::aboutToQuit, this, &Recorder::stopRecording);
    }

public slots:
    void startRecording(QString filename)
    {
        if (m_file.isOpen())
        {
            return;
        }

        m_file.setFileName(filename);
        if (!m_file.open(QIODevice::WriteOnly))
        {
            return;
        }

        m_dataStream.setDevice(&m_file);
        m_dataStream.setVersion(QDataStream::Qt_5_15);

        m_recording = true;
        m_startTime = QDateTime::currentDateTime();

        connect(qApp, &QApplication::focusChanged, this, &Recorder::onFocusChanged);
        connect(qApp, &QApplication::applicationStateChanged, this, &Recorder::onApplicationStateChanged);
        connect(qApp, &QApplication::aboutToQuit, this, &Recorder::stopRecording);

        m_timer.start(20, this);
    }

    void stopRecording()
    {
        if (!m_recording)
        {
            return;
        }

        m_recording = false;

        m_timer.stop();

        disconnect(qApp, &QApplication::focusChanged, this, &Recorder::onFocusChanged);
        disconnect(qApp, &QApplication::applicationStateChanged, this, &Recorder::onApplicationStateChanged);
        disconnect(qApp, &QApplication::aboutToQuit, this, &Recorder::stopRecording);

        m_file.close();
    }

    void onMouseEvent(QMouseEvent *event)
    {
        if (m_recording)
        {
            m_dataStream << qint64(QDateTime::currentDateTime().msecsTo(m_startTime));
            m_dataStream << qint32(QEvent::MouseButtonPress + event->button());
            m_dataStream << event->pos();
        }
    }

    void onKeyEvent(QKeyEvent *event)
    {
        if (m_recording)
        {
            m_dataStream << qint64(QDateTime::currentDateTime().msecsTo(m_startTime));
            m_dataStream << qint32(QEvent::KeyPress + event->key());
            m_dataStream << qint32(event->modifiers());
        }
    }

private slots:
    void onTimeout()
    {
        if (qApp->applicationState() == Qt::ApplicationActive)
        {
            QPoint pos = QCursor::pos();
            m_dataStream << qint64(QDateTime::currentDateTime().msecsTo(m_startTime));
            m_dataStream << qint32(QEvent::MouseMove);
            m_dataStream << pos;
        }
    }

    void onFocusChanged(QWidget *oldWidget, QWidget *newWidget)
    {
        if (m_recording)
        {
            m_dataStream << qint64(QDateTime::currentDateTime().msecsTo(m_startTime));
            m_dataStream << qint32(QEvent::FocusOut);
            m_dataStream << oldWidget;
            m_dataStream << qint32(QEvent::FocusIn);
            m_dataStream << newWidget;
        }
    }

    void onApplicationStateChanged(Qt::ApplicationState state)
    {
        if (m_recording)
        {
            m_dataStream << qint64(QDateTime::currentDateTime().msecsTo(m_startTime));
            m_dataStream << qint32(QEvent::ApplicationActivate + state);
        }
    }

private:
    QFile m_file;
    QDataStream m_dataStream;
    bool m_recording = false;
    QDateTime m_startTime;
    QTimer m_timer;

};

class Player : public QObject
{
    Q_OBJECT

public:
    Player(QObject *parent = nullptr)
        : QObject(parent)
    {
    }

public slots:
    void play(QString filename)
    {
        if (m_file.isOpen())
        {
            return;
        }

        m_file.setFileName(filename);
        if (!m_file.open(QIODevice::ReadOnly))
        {
            return;
        }

        m_dataStream.setDevice(&m_file);
        m_dataStream.setVersion(QDataStream::Qt_5_15);

        qint64 startTime = QDateTime::currentDateTime().toMSecsSinceEpoch();

        while (!m_dataStream.atEnd())
        {
            qint64 timestamp;
            m_dataStream >> timestamp;

            qint32 eventType;
            m_dataStream >> eventType;

            switch (eventType)
            {
            case QEvent::MouseMove:
            {
                QPoint pos;
                m_dataStream >> pos;
                int delay = timestamp - startTime;
                QTimer::singleShot(delay, this, [pos]() {
                    QCursor::setPos(pos);
                });
                break;
            }
            case QEvent::MouseButtonPress:
            case QEvent::MouseButtonRelease:
            {
                int button = eventType - QEvent::MouseButtonPress;
                QPoint pos;
                m_dataStream >> pos;
                int delay = timestamp - startTime;
                QTimer::singleShot(delay, this, [button, pos]() {
                    QMouseEvent event(QEvent::MouseButtonPress + button, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
                    qApp->sendEvent(qApp->focusWidget(), &event);
                });
                break;
            }
            case QEvent::KeyPress:
            case QEvent::KeyRelease:
            {
                int key = eventType - QEvent::KeyPress;
                int modifiers;
                m_dataStream >> modifiers;
                int delay = timestamp - startTime;
                QTimer::singleShot(delay, this, [key, modifiers]() {
                    QKeyEvent event(key == 0 ? QEvent::KeyPress : QEvent::KeyRelease, key, Qt::NoModifier, QString(), false, modifiers);
                    qApp->sendEvent(qApp->focusWidget(), &event);
                });
                break;
            }
            case QEvent::FocusOut:
            case QEvent::FocusIn:
            {
                QWidget *oldWidget, *newWidget;
                m_dataStream >> oldWidget >> newWidget;
                int delay = timestamp - startTime;
                QTimer::singleShot(delay, this, [oldWidget, newWidget]() {
                    qApp->setActiveWindow(newWidget->window());
                    qApp->setActiveWindow(newWidget);
                    qApp->setActiveWindow(newWidget->window());
                    newWidget->setFocus(Qt::OtherFocusReason);
                });
                break;
            }
            case QEvent::ApplicationActivate:
            case QEvent::ApplicationDeactivate:
            case QEvent::ApplicationStateChange:
            {
                int state = eventType - QEvent::ApplicationActivate;
                int delay = timestamp - startTime;
                QTimer::singleShot(delay, this, [state]() {
                    qApp->setApplicationState(Qt::ApplicationState(state));
                });
                break;
            }
            default:
                break;
            }

            startTime = timestamp;
        }

        m_file.close();
    }

private:
    QFile m_file;
    QDataStream m_dataStream;

};

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

    QWidget w;
    w.show();

    Recorder recorder;
    Player player;

    QTimer::singleShot(1000, [&]() {
        recorder.startRecording("record.dat");
    });

    QTimer::singleShot(5000, [&]() {
        player.play("record.dat");
    });

    return a.exec();
}

#include "main.moc"

这个示例代码使用了两个类 `Recorder` 和 `Player` 实现了录制和回放功能。`Recorder` 类用于录制鼠标和键盘事件，`Player` 类用于回放录制的事件。在 `main` 函数中，我们创建了一个 `Recorder` 和一个 `Player` 对象，并分别在程序启动后 1 秒和 5 秒后开始录制和回放。录制的数据保存在 `record.dat` 文件中，回放时从该文件中读取数据。

在 `Recorder` 类中，我们使用 `QDataStream` 将鼠标和键盘事件的时间戳、事件类型和事件数据写入到文件中。在鼠标或键盘事件发生时，我们会记录下事件的时间戳、事件类型和事件数据，然后写入到文件中。在 `stopRecording` 函数中，我们停止录制，并断开与 `QApplication` 的信号连接。

在 `Player` 类中，我们使用 `QDataStream` 从文件中读取鼠标和键盘事件的时间戳、事件类型和事件数据，并使用 `QTimer::singleShot` 来模拟鼠标和键盘事件的发生。在鼠标或键盘事件发生时，我们会计算出事件与上一个事件的时间差，然后使用 `QTimer::singleShot` 在相应的时间后模拟事件的发生。在 `play` 函数中，我们通过循环读取文件中的所有事件，并在每个事件发生的时间点模拟事件的发生。

注意：这个示例代码只是一个简单的实现，没有考虑到很多复杂的情况，例如多线程、多窗口、控件状态等。在实际应用中，需要根据具体情况进行修改和完善。

Qt的Label::leaveEvent重载不了

在Qt中，`QLabel::leaveEvent`是一个预设的槽函数，用于处理控件失去焦点的事件，但它不是可以由开发者直接重载的标准成员函数。这是因为`leaveEvent`属于Qt的私有部分，通常内部管理，并不是为了供用户自定义而设计的。

如果你想在用户离开`QLabel`时执行特定操作，你可以通过连接`focusOut()`信号到一个自定义的槽函数，或者覆盖`QWidget::customEvent()`方法来捕获并处理`QFocusChangeEvent`。但这并不意味着直接重载`leaveEvent`，因为这样做不会生效，而且可能会导致编译错误或不可预期的行为。

如果你确实需要这样的功能，推荐的做法是创建一个派生自`QLabel`的自定义控件，并在自定义的类里重写相应的事件处理逻辑：

class CustomLabel : public QLabel {
public:
    void customLeaveEvent(QEvent *event) override {
        // 在这里添加离开事件的处理代码
    }
};

然后在你的UI中实例化这个自定义控件。