From e95e2bfd29b64d3144515c30fb9cf76adb75c6c3 Mon Sep 17 00:00:00 2001
From: Sine Striker <trueful@163.com>
Date: 周二, 07 5月 2024 21:44:21 +0800
Subject: [PATCH] minor tweaks
---
src/core/contexts/win32windowcontext.cpp | 582 ++++++++++++++++++++++++++++++++-------------------------
1 files changed, 326 insertions(+), 256 deletions(-)
diff --git a/src/core/contexts/win32windowcontext.cpp b/src/core/contexts/win32windowcontext.cpp
index 6dec43f..171a348 100644
--- a/src/core/contexts/win32windowcontext.cpp
+++ b/src/core/contexts/win32windowcontext.cpp
@@ -1,15 +1,21 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
#include "win32windowcontext_p.h"
#include <optional>
+#include <QtCore/QAbstractEventDispatcher>
+#include <QtCore/QDateTime>
#include <QtCore/QHash>
#include <QtCore/QScopeGuard>
#include <QtCore/QTimer>
-#include <QtCore/QDateTime>
#include <QtGui/QGuiApplication>
#include <QtGui/QPainter>
#include <QtGui/QPalette>
-#include <QtGui/QStyleHints>
+
+#include <QtGui/qpa/qwindowsysteminterface.h>
#include <QtGui/private/qhighdpiscaling_p.h>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -26,10 +32,6 @@
#include "qwkglobal_p.h"
#include "qwkwindowsextra_p.h"
-
-#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-Q_DECLARE_METATYPE(QMargins)
-#endif
namespace QWK {
@@ -51,13 +53,13 @@
static WNDPROC g_qtWindowProc = nullptr;
static inline bool
-#if !QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
+#if !QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
constexpr
#endif
isSystemBorderEnabled() {
return
-#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
isWin10OrGreater()
#else
false
@@ -69,55 +71,6 @@
::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER |
SWP_FRAMECHANGED);
- }
-
- static inline quint32 getDpiForWindow(HWND hwnd) {
- const DynamicApis &apis = DynamicApis::instance();
- if (apis.pGetDpiForWindow) { // Win10
- return apis.pGetDpiForWindow(hwnd);
- } else if (apis.pGetDpiForMonitor) { // Win8.1
- HMONITOR monitor = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
- 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);
- ::ReleaseDC(nullptr, hdc);
- return quint32(dpiX);
- }
- }
-
- static inline quint32 getSystemMetricsForDpi(int index, quint32 dpi) {
- const DynamicApis &apis = DynamicApis::instance();
- if (apis.pGetSystemMetricsForDpi) {
- 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 quint32 dpi = getDpiForWindow(hwnd);
- return getSystemMetricsForDpi(SM_CYCAPTION, dpi) +
- getSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) +
- getSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);
}
static void setInternalWindowFrameMargins(QWindow *window, const QMargins &margins) {
@@ -146,18 +99,6 @@
monitorInfo.cbSize = sizeof(monitorInfo);
::GetMonitorInfoW(monitor, &monitorInfo);
return monitorInfo;
- }
-
- static inline void moveWindowToDesktopCenter(HWND hwnd) {
- MONITORINFOEXW monitorInfo = getMonitorForWindow(hwnd);
- RECT windowRect{};
- ::GetWindowRect(hwnd, &windowRect);
- 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) {
@@ -215,7 +156,7 @@
[[maybe_unused]] const auto &cleaner =
qScopeGuard([windowThreadProcessId, currentThreadId]() {
::AttachThreadInput(windowThreadProcessId, currentThreadId, FALSE); //
- });
+ }); // TODO: Remove it
::BringWindowToTop(hwnd);
// Activate the window too. This will force us to the virtual desktop this
@@ -292,14 +233,15 @@
apis.ptimeEndPeriod(ms_granularity);
}
- static void showSystemMenu2(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
- const bool fixedSize) {
+ // Returns false if the menu is canceled
+ static bool showSystemMenu_sys(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;
+ return true;
}
const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
@@ -343,7 +285,8 @@
// Popup the system menu at the required position.
const auto result = ::TrackPopupMenu(
hMenu,
- (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
+ (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN) |
+ TPM_RIGHTBUTTON),
pos.x, pos.y, 0, hWnd, nullptr);
// Unhighlight the first menu item after the popup menu is closed, otherwise it will keep
@@ -352,11 +295,12 @@
if (!result) {
// The user canceled the menu, no need to continue.
- return;
+ return false;
}
// Send the command that the user chooses to the corresponding window.
::PostMessageW(hWnd, WM_SYSCOMMAND, result, 0);
+ return true;
}
static inline Win32WindowContext::WindowPart getHitWindowPart(int hitTestResult) {
@@ -383,7 +327,7 @@
case HTBORDER:
return Win32WindowContext::FixedBorder;
default:
- // unreachable
+ Q_UNREACHABLE();
break;
}
return Win32WindowContext::Outside;
@@ -421,6 +365,107 @@
return true;
}
+ static inline constexpr bool isNonClientMessage(const UINT message) {
+ if (((message >= WM_NCCREATE) && (message <= WM_NCACTIVATE)) ||
+ ((message >= WM_NCMOUSEMOVE) && (message <= WM_NCMBUTTONDBLCLK)) ||
+ ((message >= WM_NCXBUTTONDOWN) && (message <= WM_NCXBUTTONDBLCLK))
+#if (WINVER >= _WIN32_WINNT_WIN8)
+ || ((message >= WM_NCPOINTERUPDATE) && (message <= WM_NCPOINTERUP))
+#endif
+ || ((message == WM_NCMOUSEHOVER) || (message == WM_NCMOUSELEAVE))) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ static MSG createMessageBlock(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
+ MSG msg;
+ msg.hwnd = hWnd; // re-create MSG structure
+ msg.message = message; // time and pt fields ignored
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+
+ const DWORD dwScreenPos = ::GetMessagePos();
+ msg.pt.x = GET_X_LPARAM(dwScreenPos);
+ msg.pt.y = GET_Y_LPARAM(dwScreenPos);
+ if (!isNonClientMessage(message)) {
+ ::ScreenToClient(hWnd, &msg.pt);
+ }
+ return msg;
+ }
+
+ static inline constexpr bool isInputMessage(UINT m) {
+ switch (m) {
+ case WM_IME_STARTCOMPOSITION:
+ case WM_IME_ENDCOMPOSITION:
+ case WM_IME_COMPOSITION:
+ case WM_INPUT:
+ case WM_TOUCH:
+ case WM_MOUSEHOVER:
+ case WM_MOUSELEAVE:
+ case WM_NCMOUSEHOVER:
+ case WM_NCMOUSELEAVE:
+ case WM_SIZING:
+ case WM_MOVING:
+ case WM_SYSCOMMAND:
+ case WM_COMMAND:
+ case WM_DWMNCRENDERINGCHANGED:
+ case WM_PAINT:
+ return true;
+ default:
+ break;
+ }
+ return (m >= WM_MOUSEFIRST && m <= WM_MOUSELAST) ||
+ (m >= WM_NCMOUSEMOVE && m <= WM_NCXBUTTONDBLCLK) ||
+ (m >= WM_KEYFIRST && m <= WM_KEYLAST);
+ }
+
+ static inline QByteArray nativeEventType() {
+ return QByteArrayLiteral("windows_generic_MSG");
+ }
+
+ // Send to QAbstractEventDispatcher
+ bool filterNativeEvent(MSG *msg, LRESULT *result) {
+ auto dispatcher = QAbstractEventDispatcher::instance();
+ QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
+ if (dispatcher && dispatcher->filterNativeEvent(nativeEventType(), msg, &filterResult)) {
+ *result = LRESULT(filterResult);
+ return true;
+ }
+ return false;
+ }
+
+ // Send to QWindowSystemInterface
+ bool filterNativeEvent(QWindow *window, MSG *msg, LRESULT *result) {
+ QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
+ if (QWindowSystemInterface::handleNativeEvent(window, nativeEventType(), msg,
+ &filterResult)) {
+ *result = LRESULT(filterResult);
+ return true;
+ }
+ return false;
+ }
+
+ static inline bool forwardFilteredEvent(QWindow *window, HWND hWnd, UINT message, WPARAM wParam,
+ LPARAM lParam, LRESULT *result) {
+ MSG msg = createMessageBlock(hWnd, message, wParam, lParam);
+
+ // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1025
+ // Do exact the same as what Qt Windows plugin does.
+
+ // Run the native event filters. QTBUG-67095: Exclude input messages which are sent
+ // by QEventDispatcherWin32::processEvents()
+ if (!isInputMessage(msg.message) && filterNativeEvent(&msg, result))
+ return true;
+
+ auto platformWindow = window->handle();
+ if (platformWindow && filterNativeEvent(platformWindow->window(), &msg, result))
+ return true;
+
+ return false;
+ }
+
// https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1556
// In QWindowsContext::windowsProc(), the messages will be passed to all global native event
// filters, but because we have already filtered the messages in the hook WndProc function for
@@ -440,23 +485,44 @@
return false;
}
- // 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 acquires the initial data.
auto msg = static_cast<const MSG *>(message);
- if (msg->message == WM_NCCALCSIZE && lastMessageContext) {
- LRESULT res;
- if (lastMessageContext->nonClientCalcSizeHandler(msg->hwnd, msg->message,
- msg->wParam, msg->lParam, &res)) {
- *result = decltype(*result)(res);
- return true;
+ switch (msg->message) {
+ case WM_NCCALCSIZE: {
+ // 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 acquires the initial data.
+ if (lastMessageContext) {
+ LRESULT res;
+ if (lastMessageContext->nonClientCalcSizeHandler(
+ msg->hwnd, msg->message, msg->wParam, msg->lParam, &res)) {
+ *result = decltype(*result)(res);
+ return true;
+ }
+ }
+ break;
}
+
+ // case WM_NCHITTEST: {
+ // // The child window must return HTTRANSPARENT when processing
+ // WM_NCHITTEST for
+ // // the parent window to receive WM_NCHITTEST.
+ // if (!lastMessageContext) {
+ // auto rootHWnd = ::GetAncestor(msg->hwnd, GA_ROOT);
+ // if (rootHWnd != msg->hwnd) {
+ // if (auto ctx = g_wndProcHash->value(rootHWnd)) {
+ // *result = HTTRANSPARENT;
+ // return true;
+ // }
+ // }
+ // }
+ // break;
+ // }
}
return false;
}
- static WindowsNativeEventFilter *instance;
- static Win32WindowContext *lastMessageContext;
+ static inline WindowsNativeEventFilter *instance = nullptr;
+ static inline Win32WindowContext *lastMessageContext = nullptr;
static inline void install() {
if (instance) {
@@ -473,9 +539,6 @@
instance = nullptr;
}
};
-
- WindowsNativeEventFilter *WindowsNativeEventFilter::instance = nullptr;
- Win32WindowContext *WindowsNativeEventFilter::lastMessageContext = nullptr;
// https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1025
// We can see from the source code that Qt will filter out some messages first and then send the
@@ -542,18 +605,24 @@
return ::DefWindowProcW(hWnd, message, wParam, lParam);
}
+ WindowsNativeEventFilter::lastMessageContext = ctx;
+ const auto &contextCleaner = qScopeGuard([]() {
+ WindowsNativeEventFilter::lastMessageContext = nullptr; //
+ });
+
// Since Qt does the necessary processing of the WM_NCCALCSIZE message, we need to
// forward it right away and process it in our native event filter.
if (message == WM_NCCALCSIZE) {
- WindowsNativeEventFilter::lastMessageContext = ctx;
- LRESULT result = ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
- WindowsNativeEventFilter::lastMessageContext = nullptr;
- return result;
+ return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
}
// Try hooked procedure and save result
LRESULT result;
if (ctx->windowProc(hWnd, message, wParam, lParam, &result)) {
+ // Forward the event to user-defined native event filters, there may be some messages
+ // that need to be processed by the user.
+ std::ignore =
+ forwardFilteredEvent(ctx->window(), hWnd, message, wParam, lParam, &result);
return result;
}
@@ -562,18 +631,10 @@
}
static inline void addManagedWindow(QWindow *window, HWND hWnd, Win32WindowContext *ctx) {
- const auto margins = [hWnd]() -> QMargins {
- const auto titleBarHeight = int(getTitleBarHeight(hWnd));
- if (isSystemBorderEnabled()) {
- 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);
+ if (isSystemBorderEnabled()) {
+ // Inform Qt we want and have set custom margins
+ setInternalWindowFrameMargins(window, QMargins(0, -int(getTitleBarHeight(hWnd)), 0, 0));
+ }
// Store original window proc
if (!g_qtWindowProc) {
@@ -605,8 +666,8 @@
}
Win32WindowContext::~Win32WindowContext() {
- if (windowId) {
- removeManagedWindow(reinterpret_cast<HWND>(windowId));
+ if (m_windowId) {
+ removeManagedWindow(reinterpret_cast<HWND>(m_windowId));
}
}
@@ -616,35 +677,28 @@
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)
+ if (!m_windowId)
return;
- const auto hwnd = reinterpret_cast<HWND>(windowId);
+ m_delegate->setWindowVisible(m_host, true);
+ const auto hwnd = reinterpret_cast<HWND>(m_windowId);
bringWindowToFront(hwnd);
return;
}
case ShowSystemMenuHook: {
- if (!windowId)
+ if (!m_windowId)
return;
const auto &pos = *static_cast<const QPoint *>(data);
- auto hWnd = reinterpret_cast<HWND>(windowId);
+ auto hWnd = reinterpret_cast<HWND>(m_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));
+ std::ignore = showSystemMenu_sys(hWnd, qpoint2point(nativeGlobalPos), false,
+ m_delegate->isHostSizeFixed(m_host));
return;
}
@@ -658,16 +712,16 @@
return;
}
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
case DrawWindows10BorderHook: {
-#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
- if (!windowId)
+ if (!m_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);
+ const auto hwnd = reinterpret_cast<HWND>(m_windowId);
QPen pen;
pen.setWidth(int(getWindowFrameBorderThickness(hwnd)) * 2);
@@ -700,19 +754,17 @@
});
painter.restore();
return;
-#endif
}
case DrawWindows10BorderHook2: {
-#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
- if (!m_windowHandle)
+ if (!m_windowId)
return;
// https://github.com/microsoft/terminal/blob/71a6f26e6ece656084e87de1a528c4a8072eeabd/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp#L1025
// https://docs.microsoft.com/en-us/windows/win32/dwm/customframe#extending-the-client-frame
// Draw a black rectangle to make Windows native top border show
- auto hWnd = reinterpret_cast<HWND>(windowId);
+ auto hWnd = reinterpret_cast<HWND>(m_windowId);
HDC hdc = ::GetDC(hWnd);
RECT windowRect{};
::GetClientRect(hWnd, &windowRect);
@@ -725,48 +777,9 @@
::FillRect(hdc, &rcTopBorder,
reinterpret_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH)));
::ReleaseDC(hWnd, hdc);
-#endif
return;
}
-
- // case AbstractWindowContext::DrawWindows10BackgroundHook: {
- // #if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
- // if (!m_windowHandle)
- // return;
- //
- // auto hWnd = reinterpret_cast<HWND>(windowId);
- // HDC hdc = ::GetDC(hWnd);
- // RECT windowRect{};
- // ::GetClientRect(hWnd, &windowRect);
- // RECT rcRest = {
- // 0,
- // int(getWindowFrameBorderThickness(hWnd)),
- // RECT_WIDTH(windowRect),
- // RECT_HEIGHT(windowRect),
- // };
- // HBRUSH blueBrush = ::CreateSolidBrush(RGB(0, 0, 255));
- //
- // // To hide the original title bar, we have to paint on top of it
- // with
- // // the alpha component set to 255. This is a hack to do it with
- // GDI.
- // // See NonClientIslandWindow::_UpdateFrameMargins for more
- // information. HDC opaqueDc; BP_PAINTPARAMS params =
- // {sizeof(params), BPPF_NOCLIP | BPPF_ERASE}; auto buf =
- // BeginBufferedPaint(hdc, &rcRest, BPBF_TOPDOWNDIB, ¶ms,
- // &opaqueDc); if (!buf || !opaqueDc) {
- // return;
- // }
- //
- // ::FillRect(opaqueDc, &rcRest, blueBrush);
- // ::BufferedPaintSetAlpha(buf, nullptr, 255);
- // ::EndBufferedPaint(buf, TRUE);
- //
- // ::DeleteObject(blueBrush);
- // ::ReleaseDC(hWnd, hdc);
- // #endif
- // return;
- // }
+#endif
default:
break;
@@ -774,40 +787,83 @@
AbstractWindowContext::virtual_hook(id, data);
}
- void Win32WindowContext::winIdChanged() {
- // If the original window id is valid, remove all resources related
- if (windowId) {
- removeManagedWindow(reinterpret_cast<HWND>(windowId));
- windowId = 0;
+ QVariant Win32WindowContext::windowAttribute(const QString &key) const {
+ if (key == QStringLiteral("window-rect")) {
+ if (!m_windowId)
+ return {};
+
+ RECT frame{};
+ auto hwnd = reinterpret_cast<HWND>(m_windowId);
+ // According to MSDN, WS_OVERLAPPED is not allowed for AdjustWindowRect.
+ auto style = static_cast<DWORD>(::GetWindowLongPtrW(hwnd, GWL_STYLE) & ~WS_OVERLAPPED);
+ auto exStyle = static_cast<DWORD>(::GetWindowLongPtrW(hwnd, GWL_EXSTYLE));
+ const DynamicApis &apis = DynamicApis::instance();
+ if (apis.pAdjustWindowRectExForDpi) {
+ apis.pAdjustWindowRectExForDpi(&frame, style, FALSE, exStyle,
+ getDpiForWindow(hwnd));
+ } else {
+ ::AdjustWindowRectEx(&frame, style, FALSE, exStyle);
+ }
+ return QVariant::fromValue(rect2qrect(frame));
}
- if (!m_windowHandle) {
+ if (key == QStringLiteral("win10-border-needed")) {
+ return isSystemBorderEnabled() && !isWin11OrGreater();
+ }
+
+ if (key == QStringLiteral("border-thickness")) {
+ return m_windowId
+ ? int(getWindowFrameBorderThickness(reinterpret_cast<HWND>(m_windowId)))
+ : 0;
+ }
+ return AbstractWindowContext::windowAttribute(key);
+ }
+
+ void Win32WindowContext::winIdChanged(WId winId, WId oldWinId) {
+ // Reset the context data
+ mouseLeaveBlocked = false;
+ lastHitTestResult = WindowPart::Outside;
+ lastHitTestResultRaw = HTNOWHERE;
+
+ if (!isSystemBorderEnabled()) {
+ m_delegate->setWindowFlags(m_host, m_delegate->getWindowFlags(m_host) |
+ Qt::FramelessWindowHint);
+ }
+
+ // If the original window id is valid, remove all resources related
+ if (oldWinId) {
+ removeManagedWindow(reinterpret_cast<HWND>(oldWinId));
+ }
+
+ if (!winId) {
return;
}
// Install window hook
- auto winId = m_windowHandle->winId();
auto hWnd = reinterpret_cast<HWND>(winId);
-
if (!isSystemBorderEnabled()) {
- setWindowAttribute("extra-margins", true);
+ static auto margins = QVariant::fromValue(QMargins(1, 1, 1, 1));
+
+ // If we remove the system border, the window will lose its shadow. If dwm is enabled,
+ // then we need to set at least 1px margins, otherwise the following operation will
+ // fail with no effect.
+ setWindowAttribute(QStringLiteral("extra-margins"), margins);
}
+ // We should disable WS_SYSMENU, otherwise the system button icons will be visible if mica
+ // is enabled and the title bar is transparent.
{
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
+ if (isSystemBorderEnabled()) {
+ ::SetWindowLongPtrW(hWnd, GWL_STYLE, style & (~WS_SYSMENU));
+ } else {
+ ::SetWindowLongPtrW(hWnd, GWL_STYLE,
+ (style | WS_THICKFRAME | WS_CAPTION) & (~WS_SYSMENU));
+ }
}
// Add managed window
addManagedWindow(m_windowHandle, hWnd, this);
-
- // Cache win id
- windowId = winId;
}
bool Win32WindowContext::windowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam,
@@ -817,8 +873,8 @@
// We should skip these messages otherwise we will get crashes.
// NOTE: WM_QUIT won't be posted to the WindowProc function.
switch (message) {
- case WM_CLOSE:
case WM_DESTROY:
+ case WM_CLOSE:
case WM_NCDESTROY:
// Undocumented messages:
case WM_UAHDESTROYWINDOW:
@@ -849,13 +905,9 @@
// Forward to native event filter subscribers
if (!m_nativeEventFilters.isEmpty()) {
- MSG msg;
- msg.hwnd = hWnd;
- msg.message = message;
- msg.wParam = wParam;
- msg.lParam = lParam;
+ MSG msg = createMessageBlock(hWnd, message, wParam, lParam);
QT_NATIVE_EVENT_RESULT_TYPE res = 0;
- if (nativeDispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
+ if (nativeDispatch(nativeEventType(), &msg, &res)) {
*result = LRESULT(res);
return true;
}
@@ -865,18 +917,20 @@
bool Win32WindowContext::windowAttributeChanged(const QString &key, const QVariant &attribute,
const QVariant &oldAttribute) {
- const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());
+ Q_UNUSED(oldAttribute)
+
+ const auto hwnd = reinterpret_cast<HWND>(m_windowId);
const DynamicApis &apis = DynamicApis::instance();
- static constexpr const MARGINS defaultEmptyMargins = {0, 0, 0, 0};
- static constexpr const MARGINS defaultExtraMargins = {1, 1, 1, 1};
static constexpr const MARGINS extendedMargins = {-1, -1, -1, -1};
+ const auto &restoreMargins = [this, &apis, hwnd]() {
+ auto margins = qmargins2margins(
+ m_windowAttributes.value(QStringLiteral("extra-margins")).value<QMargins>());
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &margins);
+ };
+
if (key == QStringLiteral("extra-margins")) {
- if (isWin11OrGreater())
- return false;
- hasExtraMargins = attribute.toBool();
- DynamicApis::instance().pDwmExtendFrameIntoClientArea(
- hwnd, hasExtraMargins ? &defaultExtraMargins : &defaultEmptyMargins);
- return true;
+ auto margins = qmargins2margins(attribute.value<QMargins>());
+ return apis.pDwmExtendFrameIntoClientArea(hwnd, &margins) == S_OK;
}
if (key == QStringLiteral("dark-mode")) {
@@ -902,8 +956,6 @@
}
// For Win11 or later
- static const auto &defaultMargins =
- isSystemBorderEnabled() ? defaultExtraMargins : defaultEmptyMargins;
if (key == QStringLiteral("mica")) {
if (!isWin11OrGreater()) {
return false;
@@ -933,7 +985,7 @@
const BOOL enable = FALSE;
apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable));
}
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ restoreMargins();
}
return true;
}
@@ -955,7 +1007,7 @@
const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
sizeof(backdropType));
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ restoreMargins();
}
return true;
}
@@ -1002,18 +1054,15 @@
// wcad.cbData = sizeof(policy);
// apis.pSetWindowCompositionAttribute(hwnd, &wcad);
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ restoreMargins();
}
return true;
}
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, &extendedMargins);
+ // We can't extend the window frame for this effect.
+ restoreMargins();
if (isWin8OrGreater()) {
ACCENT_POLICY policy{};
policy.dwAccentState = ACCENT_ENABLE_BLURBEHIND;
@@ -1045,7 +1094,6 @@
bb.dwFlags = DWM_BB_ENABLE;
apis.pDwmEnableBlurBehindWindow(hwnd, &bb);
}
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
}
return true;
}
@@ -1254,9 +1302,8 @@
case WM_NCPOINTERUP:
#endif
case WM_NCMOUSEHOVER: {
- const WindowPart currentWindowPart = lastHitTestResult;
if (message == WM_NCMOUSEMOVE) {
- if (currentWindowPart != WindowPart::ChromeButton) {
+ if (lastHitTestResult != 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
@@ -1305,29 +1352,38 @@
// the above problems would not arise.
m_delegate->resetQtGrabbedControl(m_host);
+
+ // If the mouse moves from chrome buttons to other non-client areas, a
+ // WM_MOUSELEAVE message should be sent.
if (mouseLeaveBlocked) {
emulateClientAreaMessage(hWnd, message, wParam, lParam,
WM_NCMOUSELEAVE);
}
}
-
- // We need to make sure we get the right hit-test result when a WM_NCMOUSELEAVE
- // comes, so we reset it when we receive a WM_NCMOUSEMOVE.
-
- // If the mouse is entering the client area, there must be a WM_NCHITTEST
- // setting it to `Client` before the WM_NCMOUSELEAVE comes; if the mouse is
- // leaving the window, current window part remains as `Outside`.
- lastHitTestResult = WindowPart::Outside;
}
- if (currentWindowPart == WindowPart::ChromeButton) {
- emulateClientAreaMessage(hWnd, message, wParam, lParam);
+ if (lastHitTestResult == WindowPart::ChromeButton) {
if (message == WM_NCMOUSEMOVE) {
// ### FIXME FIXME FIXME
// ### FIXME: Calling DefWindowProc() here is really dangerous, investigate
// how to avoid doing this.
// ### FIXME FIXME FIXME
*result = ::DefWindowProcW(hWnd, WM_NCMOUSEMOVE, wParam, lParam);
+ } else if (lastHitTestResultRaw == HTSYSMENU) {
+ if (message == WM_NCLBUTTONDOWN) {
+ // A message of WM_SYSCOMMAND with SC_MOUSEMENU will be sent by Windows,
+ // and the current control flow will be blocked by the menu while
+ // Windows will create and execute a new event loop until the menu
+ // returns
+ iconButtonClickTime = ::GetTickCount64();
+ *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
+ iconButtonClickTime = 0;
+ } else if (message == WM_NCLBUTTONDBLCLK) {
+ // A message of WM_SYSCOMMAND with SC_CLOSE will be sent by Windows
+ *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
+ } else {
+ *result = FALSE;
+ }
} else {
// According to MSDN, we should return non-zero for X button messages to
// indicate we have handled these messages (due to historical reasons), for
@@ -1337,6 +1393,7 @@
? TRUE
: FALSE);
}
+ emulateClientAreaMessage(hWnd, message, wParam, lParam);
return true;
}
break;
@@ -1349,7 +1406,7 @@
// pressing area as HTCLIENT which maybe because of our former retransmission of
// WM_NCLBUTTONDOWN, as a result, a WM_NCMOUSELEAVE will come immediately and a
// lot of WM_MOUSEMOVE will come if we move the mouse, we should track the mouse
- // in advance.
+ // in advance. (May be redundant?)
if (mouseLeaveBlocked) {
mouseLeaveBlocked = false;
requestForMouseLeaveMessage(hWnd, false);
@@ -1383,19 +1440,6 @@
bool Win32WindowContext::customWindowHandler(HWND hWnd, UINT message, WPARAM wParam,
LPARAM lParam, LRESULT *result) {
switch (message) {
- case WM_SHOWWINDOW: {
- if (!centered) {
- // 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) {
- centered = true;
- moveWindowToDesktopCenter(hWnd);
- }
- }
- break;
- }
-
case WM_NCHITTEST: {
// 鍘熺敓Win32绐楀彛鍙湁椤惰竟鏄湪绐楀彛鍐呴儴resize鐨勶紝鍏朵綑涓夎竟閮芥槸鍦ㄧ獥鍙�
// 澶栭儴杩涜resize鐨勶紝鍏跺師鐞嗘槸锛學S_THICKFRAME杩欎釜绐楀彛鏍峰紡浼氬湪绐�
@@ -1478,7 +1522,8 @@
// 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)); //
+ lastHitTestResultRaw = int(*result);
+ lastHitTestResult = getHitWindowPart(lastHitTestResultRaw);
});
POINT nativeGlobalPos{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
@@ -2027,6 +2072,7 @@
bool shouldShowSystemMenu = false;
bool broughtByKeyboard = false;
POINT nativeGlobalPos{};
+
switch (message) {
case WM_RBUTTONUP: {
const POINT nativeLocalPos = getNativePosFromMouse();
@@ -2048,10 +2094,20 @@
}
case WM_SYSCOMMAND: {
const WPARAM filteredWParam = (wParam & 0xFFF0);
- if ((filteredWParam == SC_KEYMENU) && (lParam == VK_SPACE)) {
- shouldShowSystemMenu = true;
- broughtByKeyboard = true;
- nativeGlobalPos = getNativeGlobalPosFromKeyboard();
+ switch (filteredWParam) {
+ case SC_MOUSEMENU:
+ shouldShowSystemMenu = true;
+ nativeGlobalPos = getNativeGlobalPosFromKeyboard();
+ break;
+ case SC_KEYMENU:
+ if (lParam == VK_SPACE) {
+ shouldShowSystemMenu = true;
+ broughtByKeyboard = true;
+ nativeGlobalPos = getNativeGlobalPosFromKeyboard();
+ }
+ break;
+ default:
+ break;
}
break;
}
@@ -2070,8 +2126,31 @@
break;
}
if (shouldShowSystemMenu) {
- showSystemMenu2(hWnd, nativeGlobalPos, broughtByKeyboard,
- m_delegate->isHostSizeFixed(m_host));
+ bool triggeredByIconButton = iconButtonClickTime > 0;
+ if (triggeredByIconButton) {
+ // TODO: Adjust `nativeGlobalPos` to (0, realTitleBarHeight)
+ // hint: use m_delgegate->mapGeometryToScene
+ }
+ bool res = showSystemMenu_sys(hWnd, nativeGlobalPos, broughtByKeyboard,
+ m_delegate->isHostSizeFixed(m_host));
+
+ // Emulate the Windows SYSMENU button's behavior
+ static uint32_t doubleClickTime = ::GetDoubleClickTime();
+ if (triggeredByIconButton && !res &&
+ ::GetTickCount64() - iconButtonClickTime <= doubleClickTime) {
+ POINT nativeGlobalPos;
+ ::GetCursorPos(&nativeGlobalPos);
+ POINT nativeLocalPos = nativeGlobalPos;
+ ::ScreenToClient(hWnd, &nativeLocalPos);
+ QPoint qtScenePos =
+ QHighDpi::fromNativeLocalPosition(point2qpoint(nativeLocalPos), m_windowHandle);
+ WindowAgentBase::SystemButton sysButtonType = WindowAgentBase::Unknown;
+ if (isInSystemButtons(qtScenePos, &sysButtonType) &&
+ sysButtonType == WindowAgentBase::WindowIcon) {
+ ::PostMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
+ }
+ }
+
// 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
@@ -2080,15 +2159,6 @@
return true;
}
return false;
- }
-
- bool Win32WindowContext::needBorderPainter() const {
- Q_UNUSED(this)
- return isSystemBorderEnabled() && !isWin11OrGreater();
- }
-
- int Win32WindowContext::borderThickness() const {
- return int(getWindowFrameBorderThickness(reinterpret_cast<HWND>(windowId)));
}
}
--
Gitblit v1.9.1