v6.8.1

Fix build for non-windows

.editorconfig

@@ -0,0 +1,11 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+charset = utf-8
+indent_style = space
+indent_size = 4

.gitattributes

@@ -0,0 +1 @@
+* text=auto

README.md

@@ -1,11 +1,21 @@
-This is Qt 6.7.2 backport that runs on Windows 7 (what?). The repository contains patched source files from the qtbase module. 
-Approach is based on 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 better: many improvements amongst important fallbacks to default Qt 6 behaviour when running on newer Windows.
+This repository provides a backport of the Qt 6.8.2 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.
 
-You can use [our prebuild binaries](https://github.com/crystalidea/qt6windows7/releases) (we used Visual C++ 2019 with OpenSSL 3.0.13 statically linked, see [compile_win.pl](https://github.com/crystalidea/qt-build-tools/tree/master/6.6.2) script) or compile Qt yourself using compiler and build options you need.
+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.
 
-**Qt 6.7.2 designer running on Windows 7**:
+You can compile it yourself using your preferred compiler and build options or can use our [compile_win.pl](https://github.com/crystalidea/qt-build-tools/tree/master/6.8.1) build script, which utilizes Visual C++ 2022 and includes OpenSSL 3.0.13 statically linked. Alternatively, you can download our [prebuild Qt dlls](https://github.com/crystalidea/qt6windows7/releases), which also include the Qt Designer binary for demonstration purposes.
 
-![image](https://github.com/crystalidea/qt6windows7/assets/2600624/41f4291a-082a-41e8-a09d-c3b9e7f36e9e)
+**Qt 6.8.2 designer running on Windows 7**:
+
+![Qt Designer](designer.png)
+
+**Other modules**:
+
+Many of other Qt 6 modules are known to work fine on Windows 7 without modifications when compiled with patched qtbase. Verified modules:
+
+- qt5compat
+- qtimageformats
+- qttools
+- ... please let me know which work and which don't !
 
 ### Known issues:
 
@@ -13,6 +23,9 @@ You can use [our prebuild binaries](https://github.com/crystalidea/qt6windows7/r
 
 ### Older versions:
 
+- [Qt 6.8.1](https://github.com/crystalidea/qt6windows7/releases/tag/v6.8.1)
+- [Qt 6.8.0](https://github.com/crystalidea/qt6windows7/releases/tag/v6.8.0)
+- [Qt 6.7.2](https://github.com/crystalidea/qt6windows7/releases/tag/v6.7.2)
 - [Qt 6.6.3](https://github.com/crystalidea/qt6windows7/releases/tag/v6.6.3)
 - [Qt 6.6.2](https://github.com/crystalidea/qt6windows7/releases/tag/v6.6.2)
 - [Qt 6.6.1](https://github.com/crystalidea/qt6windows7/releases/tag/v6.6.1)

qtbase/src/corelib/io/qstandardpaths_win.cpp

@@ -12,7 +12,7 @@
 
 #include <qt_windows.h>
 #include <shlobj.h>
-#include <VersionHelpers.h>
+#include <versionhelpers.h>
 #include <intshcut.h>
 #include <qvarlengtharray.h>
 

qtbase/src/corelib/kernel/qfunctions_win.cpp

@@ -28,6 +28,7 @@ QComHelper::QComHelper(COINIT concurrencyModel)
 
 QComHelper::~QComHelper()
 {
+    Q_ASSERT(m_threadId == GetCurrentThreadId());
     if (SUCCEEDED(m_initResult))
         CoUninitialize();
 }

qtbase/src/corelib/thread/qmutex.cpp

@@ -637,6 +637,7 @@ void QRecursiveMutex::unlock() noexcept
 /*!
     \internal helper for lock()
  */
+Q_NEVER_INLINE
 void QBasicMutex::lockInternal() QT_MUTEX_LOCK_NOEXCEPT
 {
     if (futexAvailable()) {
@@ -670,6 +671,7 @@ bool QBasicMutex::lockInternal(int timeout) QT_MUTEX_LOCK_NOEXCEPT
 /*!
     \internal helper for tryLock(QDeadlineTimer)
  */
+Q_NEVER_INLINE
 bool QBasicMutex::lockInternal(QDeadlineTimer deadlineTimer) QT_MUTEX_LOCK_NOEXCEPT
 {
     if (deadlineTimer.hasExpired())
@@ -809,6 +811,7 @@ bool QBasicMutex::lockInternal(QDeadlineTimer deadlineTimer) QT_MUTEX_LOCK_NOEXC
 /*!
     \internal
 */
+Q_NEVER_INLINE
 void QBasicMutex::unlockInternal() noexcept
 {
     QMutexPrivate *copy = d_ptr.loadAcquire();

qtbase/src/corelib/thread/qthread_win.cpp

@@ -0,0 +1,658 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qthread.h"
+#include "qthread_p.h"
+#include "qthreadstorage.h"
+#include "qmutex.h"
+
+#include <qcoreapplication.h>
+#include <qpointer.h>
+
+#include <private/qcoreapplication_p.h>
+#include <private/qeventdispatcher_win_p.h>
+#include "qloggingcategory.h"
+
+#include <qt_windows.h>
+
+#ifndef _MT
+#  define _MT
+#endif // _MT
+#include <process.h>
+
+extern "C" {
+// MinGW is missing the declaration of SetThreadDescription:
+WINBASEAPI
+HRESULT
+WINAPI
+SetThreadDescription(
+    _In_ HANDLE hThread,
+    _In_ PCWSTR lpThreadDescription
+    );
+}
+
+QT_BEGIN_NAMESPACE
+
+#if QT_CONFIG(thread)
+
+void qt_watch_adopted_thread(const HANDLE adoptedThreadHandle, QThread *qthread);
+DWORD WINAPI qt_adopted_thread_watcher_function(LPVOID);
+
+static DWORD qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES;
+void qt_create_tls()
+{
+    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES)
+        return;
+    Q_CONSTINIT static QBasicMutex mutex;
+    QMutexLocker locker(&mutex);
+    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES)
+        return;
+    qt_current_thread_data_tls_index = TlsAlloc();
+}
+
+static void qt_free_tls()
+{
+    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES) {
+        TlsFree(qt_current_thread_data_tls_index);
+        qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES;
+    }
+}
+Q_DESTRUCTOR_FUNCTION(qt_free_tls)
+
+/*
+    QThreadData
+*/
+void QThreadData::clearCurrentThreadData()
+{
+    TlsSetValue(qt_current_thread_data_tls_index, 0);
+}
+
+QThreadData *QThreadData::current(bool createIfNecessary)
+{
+    qt_create_tls();
+    QThreadData *threadData = reinterpret_cast<QThreadData *>(TlsGetValue(qt_current_thread_data_tls_index));
+    if (!threadData && createIfNecessary) {
+        threadData = new QThreadData;
+        // This needs to be called prior to new AdoptedThread() to
+        // avoid recursion.
+        TlsSetValue(qt_current_thread_data_tls_index, threadData);
+        QT_TRY {
+            threadData->thread.storeRelease(new QAdoptedThread(threadData));
+        } QT_CATCH(...) {
+            TlsSetValue(qt_current_thread_data_tls_index, 0);
+            threadData->deref();
+            threadData = 0;
+            QT_RETHROW;
+        }
+        threadData->deref();
+        threadData->isAdopted = true;
+        threadData->threadId.storeRelaxed(reinterpret_cast<Qt::HANDLE>(quintptr(GetCurrentThreadId())));
+
+        if (!QCoreApplicationPrivate::theMainThreadId) {
+            auto *mainThread = threadData->thread.loadRelaxed();
+            mainThread->setObjectName("Qt mainThread");
+            QCoreApplicationPrivate::theMainThread.storeRelease(mainThread);
+            QCoreApplicationPrivate::theMainThreadId.storeRelaxed(threadData->threadId.loadRelaxed());
+        } else {
+            HANDLE realHandle = INVALID_HANDLE_VALUE;
+            DuplicateHandle(GetCurrentProcess(),
+                    GetCurrentThread(),
+                    GetCurrentProcess(),
+                    &realHandle,
+                    0,
+                    FALSE,
+                    DUPLICATE_SAME_ACCESS);
+            qt_watch_adopted_thread(realHandle, threadData->thread.loadRelaxed());
+        }
+    }
+    return threadData;
+}
+
+void QAdoptedThread::init()
+{
+    d_func()->handle = GetCurrentThread();
+    d_func()->id = GetCurrentThreadId();
+}
+
+static QList<HANDLE> qt_adopted_thread_handles;
+static QList<QThread *> qt_adopted_qthreads;
+Q_CONSTINIT static QBasicMutex qt_adopted_thread_watcher_mutex;
+static DWORD qt_adopted_thread_watcher_id = 0;
+static HANDLE qt_adopted_thread_wakeup = 0;
+
+/*!
+    \internal
+    Adds an adopted thread to the list of threads that Qt watches to make sure
+    the thread data is properly cleaned up. This function starts the watcher
+    thread if necessary.
+*/
+void qt_watch_adopted_thread(const HANDLE adoptedThreadHandle, QThread *qthread)
+{
+    QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
+
+    if (GetCurrentThreadId() == qt_adopted_thread_watcher_id) {
+        CloseHandle(adoptedThreadHandle);
+        return;
+    }
+
+    qt_adopted_thread_handles.append(adoptedThreadHandle);
+    qt_adopted_qthreads.append(qthread);
+
+    // Start watcher thread if it is not already running.
+    if (qt_adopted_thread_watcher_id == 0) {
+        if (qt_adopted_thread_wakeup == 0) {
+            qt_adopted_thread_wakeup = CreateEvent(0, false, false, 0);
+            qt_adopted_thread_handles.prepend(qt_adopted_thread_wakeup);
+        }
+
+        CloseHandle(CreateThread(0, 0, qt_adopted_thread_watcher_function, 0, 0, &qt_adopted_thread_watcher_id));
+    } else {
+        SetEvent(qt_adopted_thread_wakeup);
+    }
+}
+
+/*
+    This function loops and waits for native adopted threads to finish.
+    When this happens it derefs the QThreadData for the adopted thread
+    to make sure it gets cleaned up properly.
+*/
+DWORD WINAPI qt_adopted_thread_watcher_function(LPVOID)
+{
+    forever {
+        qt_adopted_thread_watcher_mutex.lock();
+
+        if (qt_adopted_thread_handles.count() == 1) {
+            qt_adopted_thread_watcher_id = 0;
+            qt_adopted_thread_watcher_mutex.unlock();
+            break;
+        }
+
+        QList<HANDLE> handlesCopy = qt_adopted_thread_handles;
+        qt_adopted_thread_watcher_mutex.unlock();
+
+        DWORD ret = WAIT_TIMEOUT;
+        int count;
+        int offset;
+        int loops = handlesCopy.size() / MAXIMUM_WAIT_OBJECTS;
+        if (handlesCopy.size() % MAXIMUM_WAIT_OBJECTS)
+            ++loops;
+        if (loops == 1) {
+            // no need to loop, no timeout
+            offset = 0;
+            count = handlesCopy.count();
+            ret = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, INFINITE);
+        } else {
+            int loop = 0;
+            do {
+                offset = loop * MAXIMUM_WAIT_OBJECTS;
+                count = qMin(handlesCopy.count() - offset, MAXIMUM_WAIT_OBJECTS);
+                ret = WaitForMultipleObjects(count, handlesCopy.constData() + offset, false, 100);
+                loop = (loop + 1) % loops;
+            } while (ret == WAIT_TIMEOUT);
+        }
+
+        if (ret == WAIT_FAILED || ret >= WAIT_OBJECT_0 + uint(count)) {
+            qWarning("QThread internal error while waiting for adopted threads: %d", int(GetLastError()));
+            continue;
+        }
+
+        const int handleIndex = offset + ret - WAIT_OBJECT_0;
+        if (handleIndex == 0) // New handle to watch was added.
+            continue;
+        const int qthreadIndex = handleIndex - 1;
+
+        qt_adopted_thread_watcher_mutex.lock();
+        QThreadData *data = QThreadData::get2(qt_adopted_qthreads.at(qthreadIndex));
+        qt_adopted_thread_watcher_mutex.unlock();
+        if (data->isAdopted) {
+            QThread *thread = data->thread;
+            Q_ASSERT(thread);
+            auto thread_p = static_cast<QThreadPrivate *>(QObjectPrivate::get(thread));
+            Q_UNUSED(thread_p);
+            Q_ASSERT(!thread_p->finished);
+            thread_p->finish();
+        }
+        data->deref();
+
+        QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
+        CloseHandle(qt_adopted_thread_handles.at(handleIndex));
+        qt_adopted_thread_handles.remove(handleIndex);
+        qt_adopted_qthreads.remove(qthreadIndex);
+    }
+
+    QThreadData *threadData = reinterpret_cast<QThreadData *>(TlsGetValue(qt_current_thread_data_tls_index));
+    if (threadData)
+        threadData->deref();
+
+    return 0;
+}
+
+#ifndef Q_OS_WIN64
+#  define ULONG_PTR DWORD
+#endif
+
+typedef struct tagTHREADNAME_INFO
+{
+    DWORD dwType;      // must be 0x1000
+    LPCSTR szName;     // pointer to name (in user addr space)
+    HANDLE dwThreadID; // thread ID (-1=caller thread)
+    DWORD dwFlags;     // reserved for future use, must be zero
+} THREADNAME_INFO;
+
+typedef HRESULT(WINAPI* SetThreadDescriptionFunc)(HANDLE, PCWSTR);
+
+#if defined(Q_CC_MSVC)
+
+// Helper function to set the thread name using RaiseException and __try
+static void setThreadNameUsingException(HANDLE threadId, LPCSTR threadName) {
+    THREADNAME_INFO info;
+    info.dwType = 0x1000;
+    info.szName = threadName;
+    info.dwThreadID = threadId;
+    info.dwFlags = 0;
+
+    __try {
+        RaiseException(0x406D1388, 0, sizeof(info) / sizeof(DWORD),
+                       reinterpret_cast<const ULONG_PTR*>(&info));
+    }
+    __except (EXCEPTION_CONTINUE_EXECUTION) {
+    }
+}
+
+#endif // Q_CC_MSVC
+
+void qt_set_thread_name(HANDLE threadId, const QString &name)
+{
+    HMODULE hKernel32 = GetModuleHandleW(L"Kernel32.dll");
+
+    SetThreadDescriptionFunc pSetThreadDescription = 
+        reinterpret_cast<SetThreadDescriptionFunc>(GetProcAddress(hKernel32, "SetThreadDescription"));
+    
+    if (pSetThreadDescription) {
+        pSetThreadDescription(threadId, reinterpret_cast<const wchar_t *>(name.utf16()) );
+    }
+    else {
+
+        #if defined(Q_CC_MSVC)
+
+            std::string stdStr = name.toStdString();
+            LPCSTR threadName = stdStr.c_str();
+            setThreadNameUsingException(threadId, threadName);
+
+        #endif // Q_CC_MSVC
+    }
+}
+
+/**************************************************************************
+ ** QThreadPrivate
+ *************************************************************************/
+
+#endif // QT_CONFIG(thread)
+
+QAbstractEventDispatcher *QThreadPrivate::createEventDispatcher(QThreadData *data)
+{
+    Q_UNUSED(data);
+    return new QEventDispatcherWin32;
+}
+
+#if QT_CONFIG(thread)
+
+unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg) noexcept
+{
+    QThread *thr = reinterpret_cast<QThread *>(arg);
+    QThreadData *data = QThreadData::get2(thr);
+
+    qt_create_tls();
+    TlsSetValue(qt_current_thread_data_tls_index, data);
+    data->threadId.storeRelaxed(reinterpret_cast<Qt::HANDLE>(quintptr(GetCurrentThreadId())));
+
+    QThread::setTerminationEnabled(false);
+
+    {
+        QMutexLocker locker(&thr->d_func()->mutex);
+        data->quitNow = thr->d_func()->exited;
+    }
+
+    data->ensureEventDispatcher();
+    data->eventDispatcher.loadRelaxed()->startingUp();
+
+    // sets the name of the current thread.
+    QString threadName = std::exchange(thr->d_func()->objectName, {});
+    if (Q_LIKELY(threadName.isEmpty()))
+        threadName = QString::fromUtf8(thr->metaObject()->className());
+    qt_set_thread_name(GetCurrentThread(), threadName);
+
+    emit thr->started(QThread::QPrivateSignal());
+    QThread::setTerminationEnabled(true);
+    thr->run();
+
+    thr->d_func()->finish();
+    return 0;
+}
+
+/*
+    For regularly terminating threads, this will be called and executed by the thread as the
+    last code before the thread exits. In that case, \a arg is the current QThread.
+
+    However, this function will also be called by QThread::terminate (as well as wait() and
+    setTerminationEnabled) to give Qt a chance to update the terminated thread's state and
+    process pending DeleteLater events for objects that live in the terminated thread. And for
+    adopted thread, this method is called by the thread watcher.
+
+    In those cases, \a arg will not be the current thread.
+*/
+void QThreadPrivate::finish(bool lockAnyway) noexcept
+{
+    QThreadPrivate *d = this;
+    QThread *thr = q_func();
+
+    QMutexLocker locker(lockAnyway ? &d->mutex : nullptr);
+    d->isInFinish = true;
+    d->priority = QThread::InheritPriority;
+    void **tls_data = reinterpret_cast<void **>(&d->data->tls);
+    if (lockAnyway)
+        locker.unlock();
+    emit thr->finished(QThread::QPrivateSignal());
+    QCoreApplicationPrivate::sendPostedEvents(nullptr, QEvent::DeferredDelete, d->data);
+    QThreadStorageData::finish(tls_data);
+    if (lockAnyway)
+        locker.relock();
+
+    QAbstractEventDispatcher *eventDispatcher = d->data->eventDispatcher.loadRelaxed();
+    if (eventDispatcher) {
+        d->data->eventDispatcher = 0;
+        if (lockAnyway)
+            locker.unlock();
+        eventDispatcher->closingDown();
+        delete eventDispatcher;
+        if (lockAnyway)
+            locker.relock();
+    }
+
+    d->running = false;
+    d->finished = true;
+    d->isInFinish = false;
+    d->interruptionRequested.store(false, std::memory_order_relaxed);
+
+    if (!d->waiters) {
+        CloseHandle(d->handle);
+        d->handle = 0;
+    }
+
+    d->id = 0;
+}
+
+/**************************************************************************
+ ** QThread
+ *************************************************************************/
+
+Qt::HANDLE QThread::currentThreadIdImpl() noexcept
+{
+    return reinterpret_cast<Qt::HANDLE>(quintptr(GetCurrentThreadId()));
+}
+
+int QThread::idealThreadCount() noexcept
+{
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo(&sysinfo);
+    return sysinfo.dwNumberOfProcessors;
+}
+
+void QThread::yieldCurrentThread()
+{
+    SwitchToThread();
+}
+
+#endif // QT_CONFIG(thread)
+
+void QThread::sleep(std::chrono::nanoseconds nsecs)
+{
+    using namespace std::chrono;
+    ::Sleep(DWORD(duration_cast<milliseconds>(nsecs).count()));
+}
+
+void QThread::sleep(unsigned long secs)
+{
+    ::Sleep(secs * 1000);
+}
+
+void QThread::msleep(unsigned long msecs)
+{
+    ::Sleep(msecs);
+}
+
+void QThread::usleep(unsigned long usecs)
+{
+    ::Sleep((usecs / 1000) + 1);
+}
+
+#if QT_CONFIG(thread)
+
+void QThread::start(Priority priority)
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+
+    if (d->isInFinish) {
+        locker.unlock();
+        wait();
+        locker.relock();
+    }
+
+    if (d->running)
+        return;
+
+    // avoid interacting with the binding system
+    d->objectName = d->extraData ? d->extraData->objectName.valueBypassingBindings()
+                                 : QString();
+    d->running = true;
+    d->finished = false;
+    d->exited = false;
+    d->returnCode = 0;
+    d->interruptionRequested.store(false, std::memory_order_relaxed);
+
+    /*
+      NOTE: we create the thread in the suspended state, set the
+      priority and then resume the thread.
+
+      since threads are created with normal priority by default, we
+      could get into a case where a thread (with priority less than
+      NormalPriority) tries to create a new thread (also with priority
+      less than NormalPriority), but the newly created thread preempts
+      its 'parent' and runs at normal priority.
+    */
+#if defined(Q_CC_MSVC) && !defined(_DLL)
+    // MSVC -MT or -MTd build
+    d->handle = (Qt::HANDLE) _beginthreadex(NULL, d->stackSize, QThreadPrivate::start,
+                                            this, CREATE_SUSPENDED, &(d->id));
+#else
+    // MSVC -MD or -MDd or MinGW build
+    d->handle = CreateThread(nullptr, d->stackSize,
+                             reinterpret_cast<LPTHREAD_START_ROUTINE>(QThreadPrivate::start),
+                             this, CREATE_SUSPENDED, reinterpret_cast<LPDWORD>(&d->id));
+#endif
+
+    if (!d->handle) {
+        qErrnoWarning("QThread::start: Failed to create thread");
+        d->running = false;
+        d->finished = true;
+        return;
+    }
+
+    int prio;
+    d->priority = priority;
+    switch (priority) {
+    case IdlePriority:
+        prio = THREAD_PRIORITY_IDLE;
+        break;
+
+    case LowestPriority:
+        prio = THREAD_PRIORITY_LOWEST;
+        break;
+
+    case LowPriority:
+        prio = THREAD_PRIORITY_BELOW_NORMAL;
+        break;
+
+    case NormalPriority:
+        prio = THREAD_PRIORITY_NORMAL;
+        break;
+
+    case HighPriority:
+        prio = THREAD_PRIORITY_ABOVE_NORMAL;
+        break;
+
+    case HighestPriority:
+        prio = THREAD_PRIORITY_HIGHEST;
+        break;
+
+    case TimeCriticalPriority:
+        prio = THREAD_PRIORITY_TIME_CRITICAL;
+        break;
+
+    case InheritPriority:
+    default:
+        prio = GetThreadPriority(GetCurrentThread());
+        break;
+    }
+
+    if (!SetThreadPriority(d->handle, prio)) {
+        qErrnoWarning("QThread::start: Failed to set thread priority");
+    }
+
+    if (ResumeThread(d->handle) == (DWORD) -1) {
+        qErrnoWarning("QThread::start: Failed to resume new thread");
+    }
+}
+
+void QThread::terminate()
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+    if (!d->running)
+        return;
+    if (!d->terminationEnabled) {
+        d->terminatePending = true;
+        return;
+    }
+
+    TerminateThread(d->handle, 0);
+    d->finish(false);
+}
+
+bool QThread::wait(QDeadlineTimer deadline)
+{
+    Q_D(QThread);
+    QMutexLocker locker(&d->mutex);
+
+    if (d->id == GetCurrentThreadId()) {
+        qWarning("QThread::wait: Thread tried to wait on itself");
+        return false;
+    }
+    if (d->finished || !d->running)
+        return true;
+    return d->wait(locker, deadline);
+}
+
+bool QThreadPrivate::wait(QMutexLocker<QMutex> &locker, QDeadlineTimer deadline)
+{
+    Q_ASSERT(locker.isLocked());
+    QThreadPrivate *d = this;
+
+    ++d->waiters;
+    locker.mutex()->unlock();
+
+    bool ret = false;
+    switch (WaitForSingleObject(d->handle, deadline.remainingTime())) {
+    case WAIT_OBJECT_0:
+        ret = true;
+        break;
+    case WAIT_FAILED:
+        qErrnoWarning("QThread::wait: Thread wait failure");
+        break;
+    case WAIT_ABANDONED:
+    case WAIT_TIMEOUT:
+    default:
+        break;
+    }
+
+    locker.mutex()->lock();
+    --d->waiters;
+
+    if (ret && !d->finished) {
+        // thread was terminated by someone else
+
+        d->finish(false);
+    }
+
+    if (d->finished && !d->waiters) {
+        CloseHandle(d->handle);
+        d->handle = 0;
+    }
+
+    return ret;
+}
+
+void QThread::setTerminationEnabled(bool enabled)
+{
+    QThread *thr = currentThread();
+    Q_ASSERT_X(thr != 0, "QThread::setTerminationEnabled()",
+               "Current thread was not started with QThread.");
+    QThreadPrivate *d = thr->d_func();
+    QMutexLocker locker(&d->mutex);
+    d->terminationEnabled = enabled;
+    if (enabled && d->terminatePending) {
+        d->finish(false);
+        locker.unlock(); // don't leave the mutex locked!
+        _endthreadex(0);
+    }
+}
+
+// Caller must hold the mutex
+void QThreadPrivate::setPriority(QThread::Priority threadPriority)
+{
+    // copied from start() with a few modifications:
+
+    int prio;
+    priority = threadPriority;
+    switch (threadPriority) {
+    case QThread::IdlePriority:
+        prio = THREAD_PRIORITY_IDLE;
+        break;
+
+    case QThread::LowestPriority:
+        prio = THREAD_PRIORITY_LOWEST;
+        break;
+
+    case QThread::LowPriority:
+        prio = THREAD_PRIORITY_BELOW_NORMAL;
+        break;
+
+    case QThread::NormalPriority:
+        prio = THREAD_PRIORITY_NORMAL;
+        break;
+
+    case QThread::HighPriority:
+        prio = THREAD_PRIORITY_ABOVE_NORMAL;
+        break;
+
+    case QThread::HighestPriority:
+        prio = THREAD_PRIORITY_HIGHEST;
+        break;
+
+    case QThread::TimeCriticalPriority:
+        prio = THREAD_PRIORITY_TIME_CRITICAL;
+        break;
+
+    default:
+        return;
+    }
+
+    if (!SetThreadPriority(handle, prio)) {
+        qErrnoWarning("QThread::setPriority: Failed to set thread priority");
+    }
+}
+
+#endif // QT_CONFIG(thread)
+
+QT_END_NAMESPACE

qtbase/src/gui/rhi/qrhid3d11.cpp

@@ -10,7 +10,9 @@
 #include <QtCore/private/qsystemerror_p.h>
 #include "qrhid3dhelpers_p.h"
 
-#include <VersionHelpers.h>
+#include <cstdio>
+
+#include <versionhelpers.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -28,7 +30,8 @@ using namespace Qt::StringLiterals;
 
 /*!
     \class QRhiD3D11InitParams
-    \inmodule QtGui
+    \inmodule QtGuiPrivate
+    \inheaderfile rhi/qrhi.h
     \since 6.6
     \brief Direct3D 11 specific initialization parameters.
 
@@ -81,7 +84,8 @@ using namespace Qt::StringLiterals;
 
 /*!
     \class QRhiD3D11NativeHandles
-    \inmodule QtGui
+    \inmodule QtGuiPrivate
+    \inheaderfile rhi/qrhi.h
     \since 6.6
     \brief Holds the D3D device and device context used by the QRhi.
 
@@ -233,9 +237,19 @@ bool QRhiD3D11::create(QRhi::Flags flags)
     // there. (some features are not supported then, however)
     useLegacySwapchainModel = qEnvironmentVariableIntValue("QT_D3D_NO_FLIP");
 
-    qCDebug(QRHI_LOG_INFO, "FLIP_* swapchain supported = true, ALLOW_TEARING supported = %s, use legacy (non-FLIP) model = %s",
+    if (!useLegacySwapchainModel) {
+        if (qEnvironmentVariableIsSet("QT_D3D_MAX_FRAME_LATENCY"))
+            maxFrameLatency = UINT(qMax(0, qEnvironmentVariableIntValue("QT_D3D_MAX_FRAME_LATENCY")));
+    } else {
+        maxFrameLatency = 0;
+    }
+
+    qCDebug(QRHI_LOG_INFO, "FLIP_* swapchain supported = true, ALLOW_TEARING supported = %s, use legacy (non-FLIP) model = %s, max frame latency = %u",
             supportsAllowTearing ? "true" : "false",
-            useLegacySwapchainModel ? "true" : "false");
+            useLegacySwapchainModel ? "true" : "false",
+            maxFrameLatency);
+    if (maxFrameLatency == 0)
+        qCDebug(QRHI_LOG_INFO, "Disabling FRAME_LATENCY_WAITABLE_OBJECT usage");
 
     if (!importedDeviceAndContext) {
         IDXGIAdapter1 *adapter;
@@ -634,6 +648,10 @@ bool QRhiD3D11::isFeatureSupported(QRhi::Feature feature) const
         return true;
     case QRhi::MultiView:
         return false;
+    case QRhi::TextureViewFormat:
+        return false; // because we use fully typed formats for textures and relaxed casting is a D3D12 thing
+    case QRhi::ResolveDepthStencil:
+        return false;
     default:
         Q_UNREACHABLE();
         return false;
@@ -1347,6 +1365,10 @@ QRhi::FrameOpResult QRhiD3D11::beginFrame(QRhiSwapChain *swapChain, QRhi::BeginF
     contextState.currentSwapChain = swapChainD;
     const int currentFrameSlot = swapChainD->currentFrameSlot;
 
+    // if we have a waitable object, now is the time to wait on it
+    if (swapChainD->frameLatencyWaitableObject)
+        WaitForSingleObjectEx(swapChainD->frameLatencyWaitableObject, 1000, true);
+
     swapChainD->cb.resetState();
 
     swapChainD->rt.d.rtv[0] = swapChainD->sampleDesc.Count > 1 ?
@@ -2153,6 +2175,8 @@ void QRhiD3D11::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
             cmd.args.resolveSubRes.srcSubRes = D3D11CalcSubresource(0, UINT(colorAtt.layer()), 1);
             cmd.args.resolveSubRes.format = dstTexD->dxgiFormat;
         }
+        if (rtTex->m_desc.depthResolveTexture())
+            qWarning("Resolving multisample depth-stencil buffers is not supported with D3D");
     }
 
     cbD->recordingPass = QD3D11CommandBuffer::NoPass;
@@ -2872,7 +2896,7 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD)
             break;
         case QD3D11CommandBuffer::Command::Draw:
             if (cmd.args.draw.ps) {
-                if (cmd.args.draw.instanceCount == 1)
+                if (cmd.args.draw.instanceCount == 1 && cmd.args.draw.firstInstance == 0)
                     context->Draw(cmd.args.draw.vertexCount, cmd.args.draw.firstVertex);
                 else
                     context->DrawInstanced(cmd.args.draw.vertexCount, cmd.args.draw.instanceCount,
@@ -2883,7 +2907,7 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD)
             break;
         case QD3D11CommandBuffer::Command::DrawIndexed:
             if (cmd.args.drawIndexed.ps) {
-                if (cmd.args.drawIndexed.instanceCount == 1)
+                if (cmd.args.drawIndexed.instanceCount == 1 && cmd.args.drawIndexed.firstInstance == 0)
                     context->DrawIndexed(cmd.args.drawIndexed.indexCount, cmd.args.drawIndexed.firstIndex,
                                          cmd.args.drawIndexed.vertexOffset);
                 else
@@ -3288,6 +3312,10 @@ bool QD3D11Texture::prepareCreate(QSize *adjustedSize)
     if (tex || tex3D || tex1D)
         destroy();
 
+    QRHI_RES_RHI(QRhiD3D11);
+    if (!rhiD->isTextureFormatSupported(m_format, m_flags))
+        return false;
+
     const bool isDepth = isDepthTextureFormat(m_format);
     const bool isCube = m_flags.testFlag(CubeMap);
     const bool is3D = m_flags.testFlag(ThreeDimensional);
@@ -3298,7 +3326,6 @@ bool QD3D11Texture::prepareCreate(QSize *adjustedSize)
     const QSize size = is1D ? QSize(qMax(1, m_pixelSize.width()), 1)
                             : (m_pixelSize.isEmpty() ? QSize(1, 1) : m_pixelSize);
 
-    QRHI_RES_RHI(QRhiD3D11);
     dxgiFormat = toD3DTextureFormat(m_format, m_flags);
     mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1);
     sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount);
@@ -4250,6 +4277,22 @@ static inline DXGI_FORMAT toD3DAttributeFormat(QRhiVertexInputAttribute::Format
         return DXGI_FORMAT_R16G16_FLOAT;
     case QRhiVertexInputAttribute::Half:
          return DXGI_FORMAT_R16_FLOAT;
+    case QRhiVertexInputAttribute::UShort4:
+    // Note: D3D does not support UShort3.  Pass through UShort3 as UShort4.
+    case QRhiVertexInputAttribute::UShort3:
+        return DXGI_FORMAT_R16G16B16A16_UINT;
+    case QRhiVertexInputAttribute::UShort2:
+        return DXGI_FORMAT_R16G16_UINT;
+    case QRhiVertexInputAttribute::UShort:
+        return DXGI_FORMAT_R16_UINT;
+    case QRhiVertexInputAttribute::SShort4:
+    // Note: D3D does not support SShort3.  Pass through SShort3 as SShort4.
+    case QRhiVertexInputAttribute::SShort3:
+        return DXGI_FORMAT_R16G16B16A16_SINT;
+    case QRhiVertexInputAttribute::SShort2:
+        return DXGI_FORMAT_R16G16_SINT;
+    case QRhiVertexInputAttribute::SShort:
+        return DXGI_FORMAT_R16_SINT;
     default:
         Q_UNREACHABLE();
         return DXGI_FORMAT_R32G32B32A32_FLOAT;
@@ -4672,7 +4715,7 @@ bool QD3D11GraphicsPipeline::create()
             } else {
                 QByteArray sem;
                 sem.resize(16);
-                qsnprintf(sem.data(), sem.size(), "TEXCOORD%d_", it->location() - matrixSlice);
+                std::snprintf(sem.data(), sem.size(), "TEXCOORD%d_", it->location() - matrixSlice);
                 matrixSliceSemantics.append(sem);
                 desc.SemanticName = matrixSliceSemantics.last().constData();
                 desc.SemanticIndex = UINT(matrixSlice);
@@ -4938,6 +4981,11 @@ void QD3D11SwapChain::destroy()
         dcompTarget = nullptr;
     }
 
+    if (frameLatencyWaitableObject) {
+        CloseHandle(frameLatencyWaitableObject);
+        frameLatencyWaitableObject = nullptr;
+    }
+
     QRHI_RES_RHI(QRhiD3D11);
     if (rhiD) {
         rhiD->unregisterResource(this);
@@ -5100,7 +5148,7 @@ bool QD3D11SwapChain::createOrResize()
     if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) {
         if (!rhiD->useLegacySwapchainModel && rhiD->ensureDirectCompositionDevice()) {
             if (!dcompTarget) {
-                hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, true, &dcompTarget);
+                hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, false, &dcompTarget);
                 if (FAILED(hr)) {
                     qWarning("Failed to create Direct Compsition target for the window: %s",
                              qPrintable(QSystemError::windowsComString(hr)));
@@ -5130,6 +5178,17 @@ bool QD3D11SwapChain::createOrResize()
     if (swapInterval == 0 && rhiD->supportsAllowTearing)
         swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
 
+    // maxFrameLatency 0 means no waitable object usage.
+    // Ignore it also when NoVSync is on, and when using WARP.
+    const bool useFrameLatencyWaitableObject = rhiD->maxFrameLatency != 0
+                                               && swapInterval != 0
+                                               && rhiD->driverInfoStruct.deviceType != QRhiDriverInfo::CpuDevice;
+
+    if (useFrameLatencyWaitableObject) {
+        // the flag is not supported in real fullscreen on D3D11, but perhaps that's fine since we only do borderless
+        swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
+    }
+
     if (!swapChain) {
         sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount);
         colorFormat = DEFAULT_FORMAT;
@@ -5215,16 +5274,31 @@ bool QD3D11SwapChain::createOrResize()
 
         if (SUCCEEDED(hr)) {
             swapChain = sc1;
-            if (m_format != SDR) {
-                IDXGISwapChain3 *sc3 = nullptr;
-                if (SUCCEEDED(sc1->QueryInterface(__uuidof(IDXGISwapChain3), reinterpret_cast<void **>(&sc3)))) {
+            IDXGISwapChain3 *sc3 = nullptr;
+            if (SUCCEEDED(sc1->QueryInterface(__uuidof(IDXGISwapChain3), reinterpret_cast<void **>(&sc3)))) {
+                if (m_format != SDR) {
                     hr = sc3->SetColorSpace1(hdrColorSpace);
                     if (FAILED(hr))
                         qWarning("Failed to set color space on swapchain: %s",
-                            qPrintable(QSystemError::windowsComString(hr)));
-                    sc3->Release();
-                } else {
+                                 qPrintable(QSystemError::windowsComString(hr)));
+                }
+                if (useFrameLatencyWaitableObject) {
+                    sc3->SetMaximumFrameLatency(rhiD->maxFrameLatency);
+                    frameLatencyWaitableObject = sc3->GetFrameLatencyWaitableObject();
+                }
+                sc3->Release();
+            } else {
+                if (m_format != SDR)
                     qWarning("IDXGISwapChain3 not available, HDR swapchain will not work as expected");
+                if (useFrameLatencyWaitableObject) {
+                    IDXGISwapChain2 *sc2 = nullptr;
+                    if (SUCCEEDED(sc1->QueryInterface(__uuidof(IDXGISwapChain2), reinterpret_cast<void **>(&sc2)))) {
+                        sc2->SetMaximumFrameLatency(rhiD->maxFrameLatency);
+                        frameLatencyWaitableObject = sc2->GetFrameLatencyWaitableObject();
+                        sc2->Release();
+                    } else { // this cannot really happen since we require DXGIFactory2
+                        qWarning("IDXGISwapChain2 not available, FrameLatencyWaitableObject cannot be used");
+                    }
                 }
             }
             if (dcompVisual) {

qtbase/src/gui/rhi/qrhid3d11_p.h

@@ -626,6 +626,7 @@ struct QD3D11SwapChain : public QRhiSwapChain
     IDCompositionVisual *dcompVisual = nullptr;
     QD3D11SwapChainTimestamps timestamps;
     int currentTimestampPairIndex = 0;
+    HANDLE frameLatencyWaitableObject = nullptr;
 };
 
 class QRhiD3D11 : public QRhiImplementation
@@ -761,6 +762,7 @@ public:
 
     QRhi::Flags rhiFlags;
     bool debugLayer = false;
+    UINT maxFrameLatency = 2; // 1-3, use 2 to keep CPU-GPU parallelism while reducing lag compared to tripple buffering
     bool importedDeviceAndContext = false;
     ID3D11Device *dev = nullptr;
     ID3D11DeviceContext1 *context = nullptr;

qtbase/src/gui/rhi/qrhid3d12.cpp

@@ -23,7 +23,8 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QRhiD3D12InitParams
-    \inmodule QtGui
+    \inmodule QtGuiPrivate
+    \inheaderfile rhi/qrhi.h
     \brief Direct3D 12 specific initialization parameters.
 
     \note This is a RHI API with limited compatibility guarantees, see \l QRhi
@@ -70,7 +71,8 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QRhiD3D12NativeHandles
-    \inmodule QtGui
+    \inmodule QtGuiPrivate
+    \inheaderfile rhi/qrhi.h
     \brief Holds the D3D12 device used by the QRhi.
 
     \note The class uses \c{void *} as the type since including the COM-based
@@ -129,7 +131,8 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QRhiD3D12CommandBufferNativeHandles
-    \inmodule QtGui
+    \inmodule QtGuiPrivate
+    \inheaderfile rhi/qrhi.h
     \brief Holds the ID3D12GraphicsCommandList1 object that is backing a QRhiCommandBuffer.
 
     \note The command list object is only guaranteed to be valid, and
@@ -239,6 +242,11 @@ bool QRhiD3D12::create(QRhi::Flags flags)
         }
     }
 
+    if (qEnvironmentVariableIsSet("QT_D3D_MAX_FRAME_LATENCY"))
+        maxFrameLatency = UINT(qMax(0, qEnvironmentVariableIntValue("QT_D3D_MAX_FRAME_LATENCY")));
+    if (maxFrameLatency != 0)
+        qCDebug(QRHI_LOG_INFO, "Using frame latency waitable object with max frame latency %u", maxFrameLatency);
+
     supportsAllowTearing = false;
     IDXGIFactory5 *factory5 = nullptr;
     if (SUCCEEDED(dxgiFactory->QueryInterface(__uuidof(IDXGIFactory5), reinterpret_cast<void **>(&factory5)))) {
@@ -501,9 +509,13 @@ bool QRhiD3D12::create(QRhi::Flags flags)
         memset(timestampReadbackArea.mem.p, 0, readbackBufSize);
     }
 
+    caps = {};
     D3D12_FEATURE_DATA_D3D12_OPTIONS3 options3 = {};
-    if (SUCCEEDED(dev->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &options3, sizeof(options3))))
+    if (SUCCEEDED(dev->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &options3, sizeof(options3)))) {
         caps.multiView = options3.ViewInstancingTier != D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED;
+        // https://microsoft.github.io/DirectX-Specs/d3d/RelaxedCasting.html
+        caps.textureViewFormat = options3.CastingFullyTypedFormatSupported;
+    }
 
     deviceLost = false;
     offscreenActive = false;
@@ -748,6 +760,12 @@ bool QRhiD3D12::isFeatureSupported(QRhi::Feature feature) const
         return false; // we generate mipmaps ourselves with compute and this is not implemented
     case QRhi::MultiView:
         return caps.multiView;
+    case QRhi::TextureViewFormat:
+        return caps.textureViewFormat;
+    case QRhi::ResolveDepthStencil:
+        // there is no Multisample Resolve support for depth/stencil formats
+        // https://learn.microsoft.com/en-us/windows/win32/direct3ddxgi/hardware-support-for-direct3d-12-1-formats
+        return false;
     }
     return false;
 }
@@ -974,7 +992,7 @@ void QD3D12CommandBuffer::visitStorageImage(QD3D12Stage s,
     const bool isArray = texD->m_flags.testFlag(QRhiTexture::TextureArray);
     const bool is3D = texD->m_flags.testFlag(QRhiTexture::ThreeDimensional);
     D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
-    uavDesc.Format = texD->dxgiFormat;
+    uavDesc.Format = texD->rtFormat;
     if (isCube) {
         uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
         uavDesc.Texture2DArray.MipSlice = UINT(d.level);
@@ -1533,6 +1551,9 @@ QRhi::FrameOpResult QRhiD3D12::beginFrame(QRhiSwapChain *swapChain, QRhi::BeginF
     for (QD3D12SwapChain *sc : std::as_const(swapchains))
         sc->waitCommandCompletionForFrameSlot(currentFrameSlot); // note: swapChainD->currentFrameSlot, not sc's
 
+    if (swapChainD->frameLatencyWaitableObject)
+        WaitForSingleObjectEx(swapChainD->frameLatencyWaitableObject, 1000, true);
+
     HRESULT hr = cmdAllocators[currentFrameSlot]->Reset();
     if (FAILED(hr)) {
         qWarning("Failed to reset command allocator: %s",
@@ -1996,7 +2017,8 @@ void QRhiD3D12::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
                                                  dstTexD->dxgiFormat);
             }
         }
-
+        if (rtTex->m_desc.depthResolveTexture())
+            qWarning("Resolving multisample depth-stencil buffers is not supported with D3D");
     }
 
     cbD->recordingPass = QD3D12CommandBuffer::NoPass;
@@ -4188,6 +4210,10 @@ bool QD3D12Texture::prepareCreate(QSize *adjustedSize)
     if (!handle.isNull())
         destroy();
 
+    QRHI_RES_RHI(QRhiD3D12);
+    if (!rhiD->isTextureFormatSupported(m_format, m_flags))
+        return false;
+
     const bool isDepth = isDepthTextureFormat(m_format);
     const bool isCube = m_flags.testFlag(CubeMap);
     const bool is3D = m_flags.testFlag(ThreeDimensional);
@@ -4198,8 +4224,27 @@ bool QD3D12Texture::prepareCreate(QSize *adjustedSize)
     const QSize size = is1D ? QSize(qMax(1, m_pixelSize.width()), 1)
                             : (m_pixelSize.isEmpty() ? QSize(1, 1) : m_pixelSize);
 
-    QRHI_RES_RHI(QRhiD3D12);
     dxgiFormat = toD3DTextureFormat(m_format, m_flags);
+    if (isDepth) {
+        srvFormat = toD3DDepthTextureSRVFormat(m_format);
+        rtFormat = toD3DDepthTextureDSVFormat(m_format);
+    } else {
+        srvFormat = dxgiFormat;
+        rtFormat = dxgiFormat;
+    }
+    if (m_writeViewFormat.format != UnknownFormat) {
+        if (isDepth)
+            rtFormat = toD3DDepthTextureDSVFormat(m_writeViewFormat.format);
+        else
+            rtFormat = toD3DTextureFormat(m_writeViewFormat.format, m_writeViewFormat.srgb ? sRGB : Flags());
+    }
+    if (m_readViewFormat.format != UnknownFormat) {
+        if (isDepth)
+            srvFormat = toD3DDepthTextureSRVFormat(m_readViewFormat.format);
+        else
+            srvFormat = toD3DTextureFormat(m_readViewFormat.format, m_readViewFormat.srgb ? sRGB : Flags());
+    }
+    
     mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1);
     sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount, dxgiFormat);
     if (sampleDesc.Count > 1) {
@@ -4258,14 +4303,13 @@ bool QD3D12Texture::prepareCreate(QSize *adjustedSize)
 bool QD3D12Texture::finishCreate()
 {
     QRHI_RES_RHI(QRhiD3D12);
-    const bool isDepth = isDepthTextureFormat(m_format);
     const bool isCube = m_flags.testFlag(CubeMap);
     const bool is3D = m_flags.testFlag(ThreeDimensional);
     const bool isArray = m_flags.testFlag(TextureArray);
     const bool is1D = m_flags.testFlag(OneDimensional);
 
     D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-    srvDesc.Format = isDepth ? toD3DDepthTextureSRVFormat(m_format) : dxgiFormat;
+    srvDesc.Format = srvFormat;
     srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
 
     if (isCube) {
@@ -4624,7 +4668,7 @@ QRhiRenderPassDescriptor *QD3D12TextureRenderTarget::newCompatibleRenderPassDesc
         QD3D12Texture *texD = QRHI_RES(QD3D12Texture, it->texture());
         QD3D12RenderBuffer *rbD = QRHI_RES(QD3D12RenderBuffer, it->renderBuffer());
         if (texD)
-            rpD->colorFormat[rpD->colorAttachmentCount] = texD->dxgiFormat;
+            rpD->colorFormat[rpD->colorAttachmentCount] = texD->rtFormat;
         else if (rbD)
             rpD->colorFormat[rpD->colorAttachmentCount] = rbD->dxgiFormat;
         rpD->colorAttachmentCount += 1;
@@ -4675,7 +4719,7 @@ bool QD3D12TextureRenderTarget::create()
             const bool isMultiView = it->multiViewCount() >= 2;
             UINT layerCount = isMultiView ? UINT(it->multiViewCount()) : 1;
             D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
-            rtvDesc.Format = toD3DTextureFormat(texD->format(), texD->flags());
+            rtvDesc.Format = texD->rtFormat;
             if (texD->flags().testFlag(QRhiTexture::CubeMap)) {
                 rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
                 rtvDesc.Texture2DArray.MipSlice = UINT(colorAtt.level());
@@ -4749,7 +4793,7 @@ bool QD3D12TextureRenderTarget::create()
                 return false;
             }
             D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = {};
-            dsvDesc.Format = toD3DDepthTextureDSVFormat(depthTexD->format());
+            dsvDesc.Format = depthTexD->rtFormat;
             dsvDesc.ViewDimension = depthTexD->sampleDesc.Count > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DMS
                                                                     : D3D12_DSV_DIMENSION_TEXTURE2D;
             if (depthTexD->flags().testFlag(QRhiTexture::TextureArray)) {
@@ -5545,6 +5589,22 @@ static inline DXGI_FORMAT toD3DAttributeFormat(QRhiVertexInputAttribute::Format
         return DXGI_FORMAT_R16G16_FLOAT;
     case QRhiVertexInputAttribute::Half:
          return DXGI_FORMAT_R16_FLOAT;
+    case QRhiVertexInputAttribute::UShort4:
+    // Note: D3D does not support UShort3.  Pass through UShort3 as UShort4.
+    case QRhiVertexInputAttribute::UShort3:
+        return DXGI_FORMAT_R16G16B16A16_UINT;
+    case QRhiVertexInputAttribute::UShort2:
+        return DXGI_FORMAT_R16G16_UINT;
+    case QRhiVertexInputAttribute::UShort:
+        return DXGI_FORMAT_R16_UINT;
+    case QRhiVertexInputAttribute::SShort4:
+    // Note: D3D does not support SShort3.  Pass through SShort3 as SShort4.
+    case QRhiVertexInputAttribute::SShort3:
+        return DXGI_FORMAT_R16G16B16A16_SINT;
+    case QRhiVertexInputAttribute::SShort2:
+        return DXGI_FORMAT_R16G16_SINT;
+    case QRhiVertexInputAttribute::SShort:
+        return DXGI_FORMAT_R16_SINT;
     }
     Q_UNREACHABLE_RETURN(DXGI_FORMAT_R32G32B32A32_FLOAT);
 }
@@ -5637,7 +5697,16 @@ bool QD3D12GraphicsPipeline::create()
     }
 
     QD3D12RenderPassDescriptor *rpD = QRHI_RES(QD3D12RenderPassDescriptor, m_renderPassDesc);
-    const DXGI_SAMPLE_DESC sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount, DXGI_FORMAT(rpD->colorFormat[0]));
+    DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN;
+    if (rpD->colorAttachmentCount > 0) {
+        format = DXGI_FORMAT(rpD->colorFormat[0]);
+    } else if (rpD->hasDepthStencil) {
+        format = DXGI_FORMAT(rpD->dsFormat);
+    } else {
+        qWarning("Cannot create graphics pipeline state without color or depthStencil format");
+        return false;
+    }
+    const DXGI_SAMPLE_DESC sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount, format);
 
     struct {
         QD3D12PipelineStateSubObject<ID3D12RootSignature *, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE> rootSig;
@@ -5678,7 +5747,7 @@ bool QD3D12GraphicsPipeline::create()
             } else {
                 QByteArray sem;
                 sem.resize(16);
-                qsnprintf(sem.data(), sem.size(), "TEXCOORD%d_", it->location() - matrixSlice);
+                std::snprintf(sem.data(), sem.size(), "TEXCOORD%d_", it->location() - matrixSlice);
                 matrixSliceSemantics.append(sem);
                 desc.SemanticName = matrixSliceSemantics.last().constData();
                 desc.SemanticIndex = UINT(matrixSlice);
@@ -6105,6 +6174,11 @@ void QD3D12SwapChain::destroy()
         dcompTarget = nullptr;
     }
 
+    if (frameLatencyWaitableObject) {
+        CloseHandle(frameLatencyWaitableObject);
+        frameLatencyWaitableObject = nullptr;
+    }
+
     QRHI_RES_RHI(QRhiD3D12);
     if (rhiD) {
         rhiD->swapchains.remove(this);
@@ -6296,7 +6370,7 @@ bool QD3D12SwapChain::createOrResize()
     if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) {
         if (rhiD->ensureDirectCompositionDevice()) {
             if (!dcompTarget) {
-                hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, true, &dcompTarget);
+                hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, false, &dcompTarget);
                 if (FAILED(hr)) {
                     qWarning("Failed to create Direct Composition target for the window: %s",
                              qPrintable(QSystemError::windowsComString(hr)));
@@ -6321,6 +6395,14 @@ bool QD3D12SwapChain::createOrResize()
     if (swapInterval == 0 && rhiD->supportsAllowTearing)
         swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
 
+    // maxFrameLatency 0 means no waitable object usage.
+    // Ignore it also when NoVSync is on, and when using WARP.
+    const bool useFrameLatencyWaitableObject = rhiD->maxFrameLatency != 0
+                                               && swapInterval != 0
+                                               && rhiD->driverInfoStruct.deviceType != QRhiDriverInfo::CpuDevice;
+    if (useFrameLatencyWaitableObject)
+        swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
+
     if (!swapChain) {
         chooseFormats();
 
@@ -6377,6 +6459,10 @@ bool QD3D12SwapChain::createOrResize()
                              qPrintable(QSystemError::windowsComString(hr)));
                 }
             }
+            if (useFrameLatencyWaitableObject) {
+                swapChain->SetMaximumFrameLatency(rhiD->maxFrameLatency);
+                frameLatencyWaitableObject = swapChain->GetFrameLatencyWaitableObject();
+            }
             if (dcompVisual) {
                 hr = dcompVisual->SetContent(swapChain);
                 if (SUCCEEDED(hr)) {

qtbase/src/gui/text/windows/qwindowsfontdatabasebase.cpp

@@ -565,16 +565,27 @@ void QWindowsFontDatabaseBase::createDirectWriteFactory(IDWriteFactory **factory
     IUnknown *result = nullptr;
 
 #  if QT_CONFIG(directwrite3)
-    DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory5), &result);
-
-    if (result == nullptr)
-        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory3), &result);
-#  endif
-
-    if (result == nullptr)
-        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory2), &result);
+    qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory6";
+    DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory6), &result);
 
     if (result == nullptr) {
+        qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory5";
+        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory5), &result);
+    }
+
+    if (result == nullptr) {
+        qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory3";
+        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory3), &result);
+    }
+#  endif
+
+    if (result == nullptr) {
+        qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory2";
+        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory2), &result);
+    }
+
+    if (result == nullptr) {
+        qCDebug(lcQpaFonts) << "Trying to create plain IDWriteFactory";
         if (FAILED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &result))) {
             qErrnoWarning("DWriteCreateFactory failed");
             return;

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

@@ -7,7 +7,6 @@
 #include "qwindowswindow.h"
 #include "qwindowskeymapper.h"
 #include "qwindowsnativeinterface.h"
-#include "qwindowsmousehandler.h"
 #include "qwindowspointerhandler.h"
 #include "qtwindowsglobal.h"
 #include "qwindowsmenu.h"
@@ -215,7 +214,6 @@ struct QWindowsContextPrivate {
     HDC m_displayContext = nullptr;
     int m_defaultDPI = 96;
     QWindowsKeyMapper m_keyMapper;
-    QWindowsMouseHandler m_mouseHandler;
     QWindowsPointerHandler m_pointerHandler;
     QWindowsMimeRegistry m_mimeConverter;
     QWindowsScreenManager m_screenManager;
@@ -228,11 +226,9 @@ struct QWindowsContextPrivate {
     bool m_asyncExpose = false;
     HPOWERNOTIFY m_powerNotification = nullptr;
     HWND m_powerDummyWindow = nullptr;
-    static bool m_darkMode;
     static bool m_v2DpiAware;
 };
 
-bool QWindowsContextPrivate::m_darkMode = false;
 bool QWindowsContextPrivate::m_v2DpiAware = false;
 
 QWindowsContextPrivate::QWindowsContextPrivate()
@@ -241,7 +237,7 @@ QWindowsContextPrivate::QWindowsContextPrivate()
     QWindowsContext::user32dll.init();
     QWindowsContext::shcoredll.init();
     
-    if (m_pointerHandler.touchDevice() || m_mouseHandler.touchDevice())
+    if (m_pointerHandler.touchDevice())
         m_systemInfo |= QWindowsContext::SI_SupportsTouch;
     m_displayContext = GetDC(nullptr);
     m_defaultDPI = GetDeviceCaps(m_displayContext, LOGPIXELSY);
@@ -249,7 +245,6 @@ QWindowsContextPrivate::QWindowsContextPrivate()
         m_systemInfo |= QWindowsContext::SI_RTL_Extensions;
         m_keyMapper.setUseRTLExtensions(true);
     }
-    m_darkMode = QWindowsTheme::queryDarkMode();
     if (FAILED(m_oleInitializeResult)) {
        qWarning() << "QWindowsContext: OleInitialize() failed: "
            << QSystemError::windowsComString(m_oleInitializeResult);
@@ -306,8 +301,7 @@ bool QWindowsContext::initTouch(unsigned integrationOptions)
 {
     if (d->m_systemInfo & QWindowsContext::SI_SupportsTouch)
         return true;
-    const bool usePointerHandler = (d->m_systemInfo & QWindowsContext::SI_SupportsPointer) != 0;
-    auto touchDevice = usePointerHandler ? d->m_pointerHandler.touchDevice() : d->m_mouseHandler.touchDevice();
+    auto touchDevice = d->m_pointerHandler.touchDevice();
     if (touchDevice.isNull()) {
         const bool mouseEmulation =
             (integrationOptions & QWindowsIntegration::DontPassOsMouseEventsSynthesizedFromTouch) == 0;
@@ -316,7 +310,6 @@ bool QWindowsContext::initTouch(unsigned integrationOptions)
     if (touchDevice.isNull())
         return false;
     d->m_pointerHandler.setTouchDevice(touchDevice);
-    d->m_mouseHandler.setTouchDevice(touchDevice);
     QWindowSystemInterface::registerInputDevice(touchDevice.data());
 
     d->m_systemInfo |= QWindowsContext::SI_SupportsTouch;
@@ -356,21 +349,6 @@ bool QWindowsContext::disposeTablet()
 #endif
 }
 
-bool QWindowsContext::initPointer(unsigned integrationOptions)
-{
-    if (integrationOptions & QWindowsIntegration::DontUseWMPointer)
-        return false;
-
-    if (QOperatingSystemVersion::current() < QOperatingSystemVersion::Windows8)
-        return false;
-
-    if (!QWindowsContext::user32dll.supportsPointerApi())
-        return false;
-
-    d->m_systemInfo |= QWindowsContext::SI_SupportsPointer;
-    return true;
-}
-
 extern "C" LRESULT QT_WIN_CALLBACK qWindowsPowerWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
     if (message != WM_POWERBROADCAST || wParam != PBT_POWERSETTINGCHANGE)
@@ -585,11 +563,6 @@ bool QWindowsContext::setProcessDpiAwareness(QtWindows::DpiAwareness dpiAwarenes
     return true;
 }
 
-bool QWindowsContext::isDarkMode()
-{
-    return QWindowsContextPrivate::m_darkMode;
-}
-
 QWindowsContext *QWindowsContext::instance()
 {
     return m_instance;
@@ -857,16 +830,12 @@ QWindow *QWindowsContext::findWindow(HWND hwnd) const
 
 QWindow *QWindowsContext::windowUnderMouse() const
 {
-    return (d->m_systemInfo & QWindowsContext::SI_SupportsPointer) ?
-        d->m_pointerHandler.windowUnderMouse() : d->m_mouseHandler.windowUnderMouse();
+    return d->m_pointerHandler.windowUnderMouse();
 }
 
 void QWindowsContext::clearWindowUnderMouse()
 {
-    if (d->m_systemInfo & QWindowsContext::SI_SupportsPointer)
-        d->m_pointerHandler.clearWindowUnderMouse();
-    else
-        d->m_mouseHandler.clearWindowUnderMouse();
+    d->m_pointerHandler.clearWindowUnderMouse();
 }
 
 /*!
@@ -1130,9 +1099,10 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
 
     MSG msg;
     msg.hwnd = hwnd;         // re-create MSG structure
-    msg.message = message;   // time and pt fields ignored
+    msg.message = message;
     msg.wParam = wParam;
     msg.lParam = lParam;
+    msg.time = GetMessageTime();
     msg.pt.x = msg.pt.y = 0;
     if (et != QtWindows::CursorEvent && (et & (QtWindows::MouseEventFlag | QtWindows::NonClientEventFlag))) {
         msg.pt.x = GET_X_LPARAM(lParam);
@@ -1181,8 +1151,7 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
 
     switch (et) {
     case QtWindows::GestureEvent:
-        if (!(d->m_systemInfo & QWindowsContext::SI_SupportsPointer))
-            return sessionManagerInteractionBlocked() || d->m_mouseHandler.translateGestureEvent(platformWindow->window(), hwnd, et, msg, result);
+        // TODO???
         break;
     case QtWindows::InputMethodOpenCandidateWindowEvent:
     case QtWindows::InputMethodCloseCandidateWindowEvent:
@@ -1216,21 +1185,7 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
         // Only refresh the window theme if the user changes the personalize settings.
         if ((wParam == 0) && (lParam != 0) // lParam sometimes may be NULL.
             && (wcscmp(reinterpret_cast<LPCWSTR>(lParam), L"ImmersiveColorSet") == 0)) {
-            const bool darkMode = QWindowsTheme::queryDarkMode();
-            const bool darkModeChanged = darkMode != QWindowsContextPrivate::m_darkMode;
-            QWindowsContextPrivate::m_darkMode = darkMode;
-            auto integration = QWindowsIntegration::instance();
-            integration->updateApplicationBadge();
-            if (integration->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle)) {
-                QWindowsTheme::instance()->refresh();
-                QWindowSystemInterface::handleThemeChange();
-            }
-            if (darkModeChanged) {
-                if (integration->darkModeHandling().testFlag(QWindowsApplication::DarkModeWindowFrames)) {
-                    for (QWindowsWindow *w : d->m_windows)
-                        w->setDarkBorder(QWindowsContextPrivate::m_darkMode);
-                }
-            }
+            QWindowsTheme::handleSettingsChanged();
         }
         return d->m_screenManager.handleScreenChanges();
     }
@@ -1336,16 +1291,11 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
     case QtWindows::NonClientMouseEvent:
         if (!platformWindow->frameStrutEventsEnabled())
             break;
-        if ((d->m_systemInfo & QWindowsContext::SI_SupportsPointer))
-            return sessionManagerInteractionBlocked() || d->m_pointerHandler.translateMouseEvent(platformWindow->window(), hwnd, et, msg, result);
-        else
-            return sessionManagerInteractionBlocked() || d->m_mouseHandler.translateMouseEvent(platformWindow->window(), hwnd, et, msg, result);
+        return sessionManagerInteractionBlocked() || d->m_pointerHandler.translateMouseEvent(platformWindow->window(), hwnd, et, msg, result);
     case QtWindows::NonClientPointerEvent:
         if (!platformWindow->frameStrutEventsEnabled())
             break;
-        if ((d->m_systemInfo & QWindowsContext::SI_SupportsPointer))
-            return sessionManagerInteractionBlocked() || d->m_pointerHandler.translatePointerEvent(platformWindow->window(), hwnd, et, msg, result);
-        break;
+        return sessionManagerInteractionBlocked() || d->m_pointerHandler.translatePointerEvent(platformWindow->window(), hwnd, et, msg, result);
     case QtWindows::EnterSizeMoveEvent:
         platformWindow->setFlag(QWindowsWindow::ResizeMoveActive);
         if (!IsZoomed(hwnd))
@@ -1359,8 +1309,7 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
             platformWindow->updateRestoreGeometry();
         return true;
     case QtWindows::ScrollEvent:
-        if (!(d->m_systemInfo & QWindowsContext::SI_SupportsPointer))
-            return sessionManagerInteractionBlocked() || d->m_mouseHandler.translateScrollEvent(platformWindow->window(), hwnd, msg, result);
+        // TODO???
         break;
     case QtWindows::MouseWheelEvent:
     case QtWindows::MouseEvent:
@@ -1371,20 +1320,14 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
                 window = window->parent();
             if (!window)
                 return false;
-            if (d->m_systemInfo & QWindowsContext::SI_SupportsPointer)
-                return sessionManagerInteractionBlocked() || d->m_pointerHandler.translateMouseEvent(window, hwnd, et, msg, result);
-            else
-                return sessionManagerInteractionBlocked() || d->m_mouseHandler.translateMouseEvent(window, hwnd, et, msg, result);
+            return sessionManagerInteractionBlocked() || d->m_pointerHandler.translateMouseEvent(window, hwnd, et, msg, result);
         }
         break;
     case QtWindows::TouchEvent:
-        if (!(d->m_systemInfo & QWindowsContext::SI_SupportsPointer))
-            return sessionManagerInteractionBlocked() || d->m_mouseHandler.translateTouchEvent(platformWindow->window(), hwnd, et, msg, result);
+        // TODO???
         break;
     case QtWindows::PointerEvent:
-        if (d->m_systemInfo & QWindowsContext::SI_SupportsPointer)
-            return sessionManagerInteractionBlocked() || d->m_pointerHandler.translatePointerEvent(platformWindow->window(), hwnd, et, msg, result);
-        break;
+        return sessionManagerInteractionBlocked() || d->m_pointerHandler.translatePointerEvent(platformWindow->window(), hwnd, et, msg, result);
     case QtWindows::FocusInEvent: // see QWindowsWindow::requestActivateWindow().
     case QtWindows::FocusOutEvent:
         handleFocusEvent(et, platformWindow);
@@ -1588,7 +1531,7 @@ void QWindowsContext::handleExitSizeMove(QWindow *window)
     //    Mouse is left in pressed state after press on size grip (inside window),
     //    no further mouse events are received
     // For cases 1,3, intercept WM_EXITSIZEMOVE to sync the buttons.
-    const Qt::MouseButtons currentButtons = QWindowsMouseHandler::queryMouseButtons();
+    const Qt::MouseButtons currentButtons = QWindowsPointerHandler::queryMouseButtons();
     const Qt::MouseButtons appButtons = QGuiApplication::mouseButtons();
     if (currentButtons == appButtons)
         return;
@@ -1604,10 +1547,7 @@ void QWindowsContext::handleExitSizeMove(QWindow *window)
                 currentButtons, button, type, keyboardModifiers);
         }
     }
-    if (d->m_systemInfo & QWindowsContext::SI_SupportsPointer)
-        d->m_pointerHandler.clearEvents();
-    else
-        d->m_mouseHandler.clearEvents();
+    d->m_pointerHandler.clearEvents();
 }
 
 bool QWindowsContext::asyncExpose() const
@@ -1622,11 +1562,9 @@ void QWindowsContext::setAsyncExpose(bool value)
 
 DWORD QWindowsContext::readAdvancedExplorerSettings(const wchar_t *subKey, DWORD defaultValue)
 {
-    const auto value =
-        QWinRegistryKey(HKEY_CURRENT_USER,
-                        LR"(Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced)")
-                       .dwordValue(subKey);
-    return value.second ? value.first : defaultValue;
+    const auto advancedSettings = QWinRegistryKey(
+            HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced)");
+    return advancedSettings.value<DWORD>(subKey).value_or(defaultValue);
 }
 
 static inline bool isEmptyRect(const RECT &rect)

qtbase/src/plugins/platforms/windows/qwindowscontext.h

@@ -143,8 +143,7 @@ public:
     enum SystemInfoFlags
     {
         SI_RTL_Extensions = 0x1,
-        SI_SupportsTouch = 0x2,
-        SI_SupportsPointer = 0x4,
+        SI_SupportsTouch = 0x2
     };
 
     // Verbose flag set by environment variable QT_QPA_VERBOSE
@@ -157,7 +156,6 @@ public:
     bool initTouch(unsigned integrationOptions); // For calls from QWindowsIntegration::QWindowsIntegration() only.
     void registerTouchWindows();
     bool initTablet();
-    bool initPointer(unsigned integrationOptions);
     bool disposeTablet();
 
     bool initPowerNotificationHandler();
@@ -210,8 +208,6 @@ public:
     static QtWindows::DpiAwareness processDpiAwareness();
     static QtWindows::DpiAwareness windowDpiAwareness(HWND hwnd);
 
-    static bool isDarkMode();
-
     void setDetectAltGrModifier(bool a);
 
     // Returns a combination of SystemInfoFlags

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

@@ -11,7 +11,7 @@
 #include "qwindowsintegration.h"
 #include "qwindowsdropdataobject.h"
 #include "qwindowswindow.h"
-#include "qwindowsmousehandler.h"
+#include "qwindowspointerhandler.h"
 #include "qwindowscursor.h"
 #include "qwindowskeymapper.h"
 
@@ -256,8 +256,9 @@ void QWindowsOleDropSource::createCursors()
         if (const QScreen *primaryScreen = QGuiApplication::primaryScreen())
             platformScreen = primaryScreen->handle();
     }
-    Q_ASSERT(platformScreen);
-    QPlatformCursor *platformCursor = platformScreen->cursor();
+    QPlatformCursor *platformCursor = nullptr;
+    if (platformScreen)
+        platformCursor = platformScreen->cursor();
 
     if (GetSystemMetrics (SM_REMOTESESSION) != 0) {
         /* Workaround for RDP issues with large cursors.
@@ -274,7 +275,7 @@ void QWindowsOleDropSource::createCursors()
         hotSpotScaleFactor = QHighDpiScaling::factor(platformScreen);
         pixmapScaleFactor = hotSpotScaleFactor / pixmap.devicePixelRatio();
     }
-    QPixmap scaledPixmap = qFuzzyCompare(pixmapScaleFactor, 1.0)
+    QPixmap scaledPixmap = (!hasPixmap || qFuzzyCompare(pixmapScaleFactor, 1.0))
         ? pixmap
         :  pixmap.scaled((QSizeF(pixmap.size()) * pixmapScaleFactor).toSize(),
                          Qt::KeepAspectRatio, Qt::SmoothTransformation);
@@ -343,7 +344,7 @@ QWindowsOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
     // In some rare cases, when a mouse button is released but the mouse is static,
     // grfKeyState will not be updated with these released buttons until the mouse
     // is moved. So we use the async key state given by queryMouseButtons() instead.
-    Qt::MouseButtons buttons = QWindowsMouseHandler::queryMouseButtons();
+    Qt::MouseButtons buttons = QWindowsPointerHandler::queryMouseButtons();
 
     SCODE result = S_OK;
     if (fEscapePressed || QWindowsDrag::isCanceled()) {
@@ -368,7 +369,7 @@ QWindowsOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
                 const QPoint localPos = m_windowUnderMouse->handle()->mapFromGlobal(globalPos);
                 QWindowSystemInterface::handleMouseEvent(m_windowUnderMouse.data(),
                                                          QPointF(localPos), QPointF(globalPos),
-                                                         QWindowsMouseHandler::queryMouseButtons(),
+                                                         QWindowsPointerHandler::queryMouseButtons(),
                                                          Qt::LeftButton, QEvent::MouseButtonRelease);
             }
             m_currentButtons = Qt::NoButton;
@@ -462,7 +463,7 @@ void QWindowsOleDropTarget::handleDrag(QWindow *window, DWORD grfKeyState,
     const Qt::DropActions actions = translateToQDragDropActions(*pdwEffect);
 
     lastModifiers = toQtKeyboardModifiers(grfKeyState);
-    lastButtons = QWindowsMouseHandler::queryMouseButtons();
+    lastButtons = QWindowsPointerHandler::queryMouseButtons();
 
     const QPlatformDragQtResponse response =
           QWindowSystemInterface::handleDrag(window, windowsDrag->dropData(),
@@ -532,7 +533,7 @@ QWindowsOleDropTarget::DragLeave()
 
     const auto *keyMapper = QWindowsContext::instance()->keyMapper();
     lastModifiers = keyMapper->queryKeyboardModifiers();
-    lastButtons = QWindowsMouseHandler::queryMouseButtons();
+    lastButtons = QWindowsPointerHandler::queryMouseButtons();
 
     QWindowSystemInterface::handleDrag(m_window, nullptr, QPoint(), Qt::IgnoreAction,
                                        Qt::NoButton, Qt::NoModifier);
@@ -561,7 +562,7 @@ QWindowsOleDropTarget::Drop(LPDATAOBJECT pDataObj, DWORD grfKeyState,
     QWindowsDrag *windowsDrag = QWindowsDrag::instance();
 
     lastModifiers = toQtKeyboardModifiers(grfKeyState);
-    lastButtons = QWindowsMouseHandler::queryMouseButtons();
+    lastButtons = QWindowsPointerHandler::queryMouseButtons();
 
     const QPlatformDropQtResponse response =
         QWindowSystemInterface::handleDrop(m_window, windowsDrag->dropData(),

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

@@ -0,0 +1,779 @@
+// 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;
+
+static inline unsigned parseOptions(const QStringList &paramList,
+                                    int *tabletAbsoluteRange,
+                                    QtWindows::DpiAwareness *dpiAwareness,
+                                    DarkModeHandling *darkModeHandling)
+{
+    unsigned options = 0;
+
+    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)
+
+        /* IDWriteFontFace3 is only reportedly available starting with Windows 10. This change is necessary starting
+        with Qt 6.8, where DirectWrite is used by default to populate the font database. 
+        More info: https://github.com/videolan/vlc/blob/master/contrib/src/qt/0001-Use-DirectWrite-font-database-only-with-Windows-10-a.patch
+        */
+
+        if (QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows10 &&
+            !(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/plugins/platforms/windows/qwindowskeymapper.cpp

@@ -806,7 +806,7 @@ static void showSystemMenu(QWindow* w)
         qWindowsWndProc(topLevelHwnd, WM_SYSCOMMAND, WPARAM(ret), 0);
 }
 
-static inline void sendExtendedPressRelease(QWindow *w, int k,
+static inline void sendExtendedPressRelease(QWindow *w, unsigned long timestamp, int k,
                                             Qt::KeyboardModifiers mods,
                                             quint32 nativeScanCode,
                                             quint32 nativeVirtualKey,
@@ -815,8 +815,8 @@ static inline void sendExtendedPressRelease(QWindow *w, int k,
                                             bool autorep = false,
                                             ushort count = 1)
 {
-    QWindowSystemInterface::handleExtendedKeyEvent(w, QEvent::KeyPress, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
-    QWindowSystemInterface::handleExtendedKeyEvent(w, QEvent::KeyRelease, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
+    QWindowSystemInterface::handleExtendedKeyEvent(w, timestamp, QEvent::KeyPress, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
+    QWindowSystemInterface::handleExtendedKeyEvent(w, timestamp, QEvent::KeyRelease, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
 }
 
 /*!
@@ -883,7 +883,7 @@ bool QWindowsKeyMapper::translateMultimediaKeyEventInternal(QWindow *window, con
 
     const int qtKey = int(CmdTbl[cmd]);
     if (!skipPressRelease)
-        sendExtendedPressRelease(receiver, qtKey, Qt::KeyboardModifier(state), 0, 0, 0);
+        sendExtendedPressRelease(receiver, msg.time, qtKey, Qt::KeyboardModifier(state), 0, 0, 0);
     // QTBUG-43343: Make sure to return false if Qt does not handle the key, otherwise,
     // the keys are not passed to the active media player.
 # if QT_CONFIG(shortcut)
@@ -963,7 +963,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
     // A multi-character key or a Input method character
     // not found by our look-ahead
     if (msgType == WM_CHAR || msgType == WM_IME_CHAR) {
-        sendExtendedPressRelease(receiver, 0, Qt::KeyboardModifier(state), scancode, 0, nModifiers, messageKeyText(msg), false);
+        sendExtendedPressRelease(receiver, msg.time, 0, Qt::KeyboardModifier(state), scancode, 0, nModifiers, messageKeyText(msg), false);
         return true;
     }
 
@@ -998,14 +998,14 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
                 if (dirStatus == VK_LSHIFT
                         && ((msg.wParam == VK_SHIFT && GetKeyState(VK_LCONTROL))
                             || (msg.wParam == VK_CONTROL && GetKeyState(VK_LSHIFT)))) {
-                    sendExtendedPressRelease(receiver, Qt::Key_Direction_L, {},
+                    sendExtendedPressRelease(receiver, msg.time, Qt::Key_Direction_L, {},
                                              scancode, vk_key, nModifiers, QString(), false);
                     result = true;
                     dirStatus = 0;
                 } else if (dirStatus == VK_RSHIFT
                            && ( (msg.wParam == VK_SHIFT && GetKeyState(VK_RCONTROL))
                                 || (msg.wParam == VK_CONTROL && GetKeyState(VK_RSHIFT)))) {
-                    sendExtendedPressRelease(receiver, Qt::Key_Direction_R, {},
+                    sendExtendedPressRelease(receiver, msg.time, Qt::Key_Direction_R, {},
                                              scancode, vk_key, nModifiers, QString(), false);
                     result = true;
                     dirStatus = 0;
@@ -1218,9 +1218,9 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
         // so, we have an auto-repeating key
         if (rec) {
             if (code < Qt::Key_Shift || code > Qt::Key_ScrollLock) {
-                QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyRelease, code,
+                QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyRelease, code,
                                                                Qt::KeyboardModifier(state), scancode, quint32(msg.wParam), nModifiers, rec->text, true);
-                QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyPress, code,
+                QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyPress, code,
                                                                Qt::KeyboardModifier(state), scancode, quint32(msg.wParam), nModifiers, rec->text, true);
                 result = true;
             }
@@ -1246,7 +1246,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
             if (msg.wParam == VK_PACKET)
                 code = asciiToKeycode(char(uch.cell()), state);
 
-            QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyPress, code,
+            QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyPress, code,
                                                            modifiers, scancode, quint32(msg.wParam), nModifiers, text, false);
             result =true;
             bool store = true;
@@ -1288,10 +1288,10 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
             if ((msg.lParam & 0x40000000) == 0 &&
                     Qt::KeyboardModifier(state) == Qt::NoModifier &&
                     ((code == Qt::Key_F18) || (code == Qt::Key_F19) || (code == Qt::Key_F20))) {
-                QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyPress, code,
+                QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyPress, code,
                                                                Qt::MetaModifier, scancode,
                                                                quint32(msg.wParam), MetaLeft);
-                QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyRelease, code,
+                QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyRelease, code,
                                                                Qt::NoModifier, scancode,
                                                                quint32(msg.wParam), 0);
                 result = true;
@@ -1303,7 +1303,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
             // Map SHIFT + Tab to SHIFT + BackTab, QShortcutMap knows about this translation
             if (code == Qt::Key_Tab && (state & Qt::ShiftModifier) == Qt::ShiftModifier)
                 code = Qt::Key_Backtab;
-            QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyRelease, code,
+            QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyRelease, code,
                                                            Qt::KeyboardModifier(state), scancode, quint32(msg.wParam),
                                                            nModifiers,
                                                            (rec ? rec->text : QString()), false);
@@ -1359,6 +1359,11 @@ QList<QKeyCombination> QWindowsKeyMapper::possibleKeyCombinations(const QKeyEven
         return result;
     }
 
+    // If Key_Tab+Shift is pressed we add Key_Backtab without
+    // shift modifier as a possible combination too
+    if (baseKey == Qt::Key_Tab && (keyMods & Qt::ShiftModifier))
+        result << (Qt::Key_Backtab | (keyMods & ~Qt::ShiftModifier));
+
     // The base key is _always_ valid, of course
     result << QKeyCombination::fromCombined(int(baseKey) + int(keyMods));
 

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

@@ -4,7 +4,6 @@
 #include <QtCore/qt_windows.h>
 
 #include "qwindowspointerhandler.h"
-#include "qwindowsmousehandler.h"
 #if QT_CONFIG(tabletevent)
 #  include "qwindowstabletsupport.h"
 #endif
@@ -41,6 +40,14 @@ enum {
 
 qint64 QWindowsPointerHandler::m_nextInputDeviceId = 1;
 
+const QPointingDevice *primaryMouse()
+{
+    static QPointer<const QPointingDevice> result;
+    if (!result)
+        result = QPointingDevice::primaryPointingDevice();
+    return result;
+}
+
 QWindowsPointerHandler::~QWindowsPointerHandler()
 {
 }
@@ -240,7 +247,7 @@ static Qt::MouseButtons mouseButtonsFromKeyState(WPARAM keyState)
     return result;
 }
 
-static Qt::MouseButtons queryMouseButtons()
+Qt::MouseButtons QWindowsPointerHandler::queryMouseButtons()
 {
     Qt::MouseButtons result = Qt::NoButton;
     const bool mouseSwapped = GetSystemMetrics(SM_SWAPBUTTON);
@@ -454,7 +461,7 @@ bool QWindowsPointerHandler::translateTouchEvent(QWindow *window, HWND hwnd,
 
     if (msg.message == WM_POINTERCAPTURECHANGED) {
         const auto *keyMapper = QWindowsContext::instance()->keyMapper();
-        QWindowSystemInterface::handleTouchCancelEvent(window, m_touchDevice.data(),
+        QWindowSystemInterface::handleTouchCancelEvent(window, msg.time, m_touchDevice.data(),
                                                        keyMapper->queryKeyboardModifiers());
         m_lastTouchPoints.clear();
         return true;
@@ -569,7 +576,7 @@ bool QWindowsPointerHandler::translateTouchEvent(QWindow *window, HWND hwnd,
         m_touchInputIDToTouchPointID.clear();
 
     const auto *keyMapper = QWindowsContext::instance()->keyMapper();
-    QWindowSystemInterface::handleTouchEvent(window, m_touchDevice.data(), touchPoints,
+    QWindowSystemInterface::handleTouchEvent(window, msg.time, m_touchDevice.data(), touchPoints,
                                              keyMapper->queryKeyboardModifiers());
     return false; // Allow mouse messages to be generated.
 }
@@ -672,7 +679,7 @@ bool QWindowsPointerHandler::translatePenEvent(QWindow *window, HWND hwnd, QtWin
 
     switch (msg.message) {
     case WM_POINTERENTER: {
-        QWindowSystemInterface::handleTabletEnterLeaveProximityEvent(window, device.data(), true);
+        QWindowSystemInterface::handleTabletEnterLeaveProximityEvent(window, msg.time, device.data(), true);
         m_windowUnderPointer = window;
         // The local coordinates may fall outside the window.
         // Wait until the next update to send the enter event.
@@ -685,7 +692,7 @@ bool QWindowsPointerHandler::translatePenEvent(QWindow *window, HWND hwnd, QtWin
             m_windowUnderPointer = nullptr;
             m_currentWindow = nullptr;
         }
-        QWindowSystemInterface::handleTabletEnterLeaveProximityEvent(window, device.data(), false);
+        QWindowSystemInterface::handleTabletEnterLeaveProximityEvent(window, msg.time, device.data(), false);
         break;
     case WM_POINTERDOWN:
     case WM_POINTERUP:
@@ -711,7 +718,7 @@ bool QWindowsPointerHandler::translatePenEvent(QWindow *window, HWND hwnd, QtWin
         const auto *keyMapper = QWindowsContext::instance()->keyMapper();
         const Qt::KeyboardModifiers keyModifiers = keyMapper->queryKeyboardModifiers();
 
-        QWindowSystemInterface::handleTabletEvent(target, device.data(),
+        QWindowSystemInterface::handleTabletEvent(target, msg.time, device.data(),
                                                   localPos, hiResGlobalPos, mouseButtons,
                                                   pressure, xTilt, yTilt, tangentialPressure,
                                                   rotation, z, keyModifiers);
@@ -762,7 +769,7 @@ bool QWindowsPointerHandler::translateMouseWheelEvent(QWindow *window,
 
     QPoint localPos = QWindowsGeometryHint::mapFromGlobal(receiver, globalPos);
 
-    QWindowSystemInterface::handleWheelEvent(receiver, localPos, globalPos, QPoint(), angleDelta, keyModifiers);
+    QWindowSystemInterface::handleWheelEvent(receiver, msg.time, localPos, globalPos, QPoint(), angleDelta, keyModifiers);
     return true;
 }
 
@@ -818,7 +825,7 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window,
     }
 
     Qt::MouseEventSource source = Qt::MouseEventNotSynthesized;
-    const QPointingDevice *device = QWindowsMouseHandler::primaryMouse();
+    const QPointingDevice *device = primaryMouse();
 
     // Following the logic of the old mouse handler, only events synthesized
     // for touch screen are marked as such. On some systems, using the bit 7 of
@@ -861,14 +868,14 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window,
             && (m_lastEventButton & mouseButtons) == 0) {
             auto releaseType = mouseEvent.type == QEvent::NonClientAreaMouseMove ?
                 QEvent::NonClientAreaMouseButtonRelease : QEvent::MouseButtonRelease;
-            QWindowSystemInterface::handleMouseEvent(window, device, localPos, globalPos, mouseButtons, m_lastEventButton,
+            QWindowSystemInterface::handleMouseEvent(window, msg.time, device, localPos, globalPos, mouseButtons, m_lastEventButton,
                                                      releaseType, keyModifiers, source);
     }
     m_lastEventType = mouseEvent.type;
     m_lastEventButton = mouseEvent.button;
 
     if (mouseEvent.type >= QEvent::NonClientAreaMouseMove && mouseEvent.type <= QEvent::NonClientAreaMouseButtonDblClick) {
-        QWindowSystemInterface::handleMouseEvent(window, device, localPos, globalPos, mouseButtons,
+        QWindowSystemInterface::handleMouseEvent(window, msg.time, device, localPos, globalPos, mouseButtons,
                                                            mouseEvent.button, mouseEvent.type, keyModifiers, source);
         return false; // Allow further event processing
     }
@@ -888,7 +895,7 @@ bool QWindowsPointerHandler::translateMouseEvent(QWindow *window,
     handleEnterLeave(window, currentWindowUnderPointer, globalPos);
 
     if (!discardEvent && mouseEvent.type != QEvent::None) {
-        QWindowSystemInterface::handleMouseEvent(window, device, localPos, globalPos, mouseButtons,
+        QWindowSystemInterface::handleMouseEvent(window, msg.time, device, localPos, globalPos, mouseButtons,
                                                  mouseEvent.button, mouseEvent.type, keyModifiers, source);
     }
 

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

@@ -132,16 +132,28 @@ namespace {
 struct DiRegKeyHandleTraits
 {
     using Type = HKEY;
-    static Type invalidValue()
+    static Type invalidValue() noexcept
     {
         // The setupapi.h functions return INVALID_HANDLE_VALUE when failing to open a registry key
         return reinterpret_cast<HKEY>(INVALID_HANDLE_VALUE);
     }
-    static bool close(Type handle) { return RegCloseKey(handle) == ERROR_SUCCESS; }
+    static bool close(Type handle) noexcept { return RegCloseKey(handle) == ERROR_SUCCESS; }
 };
 
 using DiRegKeyHandle = QUniqueHandle<DiRegKeyHandleTraits>;
 
+struct DevInfoHandleTraits
+{
+    using Type = HDEVINFO;
+    static Type invalidValue() noexcept
+    {
+        return reinterpret_cast<HDEVINFO>(INVALID_HANDLE_VALUE);
+    }
+    static bool close(Type handle) noexcept { return SetupDiDestroyDeviceInfoList(handle) == TRUE; }
+};
+
+using DevInfoHandle = QUniqueHandle<DevInfoHandleTraits>;
+
 }
 
 static void setMonitorDataFromSetupApi(QWindowsScreenData &data,
@@ -191,13 +203,16 @@ static void setMonitorDataFromSetupApi(QWindowsScreenData &data,
         constexpr GUID GUID_DEVINTERFACE_MONITOR = {
             0xe6f07b5f, 0xee97, 0x4a90, { 0xb0, 0x76, 0x33, 0xf5, 0x7b, 0xf4, 0xea, 0xa7 }
         };
-        const HDEVINFO devInfo = SetupDiGetClassDevs(&GUID_DEVINTERFACE_MONITOR, nullptr, nullptr,
-                                                     DIGCF_DEVICEINTERFACE);
+        const DevInfoHandle devInfo{ SetupDiGetClassDevs(
+                &GUID_DEVINTERFACE_MONITOR, nullptr, nullptr, DIGCF_DEVICEINTERFACE) };
+
+        if (!devInfo.isValid())
+            continue;
 
         SP_DEVICE_INTERFACE_DATA deviceInterfaceData{};
         deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);
 
-        if (!SetupDiOpenDeviceInterfaceW(devInfo, deviceName.monitorDevicePath, DIODI_NO_ADD,
+        if (!SetupDiOpenDeviceInterfaceW(devInfo.get(), deviceName.monitorDevicePath, DIODI_NO_ADD,
                                          &deviceInterfaceData)) {
             qCWarning(lcQpaScreen)
                     << u"Unable to open monitor interface to %1:"_s.arg(data.deviceName)
@@ -206,7 +221,7 @@ static void setMonitorDataFromSetupApi(QWindowsScreenData &data,
         }
 
         DWORD requiredSize{ 0 };
-        if (SetupDiGetDeviceInterfaceDetailW(devInfo, &deviceInterfaceData, nullptr, 0,
+        if (SetupDiGetDeviceInterfaceDetailW(devInfo.get(), &deviceInterfaceData, nullptr, 0,
                                              &requiredSize, nullptr)
             || GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
             continue;
@@ -217,7 +232,7 @@ static void setMonitorDataFromSetupApi(QWindowsScreenData &data,
         devicePath->cbSize = sizeof(std::remove_pointer_t<decltype(devicePath)>);
         SP_DEVINFO_DATA deviceInfoData{};
         deviceInfoData.cbSize = sizeof(deviceInfoData);
-        if (!SetupDiGetDeviceInterfaceDetailW(devInfo, &deviceInterfaceData, devicePath,
+        if (!SetupDiGetDeviceInterfaceDetailW(devInfo.get(), &deviceInterfaceData, devicePath,
                                               requiredSize, nullptr, &deviceInfoData)) {
             qCDebug(lcQpaScreen) << u"Unable to get monitor metadata for %1:"_s.arg(data.deviceName)
                                  << QSystemError::windowsString();
@@ -225,7 +240,7 @@ static void setMonitorDataFromSetupApi(QWindowsScreenData &data,
         }
 
         const DiRegKeyHandle edidRegistryKey{ SetupDiOpenDevRegKey(
-                devInfo, &deviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ) };
+                devInfo.get(), &deviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ) };
 
         if (!edidRegistryKey.isValid())
             continue;

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

@@ -13,19 +13,20 @@
 #  include "qwindowssystemtrayicon.h"
 #endif
 #include "qwindowsscreen.h"
+#include "qwindowswindow.h"
 #include <commctrl.h>
 #include <objbase.h>
-#ifndef Q_CC_MINGW
-#  include <commoncontrols.h>
-#endif
+#include <commoncontrols.h>
 #include <shellapi.h>
 
+#include <QtCore/qapplicationstatic.h>
 #include <QtCore/qvariant.h>
 #include <QtCore/qcoreapplication.h>
 #include <QtCore/qdebug.h>
 #include <QtCore/qsysinfo.h>
 #include <QtCore/qcache.h>
 #include <QtCore/qthread.h>
+#include <QtCore/qqueue.h>
 #include <QtCore/qmutex.h>
 #include <QtCore/qwaitcondition.h>
 #include <QtCore/qoperatingsystemversion.h>
@@ -52,10 +53,6 @@
 #   include <winrt/Windows.UI.ViewManagement.h>
 #endif // QT_CONFIG(cpp_winrt)
 
-#if defined(__IImageList_INTERFACE_DEFINED__) && defined(__IID_DEFINED__)
-#  define USE_IIMAGELIST
-#endif
-
 QT_BEGIN_NAMESPACE
 
 using namespace Qt::StringLiterals;
@@ -85,7 +82,11 @@ static inline QColor mixColors(const QColor &c1, const QColor &c2)
 
 enum AccentColorLevel {
     AccentColorDarkest,
+    AccentColorDarker,
+    AccentColorDark,
     AccentColorNormal,
+    AccentColorLight,
+    AccentColorLighter,
     AccentColorLightest
 };
 
@@ -100,6 +101,10 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
 {
     QColor accent;
     QColor accentLight;
+    QColor accentLighter;
+    QColor accentLightest;
+    QColor accentDark;
+    QColor accentDarker;
     QColor accentDarkest;
 
 #if QT_CONFIG(cpp_winrt)
@@ -109,6 +114,10 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
         const auto settings = UISettings();
         accent = getSysColor(settings.GetColorValue(UIColorType::Accent));
         accentLight = getSysColor(settings.GetColorValue(UIColorType::AccentLight1));
+        accentLighter = getSysColor(settings.GetColorValue(UIColorType::AccentLight2));
+        accentLightest = getSysColor(settings.GetColorValue(UIColorType::AccentLight3));
+        accentDark = getSysColor(settings.GetColorValue(UIColorType::AccentDark1));
+        accentDarker = getSysColor(settings.GetColorValue(UIColorType::AccentDark2));
         accentDarkest = getSysColor(settings.GetColorValue(UIColorType::AccentDark3));
     }
 #endif
@@ -128,14 +137,30 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
             return {};
         accent = QColor::fromRgb(abgr.blue(), abgr.green(), abgr.red(), abgr.alpha());
         accentLight = accent.lighter(120);
+        accentLighter = accentLight.lighter(120);
+        accentLightest = accentLighter.lighter(120);
         accentDarkest = accent.darker(120 * 120 * 120);
+        accentDark = accent.darker(120);
+        accentDarker = accentDark.darker(120);
+        accentDarkest = accentDarker.darker(120);
     }
 
-    if (level == AccentColorDarkest)
+    switch (level) {
+    case AccentColorDarkest:
         return accentDarkest;
-    else if (level == AccentColorLightest)
+    case AccentColorDarker:
+        return accentDarker;
+    case AccentColorDark:
+        return accentDark;
+    case AccentColorLight:
         return accentLight;
-    return accent;
+    case AccentColorLighter:
+        return accentLighter;
+    case AccentColorLightest:
+        return accentLightest;
+    default:
+        return accent;
+    }
 }
 
 static inline QColor getSysColor(int index)
@@ -148,107 +173,106 @@ static inline QColor getSysColor(int index)
 // models has been observed to trigger a WM_PAINT on the mainwindow. Suppress the
 // behavior by running it in a thread.
 
-struct QShGetFileInfoParams
-{
-    QShGetFileInfoParams(const QString &fn, DWORD a, SHFILEINFO *i, UINT f, bool *r)
-        : fileName(fn), attributes(a), flags(f), info(i), result(r)
-    { }
-
-    const QString &fileName;
-    const DWORD attributes;
-    const UINT flags;
-    SHFILEINFO *const info;
-    bool *const result;
-};
-
 class QShGetFileInfoThread : public QThread
 {
 public:
-    explicit QShGetFileInfoThread()
-        : QThread(), m_params(nullptr)
+    struct Task
     {
-        connect(this, &QThread::finished, this, &QObject::deleteLater);
+        Task(const QString &fn, DWORD a, UINT f)
+            : fileName(fn), attributes(a), flags(f)
+        {}
+        Q_DISABLE_COPY(Task)
+        ~Task()
+        {
+            DestroyIcon(hIcon);
+            hIcon = 0;
+        }
+        // Request
+        const QString fileName;
+        const DWORD attributes;
+        const UINT flags;
+        // Result
+        HICON hIcon = 0;
+        int iIcon = -1;
+        bool finished = false;
+        bool resultValid() const { return hIcon != 0 && iIcon >= 0 && finished; }
+    };
+
+    QShGetFileInfoThread()
+        : QThread()
+    {
+        start();
+    }
+
+    ~QShGetFileInfoThread()
+    {
+        cancel();
+        wait();
+    }
+
+    QSharedPointer<Task> getNextTask()
+    {
+        QMutexLocker l(&m_waitForTaskMutex);
+        while (!isInterruptionRequested()) {
+            if (!m_taskQueue.isEmpty())
+                return m_taskQueue.dequeue();
+            m_waitForTaskCondition.wait(&m_waitForTaskMutex);
+        }
+        return nullptr;
     }
 
     void run() override
     {
         QComHelper comHelper(COINIT_MULTITHREADED);
 
-        QMutexLocker readyLocker(&m_readyMutex);
-        while (!m_cancelled.loadRelaxed()) {
-            if (!m_params && !m_cancelled.loadRelaxed()
-                && !m_readyCondition.wait(&m_readyMutex, QDeadlineTimer(1000ll)))
-                continue;
-
-            if (m_params) {
-                const QString fileName = m_params->fileName;
+        while (!isInterruptionRequested()) {
+            auto task = getNextTask();
+            if (task) {
                 SHFILEINFO info;
-                const bool result = SHGetFileInfo(reinterpret_cast<const wchar_t *>(fileName.utf16()),
-                                                  m_params->attributes, &info, sizeof(SHFILEINFO),
-                                                  m_params->flags);
-                m_doneMutex.lock();
-                if (!m_cancelled.loadRelaxed()) {
-                    *m_params->result = result;
-                    memcpy(m_params->info, &info, sizeof(SHFILEINFO));
+                const bool result = SHGetFileInfo(reinterpret_cast<const wchar_t *>(task->fileName.utf16()),
+                                                  task->attributes, &info, sizeof(SHFILEINFO),
+                                                  task->flags);
+                if (result) {
+                    task->hIcon = info.hIcon;
+                    task->iIcon = info.iIcon;
                 }
-                m_params = nullptr;
-
+                task->finished = true;
                 m_doneCondition.wakeAll();
-                m_doneMutex.unlock();
             }
         }
     }
 
-    bool runWithParams(QShGetFileInfoParams *params, qint64 timeOutMSecs)
+    void runWithParams(const QSharedPointer<Task> &task,
+                       std::chrono::milliseconds timeout = std::chrono::milliseconds(5000))
     {
+        {
+            QMutexLocker l(&m_waitForTaskMutex);
+            m_taskQueue.enqueue(task);
+            m_waitForTaskCondition.wakeAll();
+        }
+
         QMutexLocker doneLocker(&m_doneMutex);
-
-        m_readyMutex.lock();
-        m_params = params;
-        m_readyCondition.wakeAll();
-        m_readyMutex.unlock();
-
-        return m_doneCondition.wait(&m_doneMutex, QDeadlineTimer(timeOutMSecs));
+        while (!task->finished && !isInterruptionRequested()) {
+            if (!m_doneCondition.wait(&m_doneMutex, QDeadlineTimer(timeout)))
+                return;
+        }
     }
 
     void cancel()
     {
-        QMutexLocker doneLocker(&m_doneMutex);
-        m_cancelled.storeRelaxed(1);
-        m_readyCondition.wakeAll();
+        requestInterruption();
+        m_doneCondition.wakeAll();
+        m_waitForTaskCondition.wakeAll();
     }
 
 private:
-    QShGetFileInfoParams *m_params;
-    QAtomicInt m_cancelled;
-    QWaitCondition m_readyCondition;
+    QQueue<QSharedPointer<Task>> m_taskQueue;
     QWaitCondition m_doneCondition;
-    QMutex m_readyMutex;
+    QWaitCondition m_waitForTaskCondition;
     QMutex m_doneMutex;
+    QMutex m_waitForTaskMutex;
 };
-
-static bool shGetFileInfoBackground(const QString &fileName, DWORD attributes,
-                                    SHFILEINFO *info, UINT flags,
-                                    qint64 timeOutMSecs = 5000)
-{
-    static QShGetFileInfoThread *getFileInfoThread = nullptr;
-    if (!getFileInfoThread) {
-        getFileInfoThread = new QShGetFileInfoThread;
-        getFileInfoThread->start();
-    }
-
-    bool result = false;
-    QShGetFileInfoParams params(fileName, attributes, info, flags, &result);
-    if (!getFileInfoThread->runWithParams(&params, timeOutMSecs)) {
-        // Cancel and reset getFileInfoThread. It'll
-        // be reinitialized the next time we get called.
-        getFileInfoThread->cancel();
-        getFileInfoThread = nullptr;
-        qWarning().noquote() << "SHGetFileInfo() timed out for " << fileName;
-        return false;
-    }
-    return result;
-}
+Q_APPLICATION_STATIC(QShGetFileInfoThread, s_shGetFileInfoThread)
 
 // from QStyle::standardPalette
 static inline QPalette standardPalette()
@@ -277,15 +301,16 @@ static QColor placeHolderColor(QColor textColor)
     This is used when the theme is light mode, and when the theme is dark but the
     application doesn't support dark mode. In the latter case, we need to check.
 */
-static void populateLightSystemBasePalette(QPalette &result)
+void QWindowsTheme::populateLightSystemBasePalette(QPalette &result)
 {
     const QColor background = getSysColor(COLOR_BTNFACE);
     const QColor textColor = getSysColor(COLOR_WINDOWTEXT);
 
-    const QColor accent = qt_accentColor(AccentColorNormal);
+    const QColor accentDark = qt_accentColor(AccentColorDark);
+    const QColor accentDarker = qt_accentColor(AccentColorDarker);
     const QColor accentDarkest = qt_accentColor(AccentColorDarkest);
 
-    const QColor linkColor = accent;
+    const QColor linkColor = accentDarker;
     const QColor btnFace = background;
     const QColor btnHighlight = getSysColor(COLOR_BTNHIGHLIGHT);
 
@@ -304,7 +329,7 @@ static void populateLightSystemBasePalette(QPalette &result)
     result.setColor(QPalette::Midlight, getSysColor(COLOR_3DLIGHT));
     result.setColor(QPalette::Shadow, getSysColor(COLOR_3DDKSHADOW));
     result.setColor(QPalette::HighlightedText, getSysColor(COLOR_HIGHLIGHTTEXT));
-    result.setColor(QPalette::Accent, accent);
+    result.setColor(QPalette::Accent, accentDark); // default accent color for controls on Light mode is AccentDark1
 
     result.setColor(QPalette::Link, linkColor);
     result.setColor(QPalette::LinkVisited, accentDarkest);
@@ -317,7 +342,7 @@ static void populateLightSystemBasePalette(QPalette &result)
         result.setColor(QPalette::Midlight, result.button().color().lighter(110));
 }
 
-static void populateDarkSystemBasePalette(QPalette &result)
+void QWindowsTheme::populateDarkSystemBasePalette(QPalette &result)
 {
     QColor foreground = Qt::white;
     QColor background = QColor(0x1E, 0x1E, 0x1E);
@@ -338,25 +363,27 @@ static void populateDarkSystemBasePalette(QPalette &result)
         // We have to craft a palette from these colors. The settings.UIElementColor(UIElementType) API
         // returns the old system colors, not the dark mode colors. If the background is black (which it
         // usually), then override it with a dark gray instead so that we can go up and down the lightness.
-        foreground = getSysColor(settings.GetColorValue(UIColorType::Foreground));
-        background = [&settings]() -> QColor {
-            auto systemBackground = getSysColor(settings.GetColorValue(UIColorType::Background));
-            if (systemBackground == Qt::black)
-                systemBackground = QColor(0x1E, 0x1E, 0x1E);
-            return systemBackground;
-        }();
-
-        accent = getSysColor(settings.GetColorValue(UIColorType::Accent));
-        accentDark = getSysColor(settings.GetColorValue(UIColorType::AccentDark1));
-        accentDarker = getSysColor(settings.GetColorValue(UIColorType::AccentDark2));
-        accentDarkest = getSysColor(settings.GetColorValue(UIColorType::AccentDark3));
-        accentLight = getSysColor(settings.GetColorValue(UIColorType::AccentLight1));
-        accentLighter = getSysColor(settings.GetColorValue(UIColorType::AccentLight2));
-        accentLightest = getSysColor(settings.GetColorValue(UIColorType::AccentLight3));
+        if (QWindowsTheme::queryColorScheme() == Qt::ColorScheme::Dark) {
+            // the system is actually running in dark mode, so UISettings will give us dark colors
+            foreground = getSysColor(settings.GetColorValue(UIColorType::Foreground));
+            background = [&settings]() -> QColor {
+                auto systemBackground = getSysColor(settings.GetColorValue(UIColorType::Background));
+                if (systemBackground == Qt::black)
+                    systemBackground = QColor(0x1E, 0x1E, 0x1E);
+                return systemBackground;
+            }();
+            accent = qt_accentColor(AccentColorNormal);
+            accentDark = qt_accentColor(AccentColorDark);
+            accentDarker = qt_accentColor(AccentColorDarker);
+            accentDarkest = qt_accentColor(AccentColorDarkest);
+            accentLight = qt_accentColor(AccentColorLight);
+            accentLighter = qt_accentColor(AccentColorLighter);
+            accentLightest = qt_accentColor(AccentColorLightest);
+        }
     }
 #endif
 
-    const QColor linkColor = accent;
+    const QColor linkColor = accentLightest;
     const QColor buttonColor = background.lighter(200);
 
     result.setColor(QPalette::All, QPalette::WindowText, foreground);
@@ -377,12 +404,12 @@ static void populateDarkSystemBasePalette(QPalette &result)
     result.setColor(QPalette::All, QPalette::Highlight, accent);
     result.setColor(QPalette::All, QPalette::HighlightedText, accent.lightness() > 128 ? Qt::black : Qt::white);
     result.setColor(QPalette::All, QPalette::Link, linkColor);
-    result.setColor(QPalette::All, QPalette::LinkVisited, accentDarkest);
+    result.setColor(QPalette::All, QPalette::LinkVisited, accentLighter);
     result.setColor(QPalette::All, QPalette::AlternateBase, accentDarkest);
     result.setColor(QPalette::All, QPalette::ToolTipBase, buttonColor);
     result.setColor(QPalette::All, QPalette::ToolTipText, foreground.darker(120));
     result.setColor(QPalette::All, QPalette::PlaceholderText, placeHolderColor(foreground));
-    result.setColor(QPalette::All, QPalette::Accent, accent);
+    result.setColor(QPalette::All, QPalette::Accent, accentLighter);
 }
 
 static inline QPalette toolTipPalette(const QPalette &systemPalette, bool light)
@@ -474,6 +501,8 @@ QWindowsTheme *QWindowsTheme::m_instance = nullptr;
 QWindowsTheme::QWindowsTheme()
 {
     m_instance = this;
+    s_colorScheme = Qt::ColorScheme::Unknown; // Used inside QWindowsTheme::effectiveColorScheme();
+    s_colorScheme = QWindowsTheme::effectiveColorScheme();
     std::fill(m_fonts, m_fonts + NFonts, nullptr);
     std::fill(m_palettes, m_palettes + NPalettes, nullptr);
     refresh();
@@ -563,9 +592,46 @@ QVariant QWindowsTheme::themeHint(ThemeHint hint) const
 
 Qt::ColorScheme QWindowsTheme::colorScheme() const
 {
+    return QWindowsTheme::effectiveColorScheme();
+}
+
+Qt::ColorScheme QWindowsTheme::effectiveColorScheme()
+{
+    auto integration = QWindowsIntegration::instance();
     if (queryHighContrast())
         return Qt::ColorScheme::Unknown;
-    return QWindowsContext::isDarkMode() ? Qt::ColorScheme::Dark : Qt::ColorScheme::Light;
+    if (s_colorSchemeOverride != Qt::ColorScheme::Unknown)
+        return s_colorSchemeOverride;
+    if (s_colorScheme != Qt::ColorScheme::Unknown)
+        return s_colorScheme;
+    if (!integration->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle))
+        return Qt::ColorScheme::Light;
+    return queryColorScheme();
+}
+
+void QWindowsTheme::requestColorScheme(Qt::ColorScheme scheme)
+{
+    s_colorSchemeOverride = scheme;
+    handleSettingsChanged();
+}
+
+void QWindowsTheme::handleSettingsChanged()
+{
+    const auto oldColorScheme = s_colorScheme;
+    s_colorScheme = Qt::ColorScheme::Unknown; // make effectiveColorScheme() query registry
+    const auto newColorScheme = effectiveColorScheme();
+    const bool colorSchemeChanged = newColorScheme != oldColorScheme;
+    s_colorScheme = newColorScheme;
+    auto integration = QWindowsIntegration::instance();
+    integration->updateApplicationBadge();
+    if (integration->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle)) {
+        QWindowsTheme::instance()->refresh();
+        QWindowSystemInterface::handleThemeChange<QWindowSystemInterface::SynchronousDelivery>();
+    }
+    if (colorSchemeChanged) {
+        for (QWindowsWindow *w : std::as_const(QWindowsContext::instance()->windows()))
+            w->setDarkBorder(s_colorScheme == Qt::ColorScheme::Dark);
+    }
 }
 
 void QWindowsTheme::clearPalettes()
@@ -579,17 +645,17 @@ void QWindowsTheme::refreshPalettes()
     if (!QGuiApplication::desktopSettingsAware())
         return;
     const bool light =
-        !QWindowsContext::isDarkMode()
+        effectiveColorScheme() != Qt::ColorScheme::Dark
         || !QWindowsIntegration::instance()->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle);
     clearPalettes();
-    m_palettes[SystemPalette] = new QPalette(QWindowsTheme::systemPalette(light ? Qt::ColorScheme::Light : Qt::ColorScheme::Dark));
+    m_palettes[SystemPalette] = new QPalette(QWindowsTheme::systemPalette(s_colorScheme));
     m_palettes[ToolTipPalette] = new QPalette(toolTipPalette(*m_palettes[SystemPalette], light));
     m_palettes[MenuPalette] = new QPalette(menuPalette(*m_palettes[SystemPalette], light));
     m_palettes[MenuBarPalette] = menuBarPalette(*m_palettes[MenuPalette], light);
     if (!light) {
         m_palettes[CheckBoxPalette] = new QPalette(*m_palettes[SystemPalette]);
         m_palettes[CheckBoxPalette]->setColor(QPalette::Active, QPalette::Base, qt_accentColor(AccentColorNormal));
-        m_palettes[CheckBoxPalette]->setColor(QPalette::Active, QPalette::Button, qt_accentColor(AccentColorLightest));
+        m_palettes[CheckBoxPalette]->setColor(QPalette::Active, QPalette::Button, qt_accentColor(AccentColorLighter));
         m_palettes[CheckBoxPalette]->setColor(QPalette::Inactive, QPalette::Base, qt_accentColor(AccentColorDarkest));
         m_palettes[RadioButtonPalette] = new QPalette(*m_palettes[CheckBoxPalette]);
     }
@@ -600,15 +666,15 @@ QPalette QWindowsTheme::systemPalette(Qt::ColorScheme colorScheme)
     QPalette result = standardPalette();
 
     switch (colorScheme) {
+    case Qt::ColorScheme::Unknown:
+        // when a high-contrast theme is active or when we fail to read, assume light
+        Q_FALLTHROUGH();
     case Qt::ColorScheme::Light:
         populateLightSystemBasePalette(result);
         break;
     case Qt::ColorScheme::Dark:
         populateDarkSystemBasePalette(result);
         break;
-    default:
-        qFatal("Unknown color scheme");
-        break;
     }
 
     if (result.window() != result.base()) {
@@ -750,11 +816,7 @@ void QWindowsTheme::refreshIconPixmapSizes()
         fileIconSizes[LargeFileIcon] + fileIconSizes[LargeFileIcon] / 2;
     fileIconSizes[JumboFileIcon] = 8 * fileIconSizes[LargeFileIcon]; // empirical, has not been observed to work
 
-#ifdef USE_IIMAGELIST
     int *availEnd = fileIconSizes + JumboFileIcon + 1;
-#else
-    int *availEnd = fileIconSizes + LargeFileIcon + 1;
-#endif // USE_IIMAGELIST
     m_fileIconSizes = QAbstractFileIconEngine::toSizeList(fileIconSizes, availEnd);
     qCDebug(lcQpaWindow) << __FUNCTION__ << m_fileIconSizes;
 }
@@ -781,7 +843,6 @@ QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSiz
 {
     int resourceId = -1;
     SHSTOCKICONID stockId = SIID_INVALID;
-    UINT stockFlags = 0;
     LPCTSTR iconName = nullptr;
     switch (sp) {
     case DriveCDIcon:
@@ -805,14 +866,12 @@ QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSiz
         resourceId = 7;
         break;
     case FileLinkIcon:
-        stockFlags = SHGSI_LINKOVERLAY;
         Q_FALLTHROUGH();
     case FileIcon:
         stockId = SIID_DOCNOASSOC;
         resourceId = 1;
         break;
     case DirLinkIcon:
-        stockFlags = SHGSI_LINKOVERLAY;
         Q_FALLTHROUGH();
     case DirClosedIcon:
     case DirIcon:
@@ -826,7 +885,6 @@ QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSiz
         resourceId = 16;
         break;
     case DirLinkOpenIcon:
-        stockFlags = SHGSI_LINKOVERLAY;
         Q_FALLTHROUGH();
     case DirOpenIcon:
         stockId = SIID_FOLDEROPEN;
@@ -866,18 +924,34 @@ QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSiz
         break;
     }
 
+    // Even with SHGSI_LINKOVERLAY flag set, loaded Icon with SHDefExtractIcon doesn't have
+    // any overlay, so we avoid SHGSI_LINKOVERLAY flag and draw it manually (QTBUG-131843)
+    const auto drawLinkOverlayIconIfNeeded = [](StandardPixmap sp, QPixmap &pixmap, QSizeF pixmapSize) {
+        if (sp == FileLinkIcon || sp == DirLinkIcon || sp == DirLinkOpenIcon) {
+            QPainter painter(&pixmap);
+            const QSizeF linkSize = pixmapSize / (pixmapSize.height() >= 48 ? 3 : 2);
+            static constexpr auto LinkOverlayIconId = 16769;
+            const QPixmap link = loadIconFromShell32(LinkOverlayIconId, linkSize.toSize());
+            const int yPos = pixmap.height() - link.size().height();
+            painter.drawPixmap(0, yPos, int(linkSize.width()), int(linkSize.height()), link);
+        }
+    };
+
     if (stockId != SIID_INVALID) {
         SHSTOCKICONINFO iconInfo;
         memset(&iconInfo, 0, sizeof(iconInfo));
         iconInfo.cbSize = sizeof(iconInfo);
-        stockFlags |= SHGSI_ICONLOCATION;
+        constexpr UINT stockFlags = SHGSI_ICONLOCATION;
         if (SHGetStockIconInfo(stockId, stockFlags, &iconInfo) == S_OK) {
             const auto iconSize = pixmapSize.width();
             HICON icon;
             if (SHDefExtractIcon(iconInfo.szPath, iconInfo.iIcon, 0, &icon, nullptr, iconSize) == S_OK) {
                 QPixmap pixmap = qt_pixmapFromWinHICON(icon);
                 DestroyIcon(icon);
-                return pixmap;
+                if (!pixmap.isNull()) {
+                    drawLinkOverlayIconIfNeeded(sp, pixmap, pixmap.size());
+                    return pixmap;
+                }
             }
         }
     }
@@ -885,11 +959,7 @@ QPixmap QWindowsTheme::standardPixmap(StandardPixmap sp, const QSizeF &pixmapSiz
     if (resourceId != -1) {
         QPixmap pixmap = loadIconFromShell32(resourceId, pixmapSize);
         if (!pixmap.isNull()) {
-            if (sp == FileLinkIcon || sp == DirLinkIcon || sp == DirLinkOpenIcon) {
-                QPainter painter(&pixmap);
-                QPixmap link = loadIconFromShell32(30, pixmapSize);
-                painter.drawPixmap(0, 0, int(pixmapSize.width()), int(pixmapSize.height()), link);
-            }
+            drawLinkOverlayIconIfNeeded(sp, pixmap, pixmapSize);
             return pixmap;
         }
     }
@@ -948,10 +1018,10 @@ public:
 
 // Shell image list helper functions.
 
-static QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info)
+static QPixmap pixmapFromShellImageList(int iImageList, int iIcon)
 {
     QPixmap result;
-#ifdef USE_IIMAGELIST
+
     // For MinGW:
     static const IID iID_IImageList = {0x46eb5926, 0x582e, 0x4017, {0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x9, 0x50}};
 
@@ -960,16 +1030,13 @@ static QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info)
     if (hr != S_OK)
         return result;
     HICON hIcon;
-    hr = imageList->GetIcon(info.iIcon, ILD_TRANSPARENT, &hIcon);
+    hr = imageList->GetIcon(iIcon, ILD_TRANSPARENT, &hIcon);
     if (hr == S_OK) {
         result = qt_pixmapFromWinHICON(hIcon);
         DestroyIcon(hIcon);
     }
     imageList->Release();
-#else
-    Q_UNUSED(iImageList);
-    Q_UNUSED(info);
-#endif // USE_IIMAGELIST
+
     return result;
 }
 
@@ -1021,13 +1088,9 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
     const int width = int(size.width());
     const int iconSize = width > fileIconSizes[SmallFileIcon] ? SHGFI_LARGEICON : SHGFI_SMALLICON;
     const int requestedImageListSize =
-#ifdef USE_IIMAGELIST
         width > fileIconSizes[ExtraLargeFileIcon]
             ? sHIL_JUMBO
             : (width > fileIconSizes[LargeFileIcon] ? sHIL_EXTRALARGE : 0);
-#else
-        0;
-#endif // !USE_IIMAGELIST
     bool cacheableDirIcon = fileInfo().isDir() && !fileInfo().isRoot();
     if (cacheableDirIcon) {
         QMutexLocker locker(&mx);
@@ -1043,7 +1106,6 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
         }
     }
 
-    SHFILEINFO info;
     unsigned int flags = SHGFI_ICON | iconSize | SHGFI_SYSICONINDEX | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX;
     DWORD attributes = 0;
     QString path = filePath;
@@ -1055,43 +1117,43 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
         flags |= SHGFI_USEFILEATTRIBUTES;
         attributes |= FILE_ATTRIBUTE_NORMAL;
     }
-    const bool val = shGetFileInfoBackground(path, attributes, &info, flags);
-
+    auto task = QSharedPointer<QShGetFileInfoThread::Task>(
+            new QShGetFileInfoThread::Task(path, attributes, flags));
+    s_shGetFileInfoThread()->runWithParams(task);
     // Even if GetFileInfo returns a valid result, hIcon can be empty in some cases
-    if (val && info.hIcon) {
+    if (task->resultValid()) {
         QString key;
         if (cacheableDirIcon) {
             if (useDefaultFolderIcon && defaultFolderIIcon < 0)
-                defaultFolderIIcon = info.iIcon;
+                defaultFolderIIcon = task->iIcon;
 
             //using the unique icon index provided by windows save us from duplicate keys
-            key = dirIconPixmapCacheKey(info.iIcon, iconSize, requestedImageListSize);
+            key = dirIconPixmapCacheKey(task->iIcon, iconSize, requestedImageListSize);
             QPixmapCache::find(key, &pixmap);
             if (!pixmap.isNull()) {
                 QMutexLocker locker(&mx);
-                dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon));
+                dirIconEntryCache.insert(filePath, FakePointer<int>::create(task->iIcon));
             }
         }
 
         if (pixmap.isNull()) {
             if (requestedImageListSize) {
-                pixmap = pixmapFromShellImageList(requestedImageListSize, info);
+                pixmap = pixmapFromShellImageList(requestedImageListSize, task->iIcon);
                 if (pixmap.isNull() && requestedImageListSize == sHIL_JUMBO)
-                    pixmap = pixmapFromShellImageList(sHIL_EXTRALARGE, info);
+                    pixmap = pixmapFromShellImageList(sHIL_EXTRALARGE, task->iIcon);
             }
             if (pixmap.isNull())
-                pixmap = qt_pixmapFromWinHICON(info.hIcon);
+                pixmap = qt_pixmapFromWinHICON(task->hIcon);
             if (!pixmap.isNull()) {
                 if (cacheableDirIcon) {
                     QMutexLocker locker(&mx);
                     QPixmapCache::insert(key, pixmap);
-                    dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon));
+                    dirIconEntryCache.insert(filePath, FakePointer<int>::create(task->iIcon));
                 }
             } else {
                 qWarning("QWindowsTheme::fileIconPixmap() no icon found");
             }
         }
-        DestroyIcon(info.hIcon);
     }
 
     return pixmap;
@@ -1131,14 +1193,16 @@ bool QWindowsTheme::useNativeMenus()
     return result;
 }
 
-bool QWindowsTheme::queryDarkMode()
+Qt::ColorScheme QWindowsTheme::queryColorScheme()
 {
-    if (queryHighContrast()) {
-        return false;
-    }
-    const auto setting = QWinRegistryKey(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)")
-                         .dwordValue(L"AppsUseLightTheme");
-    return setting.second && setting.first == 0;
+    if (queryHighContrast())
+        return Qt::ColorScheme::Unknown;
+
+    QWinRegistryKey personalizeKey{
+        HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)"
+    };
+    const bool useDarkTheme = personalizeKey.value<DWORD>(L"AppsUseLightTheme") == 0;
+    return useDarkTheme ? Qt::ColorScheme::Dark : Qt::ColorScheme::Light;
 }
 
 bool QWindowsTheme::queryHighContrast()

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

@@ -5,6 +5,7 @@
 
 #include "qwindowswindow.h"
 #include "qwindowscontext.h"
+#include "qwindowstheme.h"
 #if QT_CONFIG(draganddrop)
 #  include "qwindowsdrag.h"
 #endif
@@ -35,6 +36,7 @@
 
 #include <QtCore/qdebug.h>
 #include <QtCore/qlibraryinfo.h>
+#include <QtCore/qoperatingsystemversion.h>
 
 #include <dwmapi.h>
 
@@ -866,7 +868,8 @@ static inline bool shouldApplyDarkFrame(const QWindow *w)
 {
     if (!w->isTopLevel() || w->flags().testFlag(Qt::FramelessWindowHint))
         return false;
-    // the application has explicitly opted out of dark frames
+    
+    // the user of the application has explicitly opted out of dark frames
     if (!QWindowsIntegration::instance()->darkModeHandling().testFlag(QWindowsApplication::DarkModeWindowFrames))
         return false;
 
@@ -946,7 +949,7 @@ QWindowsWindowData
         return result;
     }
 
-    if (QWindowsContext::isDarkMode() && shouldApplyDarkFrame(w))
+    if (QWindowsTheme::instance()->colorScheme() == Qt::ColorScheme::Dark && shouldApplyDarkFrame(w))
         QWindowsWindow::setDarkBorderToWindow(result.hwnd, true);
 
     if (mirrorParentWidth != 0) {
@@ -1386,16 +1389,24 @@ QWindowsForeignWindow::QWindowsForeignWindow(QWindow *window, HWND hwnd)
         setParent(QPlatformWindow::parent());
 }
 
+QWindowsForeignWindow::~QWindowsForeignWindow()
+{
+    if (QPlatformWindow::parent())
+        setParent(nullptr);
+}
+
 void QWindowsForeignWindow::setParent(const QPlatformWindow *newParentWindow)
 {
     const bool wasTopLevel = isTopLevel_sys();
     const HWND newParent = newParentWindow ? reinterpret_cast<HWND>(newParentWindow->winId()) : HWND(nullptr);
     const bool isTopLevel = !newParent;
     const DWORD oldStyle = style();
+
     qCDebug(lcQpaWindow) << __FUNCTION__ << window() << "newParent="
         << newParentWindow << newParent << "oldStyle=" << debugWinStyle(oldStyle);
-    SetParent(m_hwnd, newParent);
-    if (wasTopLevel != isTopLevel) { // Top level window flags need to be set/cleared manually.
+
+    auto updateWindowFlags = [&]{
+        // Top level window flags need to be set/cleared manually.
         DWORD newStyle = oldStyle;
         if (isTopLevel) {
             newStyle = m_topLevelStyle;
@@ -1405,6 +1416,20 @@ void QWindowsForeignWindow::setParent(const QPlatformWindow *newParentWindow)
             newStyle |= WS_CHILD;
         }
         SetWindowLongPtr(m_hwnd, GWL_STYLE, newStyle);
+    };
+
+    if (wasTopLevel && !isTopLevel) {
+        // Becoming a child window requires the style
+        // flags to be updated before reparenting.
+        updateWindowFlags();
+    }
+
+    SetParent(m_hwnd, newParent);
+
+    if (!wasTopLevel && isTopLevel) {
+        // Becoming a top level window requires the style
+        // flags to be updated after reparenting.
+        updateWindowFlags();
     }
 }
 
@@ -2176,11 +2201,8 @@ void QWindowsWindow::setGeometry(const QRect &rectIn)
         const QMargins margins = frameMargins();
         rect.moveTopLeft(rect.topLeft() + QPoint(margins.left(), margins.top()));
     }
-
     if (m_windowState & Qt::WindowMinimized)
         m_data.geometry = rect; // Otherwise set by handleGeometryChange() triggered by event.
-    else
-        setWindowState(Qt::WindowNoState);// Update window state to WindowNoState unless minimized
 
     if (m_data.hwnd) {
         // A ResizeEvent with resulting geometry will be sent. If we cannot
@@ -2506,6 +2528,8 @@ void QWindowsWindow::handleWindowStateChange(Qt::WindowStates state)
             GetWindowPlacement(m_data.hwnd, &windowPlacement);
             const RECT geometry = RECTfromQRect(m_data.restoreGeometry);
             windowPlacement.rcNormalPosition = geometry;
+            correctWindowPlacement(windowPlacement);
+
             // Even if the window is hidden, windowPlacement's showCmd is not SW_HIDE, so change it
             // manually to avoid unhiding a hidden window with the subsequent call to
             // SetWindowPlacement().
@@ -2536,6 +2560,65 @@ void QWindowsWindow::handleWindowStateChange(Qt::WindowStates state)
     }
 }
 
+// Apply corrections to window placement in Windows 10
+// Related to task bar on top or left.
+
+inline bool QWindowsBaseWindow::hasMaximumHeight() const
+{
+    return window()->maximumHeight() != QWINDOWSIZE_MAX;
+}
+
+inline bool QWindowsBaseWindow::hasMaximumWidth() const
+{
+    return window()->maximumWidth() != QWINDOWSIZE_MAX;
+}
+
+inline bool QWindowsBaseWindow::hasMaximumSize() const
+{
+    return hasMaximumHeight() || hasMaximumWidth();
+}
+
+void QWindowsWindow::correctWindowPlacement(WINDOWPLACEMENT &windowPlacement)
+{
+    static const auto windows11 = QOperatingSystemVersion::Windows11_21H2;
+    static const bool isWindows10 = QOperatingSystemVersion::current() < windows11;
+    if (!isWindows10)
+        return;
+
+    // Correct normal position by placement offset on Windows 10
+    // (where task bar can be on any side of the screen)
+    const QPoint offset = windowPlacementOffset(m_data.hwnd, m_data.restoreGeometry.topLeft());
+    windowPlacement.rcNormalPosition = RECTfromQRect(m_data.restoreGeometry.translated(-offset));
+    qCDebug(lcQpaWindow) << "Corrected normal position by" << -offset;
+
+    // A bug in windows 10 grows
+    // - ptMaxPosition.x by the task bar's width, if it's on the left
+    // - ptMaxPosition.y by the task bar's height, if it's on the top
+    // each time GetWindowPlacement() is called.
+    // The offset of the screen's left edge (as per frameMargins_sys().left()) is ignored.
+    // => Check for windows 10 and correct.
+    if (hasMaximumSize()) {
+        const QMargins margins = frameMargins_sys();
+        const QPoint topLeft = window()->screen()->geometry().topLeft();
+        windowPlacement.ptMaxPosition = POINT{ topLeft.x() - margins.left(), topLeft.y() };
+        qCDebug(lcQpaWindow) << "Window has maximum size. Corrected topLeft by"
+                             << -margins.left();
+
+        // If there is a placement offset correct width/height unless restricted,
+        // in order to fit window onto the screen.
+        if (offset.x() > 0 && !hasMaximumWidth()) {
+            const int adjust = offset.x() / window()->devicePixelRatio();
+            window()->setWidth(window()->width() - adjust);
+            qCDebug(lcQpaWindow) << "Width shortened by" << adjust << "logical pixels.";
+        }
+        if (offset.y() > 0 && !hasMaximumHeight()) {
+            const int adjust = offset.y() / window()->devicePixelRatio();
+            window()->setHeight(window()->height() - adjust);
+            qCDebug(lcQpaWindow) << "Height shortened by" << adjust << "logical pixels.";
+        }
+    }
+}
+
 void QWindowsWindow::updateRestoreGeometry()
 {
     m_data.restoreGeometry = normalFrameGeometry(m_data.hwnd);
@@ -2680,8 +2763,24 @@ void QWindowsWindow::setWindowState_sys(Qt::WindowStates newState)
             setFlag(WithinMaximize);
             if (newState & Qt::WindowFullScreen)
                 setFlag(MaximizeToFullScreen);
-            ShowWindow(m_data.hwnd,
-                       (newState & Qt::WindowMaximized) ? SW_MAXIMIZE : SW_SHOWNOACTIVATE);
+            if (m_data.flags & Qt::FramelessWindowHint) {
+                if (newState == Qt::WindowNoState) {
+                    const QRect &rect = m_savedFrameGeometry;
+                    MoveWindow(m_data.hwnd, rect.x(), rect.y(), rect.width(), rect.height(), true);
+                } else {
+                    HMONITOR monitor = MonitorFromWindow(m_data.hwnd, MONITOR_DEFAULTTONEAREST);
+                    MONITORINFO monitorInfo = {};
+                    monitorInfo.cbSize = sizeof(MONITORINFO);
+                    GetMonitorInfo(monitor, &monitorInfo);
+                    const RECT &rect = monitorInfo.rcWork;
+                    m_savedFrameGeometry = geometry();
+                    MoveWindow(m_data.hwnd, rect.left, rect.top,
+                               rect.right - rect.left, rect.bottom - rect.top, true);
+                }
+            } else {
+                ShowWindow(m_data.hwnd,
+                           (newState & Qt::WindowMaximized) ? SW_MAXIMIZE : SW_SHOWNOACTIVATE);
+            }
             clearFlag(WithinMaximize);
             clearFlag(MaximizeToFullScreen);
         } else if (visible && (oldState & newState & Qt::WindowMinimized)) {
@@ -2720,7 +2819,7 @@ bool QWindowsWindow::windowEvent(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::ApplicationPaletteChange:
-        setDarkBorder(QWindowsContext::isDarkMode());
+        setDarkBorder(QWindowsTheme::instance()->colorScheme() == Qt::ColorScheme::Dark);
         break;
     case QEvent::WindowBlocked: // Blocked by another modal window.
         setEnabled(false);
@@ -3316,17 +3415,6 @@ enum : WORD {
     DwmwaUseImmersiveDarkModeBefore20h1 = 19
 };
 
-static bool queryDarkBorder(HWND hwnd)
-{
-    BOOL result = FALSE;
-    const bool ok =
-        SUCCEEDED(DwmGetWindowAttribute(hwnd, DwmwaUseImmersiveDarkMode, &result, sizeof(result)))
-        || SUCCEEDED(DwmGetWindowAttribute(hwnd, DwmwaUseImmersiveDarkModeBefore20h1, &result, sizeof(result)));
-    if (!ok)
-        qCWarning(lcQpaWindow, "%s: Unable to retrieve dark window border setting.", __FUNCTION__);
-    return result == TRUE;
-}
-
 bool QWindowsWindow::setDarkBorderToWindow(HWND hwnd, bool d)
 {
     const BOOL darkBorder = d ? TRUE : FALSE;
@@ -3342,8 +3430,6 @@ void QWindowsWindow::setDarkBorder(bool d)
 {
     // respect explicit opt-out and incompatible palettes or styles
     d = d && shouldApplyDarkFrame(window());
-    if (queryDarkBorder(m_data.hwnd) == d)
-        return;
 
     setDarkBorderToWindow(m_data.hwnd, d);
 }

qtbase/src/plugins/platforms/windows/uiautomation/qwindowsuiaaccessibility.cpp

@@ -0,0 +1,170 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include <QtGui/qtguiglobal.h>
+#if QT_CONFIG(accessibility)
+
+#include "qwindowsuiaaccessibility.h"
+#include "qwindowsuiautomation.h"
+#include "qwindowsuiamainprovider.h"
+#include "qwindowsuiautils.h"
+
+#include <QtGui/qaccessible.h>
+#include <QtGui/qwindow.h>
+#include <QtGui/qguiapplication.h>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtCore/qt_windows.h>
+#include <qpa/qplatformintegration.h>
+#include "qwindowsuiawrapper_p.h"
+#include "qwindowsuiawrapper.cpp"
+
+#include <QtCore/private/qwinregistry_p.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QWindowsUiAutomation;
+using namespace Qt::Literals::StringLiterals;
+
+bool QWindowsUiaAccessibility::m_accessibleActive = false;
+
+QWindowsUiaAccessibility::QWindowsUiaAccessibility()
+{
+}
+
+QWindowsUiaAccessibility::~QWindowsUiaAccessibility()
+{
+}
+
+// Handles UI Automation window messages.
+bool QWindowsUiaAccessibility::handleWmGetObject(HWND hwnd, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+    // Start handling accessibility internally
+    QGuiApplicationPrivate::platformIntegration()->accessibility()->setActive(true);
+    m_accessibleActive = true;
+
+    // Ignoring all requests while starting up / shutting down
+    if (QCoreApplication::startingUp() || QCoreApplication::closingDown())
+        return false;
+
+    if (QWindow *window = QWindowsContext::instance()->findWindow(hwnd)) {
+        if (QAccessibleInterface *accessible = window->accessibleRoot()) {
+            auto provider = QWindowsUiaMainProvider::providerForAccessible(accessible);
+            *lResult = QWindowsUiaWrapper::instance()->returnRawElementProvider(hwnd, wParam, lParam, provider.Get());
+            return true;
+        }
+    }
+    return false;
+}
+
+// Retrieve sound name by checking the icon property of a message box
+// should it be the event object.
+static QString alertSound(const QObject *object)
+{
+    if (object->inherits("QMessageBox")) {
+        enum MessageBoxIcon { // Keep in sync with QMessageBox::Icon
+            Information = 1,
+            Warning = 2,
+            Critical = 3
+        };
+        switch (object->property("icon").toInt()) {
+        case Information:
+            return QStringLiteral("SystemAsterisk");
+        case Warning:
+            return QStringLiteral("SystemExclamation");
+        case Critical:
+            return QStringLiteral("SystemHand");
+        }
+        return QString();
+    }
+    return QStringLiteral("SystemAsterisk");
+}
+
+static QString soundFileName(const QString &soundName)
+{
+    const QString key = "AppEvents\\Schemes\\Apps\\.Default\\"_L1
+        + soundName + "\\.Current"_L1;
+    return QWinRegistryKey(HKEY_CURRENT_USER, key).stringValue(L"");
+}
+
+static void playSystemSound(const QString &soundName)
+{
+    if (!soundName.isEmpty() && !soundFileName(soundName).isEmpty()) {
+        PlaySound(reinterpret_cast<const wchar_t *>(soundName.utf16()), nullptr,
+                  SND_ALIAS | SND_ASYNC | SND_NODEFAULT | SND_NOWAIT);
+    }
+}
+
+// Handles accessibility update notifications.
+void QWindowsUiaAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
+{
+    if (!event)
+        return;
+
+    // Always handle system sound events
+    switch (event->type()) {
+        case QAccessible::PopupMenuStart:
+            playSystemSound(QStringLiteral("MenuPopup"));
+            break;
+        case QAccessible::MenuCommand:
+            playSystemSound(QStringLiteral("MenuCommand"));
+            break;
+        case QAccessible::Alert:
+            playSystemSound(alertSound(event->object()));
+            break;
+        default:
+            break;
+    }
+
+    // Ignore events sent before the first UI Automation
+    // request or while QAccessible is being activated.
+    if (!m_accessibleActive)
+        return;
+
+    QAccessibleInterface *accessible = event->accessibleInterface();
+    if (!isActive() || !accessible || !accessible->isValid())
+        return;
+
+    // Ensures QWindowsUiaWrapper is properly initialized.
+    if (!QWindowsUiaWrapper::instance()->ready())
+        return;
+
+    // No need to do anything when nobody is listening.
+    if (!QWindowsUiaWrapper::instance()->clientsAreListening())
+        return;
+
+    switch (event->type()) {
+    case QAccessible::Announcement:
+        QWindowsUiaMainProvider::raiseNotification(static_cast<QAccessibleAnnouncementEvent *>(event));
+        break;
+    case QAccessible::Focus:
+        QWindowsUiaMainProvider::notifyFocusChange(event);
+        break;
+    case QAccessible::StateChanged:
+        QWindowsUiaMainProvider::notifyStateChange(static_cast<QAccessibleStateChangeEvent *>(event));
+        break;
+    case QAccessible::ValueChanged:
+        QWindowsUiaMainProvider::notifyValueChange(static_cast<QAccessibleValueChangeEvent *>(event));
+        break;
+    case QAccessible::NameChanged:
+        QWindowsUiaMainProvider::notifyNameChange(event);
+        break;
+    case QAccessible::SelectionAdd:
+        QWindowsUiaMainProvider::notifySelectionChange(event);
+        break;
+    case QAccessible::TextAttributeChanged:
+    case QAccessible::TextColumnChanged:
+    case QAccessible::TextInserted:
+    case QAccessible::TextRemoved:
+    case QAccessible::TextUpdated:
+    case QAccessible::TextSelectionChanged:
+    case QAccessible::TextCaretMoved:
+        QWindowsUiaMainProvider::notifyTextChange(event);
+        break;
+    default:
+        break;
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_CONFIG(accessibility)

qtbase/src/plugins/platforms/windows/uiautomation/qwindowsuiamainprovider.cpp

@@ -0,0 +1,843 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include <QtGui/qtguiglobal.h>
+#if QT_CONFIG(accessibility)
+
+#include "qwindowsuiamainprovider.h"
+#include "qwindowsuiavalueprovider.h"
+#include "qwindowsuiarangevalueprovider.h"
+#include "qwindowsuiatextprovider.h"
+#include "qwindowsuiatoggleprovider.h"
+#include "qwindowsuiainvokeprovider.h"
+#include "qwindowsuiaselectionprovider.h"
+#include "qwindowsuiaselectionitemprovider.h"
+#include "qwindowsuiatableprovider.h"
+#include "qwindowsuiatableitemprovider.h"
+#include "qwindowsuiagridprovider.h"
+#include "qwindowsuiagriditemprovider.h"
+#include "qwindowsuiawindowprovider.h"
+#include "qwindowsuiaexpandcollapseprovider.h"
+#include "qwindowscontext.h"
+#include "qwindowsuiautils.h"
+#include "qwindowsuiaprovidercache.h"
+#include "qwindowsuiawrapper_p.h"
+
+#include <QtCore/qloggingcategory.h>
+#include <QtGui/private/qaccessiblebridgeutils_p.h>
+#include <QtGui/qaccessible.h>
+#include <QtGui/qguiapplication.h>
+#include <QtGui/qwindow.h>
+#include <qpa/qplatforminputcontextfactory_p.h>
+#include <QtCore/private/qcomvariant_p.h>
+
+#if !defined(Q_CC_BOR) && !defined (Q_CC_GNU)
+#include <comdef.h>
+#endif
+
+#include <QtCore/qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QWindowsUiAutomation;
+
+// Returns a cached instance of the provider for a specific accessible interface.
+ComPtr<QWindowsUiaMainProvider> QWindowsUiaMainProvider::providerForAccessible(QAccessibleInterface *accessible)
+{
+    if (!accessible)
+        return nullptr;
+
+    QAccessible::Id id = QAccessible::uniqueId(accessible);
+    QWindowsUiaProviderCache *providerCache = QWindowsUiaProviderCache::instance();
+    ComPtr<QWindowsUiaMainProvider> provider = providerCache->providerForId(id);
+
+    if (!provider) {
+        provider = makeComObject<QWindowsUiaMainProvider>(accessible);
+        providerCache->insert(id, provider.Get()); // Cache holds weak references
+    }
+    return provider;
+}
+
+QWindowsUiaMainProvider::QWindowsUiaMainProvider(QAccessibleInterface *a)
+    : QWindowsUiaBaseProvider(QAccessible::uniqueId(a))
+{
+}
+
+QWindowsUiaMainProvider::~QWindowsUiaMainProvider()
+{
+}
+
+void QWindowsUiaMainProvider::notifyFocusChange(QAccessibleEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        // If this is a complex element, raise event for the focused child instead.
+        if (accessible->childCount()) {
+            if (QAccessibleInterface *child = accessible->focusChild())
+                accessible = child;
+        }
+        if (auto provider = providerForAccessible(accessible))
+            QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_AutomationFocusChangedEventId);
+    }
+}
+
+void QWindowsUiaMainProvider::notifyStateChange(QAccessibleStateChangeEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        if (event->changedStates().checked || event->changedStates().checkStateMixed) {
+           // Notifies states changes in checkboxes.
+           if (accessible->role() == QAccessible::CheckBox) {
+                if (auto provider = providerForAccessible(accessible)) {
+                    long toggleState = ToggleState_Off;
+                    if (accessible->state().checked)
+                        toggleState = accessible->state().checkStateMixed ? ToggleState_Indeterminate : ToggleState_On;
+
+                    QComVariant oldVal;
+                    QComVariant newVal{toggleState};
+                    QWindowsUiaWrapper::instance()->raiseAutomationPropertyChangedEvent(
+                            provider.Get(), UIA_ToggleToggleStatePropertyId, oldVal.get(), newVal.get());
+                }
+            }
+        }
+        if (event->changedStates().active) {
+            if (accessible->role() == QAccessible::Window) {
+                // Notifies window opened/closed.
+                if (auto provider = providerForAccessible(accessible)) {
+                    if (accessible->state().active) {
+                        QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_Window_WindowOpenedEventId);
+                        if (QAccessibleInterface *focused = accessible->focusChild()) {
+                            if (auto focusedProvider = providerForAccessible(focused)) {
+                                QWindowsUiaWrapper::instance()->raiseAutomationEvent(focusedProvider.Get(),
+                                                        UIA_AutomationFocusChangedEventId);
+                            }
+                        }
+                    } else {
+                        QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_Window_WindowClosedEventId);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void QWindowsUiaMainProvider::notifyValueChange(QAccessibleValueChangeEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        if (accessible->role() == QAccessible::ComboBox && accessible->childCount() > 0) {
+            QAccessibleInterface *listacc = accessible->child(0);
+            if (listacc && listacc->role() == QAccessible::List) {
+                int count = listacc->childCount();
+                for (int i = 0; i < count; ++i) {
+                    QAccessibleInterface *item = listacc->child(i);
+                    if (item && item->isValid() && item->text(QAccessible::Name) == event->value()) {
+                        if (!item->state().selected) {
+                            if (QAccessibleActionInterface *actionInterface = item->actionInterface())
+                                actionInterface->doAction(QAccessibleActionInterface::toggleAction());
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        if (event->value().typeId() == QMetaType::QString) {
+            if (auto provider = providerForAccessible(accessible)) {
+                // Notifies changes in string values.
+                const QComVariant oldVal;
+                const QComVariant newVal{ event->value().toString() };
+                QWindowsUiaWrapper::instance()->raiseAutomationPropertyChangedEvent(provider.Get(), UIA_ValueValuePropertyId,
+                                                       oldVal.get(), newVal.get());
+            }
+        } else if (QAccessibleValueInterface *valueInterface = accessible->valueInterface()) {
+            if (auto provider = providerForAccessible(accessible)) {
+                // Notifies changes in values of controls supporting the value interface.
+                const QComVariant oldVal;
+                const QComVariant newVal{ valueInterface->currentValue().toDouble() };
+                QWindowsUiaWrapper::instance()->raiseAutomationPropertyChangedEvent(
+                        provider.Get(), UIA_RangeValueValuePropertyId, oldVal.get(), newVal.get());
+            }
+        }
+    }
+}
+
+void QWindowsUiaMainProvider::notifyNameChange(QAccessibleEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        // Restrict notification to combo boxes, which need it for accessibility,
+        // in order to avoid slowdowns with unnecessary notifications.
+        if (accessible->role() == QAccessible::ComboBox) {
+            if (auto provider = providerForAccessible(accessible)) {
+                QComVariant oldVal;
+                QComVariant newVal{ accessible->text(QAccessible::Name) };
+                QWindowsUiaWrapper::instance()->raiseAutomationPropertyChangedEvent(provider.Get(), UIA_NamePropertyId,
+                                                       oldVal.get(), newVal.get());
+            }
+        }
+    }
+}
+
+void QWindowsUiaMainProvider::notifySelectionChange(QAccessibleEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        if (auto provider = providerForAccessible(accessible))
+            QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_SelectionItem_ElementSelectedEventId);
+    }
+}
+
+// Notifies changes in text content and selection state of text controls.
+void QWindowsUiaMainProvider::notifyTextChange(QAccessibleEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        if (accessible->textInterface()) {
+            if (auto provider = providerForAccessible(accessible)) {
+                if (event->type() == QAccessible::TextSelectionChanged) {
+                    QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_Text_TextSelectionChangedEventId);
+                } else if (event->type() == QAccessible::TextCaretMoved) {
+                    if (!accessible->state().readOnly) {
+                        QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(),
+                                                UIA_Text_TextSelectionChangedEventId);
+                    }
+                } else {
+                    QWindowsUiaWrapper::instance()->raiseAutomationEvent(provider.Get(), UIA_Text_TextChangedEventId);
+                }
+            }
+        }
+    }
+}
+
+void QWindowsUiaMainProvider::raiseNotification(QAccessibleAnnouncementEvent *event)
+{
+    if (QAccessibleInterface *accessible = event->accessibleInterface()) {
+        if (auto provider = providerForAccessible(accessible)) {
+            QBStr message{ event->message() };
+            QAccessible::AnnouncementPoliteness prio = event->politeness();
+            NotificationProcessing processing = (prio == QAccessible::AnnouncementPoliteness::Assertive)
+                    ? NotificationProcessing_ImportantAll
+                    : NotificationProcessing_All;
+            QBStr activityId{ QString::fromLatin1("") };
+            QWindowsUiaWrapper::instance()->raiseNotificationEvent(provider.Get(), NotificationKind_Other, processing, message.bstr(),
+                                      activityId.bstr());
+
+        }
+    }
+}
+
+HRESULT STDMETHODCALLTYPE QWindowsUiaMainProvider::QueryInterface(REFIID iid, LPVOID *iface)
+{
+    HRESULT result = QComObject::QueryInterface(iid, iface);
+
+    if (SUCCEEDED(result) && iid == __uuidof(IRawElementProviderFragmentRoot)) {
+        QAccessibleInterface *accessible = accessibleInterface();
+        if (accessible && hwndForAccessible(accessible)) {
+            result = S_OK;
+        } else {
+            Release();
+            result = E_NOINTERFACE;
+            *iface = nullptr;
+        }
+    }
+
+    return result;
+}
+
+HRESULT QWindowsUiaMainProvider::get_ProviderOptions(ProviderOptions *pRetVal)
+{
+    if (!pRetVal)
+        return E_INVALIDARG;
+    // We are STA, (OleInitialize()).
+    *pRetVal = static_cast<ProviderOptions>(ProviderOptions_ServerSideProvider | ProviderOptions_UseComThreading);
+    return S_OK;
+}
+
+// Return providers for specific control patterns
+HRESULT QWindowsUiaMainProvider::GetPatternProvider(PATTERNID idPattern, IUnknown **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << idPattern;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    switch (idPattern) {
+    case UIA_WindowPatternId:
+        if (accessible->parent() && (accessible->parent()->role() == QAccessible::Application)) {
+            *pRetVal = makeComObject<QWindowsUiaWindowProvider>(id()).Detach();
+        }
+        break;
+    case UIA_TextPatternId:
+    case UIA_TextPattern2Id:
+        // All text controls.
+        if (accessible->textInterface()) {
+            *pRetVal = makeComObject<QWindowsUiaTextProvider>(id()).Detach();
+        }
+        break;
+    case UIA_ValuePatternId:
+        // All non-static controls support the Value pattern.
+        if (accessible->role() != QAccessible::StaticText)
+            *pRetVal = makeComObject<QWindowsUiaValueProvider>(id()).Detach();
+        break;
+    case UIA_RangeValuePatternId:
+        // Controls providing a numeric value within a range (e.g., sliders, scroll bars, dials).
+        if (accessible->valueInterface()) {
+            *pRetVal = makeComObject<QWindowsUiaRangeValueProvider>(id()).Detach();
+        }
+        break;
+    case UIA_TogglePatternId:
+        // Checkboxes and other checkable controls.
+        if (accessible->state().checkable)
+            *pRetVal = makeComObject<QWindowsUiaToggleProvider>(id()).Detach();
+        break;
+    case UIA_SelectionPatternId:
+    case UIA_SelectionPattern2Id:
+        // Selections via QAccessibleSelectionInterface or lists of items.
+        if (accessible->selectionInterface()
+                || accessible->role() == QAccessible::List
+                || accessible->role() == QAccessible::PageTabList) {
+            *pRetVal = makeComObject<QWindowsUiaSelectionProvider>(id()).Detach();
+        }
+        break;
+    case UIA_SelectionItemPatternId:
+        // Parent supports selection interface or items within a list and radio buttons.
+        if ((accessible->parent() && accessible->parent()->selectionInterface())
+                || (accessible->role() == QAccessible::RadioButton)
+                || (accessible->role() == QAccessible::ListItem)
+                || (accessible->role() == QAccessible::PageTab)) {
+            *pRetVal = makeComObject<QWindowsUiaSelectionItemProvider>(id()).Detach();
+        }
+        break;
+    case UIA_TablePatternId:
+        // Table/tree.
+        if (accessible->tableInterface()
+                && ((accessible->role() == QAccessible::Table) || (accessible->role() == QAccessible::Tree))) {
+            *pRetVal = makeComObject<QWindowsUiaTableProvider>(id()).Detach();
+        }
+        break;
+    case UIA_TableItemPatternId:
+        // Item within a table/tree.
+        if (accessible->tableCellInterface()
+                && ((accessible->role() == QAccessible::Cell) || (accessible->role() == QAccessible::TreeItem))) {
+            *pRetVal = makeComObject<QWindowsUiaTableItemProvider>(id()).Detach();
+        }
+        break;
+    case UIA_GridPatternId:
+        // Table/tree.
+        if (accessible->tableInterface()
+                && ((accessible->role() == QAccessible::Table) || (accessible->role() == QAccessible::Tree))) {
+            *pRetVal = makeComObject<QWindowsUiaGridProvider>(id()).Detach();
+        }
+        break;
+    case UIA_GridItemPatternId:
+        // Item within a table/tree.
+        if (accessible->tableCellInterface()
+                && ((accessible->role() == QAccessible::Cell) || (accessible->role() == QAccessible::TreeItem))) {
+            *pRetVal = makeComObject<QWindowsUiaGridItemProvider>(id()).Detach();
+        }
+        break;
+    case UIA_InvokePatternId:
+        // Things that have an invokable action (e.g., simple buttons).
+        if (accessible->actionInterface()) {
+            *pRetVal = makeComObject<QWindowsUiaInvokeProvider>(id()).Detach();
+        }
+        break;
+    case UIA_ExpandCollapsePatternId:
+        // Menu items with submenus.
+        if ((accessible->role() == QAccessible::MenuItem
+                && accessible->childCount() > 0
+                && accessible->child(0)->role() == QAccessible::PopupMenu)
+            || accessible->role() == QAccessible::ComboBox
+            || (accessible->role() == QAccessible::TreeItem && accessible->state().expandable)) {
+            *pRetVal = makeComObject<QWindowsUiaExpandCollapseProvider>(id()).Detach();
+        }
+        break;
+    default:
+        break;
+    }
+
+    return S_OK;
+}
+
+void QWindowsUiaMainProvider::fillVariantArrayForRelation(QAccessibleInterface* accessible,
+                                                          QAccessible::Relation relation, VARIANT *pRetVal)
+{
+    Q_ASSERT(accessible);
+
+    typedef std::pair<QAccessibleInterface*, QAccessible::Relation> RelationPair;
+    const QList<RelationPair> relationInterfaces = accessible->relations(relation);
+    if (relationInterfaces.empty())
+        return;
+
+    SAFEARRAY *elements = SafeArrayCreateVector(VT_UNKNOWN, 0, relationInterfaces.size());
+    for (LONG i = 0; i < relationInterfaces.size(); ++i) {
+        if (ComPtr<IRawElementProviderSimple> provider =
+                    providerForAccessible(relationInterfaces.at(i).first)) {
+            SafeArrayPutElement(elements, &i, provider.Get());
+        }
+    }
+
+    pRetVal->vt = VT_UNKNOWN | VT_ARRAY;
+    pRetVal->parray = elements;
+}
+
+void QWindowsUiaMainProvider::setAriaProperties(QAccessibleInterface *accessible, VARIANT *pRetVal)
+{
+    Q_ASSERT(accessible);
+
+    QAccessibleAttributesInterface *attributesIface = accessible->attributesInterface();
+    if (!attributesIface)
+        return;
+
+    QString ariaString;
+    const QList<QAccessible::Attribute> attrKeys = attributesIface->attributeKeys();
+    for (qsizetype i = 0; i < attrKeys.size(); ++i) {
+        if (i != 0)
+            ariaString += QStringLiteral(";");
+        const QAccessible::Attribute key = attrKeys.at(i);
+        const QVariant value = attributesIface->attributeValue(key);
+        // see "Core Accessibility API Mappings" spec: https://www.w3.org/TR/core-aam-1.2/
+        switch (key) {
+        case QAccessible::Attribute::Custom:
+        {
+            // forward custom attributes as-is
+            Q_ASSERT((value.canConvert<QHash<QString, QString>>()));
+            const QHash<QString, QString> attrMap = value.value<QHash<QString, QString>>();
+            for (auto [name, val] : attrMap.asKeyValueRange()) {
+                if (name != *attrMap.keyBegin())
+                    ariaString += QStringLiteral(";");
+                ariaString += name + QStringLiteral("=") + val;
+            }
+            break;
+        }
+        case QAccessible::Attribute::Level:
+            Q_ASSERT(value.canConvert<int>());
+            ariaString += QStringLiteral("level=") + QString::number(value.toInt());
+            break;
+        default:
+            break;
+        }
+    }
+
+    *pRetVal = QComVariant{ ariaString }.release();
+}
+
+void QWindowsUiaMainProvider::setStyle(QAccessibleInterface *accessible, VARIANT *pRetVal)
+{
+    Q_ASSERT(accessible);
+
+    QAccessibleAttributesInterface *attributesIface = accessible->attributesInterface();
+    if (!attributesIface)
+        return;
+
+    // currently, only heading styles are implemented here
+    if (accessible->role() != QAccessible::Role::Heading)
+        return;
+
+    const QVariant levelVariant = attributesIface->attributeValue(QAccessible::Attribute::Level);
+    if (!levelVariant.isValid())
+        return;
+
+    Q_ASSERT(levelVariant.canConvert<int>());
+    // UIA only has styles for heading levels 1-9
+    const int level = levelVariant.toInt();
+    if (level < 1 || level > 9)
+        return;
+
+    const long styleId = styleIdForHeadingLevel(level);
+    *pRetVal = QComVariant{ styleId }.release();
+}
+
+int QWindowsUiaMainProvider::styleIdForHeadingLevel(int headingLevel)
+{
+    // only heading levels 1-9 have a corresponding UIA style ID
+    Q_ASSERT(headingLevel > 0 && headingLevel <= 9);
+
+    static constexpr int styles[] = {
+        StyleId_Heading1,
+        StyleId_Heading2,
+        StyleId_Heading3,
+        StyleId_Heading4,
+        StyleId_Heading5,
+        StyleId_Heading6,
+        StyleId_Heading7,
+        StyleId_Heading8,
+        StyleId_Heading9,
+    };
+
+    return styles[headingLevel - 1];
+}
+
+HRESULT QWindowsUiaMainProvider::GetPropertyValue(PROPERTYID idProp, VARIANT *pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << idProp;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    clearVariant(pRetVal);
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    bool topLevelWindow = accessible->parent() && (accessible->parent()->role() == QAccessible::Application);
+
+    switch (idProp) {
+    case UIA_ProcessIdPropertyId:
+        // PID
+        *pRetVal = QComVariant{ static_cast<long>(GetCurrentProcessId()) }.release();
+        break;
+    case UIA_AccessKeyPropertyId:
+        // Accelerator key.
+        *pRetVal = QComVariant{ accessible->text(QAccessible::Accelerator) }.release();
+        break;
+    case UIA_AriaPropertiesPropertyId:
+        setAriaProperties(accessible, pRetVal);
+        break;
+    case UIA_AutomationIdPropertyId:
+        // Automation ID, which can be used by tools to select a specific control in the UI.
+        *pRetVal = QComVariant{ QAccessibleBridgeUtils::accessibleId(accessible) }.release();
+        break;
+    case UIA_ClassNamePropertyId:
+        // Class name.
+        if (QObject *o = accessible->object()) {
+            QString className = QLatin1StringView(o->metaObject()->className());
+            *pRetVal = QComVariant{ className }.release();
+        }
+        break;
+    case UIA_DescribedByPropertyId:
+        fillVariantArrayForRelation(accessible, QAccessible::DescriptionFor, pRetVal);
+        break;
+    case UIA_FlowsFromPropertyId:
+        fillVariantArrayForRelation(accessible, QAccessible::FlowsTo, pRetVal);
+        break;
+    case UIA_FlowsToPropertyId:
+        fillVariantArrayForRelation(accessible, QAccessible::FlowsFrom, pRetVal);
+        break;
+    case UIA_FrameworkIdPropertyId:
+        *pRetVal = QComVariant{ QStringLiteral("Qt") }.release();
+        break;
+    case UIA_ControlTypePropertyId:
+        if (topLevelWindow) {
+            // Reports a top-level widget as a window, instead of "custom".
+            *pRetVal = QComVariant{ UIA_WindowControlTypeId }.release();
+        } else {
+            // Control type converted from role.
+            auto controlType = roleToControlTypeId(accessible->role());
+
+            // The native OSK should be disabled if the Qt OSK is in use,
+            // or if disabled via application attribute.
+            static bool imModuleEmpty = QPlatformInputContextFactory::requested().isEmpty();
+            bool nativeVKDisabled = QCoreApplication::testAttribute(Qt::AA_DisableNativeVirtualKeyboard);
+
+            // If we want to disable the native OSK auto-showing
+            // we have to report text fields as non-editable.
+            if (controlType == UIA_EditControlTypeId && (!imModuleEmpty || nativeVKDisabled))
+                controlType = UIA_TextControlTypeId;
+
+            *pRetVal = QComVariant{ controlType }.release();
+        }
+        break;
+    case UIA_HelpTextPropertyId:
+        *pRetVal = QComVariant{ accessible->text(QAccessible::Help) }.release();
+        break;
+    case UIA_HasKeyboardFocusPropertyId:
+        if (topLevelWindow) {
+            // Windows set the active state to true when they are focused
+            *pRetVal = QComVariant{ accessible->state().active ? true : false }.release();
+        } else {
+            *pRetVal = QComVariant{ accessible->state().focused ? true : false }.release();
+        }
+        break;
+    case UIA_IsKeyboardFocusablePropertyId:
+        if (topLevelWindow) {
+            // Windows should always be focusable
+            *pRetVal = QComVariant{ true }.release();
+        } else {
+            *pRetVal = QComVariant{ accessible->state().focusable ? true : false }.release();
+        }
+        break;
+    case UIA_IsOffscreenPropertyId:
+        *pRetVal = QComVariant{ accessible->state().offscreen ? true : false }.release();
+        break;
+    case UIA_IsContentElementPropertyId:
+        *pRetVal = QComVariant{ true }.release();
+        break;
+    case UIA_IsControlElementPropertyId:
+        *pRetVal = QComVariant{ true }.release();
+        break;
+    case UIA_IsEnabledPropertyId:
+        *pRetVal = QComVariant{ !accessible->state().disabled }.release();
+        break;
+    case UIA_IsPasswordPropertyId:
+        *pRetVal = QComVariant{ accessible->role() == QAccessible::EditableText
+                                && accessible->state().passwordEdit }
+                           .release();
+        break;
+    case UIA_IsPeripheralPropertyId:
+        // True for peripheral UIs.
+        if (QWindow *window = windowForAccessible(accessible)) {
+            const Qt::WindowType wt = window->type();
+            *pRetVal = QComVariant{ wt == Qt::Popup || wt == Qt::ToolTip || wt == Qt::SplashScreen }
+                               .release();
+        }
+        break;
+    case UIA_IsDialogPropertyId:
+        *pRetVal = QComVariant{ accessible->role() == QAccessible::Dialog
+                                || accessible->role() == QAccessible::AlertMessage }
+                           .release();
+        break;
+    case UIA_FullDescriptionPropertyId:
+        *pRetVal = QComVariant{ accessible->text(QAccessible::Description) }.release();
+        break;
+    case UIA_NamePropertyId: {
+        QString name = accessible->text(QAccessible::Name);
+        if (name.isEmpty() && topLevelWindow)
+           name = QCoreApplication::applicationName();
+        *pRetVal = QComVariant{ name }.release();
+        break;
+    }
+    case UIA_StyleIdAttributeId:
+        setStyle(accessible, pRetVal);
+        break;
+    default:
+        break;
+    }
+    return S_OK;
+}
+
+HRESULT QWindowsUiaMainProvider::get_HostRawElementProvider(IRawElementProviderSimple **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    // Returns a host provider only for controls associated with a native window handle. Others should return NULL.
+    if (QAccessibleInterface *accessible = accessibleInterface()) {
+        if (HWND hwnd = hwndForAccessible(accessible)) {
+            return QWindowsUiaWrapper::instance()->hostProviderFromHwnd(hwnd, pRetVal);
+        }
+    }
+    return S_OK;
+}
+
+// Navigates within the tree of accessible controls.
+HRESULT QWindowsUiaMainProvider::Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << direction << " this: " << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    QAccessibleInterface *targetacc = nullptr;
+
+    if (direction == NavigateDirection_Parent) {
+        if (QAccessibleInterface *parent = accessible->parent()) {
+            // The Application's children are considered top level objects.
+            if (parent->isValid() && parent->role() != QAccessible::Application) {
+                targetacc = parent;
+            }
+        }
+    } else {
+        QAccessibleInterface *parent = nullptr;
+        int index = 0;
+        int incr = 1;
+        switch (direction) {
+        case NavigateDirection_FirstChild:
+            parent = accessible;
+            index = 0;
+            incr = 1;
+            break;
+        case NavigateDirection_LastChild:
+            parent = accessible;
+            index = accessible->childCount() - 1;
+            incr = -1;
+            break;
+        case NavigateDirection_NextSibling:
+            if ((parent = accessible->parent()))
+                index = parent->indexOfChild(accessible) + 1;
+            incr = 1;
+            break;
+        case NavigateDirection_PreviousSibling:
+            if ((parent = accessible->parent()))
+                index = parent->indexOfChild(accessible) - 1;
+            incr = -1;
+            break;
+        default:
+            Q_UNREACHABLE();
+            break;
+        }
+
+        if (parent && parent->isValid()) {
+            for (int count = parent->childCount(); index >= 0 && index < count; index += incr) {
+                if (QAccessibleInterface *child = parent->child(index)) {
+                    if (child->isValid() && !child->state().invisible) {
+                        targetacc = child;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    if (targetacc)
+        *pRetVal = providerForAccessible(targetacc).Detach();
+    return S_OK;
+}
+
+// Returns a unique id assigned to the UI element, used as key by the UI Automation framework.
+HRESULT QWindowsUiaMainProvider::GetRuntimeId(SAFEARRAY **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    // The UiaAppendRuntimeId constant is used to make then ID unique
+    // among multiple instances running on the system.
+    int rtId[] = { UiaAppendRuntimeId, int(id()) };
+
+    if ((*pRetVal = SafeArrayCreateVector(VT_I4, 0, 2))) {
+        for (LONG i = 0; i < 2; ++i)
+            SafeArrayPutElement(*pRetVal, &i, &rtId[i]);
+    }
+    return S_OK;
+}
+
+// Returns the bounding rectangle for the accessible control.
+HRESULT QWindowsUiaMainProvider::get_BoundingRectangle(UiaRect *pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    QWindow *window = windowForAccessible(accessible);
+    if (!window)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    rectToNativeUiaRect(accessible->rect(), window, pRetVal);
+    return S_OK;
+}
+
+HRESULT QWindowsUiaMainProvider::GetEmbeddedFragmentRoots(SAFEARRAY **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+    // No embedded roots.
+    return S_OK;
+}
+
+// Sets focus to the control.
+HRESULT QWindowsUiaMainProvider::SetFocus()
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    QAccessibleActionInterface *actionInterface = accessible->actionInterface();
+    if (!actionInterface)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    actionInterface->doAction(QAccessibleActionInterface::setFocusAction());
+    return S_OK;
+}
+
+HRESULT QWindowsUiaMainProvider::get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    // Our UI Automation implementation considers the window as the root for
+    // non-native controls/fragments.
+    if (QAccessibleInterface *accessible = accessibleInterface()) {
+        if (QWindow *window = windowForAccessible(accessible)) {
+            if (QAccessibleInterface *rootacc = window->accessibleRoot())
+                *pRetVal = providerForAccessible(rootacc).Detach();
+        }
+    }
+    return S_OK;
+}
+
+// Returns a provider for the UI element present at the specified screen coordinates.
+HRESULT QWindowsUiaMainProvider::ElementProviderFromPoint(double x, double y, IRawElementProviderFragment **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << x << y;
+
+    if (!pRetVal) {
+        return E_INVALIDARG;
+    }
+    *pRetVal = nullptr;
+
+    QAccessibleInterface *accessible = accessibleInterface();
+    if (!accessible)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    QWindow *window = windowForAccessible(accessible);
+    if (!window)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+    // Scales coordinates from High DPI screens.
+    UiaPoint uiaPoint = {x, y};
+    QPoint point;
+    nativeUiaPointToPoint(uiaPoint, window, &point);
+
+    QAccessibleInterface *targetacc = accessible->childAt(point.x(), point.y());
+
+    if (targetacc) {
+        QAccessibleInterface *acc = targetacc;
+        // Controls can be embedded within grouping elements. By default returns the innermost control.
+        while (acc) {
+            targetacc = acc;
+            // For accessibility tools it may be better to return the text element instead of its subcomponents.
+            if (targetacc->textInterface()) break;
+            acc = acc->childAt(point.x(), point.y());
+        }
+        *pRetVal = providerForAccessible(targetacc).Detach();
+    }
+    return S_OK;
+}
+
+// Returns the fragment with focus.
+HRESULT QWindowsUiaMainProvider::GetFocus(IRawElementProviderFragment **pRetVal)
+{
+    qCDebug(lcQpaUiAutomation) << __FUNCTION__ << this;
+
+    if (!pRetVal)
+        return E_INVALIDARG;
+    *pRetVal = nullptr;
+
+    if (QAccessibleInterface *accessible = accessibleInterface()) {
+        if (QAccessibleInterface *focusacc = accessible->focusChild()) {
+            *pRetVal = providerForAccessible(focusacc).Detach();
+        }
+    }
+    return S_OK;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_CONFIG(accessibility)

qtbase/src/plugins/platforms/windows/uiautomation/qwindowsuiawrapper.cpp

@@ -0,0 +1,89 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include <initguid.h>
+
+#include "qwindowsuiawrapper_p.h"
+#include <QtCore/private/qsystemlibrary_p.h>
+
+QT_BEGIN_NAMESPACE
+
+// private constructor
+QWindowsUiaWrapper::QWindowsUiaWrapper()
+{
+    QSystemLibrary uiaLib(QStringLiteral("UIAutomationCore"));
+    if (uiaLib.load()) {
+        m_pUiaReturnRawElementProvider = reinterpret_cast<PtrUiaReturnRawElementProvider>(uiaLib.resolve("UiaReturnRawElementProvider"));
+        m_pUiaHostProviderFromHwnd = reinterpret_cast<PtrUiaHostProviderFromHwnd>(uiaLib.resolve("UiaHostProviderFromHwnd"));
+        m_pUiaRaiseAutomationPropertyChangedEvent = reinterpret_cast<PtrUiaRaiseAutomationPropertyChangedEvent>(uiaLib.resolve("UiaRaiseAutomationPropertyChangedEvent"));
+        m_pUiaRaiseAutomationEvent = reinterpret_cast<PtrUiaRaiseAutomationEvent>(uiaLib.resolve("UiaRaiseAutomationEvent"));
+        m_pUiaRaiseNotificationEvent = reinterpret_cast<PtrUiaRaiseNotificationEvent>(uiaLib.resolve("UiaRaiseNotificationEvent"));
+        m_pUiaClientsAreListening = reinterpret_cast<PtrUiaClientsAreListening>(uiaLib.resolve("UiaClientsAreListening"));
+    }
+}
+
+QWindowsUiaWrapper::~QWindowsUiaWrapper()
+{
+}
+
+// shared instance
+QWindowsUiaWrapper *QWindowsUiaWrapper::instance()
+{
+    static QWindowsUiaWrapper wrapper;
+    return &wrapper;
+}
+
+// True if all symbols resolved.
+BOOL QWindowsUiaWrapper::ready()
+{
+    return m_pUiaReturnRawElementProvider
+        && m_pUiaHostProviderFromHwnd
+        && m_pUiaRaiseAutomationPropertyChangedEvent
+        && m_pUiaRaiseAutomationEvent
+        && m_pUiaClientsAreListening;
+}
+
+BOOL QWindowsUiaWrapper::clientsAreListening()
+{
+    if (!m_pUiaClientsAreListening)
+        return FALSE;
+    return m_pUiaClientsAreListening();
+}
+
+LRESULT QWindowsUiaWrapper::returnRawElementProvider(HWND hwnd, WPARAM wParam, LPARAM lParam, IRawElementProviderSimple *el)
+{
+    if (!m_pUiaReturnRawElementProvider)
+        return static_cast<LRESULT>(NULL);
+    return m_pUiaReturnRawElementProvider(hwnd, wParam, lParam, el);
+}
+
+HRESULT QWindowsUiaWrapper::hostProviderFromHwnd(HWND hwnd, IRawElementProviderSimple **ppProvider)
+{
+    if (!m_pUiaHostProviderFromHwnd)
+        return UIA_E_NOTSUPPORTED;
+    return m_pUiaHostProviderFromHwnd(hwnd, ppProvider);
+}
+
+HRESULT QWindowsUiaWrapper::raiseAutomationPropertyChangedEvent(IRawElementProviderSimple *pProvider, PROPERTYID id, VARIANT oldValue, VARIANT newValue)
+{
+    if (!m_pUiaRaiseAutomationPropertyChangedEvent)
+        return UIA_E_NOTSUPPORTED;
+    return m_pUiaRaiseAutomationPropertyChangedEvent(pProvider, id, oldValue, newValue);
+}
+
+HRESULT QWindowsUiaWrapper::raiseAutomationEvent(IRawElementProviderSimple *pProvider, EVENTID id)
+{
+    if (!m_pUiaRaiseAutomationEvent)
+        return UIA_E_NOTSUPPORTED;
+    return m_pUiaRaiseAutomationEvent(pProvider, id);
+}
+
+HRESULT QWindowsUiaWrapper::raiseNotificationEvent(IRawElementProviderSimple *pProvider, NotificationKind notificationKind, NotificationProcessing notificationProcessing, BSTR displayString, BSTR activityId)
+{
+    if (!m_pUiaRaiseNotificationEvent)
+        return UIA_E_NOTSUPPORTED;
+    return m_pUiaRaiseNotificationEvent(pProvider, notificationKind, notificationProcessing, displayString, activityId);
+}
+
+QT_END_NAMESPACE
+

qtbase/src/plugins/platforms/windows/uiautomation/qwindowsuiawrapper_p.h

@@ -0,0 +1,57 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QWINDOWSUIAWRAPPER_H
+#define QWINDOWSUIAWRAPPER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/private/qtguiglobal_p.h>
+
+QT_REQUIRE_CONFIG(accessibility);
+
+QT_BEGIN_NAMESPACE
+
+class QWindowsUiaWrapper
+{
+    QWindowsUiaWrapper();
+    virtual ~QWindowsUiaWrapper();
+public:
+    static QWindowsUiaWrapper *instance();
+    BOOL ready();
+    BOOL clientsAreListening();
+    LRESULT returnRawElementProvider(HWND hwnd, WPARAM wParam, LPARAM lParam, IRawElementProviderSimple *el);
+    HRESULT hostProviderFromHwnd(HWND hwnd, IRawElementProviderSimple **ppProvider);
+    HRESULT raiseAutomationPropertyChangedEvent(IRawElementProviderSimple *pProvider, PROPERTYID id, VARIANT oldValue, VARIANT newValue);
+    HRESULT raiseAutomationEvent(IRawElementProviderSimple *pProvider, EVENTID id);
+    HRESULT raiseNotificationEvent(IRawElementProviderSimple *pProvider, NotificationKind notificationKind, NotificationProcessing notificationProcessing, BSTR displayString, BSTR activityId);
+
+private:
+    typedef LRESULT (WINAPI *PtrUiaReturnRawElementProvider)(HWND, WPARAM, LPARAM, IRawElementProviderSimple *);
+    typedef HRESULT (WINAPI *PtrUiaHostProviderFromHwnd)(HWND, IRawElementProviderSimple **);
+    typedef HRESULT (WINAPI *PtrUiaRaiseAutomationPropertyChangedEvent)(IRawElementProviderSimple *, PROPERTYID, VARIANT, VARIANT);
+    typedef HRESULT (WINAPI *PtrUiaRaiseAutomationEvent)(IRawElementProviderSimple *, EVENTID);
+    typedef HRESULT (WINAPI *PtrUiaRaiseNotificationEvent)(IRawElementProviderSimple *, NotificationKind, NotificationProcessing, BSTR, BSTR);
+
+    typedef BOOL (WINAPI *PtrUiaClientsAreListening)();
+    PtrUiaReturnRawElementProvider             m_pUiaReturnRawElementProvider = nullptr;
+    PtrUiaHostProviderFromHwnd                 m_pUiaHostProviderFromHwnd = nullptr;
+    PtrUiaRaiseAutomationPropertyChangedEvent  m_pUiaRaiseAutomationPropertyChangedEvent = nullptr;
+    PtrUiaRaiseAutomationEvent                 m_pUiaRaiseAutomationEvent = nullptr;
+    PtrUiaRaiseNotificationEvent               m_pUiaRaiseNotificationEvent = nullptr;
+    PtrUiaClientsAreListening                  m_pUiaClientsAreListening = nullptr;
+};
+
+QT_END_NAMESPACE
+
+#endif //QWINDOWSUIAWRAPPER_H
+

qtbase/src/plugins/platforms/windows/vxkex.h

@@ -261,16 +261,13 @@ static BOOL GetDisplayAutoRotationPreferences(
 static BOOL SetProcessDpiAwarenessContext(
     IN  DPI_AWARENESS_CONTEXT   DpiContext)
 {
-    switch ((ULONG_PTR)DpiContext) {
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE:
+    if ((ULONG_PTR)DpiContext == (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE) {
         //NOTHING;
-        break;
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2:
+    } else if ((ULONG_PTR)DpiContext == (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ||
+             (ULONG_PTR)DpiContext == (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ||
+             (ULONG_PTR)DpiContext == (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) {
         SetProcessDPIAware();
-        break;
-    default:
+    } else {
         return FALSE;
     }
 
@@ -287,14 +284,13 @@ static BOOL AreDpiAwarenessContextsEqual(
 static BOOL IsValidDpiAwarenessContext(
     IN  DPI_AWARENESS_CONTEXT   Value)
 {
-    switch ((ULONG_PTR)Value) {
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE:
-    case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2:
+    if ((ULONG_PTR)Value == (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE ||
+        (ULONG_PTR)Value == (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED ||
+        (ULONG_PTR)Value == (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ||
+        (ULONG_PTR)Value == (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ||
+        (ULONG_PTR)Value == (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) {
         return TRUE;
-    default:
+    } else {
         return FALSE;
     }
 }

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
 
@@ -90,11 +92,6 @@ enum QSliderDirection { SlUp, SlDown, SlLeft, SlRight };
 
 QWindowsStylePrivate::QWindowsStylePrivate() = default;
 
-qreal QWindowsStylePrivate::appDevicePixelRatio()
-{
-    return qApp->devicePixelRatio();
-}
-
 // Returns \c true if the toplevel parent of \a widget has seen the Alt-key
 bool QWindowsStylePrivate::hasSeenAlt(const QWidget *widget) const
 {
@@ -261,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)
 {
@@ -459,46 +458,6 @@ int QWindowsStyle::pixelMetric(PixelMetric pm, const QStyleOption *opt, const QW
 QPixmap QWindowsStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
                                       const QWidget *widget) const
 {
-#if defined(Q_OS_WIN)
-    QPixmap desktopIcon;
-    switch(standardPixmap) {
-    case SP_DriveCDIcon:
-    case SP_DriveDVDIcon:
-    case SP_DriveNetIcon:
-    case SP_DriveHDIcon:
-    case SP_DriveFDIcon:
-    case SP_FileIcon:
-    case SP_FileLinkIcon:
-    case SP_DirLinkIcon:
-    case SP_DirClosedIcon:
-    case SP_DesktopIcon:
-    case SP_ComputerIcon:
-    case SP_DirOpenIcon:
-    case SP_FileDialogNewFolder:
-    case SP_DirHomeIcon:
-    case SP_TrashIcon:
-    case SP_VistaShield:
-        if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
-            QPlatformTheme::StandardPixmap sp = static_cast<QPlatformTheme::StandardPixmap>(standardPixmap);
-            desktopIcon = theme->standardPixmap(sp, QSizeF(16, 16));
-        }
-        break;
-    case SP_MessageBoxInformation:
-    case SP_MessageBoxWarning:
-    case SP_MessageBoxCritical:
-    case SP_MessageBoxQuestion:
-        if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
-            QPlatformTheme::StandardPixmap sp = static_cast<QPlatformTheme::StandardPixmap>(standardPixmap);
-            desktopIcon = theme->standardPixmap(sp, QSizeF());
-        }
-        break;
-    default:
-        break;
-    }
-    if (!desktopIcon.isNull()) {
-        return desktopIcon;
-    }
-#endif // Q_OS_WIN
     return QCommonStyle::standardPixmap(standardPixmap, opt, widget);
 }