From fee0c64a8f8d6237f94457b608cc09614514f9b5 Mon Sep 17 00:00:00 2001
From: Sine Striker <trueful@163.com>
Date: 周六, 23 12月 2023 15:00:35 +0800
Subject: [PATCH] Fix window overflow
---
src/core/contexts/win32windowcontext.cpp | 1078 +++++++++++++++++++++++++++++++++++++++++++----------------
1 files changed, 786 insertions(+), 292 deletions(-)
diff --git a/src/core/contexts/win32windowcontext.cpp b/src/core/contexts/win32windowcontext.cpp
index 2ff795e..27450d9 100644
--- a/src/core/contexts/win32windowcontext.cpp
+++ b/src/core/contexts/win32windowcontext.cpp
@@ -1,15 +1,15 @@
#include "win32windowcontext_p.h"
-#include "qwkcoreglobal_p.h"
#include <optional>
#include <QtCore/QHash>
-#include <QtCore/QAbstractNativeEventFilter>
-#include <QtCore/QOperatingSystemVersion>
#include <QtCore/QScopeGuard>
+#include <QtCore/QTimer>
#include <QtGui/QGuiApplication>
+#include <QtGui/QPainter>
+#include <QtGui/QPalette>
+#include <QtGui/QStyleHints>
-#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>
@@ -21,182 +21,33 @@
# 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 {
- static constexpr const auto kAutoHideTaskBarThickness =
- quint8{2}; // The thickness of an auto-hide taskbar in pixels.
+ // The thickness of an auto-hide taskbar in pixels.
+ static constexpr const quint8 kAutoHideTaskBarThickness = 2;
- using WndProcHash = QHash<HWND, Win32WindowContext *>; // hWnd -> context
+ QWK_USED static constexpr const struct {
+ const uint32_t activeLight = MAKE_RGBA_COLOR(110, 110, 110, 255); // #6E6E6E
+ const uint32_t activeDark = MAKE_RGBA_COLOR(51, 51, 51, 255); // #333333
+ const uint32_t inactiveLight = MAKE_RGBA_COLOR(167, 167, 167, 255); // #A7A7A7
+ const uint32_t inactiveDark = MAKE_RGBA_COLOR(61, 61, 62, 255); // #3D3D3E
+ } kWindowsColorSet;
+
+ // hWnd -> context
+ using WndProcHash = QHash<HWND, Win32WindowContext *>;
Q_GLOBAL_STATIC(WndProcHash, g_wndProcHash)
- static WNDPROC g_qtWindowProc = nullptr; // Original Qt window proc function
-
- static struct QWK_Hook {
- QWK_Hook() {
- qApp->setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
- }
- } g_hook{};
-
- struct DynamicApis {
- decltype(&::DwmFlush) pDwmFlush = nullptr;
- decltype(&::DwmIsCompositionEnabled) pDwmIsCompositionEnabled = nullptr;
- decltype(&::DwmGetCompositionTimingInfo) pDwmGetCompositionTimingInfo = nullptr;
- decltype(&::GetDpiForWindow) pGetDpiForWindow = nullptr;
- decltype(&::GetSystemMetricsForDpi) pGetSystemMetricsForDpi = nullptr;
- decltype(&::GetDpiForMonitor) pGetDpiForMonitor = nullptr;
- decltype(&::timeGetDevCaps) ptimeGetDevCaps = nullptr;
- decltype(&::timeBeginPeriod) ptimeBeginPeriod = nullptr;
- decltype(&::timeEndPeriod) ptimeEndPeriod = nullptr;
-
- DynamicApis() {
- QSystemLibrary user32(QStringLiteral("user32.dll"));
- pGetDpiForWindow =
- reinterpret_cast<decltype(pGetDpiForWindow)>(user32.resolve("GetDpiForWindow"));
- pGetSystemMetricsForDpi = reinterpret_cast<decltype(pGetSystemMetricsForDpi)>(
- user32.resolve("GetSystemMetricsForDpi"));
-
- QSystemLibrary shcore(QStringLiteral("shcore.dll"));
- pGetDpiForMonitor =
- reinterpret_cast<decltype(pGetDpiForMonitor)>(shcore.resolve("GetDpiForMonitor"));
-
- QSystemLibrary dwmapi(QStringLiteral("dwmapi.dll"));
- pDwmFlush = reinterpret_cast<decltype(pDwmFlush)>(dwmapi.resolve("DwmFlush"));
- pDwmIsCompositionEnabled = reinterpret_cast<decltype(pDwmIsCompositionEnabled)>(
- dwmapi.resolve("DwmIsCompositionEnabled"));
- pDwmGetCompositionTimingInfo = reinterpret_cast<decltype(pDwmGetCompositionTimingInfo)>(dwmapi.resolve("DwmGetCompositionTimingInfo"));
-
- QSystemLibrary winmm(QStringLiteral("winmm.dll"));
- ptimeGetDevCaps = reinterpret_cast<decltype(ptimeGetDevCaps)>(winmm.resolve("timeGetDevCaps"));
- ptimeBeginPeriod = reinterpret_cast<decltype(ptimeBeginPeriod)>(winmm.resolve("timeBeginPeriod"));
- ptimeEndPeriod = reinterpret_cast<decltype(ptimeEndPeriod)>(winmm.resolve("timeEndPeriod"));
- }
-
- ~DynamicApis() = default;
-
- static const DynamicApis &instance() {
- static const DynamicApis inst{};
- return inst;
- }
-
- private:
- 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 =
- QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows8;
- return result;
- }
-
- static inline bool isWin8Point1OrGreater() {
- static const bool result =
- QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows8_1;
- return result;
- }
-
- static inline bool isWin10OrGreater() {
- static const bool result =
- QOperatingSystemVersion::current() >= QOperatingSystemVersion::Windows10;
- 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;
- }
+ // Original Qt window proc function
+ static WNDPROC g_qtWindowProc = nullptr;
static inline void triggerFrameChange(HWND hwnd) {
::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0,
@@ -210,59 +61,56 @@
return apis.pGetDpiForWindow(hwnd);
} else if (apis.pGetDpiForMonitor) { // Win8.1
HMONITOR monitor = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
- UINT dpiX{USER_DEFAULT_SCREEN_DPI};
- UINT dpiY{USER_DEFAULT_SCREEN_DPI};
+ UINT dpiX{0};
+ UINT dpiY{0};
apis.pGetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY);
return dpiX;
} else { // Win2K
HDC hdc = ::GetDC(nullptr);
const int dpiX = ::GetDeviceCaps(hdc, LOGPIXELSX);
- const int dpiY = ::GetDeviceCaps(hdc, LOGPIXELSY);
+ // const int dpiY = ::GetDeviceCaps(hdc, LOGPIXELSY);
::ReleaseDC(nullptr, hdc);
return quint32(dpiX);
}
}
- static inline quint32 getResizeBorderThickness(HWND hwnd) {
+ static inline quint32 getSystemMetricsForDpi(int index, quint32 dpi) {
const DynamicApis &apis = DynamicApis::instance();
if (apis.pGetSystemMetricsForDpi) {
- const quint32 dpi = getDpiForWindow(hwnd);
- return apis.pGetSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
- apis.pGetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
- } else {
- return ::GetSystemMetrics(SM_CXSIZEFRAME) + ::GetSystemMetrics(SM_CXPADDEDBORDER);
+ return ::GetSystemMetricsForDpi(index, dpi);
}
+ return ::GetSystemMetrics(index);
+ }
+
+ static inline quint32 getWindowFrameBorderThickness(HWND hwnd) {
+ const DynamicApis &apis = DynamicApis::instance();
+ if (UINT result = 0; SUCCEEDED(apis.pDwmGetWindowAttribute(
+ hwnd, _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, &result, sizeof(result)))) {
+ return result;
+ }
+ return getSystemMetricsForDpi(SM_CXBORDER, getDpiForWindow(hwnd));
+ }
+
+ static inline quint32 getResizeBorderThickness(HWND hwnd) {
+ const quint32 dpi = getDpiForWindow(hwnd);
+ return getSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
+ getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
}
static inline quint32 getTitleBarHeight(HWND hwnd) {
- const auto captionHeight = [hwnd]() -> int {
- const DynamicApis &apis = DynamicApis::instance();
- if (apis.pGetSystemMetricsForDpi) {
- const quint32 dpi = getDpiForWindow(hwnd);
- return apis.pGetSystemMetricsForDpi(SM_CYCAPTION, dpi);
- } else {
- return ::GetSystemMetrics(SM_CYCAPTION);
- }
- }();
- return captionHeight + getResizeBorderThickness(hwnd);
+ const quint32 dpi = getDpiForWindow(hwnd);
+ return getSystemMetricsForDpi(SM_CYCAPTION, dpi) +
+ getSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
+ getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
}
- static inline void updateInternalWindowFrameMargins(HWND hwnd, QWindow *window) {
- const auto margins = [hwnd]() -> QMargins {
- const int titleBarHeight = getTitleBarHeight(hwnd);
- if (isWin10OrGreater()) {
- return {0, -titleBarHeight, 0, 0};
- } else {
- const int frameSize = 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)
if (QPlatformWindow *platformWindow = window->handle()) {
if (const auto ni = QGuiApplication::platformNativeInterface()) {
- ni->setWindowProperty(platformWindow, QStringLiteral("_q_windowsCustomMargins"),
+ ni->setWindowProperty(platformWindow, QStringLiteral("WindowsCustomMargins"),
marginsVar);
}
}
@@ -282,16 +130,83 @@
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 = (RECT_WIDTH(monitorInfo.rcMonitor) - RECT_WIDTH(windowRect)) / 2;
- const auto newY = (RECT_HEIGHT(monitorInfo.rcMonitor) - RECT_HEIGHT(windowRect)) / 2;
+ const auto newX = monitorInfo.rcMonitor.left +
+ (RECT_WIDTH(monitorInfo.rcMonitor) - RECT_WIDTH(windowRect)) / 2;
+ const auto newY = monitorInfo.rcMonitor.top +
+ (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) {
@@ -308,12 +223,15 @@
::GetWindowPlacement(hwnd, &wp);
return ((wp.showCmd == SW_NORMAL) || (wp.showCmd == SW_RESTORE));
#else
+ if (isFullScreen(hwnd)) {
+ return false;
+ }
const auto style = static_cast<DWORD>(::GetWindowLongPtrW(hwnd, GWL_STYLE));
return (!(style & (WS_MINIMIZE | WS_MAXIMIZE)));
#endif
}
- static inline void syncPaintEventWithDwm() {
+ static void syncPaintEventWithDwm() {
// No need to sync with DWM if DWM composition is disabled.
if (!isDwmCompositionEnabled()) {
return;
@@ -358,6 +276,73 @@
apis.ptimeEndPeriod(ms_granularity);
}
+ static void showSystemMenu2(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
+ const bool fixedSize) {
+ HMENU hMenu = ::GetSystemMenu(hWnd, FALSE);
+ if (!hMenu) {
+ // The corresponding window doesn't have a system menu, most likely due to the
+ // lack of the "WS_SYSMENU" window style. This situation should not be treated
+ // as an error so just ignore it and return early.
+ return;
+ }
+
+ const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
+ ::EnableMenuItem(hMenu, SC_CLOSE, (MF_BYCOMMAND | MFS_ENABLED));
+ ::EnableMenuItem(hMenu, SC_MAXIMIZE,
+ (MF_BYCOMMAND | ((maxOrFull || fixedSize) ? MFS_DISABLED : MFS_ENABLED)));
+ ::EnableMenuItem(hMenu, SC_RESTORE,
+ (MF_BYCOMMAND | ((maxOrFull && !fixedSize) ? MFS_ENABLED : MFS_DISABLED)));
+ // The first menu item should be selected by default if the menu is brought
+ // up by keyboard. I don't know how to pre-select a menu item but it seems
+ // highlight can do the job. However, there's an annoying issue if we do
+ // this manually: the highlighted menu item is really only highlighted,
+ // not selected, so even if the mouse cursor hovers on other menu items
+ // or the user navigates to other menu items through keyboard, the original
+ // highlight bar will not move accordingly, the OS will generate another
+ // highlight bar to indicate the current selected menu item, which will make
+ // the menu look kind of weird. Currently I don't know how to fix this issue.
+ ::HiliteMenuItem(hWnd, hMenu, SC_RESTORE,
+ (MF_BYCOMMAND | (selectFirstEntry ? MFS_HILITE : MFS_UNHILITE)));
+ ::EnableMenuItem(hMenu, SC_MINIMIZE, (MF_BYCOMMAND | MFS_ENABLED));
+ ::EnableMenuItem(hMenu, SC_SIZE,
+ (MF_BYCOMMAND | ((maxOrFull || fixedSize) ? MFS_DISABLED : MFS_ENABLED)));
+ ::EnableMenuItem(hMenu, SC_MOVE, (MF_BYCOMMAND | (maxOrFull ? MFS_DISABLED : MFS_ENABLED)));
+
+ // The default menu item will appear in bold font. There can only be one default
+ // menu item per menu at most. Set the item ID to "UINT_MAX" (or simply "-1")
+ // can clear the default item for the given menu.
+ UINT defaultItemId = UINT_MAX;
+ if (isWin11OrGreater()) {
+ if (maxOrFull) {
+ defaultItemId = SC_RESTORE;
+ } else {
+ defaultItemId = SC_MAXIMIZE;
+ }
+ }
+ if (defaultItemId == UINT_MAX) {
+ defaultItemId = SC_CLOSE;
+ }
+ ::SetMenuDefaultItem(hMenu, defaultItemId, FALSE);
+
+ // Popup the system menu at the required position.
+ const auto result = ::TrackPopupMenu(
+ hMenu,
+ (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
+ pos.x, pos.y, 0, hWnd, nullptr);
+
+ // Unhighlight the first menu item after the popup menu is closed, otherwise it will keep
+ // highlighting until we unhighlight it manually.
+ ::HiliteMenuItem(hWnd, hMenu, SC_RESTORE, (MF_BYCOMMAND | MFS_UNHILITE));
+
+ if (!result) {
+ // The user canceled the menu, no need to continue.
+ return;
+ }
+
+ // Send the command that the user chooses to the corresponding window.
+ ::PostMessageW(hWnd, WM_SYSCOMMAND, result, 0);
+ }
+
static inline Win32WindowContext::WindowPart getHitWindowPart(int hitTestResult) {
switch (hitTestResult) {
case HTCLIENT:
@@ -382,7 +367,8 @@
case HTBORDER:
return Win32WindowContext::FixedBorder;
default:
- break; // unreachable
+ // unreachable
+ break;
}
return Win32WindowContext::Outside;
}
@@ -426,14 +412,11 @@
// DefWindowProc(). Consequently, we have to add a global native filter that forwards the result
// of the hook function, telling Qt whether we have filtered the events before. Since Qt only
// handles Windows window messages in the main thread, it is safe to do so.
- class WindowsNativeEventFilter : public QAbstractNativeEventFilter {
+ class WindowsNativeEventFilter : public AppNativeEventFilter {
public:
bool nativeEventFilter(const QByteArray &eventType, void *message,
QT_NATIVE_EVENT_RESULT_TYPE *result) override {
Q_UNUSED(eventType)
-
- auto orgLastMessageContext = lastMessageContext;
- lastMessageContext = nullptr;
// It has been observed that the pointer that Qt gives us is sometimes null on some
// machines. We need to guard against it in such scenarios.
@@ -443,11 +426,11 @@
// https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1546
// Qt needs to refer to the WM_NCCALCSIZE message data that hasn't been processed, so we
- // have to process it after Qt acquired the initial data.
+ // have to process it after Qt acquires the initial data.
auto msg = static_cast<const MSG *>(message);
- if (msg->message == WM_NCCALCSIZE && orgLastMessageContext) {
+ if (msg->message == WM_NCCALCSIZE && lastMessageContext) {
LRESULT res;
- if (Win32WindowContext::nonClientCalcSizeHandler(msg->hwnd, msg->message,
+ if (lastMessageContext->nonClientCalcSizeHandler(msg->hwnd, msg->message,
msg->wParam, msg->lParam, &res)) {
*result = decltype(*result)(res);
return true;
@@ -460,12 +443,16 @@
static Win32WindowContext *lastMessageContext;
static inline void install() {
+ if (instance) {
+ return;
+ }
instance = new WindowsNativeEventFilter();
- installNativeEventFilter(instance);
}
static inline void uninstall() {
- removeNativeEventFilter(instance);
+ if (!instance) {
+ return;
+ }
delete instance;
instance = nullptr;
}
@@ -543,47 +530,34 @@
// forward it right away and process it in our native event filter.
if (message == WM_NCCALCSIZE) {
WindowsNativeEventFilter::lastMessageContext = ctx;
- return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
+ LRESULT result = ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
+ WindowsNativeEventFilter::lastMessageContext = nullptr;
+ return result;
}
// Try hooked procedure and save result
LRESULT result;
- bool handled = ctx->windowProc(hWnd, message, wParam, lParam, &result);
-
- // TODO: Determine whether to show system menu
- // ...
-
- if (handled) {
+ if (ctx->windowProc(hWnd, message, wParam, lParam, &result)) {
return result;
}
// Continue dispatching.
- WindowsNativeEventFilter::lastMessageContext = ctx;
return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
}
- Win32WindowContext::Win32WindowContext() : AbstractWindowContext() {
- }
-
- Win32WindowContext::~Win32WindowContext() {
- // Remove window handle mapping
- if (auto hWnd = reinterpret_cast<HWND>(windowId); hWnd) {
- g_wndProcHash->remove(hWnd);
-
- // Remove event filter if the all windows has been destroyed
- if (g_wndProcHash->empty()) {
- WindowsNativeEventFilter::uninstall();
+ 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};
}
- }
- }
-
- bool Win32WindowContext::setupHost() {
- // Install window hook
- auto winId = m_windowHandle->winId();
- auto hWnd = reinterpret_cast<HWND>(winId);
+ }();
// Inform Qt we want and have set custom margins
- updateInternalWindowFrameMargins(hWnd, m_windowHandle);
+ setInternalWindowFrameMargins(window, margins);
// Store original window proc
if (!g_qtWindowProc) {
@@ -594,17 +568,175 @@
::SetWindowLongPtrW(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(QWKHookedWndProc));
// Install global native event filter
- if (!WindowsNativeEventFilter::instance) {
- WindowsNativeEventFilter::install();
- }
-
- // Cache window ID
- windowId = winId;
+ WindowsNativeEventFilter::install();
// Save window handle mapping
- g_wndProcHash->insert(hWnd, this);
+ g_wndProcHash->insert(hWnd, ctx);
+ }
- return true;
+ static inline void removeManagedWindow(HWND hWnd) {
+ // Remove window handle mapping
+ if (!g_wndProcHash->remove(hWnd))
+ return;
+
+ // Remove event filter if the all windows has been destroyed
+ if (g_wndProcHash->empty()) {
+ WindowsNativeEventFilter::uninstall();
+ }
+ }
+
+ Win32WindowContext::Win32WindowContext() : AbstractWindowContext() {
+ }
+
+ Win32WindowContext::~Win32WindowContext() {
+ if (windowId) {
+ removeManagedWindow(reinterpret_cast<HWND>(windowId));
+ }
+ }
+
+ QString Win32WindowContext::key() const {
+ return QStringLiteral("win32");
+ }
+
+ void Win32WindowContext::virtual_hook(int id, void *data) {
+ switch (id) {
+ case CentralizeHook: {
+ if (!windowId)
+ return;
+ const auto hwnd = reinterpret_cast<HWND>(windowId);
+ 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)
+ const QPoint nativeGlobalPos =
+ QHighDpi::toNativeGlobalPosition(pos, m_windowHandle);
+#else
+ const QPoint nativeGlobalPos = QHighDpi::toNativePixels(pos, m_windowHandle);
+#endif
+ showSystemMenu2(hWnd, qpoint2point(nativeGlobalPos), false,
+ m_delegate->isHostSizeFixed(m_host));
+ return;
+ }
+
+ case DefaultColorsHook: {
+ auto &map = *static_cast<QMap<QString, QColor> *>(data);
+ map.clear();
+ map.insert(QStringLiteral("activeLight"), kWindowsColorSet.activeLight);
+ map.insert(QStringLiteral("activeDark"), kWindowsColorSet.activeDark);
+ map.insert(QStringLiteral("inactiveLight"), kWindowsColorSet.inactiveLight);
+ map.insert(QStringLiteral("inactiveDark"), kWindowsColorSet.inactiveDark);
+ return;
+ }
+
+ 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]);
+ const auto ®ion = *static_cast<const QRegion *>(args[2]);
+ const auto hwnd = reinterpret_cast<HWND>(windowId);
+
+ QPen pen;
+ pen.setWidth(getWindowFrameBorderThickness(hwnd) * 2);
+
+ const bool dark = isDarkThemeActive() && isDarkWindowFrameEnabled(hwnd);
+ if (m_delegate->isWindowActive(m_host)) {
+ if (isWindowFrameBorderColorized()) {
+ pen.setColor(getAccentColor());
+ } else {
+ static QColor frameBorderActiveColorLight(kWindowsColorSet.activeLight);
+ static QColor frameBorderActiveColorDark(kWindowsColorSet.activeDark);
+ pen.setColor(dark ? frameBorderActiveColorDark
+ : frameBorderActiveColorLight);
+ }
+ } else {
+ static QColor frameBorderInactiveColorLight(kWindowsColorSet.inactiveLight);
+ static QColor frameBorderInactiveColorDark(kWindowsColorSet.inactiveDark);
+ pen.setColor(dark ? frameBorderInactiveColorDark
+ : frameBorderInactiveColorLight);
+ }
+ painter.save();
+
+ // We needs anti-aliasing to give us better result.
+ painter.setRenderHint(QPainter::Antialiasing);
+
+ painter.setPen(pen);
+ painter.drawLine(QLine{
+ QPoint{0, 0},
+ QPoint{m_windowHandle->width(), 0}
+ });
+ painter.restore();
+ return;
+ }
+
+ default:
+ break;
+ }
+ AbstractWindowContext::virtual_hook(id, data);
+ }
+
+ bool Win32WindowContext::needBorderPainter() const {
+ return isWin10OrGreater() && !isWin11OrGreater();
+ }
+
+ int Win32WindowContext::borderThickness() const {
+ return getWindowFrameBorderThickness(reinterpret_cast<HWND>(windowId));
+ }
+
+ 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) {
+ return;
+ }
+
+ // Install window hook
+ auto winId = m_windowHandle->winId();
+ auto hWnd = reinterpret_cast<HWND>(winId);
+
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
+ if (!isWin10OrGreater())
+#endif
+ {
+ static constexpr const MARGINS margins = {1, 1, 1, 1};
+ DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins);
+ }
+
+ {
+ 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(m_windowHandle, hWnd, this);
+
+ // Cache win id
+ windowId = winId;
}
bool Win32WindowContext::windowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
@@ -639,14 +771,202 @@
return true;
}
+ // Whether to show system menu
+ if (systemMenuHandler(hWnd, message, wParam, lParam, result)) {
+ return true;
+ }
+
+ // Forward to native event filter subscribers
+ if (!m_nativeEventFilters.isEmpty()) {
+ MSG msg;
+ msg.hwnd = hWnd;
+ msg.message = message;
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+ QT_NATIVE_EVENT_RESULT_TYPE res = 0;
+ if (dispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
+ *result = LRESULT(res);
+ return true;
+ }
+ }
return false; // Not handled
}
- static constexpr const auto kMessageTag = WPARAM(0x97CCEA99);
+ 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 (!isWin10OrGreater()) {
+ return false;
+ }
+ if (attribute.userType() == QMetaType::QColor) {
+ // 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 (isWin11OrGreater()) {
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TRANSIENTWINDOW;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ } else {
+ auto gradientColor = attribute.value<QColor>();
- static inline constexpr bool isTaggedMessage(WPARAM wParam) {
- return (wParam == kMessageTag);
+ 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 {
+ if (isWin11OrGreater()) {
+ const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
+ apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
+ sizeof(backdropType));
+ } else {
+ 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")) {
+ 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 {
+ const WPARAM wParam = MAKEWPARAM(44500, 61897);
+ const LPARAM lParam = MAKELPARAM(62662, 44982); // Not used. Reserve for future use.
+ } kMessageTag;
static inline quint64 getKeyState() {
quint64 result = 0;
@@ -686,7 +1006,7 @@
// wParam is always ignored in mouse leave messages, but here we
// give them a special tag to be able to distinguish which messages
// are sent by ourselves.
- return kMessageTag;
+ return kMessageTag.wParam;
}
const quint64 keyState = getKeyState();
if ((myMsg >= WM_NCXBUTTONDOWN) && (myMsg <= WM_NCXBUTTONDBLCLK)) {
@@ -764,6 +1084,7 @@
SEND_MESSAGE(hWnd, WM_MOUSELEAVE, wParamNew, lParamNew);
break;
default:
+ // unreachable
break;
}
@@ -786,7 +1107,7 @@
LPARAM lParam, LRESULT *result) {
switch (message) {
case WM_MOUSELEAVE: {
- if (!isTaggedMessage(wParam)) {
+ if (wParam != kMessageTag.wParam) {
// Qt will call TrackMouseEvent() to get the WM_MOUSELEAVE message when it
// receives WM_MOUSEMOVE messages, and since we are converting every
// WM_NCMOUSEMOVE message to WM_MOUSEMOVE message and send it back to the window
@@ -798,9 +1119,9 @@
DWORD dwScreenPos = ::GetMessagePos();
POINT screenPoint{GET_X_LPARAM(dwScreenPos), GET_Y_LPARAM(dwScreenPos)};
::ScreenToClient(hWnd, &screenPoint);
- QPoint qtScenePos =
- QHighDpi::fromNativeLocalPosition(QPoint{screenPoint.x, screenPoint.y}, m_windowHandle);
- auto dummy = CoreWindowAgent::Unknown;
+ QPoint qtScenePos = QHighDpi::fromNativeLocalPosition(point2qpoint(screenPoint),
+ m_windowHandle);
+ auto dummy = WindowAgentBase::Unknown;
if (isInSystemButtons(qtScenePos, &dummy)) {
// We must record whether the last WM_MOUSELEAVE was filtered, because if
// Qt does not receive this message it will not call TrackMouseEvent()
@@ -847,7 +1168,54 @@
const WindowPart currentWindowPart = lastHitTestResult;
if (message == WM_NCMOUSEMOVE) {
if (currentWindowPart != WindowPart::ChromeButton) {
- m_delegate->resetQtGrabbedControl();
+ // 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,
WM_NCMOUSELEAVE);
@@ -909,7 +1277,9 @@
// 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.
- m_delegate->resetQtGrabbedControl();
+
+ // Why do we need to call this function here?
+ m_delegate->resetQtGrabbedControl(m_host);
}
}
break;
@@ -929,13 +1299,14 @@
// If wParam is TRUE, the window is being shown.
// If lParam is zero, the message was sent because of a call to the ShowWindow
// function.
- if (wParam && lParam == 0) {
+ if (wParam && !lParam) {
centered = true;
- moveToDesktopCenter(hWnd);
+ moveWindowToDesktopCenter(hWnd);
}
}
break;
}
+
case WM_NCHITTEST: {
// 鍘熺敓Win32绐楀彛鍙湁椤惰竟鏄湪绐楀彛鍐呴儴resize鐨勶紝鍏朵綑涓夎竟閮芥槸鍦ㄧ獥鍙�
// 澶栭儴杩涜resize鐨勶紝鍏跺師鐞嗘槸锛學S_THICKFRAME杩欎釜绐楀彛鏍峰紡浼氬湪绐�
@@ -1017,7 +1388,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)); //
});
@@ -1031,14 +1401,14 @@
auto clientWidth = RECT_WIDTH(clientRect);
auto clientHeight = RECT_HEIGHT(clientRect);
- QPoint qtScenePos = QHighDpi::fromNativeLocalPosition(
- QPoint(nativeLocalPos.x, nativeLocalPos.y), m_windowHandle);
+ QPoint qtScenePos =
+ QHighDpi::fromNativeLocalPosition(point2qpoint(nativeLocalPos), m_windowHandle);
bool isFixedSize = m_delegate->isHostSizeFixed(m_host);
bool isTitleBar = isInTitleBarDraggableArea(qtScenePos);
bool dontOverrideCursor = false; // ### TODO
- CoreWindowAgent::SystemButton sysButtonType = CoreWindowAgent::Unknown;
+ WindowAgentBase::SystemButton sysButtonType = WindowAgentBase::Unknown;
if (!isFixedSize && isInSystemButtons(qtScenePos, &sysButtonType)) {
// Firstly, we set the hit test result to a default value to be able to detect
// whether we have changed it or not afterwards.
@@ -1048,22 +1418,31 @@
// this is also the normal behavior of a native Win32 window (but only when the
// window is not maximized/fullscreen/minimized, of course).
if (isWindowNoState(hWnd)) {
- static constexpr const int kBorderSize = 2;
+ static constexpr const quint8 kBorderSize = 2;
bool isTop = (nativeLocalPos.y <= kBorderSize);
+ bool isLeft = nativeLocalPos.x <= kBorderSize;
bool isRight = (nativeLocalPos.x >= (clientWidth - kBorderSize));
- if (isTop || isRight) {
+ if (isTop || isLeft || isRight) {
if (dontOverrideCursor) {
// The user doesn't want the window to be resized, so we tell
// Windows we are in the client area so that the controls beneath
// the mouse cursor can still be hovered or clicked.
*result = (isTitleBar ? HTCAPTION : HTCLIENT);
} else {
- if (isTop && isRight) {
- *result = HTTOPRIGHT;
- } else if (isTop) {
- *result = HTTOP;
+ if (isTop) {
+ if (isLeft) {
+ *result = HTTOPLEFT;
+ } else if (isRight) {
+ *result = HTTOPRIGHT;
+ } else {
+ *result = HTTOP;
+ }
} else {
- *result = HTRIGHT;
+ if (isLeft) {
+ *result = HTLEFT;
+ } else {
+ *result = HTRIGHT;
+ }
}
}
}
@@ -1073,23 +1452,24 @@
// exact role of our button. The Snap Layout feature introduced in Windows
// 11 won't work without this.
switch (sysButtonType) {
- case CoreWindowAgent::WindowIcon:
+ case WindowAgentBase::WindowIcon:
*result = HTSYSMENU;
break;
- case CoreWindowAgent::Help:
+ case WindowAgentBase::Help:
*result = HTHELP;
break;
- case CoreWindowAgent::Minimize:
+ case WindowAgentBase::Minimize:
*result = HTREDUCE;
break;
- case CoreWindowAgent::Maximize:
+ case WindowAgentBase::Maximize:
*result = HTZOOM;
break;
- case CoreWindowAgent::Close:
+ case WindowAgentBase::Close:
*result = HTCLOSE;
break;
default:
- break; // unreachable
+ // unreachable
+ break;
}
}
if (*result == HTNOWHERE) {
@@ -1108,6 +1488,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.
@@ -1130,7 +1511,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
@@ -1150,7 +1531,9 @@
}
*result = HTCLIENT;
return true;
- } else {
+ } else
+#endif
+ {
if (full) {
*result = HTCLIENT;
return true;
@@ -1163,9 +1546,9 @@
const bool isBottom = (nativeLocalPos.y >= (clientHeight - frameSize));
// Make the border a little wider to let the user easy to resize on corners.
const auto scaleFactor = ((isTop || isBottom) ? qreal(2) : qreal(1));
- const int scaledFrameSizeX = std::round(qreal(frameSize) * scaleFactor);
- const bool isLeft = (nativeLocalPos.x < scaledFrameSizeX);
- const bool isRight = (nativeLocalPos.x >= (clientWidth - scaledFrameSizeX));
+ const int scaledFrameSize = std::round(qreal(frameSize) * scaleFactor);
+ const bool isLeft = (nativeLocalPos.x < scaledFrameSize);
+ const bool isRight = (nativeLocalPos.x >= (clientWidth - scaledFrameSize));
if (dontOverrideCursor && (isTop || isBottom || isLeft || isRight)) {
// Return HTCLIENT instead of HTBORDER here, because the mouse is
// inside the window now, return HTCLIENT to let the controls
@@ -1214,9 +1597,28 @@
return true;
}
}
+
+ case WM_WINDOWPOSCHANGING: {
+ // ### FIXME: How does this problem happen and why is it solved?
+ // When toggling the "Show theme color in title bar and window border" setting in
+ // Windows Settings, or calling `DrawMenuBar()`, Windows sends a message of
+ // WM_WINDOWPOSCHANGING with flags 0x37. If we do not process this message,
+ // the client area as a whole will shift to the left, which looks very abnormal if
+ // we don't repaint it. This exception disappears if we add SWP_NOCOPYBITS flag.
+ // But I don't know what caused the problem, or why this would solve it.
+ static constexpr const auto kBadWindowPosFlag =
+ SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED;
+ const auto windowPos = reinterpret_cast<LPWINDOWPOS>(lParam);
+ if (windowPos->flags == kBadWindowPosFlag) {
+ windowPos->flags |= SWP_NOCOPYBITS;
+ }
+ break;
+ }
+
default:
break;
}
+
if (!isWin10OrGreater()) {
switch (message) {
case WM_NCUAHDRAWCAPTION:
@@ -1249,11 +1651,7 @@
// window activation state change.
*result = ::DefWindowProcW(hWnd, WM_NCACTIVATE, wParam, -1);
} else {
- if (wParam) {
- *result = FALSE;
- } else {
- *result = TRUE;
- }
+ *result = TRUE;
}
return true;
}
@@ -1283,6 +1681,7 @@
bool Win32WindowContext::nonClientCalcSizeHandler(HWND hWnd, UINT message, WPARAM wParam,
LPARAM lParam, LRESULT *result) {
Q_UNUSED(message)
+ Q_UNUSED(this)
// Windows鏄牴鎹繖涓秷鎭殑杩斿洖鍊兼潵璁剧疆绐楀彛鐨勫鎴峰尯锛堢獥鍙ｄ腑鐪熸鏄剧ず鐨勫唴瀹癸級
// 鍜岄潪瀹㈡埛鍖猴紙鏍囬鏍忋�佺獥鍙ｈ竟妗嗐�佽彍鍗曟爮鍜岀姸鎬佹爮绛塛indows绯荤粺鑷鎻愪緵鐨勯儴鍒�
@@ -1371,6 +1770,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.
@@ -1398,6 +1798,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
@@ -1412,11 +1813,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,
@@ -1507,4 +1913,92 @@
return true;
}
+ bool Win32WindowContext::systemMenuHandler(HWND hWnd, UINT message, WPARAM wParam,
+ LPARAM lParam, LRESULT *result) {
+ const auto getNativePosFromMouse = [lParam]() -> POINT {
+ return {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
+ };
+ const auto getNativeGlobalPosFromKeyboard = [hWnd]() -> POINT {
+ const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
+ const quint32 frameSize = getResizeBorderThickness(hWnd);
+ const quint32 horizontalOffset = ((maxOrFull || !isWin10OrGreater()) ? 0 : frameSize);
+ const auto verticalOffset = [hWnd, maxOrFull, frameSize]() -> quint32 {
+ const quint32 titleBarHeight = getTitleBarHeight(hWnd);
+ if (!isWin10OrGreater()) {
+ return titleBarHeight;
+ }
+ if (isWin11OrGreater()) {
+ if (maxOrFull) {
+ return (titleBarHeight + frameSize);
+ }
+ return titleBarHeight;
+ }
+ if (maxOrFull) {
+ return titleBarHeight;
+ }
+ return titleBarHeight - frameSize;
+ }();
+ RECT windowPos{};
+ ::GetWindowRect(hWnd, &windowPos);
+ return {static_cast<LONG>(windowPos.left + horizontalOffset),
+ static_cast<LONG>(windowPos.top + verticalOffset)};
+ };
+ bool shouldShowSystemMenu = false;
+ bool broughtByKeyboard = false;
+ POINT nativeGlobalPos{};
+ switch (message) {
+ case WM_RBUTTONUP: {
+ const POINT nativeLocalPos = getNativePosFromMouse();
+ const QPoint qtScenePos =
+ QHighDpi::fromNativeLocalPosition(point2qpoint(nativeLocalPos), m_windowHandle);
+ if (isInTitleBarDraggableArea(qtScenePos)) {
+ shouldShowSystemMenu = true;
+ nativeGlobalPos = nativeLocalPos;
+ ::ClientToScreen(hWnd, &nativeGlobalPos);
+ }
+ break;
+ }
+ case WM_NCRBUTTONUP: {
+ if (wParam == HTCAPTION) {
+ shouldShowSystemMenu = true;
+ nativeGlobalPos = getNativePosFromMouse();
+ }
+ break;
+ }
+ case WM_SYSCOMMAND: {
+ const WPARAM filteredWParam = (wParam & 0xFFF0);
+ if ((filteredWParam == SC_KEYMENU) && (lParam == VK_SPACE)) {
+ shouldShowSystemMenu = true;
+ broughtByKeyboard = true;
+ nativeGlobalPos = getNativeGlobalPosFromKeyboard();
+ }
+ break;
+ }
+ case WM_KEYDOWN:
+ case WM_SYSKEYDOWN: {
+ const bool altPressed = ((wParam == VK_MENU) || (::GetKeyState(VK_MENU) < 0));
+ const bool spacePressed = ((wParam == VK_SPACE) || (::GetKeyState(VK_SPACE) < 0));
+ if (altPressed && spacePressed) {
+ shouldShowSystemMenu = true;
+ broughtByKeyboard = true;
+ nativeGlobalPos = getNativeGlobalPosFromKeyboard();
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ if (shouldShowSystemMenu) {
+ showSystemMenu2(hWnd, nativeGlobalPos, broughtByKeyboard,
+ m_delegate->isHostSizeFixed(m_host));
+ // QPA's internal code will handle system menu events separately, and its
+ // behavior is not what we would want to see because it doesn't know our
+ // window doesn't have any window frame now, so return early here to avoid
+ // entering Qt's own handling logic.
+ *result = FALSE;
+ return true;
+ }
+ return false;
+ }
+
}
--
Gitblit v1.9.1