Fix a mistake

Sine Striker

2024-05-08 5778d4540f0b522946c84c8ba601456f2d440f78

 src/core/contexts/win32windowcontext.cpp

@@ -1,14 +1,21 @@
// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
// SPDX-License-Identifier: Apache-2.0

#include "win32windowcontext_p.h"

#include <optional>

#include <QtCore/QAbstractEventDispatcher>
#include <QtCore/QDateTime>
#include <QtCore/QHash>
#include <QtCore/QScopeGuard>
#include <QtCore/QTimer>
#include <QtGui/QGuiApplication>
#include <QtGui/QPainter>
#include <QtGui/QPalette>
#include <QtGui/QStyleHints>

#include <QtGui/qpa/qwindowsysteminterface.h>

#include <QtGui/private/qhighdpiscaling_p.h>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -26,11 +33,13 @@
#include "qwkglobal_p.h"
#include "qwkwindowsextra_p.h"

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
Q_DECLARE_METATYPE(QMargins)
#endif

namespace QWK {

    enum IconButtonClickLevelFlag {
        IconButtonClicked = 1,
        IconButtonDoubleClicked = 2,
        IconButtonTriggersClose = 4,
    };

    // The thickness of an auto-hide taskbar in pixels.
    static constexpr const quint8 kAutoHideTaskBarThickness = 2;
@@ -49,59 +58,25 @@
    // Original Qt window proc function
    static WNDPROC g_qtWindowProc = nullptr;

    static inline bool
#if !QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
        constexpr
#endif

        isSystemBorderEnabled() {
        return
#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
            isWin10OrGreater()
#else
            false
#endif
                ;
    }

    static inline void triggerFrameChange(HWND hwnd) {
        ::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0,
                       SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER |
                           SWP_FRAMECHANGED);
    }

    static inline quint32 getDpiForWindow(HWND hwnd) {
        const DynamicApis &apis = DynamicApis::instance();
        if (apis.pGetDpiForWindow) {         // Win10
            return apis.pGetDpiForWindow(hwnd);
        } else if (apis.pGetDpiForMonitor) { // Win8.1
            HMONITOR monitor = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
            UINT dpiX{0};
            UINT dpiY{0};
            apis.pGetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY);
            return dpiX;
        } else { // Win2K
            HDC hdc = ::GetDC(nullptr);
            const int dpiX = ::GetDeviceCaps(hdc, LOGPIXELSX);
            // const int dpiY = ::GetDeviceCaps(hdc, LOGPIXELSY);
            ::ReleaseDC(nullptr, hdc);
            return quint32(dpiX);
        }
    }

    static inline quint32 getSystemMetricsForDpi(int index, quint32 dpi) {
        const DynamicApis &apis = DynamicApis::instance();
        if (apis.pGetSystemMetricsForDpi) {
            return ::GetSystemMetricsForDpi(index, dpi);
        }
        return ::GetSystemMetrics(index);
    }

    static inline quint32 getWindowFrameBorderThickness(HWND hwnd) {
        const DynamicApis &apis = DynamicApis::instance();
        if (UINT result = 0; SUCCEEDED(apis.pDwmGetWindowAttribute(
                hwnd, _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, &result, sizeof(result)))) {
            return result;
        }
        return getSystemMetricsForDpi(SM_CXBORDER, getDpiForWindow(hwnd));
    }

    static inline quint32 getResizeBorderThickness(HWND hwnd) {
        const quint32 dpi = getDpiForWindow(hwnd);
        return getSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
               getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
    }

    static inline quint32 getTitleBarHeight(HWND hwnd) {
        const quint32 dpi = getDpiForWindow(hwnd);
        return getSystemMetricsForDpi(SM_CYCAPTION, dpi) +
               getSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
               getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
    }

    static void setInternalWindowFrameMargins(QWindow *window, const QMargins &margins) {
@@ -130,18 +105,6 @@
        monitorInfo.cbSize = sizeof(monitorInfo);
        ::GetMonitorInfoW(monitor, &monitorInfo);
        return monitorInfo;
    }

    static inline void moveWindowToDesktopCenter(HWND hwnd) {
        MONITORINFOEXW monitorInfo = getMonitorForWindow(hwnd);
        RECT windowRect{};
        ::GetWindowRect(hwnd, &windowRect);
        const auto newX = monitorInfo.rcMonitor.left +
                          (RECT_WIDTH(monitorInfo.rcMonitor) - RECT_WIDTH(windowRect)) / 2;
        const auto newY = monitorInfo.rcMonitor.top +
                          (RECT_HEIGHT(monitorInfo.rcMonitor) - RECT_HEIGHT(windowRect)) / 2;
        ::SetWindowPos(hwnd, nullptr, newX, newY, 0, 0,
                       SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER);
    }

    static inline void moveWindowToMonitor(HWND hwnd, const MONITORINFOEXW &activeMonitor) {
@@ -199,7 +162,7 @@
        [[maybe_unused]] const auto &cleaner =
            qScopeGuard([windowThreadProcessId, currentThreadId]() {
                ::AttachThreadInput(windowThreadProcessId, currentThreadId, FALSE); //
            });
            }); // TODO: Remove it

        ::BringWindowToTop(hwnd);
        // Activate the window too. This will force us to the virtual desktop this
@@ -276,14 +239,15 @@
        apis.ptimeEndPeriod(ms_granularity);
    }

    static void showSystemMenu2(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
                                const bool fixedSize) {
    // Returns false if the menu is canceled
    static bool showSystemMenu_sys(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
                                   const bool fixedSize) {
        HMENU hMenu = ::GetSystemMenu(hWnd, FALSE);
        if (!hMenu) {
            // The corresponding window doesn't have a system menu, most likely due to the
            // lack of the "WS_SYSMENU" window style. This situation should not be treated
            // as an error so just ignore it and return early.
            return;
            return true;
        }

        const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
@@ -327,7 +291,8 @@
        // Popup the system menu at the required position.
        const auto result = ::TrackPopupMenu(
            hMenu,
            (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
            (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN) |
             TPM_RIGHTBUTTON),
            pos.x, pos.y, 0, hWnd, nullptr);

        // Unhighlight the first menu item after the popup menu is closed, otherwise it will keep
@@ -336,11 +301,12 @@

        if (!result) {
            // The user canceled the menu, no need to continue.
            return;
            return false;
        }

        // Send the command that the user chooses to the corresponding window.
        ::PostMessageW(hWnd, WM_SYSCOMMAND, result, 0);
        return true;
    }

    static inline Win32WindowContext::WindowPart getHitWindowPart(int hitTestResult) {
@@ -367,7 +333,7 @@
            case HTBORDER:
                return Win32WindowContext::FixedBorder;
            default:
                // unreachable
                Q_UNREACHABLE();
                break;
        }
        return Win32WindowContext::Outside;
@@ -405,6 +371,107 @@
        return true;
    }

    static inline constexpr bool isNonClientMessage(const UINT message) {
        if (((message >= WM_NCCREATE) && (message <= WM_NCACTIVATE)) ||
            ((message >= WM_NCMOUSEMOVE) && (message <= WM_NCMBUTTONDBLCLK)) ||
            ((message >= WM_NCXBUTTONDOWN) && (message <= WM_NCXBUTTONDBLCLK))
#if (WINVER >= _WIN32_WINNT_WIN8)
            || ((message >= WM_NCPOINTERUPDATE) && (message <= WM_NCPOINTERUP))
#endif
            || ((message == WM_NCMOUSEHOVER) || (message == WM_NCMOUSELEAVE))) {
            return true;
        } else {
            return false;
        }
    }

    static MSG createMessageBlock(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
        MSG msg;
        msg.hwnd = hWnd;       // re-create MSG structure
        msg.message = message; // time and pt fields ignored
        msg.wParam = wParam;
        msg.lParam = lParam;

        const DWORD dwScreenPos = ::GetMessagePos();
        msg.pt.x = GET_X_LPARAM(dwScreenPos);
        msg.pt.y = GET_Y_LPARAM(dwScreenPos);
        if (!isNonClientMessage(message)) {
            ::ScreenToClient(hWnd, &msg.pt);
        }
        return msg;
    }

    static inline constexpr bool isInputMessage(UINT m) {
        switch (m) {
            case WM_IME_STARTCOMPOSITION:
            case WM_IME_ENDCOMPOSITION:
            case WM_IME_COMPOSITION:
            case WM_INPUT:
            case WM_TOUCH:
            case WM_MOUSEHOVER:
            case WM_MOUSELEAVE:
            case WM_NCMOUSEHOVER:
            case WM_NCMOUSELEAVE:
            case WM_SIZING:
            case WM_MOVING:
            case WM_SYSCOMMAND:
            case WM_COMMAND:
            case WM_DWMNCRENDERINGCHANGED:
            case WM_PAINT:
                return true;
            default:
                break;
        }
        return (m >= WM_MOUSEFIRST && m <= WM_MOUSELAST) ||
               (m >= WM_NCMOUSEMOVE && m <= WM_NCXBUTTONDBLCLK) ||
               (m >= WM_KEYFIRST && m <= WM_KEYLAST);
    }

    static inline QByteArray nativeEventType() {
        return QByteArrayLiteral("windows_generic_MSG");
    }

    // Send to QAbstractEventDispatcher
    bool filterNativeEvent(MSG *msg, LRESULT *result) {
        auto dispatcher = QAbstractEventDispatcher::instance();
        QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
        if (dispatcher && dispatcher->filterNativeEvent(nativeEventType(), msg, &filterResult)) {
            *result = LRESULT(filterResult);
            return true;
        }
        return false;
    }

    // Send to QWindowSystemInterface
    bool filterNativeEvent(QWindow *window, MSG *msg, LRESULT *result) {
        QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
        if (QWindowSystemInterface::handleNativeEvent(window, nativeEventType(), msg,
                                                      &filterResult)) {
            *result = LRESULT(filterResult);
            return true;
        }
        return false;
    }

    static inline bool forwardFilteredEvent(QWindow *window, HWND hWnd, UINT message, WPARAM wParam,
                                            LPARAM lParam, LRESULT *result) {
        MSG msg = createMessageBlock(hWnd, message, wParam, lParam);

        // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1025
        // Do exact the same as what Qt Windows plugin does.

        // Run the native event filters. QTBUG-67095: Exclude input messages which are sent
        // by QEventDispatcherWin32::processEvents()
        if (!isInputMessage(msg.message) && filterNativeEvent(&msg, result))
            return true;

        auto platformWindow = window->handle();
        if (platformWindow && filterNativeEvent(platformWindow->window(), &msg, result))
            return true;

        return false;
    }

    // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1556
    // In QWindowsContext::windowsProc(), the messages will be passed to all global native event
    // filters, but because we have already filtered the messages in the hook WndProc function for
@@ -424,23 +491,44 @@
                return false;
            }

            // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1546
            // Qt needs to refer to the WM_NCCALCSIZE message data that hasn't been processed, so we
            // have to process it after Qt acquires the initial data.
            auto msg = static_cast<const MSG *>(message);
            if (msg->message == WM_NCCALCSIZE && lastMessageContext) {
                LRESULT res;
                if (lastMessageContext->nonClientCalcSizeHandler(msg->hwnd, msg->message,
                                                                 msg->wParam, msg->lParam, &res)) {
                    *result = decltype(*result)(res);
                    return true;
            switch (msg->message) {
                case WM_NCCALCSIZE: {
                    // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1546
                    // Qt needs to refer to the WM_NCCALCSIZE message data that hasn't been
                    // processed, so we have to process it after Qt acquires the initial data.
                    if (lastMessageContext) {
                        LRESULT res;
                        if (lastMessageContext->nonClientCalcSizeHandler(
                                msg->hwnd, msg->message, msg->wParam, msg->lParam, &res)) {
                            *result = decltype(*result)(res);
                            return true;
                        }
                    }
                    break;
                }

                    // case WM_NCHITTEST: {
                    //     // The child window must return HTTRANSPARENT when processing
                    //     WM_NCHITTEST for
                    //     // the parent window to receive WM_NCHITTEST.
                    //     if (!lastMessageContext) {
                    //         auto rootHWnd = ::GetAncestor(msg->hwnd, GA_ROOT);
                    //         if (rootHWnd != msg->hwnd) {
                    //             if (auto ctx = g_wndProcHash->value(rootHWnd)) {
                    //                 *result = HTTRANSPARENT;
                    //                 return true;
                    //             }
                    //         }
                    //     }
                    //     break;
                    // }
            }
            return false;
        }

        static WindowsNativeEventFilter *instance;
        static Win32WindowContext *lastMessageContext;
        static inline WindowsNativeEventFilter *instance = nullptr;
        static inline Win32WindowContext *lastMessageContext = nullptr;

        static inline void install() {
            if (instance) {
@@ -457,9 +545,6 @@
            instance = nullptr;
        }
    };

    WindowsNativeEventFilter *WindowsNativeEventFilter::instance = nullptr;
    Win32WindowContext *WindowsNativeEventFilter::lastMessageContext = nullptr;

    // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1025
    // We can see from the source code that Qt will filter out some messages first and then send the
@@ -526,18 +611,24 @@
            return ::DefWindowProcW(hWnd, message, wParam, lParam);
        }

        WindowsNativeEventFilter::lastMessageContext = ctx;
        const auto &contextCleaner = qScopeGuard([]() {
            WindowsNativeEventFilter::lastMessageContext = nullptr; //
        });

        // Since Qt does the necessary processing of the WM_NCCALCSIZE message, we need to
        // forward it right away and process it in our native event filter.
        if (message == WM_NCCALCSIZE) {
            WindowsNativeEventFilter::lastMessageContext = ctx;
            LRESULT result = ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
            WindowsNativeEventFilter::lastMessageContext = nullptr;
            return result;
            return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
        }

        // Try hooked procedure and save result
        LRESULT result;
        if (ctx->windowProc(hWnd, message, wParam, lParam, &result)) {
            // Forward the event to user-defined native event filters, there may be some messages
            // that need to be processed by the user.
            std::ignore =
                forwardFilteredEvent(ctx->window(), hWnd, message, wParam, lParam, &result);
            return result;
        }

@@ -546,18 +637,10 @@
    }

    static inline void addManagedWindow(QWindow *window, HWND hWnd, Win32WindowContext *ctx) {
        const auto margins = [hWnd]() -> QMargins {
            const auto titleBarHeight = int(getTitleBarHeight(hWnd));
            if (isWin10OrGreater()) {
                return {0, -titleBarHeight, 0, 0};
            } else {
                const auto frameSize = int(getResizeBorderThickness(hWnd));
                return {-frameSize, -titleBarHeight, -frameSize, -frameSize};
            }
        }();

        // Inform Qt we want and have set custom margins
        setInternalWindowFrameMargins(window, margins);
        if (isSystemBorderEnabled()) {
            // Inform Qt we want and have set custom margins
            setInternalWindowFrameMargins(window, QMargins(0, -int(getTitleBarHeight(hWnd)), 0, 0));
        }

        // Store original window proc
        if (!g_qtWindowProc) {
@@ -589,8 +672,8 @@
    }

    Win32WindowContext::~Win32WindowContext() {
        if (windowId) {
            removeManagedWindow(reinterpret_cast<HWND>(windowId));
        if (m_windowId) {
            removeManagedWindow(reinterpret_cast<HWND>(m_windowId));
        }
    }

@@ -600,35 +683,28 @@

    void Win32WindowContext::virtual_hook(int id, void *data) {
        switch (id) {
            case CentralizeHook: {
                if (!windowId)
                    return;
                const auto hwnd = reinterpret_cast<HWND>(windowId);
                moveWindowToDesktopCenter(hwnd);
                return;
            }

            case RaiseWindowHook: {
                if (!windowId)
                if (!m_windowId)
                    return;
                const auto hwnd = reinterpret_cast<HWND>(windowId);
                m_delegate->setWindowVisible(m_host, true);
                const auto hwnd = reinterpret_cast<HWND>(m_windowId);
                bringWindowToFront(hwnd);
                return;
            }

            case ShowSystemMenuHook: {
                if (!windowId)
                if (!m_windowId)
                    return;
                const auto &pos = *static_cast<const QPoint *>(data);
                auto hWnd = reinterpret_cast<HWND>(windowId);
                auto hWnd = reinterpret_cast<HWND>(m_windowId);
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
                const QPoint nativeGlobalPos =
                    QHighDpi::toNativeGlobalPosition(pos, m_windowHandle);
#else
                const QPoint nativeGlobalPos = QHighDpi::toNativePixels(pos, m_windowHandle);
#endif
                showSystemMenu2(hWnd, qpoint2point(nativeGlobalPos), false,
                                m_delegate->isHostSizeFixed(m_host));
                std::ignore = showSystemMenu_sys(hWnd, qpoint2point(nativeGlobalPos), false,
                                                 m_delegate->isHostSizeFixed(m_host));
                return;
            }

@@ -642,18 +718,19 @@
                return;
            }

#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
            case DrawWindows10BorderHook: {
                if (!windowId)
                if (!m_windowId)
                    return;

                auto args = static_cast<void **>(data);
                auto &painter = *static_cast<QPainter *>(args[0]);
                const auto &rect = *static_cast<const QRect *>(args[1]);
                const auto &region = *static_cast<const QRegion *>(args[2]);
                const auto hwnd = reinterpret_cast<HWND>(windowId);
                const auto hwnd = reinterpret_cast<HWND>(m_windowId);

                QPen pen;
                pen.setWidth(getWindowFrameBorderThickness(hwnd) * 2);
                pen.setWidth(int(getWindowFrameBorderThickness(hwnd)) * 2);

                const bool dark = isDarkThemeActive() && isDarkWindowFrameEnabled(hwnd);
                if (m_delegate->isWindowActive(m_host)) {
@@ -673,7 +750,7 @@
                }
                painter.save();

                // We needs anti-aliasing to give us better result.
                // We need antialiasing to give us better result.
                painter.setRenderHint(QPainter::Antialiasing);

                painter.setPen(pen);
@@ -685,65 +762,114 @@
                return;
            }

            case DrawWindows10BorderHook2: {
                if (!m_windowId)
                    return;

                // https://github.com/microsoft/terminal/blob/71a6f26e6ece656084e87de1a528c4a8072eeabd/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp#L1025
                // https://docs.microsoft.com/en-us/windows/win32/dwm/customframe#extending-the-client-frame
                // Draw a black rectangle to make Windows native top border show

                auto hWnd = reinterpret_cast<HWND>(m_windowId);
                HDC hdc = ::GetDC(hWnd);
                RECT windowRect{};
                ::GetClientRect(hWnd, &windowRect);
                RECT rcTopBorder = {
                    0,
                    0,
                    RECT_WIDTH(windowRect),
                    int(getWindowFrameBorderThickness(hWnd)),
                };
                ::FillRect(hdc, &rcTopBorder,
                           reinterpret_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH)));
                ::ReleaseDC(hWnd, hdc);
                return;
            }
#endif

            default:
                break;
        }
        AbstractWindowContext::virtual_hook(id, data);
    }

    bool Win32WindowContext::needBorderPainter() const {
        return isWin10OrGreater() && !isWin11OrGreater();
    }
    QVariant Win32WindowContext::windowAttribute(const QString &key) const {
        if (key == QStringLiteral("window-rect")) {
            if (!m_windowId)
                return {};

    int Win32WindowContext::borderThickness() const {
        return getWindowFrameBorderThickness(reinterpret_cast<HWND>(windowId));
    }

    void Win32WindowContext::winIdChanged() {
        // If the original window id is valid, remove all resources related
        if (windowId) {
            removeManagedWindow(reinterpret_cast<HWND>(windowId));
            windowId = 0;
            RECT frame{};
            auto hwnd = reinterpret_cast<HWND>(m_windowId);
            // According to MSDN, WS_OVERLAPPED is not allowed for AdjustWindowRect.
            auto style = static_cast<DWORD>(::GetWindowLongPtrW(hwnd, GWL_STYLE) & ~WS_OVERLAPPED);
            auto exStyle = static_cast<DWORD>(::GetWindowLongPtrW(hwnd, GWL_EXSTYLE));
            const DynamicApis &apis = DynamicApis::instance();
            if (apis.pAdjustWindowRectExForDpi) {
                apis.pAdjustWindowRectExForDpi(&frame, style, FALSE, exStyle,
                                               getDpiForWindow(hwnd));
            } else {
                ::AdjustWindowRectEx(&frame, style, FALSE, exStyle);
            }
            return QVariant::fromValue(rect2qrect(frame));
        }

        if (!m_windowHandle) {
        if (key == QStringLiteral("win10-border-needed")) {
            return isSystemBorderEnabled() && !isWin11OrGreater();
        }

        if (key == QStringLiteral("border-thickness")) {
            return m_windowId
                       ? int(getWindowFrameBorderThickness(reinterpret_cast<HWND>(m_windowId)))
                       : 0;
        }
        return AbstractWindowContext::windowAttribute(key);
    }

    void Win32WindowContext::winIdChanged(WId winId, WId oldWinId) {
        // Reset the context data
        mouseLeaveBlocked = false;
        lastHitTestResult = WindowPart::Outside;
        lastHitTestResultRaw = HTNOWHERE;

        if (!isSystemBorderEnabled()) {
            m_delegate->setWindowFlags(m_host, m_delegate->getWindowFlags(m_host) |
                                                   Qt::FramelessWindowHint);
        }

        // If the original window id is valid, remove all resources related
        if (oldWinId) {
            removeManagedWindow(reinterpret_cast<HWND>(oldWinId));
        }

        if (!winId) {
            return;
        }

        // Install window hook
        auto winId = m_windowHandle->winId();
        auto hWnd = reinterpret_cast<HWND>(winId);
        if (!isSystemBorderEnabled()) {
            static auto margins = QVariant::fromValue(QMargins(1, 1, 1, 1));

#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
        if (!isWin10OrGreater())
#endif
            // If we remove the system border, the window will lose its shadow. If dwm is enabled,
            // then we need to set at least 1px margins, otherwise the following operation will
            // fail with no effect.
            setWindowAttribute(QStringLiteral("extra-margins"), margins);
        }

        // We should disable WS_SYSMENU, otherwise the system button icons will be visible if mica
        // is enabled and the title bar is transparent.
        {
            static constexpr const MARGINS margins = {1, 1, 1, 1};
            DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins);
            auto style = ::GetWindowLongPtrW(hWnd, GWL_STYLE);
            if (isSystemBorderEnabled()) {
                ::SetWindowLongPtrW(hWnd, GWL_STYLE, style & (~WS_SYSMENU));
            } else {
                ::SetWindowLongPtrW(hWnd, GWL_STYLE,
                                    (style | WS_THICKFRAME | WS_CAPTION) & (~WS_SYSMENU));
            }
        }

#if !QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
        {
            DWORD style = ::GetWindowLongW(hWnd, GWL_STYLE);
            ::SetWindowLongW(hWnd, GWL_STYLE, style | WS_THICKFRAME | WS_CAPTION);
        }
#endif

#if QT_VERSION < QT_VERSION_CHECK(6, 5, 0)
        for (const auto attr : {
                 _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1,
                 _DWMWA_USE_IMMERSIVE_DARK_MODE,
             }) {
            const BOOL enable = TRUE;
            DynamicApis::instance().pDwmSetWindowAttribute(hWnd, attr, &enable, sizeof(enable));
        }
#endif

        // Add managed window
        addManagedWindow(m_windowHandle, hWnd, this);

        // Cache win id
        windowId = winId;
    }

    bool Win32WindowContext::windowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
@@ -753,8 +879,8 @@
        // We should skip these messages otherwise we will get crashes.
        // NOTE: WM_QUIT won't be posted to the WindowProc function.
        switch (message) {
            case WM_CLOSE:
            case WM_DESTROY:
            case WM_CLOSE:
            case WM_NCDESTROY:
            // Undocumented messages:
            case WM_UAHDESTROYWINDOW:
@@ -785,13 +911,9 @@

        // Forward to native event filter subscribers
        if (!m_nativeEventFilters.isEmpty()) {
            MSG msg;
            msg.hwnd = hWnd;
            msg.message = message;
            msg.wParam = wParam;
            msg.lParam = lParam;
            MSG msg = createMessageBlock(hWnd, message, wParam, lParam);
            QT_NATIVE_EVENT_RESULT_TYPE res = 0;
            if (dispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
            if (nativeDispatch(nativeEventType(), &msg, &res)) {
                *result = LRESULT(res);
                return true;
            }
@@ -801,11 +923,45 @@

    bool Win32WindowContext::windowAttributeChanged(const QString &key, const QVariant &attribute,
                                                    const QVariant &oldAttribute) {
        const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());
        Q_UNUSED(oldAttribute)

        const auto hwnd = reinterpret_cast<HWND>(m_windowId);
        const DynamicApis &apis = DynamicApis::instance();
        static constexpr const MARGINS extendMargins = {-1, -1, -1, -1};
        static const auto defaultMargins =
            isWin10OrGreater() ? MARGINS{0, 0, 0, 0} : MARGINS{1, 1, 1, 1};
        static constexpr const MARGINS extendedMargins = {-1, -1, -1, -1};
        const auto &restoreMargins = [this, &apis, hwnd]() {
            auto margins = qmargins2margins(
                m_windowAttributes.value(QStringLiteral("extra-margins")).value<QMargins>());
            apis.pDwmExtendFrameIntoClientArea(hwnd, &margins);
        };

        if (key == QStringLiteral("extra-margins")) {
            auto margins = qmargins2margins(attribute.value<QMargins>());
            return apis.pDwmExtendFrameIntoClientArea(hwnd, &margins) == S_OK;
        }

        if (key == QStringLiteral("dark-mode")) {
            if (!isWin101809OrGreater()) {
                return false;
            }

            BOOL enable = attribute.toBool();
            if (isWin101903OrGreater()) {
                apis.pSetPreferredAppMode(enable ? PAM_AUTO : PAM_DEFAULT);
            } else {
                apis.pAllowDarkModeForApp(enable);
            }
            for (const auto attr : {
                     _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1,
                     _DWMWA_USE_IMMERSIVE_DARK_MODE,
                 }) {
                apis.pDwmSetWindowAttribute(hwnd, attr, &enable, sizeof(enable));
            }

            apis.pFlushMenuThemes();
            return true;
        }

        // For Win11 or later
        if (key == QStringLiteral("mica")) {
            if (!isWin11OrGreater()) {
                return false;
@@ -813,7 +969,7 @@
            if (attribute.toBool()) {
                // We need to extend the window frame into the whole client area to be able
                // to see the blurred window background.
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);
                if (isWin1122H2OrGreater()) {
                    // Use official DWM API to enable Mica, available since Windows 11 22H2
                    // (10.0.22621).
@@ -835,17 +991,19 @@
                    const BOOL enable = FALSE;
                    apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable));
                }
                apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
                restoreMargins();
            }
            return true;
        } else if (key == QStringLiteral("mica-alt")) {
        }

        if (key == QStringLiteral("mica-alt")) {
            if (!isWin1122H2OrGreater()) {
                return false;
            }
            if (attribute.toBool()) {
                // We need to extend the window frame into the whole client area to be able
                // to see the blurred window background.
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);
                // Use official DWM API to enable Mica Alt, available since Windows 11 22H2
                // (10.0.22621).
                const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TABBEDWINDOW;
@@ -855,60 +1013,62 @@
                const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
                apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
                                            sizeof(backdropType));
                apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
                restoreMargins();
            }
            return true;
        } else if (key == QStringLiteral("acrylic-material")) {
            if (!isWin10OrGreater()) {
        }

        if (key == QStringLiteral("acrylic-material")) {
            if (!isWin11OrGreater()) {
                return false;
            }
            if (attribute.userType() == QMetaType::QColor) {
                // We need to extend the window frame into the whole client area to be able
                // to see the blurred window background.
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
                if (isWin11OrGreater()) {
                    const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TRANSIENTWINDOW;
                    apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
                                                sizeof(backdropType));
                } else {
                    auto gradientColor = attribute.value<QColor>();

                    ACCENT_POLICY policy{};
                    policy.dwAccentState = ACCENT_ENABLE_ACRYLICBLURBEHIND;
                    policy.dwAccentFlags = ACCENT_ENABLE_ACRYLIC_WITH_LUMINOSITY;
                    // This API expects the #AABBGGRR format.
                    policy.dwGradientColor =
                        DWORD(qRgba(gradientColor.blue(), gradientColor.green(),
                                    gradientColor.red(), gradientColor.alpha()));
                    WINDOWCOMPOSITIONATTRIBDATA wcad{};
                    wcad.Attrib = WCA_ACCENT_POLICY;
                    wcad.pvData = &policy;
                    wcad.cbData = sizeof(policy);
                    apis.pSetWindowCompositionAttribute(hwnd, &wcad);
                }
            } else {
                if (isWin11OrGreater()) {
                    const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
                    apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
                                                sizeof(backdropType));
                } else {
                    ACCENT_POLICY policy{};
                    policy.dwAccentState = ACCENT_DISABLED;
                    policy.dwAccentFlags = ACCENT_NONE;
                    WINDOWCOMPOSITIONATTRIBDATA wcad{};
                    wcad.Attrib = WCA_ACCENT_POLICY;
                    wcad.pvData = &policy;
                    wcad.cbData = sizeof(policy);
                    apis.pSetWindowCompositionAttribute(hwnd, &wcad);
                }
                apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
            }
            return true;
        } else if (key == QStringLiteral("dwm-blur")) {
            if (attribute.toBool()) {
                // We need to extend the window frame into the whole client area to be able
                // to see the blurred window background.
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
                apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);

                const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TRANSIENTWINDOW;
                apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
                                            sizeof(backdropType));

                // PRIVATE API REFERENCE:
                //     QColor gradientColor = {};
                //     ACCENT_POLICY policy{};
                //     policy.dwAccentState = ACCENT_ENABLE_ACRYLICBLURBEHIND;
                //     policy.dwAccentFlags = ACCENT_ENABLE_ACRYLIC_WITH_LUMINOSITY;
                //     // This API expects the #AABBGGRR format.
                //     policy.dwGradientColor =
                //         DWORD(qRgba(gradientColor.blue(), gradientColor.green(),
                //                     gradientColor.red(), gradientColor.alpha()));
                //     WINDOWCOMPOSITIONATTRIBDATA wcad{};
                //     wcad.Attrib = WCA_ACCENT_POLICY;
                //     wcad.pvData = &policy;
                //     wcad.cbData = sizeof(policy);
                //     apis.pSetWindowCompositionAttribute(hwnd, &wcad);
            } else {
                const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
                apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
                                            sizeof(backdropType));

                // PRIVATE API REFERENCE:
                //     ACCENT_POLICY policy{};
                //     policy.dwAccentState = ACCENT_DISABLED;
                //     policy.dwAccentFlags = ACCENT_NONE;
                //     WINDOWCOMPOSITIONATTRIBDATA wcad{};
                //     wcad.Attrib = WCA_ACCENT_POLICY;
                //     wcad.pvData = &policy;
                //     wcad.cbData = sizeof(policy);
                //     apis.pSetWindowCompositionAttribute(hwnd, &wcad);

                restoreMargins();
            }
            return true;
        }

        if (key == QStringLiteral("dwm-blur")) {
            if (attribute.toBool()) {
                // We can't extend the window frame for this effect.
                restoreMargins();
                if (isWin8OrGreater()) {
                    ACCENT_POLICY policy{};
                    policy.dwAccentState = ACCENT_ENABLE_BLURBEHIND;
@@ -940,7 +1100,6 @@
                    bb.dwFlags = DWM_BB_ENABLE;
                    apis.pDwmEnableBlurBehindWindow(hwnd, &bb);
                }
                apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
            }
            return true;
        }
@@ -1149,9 +1308,8 @@
    case WM_NCPOINTERUP:
#endif
            case WM_NCMOUSEHOVER: {
                const WindowPart currentWindowPart = lastHitTestResult;
                if (message == WM_NCMOUSEMOVE) {
                    if (currentWindowPart != WindowPart::ChromeButton) {
                    if (lastHitTestResult != WindowPart::ChromeButton) {
                        // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/widgets/kernel/qwidgetwindow.cpp#L472
                        // When the mouse press event arrives, QWidgetWindow will implicitly grab
                        // the top widget right under the mouse, and set `qt_button_down` to this
@@ -1200,29 +1358,60 @@
                        // the above problems would not arise.

                        m_delegate->resetQtGrabbedControl(m_host);

                        // If the mouse moves from chrome buttons to other non-client areas, a
                        // WM_MOUSELEAVE message should be sent.
                        if (mouseLeaveBlocked) {
                            emulateClientAreaMessage(hWnd, message, wParam, lParam,
                                                     WM_NCMOUSELEAVE);
                        }
                    }

                    // We need to make sure we get the right hit-test result when a WM_NCMOUSELEAVE
                    // comes, so we reset it when we receive a WM_NCMOUSEMOVE.

                    // If the mouse is entering the client area, there must be a WM_NCHITTEST
                    // setting it to `Client` before the WM_NCMOUSELEAVE comes; if the mouse is
                    // leaving the window, current window part remains as `Outside`.
                    lastHitTestResult = WindowPart::Outside;
                }

                if (currentWindowPart == WindowPart::ChromeButton) {
                    emulateClientAreaMessage(hWnd, message, wParam, lParam);
                if (lastHitTestResult == WindowPart::ChromeButton) {
                    if (message == WM_NCMOUSEMOVE) {
                        // ### FIXME FIXME FIXME
                        // ### FIXME: Calling DefWindowProc() here is really dangerous, investigate
                        // how to avoid doing this.
                        // ### FIXME FIXME FIXME
                        *result = ::DefWindowProcW(hWnd, WM_NCMOUSEMOVE, wParam, lParam);
                        emulateClientAreaMessage(hWnd, message, wParam, lParam);
                        return true;
                    }

                    if (lastHitTestResultRaw == HTSYSMENU) {
                        switch (message) {
                            case WM_NCLBUTTONDOWN:
                                if (iconButtonClickLevel == 0) {
                                    // A message of WM_SYSCOMMAND with SC_MOUSEMENU will be sent by
                                    // Windows, and the current control flow will be blocked by the
                                    // menu while Windows will create and execute a new event loop
                                    // until the menu returns
                                    iconButtonClickTime = ::GetTickCount64();
                                    *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
                                    iconButtonClickTime = 0;
                                    if (iconButtonClickLevel & IconButtonTriggersClose) {
                                        ::PostMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
                                    }
                                    if (iconButtonClickLevel & IconButtonDoubleClicked) {
                                        iconButtonClickLevel = 0;
                                    }
                                    // Otherwise, no need to reset `iconButtonClickLevel` if not to
                                    // close, if it has value, there must be another incoming
                                    // WM_NCLBUTTONDOWN
                                } else {
                                    iconButtonClickLevel = 0;
                                }
                                break;
                            case WM_NCLBUTTONDBLCLK:
                                // A message of WM_SYSCOMMAND with SC_CLOSE will be sent by Windows
                                *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
                                break;
                            default:
                                *result = FALSE;
                                emulateClientAreaMessage(hWnd, message, wParam, lParam);
                                break;
                        }
                    } else {
                        // According to MSDN, we should return non-zero for X button messages to
                        // indicate we have handled these messages (due to historical reasons), for
@@ -1231,6 +1420,7 @@
                            (((message >= WM_NCXBUTTONDOWN) && (message <= WM_NCXBUTTONDBLCLK))
                                 ? TRUE
                                 : FALSE);
                        emulateClientAreaMessage(hWnd, message, wParam, lParam);
                    }
                    return true;
                }
@@ -1244,7 +1434,7 @@
                    // pressing area as HTCLIENT which maybe because of our former retransmission of
                    // WM_NCLBUTTONDOWN, as a result, a WM_NCMOUSELEAVE will come immediately and a
                    // lot of WM_MOUSEMOVE will come if we move the mouse, we should track the mouse
                    // in advance.
                    // in advance. (May be redundant?)
                    if (mouseLeaveBlocked) {
                        mouseLeaveBlocked = false;
                        requestForMouseLeaveMessage(hWnd, false);
@@ -1278,19 +1468,6 @@
    bool Win32WindowContext::customWindowHandler(HWND hWnd, UINT message, WPARAM wParam,
                                                 LPARAM lParam, LRESULT *result) {
        switch (message) {
            case WM_SHOWWINDOW: {
                if (!centered) {
                    // If wParam is TRUE, the window is being shown.
                    // If lParam is zero, the message was sent because of a call to the ShowWindow
                    // function.
                    if (wParam && !lParam) {
                        centered = true;
                        moveWindowToDesktopCenter(hWnd);
                    }
                }
                break;
            }

            case WM_NCHITTEST: {
                // 原生Win32窗口只有顶边是在窗口内部resize的，其余三边都是在窗口
                // 外部进行resize的，其原理是，WS_THICKFRAME这个窗口样式会在窗
@@ -1373,7 +1550,8 @@
                // color, our homemade top border can almost have exactly the same
                // appearance with the system's one.
                [[maybe_unused]] const auto &hitTestRecorder = qScopeGuard([this, result]() {
                    lastHitTestResult = getHitWindowPart(int(*result)); //
                    lastHitTestResultRaw = int(*result);
                    lastHitTestResult = getHitWindowPart(lastHitTestResultRaw);
                });

                POINT nativeGlobalPos{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
@@ -1472,8 +1650,7 @@
                int frameSize = getResizeBorderThickness(hWnd);
                bool isTop = (nativeLocalPos.y < frameSize);

#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
                if (isWin10OrGreater()) {
                if (isSystemBorderEnabled()) {
                    // This will handle the left, right and bottom parts of the frame
                    // because we didn't change them.
                    LRESULT originalHitTestResult = ::DefWindowProcW(hWnd, WM_NCHITTEST, 0, lParam);
@@ -1515,9 +1692,7 @@
                    }
                    *result = HTCLIENT;
                    return true;
                } else
#endif
                {
                } else {
                    if (full) {
                        *result = HTCLIENT;
                        return true;
@@ -1603,7 +1778,7 @@
                break;
        }

        if (!isWin10OrGreater()) {
        if (!isSystemBorderEnabled()) {
            switch (message) {
                case WM_NCUAHDRAWCAPTION:
                case WM_NCUAHDRAWFRAME: {
@@ -1667,7 +1842,6 @@
        Q_UNUSED(message)
        Q_UNUSED(this)

#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
        // Windows是根据这个消息的返回值来设置窗口的客户区（窗口中真正显示的内容）
        // 和非客户区（标题栏、窗口边框、菜单栏和状态栏等Windows系统自行提供的部分
        // ，不过对于Qt来说，除了标题栏和窗口边框，非客户区基本也都是自绘的）的范
@@ -1755,7 +1929,7 @@
        // and align it with the upper-left corner of our new client area".
        const auto clientRect = wParam ? &(reinterpret_cast<LPNCCALCSIZE_PARAMS>(lParam))->rgrc[0]
                                       : reinterpret_cast<LPRECT>(lParam);
        if (isWin10OrGreater()) {
        if (isSystemBorderEnabled()) {
            // Store the original top margin before the default window procedure applies the
            // default frame.
            const LONG originalTop = clientRect->top;
@@ -1782,6 +1956,7 @@
            // technique to bring the top border back.
            clientRect->top = originalTop;
        }

        const bool max = IsMaximized(hWnd);
        const bool full = isFullScreen(hWnd);
        // We don't need this correction when we're fullscreen. We will
@@ -1796,7 +1971,7 @@
            // a window when it's maximized unless you restore it).
            const quint32 frameSize = getResizeBorderThickness(hWnd);
            clientRect->top += frameSize;
            if (!isWin10OrGreater()) {
            if (!isSystemBorderEnabled()) {
                clientRect->bottom -= frameSize;
                clientRect->left += frameSize;
                clientRect->right -= frameSize;
@@ -1875,7 +2050,6 @@
                }
            }
        }
#endif
        // We should call this function only before the function returns.
        syncPaintEventWithDwm();
        // By returning WVR_REDRAW we can make the window resizing look
@@ -1900,10 +2074,11 @@
        const auto getNativeGlobalPosFromKeyboard = [hWnd]() -> POINT {
            const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
            const quint32 frameSize = getResizeBorderThickness(hWnd);
            const quint32 horizontalOffset = ((maxOrFull || !isWin10OrGreater()) ? 0 : frameSize);
            const quint32 horizontalOffset =
                ((maxOrFull || !isSystemBorderEnabled()) ? 0 : frameSize);
            const auto verticalOffset = [hWnd, maxOrFull, frameSize]() -> quint32 {
                const quint32 titleBarHeight = getTitleBarHeight(hWnd);
                if (!isWin10OrGreater()) {
                if (!isSystemBorderEnabled()) {
                    return titleBarHeight;
                }
                if (isWin11OrGreater()) {
@@ -1925,12 +2100,16 @@
        bool shouldShowSystemMenu = false;
        bool broughtByKeyboard = false;
        POINT nativeGlobalPos{};

        switch (message) {
            case WM_RBUTTONUP: {
                const POINT nativeLocalPos = getNativePosFromMouse();
                const QPoint qtScenePos =
                    QHighDpi::fromNativeLocalPosition(point2qpoint(nativeLocalPos), m_windowHandle);
                if (isInTitleBarDraggableArea(qtScenePos)) {
                WindowAgentBase::SystemButton sysButtonType = WindowAgentBase::Unknown;
                if (isInTitleBarDraggableArea(qtScenePos) ||
                    (isInSystemButtons(qtScenePos, &sysButtonType) &&
                     sysButtonType == WindowAgentBase::WindowIcon)) {
                    shouldShowSystemMenu = true;
                    nativeGlobalPos = nativeLocalPos;
                    ::ClientToScreen(hWnd, &nativeGlobalPos);
@@ -1946,10 +2125,20 @@
            }
            case WM_SYSCOMMAND: {
                const WPARAM filteredWParam = (wParam & 0xFFF0);
                if ((filteredWParam == SC_KEYMENU) && (lParam == VK_SPACE)) {
                    shouldShowSystemMenu = true;
                    broughtByKeyboard = true;
                    nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                switch (filteredWParam) {
                    case SC_MOUSEMENU:
                        shouldShowSystemMenu = true;
                        nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                        break;
                    case SC_KEYMENU:
                        if (lParam == VK_SPACE) {
                            shouldShowSystemMenu = true;
                            broughtByKeyboard = true;
                            nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                        }
                        break;
                    default:
                        break;
                }
                break;
            }
@@ -1968,8 +2157,86 @@
                break;
        }
        if (shouldShowSystemMenu) {
            showSystemMenu2(hWnd, nativeGlobalPos, broughtByKeyboard,
                            m_delegate->isHostSizeFixed(m_host));
            static HHOOK mouseHook = nullptr;
            static std::optional<POINT> mouseClickPos;
            static bool mouseDoubleClicked = false;
            bool mouseHookedLocal = false;

            // The menu is triggered by a click on icon button
            if (iconButtonClickTime > 0) {
                POINT menuPos{0, static_cast<LONG>(getTitleBarHeight(hWnd))};
                if (const auto tb = titleBar()) {
                    auto titleBarHeight = qreal(m_delegate->mapGeometryToScene(tb).height());
                    titleBarHeight *= m_windowHandle->devicePixelRatio();
                    menuPos.y = qRound(titleBarHeight);
                }
                ::ClientToScreen(hWnd, &menuPos);
                nativeGlobalPos = menuPos;

                // Install mouse hook
                if (!mouseHook) {
                    mouseHook = ::SetWindowsHookExW(
                        WH_MOUSE,
                        [](int nCode, WPARAM wParam, LPARAM lParam) {
                            if (nCode >= 0) {
                                switch (wParam) {
                                    case WM_LBUTTONDBLCLK:
                                        mouseDoubleClicked = true;
                                        Q_FALLTHROUGH();

                                        // case WM_POINTERDOWN:

                                    case WM_LBUTTONDOWN: {
                                        auto pMouseStruct =
                                            reinterpret_cast<MOUSEHOOKSTRUCT *>(lParam);
                                        if (pMouseStruct) {
                                            mouseClickPos = pMouseStruct->pt;
                                        }
                                        break;
                                    }
                                    default:
                                        break;
                                }
                            }
                            return ::CallNextHookEx(nullptr, nCode, wParam, lParam);
                        },
                        nullptr, ::GetCurrentThreadId());
                    mouseHookedLocal = true;
                }
            }

            bool res = showSystemMenu_sys(hWnd, nativeGlobalPos, broughtByKeyboard,
                                          m_delegate->isHostSizeFixed(m_host));

            // Uninstall mouse hook and check if it's a double-click
            if (mouseHookedLocal) {
                ::UnhookWindowsHookEx(mouseHook);

                // Emulate the Windows icon button's behavior
                if (!res && mouseClickPos.has_value()) {
                    POINT nativeLocalPos = mouseClickPos.value();
                    ::ScreenToClient(hWnd, &nativeLocalPos);
                    QPoint qtScenePos = QHighDpi::fromNativeLocalPosition(
                        point2qpoint(nativeLocalPos), m_windowHandle);
                    WindowAgentBase::SystemButton sysButtonType = WindowAgentBase::Unknown;
                    if (isInSystemButtons(qtScenePos, &sysButtonType) &&
                        sysButtonType == WindowAgentBase::WindowIcon) {
                        iconButtonClickLevel |= IconButtonClicked;
                        if (::GetTickCount64() - iconButtonClickTime <= ::GetDoubleClickTime()) {
                            iconButtonClickLevel |= IconButtonTriggersClose;
                        }
                    }
                }

                if (mouseDoubleClicked) {
                    iconButtonClickLevel |= IconButtonDoubleClicked;
                }

                mouseHook = nullptr;
                mouseClickPos.reset();
                mouseDoubleClicked = false;
            }

            // QPA's internal code will handle system menu events separately, and its
            // behavior is not what we would want to see because it doesn't know our
            // window doesn't have any window frame now, so return early here to avoid