qeventdispatcher_win_p.h

Enable keyboard shortcuts

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QEVENTDISPATCHER_WIN_P_H

#define QEVENTDISPATCHER_WIN_P_H

//

//  W A R N I N G

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

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "QtCore/qabstracteventdispatcher.h"

#include "QtCore/qt_windows.h"

#include "QtCore/qhash.h"

#include "QtCore/qatomic.h"

#include "qabstracteventdispatcher_p.h"

QT_BEGIN_NAMESPACE

class QEventDispatcherWin32Private;

// forward declaration

LRESULT QT_WIN_CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);

class Q_CORE_EXPORT QEventDispatcherWin32 : public QAbstractEventDispatcherV2

    Q_OBJECT

    Q_DECLARE_PRIVATE(QEventDispatcherWin32)

public:

    explicit QEventDispatcherWin32(QObject *parent = nullptr);

    ~QEventDispatcherWin32();

    bool QT_ENSURE_STACK_ALIGNED_FOR_SSE processEvents(QEventLoop::ProcessEventsFlags flags) override;

    void registerSocketNotifier(QSocketNotifier *notifier) override;

    void unregisterSocketNotifier(QSocketNotifier *notifier) override;

    void registerTimer(Qt::TimerId timerId, Duration interval, Qt::TimerType timerType,

                       QObject *object) final;

    bool unregisterTimer(Qt::TimerId timerId) final;

    bool unregisterTimers(QObject *object) final;

    QList<TimerInfoV2> timersForObject(QObject *object) const final;

    Duration remainingTime(Qt::TimerId timerId) const final;

    void wakeUp() override;

    void interrupt() override;

    void startingUp() override;

    void closingDown() override;

    bool event(QEvent *e) override;

    HWND internalHwnd();

protected:

    QEventDispatcherWin32(QEventDispatcherWin32Private &dd, QObject *parent = nullptr);

    virtual void sendPostedEvents();

    void doUnregisterSocketNotifier(QSocketNotifier *notifier);

private:

    friend LRESULT QT_WIN_CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp);

};

struct QSockNot {

    QSocketNotifier *obj;

    qintptr fd;

};

typedef QHash<qintptr, QSockNot *> QSNDict;

struct QSockFd {

    long event;

    long mask;

    bool selected;

    explicit inline QSockFd(long ev = 0, long ma = 0) : event(ev), mask(ma), selected(false) { }

};

typedef QHash<qintptr, QSockFd> QSFDict;

struct WinTimerInfo {                           // internal timer info

    qint64 interval;                            // - in milliseconds

    quint64 timeout;                            // - when to actually fire

    QObject *dispatcher;

    QObject *obj;                               // - object to receive events

    int timerId;

    Qt::TimerType timerType;

    UINT fastTimerId;

    bool inTimerEvent;

    bool usesExtendedInterval;

    bool isSecondTimeout;

};

class QZeroTimerEvent : public QTimerEvent

public:

    explicit inline QZeroTimerEvent(int timerId)

        : QTimerEvent(timerId)

    { t = QEvent::ZeroTimerEvent; }

};

typedef QHash<int, WinTimerInfo*> WinTimerDict; // fast dict of timers

class Q_CORE_EXPORT QEventDispatcherWin32Private : public QAbstractEventDispatcherPrivate

    Q_DECLARE_PUBLIC(QEventDispatcherWin32)

public:

    QEventDispatcherWin32Private();

    ~QEventDispatcherWin32Private();

    QAtomicInt interrupt;

    // internal window handle used for socketnotifiers/timers/etc

    HWND internalHwnd;

    // for controlling when to send posted events

    UINT_PTR sendPostedEventsTimerId;

    QAtomicInt wakeUps;

    void startPostedEventsTimer();

    // timers

    WinTimerDict timerDict;

    void registerTimer(WinTimerInfo *t);

    void unregisterTimer(WinTimerInfo *t);

    void sendTimerEvent(int timerId);

    // socket notifiers

    QSNDict sn_read;

    QSNDict sn_write;

    QSNDict sn_except;

    QSFDict active_fd;

    bool activateNotifiersPosted;

    void postActivateSocketNotifiers();

    void doWsaAsyncSelect(qintptr socket, long event);

    bool closingDown = false;

    QList<MSG> queuedUserInputEvents;

    QList<MSG> queuedSocketEvents;

};

QT_END_NAMESPACE

#endif // QEVENTDISPATCHER_WIN_P_H