From 4fc35bd506d1fb9d41324d7dd33047c491f2979f Mon Sep 17 00:00:00 2001
From: Sine Striker <trueful@163.com>
Date: 周三, 08 5月 2024 11:00:38 +0800
Subject: [PATCH] Add mouse hook when exec menu
---
src/core/contexts/win32windowcontext.cpp | 1087 ++++++++++++++++++++++++++++++++++++++++++---------------
1 files changed, 800 insertions(+), 287 deletions(-)
diff --git a/src/core/contexts/win32windowcontext.cpp b/src/core/contexts/win32windowcontext.cpp
index 27450d9..9ad30da 100644
--- a/src/core/contexts/win32windowcontext.cpp
+++ b/src/core/contexts/win32windowcontext.cpp
@@ -1,14 +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 <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,9 +33,303 @@
#include "qwkglobal_p.h"
#include "qwkwindowsextra_p.h"
-#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-Q_DECLARE_METATYPE(QMargins)
-#endif
+static QHash<int, const wchar_t *> xmsgHash = //
+ {
+ //
+ {0, L"WM_NULL" },
+ {1, L"WM_CREATE" },
+ {2, L"WM_DESTROY" },
+ {3, L"WM_MOVE" },
+ {5, L"WM_SIZE" },
+ {6, L"WM_ACTIVATE" },
+ {7, L"WM_SETFOCUS" },
+ {8, L"WM_KILLFOCUS" },
+ {10, L"WM_ENABLE" },
+ {11, L"WM_SETREDRAW" },
+ {12, L"WM_SETTEXT" },
+ {13, L"WM_GETTEXT" },
+ {14, L"WM_GETTEXTLENGTH" },
+ {15, L"WM_PAINT" },
+ {16, L"WM_CLOSE" },
+ {17, L"WM_QUERYENDSESSION" },
+ {18, L"WM_QUIT" },
+ {19, L"WM_QUERYOPEN" },
+ {20, L"WM_ERASEBKGND" },
+ {21, L"WM_SYSCOLORCHANGE" },
+ {22, L"WM_ENDSESSION" },
+ {24, L"WM_SHOWWINDOW" },
+ {25, L"WM_CTLCOLOR" },
+ {26, L"WM_WININICHANGE" },
+ {27, L"WM_DEVMODECHANGE" },
+ {28, L"WM_ACTIVATEAPP" },
+ {29, L"WM_FONTCHANGE" },
+ {30, L"WM_TIMECHANGE" },
+ {31, L"WM_CANCELMODE" },
+ {32, L"WM_SETCURSOR" },
+ {33, L"WM_MOUSEACTIVATE" },
+ {34, L"WM_CHILDACTIVATE" },
+ {35, L"WM_QUEUESYNC" },
+ {36, L"WM_GETMINMAXINFO" },
+ {38, L"WM_PAINTICON" },
+ {39, L"WM_ICONERASEBKGND" },
+ {40, L"WM_NEXTDLGCTL" },
+ {42, L"WM_SPOOLERSTATUS" },
+ {43, L"WM_DRAWITEM" },
+ {44, L"WM_MEASUREITEM" },
+ {45, L"WM_DELETEITEM" },
+ {46, L"WM_VKEYTOITEM" },
+ {47, L"WM_CHARTOITEM" },
+ {48, L"WM_SETFONT" },
+ {49, L"WM_GETFONT" },
+ {50, L"WM_SETHOTKEY" },
+ {51, L"WM_GETHOTKEY" },
+ {55, L"WM_QUERYDRAGICON" },
+ {57, L"WM_COMPAREITEM" },
+ {61, L"WM_GETOBJECT" },
+ {65, L"WM_COMPACTING" },
+ {68, L"WM_COMMNOTIFY" },
+ {70, L"WM_WINDOWPOSCHANGING" },
+ {71, L"WM_WINDOWPOSCHANGED" },
+ {72, L"WM_POWER" },
+ {73, L"WM_COPYGLOBALDATA" },
+ {74, L"WM_COPYDATA" },
+ {75, L"WM_CANCELJOURNAL" },
+ {78, L"WM_NOTIFY" },
+ {80, L"WM_INPUTLANGCHANGEREQUEST"},
+ {81, L"WM_INPUTLANGCHANGE" },
+ {82, L"WM_TCARD" },
+ {83, L"WM_HELP" },
+ {84, L"WM_USERCHANGED" },
+ {85, L"WM_NOTIFYFORMAT" },
+ {123, L"WM_CONTEXTMENU" },
+ {124, L"WM_STYLECHANGING" },
+ {125, L"WM_STYLECHANGED" },
+ {126, L"WM_DISPLAYCHANGE" },
+ {127, L"WM_GETICON" },
+ {128, L"WM_SETICON" },
+ {129, L"WM_NCCREATE" },
+ {130, L"WM_NCDESTROY" },
+ {131, L"WM_NCCALCSIZE" },
+ {132, L"WM_NCHITTEST" },
+ {133, L"WM_NCPAINT" },
+ {134, L"WM_NCACTIVATE" },
+ {135, L"WM_GETDLGCODE" },
+ {136, L"WM_SYNCPAINT" },
+ {160, L"WM_NCMOUSEMOVE" },
+ {161, L"WM_NCLBUTTONDOWN" },
+ {162, L"WM_NCLBUTTONUP" },
+ {163, L"WM_NCLBUTTONDBLCLK" },
+ {164, L"WM_NCRBUTTONDOWN" },
+ {165, L"WM_NCRBUTTONUP" },
+ {166, L"WM_NCRBUTTONDBLCLK" },
+ {167, L"WM_NCMBUTTONDOWN" },
+ {168, L"WM_NCMBUTTONUP" },
+ {169, L"WM_NCMBUTTONDBLCLK" },
+ {171, L"WM_NCXBUTTONDOWN" },
+ {172, L"WM_NCXBUTTONUP" },
+ {173, L"WM_NCXBUTTONDBLCLK" },
+ {176, L"EM_GETSEL" },
+ {177, L"EM_SETSEL" },
+ {178, L"EM_GETRECT" },
+ {179, L"EM_SETRECT" },
+ {180, L"EM_SETRECTNP" },
+ {181, L"EM_SCROLL" },
+ {182, L"EM_LINESCROLL" },
+ {183, L"EM_SCROLLCARET" },
+ {185, L"EM_GETMODIFY" },
+ {187, L"EM_SETMODIFY" },
+ {188, L"EM_GETLINECOUNT" },
+ {189, L"EM_LINEINDEX" },
+ {190, L"EM_SETHANDLE" },
+ {191, L"EM_GETHANDLE" },
+ {192, L"EM_GETTHUMB" },
+ {193, L"EM_LINELENGTH" },
+ {194, L"EM_REPLACESEL" },
+ {195, L"EM_SETFONT" },
+ {196, L"EM_GETLINE" },
+ {197, L"EM_LIMITTEXT" },
+ {197, L"EM_SETLIMITTEXT" },
+ {198, L"EM_CANUNDO" },
+ {199, L"EM_UNDO" },
+ {200, L"EM_FMTLINES" },
+ {201, L"EM_LINEFROMCHAR" },
+ {202, L"EM_SETWORDBREAK" },
+ {203, L"EM_SETTABSTOPS" },
+ {204, L"EM_SETPASSWORDCHAR" },
+ {205, L"EM_EMPTYUNDOBUFFER" },
+ {206, L"EM_GETFIRSTVISIBLELINE" },
+ {207, L"EM_SETREADONLY" },
+ {209, L"EM_SETWORDBREAKPROC" },
+ {209, L"EM_GETWORDBREAKPROC" },
+ {210, L"EM_GETPASSWORDCHAR" },
+ {211, L"EM_SETMARGINS" },
+ {212, L"EM_GETMARGINS" },
+ {213, L"EM_GETLIMITTEXT" },
+ {214, L"EM_POSFROMCHAR" },
+ {215, L"EM_CHARFROMPOS" },
+ {216, L"EM_SETIMESTATUS" },
+ {217, L"EM_GETIMESTATUS" },
+ {224, L"SBM_SETPOS" },
+ {225, L"SBM_GETPOS" },
+ {226, L"SBM_SETRANGE" },
+ {227, L"SBM_GETRANGE" },
+ {228, L"SBM_ENABLE_ARROWS" },
+ {230, L"SBM_SETRANGEREDRAW" },
+ {233, L"SBM_SETSCROLLINFO" },
+ {234, L"SBM_GETSCROLLINFO" },
+ {235, L"SBM_GETSCROLLBARINFO" },
+ {240, L"BM_GETCHECK" },
+ {241, L"BM_SETCHECK" },
+ {242, L"BM_GETSTATE" },
+ {243, L"BM_SETSTATE" },
+ {244, L"BM_SETSTYLE" },
+ {245, L"BM_CLICK" },
+ {246, L"BM_GETIMAGE" },
+ {247, L"BM_SETIMAGE" },
+ {248, L"BM_SETDONTCLICK" },
+ {255, L"WM_INPUT" },
+ {256, L"WM_KEYDOWN" },
+ {256, L"WM_KEYFIRST" },
+ {257, L"WM_KEYUP" },
+ {258, L"WM_CHAR" },
+ {259, L"WM_DEADCHAR" },
+ {260, L"WM_SYSKEYDOWN" },
+ {261, L"WM_SYSKEYUP" },
+ {262, L"WM_SYSCHAR" },
+ {263, L"WM_SYSDEADCHAR" },
+ {264, L"WM_KEYLAST" },
+ {265, L"WM_UNICHAR" },
+ {265, L"WM_WNT_CONVERTREQUESTEX" },
+ {266, L"WM_CONVERTREQUEST" },
+ {267, L"WM_CONVERTRESULT" },
+ {268, L"WM_INTERIM" },
+ {269, L"WM_IME_STARTCOMPOSITION" },
+ {270, L"WM_IME_ENDCOMPOSITION" },
+ {271, L"WM_IME_COMPOSITION" },
+ {271, L"WM_IME_KEYLAST" },
+ {272, L"WM_INITDIALOG" },
+ {273, L"WM_COMMAND" },
+ {274, L"WM_SYSCOMMAND" },
+ {275, L"WM_TIMER" },
+ {276, L"WM_HSCROLL" },
+ {277, L"WM_VSCROLL" },
+ {278, L"WM_INITMENU" },
+ {279, L"WM_INITMENUPOPUP" },
+ {280, L"WM_SYSTIMER" },
+ {287, L"WM_MENUSELECT" },
+ {288, L"WM_MENUCHAR" },
+ {289, L"WM_ENTERIDLE" },
+ {290, L"WM_MENURBUTTONUP" },
+ {291, L"WM_MENUDRAG" },
+ {292, L"WM_MENUGETOBJECT" },
+ {293, L"WM_UNINITMENUPOPUP" },
+ {294, L"WM_MENUCOMMAND" },
+ {295, L"WM_CHANGEUISTATE" },
+ {296, L"WM_UPDATEUISTATE" },
+ {297, L"WM_QUERYUISTATE" },
+ {306, L"WM_CTLCOLORMSGBOX" },
+ {307, L"WM_CTLCOLOREDIT" },
+ {308, L"WM_CTLCOLORLISTBOX" },
+ {309, L"WM_CTLCOLORBTN" },
+ {310, L"WM_CTLCOLORDLG" },
+ {311, L"WM_CTLCOLORSCROLLBAR" },
+ {312, L"WM_CTLCOLORSTATIC" },
+ {512, L"WM_MOUSEFIRST" },
+ {512, L"WM_MOUSEMOVE" },
+ {513, L"WM_LBUTTONDOWN" },
+ {514, L"WM_LBUTTONUP" },
+ {515, L"WM_LBUTTONDBLCLK" },
+ {516, L"WM_RBUTTONDOWN" },
+ {517, L"WM_RBUTTONUP" },
+ {518, L"WM_RBUTTONDBLCLK" },
+ {519, L"WM_MBUTTONDOWN" },
+ {520, L"WM_MBUTTONUP" },
+ {521, L"WM_MBUTTONDBLCLK" },
+ {521, L"WM_MOUSELAST" },
+ {522, L"WM_MOUSEWHEEL" },
+ {523, L"WM_XBUTTONDOWN" },
+ {524, L"WM_XBUTTONUP" },
+ {525, L"WM_XBUTTONDBLCLK" },
+ {528, L"WM_PARENTNOTIFY" },
+ {529, L"WM_ENTERMENULOOP" },
+ {530, L"WM_EXITMENULOOP" },
+ {531, L"WM_NEXTMENU" },
+ {532, L"WM_SIZING" },
+ {533, L"WM_CAPTURECHANGED" },
+ {534, L"WM_MOVING" },
+ {536, L"WM_POWERBROADCAST" },
+ {537, L"WM_DEVICECHANGE" },
+ {544, L"WM_MDICREATE" },
+ {545, L"WM_MDIDESTROY" },
+ {546, L"WM_MDIACTIVATE" },
+ {547, L"WM_MDIRESTORE" },
+ {548, L"WM_MDINEXT" },
+ {549, L"WM_MDIMAXIMIZE" },
+ {550, L"WM_MDITILE" },
+ {551, L"WM_MDICASCADE" },
+ {552, L"WM_MDIICONARRANGE" },
+ {553, L"WM_MDIGETACTIVE" },
+ {560, L"WM_MDISETMENU" },
+ {561, L"WM_ENTERSIZEMOVE" },
+ {562, L"WM_EXITSIZEMOVE" },
+ {563, L"WM_DROPFILES" },
+ {564, L"WM_MDIREFRESHMENU" },
+ {640, L"WM_IME_REPORT" },
+ {641, L"WM_IME_SETCONTEXT" },
+ {642, L"WM_IME_NOTIFY" },
+ {643, L"WM_IME_CONTROL" },
+ {644, L"WM_IME_COMPOSITIONFULL" },
+ {645, L"WM_IME_SELECT" },
+ {646, L"WM_IME_CHAR" },
+ {648, L"WM_IME_REQUEST" },
+ {656, L"WM_IMEKEYDOWN" },
+ {656, L"WM_IME_KEYDOWN" },
+ {657, L"WM_IMEKEYUP" },
+ {657, L"WM_IME_KEYUP" },
+ {672, L"WM_NCMOUSEHOVER" },
+ {673, L"WM_MOUSEHOVER" },
+ {674, L"WM_NCMOUSELEAVE" },
+ {675, L"WM_MOUSELEAVE" },
+ {768, L"WM_CUT" },
+ {769, L"WM_COPY" },
+ {770, L"WM_PASTE" },
+ {771, L"WM_CLEAR" },
+ {772, L"WM_UNDO" },
+ {773, L"WM_RENDERFORMAT" },
+ {774, L"WM_RENDERALLFORMATS" },
+ {775, L"WM_DESTROYCLIPBOARD" },
+ {776, L"WM_DRAWCLIPBOARD" },
+ {777, L"WM_PAINTCLIPBOARD" },
+ {778, L"WM_VSCROLLCLIPBOARD" },
+ {779, L"WM_SIZECLIPBOARD" },
+ {780, L"WM_ASKCBFORMATNAME" },
+ {781, L"WM_CHANGECBCHAIN" },
+ {782, L"WM_HSCROLLCLIPBOARD" },
+ {783, L"WM_QUERYNEWPALETTE" },
+ {784, L"WM_PALETTEISCHANGING" },
+ {785, L"WM_PALETTECHANGED" },
+ {786, L"WM_HOTKEY" },
+ {791, L"WM_PRINT" },
+ {792, L"WM_PRINTCLIENT" },
+ {793, L"WM_APPCOMMAND" },
+ {856, L"WM_HANDHELDFIRST" },
+ {863, L"WM_HANDHELDLAST" },
+ {864, L"WM_AFXFIRST" },
+ {895, L"WM_AFXLAST" },
+ {896, L"WM_PENWINFIRST" },
+ {897, L"WM_RCRESULT" },
+ {898, L"WM_HOOKRCRESULT" },
+ {899, L"WM_GLOBALRCCHANGE" },
+ {899, L"WM_PENMISCINFO" },
+ {900, L"WM_SKB" },
+ {901, L"WM_HEDITCTL" },
+ {901, L"WM_PENCTL" },
+ {902, L"WM_PENMISC" },
+ {903, L"WM_CTLINIT" },
+ {904, L"WM_PENEVENT" },
+ {911, L"WM_PENWINLAST" },
+ {1024, L"WM_USER" },
+};
namespace QWK {
@@ -49,59 +350,25 @@
// Original Qt window proc function
static WNDPROC g_qtWindowProc = nullptr;
+ static inline bool
+#if !QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
+ constexpr
+#endif
+
+ isSystemBorderEnabled() {
+ return
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
+ isWin10OrGreater()
+#else
+ false
+#endif
+ ;
+ }
+
static inline void triggerFrameChange(HWND hwnd) {
::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) {
@@ -130,18 +397,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) {
@@ -199,7 +454,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
@@ -276,14 +531,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);
@@ -327,7 +583,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
@@ -336,11 +593,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) {
@@ -367,7 +625,7 @@
case HTBORDER:
return Win32WindowContext::FixedBorder;
default:
- // unreachable
+ Q_UNREACHABLE();
break;
}
return Win32WindowContext::Outside;
@@ -405,6 +663,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
@@ -424,23 +783,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) {
@@ -457,9 +837,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
@@ -526,18 +903,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;
}
@@ -546,18 +929,10 @@
}
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);
+ 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) {
@@ -589,8 +964,8 @@
}
Win32WindowContext::~Win32WindowContext() {
- if (windowId) {
- removeManagedWindow(reinterpret_cast<HWND>(windowId));
+ if (m_windowId) {
+ removeManagedWindow(reinterpret_cast<HWND>(m_windowId));
}
}
@@ -600,35 +975,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;
}
@@ -642,18 +1010,19 @@
return;
}
+#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDERS)
case DrawWindows10BorderHook: {
- 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(getWindowFrameBorderThickness(hwnd) * 2);
+ pen.setWidth(int(getWindowFrameBorderThickness(hwnd)) * 2);
const bool dark = isDarkThemeActive() && isDarkWindowFrameEnabled(hwnd);
if (m_delegate->isWindowActive(m_host)) {
@@ -673,7 +1042,7 @@
}
painter.save();
- // We needs anti-aliasing to give us better result.
+ // We need antialiasing to give us better result.
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
@@ -685,58 +1054,114 @@
return;
}
+ case DrawWindows10BorderHook2: {
+ 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>(m_windowId);
+ HDC hdc = ::GetDC(hWnd);
+ RECT windowRect{};
+ ::GetClientRect(hWnd, &windowRect);
+ RECT rcTopBorder = {
+ 0,
+ 0,
+ RECT_WIDTH(windowRect),
+ int(getWindowFrameBorderThickness(hWnd)),
+ };
+ ::FillRect(hdc, &rcTopBorder,
+ reinterpret_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH)));
+ ::ReleaseDC(hWnd, hdc);
+ return;
+ }
+#endif
+
default:
break;
}
AbstractWindowContext::virtual_hook(id, data);
}
- bool Win32WindowContext::needBorderPainter() const {
- return isWin10OrGreater() && !isWin11OrGreater();
- }
+ QVariant Win32WindowContext::windowAttribute(const QString &key) const {
+ if (key == QStringLiteral("window-rect")) {
+ if (!m_windowId)
+ return {};
- 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;
+ 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()) {
+ static auto margins = QVariant::fromValue(QMargins(1, 1, 1, 1));
-#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
- if (!isWin10OrGreater())
-#endif
- {
- static constexpr const MARGINS margins = {1, 1, 1, 1};
- DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins);
+ // 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,
@@ -746,8 +1171,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:
@@ -760,6 +1185,10 @@
if (!isValidWindow(hWnd, false, true)) {
return false;
}
+
+ // qDebug().noquote() << QDateTime::currentDateTime()
+ // << QString::fromStdWString(xmsgHash.value(message, L"")) << Qt::hex
+ // << message;
// Test snap layout
if (snapLayoutHandler(hWnd, message, wParam, lParam, result)) {
@@ -778,13 +1207,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 (dispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
+ if (nativeDispatch(nativeEventType(), &msg, &res)) {
*result = LRESULT(res);
return true;
}
@@ -794,11 +1219,45 @@
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 extendMargins = {-1, -1, -1, -1};
- static const auto defaultMargins =
- isWin10OrGreater() ? MARGINS{0, 0, 0, 0} : MARGINS{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")) {
+ auto margins = qmargins2margins(attribute.value<QMargins>());
+ return apis.pDwmExtendFrameIntoClientArea(hwnd, &margins) == S_OK;
+ }
+
+ 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;
+ }
+
+ // For Win11 or later
if (key == QStringLiteral("mica")) {
if (!isWin11OrGreater()) {
return false;
@@ -806,7 +1265,7 @@
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);
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);
if (isWin1122H2OrGreater()) {
// Use official DWM API to enable Mica, available since Windows 11 22H2
// (10.0.22621).
@@ -828,17 +1287,19 @@
const BOOL enable = FALSE;
apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable));
}
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ restoreMargins();
}
return true;
- } else if (key == QStringLiteral("mica-alt")) {
+ }
+
+ 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);
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);
// Use official DWM API to enable Mica Alt, available since Windows 11 22H2
// (10.0.22621).
const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TABBEDWINDOW;
@@ -848,60 +1309,62 @@
const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO;
apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType,
sizeof(backdropType));
- apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins);
+ restoreMargins();
}
return true;
- } else if (key == QStringLiteral("acrylic-material")) {
- if (!isWin10OrGreater()) {
+ }
+
+ if (key == QStringLiteral("acrylic-material")) {
+ if (!isWin11OrGreater()) {
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>();
-
- 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);
+ apis.pDwmExtendFrameIntoClientArea(hwnd, &extendedMargins);
+
+ 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);
+
+ restoreMargins();
+ }
+ return true;
+ }
+
+ if (key == QStringLiteral("dwm-blur")) {
+ if (attribute.toBool()) {
+ // We can't extend the window frame for this effect.
+ restoreMargins();
if (isWin8OrGreater()) {
ACCENT_POLICY policy{};
policy.dwAccentState = ACCENT_ENABLE_BLURBEHIND;
@@ -933,31 +1396,7 @@
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;
@@ -1165,9 +1604,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
@@ -1216,29 +1654,53 @@
// 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);
+ emulateClientAreaMessage(hWnd, message, wParam, lParam);
+ return true;
+ }
+
+ if (lastHitTestResultRaw == HTSYSMENU) {
+ switch (message) {
+ case WM_NCLBUTTONDOWN:
+ if (iconButtonClickTime == 0) {
+ // 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, WM_NCLBUTTONDOWN, wParam, lParam);
+ iconButtonClickTime = 0;
+ } else {
+ *result = FALSE;
+ emulateClientAreaMessage(hWnd, message, wParam, lParam);
+ }
+ break;
+ case WM_NCLBUTTONDBLCLK:
+ // A message of WM_SYSCOMMAND with SC_CLOSE will be sent by Windows
+ *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
+ break;
+ default:
+ *result = FALSE;
+ emulateClientAreaMessage(hWnd, message, wParam, lParam);
+ break;
+ }
} 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
@@ -1247,6 +1709,7 @@
(((message >= WM_NCXBUTTONDOWN) && (message <= WM_NCXBUTTONDBLCLK))
? TRUE
: FALSE);
+ emulateClientAreaMessage(hWnd, message, wParam, lParam);
}
return true;
}
@@ -1260,7 +1723,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);
@@ -1294,19 +1757,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杩欎釜绐楀彛鏍峰紡浼氬湪绐�
@@ -1389,7 +1839,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)};
@@ -1488,8 +1939,7 @@
int frameSize = getResizeBorderThickness(hWnd);
bool isTop = (nativeLocalPos.y < frameSize);
-#if QWINDOWKIT_CONFIG(ENABLE_WINDOWS_SYSTEM_BORDER)
- if (isWin10OrGreater()) {
+ if (isSystemBorderEnabled()) {
// This will handle the left, right and bottom parts of the frame
// because we didn't change them.
LRESULT originalHitTestResult = ::DefWindowProcW(hWnd, WM_NCHITTEST, 0, lParam);
@@ -1531,9 +1981,7 @@
}
*result = HTCLIENT;
return true;
- } else
-#endif
- {
+ } else {
if (full) {
*result = HTCLIENT;
return true;
@@ -1619,7 +2067,7 @@
break;
}
- if (!isWin10OrGreater()) {
+ if (!isSystemBorderEnabled()) {
switch (message) {
case WM_NCUAHDRAWCAPTION:
case WM_NCUAHDRAWFRAME: {
@@ -1770,8 +2218,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()) {
+ if (isSystemBorderEnabled()) {
// Store the original top margin before the default window procedure applies the
// default frame.
const LONG originalTop = clientRect->top;
@@ -1798,7 +2245,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
@@ -1813,16 +2260,11 @@
// 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
+ if (!isSystemBorderEnabled()) {
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,
@@ -1921,10 +2363,11 @@
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 quint32 horizontalOffset =
+ ((maxOrFull || !isSystemBorderEnabled()) ? 0 : frameSize);
const auto verticalOffset = [hWnd, maxOrFull, frameSize]() -> quint32 {
const quint32 titleBarHeight = getTitleBarHeight(hWnd);
- if (!isWin10OrGreater()) {
+ if (!isSystemBorderEnabled()) {
return titleBarHeight;
}
if (isWin11OrGreater()) {
@@ -1946,6 +2389,7 @@
bool shouldShowSystemMenu = false;
bool broughtByKeyboard = false;
POINT nativeGlobalPos{};
+
switch (message) {
case WM_RBUTTONUP: {
const POINT nativeLocalPos = getNativePosFromMouse();
@@ -1967,10 +2411,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;
}
@@ -1989,8 +2443,67 @@
break;
}
if (shouldShowSystemMenu) {
- showSystemMenu2(hWnd, nativeGlobalPos, broughtByKeyboard,
- m_delegate->isHostSizeFixed(m_host));
+ static HHOOK mouseHook = nullptr;
+ static std::optional<POINT> mouseClickPos;
+ bool mouseHookedLocal = false;
+ if (iconButtonClickTime > 0) {
+ POINT menuPos{0, static_cast<LONG>(getTitleBarHeight(hWnd))};
+ if (const auto tb = titleBar()) {
+ auto titleBarHeight = qreal(m_delegate->mapGeometryToScene(tb).height());
+ titleBarHeight *= m_windowHandle->devicePixelRatio();
+ menuPos.y = qRound(titleBarHeight);
+ }
+ ::ClientToScreen(hWnd, &menuPos);
+ nativeGlobalPos = menuPos;
+
+ // Install mouse hook
+ if (!mouseHook) {
+ mouseHook = ::SetWindowsHookExW(
+ WH_MOUSE,
+ [](int nCode, WPARAM wParam, LPARAM lParam) {
+ if (nCode >= 0) {
+ if (wParam == WM_LBUTTONDOWN || wParam == WM_LBUTTONDBLCLK) {
+ auto pMouseStruct = reinterpret_cast<MOUSEHOOKSTRUCT *>(lParam);
+ if (pMouseStruct) {
+ mouseClickPos = pMouseStruct->pt;
+ }
+ }
+ }
+ return ::CallNextHookEx(nullptr, nCode, wParam, lParam);
+ },
+ nullptr, ::GetCurrentThreadId());
+ mouseHookedLocal = true;
+ }
+ }
+ bool res = showSystemMenu_sys(hWnd, nativeGlobalPos, broughtByKeyboard,
+ m_delegate->isHostSizeFixed(m_host));
+
+ // Uninstall mouse hook and check if it's a double-click
+ if (mouseHookedLocal) {
+ ::UnhookWindowsHookEx(mouseHook);
+
+ // Emulate the Windows icon button's behavior
+ static uint32_t doubleClickTime = ::GetDoubleClickTime();
+ if (!res && mouseClickPos.has_value() &&
+ ::GetTickCount64() - iconButtonClickTime <= doubleClickTime) {
+ POINT nativeGlobalPos;
+ ::GetCursorPos(&nativeGlobalPos);
+ POINT nativeLocalPos = mouseClickPos.value();
+ // qDebug() << point2qpoint(nativeLocalPos) << point2qpoint(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);
+ }
+ }
+
+ mouseHook = nullptr;
+ mouseClickPos.reset();
+ }
+
// 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
--
Gitblit v1.9.1