qt 6.8.0 support

This commit is contained in:
kleuter 2024-11-18 11:31:57 +01:00
parent c4707639b4
commit 09a199127f
20 changed files with 2264 additions and 354 deletions

View File

@ -1,11 +1,11 @@
This is Qt 6.7.3 **qtbase module** backport that runs on Windows 7/8. The repository contains patched source files from the qtbase module. This is Qt 6.8.0 **qtbase module** backport that runs on Windows 7/8. 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. 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.
- After replacing qtbase source files with the patched ones from this repository, you can compile Qt yourself using compiler and build options you need. - After replacing qtbase source files with the patched ones from this repository, you can compile Qt yourself using compiler and build options you need.
- You can use our [compile_win.pl](https://github.com/crystalidea/qt-build-tools/tree/master/6.7.3) build script (uses Visual C++ 2022 with OpenSSL 3.0.13 statically linked) - You can use our [compile_win.pl](https://github.com/crystalidea/qt-build-tools/tree/master/6.8.0) build script (uses Visual C++ 2022 with OpenSSL 3.0.13 statically linked)
- You can download our [prebuild Qt dlls](https://github.com/crystalidea/qt6windows7/releases) which also have Qt Designer binary for demonstration - You can download our [prebuild Qt dlls](https://github.com/crystalidea/qt6windows7/releases) which also have Qt Designer binary for demonstration
**Qt 6.7.3 designer running on Windows 7**: **Qt 6.8.0 designer running on Windows 7**:
![Qt Designer](designer.png) ![Qt Designer](designer.png)
@ -15,6 +15,8 @@ Approach is based on this [forum thread](https://forum.qt.io/topic/133002/qt-cre
### Older versions: ### Older versions:
- [Qt 6.7.3](https://github.com/crystalidea/qt6windows7/releases/tag/v6.7.3)
- [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.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.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) - [Qt 6.6.1](https://github.com/crystalidea/qt6windows7/releases/tag/v6.6.1)

Binary file not shown.

Before

Width:  |  Height:  |  Size: 76 KiB

After

Width:  |  Height:  |  Size: 72 KiB

View File

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

View File

@ -0,0 +1,648 @@
// 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 <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 = 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);
}
}
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);
QThreadPrivate::finish(thread);
}
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);
// 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) {
}
}
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();
finish(arg);
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(void *arg, bool lockAnyway) noexcept
{
QThread *thr = reinterpret_cast<QThread *>(arg);
QThreadPrivate *d = thr->d_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());
qCDebug(lcDeleteLater) << "Sending deferred delete events as part of finishing thread" << thr;
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);
QThreadPrivate::finish(this, 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;
++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
QThreadPrivate::finish(this, 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) {
QThreadPrivate::finish(thr, 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

View File

@ -10,6 +10,8 @@
#include <QtCore/private/qsystemerror_p.h> #include <QtCore/private/qsystemerror_p.h>
#include "qrhid3dhelpers_p.h" #include "qrhid3dhelpers_p.h"
#include <cstdio>
#include <VersionHelpers.h> #include <VersionHelpers.h>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
@ -28,7 +30,8 @@ using namespace Qt::StringLiterals;
/*! /*!
\class QRhiD3D11InitParams \class QRhiD3D11InitParams
\inmodule QtGui \inmodule QtGuiPrivate
\inheaderfile rhi/qrhi.h
\since 6.6 \since 6.6
\brief Direct3D 11 specific initialization parameters. \brief Direct3D 11 specific initialization parameters.
@ -81,7 +84,8 @@ using namespace Qt::StringLiterals;
/*! /*!
\class QRhiD3D11NativeHandles \class QRhiD3D11NativeHandles
\inmodule QtGui \inmodule QtGuiPrivate
\inheaderfile rhi/qrhi.h
\since 6.6 \since 6.6
\brief Holds the D3D device and device context used by the QRhi. \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) // there. (some features are not supported then, however)
useLegacySwapchainModel = qEnvironmentVariableIntValue("QT_D3D_NO_FLIP"); 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", 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) { if (!importedDeviceAndContext) {
IDXGIAdapter1 *adapter; IDXGIAdapter1 *adapter;
@ -634,6 +648,10 @@ bool QRhiD3D11::isFeatureSupported(QRhi::Feature feature) const
return true; return true;
case QRhi::MultiView: case QRhi::MultiView:
return false; 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: default:
Q_UNREACHABLE(); Q_UNREACHABLE();
return false; return false;
@ -1347,6 +1365,10 @@ QRhi::FrameOpResult QRhiD3D11::beginFrame(QRhiSwapChain *swapChain, QRhi::BeginF
contextState.currentSwapChain = swapChainD; contextState.currentSwapChain = swapChainD;
const int currentFrameSlot = swapChainD->currentFrameSlot; 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->cb.resetState();
swapChainD->rt.d.rtv[0] = swapChainD->sampleDesc.Count > 1 ? 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.srcSubRes = D3D11CalcSubresource(0, UINT(colorAtt.layer()), 1);
cmd.args.resolveSubRes.format = dstTexD->dxgiFormat; 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; cbD->recordingPass = QD3D11CommandBuffer::NoPass;
@ -4250,6 +4274,22 @@ static inline DXGI_FORMAT toD3DAttributeFormat(QRhiVertexInputAttribute::Format
return DXGI_FORMAT_R16G16_FLOAT; return DXGI_FORMAT_R16G16_FLOAT;
case QRhiVertexInputAttribute::Half: case QRhiVertexInputAttribute::Half:
return DXGI_FORMAT_R16_FLOAT; 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: default:
Q_UNREACHABLE(); Q_UNREACHABLE();
return DXGI_FORMAT_R32G32B32A32_FLOAT; return DXGI_FORMAT_R32G32B32A32_FLOAT;
@ -4672,7 +4712,7 @@ bool QD3D11GraphicsPipeline::create()
} else { } else {
QByteArray sem; QByteArray sem;
sem.resize(16); 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); matrixSliceSemantics.append(sem);
desc.SemanticName = matrixSliceSemantics.last().constData(); desc.SemanticName = matrixSliceSemantics.last().constData();
desc.SemanticIndex = UINT(matrixSlice); desc.SemanticIndex = UINT(matrixSlice);
@ -4938,6 +4978,11 @@ void QD3D11SwapChain::destroy()
dcompTarget = nullptr; dcompTarget = nullptr;
} }
if (frameLatencyWaitableObject) {
CloseHandle(frameLatencyWaitableObject);
frameLatencyWaitableObject = nullptr;
}
QRHI_RES_RHI(QRhiD3D11); QRHI_RES_RHI(QRhiD3D11);
if (rhiD) { if (rhiD) {
rhiD->unregisterResource(this); rhiD->unregisterResource(this);
@ -5100,7 +5145,7 @@ bool QD3D11SwapChain::createOrResize()
if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) { if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) {
if (!rhiD->useLegacySwapchainModel && rhiD->ensureDirectCompositionDevice()) { if (!rhiD->useLegacySwapchainModel && rhiD->ensureDirectCompositionDevice()) {
if (!dcompTarget) { if (!dcompTarget) {
hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, true, &dcompTarget); hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, false, &dcompTarget);
if (FAILED(hr)) { if (FAILED(hr)) {
qWarning("Failed to create Direct Compsition target for the window: %s", qWarning("Failed to create Direct Compsition target for the window: %s",
qPrintable(QSystemError::windowsComString(hr))); qPrintable(QSystemError::windowsComString(hr)));
@ -5130,6 +5175,17 @@ bool QD3D11SwapChain::createOrResize()
if (swapInterval == 0 && rhiD->supportsAllowTearing) if (swapInterval == 0 && rhiD->supportsAllowTearing)
swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING; 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) { if (!swapChain) {
sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount); sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount);
colorFormat = DEFAULT_FORMAT; colorFormat = DEFAULT_FORMAT;
@ -5215,16 +5271,31 @@ bool QD3D11SwapChain::createOrResize()
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {
swapChain = sc1; swapChain = sc1;
if (m_format != SDR) {
IDXGISwapChain3 *sc3 = nullptr; IDXGISwapChain3 *sc3 = nullptr;
if (SUCCEEDED(sc1->QueryInterface(__uuidof(IDXGISwapChain3), reinterpret_cast<void **>(&sc3)))) { if (SUCCEEDED(sc1->QueryInterface(__uuidof(IDXGISwapChain3), reinterpret_cast<void **>(&sc3)))) {
if (m_format != SDR) {
hr = sc3->SetColorSpace1(hdrColorSpace); hr = sc3->SetColorSpace1(hdrColorSpace);
if (FAILED(hr)) if (FAILED(hr))
qWarning("Failed to set color space on swapchain: %s", qWarning("Failed to set color space on swapchain: %s",
qPrintable(QSystemError::windowsComString(hr))); qPrintable(QSystemError::windowsComString(hr)));
}
if (useFrameLatencyWaitableObject) {
sc3->SetMaximumFrameLatency(rhiD->maxFrameLatency);
frameLatencyWaitableObject = sc3->GetFrameLatencyWaitableObject();
}
sc3->Release(); sc3->Release();
} else { } else {
if (m_format != SDR)
qWarning("IDXGISwapChain3 not available, HDR swapchain will not work as expected"); 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) { if (dcompVisual) {

View File

@ -626,6 +626,7 @@ struct QD3D11SwapChain : public QRhiSwapChain
IDCompositionVisual *dcompVisual = nullptr; IDCompositionVisual *dcompVisual = nullptr;
QD3D11SwapChainTimestamps timestamps; QD3D11SwapChainTimestamps timestamps;
int currentTimestampPairIndex = 0; int currentTimestampPairIndex = 0;
HANDLE frameLatencyWaitableObject = nullptr;
}; };
class QRhiD3D11 : public QRhiImplementation class QRhiD3D11 : public QRhiImplementation
@ -761,6 +762,7 @@ public:
QRhi::Flags rhiFlags; QRhi::Flags rhiFlags;
bool debugLayer = false; 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; bool importedDeviceAndContext = false;
ID3D11Device *dev = nullptr; ID3D11Device *dev = nullptr;
ID3D11DeviceContext1 *context = nullptr; ID3D11DeviceContext1 *context = nullptr;

View File

@ -23,7 +23,8 @@ QT_BEGIN_NAMESPACE
/*! /*!
\class QRhiD3D12InitParams \class QRhiD3D12InitParams
\inmodule QtGui \inmodule QtGuiPrivate
\inheaderfile rhi/qrhi.h
\brief Direct3D 12 specific initialization parameters. \brief Direct3D 12 specific initialization parameters.
\note This is a RHI API with limited compatibility guarantees, see \l QRhi \note This is a RHI API with limited compatibility guarantees, see \l QRhi
@ -70,7 +71,8 @@ QT_BEGIN_NAMESPACE
/*! /*!
\class QRhiD3D12NativeHandles \class QRhiD3D12NativeHandles
\inmodule QtGui \inmodule QtGuiPrivate
\inheaderfile rhi/qrhi.h
\brief Holds the D3D12 device used by the QRhi. \brief Holds the D3D12 device used by the QRhi.
\note The class uses \c{void *} as the type since including the COM-based \note The class uses \c{void *} as the type since including the COM-based
@ -129,7 +131,8 @@ QT_BEGIN_NAMESPACE
/*! /*!
\class QRhiD3D12CommandBufferNativeHandles \class QRhiD3D12CommandBufferNativeHandles
\inmodule QtGui \inmodule QtGuiPrivate
\inheaderfile rhi/qrhi.h
\brief Holds the ID3D12GraphicsCommandList1 object that is backing a QRhiCommandBuffer. \brief Holds the ID3D12GraphicsCommandList1 object that is backing a QRhiCommandBuffer.
\note The command list object is only guaranteed to be valid, and \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; supportsAllowTearing = false;
IDXGIFactory5 *factory5 = nullptr; IDXGIFactory5 *factory5 = nullptr;
if (SUCCEEDED(dxgiFactory->QueryInterface(__uuidof(IDXGIFactory5), reinterpret_cast<void **>(&factory5)))) { 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); memset(timestampReadbackArea.mem.p, 0, readbackBufSize);
} }
caps = {};
D3D12_FEATURE_DATA_D3D12_OPTIONS3 options3 = {}; 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; 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; deviceLost = false;
offscreenActive = 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 return false; // we generate mipmaps ourselves with compute and this is not implemented
case QRhi::MultiView: case QRhi::MultiView:
return caps.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; return false;
} }
@ -974,7 +992,7 @@ void QD3D12CommandBuffer::visitStorageImage(QD3D12Stage s,
const bool isArray = texD->m_flags.testFlag(QRhiTexture::TextureArray); const bool isArray = texD->m_flags.testFlag(QRhiTexture::TextureArray);
const bool is3D = texD->m_flags.testFlag(QRhiTexture::ThreeDimensional); const bool is3D = texD->m_flags.testFlag(QRhiTexture::ThreeDimensional);
D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {}; D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
uavDesc.Format = texD->dxgiFormat; uavDesc.Format = texD->rtFormat;
if (isCube) { if (isCube) {
uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY; uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
uavDesc.Texture2DArray.MipSlice = UINT(d.level); 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)) for (QD3D12SwapChain *sc : std::as_const(swapchains))
sc->waitCommandCompletionForFrameSlot(currentFrameSlot); // note: swapChainD->currentFrameSlot, not sc's sc->waitCommandCompletionForFrameSlot(currentFrameSlot); // note: swapChainD->currentFrameSlot, not sc's
if (swapChainD->frameLatencyWaitableObject)
WaitForSingleObjectEx(swapChainD->frameLatencyWaitableObject, 1000, true);
HRESULT hr = cmdAllocators[currentFrameSlot]->Reset(); HRESULT hr = cmdAllocators[currentFrameSlot]->Reset();
if (FAILED(hr)) { if (FAILED(hr)) {
qWarning("Failed to reset command allocator: %s", qWarning("Failed to reset command allocator: %s",
@ -1996,7 +2017,8 @@ void QRhiD3D12::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
dstTexD->dxgiFormat); dstTexD->dxgiFormat);
} }
} }
if (rtTex->m_desc.depthResolveTexture())
qWarning("Resolving multisample depth-stencil buffers is not supported with D3D");
} }
cbD->recordingPass = QD3D12CommandBuffer::NoPass; cbD->recordingPass = QD3D12CommandBuffer::NoPass;
@ -4198,8 +4220,27 @@ bool QD3D12Texture::prepareCreate(QSize *adjustedSize)
const QSize size = is1D ? QSize(qMax(1, m_pixelSize.width()), 1) const QSize size = is1D ? QSize(qMax(1, m_pixelSize.width()), 1)
: (m_pixelSize.isEmpty() ? QSize(1, 1) : m_pixelSize); : (m_pixelSize.isEmpty() ? QSize(1, 1) : m_pixelSize);
QRHI_RES_RHI(QRhiD3D12);
dxgiFormat = toD3DTextureFormat(m_format, m_flags); 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());
}
QRHI_RES_RHI(QRhiD3D12);
mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1); mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1);
sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount, dxgiFormat); sampleDesc = rhiD->effectiveSampleDesc(m_sampleCount, dxgiFormat);
if (sampleDesc.Count > 1) { if (sampleDesc.Count > 1) {
@ -4258,14 +4299,13 @@ bool QD3D12Texture::prepareCreate(QSize *adjustedSize)
bool QD3D12Texture::finishCreate() bool QD3D12Texture::finishCreate()
{ {
QRHI_RES_RHI(QRhiD3D12); QRHI_RES_RHI(QRhiD3D12);
const bool isDepth = isDepthTextureFormat(m_format);
const bool isCube = m_flags.testFlag(CubeMap); const bool isCube = m_flags.testFlag(CubeMap);
const bool is3D = m_flags.testFlag(ThreeDimensional); const bool is3D = m_flags.testFlag(ThreeDimensional);
const bool isArray = m_flags.testFlag(TextureArray); const bool isArray = m_flags.testFlag(TextureArray);
const bool is1D = m_flags.testFlag(OneDimensional); const bool is1D = m_flags.testFlag(OneDimensional);
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Format = isDepth ? toD3DDepthTextureSRVFormat(m_format) : dxgiFormat; srvDesc.Format = srvFormat;
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
if (isCube) { if (isCube) {
@ -4624,7 +4664,7 @@ QRhiRenderPassDescriptor *QD3D12TextureRenderTarget::newCompatibleRenderPassDesc
QD3D12Texture *texD = QRHI_RES(QD3D12Texture, it->texture()); QD3D12Texture *texD = QRHI_RES(QD3D12Texture, it->texture());
QD3D12RenderBuffer *rbD = QRHI_RES(QD3D12RenderBuffer, it->renderBuffer()); QD3D12RenderBuffer *rbD = QRHI_RES(QD3D12RenderBuffer, it->renderBuffer());
if (texD) if (texD)
rpD->colorFormat[rpD->colorAttachmentCount] = texD->dxgiFormat; rpD->colorFormat[rpD->colorAttachmentCount] = texD->rtFormat;
else if (rbD) else if (rbD)
rpD->colorFormat[rpD->colorAttachmentCount] = rbD->dxgiFormat; rpD->colorFormat[rpD->colorAttachmentCount] = rbD->dxgiFormat;
rpD->colorAttachmentCount += 1; rpD->colorAttachmentCount += 1;
@ -4675,7 +4715,7 @@ bool QD3D12TextureRenderTarget::create()
const bool isMultiView = it->multiViewCount() >= 2; const bool isMultiView = it->multiViewCount() >= 2;
UINT layerCount = isMultiView ? UINT(it->multiViewCount()) : 1; UINT layerCount = isMultiView ? UINT(it->multiViewCount()) : 1;
D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {}; D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
rtvDesc.Format = toD3DTextureFormat(texD->format(), texD->flags()); rtvDesc.Format = texD->rtFormat;
if (texD->flags().testFlag(QRhiTexture::CubeMap)) { if (texD->flags().testFlag(QRhiTexture::CubeMap)) {
rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
rtvDesc.Texture2DArray.MipSlice = UINT(colorAtt.level()); rtvDesc.Texture2DArray.MipSlice = UINT(colorAtt.level());
@ -4749,7 +4789,7 @@ bool QD3D12TextureRenderTarget::create()
return false; return false;
} }
D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = {}; 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 dsvDesc.ViewDimension = depthTexD->sampleDesc.Count > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DMS
: D3D12_DSV_DIMENSION_TEXTURE2D; : D3D12_DSV_DIMENSION_TEXTURE2D;
if (depthTexD->flags().testFlag(QRhiTexture::TextureArray)) { if (depthTexD->flags().testFlag(QRhiTexture::TextureArray)) {
@ -5545,6 +5585,22 @@ static inline DXGI_FORMAT toD3DAttributeFormat(QRhiVertexInputAttribute::Format
return DXGI_FORMAT_R16G16_FLOAT; return DXGI_FORMAT_R16G16_FLOAT;
case QRhiVertexInputAttribute::Half: case QRhiVertexInputAttribute::Half:
return DXGI_FORMAT_R16_FLOAT; 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); Q_UNREACHABLE_RETURN(DXGI_FORMAT_R32G32B32A32_FLOAT);
} }
@ -5678,7 +5734,7 @@ bool QD3D12GraphicsPipeline::create()
} else { } else {
QByteArray sem; QByteArray sem;
sem.resize(16); 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); matrixSliceSemantics.append(sem);
desc.SemanticName = matrixSliceSemantics.last().constData(); desc.SemanticName = matrixSliceSemantics.last().constData();
desc.SemanticIndex = UINT(matrixSlice); desc.SemanticIndex = UINT(matrixSlice);
@ -6105,6 +6161,11 @@ void QD3D12SwapChain::destroy()
dcompTarget = nullptr; dcompTarget = nullptr;
} }
if (frameLatencyWaitableObject) {
CloseHandle(frameLatencyWaitableObject);
frameLatencyWaitableObject = nullptr;
}
QRHI_RES_RHI(QRhiD3D12); QRHI_RES_RHI(QRhiD3D12);
if (rhiD) { if (rhiD) {
rhiD->swapchains.remove(this); rhiD->swapchains.remove(this);
@ -6296,7 +6357,7 @@ bool QD3D12SwapChain::createOrResize()
if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) { if (m_flags.testFlag(SurfaceHasPreMulAlpha) || m_flags.testFlag(SurfaceHasNonPreMulAlpha)) {
if (rhiD->ensureDirectCompositionDevice()) { if (rhiD->ensureDirectCompositionDevice()) {
if (!dcompTarget) { if (!dcompTarget) {
hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, true, &dcompTarget); hr = rhiD->dcompDevice->CreateTargetForHwnd(hwnd, false, &dcompTarget);
if (FAILED(hr)) { if (FAILED(hr)) {
qWarning("Failed to create Direct Composition target for the window: %s", qWarning("Failed to create Direct Composition target for the window: %s",
qPrintable(QSystemError::windowsComString(hr))); qPrintable(QSystemError::windowsComString(hr)));
@ -6321,6 +6382,14 @@ bool QD3D12SwapChain::createOrResize()
if (swapInterval == 0 && rhiD->supportsAllowTearing) if (swapInterval == 0 && rhiD->supportsAllowTearing)
swapChainFlags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING; 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) { if (!swapChain) {
chooseFormats(); chooseFormats();
@ -6377,6 +6446,10 @@ bool QD3D12SwapChain::createOrResize()
qPrintable(QSystemError::windowsComString(hr))); qPrintable(QSystemError::windowsComString(hr)));
} }
} }
if (useFrameLatencyWaitableObject) {
swapChain->SetMaximumFrameLatency(rhiD->maxFrameLatency);
frameLatencyWaitableObject = swapChain->GetFrameLatencyWaitableObject();
}
if (dcompVisual) { if (dcompVisual) {
hr = dcompVisual->SetContent(swapChain); hr = dcompVisual->SetContent(swapChain);
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {

View File

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

View File

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

View File

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

View File

@ -11,7 +11,7 @@
#include "qwindowsintegration.h" #include "qwindowsintegration.h"
#include "qwindowsdropdataobject.h" #include "qwindowsdropdataobject.h"
#include "qwindowswindow.h" #include "qwindowswindow.h"
#include "qwindowsmousehandler.h" #include "qwindowspointerhandler.h"
#include "qwindowscursor.h" #include "qwindowscursor.h"
#include "qwindowskeymapper.h" #include "qwindowskeymapper.h"
@ -344,7 +344,7 @@ QWindowsOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
// In some rare cases, when a mouse button is released but the mouse is static, // 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 // 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. // 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; SCODE result = S_OK;
if (fEscapePressed || QWindowsDrag::isCanceled()) { if (fEscapePressed || QWindowsDrag::isCanceled()) {
@ -369,7 +369,7 @@ QWindowsOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
const QPoint localPos = m_windowUnderMouse->handle()->mapFromGlobal(globalPos); const QPoint localPos = m_windowUnderMouse->handle()->mapFromGlobal(globalPos);
QWindowSystemInterface::handleMouseEvent(m_windowUnderMouse.data(), QWindowSystemInterface::handleMouseEvent(m_windowUnderMouse.data(),
QPointF(localPos), QPointF(globalPos), QPointF(localPos), QPointF(globalPos),
QWindowsMouseHandler::queryMouseButtons(), QWindowsPointerHandler::queryMouseButtons(),
Qt::LeftButton, QEvent::MouseButtonRelease); Qt::LeftButton, QEvent::MouseButtonRelease);
} }
m_currentButtons = Qt::NoButton; m_currentButtons = Qt::NoButton;
@ -463,7 +463,7 @@ void QWindowsOleDropTarget::handleDrag(QWindow *window, DWORD grfKeyState,
const Qt::DropActions actions = translateToQDragDropActions(*pdwEffect); const Qt::DropActions actions = translateToQDragDropActions(*pdwEffect);
lastModifiers = toQtKeyboardModifiers(grfKeyState); lastModifiers = toQtKeyboardModifiers(grfKeyState);
lastButtons = QWindowsMouseHandler::queryMouseButtons(); lastButtons = QWindowsPointerHandler::queryMouseButtons();
const QPlatformDragQtResponse response = const QPlatformDragQtResponse response =
QWindowSystemInterface::handleDrag(window, windowsDrag->dropData(), QWindowSystemInterface::handleDrag(window, windowsDrag->dropData(),
@ -533,7 +533,7 @@ QWindowsOleDropTarget::DragLeave()
const auto *keyMapper = QWindowsContext::instance()->keyMapper(); const auto *keyMapper = QWindowsContext::instance()->keyMapper();
lastModifiers = keyMapper->queryKeyboardModifiers(); lastModifiers = keyMapper->queryKeyboardModifiers();
lastButtons = QWindowsMouseHandler::queryMouseButtons(); lastButtons = QWindowsPointerHandler::queryMouseButtons();
QWindowSystemInterface::handleDrag(m_window, nullptr, QPoint(), Qt::IgnoreAction, QWindowSystemInterface::handleDrag(m_window, nullptr, QPoint(), Qt::IgnoreAction,
Qt::NoButton, Qt::NoModifier); Qt::NoButton, Qt::NoModifier);
@ -562,7 +562,7 @@ QWindowsOleDropTarget::Drop(LPDATAOBJECT pDataObj, DWORD grfKeyState,
QWindowsDrag *windowsDrag = QWindowsDrag::instance(); QWindowsDrag *windowsDrag = QWindowsDrag::instance();
lastModifiers = toQtKeyboardModifiers(grfKeyState); lastModifiers = toQtKeyboardModifiers(grfKeyState);
lastButtons = QWindowsMouseHandler::queryMouseButtons(); lastButtons = QWindowsPointerHandler::queryMouseButtons();
const QPlatformDropQtResponse response = const QPlatformDropQtResponse response =
QWindowSystemInterface::handleDrop(m_window, windowsDrag->dropData(), QWindowSystemInterface::handleDrop(m_window, windowsDrag->dropData(),

View File

@ -806,7 +806,7 @@ static void showSystemMenu(QWindow* w)
qWindowsWndProc(topLevelHwnd, WM_SYSCOMMAND, WPARAM(ret), 0); 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, Qt::KeyboardModifiers mods,
quint32 nativeScanCode, quint32 nativeScanCode,
quint32 nativeVirtualKey, quint32 nativeVirtualKey,
@ -815,8 +815,8 @@ static inline void sendExtendedPressRelease(QWindow *w, int k,
bool autorep = false, bool autorep = false,
ushort count = 1) ushort count = 1)
{ {
QWindowSystemInterface::handleExtendedKeyEvent(w, QEvent::KeyPress, 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, QEvent::KeyRelease, 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]); const int qtKey = int(CmdTbl[cmd]);
if (!skipPressRelease) 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, // 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. // the keys are not passed to the active media player.
# if QT_CONFIG(shortcut) # if QT_CONFIG(shortcut)
@ -963,7 +963,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
// A multi-character key or a Input method character // A multi-character key or a Input method character
// not found by our look-ahead // not found by our look-ahead
if (msgType == WM_CHAR || msgType == WM_IME_CHAR) { 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; return true;
} }
@ -998,14 +998,14 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
if (dirStatus == VK_LSHIFT if (dirStatus == VK_LSHIFT
&& ((msg.wParam == VK_SHIFT && GetKeyState(VK_LCONTROL)) && ((msg.wParam == VK_SHIFT && GetKeyState(VK_LCONTROL))
|| (msg.wParam == VK_CONTROL && GetKeyState(VK_LSHIFT)))) { || (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); scancode, vk_key, nModifiers, QString(), false);
result = true; result = true;
dirStatus = 0; dirStatus = 0;
} else if (dirStatus == VK_RSHIFT } else if (dirStatus == VK_RSHIFT
&& ( (msg.wParam == VK_SHIFT && GetKeyState(VK_RCONTROL)) && ( (msg.wParam == VK_SHIFT && GetKeyState(VK_RCONTROL))
|| (msg.wParam == VK_CONTROL && GetKeyState(VK_RSHIFT)))) { || (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); scancode, vk_key, nModifiers, QString(), false);
result = true; result = true;
dirStatus = 0; dirStatus = 0;
@ -1218,9 +1218,9 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
// so, we have an auto-repeating key // so, we have an auto-repeating key
if (rec) { if (rec) {
if (code < Qt::Key_Shift || code > Qt::Key_ScrollLock) { 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); 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); Qt::KeyboardModifier(state), scancode, quint32(msg.wParam), nModifiers, rec->text, true);
result = true; result = true;
} }
@ -1246,7 +1246,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
if (msg.wParam == VK_PACKET) if (msg.wParam == VK_PACKET)
code = asciiToKeycode(char(uch.cell()), state); 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); modifiers, scancode, quint32(msg.wParam), nModifiers, text, false);
result =true; result =true;
bool store = true; bool store = true;
@ -1288,10 +1288,10 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
if ((msg.lParam & 0x40000000) == 0 && if ((msg.lParam & 0x40000000) == 0 &&
Qt::KeyboardModifier(state) == Qt::NoModifier && Qt::KeyboardModifier(state) == Qt::NoModifier &&
((code == Qt::Key_F18) || (code == Qt::Key_F19) || (code == Qt::Key_F20))) { ((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, Qt::MetaModifier, scancode,
quint32(msg.wParam), MetaLeft); quint32(msg.wParam), MetaLeft);
QWindowSystemInterface::handleExtendedKeyEvent(receiver, QEvent::KeyRelease, code, QWindowSystemInterface::handleExtendedKeyEvent(receiver, msg.time, QEvent::KeyRelease, code,
Qt::NoModifier, scancode, Qt::NoModifier, scancode,
quint32(msg.wParam), 0); quint32(msg.wParam), 0);
result = true; result = true;
@ -1303,7 +1303,7 @@ bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, MSG msg,
// Map SHIFT + Tab to SHIFT + BackTab, QShortcutMap knows about this translation // Map SHIFT + Tab to SHIFT + BackTab, QShortcutMap knows about this translation
if (code == Qt::Key_Tab && (state & Qt::ShiftModifier) == Qt::ShiftModifier) if (code == Qt::Key_Tab && (state & Qt::ShiftModifier) == Qt::ShiftModifier)
code = Qt::Key_Backtab; 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), Qt::KeyboardModifier(state), scancode, quint32(msg.wParam),
nModifiers, nModifiers,
(rec ? rec->text : QString()), false); (rec ? rec->text : QString()), false);

View File

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

View File

@ -13,19 +13,20 @@
# include "qwindowssystemtrayicon.h" # include "qwindowssystemtrayicon.h"
#endif #endif
#include "qwindowsscreen.h" #include "qwindowsscreen.h"
#include "qwindowswindow.h"
#include <commctrl.h> #include <commctrl.h>
#include <objbase.h> #include <objbase.h>
#ifndef Q_CC_MINGW #include <commoncontrols.h>
# include <commoncontrols.h>
#endif
#include <shellapi.h> #include <shellapi.h>
#include <QtCore/qapplicationstatic.h>
#include <QtCore/qvariant.h> #include <QtCore/qvariant.h>
#include <QtCore/qcoreapplication.h> #include <QtCore/qcoreapplication.h>
#include <QtCore/qdebug.h> #include <QtCore/qdebug.h>
#include <QtCore/qsysinfo.h> #include <QtCore/qsysinfo.h>
#include <QtCore/qcache.h> #include <QtCore/qcache.h>
#include <QtCore/qthread.h> #include <QtCore/qthread.h>
#include <QtCore/qqueue.h>
#include <QtCore/qmutex.h> #include <QtCore/qmutex.h>
#include <QtCore/qwaitcondition.h> #include <QtCore/qwaitcondition.h>
#include <QtCore/qoperatingsystemversion.h> #include <QtCore/qoperatingsystemversion.h>
@ -52,10 +53,6 @@
# include <winrt/Windows.UI.ViewManagement.h> # include <winrt/Windows.UI.ViewManagement.h>
#endif // QT_CONFIG(cpp_winrt) #endif // QT_CONFIG(cpp_winrt)
#if defined(__IImageList_INTERFACE_DEFINED__) && defined(__IID_DEFINED__)
# define USE_IIMAGELIST
#endif
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals; using namespace Qt::StringLiterals;
@ -85,7 +82,11 @@ static inline QColor mixColors(const QColor &c1, const QColor &c2)
enum AccentColorLevel { enum AccentColorLevel {
AccentColorDarkest, AccentColorDarkest,
AccentColorDarker,
AccentColorDark,
AccentColorNormal, AccentColorNormal,
AccentColorLight,
AccentColorLighter,
AccentColorLightest AccentColorLightest
}; };
@ -100,6 +101,10 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
{ {
QColor accent; QColor accent;
QColor accentLight; QColor accentLight;
QColor accentLighter;
QColor accentLightest;
QColor accentDark;
QColor accentDarker;
QColor accentDarkest; QColor accentDarkest;
#if QT_CONFIG(cpp_winrt) #if QT_CONFIG(cpp_winrt)
@ -109,6 +114,10 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
const auto settings = UISettings(); const auto settings = UISettings();
accent = getSysColor(settings.GetColorValue(UIColorType::Accent)); accent = getSysColor(settings.GetColorValue(UIColorType::Accent));
accentLight = getSysColor(settings.GetColorValue(UIColorType::AccentLight1)); 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)); accentDarkest = getSysColor(settings.GetColorValue(UIColorType::AccentDark3));
} }
#endif #endif
@ -128,14 +137,30 @@ static constexpr QColor getSysColor(winrt::Windows::UI::Color &&color)
return {}; return {};
accent = QColor::fromRgb(abgr.blue(), abgr.green(), abgr.red(), abgr.alpha()); accent = QColor::fromRgb(abgr.blue(), abgr.green(), abgr.red(), abgr.alpha());
accentLight = accent.lighter(120); accentLight = accent.lighter(120);
accentLighter = accentLight.lighter(120);
accentLightest = accentLighter.lighter(120);
accentDarkest = accent.darker(120 * 120 * 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; return accentDarkest;
else if (level == AccentColorLightest) case AccentColorDarker:
return accentDarker;
case AccentColorDark:
return accentDark;
case AccentColorLight:
return accentLight; return accentLight;
case AccentColorLighter:
return accentLighter;
case AccentColorLightest:
return accentLightest;
default:
return accent; return accent;
}
} }
static inline QColor getSysColor(int index) 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 // models has been observed to trigger a WM_PAINT on the mainwindow. Suppress the
// behavior by running it in a thread. // 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 class QShGetFileInfoThread : public QThread
{ {
public: public:
explicit QShGetFileInfoThread() struct Task
: QThread(), m_params(nullptr)
{ {
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 void run() override
{ {
QComHelper comHelper(COINIT_MULTITHREADED); QComHelper comHelper(COINIT_MULTITHREADED);
QMutexLocker readyLocker(&m_readyMutex); while (!isInterruptionRequested()) {
while (!m_cancelled.loadRelaxed()) { auto task = getNextTask();
if (!m_params && !m_cancelled.loadRelaxed() if (task) {
&& !m_readyCondition.wait(&m_readyMutex, QDeadlineTimer(1000ll)))
continue;
if (m_params) {
const QString fileName = m_params->fileName;
SHFILEINFO info; SHFILEINFO info;
const bool result = SHGetFileInfo(reinterpret_cast<const wchar_t *>(fileName.utf16()), const bool result = SHGetFileInfo(reinterpret_cast<const wchar_t *>(task->fileName.utf16()),
m_params->attributes, &info, sizeof(SHFILEINFO), task->attributes, &info, sizeof(SHFILEINFO),
m_params->flags); task->flags);
m_doneMutex.lock(); if (result) {
if (!m_cancelled.loadRelaxed()) { task->hIcon = info.hIcon;
*m_params->result = result; task->iIcon = info.iIcon;
memcpy(m_params->info, &info, sizeof(SHFILEINFO));
} }
m_params = nullptr; task->finished = true;
m_doneCondition.wakeAll(); 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); QMutexLocker doneLocker(&m_doneMutex);
while (!task->finished && !isInterruptionRequested()) {
m_readyMutex.lock(); if (!m_doneCondition.wait(&m_doneMutex, QDeadlineTimer(timeout)))
m_params = params; return;
m_readyCondition.wakeAll(); }
m_readyMutex.unlock();
return m_doneCondition.wait(&m_doneMutex, QDeadlineTimer(timeOutMSecs));
} }
void cancel() void cancel()
{ {
QMutexLocker doneLocker(&m_doneMutex); requestInterruption();
m_cancelled.storeRelaxed(1); m_doneCondition.wakeAll();
m_readyCondition.wakeAll(); m_waitForTaskCondition.wakeAll();
} }
private: private:
QShGetFileInfoParams *m_params; QQueue<QSharedPointer<Task>> m_taskQueue;
QAtomicInt m_cancelled;
QWaitCondition m_readyCondition;
QWaitCondition m_doneCondition; QWaitCondition m_doneCondition;
QMutex m_readyMutex; QWaitCondition m_waitForTaskCondition;
QMutex m_doneMutex; QMutex m_doneMutex;
QMutex m_waitForTaskMutex;
}; };
Q_APPLICATION_STATIC(QShGetFileInfoThread, s_shGetFileInfoThread)
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;
}
// from QStyle::standardPalette // from QStyle::standardPalette
static inline QPalette 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 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. 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 background = getSysColor(COLOR_BTNFACE);
const QColor textColor = getSysColor(COLOR_WINDOWTEXT); 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 accentDarkest = qt_accentColor(AccentColorDarkest);
const QColor linkColor = accent; const QColor linkColor = accentDarker;
const QColor btnFace = background; const QColor btnFace = background;
const QColor btnHighlight = getSysColor(COLOR_BTNHIGHLIGHT); 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::Midlight, getSysColor(COLOR_3DLIGHT));
result.setColor(QPalette::Shadow, getSysColor(COLOR_3DDKSHADOW)); result.setColor(QPalette::Shadow, getSysColor(COLOR_3DDKSHADOW));
result.setColor(QPalette::HighlightedText, getSysColor(COLOR_HIGHLIGHTTEXT)); 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::Link, linkColor);
result.setColor(QPalette::LinkVisited, accentDarkest); result.setColor(QPalette::LinkVisited, accentDarkest);
@ -317,7 +342,7 @@ static void populateLightSystemBasePalette(QPalette &result)
result.setColor(QPalette::Midlight, result.button().color().lighter(110)); result.setColor(QPalette::Midlight, result.button().color().lighter(110));
} }
static void populateDarkSystemBasePalette(QPalette &result) void QWindowsTheme::populateDarkSystemBasePalette(QPalette &result)
{ {
QColor foreground = Qt::white; QColor foreground = Qt::white;
QColor background = QColor(0x1E, 0x1E, 0x1E); QColor background = QColor(0x1E, 0x1E, 0x1E);
@ -338,6 +363,8 @@ static void populateDarkSystemBasePalette(QPalette &result)
// We have to craft a palette from these colors. The settings.UIElementColor(UIElementType) API // 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 // 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. // usually), then override it with a dark gray instead so that we can go up and down the lightness.
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)); foreground = getSysColor(settings.GetColorValue(UIColorType::Foreground));
background = [&settings]() -> QColor { background = [&settings]() -> QColor {
auto systemBackground = getSysColor(settings.GetColorValue(UIColorType::Background)); auto systemBackground = getSysColor(settings.GetColorValue(UIColorType::Background));
@ -345,18 +372,18 @@ static void populateDarkSystemBasePalette(QPalette &result)
systemBackground = QColor(0x1E, 0x1E, 0x1E); systemBackground = QColor(0x1E, 0x1E, 0x1E);
return systemBackground; return systemBackground;
}(); }();
accent = qt_accentColor(AccentColorNormal);
accent = getSysColor(settings.GetColorValue(UIColorType::Accent)); accentDark = qt_accentColor(AccentColorDark);
accentDark = getSysColor(settings.GetColorValue(UIColorType::AccentDark1)); accentDarker = qt_accentColor(AccentColorDarker);
accentDarker = getSysColor(settings.GetColorValue(UIColorType::AccentDark2)); accentDarkest = qt_accentColor(AccentColorDarkest);
accentDarkest = getSysColor(settings.GetColorValue(UIColorType::AccentDark3)); accentLight = qt_accentColor(AccentColorLight);
accentLight = getSysColor(settings.GetColorValue(UIColorType::AccentLight1)); accentLighter = qt_accentColor(AccentColorLighter);
accentLighter = getSysColor(settings.GetColorValue(UIColorType::AccentLight2)); accentLightest = qt_accentColor(AccentColorLightest);
accentLightest = getSysColor(settings.GetColorValue(UIColorType::AccentLight3)); }
} }
#endif #endif
const QColor linkColor = accent; const QColor linkColor = accentLightest;
const QColor buttonColor = background.lighter(200); const QColor buttonColor = background.lighter(200);
result.setColor(QPalette::All, QPalette::WindowText, foreground); 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::Highlight, accent);
result.setColor(QPalette::All, QPalette::HighlightedText, accent.lightness() > 128 ? Qt::black : Qt::white); 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::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::AlternateBase, accentDarkest);
result.setColor(QPalette::All, QPalette::ToolTipBase, buttonColor); result.setColor(QPalette::All, QPalette::ToolTipBase, buttonColor);
result.setColor(QPalette::All, QPalette::ToolTipText, foreground.darker(120)); result.setColor(QPalette::All, QPalette::ToolTipText, foreground.darker(120));
result.setColor(QPalette::All, QPalette::PlaceholderText, placeHolderColor(foreground)); 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) static inline QPalette toolTipPalette(const QPalette &systemPalette, bool light)
@ -474,6 +501,7 @@ QWindowsTheme *QWindowsTheme::m_instance = nullptr;
QWindowsTheme::QWindowsTheme() QWindowsTheme::QWindowsTheme()
{ {
m_instance = this; m_instance = this;
s_colorScheme = QWindowsTheme::queryColorScheme();
std::fill(m_fonts, m_fonts + NFonts, nullptr); std::fill(m_fonts, m_fonts + NFonts, nullptr);
std::fill(m_palettes, m_palettes + NPalettes, nullptr); std::fill(m_palettes, m_palettes + NPalettes, nullptr);
refresh(); refresh();
@ -562,10 +590,44 @@ QVariant QWindowsTheme::themeHint(ThemeHint hint) const
} }
Qt::ColorScheme QWindowsTheme::colorScheme() const Qt::ColorScheme QWindowsTheme::colorScheme() const
{
return QWindowsTheme::effectiveColorScheme();
}
Qt::ColorScheme QWindowsTheme::effectiveColorScheme()
{ {
if (queryHighContrast()) if (queryHighContrast())
return Qt::ColorScheme::Unknown; 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;
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() void QWindowsTheme::clearPalettes()
@ -579,17 +641,17 @@ void QWindowsTheme::refreshPalettes()
if (!QGuiApplication::desktopSettingsAware()) if (!QGuiApplication::desktopSettingsAware())
return; return;
const bool light = const bool light =
!QWindowsContext::isDarkMode() effectiveColorScheme() != Qt::ColorScheme::Dark
|| !QWindowsIntegration::instance()->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle); || !QWindowsIntegration::instance()->darkModeHandling().testFlag(QWindowsApplication::DarkModeStyle);
clearPalettes(); 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[ToolTipPalette] = new QPalette(toolTipPalette(*m_palettes[SystemPalette], light));
m_palettes[MenuPalette] = new QPalette(menuPalette(*m_palettes[SystemPalette], light)); m_palettes[MenuPalette] = new QPalette(menuPalette(*m_palettes[SystemPalette], light));
m_palettes[MenuBarPalette] = menuBarPalette(*m_palettes[MenuPalette], light); m_palettes[MenuBarPalette] = menuBarPalette(*m_palettes[MenuPalette], light);
if (!light) { if (!light) {
m_palettes[CheckBoxPalette] = new QPalette(*m_palettes[SystemPalette]); 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::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[CheckBoxPalette]->setColor(QPalette::Inactive, QPalette::Base, qt_accentColor(AccentColorDarkest));
m_palettes[RadioButtonPalette] = new QPalette(*m_palettes[CheckBoxPalette]); m_palettes[RadioButtonPalette] = new QPalette(*m_palettes[CheckBoxPalette]);
} }
@ -600,15 +662,15 @@ QPalette QWindowsTheme::systemPalette(Qt::ColorScheme colorScheme)
QPalette result = standardPalette(); QPalette result = standardPalette();
switch (colorScheme) { 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: case Qt::ColorScheme::Light:
populateLightSystemBasePalette(result); populateLightSystemBasePalette(result);
break; break;
case Qt::ColorScheme::Dark: case Qt::ColorScheme::Dark:
populateDarkSystemBasePalette(result); populateDarkSystemBasePalette(result);
break; break;
default:
qFatal("Unknown color scheme");
break;
} }
if (result.window() != result.base()) { if (result.window() != result.base()) {
@ -750,11 +812,7 @@ void QWindowsTheme::refreshIconPixmapSizes()
fileIconSizes[LargeFileIcon] + fileIconSizes[LargeFileIcon] / 2; fileIconSizes[LargeFileIcon] + fileIconSizes[LargeFileIcon] / 2;
fileIconSizes[JumboFileIcon] = 8 * fileIconSizes[LargeFileIcon]; // empirical, has not been observed to work fileIconSizes[JumboFileIcon] = 8 * fileIconSizes[LargeFileIcon]; // empirical, has not been observed to work
#ifdef USE_IIMAGELIST
int *availEnd = fileIconSizes + JumboFileIcon + 1; int *availEnd = fileIconSizes + JumboFileIcon + 1;
#else
int *availEnd = fileIconSizes + LargeFileIcon + 1;
#endif // USE_IIMAGELIST
m_fileIconSizes = QAbstractFileIconEngine::toSizeList(fileIconSizes, availEnd); m_fileIconSizes = QAbstractFileIconEngine::toSizeList(fileIconSizes, availEnd);
qCDebug(lcQpaWindow) << __FUNCTION__ << m_fileIconSizes; qCDebug(lcQpaWindow) << __FUNCTION__ << m_fileIconSizes;
} }
@ -948,10 +1006,10 @@ public:
// Shell image list helper functions. // Shell image list helper functions.
static QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info) static QPixmap pixmapFromShellImageList(int iImageList, int iIcon)
{ {
QPixmap result; QPixmap result;
#ifdef USE_IIMAGELIST
// For MinGW: // For MinGW:
static const IID iID_IImageList = {0x46eb5926, 0x582e, 0x4017, {0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x9, 0x50}}; static const IID iID_IImageList = {0x46eb5926, 0x582e, 0x4017, {0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x9, 0x50}};
@ -960,16 +1018,13 @@ static QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info)
if (hr != S_OK) if (hr != S_OK)
return result; return result;
HICON hIcon; HICON hIcon;
hr = imageList->GetIcon(info.iIcon, ILD_TRANSPARENT, &hIcon); hr = imageList->GetIcon(iIcon, ILD_TRANSPARENT, &hIcon);
if (hr == S_OK) { if (hr == S_OK) {
result = qt_pixmapFromWinHICON(hIcon); result = qt_pixmapFromWinHICON(hIcon);
DestroyIcon(hIcon); DestroyIcon(hIcon);
} }
imageList->Release(); imageList->Release();
#else
Q_UNUSED(iImageList);
Q_UNUSED(info);
#endif // USE_IIMAGELIST
return result; return result;
} }
@ -1021,13 +1076,9 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
const int width = int(size.width()); const int width = int(size.width());
const int iconSize = width > fileIconSizes[SmallFileIcon] ? SHGFI_LARGEICON : SHGFI_SMALLICON; const int iconSize = width > fileIconSizes[SmallFileIcon] ? SHGFI_LARGEICON : SHGFI_SMALLICON;
const int requestedImageListSize = const int requestedImageListSize =
#ifdef USE_IIMAGELIST
width > fileIconSizes[ExtraLargeFileIcon] width > fileIconSizes[ExtraLargeFileIcon]
? sHIL_JUMBO ? sHIL_JUMBO
: (width > fileIconSizes[LargeFileIcon] ? sHIL_EXTRALARGE : 0); : (width > fileIconSizes[LargeFileIcon] ? sHIL_EXTRALARGE : 0);
#else
0;
#endif // !USE_IIMAGELIST
bool cacheableDirIcon = fileInfo().isDir() && !fileInfo().isRoot(); bool cacheableDirIcon = fileInfo().isDir() && !fileInfo().isRoot();
if (cacheableDirIcon) { if (cacheableDirIcon) {
QMutexLocker locker(&mx); QMutexLocker locker(&mx);
@ -1043,7 +1094,6 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
} }
} }
SHFILEINFO info;
unsigned int flags = SHGFI_ICON | iconSize | SHGFI_SYSICONINDEX | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX; unsigned int flags = SHGFI_ICON | iconSize | SHGFI_SYSICONINDEX | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX;
DWORD attributes = 0; DWORD attributes = 0;
QString path = filePath; QString path = filePath;
@ -1055,43 +1105,43 @@ QPixmap QWindowsFileIconEngine::filePixmap(const QSize &size, QIcon::Mode, QIcon
flags |= SHGFI_USEFILEATTRIBUTES; flags |= SHGFI_USEFILEATTRIBUTES;
attributes |= FILE_ATTRIBUTE_NORMAL; 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 // Even if GetFileInfo returns a valid result, hIcon can be empty in some cases
if (val && info.hIcon) { if (task->resultValid()) {
QString key; QString key;
if (cacheableDirIcon) { if (cacheableDirIcon) {
if (useDefaultFolderIcon && defaultFolderIIcon < 0) if (useDefaultFolderIcon && defaultFolderIIcon < 0)
defaultFolderIIcon = info.iIcon; defaultFolderIIcon = task->iIcon;
//using the unique icon index provided by windows save us from duplicate keys //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); QPixmapCache::find(key, &pixmap);
if (!pixmap.isNull()) { if (!pixmap.isNull()) {
QMutexLocker locker(&mx); QMutexLocker locker(&mx);
dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon)); dirIconEntryCache.insert(filePath, FakePointer<int>::create(task->iIcon));
} }
} }
if (pixmap.isNull()) { if (pixmap.isNull()) {
if (requestedImageListSize) { if (requestedImageListSize) {
pixmap = pixmapFromShellImageList(requestedImageListSize, info); pixmap = pixmapFromShellImageList(requestedImageListSize, task->iIcon);
if (pixmap.isNull() && requestedImageListSize == sHIL_JUMBO) if (pixmap.isNull() && requestedImageListSize == sHIL_JUMBO)
pixmap = pixmapFromShellImageList(sHIL_EXTRALARGE, info); pixmap = pixmapFromShellImageList(sHIL_EXTRALARGE, task->iIcon);
} }
if (pixmap.isNull()) if (pixmap.isNull())
pixmap = qt_pixmapFromWinHICON(info.hIcon); pixmap = qt_pixmapFromWinHICON(task->hIcon);
if (!pixmap.isNull()) { if (!pixmap.isNull()) {
if (cacheableDirIcon) { if (cacheableDirIcon) {
QMutexLocker locker(&mx); QMutexLocker locker(&mx);
QPixmapCache::insert(key, pixmap); QPixmapCache::insert(key, pixmap);
dirIconEntryCache.insert(filePath, FakePointer<int>::create(info.iIcon)); dirIconEntryCache.insert(filePath, FakePointer<int>::create(task->iIcon));
} }
} else { } else {
qWarning("QWindowsTheme::fileIconPixmap() no icon found"); qWarning("QWindowsTheme::fileIconPixmap() no icon found");
} }
} }
DestroyIcon(info.hIcon);
} }
return pixmap; return pixmap;
@ -1131,14 +1181,14 @@ bool QWindowsTheme::useNativeMenus()
return result; return result;
} }
bool QWindowsTheme::queryDarkMode() Qt::ColorScheme QWindowsTheme::queryColorScheme()
{ {
if (queryHighContrast()) { if (queryHighContrast())
return false; return Qt::ColorScheme::Unknown;
}
const auto setting = QWinRegistryKey(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)") const auto setting = QWinRegistryKey(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)")
.dwordValue(L"AppsUseLightTheme"); .dwordValue(L"AppsUseLightTheme");
return setting.second && setting.first == 0; return setting.second && setting.first == 0 ? Qt::ColorScheme::Dark : Qt::ColorScheme::Light;
} }
bool QWindowsTheme::queryHighContrast() bool QWindowsTheme::queryHighContrast()

View File

@ -5,6 +5,7 @@
#include "qwindowswindow.h" #include "qwindowswindow.h"
#include "qwindowscontext.h" #include "qwindowscontext.h"
#include "qwindowstheme.h"
#if QT_CONFIG(draganddrop) #if QT_CONFIG(draganddrop)
# include "qwindowsdrag.h" # include "qwindowsdrag.h"
#endif #endif
@ -867,7 +868,8 @@ static inline bool shouldApplyDarkFrame(const QWindow *w)
{ {
if (!w->isTopLevel() || w->flags().testFlag(Qt::FramelessWindowHint)) if (!w->isTopLevel() || w->flags().testFlag(Qt::FramelessWindowHint))
return false; 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)) if (!QWindowsIntegration::instance()->darkModeHandling().testFlag(QWindowsApplication::DarkModeWindowFrames))
return false; return false;
@ -947,7 +949,7 @@ QWindowsWindowData
return result; return result;
} }
if (QWindowsContext::isDarkMode() && shouldApplyDarkFrame(w)) if (QWindowsTheme::instance()->colorScheme() == Qt::ColorScheme::Dark && shouldApplyDarkFrame(w))
QWindowsWindow::setDarkBorderToWindow(result.hwnd, true); QWindowsWindow::setDarkBorderToWindow(result.hwnd, true);
if (mirrorParentWidth != 0) { if (mirrorParentWidth != 0) {
@ -1387,6 +1389,12 @@ QWindowsForeignWindow::QWindowsForeignWindow(QWindow *window, HWND hwnd)
setParent(QPlatformWindow::parent()); setParent(QPlatformWindow::parent());
} }
QWindowsForeignWindow::~QWindowsForeignWindow()
{
if (QPlatformWindow::parent())
setParent(nullptr);
}
void QWindowsForeignWindow::setParent(const QPlatformWindow *newParentWindow) void QWindowsForeignWindow::setParent(const QPlatformWindow *newParentWindow)
{ {
const bool wasTopLevel = isTopLevel_sys(); const bool wasTopLevel = isTopLevel_sys();
@ -2739,7 +2747,7 @@ bool QWindowsWindow::windowEvent(QEvent *event)
{ {
switch (event->type()) { switch (event->type()) {
case QEvent::ApplicationPaletteChange: case QEvent::ApplicationPaletteChange:
setDarkBorder(QWindowsContext::isDarkMode()); setDarkBorder(QWindowsTheme::instance()->colorScheme() == Qt::ColorScheme::Dark);
break; break;
case QEvent::WindowBlocked: // Blocked by another modal window. case QEvent::WindowBlocked: // Blocked by another modal window.
setEnabled(false); setEnabled(false);
@ -3335,17 +3343,6 @@ enum : WORD {
DwmwaUseImmersiveDarkModeBefore20h1 = 19 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) bool QWindowsWindow::setDarkBorderToWindow(HWND hwnd, bool d)
{ {
const BOOL darkBorder = d ? TRUE : FALSE; const BOOL darkBorder = d ? TRUE : FALSE;
@ -3361,8 +3358,6 @@ void QWindowsWindow::setDarkBorder(bool d)
{ {
// respect explicit opt-out and incompatible palettes or styles // respect explicit opt-out and incompatible palettes or styles
d = d && shouldApplyDarkFrame(window()); d = d && shouldApplyDarkFrame(window());
if (queryDarkBorder(m_data.hwnd) == d)
return;
setDarkBorderToWindow(m_data.hwnd, d); setDarkBorderToWindow(m_data.hwnd, d);
} }

View File

@ -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)

View File

@ -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 QPair<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)

View File

@ -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

View File

@ -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

View File

@ -90,11 +90,6 @@ enum QSliderDirection { SlUp, SlDown, SlLeft, SlRight };
QWindowsStylePrivate::QWindowsStylePrivate() = default; QWindowsStylePrivate::QWindowsStylePrivate() = default;
qreal QWindowsStylePrivate::appDevicePixelRatio()
{
return qApp->devicePixelRatio();
}
// Returns \c true if the toplevel parent of \a widget has seen the Alt-key // Returns \c true if the toplevel parent of \a widget has seen the Alt-key
bool QWindowsStylePrivate::hasSeenAlt(const QWidget *widget) const bool QWindowsStylePrivate::hasSeenAlt(const QWidget *widget) const
{ {
@ -459,46 +454,6 @@ int QWindowsStyle::pixelMetric(PixelMetric pm, const QStyleOption *opt, const QW
QPixmap QWindowsStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt, QPixmap QWindowsStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
const QWidget *widget) const 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); return QCommonStyle::standardPixmap(standardPixmap, opt, widget);
} }