From 087591ff0090d0417dfda10968a0411caab4a7c0 Mon Sep 17 00:00:00 2001
From: Sine Striker <trueful@163.com>
Date: 周六, 23 12月 2023 16:43:42 +0800
Subject: [PATCH] Update document
---
src/core/contexts/win32windowcontext.cpp | 678 ++++++++++++++++++++++++++++++--------------------------
1 files changed, 362 insertions(+), 316 deletions(-)
diff --git a/src/core/contexts/win32windowcontext.cpp b/src/core/contexts/win32windowcontext.cpp
index cda9058..146ce65 100644
--- a/src/core/contexts/win32windowcontext.cpp
+++ b/src/core/contexts/win32windowcontext.cpp
@@ -10,8 +10,6 @@
#include <QtGui/QPalette>
#include <QtGui/QStyleHints>
-#include <QtCore/private/qwinregistry_p.h>
-#include <QtCore/private/qsystemlibrary_p.h>
#include <QtGui/private/qhighdpiscaling_p.h>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
# include <QtGui/private/qguiapplication_p.h>
@@ -23,44 +21,16 @@
# include <QtGui/qpa/qplatformwindow_p.h>
#endif
-#include <shellscalingapi.h>
-#include <dwmapi.h>
-#include <timeapi.h>
+#include <QWKCore/qwkconfig.h>
#include "qwkglobal_p.h"
+#include "qwkwindowsextra_p.h"
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
Q_DECLARE_METATYPE(QMargins)
#endif
namespace QWK {
-
- enum _DWMWINDOWATTRIBUTE {
- // [set] BOOL, Allows the use of host backdrop brushes for the window.
- _DWMWA_USE_HOSTBACKDROPBRUSH = 17,
-
- // Undocumented, the same with DWMWA_USE_IMMERSIVE_DARK_MODE, but available on systems
- // before Win10 20H1.
- _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 = 19,
-
- // [set] BOOL, Allows a window to either use the accent color, or dark, according to the
- // user Color Mode preferences.
- _DWMWA_USE_IMMERSIVE_DARK_MODE = 20,
-
- // [set] WINDOW_CORNER_PREFERENCE, Controls the policy that rounds top-level window corners
- _DWMWA_WINDOW_CORNER_PREFERENCE = 33,
-
- // [get] UINT, width of the visible border around a thick frame window
- _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS = 37,
-
- // [get, set] SYSTEMBACKDROP_TYPE, Controls the system-drawn backdrop material of a window,
- // including behind the non-client area.
- _DWMWA_SYSTEMBACKDROP_TYPE = 38,
-
- // Undocumented, use this value to enable Mica material on Win11 21H2. You should use
- // DWMWA_SYSTEMBACKDROP_TYPE instead on Win11 22H2 and newer.
- _DWMWA_MICA_EFFECT = 1029
- };
// The thickness of an auto-hide taskbar in pixels.
static constexpr const quint8 kAutoHideTaskBarThickness = 2;
@@ -78,251 +48,6 @@
// Original Qt window proc function
static WNDPROC g_qtWindowProc = nullptr;
-
- struct DynamicApis {
- static const DynamicApis &instance() {
- static const DynamicApis inst{};
- return inst;
- }
-
- // template <typename T>
- // struct DefaultFunc;
- //
- // template <typename Return, typename... Args>
- // struct DefaultFunc<Return(QT_WIN_CALLBACK *)(Args...)> {
- // static Return STDAPICALLTYPE func(Args...) {
- // return Return{};
- // }
- // };
- //
- // #define DYNAMIC_API_DECLARE(NAME) decltype(&::NAME) p##NAME =
- // DefaultFunc<decltype(&::NAME)>::func
-
-#define DYNAMIC_API_DECLARE(NAME) decltype(&::NAME) p##NAME = nullptr
-
- DYNAMIC_API_DECLARE(DwmFlush);
- DYNAMIC_API_DECLARE(DwmIsCompositionEnabled);
- DYNAMIC_API_DECLARE(DwmGetCompositionTimingInfo);
- DYNAMIC_API_DECLARE(DwmGetWindowAttribute);
- DYNAMIC_API_DECLARE(DwmSetWindowAttribute);
- DYNAMIC_API_DECLARE(GetDpiForWindow);
- DYNAMIC_API_DECLARE(GetSystemMetricsForDpi);
- DYNAMIC_API_DECLARE(GetDpiForMonitor);
- DYNAMIC_API_DECLARE(timeGetDevCaps);
- DYNAMIC_API_DECLARE(timeBeginPeriod);
- DYNAMIC_API_DECLARE(timeEndPeriod);
-
-#undef DYNAMIC_API_DECLARE
-
- private:
- DynamicApis() {
-#define DYNAMIC_API_RESOLVE(DLL, NAME) \
- p##NAME = reinterpret_cast<decltype(p##NAME)>(DLL.resolve(#NAME))
-
- QSystemLibrary user32(QStringLiteral("user32"));
- DYNAMIC_API_RESOLVE(user32, GetDpiForWindow);
- DYNAMIC_API_RESOLVE(user32, GetSystemMetricsForDpi);
-
- QSystemLibrary shcore(QStringLiteral("shcore"));
- DYNAMIC_API_RESOLVE(shcore, GetDpiForMonitor);
-
- QSystemLibrary dwmapi(QStringLiteral("dwmapi"));
- DYNAMIC_API_RESOLVE(dwmapi, DwmFlush);
- DYNAMIC_API_RESOLVE(dwmapi, DwmIsCompositionEnabled);
- DYNAMIC_API_RESOLVE(dwmapi, DwmGetCompositionTimingInfo);
- DYNAMIC_API_RESOLVE(dwmapi, DwmGetWindowAttribute);
- DYNAMIC_API_RESOLVE(dwmapi, DwmSetWindowAttribute);
-
- QSystemLibrary winmm(QStringLiteral("winmm"));
- DYNAMIC_API_RESOLVE(winmm, timeGetDevCaps);
- DYNAMIC_API_RESOLVE(winmm, timeBeginPeriod);
- DYNAMIC_API_RESOLVE(winmm, timeEndPeriod);
-
-#undef DYNAMIC_API_RESOLVE
- }
-
- ~DynamicApis() = default;
-
- Q_DISABLE_COPY_MOVE(DynamicApis)
- };
-
- static inline constexpr bool operator==(const POINT &lhs, const POINT &rhs) noexcept {
- return ((lhs.x == rhs.x) && (lhs.y == rhs.y));
- }
-
- static inline constexpr bool operator!=(const POINT &lhs, const POINT &rhs) noexcept {
- return !operator==(lhs, rhs);
- }
-
- static inline constexpr bool operator==(const SIZE &lhs, const SIZE &rhs) noexcept {
- return ((lhs.cx == rhs.cx) && (lhs.cy == rhs.cy));
- }
-
- static inline constexpr bool operator!=(const SIZE &lhs, const SIZE &rhs) noexcept {
- return !operator==(lhs, rhs);
- }
-
- static inline constexpr bool operator>(const SIZE &lhs, const SIZE &rhs) noexcept {
- return ((lhs.cx * lhs.cy) > (rhs.cx * rhs.cy));
- }
-
- static inline constexpr bool operator>=(const SIZE &lhs, const SIZE &rhs) noexcept {
- return (operator>(lhs, rhs) || operator==(lhs, rhs));
- }
-
- static inline constexpr bool operator<(const SIZE &lhs, const SIZE &rhs) noexcept {
- return (operator!=(lhs, rhs) && !operator>(lhs, rhs));
- }
-
- static inline constexpr bool operator<=(const SIZE &lhs, const SIZE &rhs) noexcept {
- return (operator<(lhs, rhs) || operator==(lhs, rhs));
- }
-
- static inline constexpr bool operator==(const RECT &lhs, const RECT &rhs) noexcept {
- return ((lhs.left == rhs.left) && (lhs.top == rhs.top) && (lhs.right == rhs.right) &&
- (lhs.bottom == rhs.bottom));
- }
-
- static inline constexpr bool operator!=(const RECT &lhs, const RECT &rhs) noexcept {
- return !operator==(lhs, rhs);
- }
-
- static inline constexpr QPoint point2qpoint(const POINT &point) {
- return QPoint{int(point.x), int(point.y)};
- }
-
- static inline constexpr POINT qpoint2point(const QPoint &point) {
- return POINT{LONG(point.x()), LONG(point.y())};
- }
-
- static inline constexpr QSize size2qsize(const SIZE &size) {
- return QSize{int(size.cx), int(size.cy)};
- }
-
- static inline constexpr SIZE qsize2size(const QSize &size) {
- return SIZE{LONG(size.width()), LONG(size.height())};
- }
-
- static inline constexpr QRect rect2qrect(const RECT &rect) {
- return QRect{
- QPoint{int(rect.left), int(rect.top) },
- QSize{int(RECT_WIDTH(rect)), int(RECT_HEIGHT(rect))}
- };
- }
-
- static inline constexpr RECT qrect2rect(const QRect &qrect) {
- return RECT{LONG(qrect.left()), LONG(qrect.top()), LONG(qrect.right()),
- LONG(qrect.bottom())};
- }
-
- static inline /*constexpr*/ QString hwnd2str(const WId windowId) {
- // NULL handle is allowed here.
- return QLatin1String("0x") +
- QString::number(windowId, 16).toUpper().rightJustified(8, u'0');
- }
-
- static inline /*constexpr*/ QString hwnd2str(HWND hwnd) {
- // NULL handle is allowed here.
- return hwnd2str(reinterpret_cast<WId>(hwnd));
- }
-
- static inline bool isWin8OrGreater() {
- static const bool result = IsWindows8OrGreater_Real();
- return result;
- }
-
- static inline bool isWin8Point1OrGreater() {
- static const bool result = IsWindows8Point1OrGreater_Real();
- return result;
- }
-
- static inline bool isWin10OrGreater() {
- static const bool result = IsWindows10OrGreater_Real();
- return result;
- }
-
- static inline bool isWin11OrGreater() {
- static const bool result = IsWindows11OrGreater_Real();
- return result;
- }
-
- static inline bool isDwmCompositionEnabled() {
- if (isWin8OrGreater()) {
- return true;
- }
- const DynamicApis &apis = DynamicApis::instance();
- if (!apis.pDwmIsCompositionEnabled) {
- return false;
- }
- BOOL enabled = FALSE;
- return SUCCEEDED(apis.pDwmIsCompositionEnabled(&enabled)) && enabled;
- }
-
- static inline bool isWindowFrameBorderColorized() {
- const QWinRegistryKey registry(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\DWM)");
- if (!registry.isValid()) {
- return false;
- }
- const auto value = registry.dwordValue(L"ColorPrevalence");
- if (!value.second) {
- return false;
- }
- return value.first;
- }
-
- static inline bool isDarkThemeActive() {
-#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
- return QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark;
-#else
- const QWinRegistryKey registry(
- HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)");
- if (!registry.isValid()) {
- return false;
- }
- const auto value = registry.dwordValue(L"AppsUseLightTheme");
- if (!value.second) {
- return false;
- }
- return !value.first;
-#endif
- }
-
- static inline bool isDarkWindowFrameEnabled(HWND hwnd) {
- BOOL enabled = FALSE;
- const DynamicApis &apis = DynamicApis::instance();
- if (SUCCEEDED(apis.pDwmGetWindowAttribute(hwnd, _DWMWA_USE_IMMERSIVE_DARK_MODE, &enabled,
- sizeof(enabled)))) {
- return enabled;
- } else if (SUCCEEDED(apis.pDwmGetWindowAttribute(hwnd,
- _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1,
- &enabled, sizeof(enabled)))) {
- return enabled;
- } else {
- return false;
- }
- }
-
- static inline QColor getAccentColor() {
-#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
- return QGuiApplication::palette().color(QPalette::Accent);
-#else
- const QWinRegistryKey registry(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\DWM)");
- if (!registry.isValid()) {
- return {};
- }
- const auto value = registry.dwordValue(L"AccentColor");
- if (!value.second) {
- return {};
- }
- // The retrieved value is in the #AABBGGRR format, we need to
- // convert it to the #AARRGGBB format which Qt expects.
- const QColor abgr = QColor::fromRgba(value.first);
- if (!abgr.isValid()) {
- return {};
- }
- return QColor::fromRgb(abgr.blue(), abgr.green(), abgr.red(), abgr.alpha());
-#endif
- }
static inline void triggerFrameChange(HWND hwnd) {
::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0,
@@ -379,16 +104,7 @@
getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
}
- static void updateInternalWindowFrameMargins(HWND hwnd, QWindow *window) {
- const auto margins = [hwnd]() -> QMargins {
- const auto titleBarHeight = int(getTitleBarHeight(hwnd));
- if (isWin10OrGreater()) {
- return {0, -titleBarHeight, 0, 0};
- } else {
- const auto frameSize = int(getResizeBorderThickness(hwnd));
- return {-frameSize, -titleBarHeight, -frameSize, -frameSize};
- }
- }();
+ static void setInternalWindowFrameMargins(QWindow *window, const QMargins &margins) {
const QVariant marginsVar = QVariant::fromValue(margins);
window->setProperty("_q_windowsCustomMargins", marginsVar);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -414,10 +130,10 @@
monitorInfo.cbSize = sizeof(monitorInfo);
::GetMonitorInfoW(monitor, &monitorInfo);
return monitorInfo;
- };
+ }
- static inline void moveToDesktopCenter(HWND hwnd) {
- const auto monitorInfo = getMonitorForWindow(hwnd);
+ static inline void moveWindowToDesktopCenter(HWND hwnd) {
+ MONITORINFOEXW monitorInfo = getMonitorForWindow(hwnd);
RECT windowRect{};
::GetWindowRect(hwnd, &windowRect);
const auto newX = monitorInfo.rcMonitor.left +
@@ -426,6 +142,71 @@
(RECT_HEIGHT(monitorInfo.rcMonitor) - RECT_HEIGHT(windowRect)) / 2;
::SetWindowPos(hwnd, nullptr, newX, newY, 0, 0,
SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER);
+ }
+
+ static inline void moveWindowToMonitor(HWND hwnd, const MONITORINFOEXW &activeMonitor) {
+ RECT currentMonitorRect = getMonitorForWindow(hwnd).rcMonitor;
+ RECT activeMonitorRect = activeMonitor.rcMonitor;
+ // We are in the same monitor, nothing to adjust here.
+ if (currentMonitorRect == activeMonitorRect) {
+ return;
+ }
+ RECT currentWindowRect{};
+ ::GetWindowRect(hwnd, ¤tWindowRect);
+ auto newWindowX =
+ activeMonitorRect.left + (currentWindowRect.left - currentMonitorRect.left);
+ auto newWindowY = activeMonitorRect.top + (currentWindowRect.top - currentMonitorRect.top);
+ ::SetWindowPos(hwnd, nullptr, newWindowX, newWindowY, RECT_WIDTH(currentWindowRect),
+ RECT_HEIGHT(currentWindowRect),
+ SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER);
+ }
+
+ static inline void bringWindowToFront(HWND hwnd) {
+ HWND oldForegroundWindow = ::GetForegroundWindow();
+ if (!oldForegroundWindow) {
+ // The foreground window can be NULL, it's not an API error.
+ return;
+ }
+ MONITORINFOEXW activeMonitor = getMonitorForWindow(oldForegroundWindow);
+ // We need to show the window first, otherwise we won't be able to bring it to front.
+ if (!::IsWindowVisible(hwnd)) {
+ ::ShowWindow(hwnd, SW_SHOW);
+ }
+ if (IsMinimized(hwnd)) {
+ // Restore the window if it is minimized.
+ ::ShowWindow(hwnd, SW_RESTORE);
+ // Once we've been restored, throw us on the active monitor.
+ moveWindowToMonitor(hwnd, activeMonitor);
+ // When the window is restored, it will always become the foreground window.
+ // So return early here, we don't need the following code to bring it to front.
+ return;
+ }
+ // OK, our window is not minimized, so now we will try to bring it to front manually.
+ // First try to send a message to the current foreground window to check whether
+ // it is currently hanging or not.
+ if (!::SendMessageTimeoutW(oldForegroundWindow, WM_NULL, 0, 0,
+ SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG, 1000,
+ nullptr)) {
+ // The foreground window hangs, can't activate current window.
+ return;
+ }
+ DWORD windowThreadProcessId = ::GetWindowThreadProcessId(oldForegroundWindow, nullptr);
+ DWORD currentThreadId = ::GetCurrentThreadId();
+ // We won't be able to change a window's Z order if it's not our own window,
+ // so we use this small technique to pretend the foreground window is ours.
+ ::AttachThreadInput(windowThreadProcessId, currentThreadId, TRUE);
+
+ [[maybe_unused]] const auto &cleaner =
+ qScopeGuard([windowThreadProcessId, currentThreadId]() {
+ ::AttachThreadInput(windowThreadProcessId, currentThreadId, FALSE); //
+ });
+
+ ::BringWindowToTop(hwnd);
+ // Activate the window too. This will force us to the virtual desktop this
+ // window is on, if it's on another virtual desktop.
+ ::SetActiveWindow(hwnd);
+ // Throw us on the active monitor.
+ moveWindowToMonitor(hwnd, activeMonitor);
}
static inline bool isFullScreen(HWND hwnd) {
@@ -764,7 +545,20 @@
return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
}
- static inline void addManagedWindow(HWND hWnd, Win32WindowContext *ctx) {
+ static inline void addManagedWindow(QWindow *window, HWND hWnd, Win32WindowContext *ctx) {
+ const auto margins = [hWnd]() -> QMargins {
+ const auto titleBarHeight = int(getTitleBarHeight(hWnd));
+ if (isWin10OrGreater()) {
+ return {0, -titleBarHeight, 0, 0};
+ } else {
+ const auto frameSize = int(getResizeBorderThickness(hWnd));
+ return {-frameSize, -titleBarHeight, -frameSize, -frameSize};
+ }
+ }();
+
+ // Inform Qt we want and have set custom margins
+ setInternalWindowFrameMargins(window, margins);
+
// Store original window proc
if (!g_qtWindowProc) {
g_qtWindowProc = reinterpret_cast<WNDPROC>(::GetWindowLongPtrW(hWnd, GWLP_WNDPROC));
@@ -807,12 +601,24 @@
void Win32WindowContext::virtual_hook(int id, void *data) {
switch (id) {
case CentralizeHook: {
+ if (!windowId)
+ return;
const auto hwnd = reinterpret_cast<HWND>(windowId);
- moveToDesktopCenter(hwnd);
+ moveWindowToDesktopCenter(hwnd);
+ return;
+ }
+
+ case RaiseWindowHook: {
+ if (!windowId)
+ return;
+ const auto hwnd = reinterpret_cast<HWND>(windowId);
+ bringWindowToFront(hwnd);
return;
}
case ShowSystemMenuHook: {
+ if (!windowId)
+ return;
const auto &pos = *static_cast<const QPoint *>(data);
auto hWnd = reinterpret_cast<HWND>(windowId);
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -837,6 +643,9 @@
}
case DrawWindows10BorderHook: {
+ if (!windowId)
+ return;
+
auto args = static_cast<void **>(data);
auto &painter = *static_cast<QPainter *>(args[0]);
const auto &rect = *static_cast<const QRect *>(args[1]);
@@ -876,10 +685,8 @@
return;
}
- default: {
- // unreachable
+ default:
break;
- }
}
AbstractWindowContext::virtual_hook(id, data);
}
@@ -892,9 +699,11 @@
return getWindowFrameBorderThickness(reinterpret_cast<HWND>(windowId));
}
- void Win32WindowContext::winIdChanged(QWindow *oldWindow) {
- if (oldWindow) {
+ void Win32WindowContext::winIdChanged() {
+ // If the original window id is valid, remove all resources related
+ if (windowId) {
removeManagedWindow(reinterpret_cast<HWND>(windowId));
+ windowId = 0;
}
if (!m_windowHandle) {
@@ -905,21 +714,32 @@
auto winId = m_windowHandle->winId();
auto hWnd = reinterpret_cast<HWND>(winId);
-#if QT_VERSION < QT_VERSION_CHECK(6, 5, 0)
- for (const auto attr : {
- _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1,
- _DWMWA_USE_IMMERSIVE_DARK_MODE,
- }) {
- const BOOL enable = TRUE;
- DynamicApis::instance().pDwmSetWindowAttribute(hWnd, attr, &enable, sizeof(enable));
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
+ if (!isWin10OrGreater()) {
+ static constexpr const MARGINS margins = {1, 1, 1, 1};
+ DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins);
+ }
+#else
+ {
+ static const MARGINS margins =
+ isWin10OrGreater() ? MARGINS{0, 0, 0, 0} : MARGINS{1, 1, 1, 1};
+ DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins);
}
#endif
- // Inform Qt we want and have set custom margins
- updateInternalWindowFrameMargins(hWnd, m_windowHandle);
+
+ {
+ auto style = ::GetWindowLongPtrW(hWnd, GWL_STYLE);
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
+ ::SetWindowLongPtrW(hWnd, GWL_STYLE, style & (~WS_SYSMENU));
+#else
+ ::SetWindowLongPtrW(hWnd, GWL_STYLE,
+ (style | WS_THICKFRAME | WS_CAPTION) & (~WS_SYSMENU));
+#endif
+ }
// Add managed window
- addManagedWindow(hWnd, this);
+ addManagedWindow(m_windowHandle, hWnd, this);
// Cache win id
windowId = winId;
@@ -976,6 +796,178 @@
}
}
return false; // Not handled
+ }
+
+ bool Win32WindowContext::windowAttributeChanged(const QString &key, const QVariant &attribute,
+ const QVariant &oldAttribute) {
+ const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());
+ const DynamicApis &apis = DynamicApis::instance();
+ static constexpr const MARGINS extendMargins = {-1, -1, -1, -1};
+ static const auto defaultMargins =
+ isWin10OrGreater() ? MARGINS{0, 0, 0, 0} : MARGINS{1, 1, 1, 1};
+ if (key == QStringLiteral("mica")) {
+ if (!isWin11OrGreater()) {
+ return false;
+ }
+ if (attribute.toBool()) {
+ // We need to extend the window frame into the whole client area to be able
+ // to see the blurred window background.
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
+ if (isWin1122H2OrGreater()) {
+ // Use official DWM API to enable Mica, available since Windows 11 22H2
+ // (10.0.22621).
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_MAINWINDOW;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ } else {
+ // Use undocumented DWM API to enable Mica, available since Windows 11
+ // (10.0.22000).
+ const BOOL enable = TRUE;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable));
+ }
+ } else {
+ if (isWin1122H2OrGreater()) {
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ } else {
+ const BOOL enable = FALSE;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable));
+ }
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ }
+ return true;
+ } else if (key == QStringLiteral("mica-alt")) {
+ if (!isWin1122H2OrGreater()) {
+ return false;
+ }
+ if (attribute.toBool()) {
+ // We need to extend the window frame into the whole client area to be able
+ // to see the blurred window background.
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
+ // Use official DWM API to enable Mica Alt, available since Windows 11 22H2
+ // (10.0.22621).
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TABBEDWINDOW;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ } else {
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ }
+ return true;
+ } else if (key == QStringLiteral("acrylic-material")) {
+ if (!isWin11OrGreater()) {
+ return false;
+ }
+ if (attribute.toBool()) {
+ // We need to extend the window frame into the whole client area to be able
+ // to see the blurred window background.
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
+
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TRANSIENTWINDOW;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+
+ // PRIVATE API REFERENCE:
+ // QColor gradientColor = {};
+ // ACCENT_POLICY policy{};
+ // policy.dwAccentState = ACCENT_ENABLE_ACRYLICBLURBEHIND;
+ // policy.dwAccentFlags = ACCENT_ENABLE_ACRYLIC_WITH_LUMINOSITY;
+ // // This API expects the #AABBGGRR format.
+ // policy.dwGradientColor =
+ // DWORD(qRgba(gradientColor.blue(), gradientColor.green(),
+ // gradientColor.red(), gradientColor.alpha()));
+ // WINDOWCOMPOSITIONATTRIBDATA wcad{};
+ // wcad.Attrib = WCA_ACCENT_POLICY;
+ // wcad.pvData = &policy;
+ // wcad.cbData = sizeof(policy);
+ // apis.pSetWindowCompositionAttribute(hwnd, &wcad);
+ } else {
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+
+ // PRIVATE API REFERENCE:
+ // ACCENT_POLICY policy{};
+ // policy.dwAccentState = ACCENT_DISABLED;
+ // policy.dwAccentFlags = ACCENT_NONE;
+ // WINDOWCOMPOSITIONATTRIBDATA wcad{};
+ // wcad.Attrib = WCA_ACCENT_POLICY;
+ // wcad.pvData = &policy;
+ // wcad.cbData = sizeof(policy);
+ // apis.pSetWindowCompositionAttribute(hwnd, &wcad);
+
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ }
+ return true;
+ } else if (key == QStringLiteral("dwm-blur")) {
+ // TODO: Optimize
+ // Currently not available!!!
+ if (attribute.toBool()) {
+ // We need to extend the window frame into the whole client area to be able
+ // to see the blurred window background.
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins);
+ if (isWin8OrGreater()) {
+ ACCENT_POLICY policy{};
+ policy.dwAccentState = ACCENT_ENABLE_BLURBEHIND;
+ policy.dwAccentFlags = ACCENT_NONE;
+ WINDOWCOMPOSITIONATTRIBDATA wcad{};
+ wcad.Attrib = WCA_ACCENT_POLICY;
+ wcad.pvData = &policy;
+ wcad.cbData = sizeof(policy);
+ apis.pSetWindowCompositionAttribute(hwnd, &wcad);
+ } else {
+ DWM_BLURBEHIND bb{};
+ bb.fEnable = TRUE;
+ bb.dwFlags = DWM_BB_ENABLE;
+ apis.pDwmEnableBlurBehindWindow(hwnd, &bb);
+ }
+ } else {
+ if (isWin8OrGreater()) {
+ ACCENT_POLICY policy{};
+ policy.dwAccentState = ACCENT_DISABLED;
+ policy.dwAccentFlags = ACCENT_NONE;
+ WINDOWCOMPOSITIONATTRIBDATA wcad{};
+ wcad.Attrib = WCA_ACCENT_POLICY;
+ wcad.pvData = &policy;
+ wcad.cbData = sizeof(policy);
+ apis.pSetWindowCompositionAttribute(hwnd, &wcad);
+ } else {
+ DWM_BLURBEHIND bb{};
+ bb.fEnable = FALSE;
+ bb.dwFlags = DWM_BB_ENABLE;
+ apis.pDwmEnableBlurBehindWindow(hwnd, &bb);
+ }
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ }
+ return true;
+ } else if (key == QStringLiteral("dark-mode")) {
+ if (!isWin101809OrGreater()) {
+ return false;
+ }
+
+ BOOL enable = attribute.toBool();
+
+ if (isWin101903OrGreater()) {
+ apis.pSetPreferredAppMode(enable ? PAM_AUTO : PAM_DEFAULT);
+ } else {
+ apis.pAllowDarkModeForApp(enable);
+ }
+
+ for (const auto attr : {
+ _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1,
+ _DWMWA_USE_IMMERSIVE_DARK_MODE,
+ }) {
+ apis.pDwmSetWindowAttribute(hwnd, attr, &enable, sizeof(enable));
+ }
+
+ apis.pFlushMenuThemes();
+
+ return true;
+ }
+ return false;
}
QWK_USED static constexpr const struct {
@@ -1183,6 +1175,53 @@
const WindowPart currentWindowPart = lastHitTestResult;
if (message == WM_NCMOUSEMOVE) {
if (currentWindowPart != WindowPart::ChromeButton) {
+ // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/widgets/kernel/qwidgetwindow.cpp#L472
+ // When the mouse press event arrives, QWidgetWindow will implicitly grab
+ // the top widget right under the mouse, and set `qt_button_down` to this
+ // widget. At this time, no other widgets will accept the mouse event until
+ // QWidgetWindow receives the mouse release event, then set `qt_button_down`
+ // to null.
+
+ // Imagine the following situation, now the main window has a pop-up menu,
+ // the focus is not on the main window, if we click outside the pop-up menu,
+ // the menu will close, which seems to be completely fine. But if we close
+ // the menu by clicking on the title bar draggable area, then other widgets
+ // won't accept the mouse message afterwards.
+
+ // Here's the reason.
+ // When the mouse is placed in the draggable area of the title bar, there
+ // are two situations.
+
+ // 1. If the focus is on the main window, and the last result of
+ // WM_NCHITTEST is HTCAPTION, the mouse click event in the title bar is
+ // taken over by Windows and Qt does not receive the mouse click event.
+
+ // 2. If the main window has a pop-up menu, it is completely different. When
+ // the mouse is pressed on the title bar, Windows sends the WM_LBUTTONDOWN
+ // message to the window plane of the pop-up menu, the menu is closed, but
+ // Qt will continue to forward the event to the QWidget under the mouse, and
+ // the event will be processed by QWidgetWindow, causing the title bar
+ // widget to be implicitly grabbed. After the menu is closed, Windows
+ // immediately sends WM_NCHITTEST, because the mouse is in the title bar
+ // draggable area, the result is HTCAPTION, so when the mouse is released,
+ // Windows sends WM_NCLBUTTONUP, which is a non-client message, and it
+ // will be ignored by Qt. As a consequence, QWidgetWindow can't receive a
+ // mouse release message in the client area, so the grab remains, and other
+ // widgets cannot receive mouse events.
+
+ // Since we didn't watch the menu window, we cannot capture any mouse
+ // press events sent by Windows, so we cannot solve this problem by
+ // recording mouse events. Fortunately, we found that the main window will
+ // receive a WM_NCMOUSEMOVE message immediately after the menu is closed, so
+ // we just manually send a mouse release event when this message arrives and
+ // set qt_button_down to null. Don't worry, when receiving WM_NCMOUSEMOVE,
+ // there shouldn't be any control in the state of being grabbed.
+
+ // In the native window, although QWidgetWindow handles the forwarded mouse
+ // press event when the menu is closed, since the native title bar is not a
+ // QWidget, no widget will be grabbed, and `qt_button_down` remains empty,
+ // the above problems would not arise.
+
m_delegate->resetQtGrabbedControl(m_host);
if (mouseLeaveBlocked) {
emulateClientAreaMessage(hWnd, message, wParam, lParam,
@@ -1245,6 +1284,8 @@
// window from client area, which means we will get previous window part as
// HTCLIENT if the mouse leaves window from client area and enters window
// from non-client area, but it has no bad effect.
+
+ // Why do we need to call this function here?
m_delegate->resetQtGrabbedControl(m_host);
}
}
@@ -1267,7 +1308,7 @@
// function.
if (wParam && !lParam) {
centered = true;
- moveToDesktopCenter(hWnd);
+ moveWindowToDesktopCenter(hWnd);
}
}
break;
@@ -1354,7 +1395,6 @@
// Terminal does, however, later I found that if we choose a proper
// color, our homemade top border can almost have exactly the same
// appearance with the system's one.
-
[[maybe_unused]] const auto &hitTestRecorder = qScopeGuard([this, result]() {
lastHitTestResult = getHitWindowPart(int(*result)); //
});
@@ -1455,6 +1495,7 @@
int frameSize = getResizeBorderThickness(hWnd);
bool isTop = (nativeLocalPos.y < frameSize);
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
if (isWin10OrGreater()) {
// This will handle the left, right and bottom parts of the frame
// because we didn't change them.
@@ -1477,7 +1518,7 @@
*result = (isTitleBar ? HTCAPTION : HTCLIENT);
return true;
}
- // At this point, we know that the cursor is inside the client area
+ // At this point, we know that the cursor is inside the client area,
// so it has to be either the little border at the top of our custom
// title bar or the drag bar. Apparently, it must be the drag bar or
// the little border at the top which the user can use to move or
@@ -1497,7 +1538,9 @@
}
*result = HTCLIENT;
return true;
- } else {
+ } else
+#endif
+ {
if (full) {
*result = HTCLIENT;
return true;
@@ -1615,11 +1658,7 @@
// window activation state change.
*result = ::DefWindowProcW(hWnd, WM_NCACTIVATE, wParam, -1);
} else {
- if (wParam) {
- *result = FALSE;
- } else {
- *result = TRUE;
- }
+ *result = TRUE;
}
return true;
}
@@ -1738,6 +1777,7 @@
// and align it with the upper-left corner of our new client area".
const auto clientRect = wParam ? &(reinterpret_cast<LPNCCALCSIZE_PARAMS>(lParam))->rgrc[0]
: reinterpret_cast<LPRECT>(lParam);
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
if (isWin10OrGreater()) {
// Store the original top margin before the default window procedure applies the
// default frame.
@@ -1765,6 +1805,7 @@
// technique to bring the top border back.
clientRect->top = originalTop;
}
+#endif
const bool max = IsMaximized(hWnd);
const bool full = isFullScreen(hWnd);
// We don't need this correction when we're fullscreen. We will
@@ -1779,11 +1820,16 @@
// a window when it's maximized unless you restore it).
const quint32 frameSize = getResizeBorderThickness(hWnd);
clientRect->top += frameSize;
+
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
if (!isWin10OrGreater()) {
+#endif
clientRect->bottom -= frameSize;
clientRect->left += frameSize;
clientRect->right -= frameSize;
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
}
+#endif
}
// Attempt to detect if there's an autohide taskbar, and if
// there is, reduce our size a bit on the side with the taskbar,
--
Gitblit v1.9.1