Merge d6525e7907 into 50a1a7f6e9

README.md

@@ -1,4 +1,4 @@
-This repository provides a backport of the Qt 6.8.1 qtbase module, tailored for compatibility with Windows 7 and 8. It contains patched source files from the qtbase module, along with some additional required files. To apply the backport, simply copy the contents of the src folder into your qtbase/src directory, replacing the existing files.
+This repository provides a backport of the Qt 6.8.1 qtbase module, tailored for compatibility with Windows 7, 8 and 8.1. It contains patched source files from the qtbase module, along with some additional required files. To apply the backport, simply copy the contents of the src folder into your qtbase/src directory, replacing the existing files.
 
 This approach builds upon the methodology discussed in this forum [thread](https://forum.qt.io/topic/133002/qt-creator-6-0-1-and-qt-6-2-2-running-on-windows-7/60) but offers significant enhancements, including important fallbacks to the default Qt 6 behavior when running on newer versions of Windows.
 

qtbase/src/plugins/platforms/windows/qwindowsintegration.cpp

@@ -0,0 +1,801 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// Copyright (C) 2013 Samuel Gaist <samuel.gaist@edeltech.ch>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qwindowsintegration.h"
+#include "qwindowswindow.h"
+#include "qwindowscontext.h"
+#include "qwin10helpers.h"
+#include "qwindowsmenu.h"
+#include "qwindowsopenglcontext.h"
+
+#include "qwindowsscreen.h"
+#include "qwindowstheme.h"
+#include "qwindowsservices.h"
+#include <QtGui/private/qtgui-config_p.h>
+#if QT_CONFIG(directwrite3)
+#include <QtGui/private/qwindowsdirectwritefontdatabase_p.h>
+#endif
+#ifndef QT_NO_FREETYPE
+#  include <QtGui/private/qwindowsfontdatabase_ft_p.h>
+#endif
+#include <QtGui/private/qwindowsfontdatabase_p.h>
+#if QT_CONFIG(clipboard)
+#  include "qwindowsclipboard.h"
+#  if QT_CONFIG(draganddrop)
+#    include "qwindowsdrag.h"
+#  endif
+#endif
+#include "qwindowsinputcontext.h"
+#include "qwindowskeymapper.h"
+#if QT_CONFIG(accessibility)
+#  include "uiautomation/qwindowsuiaaccessibility.h"
+#endif
+
+#include <qpa/qplatformnativeinterface.h>
+#include <qpa/qwindowsysteminterface.h>
+#if QT_CONFIG(sessionmanager)
+#  include "qwindowssessionmanager.h"
+#endif
+#include <QtGui/qpointingdevice.h>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtGui/private/qhighdpiscaling_p.h>
+#include <QtGui/qpa/qplatforminputcontextfactory_p.h>
+#include <QtGui/qpa/qplatformcursor.h>
+
+#include <QtGui/private/qwindowsguieventdispatcher_p.h>
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qvariant.h>
+
+#include <QtCore/qoperatingsystemversion.h>
+#include <QtCore/private/qfunctions_win_p.h>
+
+#include <wrl.h>
+
+#include <limits.h>
+
+#if !defined(QT_NO_OPENGL)
+#  include "qwindowsglcontext.h"
+#endif
+
+#include "qwindowsopengltester.h"
+
+#if QT_CONFIG(cpp_winrt)
+#  include <QtCore/private/qt_winrtbase_p.h>
+#  include <winrt/Windows.UI.Notifications.h>
+#  include <winrt/Windows.Data.Xml.Dom.h>
+#  include <winrt/Windows.Foundation.h>
+#  include <winrt/Windows.UI.ViewManagement.h>
+#endif
+
+#include <memory>
+
+static inline void initOpenGlBlacklistResources()
+{
+    Q_INIT_RESOURCE(openglblacklists);
+}
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt::StringLiterals;
+
+struct QWindowsIntegrationPrivate
+{
+    Q_DISABLE_COPY_MOVE(QWindowsIntegrationPrivate)
+    explicit QWindowsIntegrationPrivate() = default;
+    ~QWindowsIntegrationPrivate();
+
+    void parseOptions(QWindowsIntegration *q, const QStringList &paramList);
+
+    unsigned m_options = 0;
+    QWindowsContext m_context;
+    QPlatformFontDatabase *m_fontDatabase = nullptr;
+#if QT_CONFIG(clipboard)
+    QWindowsClipboard m_clipboard;
+#  if QT_CONFIG(draganddrop)
+    QWindowsDrag m_drag;
+#  endif
+#endif
+#ifndef QT_NO_OPENGL
+    QMutex m_staticContextLock;
+    QScopedPointer<QWindowsStaticOpenGLContext> m_staticOpenGLContext;
+#endif // QT_NO_OPENGL
+    QScopedPointer<QPlatformInputContext> m_inputContext;
+#if QT_CONFIG(accessibility)
+   QWindowsUiaAccessibility m_accessibility;
+#endif
+    QWindowsServices m_services;
+};
+
+template <typename IntType>
+bool parseIntOption(const QString &parameter,const QLatin1StringView &option,
+                    IntType minimumValue, IntType maximumValue, IntType *target)
+{
+    const int valueLength = parameter.size() - option.size() - 1;
+    if (valueLength < 1 || !parameter.startsWith(option) || parameter.at(option.size()) != u'=')
+        return false;
+    bool ok;
+    const auto valueRef = QStringView{parameter}.right(valueLength);
+    const int value = valueRef.toInt(&ok);
+    if (ok) {
+        if (value >= int(minimumValue) && value <= int(maximumValue))
+            *target = static_cast<IntType>(value);
+        else {
+            qWarning() << "Value" << value << "for option" << option << "out of range"
+                << minimumValue << ".." << maximumValue;
+        }
+    } else {
+        qWarning() << "Invalid value" << valueRef << "for option" << option;
+    }
+    return true;
+}
+
+using DarkModeHandlingFlag = QNativeInterface::Private::QWindowsApplication::DarkModeHandlingFlag;
+using DarkModeHandling = QNativeInterface::Private::QWindowsApplication::DarkModeHandling;
+
+typedef LONG (WINAPI *RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
+
+bool isWindows81() {
+    HMODULE hNtdll = GetModuleHandleA("ntdll.dll");
+    if (!hNtdll) {
+        return false; // Failed to load ntdll.dll
+    }
+
+    RtlGetVersionPtr RtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hNtdll, "RtlGetVersion");
+    if (!RtlGetVersion) {
+        return false; // Failed to get RtlGetVersion
+    }
+
+    RTL_OSVERSIONINFOW rovi = {0};
+    rovi.dwOSVersionInfoSize = sizeof(rovi);
+
+    if (RtlGetVersion(&rovi) == 0) { // STATUS_SUCCESS
+        return (rovi.dwMajorVersion == 6 && rovi.dwMinorVersion == 3);
+    }
+
+    return false; // Unknown version
+}
+
+static inline unsigned parseOptions(const QStringList &paramList,
+                                    int *tabletAbsoluteRange,
+                                    QtWindows::DpiAwareness *dpiAwareness,
+                                    DarkModeHandling *darkModeHandling)
+{
+    unsigned options = 0;
+
+    // for some reason DirectWrite fonts don't work on Windows 8.1
+    // https://github.com/crystalidea/qt6windows7/issues/26
+
+    if (isWindows81())
+        options |= QWindowsIntegration::DontUseDirectWriteFonts;
+
+    for (const QString &param : paramList) {
+        if (param.startsWith(u"fontengine=")) {
+            if (param.endsWith(u"gdi")) {
+                options |= QWindowsIntegration::FontDatabaseGDI;
+            } else if (param.endsWith(u"freetype")) {
+                options |= QWindowsIntegration::FontDatabaseFreeType;
+            } else if (param.endsWith(u"native")) {
+                options |= QWindowsIntegration::FontDatabaseNative;
+            }
+        } else if (param.startsWith(u"dialogs=")) {
+            if (param.endsWith(u"xp")) {
+                options |= QWindowsIntegration::XpNativeDialogs;
+            } else if (param.endsWith(u"none")) {
+                options |= QWindowsIntegration::NoNativeDialogs;
+            }
+        } else if (param == u"altgr") {
+            options |= QWindowsIntegration::DetectAltGrModifier;
+        } else if (param == u"gl=gdi") {
+            options |= QWindowsIntegration::DisableArb;
+        } else if (param == u"nodirectwrite") {
+            options |= QWindowsIntegration::DontUseDirectWriteFonts;
+        } else if (param == u"nocolorfonts") {
+            options |= QWindowsIntegration::DontUseColorFonts;
+        } else if (param == u"nomousefromtouch") {
+            options |= QWindowsIntegration::DontPassOsMouseEventsSynthesizedFromTouch;
+        } else if (parseIntOption(param, "verbose"_L1, 0, INT_MAX, &QWindowsContext::verbose)
+            || parseIntOption(param, "tabletabsoluterange"_L1, 0, INT_MAX, tabletAbsoluteRange)
+            || parseIntOption(param, "dpiawareness"_L1, QtWindows::DpiAwareness::Invalid,
+                    QtWindows::DpiAwareness::PerMonitorVersion2, dpiAwareness)) {
+        } else if (param == u"menus=native") {
+            options |= QWindowsIntegration::AlwaysUseNativeMenus;
+        } else if (param == u"menus=none") {
+            options |= QWindowsIntegration::NoNativeMenus;
+        } else if (param == u"reverse") {
+            options |= QWindowsIntegration::RtlEnabled;
+        } else if (param == u"darkmode=0") {
+            *darkModeHandling = {};
+        } else if (param == u"darkmode=1") {
+            darkModeHandling->setFlag(DarkModeHandlingFlag::DarkModeWindowFrames);
+            darkModeHandling->setFlag(DarkModeHandlingFlag::DarkModeStyle, false);
+        } else if (param == u"darkmode=2") {
+            darkModeHandling->setFlag(DarkModeHandlingFlag::DarkModeWindowFrames);
+            darkModeHandling->setFlag(DarkModeHandlingFlag::DarkModeStyle);
+        } else {
+            qWarning() << "Unknown option" << param;
+        }
+    }
+    return options;
+}
+
+void QWindowsIntegrationPrivate::parseOptions(QWindowsIntegration *q, const QStringList &paramList)
+{
+    initOpenGlBlacklistResources();
+
+    static bool dpiAwarenessSet = false;
+    // Default to per-monitor-v2 awareness (if available)
+    QtWindows::DpiAwareness dpiAwareness = QtWindows::DpiAwareness::PerMonitorVersion2;
+
+    int tabletAbsoluteRange = -1;
+    DarkModeHandling darkModeHandling = DarkModeHandlingFlag::DarkModeWindowFrames
+                                      | DarkModeHandlingFlag::DarkModeStyle;
+    m_options = ::parseOptions(paramList, &tabletAbsoluteRange, &dpiAwareness, &darkModeHandling);
+    q->setDarkModeHandling(darkModeHandling);
+    QWindowsFontDatabase::setFontOptions(m_options);
+    if (tabletAbsoluteRange >= 0)
+        QWindowsContext::setTabletAbsoluteRange(tabletAbsoluteRange);
+
+    QCoreApplication::setAttribute(Qt::AA_CompressHighFrequencyEvents);
+    QWindowSystemInterfacePrivate::TabletEvent::setPlatformSynthesizesMouse(false);
+
+    if (!dpiAwarenessSet) { // Set only once in case of repeated instantiations of QGuiApplication.
+        if (!QCoreApplication::testAttribute(Qt::AA_PluginApplication)) {
+            m_context.setProcessDpiAwareness(dpiAwareness);
+            qCDebug(lcQpaWindow) << "DpiAwareness=" << dpiAwareness
+                << "effective process DPI awareness=" << QWindowsContext::processDpiAwareness();
+        }
+        dpiAwarenessSet = true;
+    }
+
+    m_context.initTouch(m_options);
+    QPlatformCursor::setCapability(QPlatformCursor::OverrideCursor);
+
+    m_context.initPowerNotificationHandler();
+}
+
+QWindowsIntegrationPrivate::~QWindowsIntegrationPrivate()
+{
+    delete m_fontDatabase;
+}
+
+QWindowsIntegration *QWindowsIntegration::m_instance = nullptr;
+
+QWindowsIntegration::QWindowsIntegration(const QStringList &paramList) :
+    d(new QWindowsIntegrationPrivate)
+{
+    m_instance = this;
+    d->parseOptions(this, paramList);
+#if QT_CONFIG(clipboard)
+    d->m_clipboard.registerViewer();
+#endif
+    d->m_context.screenManager().initialize();
+    d->m_context.setDetectAltGrModifier((d->m_options & DetectAltGrModifier) != 0);
+}
+
+QWindowsIntegration::~QWindowsIntegration()
+{
+    m_instance = nullptr;
+}
+
+void QWindowsIntegration::initialize()
+{
+    auto icStrs = QPlatformInputContextFactory::requested();
+    icStrs.isEmpty() ? d->m_inputContext.reset(new QWindowsInputContext)
+                     : d->m_inputContext.reset(QPlatformInputContextFactory::create(icStrs));
+}
+
+bool QWindowsIntegration::hasCapability(QPlatformIntegration::Capability cap) const
+{
+    switch (cap) {
+    case ThreadedPixmaps:
+        return true;
+#ifndef QT_NO_OPENGL
+    case OpenGL:
+        return true;
+    case ThreadedOpenGL:
+        if (const QWindowsStaticOpenGLContext *glContext = QWindowsIntegration::staticOpenGLContext())
+            return glContext->supportsThreadedOpenGL();
+        return false;
+#endif // !QT_NO_OPENGL
+    case WindowMasks:
+        return true;
+    case MultipleWindows:
+        return true;
+    case ForeignWindows:
+        return true;
+    case RasterGLSurface:
+        return true;
+    case AllGLFunctionsQueryable:
+        return true;
+    case SwitchableWidgetComposition:
+        return false; // QTBUG-68329 QTBUG-53515 QTBUG-54734
+    case BackingStoreStaticContents:
+        return true;
+    default:
+        return QPlatformIntegration::hasCapability(cap);
+    }
+    return false;
+}
+
+QPlatformWindow *QWindowsIntegration::createPlatformWindow(QWindow *window) const
+{
+    if (window->type() == Qt::Desktop) {
+        auto *result = new QWindowsDesktopWindow(window);
+        qCDebug(lcQpaWindow) << "Desktop window:" << window
+            << Qt::showbase << Qt::hex << result->winId() << Qt::noshowbase << Qt::dec << result->geometry();
+        return result;
+    }
+
+    QWindowsWindowData requested;
+    requested.flags = window->flags();
+    requested.geometry = window->isTopLevel()
+        ? QHighDpi::toNativePixels(window->geometry(), window)
+        : QHighDpi::toNativeLocalPosition(window->geometry(), window);
+    if (!(requested.flags & Qt::FramelessWindowHint)) {
+        // Apply custom margins (see  QWindowsWindow::setCustomMargins())).
+        const QVariant customMarginsV = window->property("_q_windowsCustomMargins");
+        if (customMarginsV.isValid())
+            requested.customMargins = qvariant_cast<QMargins>(customMarginsV);
+    }
+
+    QWindowsWindowData obtained =
+        QWindowsWindowData::create(window, requested,
+                                   QWindowsWindow::formatWindowTitle(window->title()));
+    qCDebug(lcQpaWindow).nospace()
+        << __FUNCTION__ << ' ' << window
+        << "\n    Requested: " << requested.geometry << " frame incl.="
+        << QWindowsGeometryHint::positionIncludesFrame(window)
+        << ' ' << requested.flags
+        << "\n    Obtained : " << obtained.geometry << " margins=" << obtained.fullFrameMargins
+        << " handle=" << obtained.hwnd << ' ' << obtained.flags << '\n';
+
+    if (Q_UNLIKELY(!obtained.hwnd))
+        return nullptr;
+
+    QWindowsWindow *result = createPlatformWindowHelper(window, obtained);
+    Q_ASSERT(result);
+
+    if (window->isTopLevel() && !QWindowsContext::shouldHaveNonClientDpiScaling(window))
+        result->setFlag(QWindowsWindow::DisableNonClientScaling);
+
+    if (QWindowsMenuBar *menuBarToBeInstalled = QWindowsMenuBar::menuBarOf(window))
+        menuBarToBeInstalled->install(result);
+
+    return result;
+}
+
+QPlatformWindow *QWindowsIntegration::createForeignWindow(QWindow *window, WId nativeHandle) const
+{
+    const HWND hwnd = reinterpret_cast<HWND>(nativeHandle);
+    if (!IsWindow(hwnd)) {
+       qWarning("Windows QPA: Invalid foreign window ID %p.", hwnd);
+       return nullptr;
+    }
+    auto *result = new QWindowsForeignWindow(window, hwnd);
+    const QRect obtainedGeometry = result->geometry();
+    QScreen *screen = nullptr;
+    if (const QPlatformScreen *pScreen = result->screenForGeometry(obtainedGeometry))
+        screen = pScreen->screen();
+    if (screen && screen != window->screen())
+        window->setScreen(screen);
+    qCDebug(lcQpaWindow) << "Foreign window:" << window << Qt::showbase << Qt::hex
+        << result->winId() << Qt::noshowbase << Qt::dec << obtainedGeometry << screen;
+    return result;
+}
+
+// Overridden to return a QWindowsDirect2DWindow in Direct2D plugin.
+QWindowsWindow *QWindowsIntegration::createPlatformWindowHelper(QWindow *window, const QWindowsWindowData &data) const
+{
+    return new QWindowsWindow(window, data);
+}
+
+#ifndef QT_NO_OPENGL
+
+QWindowsStaticOpenGLContext *QWindowsStaticOpenGLContext::doCreate()
+{
+#if defined(QT_OPENGL_DYNAMIC)
+    QWindowsOpenGLTester::Renderer requestedRenderer = QWindowsOpenGLTester::requestedRenderer();
+    switch (requestedRenderer) {
+    case QWindowsOpenGLTester::DesktopGl:
+        if (QWindowsStaticOpenGLContext *glCtx = QOpenGLStaticContext::create()) {
+            if ((QWindowsOpenGLTester::supportedRenderers(requestedRenderer) & QWindowsOpenGLTester::DisableRotationFlag)
+                && !QWindowsScreen::setOrientationPreference(Qt::LandscapeOrientation)) {
+                qCWarning(lcQpaGl, "Unable to disable rotation.");
+            }
+            return glCtx;
+        }
+        qCWarning(lcQpaGl, "System OpenGL failed. Falling back to Software OpenGL.");
+        return QOpenGLStaticContext::create(true);
+    case QWindowsOpenGLTester::SoftwareRasterizer:
+        if (QWindowsStaticOpenGLContext *swCtx = QOpenGLStaticContext::create(true))
+            return swCtx;
+        qCWarning(lcQpaGl, "Software OpenGL failed. Falling back to system OpenGL.");
+        if (QWindowsOpenGLTester::supportedRenderers(requestedRenderer) & QWindowsOpenGLTester::DesktopGl)
+            return QOpenGLStaticContext::create();
+        return nullptr;
+    default:
+        break;
+    }
+
+    const QWindowsOpenGLTester::Renderers supportedRenderers = QWindowsOpenGLTester::supportedRenderers(requestedRenderer);
+    if (supportedRenderers.testFlag(QWindowsOpenGLTester::DisableProgramCacheFlag)
+        && !QCoreApplication::testAttribute(Qt::AA_DisableShaderDiskCache)) {
+        QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache);
+    }
+    if (supportedRenderers & QWindowsOpenGLTester::DesktopGl) {
+        if (QWindowsStaticOpenGLContext *glCtx = QOpenGLStaticContext::create()) {
+            if ((supportedRenderers & QWindowsOpenGLTester::DisableRotationFlag)
+                && !QWindowsScreen::setOrientationPreference(Qt::LandscapeOrientation)) {
+                qCWarning(lcQpaGl, "Unable to disable rotation.");
+            }
+            return glCtx;
+        }
+    }
+    return QOpenGLStaticContext::create(true);
+#else
+    return QOpenGLStaticContext::create();
+#endif
+}
+
+QWindowsStaticOpenGLContext *QWindowsStaticOpenGLContext::create()
+{
+    return QWindowsStaticOpenGLContext::doCreate();
+}
+
+QPlatformOpenGLContext *QWindowsIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
+{
+    qCDebug(lcQpaGl) << __FUNCTION__ << context->format();
+    if (QWindowsStaticOpenGLContext *staticOpenGLContext = QWindowsIntegration::staticOpenGLContext()) {
+        std::unique_ptr<QWindowsOpenGLContext> result(staticOpenGLContext->createContext(context));
+        if (result->isValid())
+            return result.release();
+    }
+    return nullptr;
+}
+
+QOpenGLContext::OpenGLModuleType QWindowsIntegration::openGLModuleType()
+{
+#if !defined(QT_OPENGL_DYNAMIC)
+    return QOpenGLContext::LibGL;
+#else
+    if (const QWindowsStaticOpenGLContext *staticOpenGLContext = QWindowsIntegration::staticOpenGLContext())
+        return staticOpenGLContext->moduleType();
+    return QOpenGLContext::LibGL;
+#endif
+}
+
+HMODULE QWindowsIntegration::openGLModuleHandle() const
+{
+    if (QWindowsStaticOpenGLContext *staticOpenGLContext = QWindowsIntegration::staticOpenGLContext())
+        return static_cast<HMODULE>(staticOpenGLContext->moduleHandle());
+
+    return nullptr;
+}
+
+QOpenGLContext *QWindowsIntegration::createOpenGLContext(HGLRC ctx, HWND window, QOpenGLContext *shareContext) const
+{
+    if (!ctx || !window)
+        return nullptr;
+
+    if (QWindowsStaticOpenGLContext *staticOpenGLContext = QWindowsIntegration::staticOpenGLContext()) {
+        std::unique_ptr<QWindowsOpenGLContext> result(staticOpenGLContext->createContext(ctx, window));
+        if (result->isValid()) {
+            auto *context = new QOpenGLContext;
+            context->setShareContext(shareContext);
+            auto *contextPrivate = QOpenGLContextPrivate::get(context);
+            contextPrivate->adopt(result.release());
+            return context;
+        }
+    }
+
+    return nullptr;
+}
+
+QWindowsStaticOpenGLContext *QWindowsIntegration::staticOpenGLContext()
+{
+    QWindowsIntegration *integration = QWindowsIntegration::instance();
+    if (!integration)
+        return nullptr;
+    QWindowsIntegrationPrivate *d = integration->d.data();
+    QMutexLocker lock(&d->m_staticContextLock);
+    if (d->m_staticOpenGLContext.isNull())
+        d->m_staticOpenGLContext.reset(QWindowsStaticOpenGLContext::create());
+    return d->m_staticOpenGLContext.data();
+}
+#endif // !QT_NO_OPENGL
+
+QPlatformFontDatabase *QWindowsIntegration::fontDatabase() const
+{
+    if (!d->m_fontDatabase) {
+#ifndef QT_NO_FREETYPE
+        if (d->m_options & QWindowsIntegration::FontDatabaseFreeType)
+            d->m_fontDatabase = new QWindowsFontDatabaseFT;
+        else
+#endif // QT_NO_FREETYPE
+#if QT_CONFIG(directwrite3)
+        if (!(d->m_options & (QWindowsIntegration::FontDatabaseGDI | QWindowsIntegration::DontUseDirectWriteFonts)))
+            d->m_fontDatabase = new QWindowsDirectWriteFontDatabase;
+        else
+#endif
+            d->m_fontDatabase = new QWindowsFontDatabase;
+    }
+    return d->m_fontDatabase;
+}
+
+#ifdef SPI_GETKEYBOARDSPEED
+static inline int keyBoardAutoRepeatRateMS()
+{
+  DWORD time = 0;
+  if (SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &time, 0))
+      return time ? 1000 / static_cast<int>(time) : 500;
+  return 30;
+}
+#endif
+
+QVariant QWindowsIntegration::styleHint(QPlatformIntegration::StyleHint hint) const
+{
+    switch (hint) {
+    case QPlatformIntegration::CursorFlashTime:
+        if (const unsigned timeMS = GetCaretBlinkTime())
+            return QVariant(timeMS != INFINITE ? int(timeMS) * 2 : 0);
+        break;
+#ifdef SPI_GETKEYBOARDSPEED
+    case KeyboardAutoRepeatRate:
+        return QVariant(keyBoardAutoRepeatRateMS());
+#endif
+    case QPlatformIntegration::ShowIsMaximized:
+    case QPlatformIntegration::StartDragTime:
+    case QPlatformIntegration::StartDragDistance:
+    case QPlatformIntegration::KeyboardInputInterval:
+    case QPlatformIntegration::ShowIsFullScreen:
+    case QPlatformIntegration::PasswordMaskDelay:
+    case QPlatformIntegration::StartDragVelocity:
+        break; // Not implemented
+    case QPlatformIntegration::FontSmoothingGamma:
+        return QVariant(QWindowsFontDatabase::fontSmoothingGamma());
+    case QPlatformIntegration::MouseDoubleClickInterval:
+        if (const UINT ms = GetDoubleClickTime())
+            return QVariant(int(ms));
+        break;
+    case QPlatformIntegration::UseRtlExtensions:
+        return QVariant(d->m_context.useRTLExtensions());
+    default:
+        break;
+    }
+    return QPlatformIntegration::styleHint(hint);
+}
+
+QPlatformKeyMapper *QWindowsIntegration::keyMapper() const
+{
+    return d->m_context.keyMapper();
+}
+
+#if QT_CONFIG(clipboard)
+QPlatformClipboard * QWindowsIntegration::clipboard() const
+{
+    return &d->m_clipboard;
+}
+#  if QT_CONFIG(draganddrop)
+QPlatformDrag *QWindowsIntegration::drag() const
+{
+    return &d->m_drag;
+}
+#  endif // QT_CONFIG(draganddrop)
+#endif // !QT_NO_CLIPBOARD
+
+QPlatformInputContext * QWindowsIntegration::inputContext() const
+{
+    return d->m_inputContext.data();
+}
+
+#if QT_CONFIG(accessibility)
+QPlatformAccessibility *QWindowsIntegration::accessibility() const
+{
+    return &d->m_accessibility;
+}
+#endif
+
+unsigned QWindowsIntegration::options() const
+{
+    return d->m_options;
+}
+
+#if QT_CONFIG(sessionmanager)
+QPlatformSessionManager *QWindowsIntegration::createPlatformSessionManager(const QString &id, const QString &key) const
+{
+    return new QWindowsSessionManager(id, key);
+}
+#endif
+
+QAbstractEventDispatcher * QWindowsIntegration::createEventDispatcher() const
+{
+    return new QWindowsGuiEventDispatcher;
+}
+
+QStringList QWindowsIntegration::themeNames() const
+{
+    return QStringList(QLatin1StringView(QWindowsTheme::name));
+}
+
+QPlatformTheme *QWindowsIntegration::createPlatformTheme(const QString &name) const
+{
+    if (name == QLatin1StringView(QWindowsTheme::name))
+        return new QWindowsTheme;
+    return QPlatformIntegration::createPlatformTheme(name);
+}
+
+QPlatformServices *QWindowsIntegration::services() const
+{
+    return &d->m_services;
+}
+
+void QWindowsIntegration::beep() const
+{
+    MessageBeep(MB_OK);  // For QApplication
+}
+
+void QWindowsIntegration::setApplicationBadge(qint64 number)
+{
+    // Clamp to positive numbers, as the Windows API doesn't support negative numbers
+    number = qMax(0, number);
+
+    // Persist, so we can re-apply it on setting changes and Explorer restart
+    m_applicationBadgeNumber = number;
+
+    static const bool isWindows11 = QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows11;
+
+#if QT_CONFIG(cpp_winrt)
+    // We prefer the native BadgeUpdater API, that allows us to set a number directly,
+    // but it requires that the application has a package identity, and also doesn't
+    // seem to work in all cases on < Windows 11.
+    QT_TRY {
+        if (isWindows11 && qt_win_hasPackageIdentity()) {
+            using namespace winrt::Windows::UI::Notifications;
+            auto badgeXml = BadgeUpdateManager::GetTemplateContent(BadgeTemplateType::BadgeNumber);
+            badgeXml.SelectSingleNode(L"//badge/@value").NodeValue(winrt::box_value(winrt::to_hstring(number)));
+            BadgeUpdateManager::CreateBadgeUpdaterForApplication().Update(BadgeNotification(badgeXml));
+            return;
+        }
+    } QT_CATCH(...) {
+        // fall back to win32 implementation
+    }
+#endif
+
+    // Fallback for non-packaged apps, Windows 10, or Qt builds without WinRT/C++ support
+
+    if (!number) {
+        // Clear badge
+        setApplicationBadge(QImage());
+        return;
+    }
+
+    const bool isDarkMode = QWindowsTheme::instance()->colorScheme()
+                         == Qt::ColorScheme::Dark;
+
+    QColor badgeColor;
+    QColor textColor;
+
+#if QT_CONFIG(cpp_winrt)
+    if (isWindows11) {
+        // Match colors used by BadgeUpdater
+        static const auto fromUIColor = [](winrt::Windows::UI::Color &&color) {
+            return QColor(color.R, color.G, color.B, color.A);
+        };
+        using namespace winrt::Windows::UI::ViewManagement;
+        const auto settings = UISettings();
+        badgeColor = fromUIColor(settings.GetColorValue(isDarkMode ?
+            UIColorType::AccentLight2 : UIColorType::Accent));
+        textColor = fromUIColor(settings.GetColorValue(UIColorType::Background));
+    }
+#endif
+
+    if (!badgeColor.isValid()) {
+        // Fall back to basic badge colors, based on Windows 10 look
+        badgeColor = isDarkMode ? Qt::black : QColor(220, 220, 220);
+        badgeColor.setAlphaF(0.5f);
+        textColor = isDarkMode ? Qt::white : Qt::black;
+    }
+
+    const auto devicePixelRatio = qApp->devicePixelRatio();
+
+    static const QSize iconBaseSize(16, 16);
+    QImage image(iconBaseSize * devicePixelRatio,
+        QImage::Format_ARGB32_Premultiplied);
+    image.fill(Qt::transparent);
+
+    QPainter painter(&image);
+
+    QRect badgeRect = image.rect();
+    QPen badgeBorderPen = Qt::NoPen;
+    if (!isWindows11) {
+        QColor badgeBorderColor = textColor;
+        badgeBorderColor.setAlphaF(0.5f);
+        badgeBorderPen = badgeBorderColor;
+        badgeRect.adjust(1, 1, -1, -1);
+    }
+    painter.setBrush(badgeColor);
+    painter.setPen(badgeBorderPen);
+    painter.setRenderHint(QPainter::Antialiasing);
+    painter.drawEllipse(badgeRect);
+
+    auto pixelSize = qCeil(10.5 * devicePixelRatio);
+    // Unlike the BadgeUpdater API we're limited by a square
+    // badge, so adjust the font size when above two digits.
+    const bool textOverflow = number > 99;
+    if (textOverflow)
+        pixelSize *= 0.8;
+
+    QFont font = painter.font();
+    font.setPixelSize(pixelSize);
+    font.setWeight(isWindows11 ? QFont::Medium : QFont::DemiBold);
+    painter.setFont(font);
+
+    painter.setRenderHint(QPainter::TextAntialiasing, devicePixelRatio > 1);
+    painter.setPen(textColor);
+
+    auto text = textOverflow ? u"99+"_s : QString::number(number);
+    painter.translate(textOverflow ? 1 : 0, textOverflow ? 0 : -1);
+    painter.drawText(image.rect(), Qt::AlignCenter, text);
+
+    painter.end();
+
+    setApplicationBadge(image);
+}
+
+void QWindowsIntegration::setApplicationBadge(const QImage &image)
+{
+    QComHelper comHelper;
+
+    using Microsoft::WRL::ComPtr;
+
+    ComPtr<ITaskbarList3> taskbarList;
+    CoCreateInstance(CLSID_TaskbarList, nullptr,
+        CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&taskbarList));
+    if (!taskbarList) {
+        // There may not be any windows with a task bar button yet,
+        // in which case we'll apply the badge once a window with
+        // a button has been created.
+        return;
+    }
+
+    const auto hIcon = image.toHICON();
+
+    // Apply the icon to all top level windows, since the badge is
+    // set on an application level. If one of the windows go away
+    // the other windows will take over in showing the badge.
+    const auto topLevelWindows = QGuiApplication::topLevelWindows();
+    for (auto *topLevelWindow : topLevelWindows) {
+        if (!topLevelWindow->handle())
+            continue;
+        auto hwnd = reinterpret_cast<HWND>(topLevelWindow->winId());
+        taskbarList->SetOverlayIcon(hwnd, hIcon, L"");
+    }
+
+    DestroyIcon(hIcon);
+
+    // FIXME: Update icon when the application scale factor changes.
+    // Doing so in response to screen DPI changes is too soon, as the
+    // task bar is not yet ready for an updated icon, and will just
+    // result in a blurred icon even if our icon is high-DPI.
+}
+
+void QWindowsIntegration::updateApplicationBadge()
+{
+    // The system color settings have changed, or we are reacting
+    // to a task bar button being created for the fist time or after
+    // Explorer had crashed and re-started. In any case, re-apply the
+    // badge so that everything is up to date.
+    if (m_applicationBadgeNumber)
+        setApplicationBadge(m_applicationBadgeNumber);
+}
+
+#if QT_CONFIG(vulkan)
+QPlatformVulkanInstance *QWindowsIntegration::createPlatformVulkanInstance(QVulkanInstance *instance) const
+{
+    return new QWindowsVulkanInstance(instance);
+}
+#endif
+
+QT_END_NAMESPACE

qtbase/src/widgets/styles/qwindowsstyle.cpp

@@ -59,7 +59,9 @@
 
 #include <algorithm>
 
+#if defined(Q_OS_WIN)
 #include "../../plugins/platforms/windows/vxkex.h"
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -256,8 +258,10 @@ void QWindowsStyle::polish(QPalette &pal)
     QCommonStyle::polish(pal);
 }
 
+#if defined(Q_OS_WIN)
 typedef BOOL (WINAPI *GetSystemMetricsForDpiFunc)(int, UINT);
 typedef BOOL (WINAPI *SystemParametersInfoForDpiFunc)(UINT, UINT, PVOID, UINT, UINT);
+#endif
 
 int QWindowsStylePrivate::pixelMetricFromSystemDp(QStyle::PixelMetric pm, const QStyleOption *, const QWidget *widget)
 {