| | |
|---|
| | | #include <QtGui/QPalette> |
|---|
| | | #include <QtGui/QStyleHints> |
|---|
| | | |
|---|
| | | #include <QtCore/private/qwinregistry_p.h> |
|---|
| | | #include <QtCore/private/qsystemlibrary_p.h> |
|---|
| | | #include <QtGui/private/qhighdpiscaling_p.h> |
|---|
| | | #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) |
|---|
| | | # include <QtGui/private/qguiapplication_p.h> |
|---|
| | |
|---|
| | | # include <QtGui/qpa/qplatformwindow_p.h> |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #include <shellscalingapi.h> |
|---|
| | | #include <dwmapi.h> |
|---|
| | | #include <timeapi.h> |
|---|
| | | |
|---|
| | | #include "qwkglobal_p.h" |
|---|
| | | #include "qwkwindowsextra_p.h" |
|---|
| | | |
|---|
| | | #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) |
|---|
| | | Q_DECLARE_METATYPE(QMargins) |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | namespace QWK { |
|---|
| | | |
|---|
| | | enum _DWMWINDOWATTRIBUTE { |
|---|
| | | // [set] BOOL, Allows the use of host backdrop brushes for the window. |
|---|
| | | _DWMWA_USE_HOSTBACKDROPBRUSH = 17, |
|---|
| | | |
|---|
| | | // Undocumented, the same with DWMWA_USE_IMMERSIVE_DARK_MODE, but available on systems |
|---|
| | | // before Win10 20H1. |
|---|
| | | _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 = 19, |
|---|
| | | |
|---|
| | | // [set] BOOL, Allows a window to either use the accent color, or dark, according to the |
|---|
| | | // user Color Mode preferences. |
|---|
| | | _DWMWA_USE_IMMERSIVE_DARK_MODE = 20, |
|---|
| | | |
|---|
| | | // [set] WINDOW_CORNER_PREFERENCE, Controls the policy that rounds top-level window corners |
|---|
| | | _DWMWA_WINDOW_CORNER_PREFERENCE = 33, |
|---|
| | | |
|---|
| | | // [get] UINT, width of the visible border around a thick frame window |
|---|
| | | _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS = 37, |
|---|
| | | |
|---|
| | | // [get, set] SYSTEMBACKDROP_TYPE, Controls the system-drawn backdrop material of a window, |
|---|
| | | // including behind the non-client area. |
|---|
| | | _DWMWA_SYSTEMBACKDROP_TYPE = 38, |
|---|
| | | |
|---|
| | | // Undocumented, use this value to enable Mica material on Win11 21H2. You should use |
|---|
| | | // DWMWA_SYSTEMBACKDROP_TYPE instead on Win11 22H2 and newer. |
|---|
| | | _DWMWA_MICA_EFFECT = 1029 |
|---|
| | | }; |
|---|
| | | |
|---|
| | | // The thickness of an auto-hide taskbar in pixels. |
|---|
| | | static constexpr const quint8 kAutoHideTaskBarThickness = 2; |
|---|
| | |
|---|
| | | // Original Qt window proc function |
|---|
| | | static WNDPROC g_qtWindowProc = nullptr; |
|---|
| | | |
|---|
| | | struct DynamicApis { |
|---|
| | | static const DynamicApis &instance() { |
|---|
| | | static const DynamicApis inst{}; |
|---|
| | | return inst; |
|---|
| | | } |
|---|
| | | |
|---|
| | | // template <typename T> |
|---|
| | | // struct DefaultFunc; |
|---|
| | | // |
|---|
| | | // template <typename Return, typename... Args> |
|---|
| | | // struct DefaultFunc<Return(QT_WIN_CALLBACK *)(Args...)> { |
|---|
| | | // static Return STDAPICALLTYPE func(Args...) { |
|---|
| | | // return Return{}; |
|---|
| | | // } |
|---|
| | | // }; |
|---|
| | | // |
|---|
| | | // #define DYNAMIC_API_DECLARE(NAME) decltype(&::NAME) p##NAME = |
|---|
| | | // DefaultFunc<decltype(&::NAME)>::func |
|---|
| | | |
|---|
| | | #define DYNAMIC_API_DECLARE(NAME) decltype(&::NAME) p##NAME = nullptr |
|---|
| | | |
|---|
| | | DYNAMIC_API_DECLARE(DwmFlush); |
|---|
| | | DYNAMIC_API_DECLARE(DwmIsCompositionEnabled); |
|---|
| | | DYNAMIC_API_DECLARE(DwmGetCompositionTimingInfo); |
|---|
| | | DYNAMIC_API_DECLARE(DwmGetWindowAttribute); |
|---|
| | | DYNAMIC_API_DECLARE(DwmSetWindowAttribute); |
|---|
| | | DYNAMIC_API_DECLARE(GetDpiForWindow); |
|---|
| | | DYNAMIC_API_DECLARE(GetSystemMetricsForDpi); |
|---|
| | | DYNAMIC_API_DECLARE(GetDpiForMonitor); |
|---|
| | | DYNAMIC_API_DECLARE(timeGetDevCaps); |
|---|
| | | DYNAMIC_API_DECLARE(timeBeginPeriod); |
|---|
| | | DYNAMIC_API_DECLARE(timeEndPeriod); |
|---|
| | | |
|---|
| | | #undef DYNAMIC_API_DECLARE |
|---|
| | | |
|---|
| | | private: |
|---|
| | | DynamicApis() { |
|---|
| | | #define DYNAMIC_API_RESOLVE(DLL, NAME) \ |
|---|
| | | p##NAME = reinterpret_cast<decltype(p##NAME)>(DLL.resolve(#NAME)) |
|---|
| | | |
|---|
| | | QSystemLibrary user32(QStringLiteral("user32")); |
|---|
| | | DYNAMIC_API_RESOLVE(user32, GetDpiForWindow); |
|---|
| | | DYNAMIC_API_RESOLVE(user32, GetSystemMetricsForDpi); |
|---|
| | | |
|---|
| | | QSystemLibrary shcore(QStringLiteral("shcore")); |
|---|
| | | DYNAMIC_API_RESOLVE(shcore, GetDpiForMonitor); |
|---|
| | | |
|---|
| | | QSystemLibrary dwmapi(QStringLiteral("dwmapi")); |
|---|
| | | DYNAMIC_API_RESOLVE(dwmapi, DwmFlush); |
|---|
| | | DYNAMIC_API_RESOLVE(dwmapi, DwmIsCompositionEnabled); |
|---|
| | | DYNAMIC_API_RESOLVE(dwmapi, DwmGetCompositionTimingInfo); |
|---|
| | | DYNAMIC_API_RESOLVE(dwmapi, DwmGetWindowAttribute); |
|---|
| | | DYNAMIC_API_RESOLVE(dwmapi, DwmSetWindowAttribute); |
|---|
| | | |
|---|
| | | QSystemLibrary winmm(QStringLiteral("winmm")); |
|---|
| | | DYNAMIC_API_RESOLVE(winmm, timeGetDevCaps); |
|---|
| | | DYNAMIC_API_RESOLVE(winmm, timeBeginPeriod); |
|---|
| | | DYNAMIC_API_RESOLVE(winmm, timeEndPeriod); |
|---|
| | | |
|---|
| | | #undef DYNAMIC_API_RESOLVE |
|---|
| | | } |
|---|
| | | |
|---|
| | | ~DynamicApis() = default; |
|---|
| | | |
|---|
| | | Q_DISABLE_COPY_MOVE(DynamicApis) |
|---|
| | | }; |
|---|
| | | |
|---|
| | | static inline constexpr bool operator==(const POINT &lhs, const POINT &rhs) noexcept { |
|---|
| | | return ((lhs.x == rhs.x) && (lhs.y == rhs.y)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator!=(const POINT &lhs, const POINT &rhs) noexcept { |
|---|
| | | return !operator==(lhs, rhs); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator==(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return ((lhs.cx == rhs.cx) && (lhs.cy == rhs.cy)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator!=(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return !operator==(lhs, rhs); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator>(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return ((lhs.cx * lhs.cy) > (rhs.cx * rhs.cy)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator>=(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return (operator>(lhs, rhs) || operator==(lhs, rhs)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator<(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return (operator!=(lhs, rhs) && !operator>(lhs, rhs)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator<=(const SIZE &lhs, const SIZE &rhs) noexcept { |
|---|
| | | return (operator<(lhs, rhs) || operator==(lhs, rhs)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator==(const RECT &lhs, const RECT &rhs) noexcept { |
|---|
| | | return ((lhs.left == rhs.left) && (lhs.top == rhs.top) && (lhs.right == rhs.right) && |
|---|
| | | (lhs.bottom == rhs.bottom)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr bool operator!=(const RECT &lhs, const RECT &rhs) noexcept { |
|---|
| | | return !operator==(lhs, rhs); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr QPoint point2qpoint(const POINT &point) { |
|---|
| | | return QPoint{int(point.x), int(point.y)}; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr POINT qpoint2point(const QPoint &point) { |
|---|
| | | return POINT{LONG(point.x()), LONG(point.y())}; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr QSize size2qsize(const SIZE &size) { |
|---|
| | | return QSize{int(size.cx), int(size.cy)}; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr SIZE qsize2size(const QSize &size) { |
|---|
| | | return SIZE{LONG(size.width()), LONG(size.height())}; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr QRect rect2qrect(const RECT &rect) { |
|---|
| | | return QRect{ |
|---|
| | | QPoint{int(rect.left), int(rect.top) }, |
|---|
| | | QSize{int(RECT_WIDTH(rect)), int(RECT_HEIGHT(rect))} |
|---|
| | | }; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline constexpr RECT qrect2rect(const QRect &qrect) { |
|---|
| | | return RECT{LONG(qrect.left()), LONG(qrect.top()), LONG(qrect.right()), |
|---|
| | | LONG(qrect.bottom())}; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline /*constexpr*/ QString hwnd2str(const WId windowId) { |
|---|
| | | // NULL handle is allowed here. |
|---|
| | | return QLatin1String("0x") + |
|---|
| | | QString::number(windowId, 16).toUpper().rightJustified(8, u'0'); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline /*constexpr*/ QString hwnd2str(HWND hwnd) { |
|---|
| | | // NULL handle is allowed here. |
|---|
| | | return hwnd2str(reinterpret_cast<WId>(hwnd)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isWin8OrGreater() { |
|---|
| | | static const bool result = IsWindows8OrGreater_Real(); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isWin8Point1OrGreater() { |
|---|
| | | static const bool result = IsWindows8Point1OrGreater_Real(); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isWin10OrGreater() { |
|---|
| | | static const bool result = IsWindows10OrGreater_Real(); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isWin11OrGreater() { |
|---|
| | | static const bool result = IsWindows11OrGreater_Real(); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isDwmCompositionEnabled() { |
|---|
| | | if (isWin8OrGreater()) { |
|---|
| | | return true; |
|---|
| | | } |
|---|
| | | const DynamicApis &apis = DynamicApis::instance(); |
|---|
| | | if (!apis.pDwmIsCompositionEnabled) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | BOOL enabled = FALSE; |
|---|
| | | return SUCCEEDED(apis.pDwmIsCompositionEnabled(&enabled)) && enabled; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isWindowFrameBorderColorized() { |
|---|
| | | const QWinRegistryKey registry(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\DWM)"); |
|---|
| | | if (!registry.isValid()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | const auto value = registry.dwordValue(L"ColorPrevalence"); |
|---|
| | | if (!value.second) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | return value.first; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isDarkThemeActive() { |
|---|
| | | #if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0) |
|---|
| | | return QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark; |
|---|
| | | #else |
|---|
| | | const QWinRegistryKey registry( |
|---|
| | | HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)"); |
|---|
| | | if (!registry.isValid()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | const auto value = registry.dwordValue(L"AppsUseLightTheme"); |
|---|
| | | if (!value.second) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | return !value.first; |
|---|
| | | #endif |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline bool isDarkWindowFrameEnabled(HWND hwnd) { |
|---|
| | | BOOL enabled = FALSE; |
|---|
| | | const DynamicApis &apis = DynamicApis::instance(); |
|---|
| | | if (SUCCEEDED(apis.pDwmGetWindowAttribute(hwnd, _DWMWA_USE_IMMERSIVE_DARK_MODE, &enabled, |
|---|
| | | sizeof(enabled)))) { |
|---|
| | | return enabled; |
|---|
| | | } else if (SUCCEEDED(apis.pDwmGetWindowAttribute(hwnd, |
|---|
| | | _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1, |
|---|
| | | &enabled, sizeof(enabled)))) { |
|---|
| | | return enabled; |
|---|
| | | } else { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline QColor getAccentColor() { |
|---|
| | | #if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0) |
|---|
| | | return QGuiApplication::palette().color(QPalette::Accent); |
|---|
| | | #else |
|---|
| | | const QWinRegistryKey registry(HKEY_CURRENT_USER, LR"(Software\Microsoft\Windows\DWM)"); |
|---|
| | | if (!registry.isValid()) { |
|---|
| | | return {}; |
|---|
| | | } |
|---|
| | | const auto value = registry.dwordValue(L"AccentColor"); |
|---|
| | | if (!value.second) { |
|---|
| | | return {}; |
|---|
| | | } |
|---|
| | | // The retrieved value is in the #AABBGGRR format, we need to |
|---|
| | | // convert it to the #AARRGGBB format which Qt expects. |
|---|
| | | const QColor abgr = QColor::fromRgba(value.first); |
|---|
| | | if (!abgr.isValid()) { |
|---|
| | | return {}; |
|---|
| | | } |
|---|
| | | return QColor::fromRgb(abgr.blue(), abgr.green(), abgr.red(), abgr.alpha()); |
|---|
| | | #endif |
|---|
| | | } |
|---|
| | | |
|---|
| | | static inline void triggerFrameChange(HWND hwnd) { |
|---|
| | | ::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0, |
|---|
| | | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | |
|---|
| | |
|---|
| | | |
|---|
| | | static inline quint32 getDpiForWindow(HWND hwnd) { |
|---|
| | | const DynamicApis &apis = DynamicApis::instance(); |
|---|
| | | if (apis.pGetDpiForWindow) { // Win10 |
|---|
| | | if (apis.pGetDpiForWindow) { // Win10 |
|---|
| | | return apis.pGetDpiForWindow(hwnd); |
|---|
| | | } else if (apis.pGetDpiForMonitor) { // Win8.1 |
|---|
| | | HMONITOR monitor = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST); |
|---|
| | |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | case WindowAttributeChangedHook: { |
|---|
| | | auto args = static_cast<void **>(data); |
|---|
| | | const auto &key = *static_cast<const QString *>(args[0]); |
|---|
| | | const auto &newVar = *static_cast<const QVariant *>(args[1]); |
|---|
| | | const auto &oldVar = *static_cast<const QVariant *>(args[2]); |
|---|
| | | |
|---|
| | | if (key == QStringLiteral("no-frame-shadow")) { |
|---|
| | | if (!windowId) |
|---|
| | | return; |
|---|
| | | if (newVar.toBool()) { |
|---|
| | | // TODO: set off |
|---|
| | | } else { |
|---|
| | | // TODO: set on |
|---|
| | | } |
|---|
| | | } else if (key == QStringLiteral("mica-material")) { |
|---|
| | | if (!windowId || !isWin11OrGreater()) |
|---|
| | | return; |
|---|
| | | const auto hwnd = reinterpret_cast<HWND>(windowId); |
|---|
| | | if (newVar.toBool()) { |
|---|
| | | /* |
|---|
| | | |
|---|
| | | // We need to extend the window frame into the whole client area to be able |
|---|
| | | // to see the blurred window background. |
|---|
| | | static constexpr const MARGINS margins = {-1, -1, -1, -1}; |
|---|
| | | ::DwmExtendFrameIntoClientArea(hwnd, &margins); |
|---|
| | | |
|---|
| | | // Use official DWM API to enable Mica/Mica Alt, available since Windows 11 |
|---|
| | | // (10.0.22000). |
|---|
| | | const DWM_SYSTEMBACKDROP_TYPE blurType = |
|---|
| | | DWMSBT_MAINWINDOW; // This one is Mica, if you want to enable Mica Alt, |
|---|
| | | // use DWMSBT_TABBEDWINDOW instead. |
|---|
| | | DynamicApis::instance().pDwmSetWindowAttribute( |
|---|
| | | hwnd, DWMWA_SYSTEMBACKDROP_TYPE, &blurType, sizeof(blurType)); |
|---|
| | | |
|---|
| | | */ |
|---|
| | | } else { |
|---|
| | | // TODO: set off |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | case DefaultColorsHook: { |
|---|
| | | auto &map = *static_cast<QMap<QString, QColor> *>(data); |
|---|
| | | map.clear(); |
|---|
| | |
|---|
| | | auto winId = m_windowHandle->winId(); |
|---|
| | | auto hWnd = reinterpret_cast<HWND>(winId); |
|---|
| | | |
|---|
| | | if (!isWin10OrGreater()) { |
|---|
| | | static constexpr const MARGINS margins = {1, 1, 1, 1}; |
|---|
| | | DynamicApis::instance().pDwmExtendFrameIntoClientArea(hWnd, &margins); |
|---|
| | | } |
|---|
| | | |
|---|
| | | #if QT_VERSION < QT_VERSION_CHECK(6, 5, 0) |
|---|
| | | for (const auto attr : { |
|---|
| | | _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1, |
|---|
| | |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return false; // Not handled |
|---|
| | | } |
|---|
| | | |
|---|
| | | bool Win32WindowContext::windowAttributeChanged(const QString &key, const QVariant &attribute, |
|---|
| | | const QVariant &oldAttribute) { |
|---|
| | | const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId()); |
|---|
| | | const DynamicApis &apis = DynamicApis::instance(); |
|---|
| | | static constexpr const MARGINS extendMargins = {-1, -1, -1, -1}; |
|---|
| | | static const auto defaultMargins = isWin10OrGreater() ? MARGINS{0, 0, 0, 0} : MARGINS{1, 1, 1, 1}; |
|---|
| | | if (key == QStringLiteral("mica")) { |
|---|
| | | if (!isWin11OrGreater()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | if (attribute.toBool()) { |
|---|
| | | // We need to extend the window frame into the whole client area to be able |
|---|
| | | // to see the blurred window background. |
|---|
| | | apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins); |
|---|
| | | if (isWin1122H2OrGreater()) { |
|---|
| | | // Use official DWM API to enable Mica, available since Windows 11 22H2 |
|---|
| | | // (10.0.22621). |
|---|
| | | const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_MAINWINDOW; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType, |
|---|
| | | sizeof(backdropType)); |
|---|
| | | } else { |
|---|
| | | // Use undocumented DWM API to enable Mica, available since Windows 11 |
|---|
| | | // (10.0.22000). |
|---|
| | | const BOOL enable = TRUE; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable)); |
|---|
| | | } |
|---|
| | | } else { |
|---|
| | | if (isWin1122H2OrGreater()) { |
|---|
| | | const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType, |
|---|
| | | sizeof(backdropType)); |
|---|
| | | } else { |
|---|
| | | const BOOL enable = FALSE; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_MICA_EFFECT, &enable, sizeof(enable)); |
|---|
| | | } |
|---|
| | | apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins); |
|---|
| | | } |
|---|
| | | return true; |
|---|
| | | } else if (key == QStringLiteral("mica-alt")) { |
|---|
| | | if (!isWin1122H2OrGreater()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | if (attribute.toBool()) { |
|---|
| | | // We need to extend the window frame into the whole client area to be able |
|---|
| | | // to see the blurred window background. |
|---|
| | | apis.pDwmExtendFrameIntoClientArea(hwnd, &extendMargins); |
|---|
| | | // Use official DWM API to enable Mica Alt, available since Windows 11 22H2 |
|---|
| | | // (10.0.22621). |
|---|
| | | const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_TABBEDWINDOW; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType, |
|---|
| | | sizeof(backdropType)); |
|---|
| | | } else { |
|---|
| | | const _DWM_SYSTEMBACKDROP_TYPE backdropType = _DWMSBT_AUTO; |
|---|
| | | apis.pDwmSetWindowAttribute(hwnd, _DWMWA_SYSTEMBACKDROP_TYPE, &backdropType, |
|---|
| | | sizeof(backdropType)); |
|---|
| | | apis.pDwmExtendFrameIntoClientArea(hwnd, &defaultMargins); |
|---|
| | | } |
|---|
| | | return true; |
|---|
| | | } else if (key == QStringLiteral("acrylic-material")) { |
|---|
| | | if (!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>(); |
|---|
| | | |
|---|
| | | 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; |
|---|
| | | } |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | QWK_USED static constexpr const struct { |
|---|
| | |
|---|
| | | // window activation state change. |
|---|
| | | *result = ::DefWindowProcW(hWnd, WM_NCACTIVATE, wParam, -1); |
|---|
| | | } else { |
|---|
| | | if (wParam) { |
|---|
| | | *result = FALSE; |
|---|
| | | } else { |
|---|
| | | *result = TRUE; |
|---|
| | | } |
|---|
| | | *result = TRUE; |
|---|
| | | } |
|---|
| | | return true; |
|---|
| | | } |
|---|
