Add context factory

Sine Striker

2023-12-07 1a1f26d9e4ab6a4fe51baa78e40c4cdf3f402bcf

 src/core/contexts/win32windowcontext.cpp

@@ -5,10 +5,9 @@

#include <QtCore/QHash>
#include <QtCore/QAbstractNativeEventFilter>
#include <QtCore/QCoreApplication>
#include <QtCore/QOperatingSystemVersion>
#include <QtCore/QScopeGuard>
#include <QtCore/QTimer>
#include <QtGui/QGuiApplication>

#include <QtCore/private/qsystemlibrary_p.h>
#include <QtGui/private/qhighdpiscaling_p.h>
@@ -189,20 +188,12 @@
    }

    static inline void triggerFrameChange(HWND hwnd) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
            return;
        }
        ::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) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
            return 0;
        }
        const DynamicApis &apis = DynamicApis::instance();
        if (apis.pGetDpiForWindow) {         // Win10
            return apis.pGetDpiForWindow(hwnd);
@@ -222,10 +213,6 @@
    }

    static inline quint32 getResizeBorderThickness(HWND hwnd) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
            return 0;
        }
        const DynamicApis &apis = DynamicApis::instance();
        if (apis.pGetSystemMetricsForDpi) {
            const quint32 dpi = getDpiForWindow(hwnd);
@@ -237,10 +224,6 @@
    }

    static inline quint32 getTitleBarHeight(HWND hwnd) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
            return 0;
        }
        const auto captionHeight = [hwnd]() -> int {
            const DynamicApis &apis = DynamicApis::instance();
            if (apis.pGetSystemMetricsForDpi) {
@@ -254,18 +237,13 @@
    }

    static inline void updateInternalWindowFrameMargins(HWND hwnd, QWindow *window) {
        Q_ASSERT(hwnd);
        Q_ASSERT(window);
        if (!hwnd || !window) {
            return;
        }
        const auto margins = [hwnd]() -> QMargins {
            const int titleBarHeight = getTitleBarHeight(hwnd);
            if (isWin10OrGreater()) {
                return { 0, -titleBarHeight, 0, 0 };
                return {0, -titleBarHeight, 0, 0};
            } else {
                const int frameSize = getResizeBorderThickness(hwnd);
                return { -frameSize, -titleBarHeight, -frameSize, -frameSize };
                return {-frameSize, -titleBarHeight, -frameSize, -frameSize};
            }
        }();
        const QVariant marginsVar = QVariant::fromValue(margins);
@@ -273,21 +251,19 @@
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
        if (QPlatformWindow *platformWindow = window->handle()) {
            if (const auto ni = QGuiApplication::platformNativeInterface()) {
                ni->setWindowProperty(platformWindow, QStringLiteral("_q_windowsCustomMargins"), marginsVar);
                ni->setWindowProperty(platformWindow, QStringLiteral("_q_windowsCustomMargins"),
                                      marginsVar);
            }
        }
#else
        if (const auto platformWindow = dynamic_cast<QNativeInterface::Private::QWindowsWindow *>(window->handle())) {
        if (const auto platformWindow =
                dynamic_cast<QNativeInterface::Private::QWindowsWindow *>(window->handle())) {
            platformWindow->setCustomMargins(margins);
        }
#endif
    }

    static inline std::optional<MONITORINFOEXW> getMonitorForWindow(HWND hwnd) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
            return std::nullopt;
        }
    static inline MONITORINFOEXW getMonitorForWindow(HWND hwnd) {
        // Use "MONITOR_DEFAULTTONEAREST" here so that we can still get the correct
        // monitor even if the window is minimized.
        HMONITOR monitor = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
@@ -297,6 +273,16 @@
        return monitorInfo;
    };

    static inline void moveToDesktopCenter(HWND hwnd) {
        const auto monitorInfo = getMonitorForWindow(hwnd);
        RECT windowRect{};
        ::GetWindowRect(hwnd, &windowRect);
        const auto newX = (RECT_WIDTH(monitorInfo.rcMonitor) - RECT_WIDTH(windowRect)) / 2;
        const auto newY = (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 bool isFullScreen(HWND hwnd) {
        Q_ASSERT(hwnd);
        if (!hwnd) {
@@ -304,9 +290,8 @@
        }
        RECT windowRect{};
        ::GetWindowRect(hwnd, &windowRect);
        const std::optional<MONITORINFOEXW> mi = getMonitorForWindow(hwnd);
        // Compare to the full area of the screen, not the work area.
        return (windowRect == mi.value_or(MONITORINFOEXW{}).rcMonitor);
        return (windowRect == getMonitorForWindow(hwnd).rcMonitor);
    }

    static inline bool isWindowNoState(HWND hwnd) {
@@ -367,7 +352,7 @@
    }

    static bool isValidWindow(HWND hWnd, bool checkVisible, bool checkTopLevel) {
        if (::IsWindow(hWnd) == FALSE) {
        if (!::IsWindow(hWnd)) {
            return false;
        }
        const LONG_PTR styles = ::GetWindowLongPtrW(hWnd, GWL_STYLE);
@@ -378,15 +363,15 @@
        if (exStyles & WS_EX_TOOLWINDOW) {
            return false;
        }
        RECT rect = {0, 0, 0, 0};
        if (::GetWindowRect(hWnd, &rect) == FALSE) {
        RECT rect{};
        if (!::GetWindowRect(hWnd, &rect)) {
            return false;
        }
        if ((rect.left >= rect.right) || (rect.top >= rect.bottom)) {
            return false;
        }
        if (checkVisible) {
            if (::IsWindowVisible(hWnd) == FALSE) {
            if (!::IsWindowVisible(hWnd)) {
                return false;
            }
        }
@@ -409,11 +394,14 @@
    public:
        bool nativeEventFilter(const QByteArray &eventType, void *message,
                               QT_NATIVE_EVENT_RESULT_TYPE *result) override {
            Q_UNUSED(eventType);

            // It has been observed that the pointer that Qt gives us is sometimes null on some
            // machines. We need to guard against it in such scenarios.
            if (!result) {
                return false;
            }

            if (lastMessageHandled) {
                *result = static_cast<QT_NATIVE_EVENT_RESULT_TYPE>(lastMessageResult);
                return true;
@@ -514,13 +502,15 @@
        // TODO: Determine whether to show system menu
        // ...

        // Since Qt does the necessary processing of the message afterward, we still need to
        // Since Qt does the necessary processing of the WM_NCCALCSIZE afterward, we still need to
        // continue dispatching it.
        if (handled && message != WM_NCCALCSIZE) {
            return result;
        }
        return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
    }

    Win32WindowContext::Win32WindowContext(QObject *host, WindowItemDelegate *delegate)
        : AbstractWindowContext(host, delegate) {
    Win32WindowContext::Win32WindowContext() : AbstractWindowContext() {
    }

    Win32WindowContext::~Win32WindowContext() {
@@ -535,8 +525,8 @@
        }
    }

    bool Win32WindowContext::setup() {
        if (!m_windowHandle) {
    bool Win32WindowContext::setup(QObject *host, WindowItemDelegate *delegate) {
        if (!AbstractWindowContext::setup(host, delegate)) {
            return false;
        }

@@ -565,8 +555,6 @@

        // Save window handle mapping
        g_wndProcHash->insert(hWnd, this);

        QTimer::singleShot(0, m_windowHandle, [hWnd](){ triggerFrameChange(hWnd); });

        return true;
    }
@@ -617,7 +605,7 @@
        const auto &get = [](const int virtualKey) -> bool {
            return (::GetAsyncKeyState(virtualKey) < 0);
        };
        const bool buttonSwapped = (::GetSystemMetrics(SM_SWAPBUTTON) != FALSE);
        const bool buttonSwapped = ::GetSystemMetrics(SM_SWAPBUTTON);
        if (get(VK_LBUTTON)) {
            result |= (buttonSwapped ? MK_RBUTTON : MK_LBUTTON);
        }
@@ -760,9 +748,10 @@
                    // actually lost the hover state. So we filter out these superfluous mouse leave
                    // events here to avoid this issue.
                    DWORD dwScreenPos = ::GetMessagePos();
                    POINT screenPoint{GET_X_LPARAM(dwScreenPos), GET_Y_LPARAM(dwScreenPos)};
                    ::ScreenToClient(hWnd, &screenPoint);
                    QPoint qtScenePos =
                        fromNativeLocalPosition(m_windowHandle, QPoint(GET_X_LPARAM(dwScreenPos),
                                                                       GET_Y_LPARAM(dwScreenPos)));
                        fromNativeLocalPosition(m_windowHandle, {screenPoint.x, screenPoint.y});
                    auto dummy = CoreWindowAgent::Unknown;
                    if (isInSystemButtons(qtScenePos, &dummy)) {
                        // We must record whether the last WM_MOUSELEAVE was filtered, because if
@@ -887,6 +876,18 @@
    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 == 0) {
                        centered = true;
                        moveToDesktopCenter(hWnd);
                    }
                }
                break;
            }
            case WM_NCCALCSIZE: {
                // Windows是根据这个消息的返回值来设置窗口的客户区（窗口中真正显示的内容）
                // 和非客户区（标题栏、窗口边框、菜单栏和状态栏等Windows系统自行提供的部分
@@ -974,8 +975,8 @@
                // simply return 0, which means "preserve the entire old client area
                // and align it with the upper-left corner of our new client area".
                const auto clientRect =
                    ((wParam == FALSE) ? reinterpret_cast<LPRECT>(lParam)
                                       : &(reinterpret_cast<LPNCCALCSIZE_PARAMS>(lParam))->rgrc[0]);
                    wParam ? &(reinterpret_cast<LPNCCALCSIZE_PARAMS>(lParam))->rgrc[0]
                           : reinterpret_cast<LPRECT>(lParam);
                if (isWin10OrGreater()) {
                    // Store the original top margin before the default window procedure applies the
                    // default frame.
@@ -1041,9 +1042,7 @@
                        // we have to use another way to judge this if we are running
                        // on Windows 7 or Windows 8.
                        if (isWin8Point1OrGreater()) {
                            const std::optional<MONITORINFOEXW> monitorInfo =
                                getMonitorForWindow(hWnd);
                            const RECT monitorRect = monitorInfo.value().rcMonitor;
                            const RECT monitorRect = getMonitorForWindow(hWnd).rcMonitor;
                            // This helper can be used to determine if there's an
                            // auto-hide taskbar on the given edge of the monitor
                            // we're currently on.
@@ -1111,7 +1110,7 @@
                // of the upper-left non-client area. It's confirmed that this issue exists
                // from Windows 7 to Windows 10. Not tested on Windows 11 yet. Don't know
                // whether it exists on Windows XP to Windows Vista or not.
                *result = wParam == FALSE ? FALSE : WVR_REDRAW;
                *result = wParam ? WVR_REDRAW : FALSE;
                return true;
            }
            case WM_NCHITTEST: {
@@ -1214,7 +1213,7 @@

                bool isFixedSize = m_delegate->isHostSizeFixed(m_host);
                bool isTitleBar = isInTitleBarDraggableArea(qtScenePos);
                bool dontOverrideCursor = false;                  // ### TODO
                bool dontOverrideCursor = false; // ### TODO

                CoreWindowAgent::SystemButton sysButtonType = CoreWindowAgent::Unknown;
                if (!isFixedSize && isInSystemButtons(qtScenePos, &sysButtonType)) {
@@ -1265,8 +1264,6 @@
                                break;
                            case CoreWindowAgent::Close:
                                *result = HTCLOSE;
                                break;
                            case CoreWindowAgent::Unknown:
                                break;
                            default:
                                break; // unreachable
@@ -1329,6 +1326,7 @@
                        return true;
                    }
                    *result = HTCLIENT;
                    return true;
                } else {
                    if (full) {
                        *result = HTCLIENT;
@@ -1390,8 +1388,8 @@
                        return true;
                    }
                    *result = HTCLIENT;
                    return true;
                }
                return true;
            }
            default:
                break;
@@ -1428,10 +1426,10 @@
                        // window activation state change.
                        *result = ::DefWindowProcW(hWnd, WM_NCACTIVATE, wParam, -1);
                    } else {
                        if (wParam == FALSE) {
                            *result = TRUE;
                        } else {
                        if (wParam) {
                            *result = FALSE;
                        } else {
                            *result = TRUE;
                        }
                    }
                    return true;
@@ -1459,4 +1457,4 @@
        return false;
    }

}
}