Add example resources

Sine Striker

2023-12-14 e18723d66cf470720c29a9d2848150ea1cbe5450

 src/core/contexts/win32windowcontext.cpp

@@ -27,7 +27,6 @@
#include <dwmapi.h>
#include <timeapi.h>

#include "nativeeventfilter_p.h"
#include "qwkglobal_p.h"

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -84,7 +83,7 @@
    // ### FIXME: Tell the user to call in the documentation, instead of automatically
    // calling it directly.
    // ### FIXME FIXME FIXME
    static struct QWK_Hook {
    static const struct QWK_Hook {
        QWK_Hook() {
            qApp->setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
        }
@@ -635,7 +634,7 @@
    // DefWindowProc(). Consequently, we have to add a global native filter that forwards the result
    // of the hook function, telling Qt whether we have filtered the events before. Since Qt only
    // handles Windows window messages in the main thread, it is safe to do so.
    class WindowsNativeEventFilter : public NativeEventFilter {
    class WindowsNativeEventFilter : public AppNativeEventFilter {
    public:
        bool nativeEventFilter(const QByteArray &eventType, void *message,
                               QT_NATIVE_EVENT_RESULT_TYPE *result) override {
@@ -850,6 +849,7 @@
                    QPoint{m_windowHandle->width(), 0}
                });
                painter.restore();
                return;
            }

            default: {
@@ -933,10 +933,19 @@
            return true;
        }

        if (themeStuffHandler(hWnd, message, wParam, lParam, result)) {
            return true;
        // Forward to native event filter subscribers
        if (!m_nativeEventFilters.isEmpty()) {
            MSG msg;
            msg.hwnd = hWnd;
            msg.message = message;
            msg.wParam = wParam;
            msg.lParam = lParam;
            QT_NATIVE_EVENT_RESULT_TYPE res = 0;
            if (dispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
                *result = LRESULT(res);
                return true;
            }
        }

        return false; // Not handled
    }

@@ -1919,85 +1928,6 @@
            // entering Qt's own handling logic.
            *result = FALSE;
            return true;
        }
        return false;
    }

    bool Win32WindowContext::themeStuffHandler(HWND hWnd, UINT message, WPARAM wParam,
                                               LPARAM lParam, LRESULT *resul) {
        switch (message) {
            case WM_DPICHANGED: {
                const auto dpiX = UINT(LOWORD(wParam));
                const auto dpiY = UINT(HIWORD(wParam));

                QEvent e(QEvent::ScreenChangeInternal);
                dispatch(&e);
                break;
            }

            case WM_THEMECHANGED:
            case WM_SYSCOLORCHANGE: {
                QEvent e(QEvent::UpdateRequest);
                dispatch(&e);
                break;
            }

            case WM_DWMCOLORIZATIONCOLORCHANGED: {
                const QColor color = QColor::fromRgba(wParam);
                const auto blendWithOpacity = *reinterpret_cast<LPBOOL>(lParam);

                QEvent e(QEvent::UpdateRequest);
                dispatch(&e);
                break;
            }

            case WM_SETTINGCHANGE: {
                if (!wParam && lParam &&
                    std::wcscmp(reinterpret_cast<LPCWSTR>(lParam), L"ImmersiveColorSet") == 0) {
                    const QColor color = getAccentColor();
                }

                QEvent e(QEvent::UpdateRequest);
                dispatch(&e);
                break;
            }

            case WM_SIZE: {
                const bool max = wParam == SIZE_MAXIMIZED;
                const bool min = wParam == SIZE_MINIMIZED;
                const bool full = isFullScreen(hWnd);

                Qt::WindowStates states{};
                if (max) {
                    states |= Qt::WindowMaximized;
                }
                if (min) {
                    states |= Qt::WindowMinimized;
                }
                if (full) {
                    states |= Qt::WindowFullScreen;
                }

                QTimer::singleShot(0, this, [this, states] {
                    QWindowStateChangeEvent e(states);
                    dispatch(&e);
                });
                break;
            }

            case WM_ACTIVATE: {
                const auto state = LOWORD(wParam);
                const bool active = state == WA_ACTIVE || state == WA_CLICKACTIVE;
                Q_UNUSED(state)

                QTimer::singleShot(0, this, [this, active] {
                    QEvent e(active ? QEvent::WindowActivate : QEvent::WindowDeactivate);
                    dispatch(&e);
                });
                break;
            }
            default:
                break;
        }
        return false;
    }