github_mirror
/
framelesshelper
mirror of https://github.com/wangwenx190/framelesshelper.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Minor cleanup 

1. Remove unneeded functions
2. Rename some functions and variables to match their real functionality

Signed-off-by: Yuhang Zhao <2546789017@qq.com>
This commit is contained in:
Yuhang Zhao 2021-07-19 10:43:10 +08:00
parent bdbfc96eb0
commit f30339ff54
16 changed files with 112 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -127,7 +127,6 @@ if(WIN32)
endif()
target_link_libraries(${PROJECT_NAME} PRIVATE
Qt${QT_VERSION_MAJOR}::CorePrivate
Qt${QT_VERSION_MAJOR}::GuiPrivate
)

1
examples/mainwindow/main.cpp
View File

@ -27,6 +27,7 @@
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
// High DPI scaling is enabled by default from Qt 6
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
// Windows: we are using the manifest file to get maximum compatibility

3
examples/mainwindow/mainwindow.cpp
View File

@ -25,7 +25,6 @@
#include "mainwindow.h"
#include <QtGui/qpainter.h>
#include "../../framelesswindowsmanager.h"
#include "../../utilities.h"
MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags) : QMainWindow(parent, flags)
{
@ -131,7 +130,7 @@ void MainWindow::paintEvent(QPaintEvent *event)
{0, h, 0, 0}
};
painter.save();
painter.setPen({Utilities::getNativeWindowFrameColor(isActiveWindow()), 1});
painter.setPen({isActiveWindow() ? Qt::black : Qt::darkGray, 1});
painter.drawLines(lines);
painter.restore();
}

4
examples/quick/main.cpp
View File

@ -26,10 +26,10 @@
#include <QtGui/qguiapplication.h>
#include <QtQml/qqmlapplicationengine.h>
#include <QtQuickControls2/qquickstyle.h>
#include <QtQuick/qquickwindow.h>
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
// High DPI scaling is enabled by default from Qt 6
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
// Windows: we are using the manifest file to get maximum compatibility
@ -55,10 +55,8 @@ int main(int argc, char *argv[])
QQmlApplicationEngine engine;
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
QQuickWindow::setGraphicsApi(QSGRendererInterface::Software);
QQuickStyle::setStyle(QStringLiteral("Basic"));
#else
QQuickWindow::setSceneGraphBackend(QSGRendererInterface::Software);
QQuickStyle::setStyle(QStringLiteral("Default"));
#endif

2
examples/quick/qml/main.qml
View File

@ -117,7 +117,7 @@ Window {
anchors.fill: parent
color: "transparent"
border {
color: framelessHelper.nativeFrameColor
color: window.active ? "black" : "darkGray"
width: window._flh_margin
}
}

1
examples/widget/main.cpp
View File

@ -27,6 +27,7 @@
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
// High DPI scaling is enabled by default from Qt 6
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
// Windows: we are using the manifest file to get maximum compatibility

2
examples/widget/widget.cpp
View File

@ -103,7 +103,7 @@ void Widget::paintEvent(QPaintEvent *event)
{0, h, 0, 0}
};
painter.save();
painter.setPen({Utilities::getNativeWindowFrameColor(isActiveWindow()), 1});
painter.setPen({isActiveWindow() ? Qt::black : Qt::darkGray, 1});
painter.drawLines(lines);
painter.restore();
}

4
framelesshelper.cpp
View File

@ -67,8 +67,8 @@ bool FramelessHelper::eventFilter(QObject *object, QEvent *event)
return false;
}
const auto currentWindow = qobject_cast<QWindow *>(object);
const int m_borderWidth = FramelessWindowsManager::getBorderWidth(currentWindow);
const int m_borderHeight = FramelessWindowsManager::getBorderHeight(currentWindow);
const int m_borderWidth = FramelessWindowsManager::getResizeBorderWidth(currentWindow);
const int m_borderHeight = FramelessWindowsManager::getResizeBorderHeight(currentWindow);
const int m_titleBarHeight = FramelessWindowsManager::getTitleBarHeight(currentWindow);
const bool m_resizable = FramelessWindowsManager::getResizable(currentWindow);
const auto getWindowEdges =

4
framelesshelper_global.h
View File

@ -60,8 +60,8 @@
namespace _flh_global {
[[maybe_unused]] const char _flh_framelessEnabled_flag[] = "_FRAMELESSHELPER_FRAMELESS_MODE_ENABLED";
[[maybe_unused]] const char _flh_borderWidth_flag[] = "_FRAMELESSHELPER_WINDOW_BORDER_WIDTH";
[[maybe_unused]] const char _flh_borderHeight_flag[] = "_FRAMELESSHELPER_WINDOW_BORDER_HEIGHT";
[[maybe_unused]] const char _flh_borderWidth_flag[] = "_FRAMELESSHELPER_WINDOW_RESIZE_BORDER_WIDTH";
[[maybe_unused]] const char _flh_borderHeight_flag[] = "_FRAMELESSHELPER_WINDOW_RESIZE_BORDER_HEIGHT";
[[maybe_unused]] const char _flh_titleBarHeight_flag[] = "_FRAMELESSHELPER_WINDOW_TITLE_BAR_HEIGHT";
[[maybe_unused]] const char _flh_hitTestVisibleInChrome_flag[] = "_FRAMELESSHELPER_HIT_TEST_VISIBLE_IN_CHROME";
[[maybe_unused]] const char _flh_useNativeTitleBar_flag[] = "_FRAMELESSHELPER_USE_NATIVE_TITLE_BAR";

20
framelesshelper_win32.cpp
View File

@ -22,14 +22,6 @@
* SOFTWARE.
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "framelesshelper_win32.h"
#include <QtCore/qdebug.h>
#include <QtCore/qvariant.h>
@ -281,11 +273,11 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// The value of border width and border height should be
// identical in most cases, when the scale factor is 1.0, it
// should be eight pixels.
const int bh = getSystemMetric(window, Utilities::SystemMetric::BorderHeight, true);
const int bh = getSystemMetric(window, Utilities::SystemMetric::ResizeBorderHeight, true);
clientRect->top += bh;
if (!shouldHaveWindowFrame()) {
clientRect->bottom -= bh;
const int bw = getSystemMetric(window, Utilities::SystemMetric::BorderWidth, true);
const int bw = getSystemMetric(window, Utilities::SystemMetric::ResizeBorderWidth, true);
clientRect->left += bw;
clientRect->right -= bw;
}
@ -420,7 +412,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
case WM_NCPAINT: {
// 边框阴影处于非客户区的范围，因此如果直接阻止非客户区的绘制，会导致边框阴影丢失
if (!Utilities::isDwmBlurAvailable() && !shouldHaveWindowFrame()) {
if (!Utilities::isDwmCompositionAvailable() && !shouldHaveWindowFrame()) {
// Only block WM_NCPAINT when DWM composition is disabled. If
// it's blocked when DWM composition is enabled, the frame
// shadow won't be drawn.
@ -434,7 +426,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
if (shouldHaveWindowFrame()) {
break;
} else {
if (Utilities::isDwmBlurAvailable()) {
if (Utilities::isDwmCompositionAvailable()) {
// DefWindowProc won't repaint the window border if lParam
// (normally a HRGN) is -1. See the following link's "lParam"
// section:
@ -526,7 +518,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
POINT winLocalMouse = {qRound(globalMouse.x()), qRound(globalMouse.y())};
ScreenToClient(msg->hwnd, &winLocalMouse);
const QPointF localMouse = {static_cast<qreal>(winLocalMouse.x), static_cast<qreal>(winLocalMouse.y)};
const int bh = getSystemMetric(window, Utilities::SystemMetric::BorderHeight, true);
const int bh = getSystemMetric(window, Utilities::SystemMetric::ResizeBorderHeight, true);
const int tbh = getSystemMetric(window, Utilities::SystemMetric::TitleBarHeight, true);
const bool isTitleBar = (localMouse.y() <= tbh) && !Utilities::isHitTestVisibleInChrome(window);
const bool isTop = localMouse.y() <= bh;
@ -560,7 +552,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
GetClientRect(msg->hwnd, &clientRect);
const LONG ww = clientRect.right;
const LONG wh = clientRect.bottom;
const int bw = getSystemMetric(window, Utilities::SystemMetric::BorderWidth, true);
const int bw = getSystemMetric(window, Utilities::SystemMetric::ResizeBorderWidth, true);
if (IsMaximized(msg->hwnd)) {
if (isTitleBar) {
return HTCAPTION;

38
framelessquickhelper.cpp
View File

@ -25,40 +25,31 @@
#include "framelessquickhelper.h"
#include "framelesswindowsmanager.h"
#include <QtQuick/qquickwindow.h>
#include "utilities.h"
FramelessQuickHelper::FramelessQuickHelper(QQuickItem *parent) : QQuickItem(parent)
{
connect(this, &FramelessQuickHelper::windowChanged, this, [this](QQuickWindow *win){
if (m_frameColorConnection) {
disconnect(m_frameColorConnection);
}
if (win) {
m_frameColorConnection = connect(win, &QQuickWindow::activeChanged, this, &FramelessQuickHelper::nativeFrameColorChanged);
}
});
}
int FramelessQuickHelper::borderWidth() const
int FramelessQuickHelper::resizeBorderWidth() const
{
return FramelessWindowsManager::getBorderWidth(window());
return FramelessWindowsManager::getResizeBorderWidth(window());
}
void FramelessQuickHelper::setBorderWidth(const int val)
void FramelessQuickHelper::setResizeBorderWidth(const int val)
{
FramelessWindowsManager::setBorderWidth(window(), val);
Q_EMIT borderWidthChanged();
FramelessWindowsManager::setResizeBorderWidth(window(), val);
Q_EMIT resizeBorderWidthChanged();
}
int FramelessQuickHelper::borderHeight() const
int FramelessQuickHelper::resizeBorderHeight() const
{
return FramelessWindowsManager::getBorderHeight(window());
return FramelessWindowsManager::getResizeBorderHeight(window());
}
void FramelessQuickHelper::setBorderHeight(const int val)
void FramelessQuickHelper::setResizeBorderHeight(const int val)
{
FramelessWindowsManager::setBorderHeight(window(), val);
Q_EMIT borderHeightChanged();
FramelessWindowsManager::setResizeBorderHeight(window(), val);
Q_EMIT resizeBorderHeightChanged();
}
int FramelessQuickHelper::titleBarHeight() const
@ -83,15 +74,6 @@ void FramelessQuickHelper::setResizable(const bool val)
Q_EMIT resizableChanged();
}
QColor FramelessQuickHelper::nativeFrameColor() const
{
const auto win = window();
if (!win) {
return Qt::black;
}
return Utilities::getNativeWindowFrameColor(win->isActive());
}
void FramelessQuickHelper::removeWindowFrame()
{
FramelessWindowsManager::addWindow(window());

23
framelessquickhelper.h
View File

@ -34,21 +34,20 @@ class FRAMELESSHELPER_API FramelessQuickHelper : public QQuickItem
#ifdef QML_NAMED_ELEMENT
QML_NAMED_ELEMENT(FramelessHelper)
#endif
Q_PROPERTY(int borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged)
Q_PROPERTY(int borderHeight READ borderHeight WRITE setBorderHeight NOTIFY borderHeightChanged)
Q_PROPERTY(int resizeBorderWidth READ resizeBorderWidth WRITE setResizeBorderWidth NOTIFY resizeBorderWidthChanged)
Q_PROPERTY(int resizeBorderHeight READ resizeBorderHeight WRITE setResizeBorderHeight NOTIFY resizeBorderHeightChanged)
Q_PROPERTY(int titleBarHeight READ titleBarHeight WRITE setTitleBarHeight NOTIFY titleBarHeightChanged)
Q_PROPERTY(bool resizable READ resizable WRITE setResizable NOTIFY resizableChanged)
Q_PROPERTY(QColor nativeFrameColor READ nativeFrameColor NOTIFY nativeFrameColorChanged)
public:
explicit FramelessQuickHelper(QQuickItem *parent = nullptr);
~FramelessQuickHelper() override = default;
[[nodiscard]] int borderWidth() const;
void setBorderWidth(const int val);
[[nodiscard]] int resizeBorderWidth() const;
void setResizeBorderWidth(const int val);
[[nodiscard]] int borderHeight() const;
void setBorderHeight(const int val);
[[nodiscard]] int resizeBorderHeight() const;
void setResizeBorderHeight(const int val);
[[nodiscard]] int titleBarHeight() const;
void setTitleBarHeight(const int val);
@ -56,8 +55,6 @@ public:
[[nodiscard]] bool resizable() const;
void setResizable(const bool val);
[[nodiscard]] QColor nativeFrameColor() const;
public Q_SLOTS:
void removeWindowFrame();
void bringBackWindowFrame();
@ -65,12 +62,8 @@ public Q_SLOTS:
void setHitTestVisibleInChrome(QQuickItem *item, const bool visible);
Q_SIGNALS:
void borderWidthChanged();
void borderHeightChanged();
void resizeBorderWidthChanged();
void resizeBorderHeightChanged();
void titleBarHeightChanged();
void resizableChanged();
void nativeFrameColorChanged();
private:
QMetaObject::Connection m_frameColorConnection = {};
};

12
framelesswindowsmanager.cpp
View File

@ -84,7 +84,7 @@ void FramelessWindowsManager::setHitTestVisibleInChrome(QWindow *window, QObject
window->setProperty(_flh_global::_flh_hitTestVisibleInChrome_flag, QVariant::fromValue(objList));
}
int FramelessWindowsManager::getBorderWidth(const QWindow *window)
int FramelessWindowsManager::getResizeBorderWidth(const QWindow *window)
{
Q_ASSERT(window);
if (!window) {
@ -94,11 +94,11 @@ int FramelessWindowsManager::getBorderWidth(const QWindow *window)
const int value = window->property(_flh_global::_flh_borderWidth_flag).toInt();
return value <= 0 ? 8 : value;
#else
return Utilities::getSystemMetric(window, Utilities::SystemMetric::BorderWidth, false);
return Utilities::getSystemMetric(window, Utilities::SystemMetric::ResizeBorderWidth, false);
#endif
}
void FramelessWindowsManager::setBorderWidth(QWindow *window, const int value)
void FramelessWindowsManager::setResizeBorderWidth(QWindow *window, const int value)
{
Q_ASSERT(window);
if (!window || (value <= 0)) {
@ -107,7 +107,7 @@ void FramelessWindowsManager::setBorderWidth(QWindow *window, const int value)
window->setProperty(_flh_global::_flh_borderWidth_flag, value);
}
int FramelessWindowsManager::getBorderHeight(const QWindow *window)
int FramelessWindowsManager::getResizeBorderHeight(const QWindow *window)
{
Q_ASSERT(window);
if (!window) {
@ -117,11 +117,11 @@ int FramelessWindowsManager::getBorderHeight(const QWindow *window)
const int value = window->property(_flh_global::_flh_borderHeight_flag).toInt();
return value <= 0 ? 8 : value;
#else
return Utilities::getSystemMetric(window, Utilities::SystemMetric::BorderHeight, false);
return Utilities::getSystemMetric(window, Utilities::SystemMetric::ResizeBorderHeight, false);
#endif
}
void FramelessWindowsManager::setBorderHeight(QWindow *window, const int value)
void FramelessWindowsManager::setResizeBorderHeight(QWindow *window, const int value)
{
Q_ASSERT(window);
if (!window || (value <= 0)) {

11
framelesswindowsmanager.h
View File

@ -31,16 +31,17 @@ QT_FORWARD_DECLARE_CLASS(QObject)
QT_FORWARD_DECLARE_CLASS(QWindow)
QT_END_NAMESPACE
namespace FramelessWindowsManager {
namespace FramelessWindowsManager
{
FRAMELESSHELPER_API void addWindow(QWindow *window);
FRAMELESSHELPER_API void removeWindow(QWindow *window);
[[nodiscard]] FRAMELESSHELPER_API bool isWindowFrameless(const QWindow *window);
FRAMELESSHELPER_API void setHitTestVisibleInChrome(QWindow *window, QObject *object, const bool value = true);
[[nodiscard]] FRAMELESSHELPER_API int getBorderWidth(const QWindow *window);
FRAMELESSHELPER_API void setBorderWidth(QWindow *window, const int value);
[[nodiscard]] FRAMELESSHELPER_API int getBorderHeight(const QWindow *window);
FRAMELESSHELPER_API void setBorderHeight(QWindow *window, const int value);
[[nodiscard]] FRAMELESSHELPER_API int getResizeBorderWidth(const QWindow *window);
FRAMELESSHELPER_API void setResizeBorderWidth(QWindow *window, const int value);
[[nodiscard]] FRAMELESSHELPER_API int getResizeBorderHeight(const QWindow *window);
FRAMELESSHELPER_API void setResizeBorderHeight(QWindow *window, const int value);
[[nodiscard]] FRAMELESSHELPER_API int getTitleBarHeight(const QWindow *window);
FRAMELESSHELPER_API void setTitleBarHeight(QWindow *window, const int value);
[[nodiscard]] FRAMELESSHELPER_API bool getResizable(const QWindow *window);

20
utilities.h
View File

@ -25,45 +25,33 @@
#pragma once
#include "framelesshelper_global.h"
#include <QtGui/qcolor.h>
#include <QtGui/qwindow.h>
namespace Utilities {
enum class SystemMetric
{
BorderWidth,
BorderHeight,
ResizeBorderWidth,
ResizeBorderHeight,
TitleBarHeight
};
// Common
[[nodiscard]] FRAMELESSHELPER_API int getSystemMetric(const QWindow *window, const SystemMetric metric, const bool dpiAware, const bool forceSystemValue = false);
[[nodiscard]] FRAMELESSHELPER_API bool isLightThemeEnabled();
[[nodiscard]] FRAMELESSHELPER_API bool isDarkThemeEnabled();
[[nodiscard]] FRAMELESSHELPER_API int getSystemMetric(const QWindow *window, const SystemMetric metric, const bool dpiScale, const bool forceSystemValue = false);
[[nodiscard]] FRAMELESSHELPER_API QWindow *findWindow(const WId winId);
[[nodiscard]] FRAMELESSHELPER_API bool shouldUseNativeTitleBar();
[[nodiscard]] FRAMELESSHELPER_API bool isWindowFixedSize(const QWindow *window);
[[nodiscard]] FRAMELESSHELPER_API QPointF getGlobalMousePosition(const QWindow *window);
[[nodiscard]] FRAMELESSHELPER_API bool isHitTestVisibleInChrome(const QWindow *window);
[[nodiscard]] FRAMELESSHELPER_API QColor getNativeWindowFrameColor(const bool isActive = true);
[[nodiscard]] FRAMELESSHELPER_API QPointF mapOriginPointToWindow(const QObject *object);
#ifdef Q_OS_WINDOWS
// Windows specific
[[nodiscard]] FRAMELESSHELPER_API bool isWin8OrGreater();
[[nodiscard]] FRAMELESSHELPER_API bool isWin8Point1OrGreater();
[[nodiscard]] FRAMELESSHELPER_API bool isWin10OrGreater();
[[nodiscard]] FRAMELESSHELPER_API bool isWin10OrGreater(const int subVer);
[[nodiscard]] FRAMELESSHELPER_API bool isDwmBlurAvailable();
[[nodiscard]] FRAMELESSHELPER_API bool isColorizationEnabled();
[[nodiscard]] FRAMELESSHELPER_API QColor getColorizationColor();
[[nodiscard]] FRAMELESSHELPER_API bool isDwmCompositionAvailable();
FRAMELESSHELPER_API void triggerFrameChange(const QWindow *window);
FRAMELESSHELPER_API void updateFrameMargins(const QWindow *window, const bool reset);
FRAMELESSHELPER_API void updateQtFrameMargins(QWindow *window, const bool enable);
[[nodiscard]] quint32 getWindowDpi(const QWindow *window);
[[nodiscard]] FRAMELESSHELPER_API QMargins getWindowNativeFrameMargins(const QWindow *window);
FRAMELESSHELPER_API void displaySystemMenu(const QWindow *window, const QPointF &pos = {});
#endif
}

413
utilities_win32.cpp
View File

@ -22,17 +22,7 @@
* SOFTWARE.
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "utilities.h"
#include <QtCore/qsettings.h>
#include <QtCore/private/qsystemlibrary_p.h>
#include <QtCore/qt_windows.h>
#include <QtGui/qguiapplication.h>
#include <QtCore/qdebug.h>
@ -51,85 +41,15 @@
Q_DECLARE_METATYPE(QMargins)
#ifndef USER_DEFAULT_SCREEN_DPI
// Only available since Windows Vista
#define USER_DEFAULT_SCREEN_DPI 96
#endif
#ifndef SM_CXPADDEDBORDER
// Only available since Windows Vista
#define SM_CXPADDEDBORDER 92
#endif
static const QString g_dwmRegistryKey = QStringLiteral(R"(HKEY_CURRENT_USER\Software\Microsoft\Windows\DWM)");
static const QString g_personalizeRegistryKey = QStringLiteral(R"(HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)");
// The standard values of resize border width, resize border height and title bar height when DPI is 96.
static const int g_defaultResizeBorderWidth = 8, g_defaultResizeBorderHeight = 8, g_defaultTitleBarHeight = 31;
// The standard values of border width, border height and title bar height when DPI is 96.
static const int g_defaultBorderWidth = 8, g_defaultBorderHeight = 8, g_defaultTitleBarHeight = 31;
using MONITOR_DPI_TYPE = enum _MONITOR_DPI_TYPE
{
MDT_EFFECTIVE_DPI = 0
};
using PROCESS_DPI_AWARENESS = enum _PROCESS_DPI_AWARENESS
{
PROCESS_DPI_UNAWARE = 0,
PROCESS_SYSTEM_DPI_AWARE = 1,
PROCESS_PER_MONITOR_DPI_AWARE = 2
};
struct Win32Data
{
using ShouldAppsUseDarkModePtr = BOOL(WINAPI *)();
using ShouldSystemUseDarkModePtr = BOOL(WINAPI *)();
using GetDpiForMonitorPtr = HRESULT(WINAPI *)(HMONITOR, MONITOR_DPI_TYPE, UINT *, UINT *);
using GetProcessDpiAwarenessPtr = HRESULT(WINAPI *)(HANDLE, PROCESS_DPI_AWARENESS *);
using GetSystemDpiForProcessPtr = UINT(WINAPI *)(HANDLE);
using GetDpiForWindowPtr = UINT(WINAPI *)(HWND);
using GetDpiForSystemPtr = UINT(WINAPI *)();
using GetSystemMetricsForDpiPtr = int(WINAPI *)(int, UINT);
using AdjustWindowRectExForDpiPtr = BOOL(WINAPI *)(LPRECT, DWORD, BOOL, DWORD, UINT);
ShouldAppsUseDarkModePtr ShouldAppsUseDarkModePFN = nullptr;
ShouldSystemUseDarkModePtr ShouldSystemUseDarkModePFN = nullptr;
GetDpiForMonitorPtr GetDpiForMonitorPFN = nullptr;
GetProcessDpiAwarenessPtr GetProcessDpiAwarenessPFN = nullptr;
GetSystemDpiForProcessPtr GetSystemDpiForProcessPFN = nullptr;
GetDpiForWindowPtr GetDpiForWindowPFN = nullptr;
GetDpiForSystemPtr GetDpiForSystemPFN = nullptr;
GetSystemMetricsForDpiPtr GetSystemMetricsForDpiPFN = nullptr;
AdjustWindowRectExForDpiPtr AdjustWindowRectExForDpiPFN = nullptr;
explicit Win32Data()
{
load();
}
void load()
{
QSystemLibrary User32Dll(QStringLiteral("User32.dll"));
GetDpiForWindowPFN = reinterpret_cast<GetDpiForWindowPtr>(User32Dll.resolve("GetDpiForWindow"));
GetDpiForSystemPFN = reinterpret_cast<GetDpiForSystemPtr>(User32Dll.resolve("GetDpiForSystem"));
GetSystemMetricsForDpiPFN = reinterpret_cast<GetSystemMetricsForDpiPtr>(User32Dll.resolve("GetSystemMetricsForDpi"));
AdjustWindowRectExForDpiPFN = reinterpret_cast<AdjustWindowRectExForDpiPtr>(User32Dll.resolve("AdjustWindowRectExForDpi"));
GetSystemDpiForProcessPFN = reinterpret_cast<GetSystemDpiForProcessPtr>(User32Dll.resolve("GetSystemDpiForProcess"));
QSystemLibrary UxThemeDll(QStringLiteral("UxTheme.dll"));
ShouldAppsUseDarkModePFN = reinterpret_cast<ShouldAppsUseDarkModePtr>(UxThemeDll.resolve(MAKEINTRESOURCEA(132)));
ShouldSystemUseDarkModePFN = reinterpret_cast<ShouldSystemUseDarkModePtr>(UxThemeDll.resolve(MAKEINTRESOURCEA(138)));
QSystemLibrary SHCoreDll(QStringLiteral("SHCore.dll"));
GetDpiForMonitorPFN = reinterpret_cast<GetDpiForMonitorPtr>(SHCoreDll.resolve("GetDpiForMonitor"));
GetProcessDpiAwarenessPFN = reinterpret_cast<GetProcessDpiAwarenessPtr>(SHCoreDll.resolve("GetProcessDpiAwareness"));
}
};
Q_GLOBAL_STATIC(Win32Data, win32Data)
bool Utilities::isDwmBlurAvailable()
bool Utilities::isDwmCompositionAvailable()
{
// DWM Composition is always enabled and can't be disabled since Windows 8.
if (isWin8OrGreater()) {
@ -137,132 +57,86 @@ bool Utilities::isDwmBlurAvailable()
}
BOOL enabled = FALSE;
if (FAILED(DwmIsCompositionEnabled(&enabled))) {
qWarning() << "DwmIsCompositionEnabled failed.";
qWarning() << "DwmIsCompositionEnabled() failed.";
return false;
}
return (enabled != FALSE);
}
int Utilities::getSystemMetric(const QWindow *window, const SystemMetric metric, const bool dpiAware, const bool forceSystemValue)
int Utilities::getSystemMetric(const QWindow *window, const SystemMetric metric, const bool dpiScale, const bool forceSystemValue)
{
Q_ASSERT(window);
if (!window) {
return 0;
}
const qreal dpr = dpiAware ? window->devicePixelRatio() : 1.0;
const auto getSystemMetricsForWindow = [dpr](const int index, const bool dpiAware) -> int {
if (win32Data()->GetSystemMetricsForDpiPFN) {
const quint32 dpi = dpiAware ? qRound(USER_DEFAULT_SCREEN_DPI * dpr) : USER_DEFAULT_SCREEN_DPI;
return win32Data()->GetSystemMetricsForDpiPFN(index, dpi);
} else {
const int value = GetSystemMetrics(index);
return dpiAware ? value : qRound(value / dpr);
}
};
int ret = 0;
switch (metric) {
case SystemMetric::BorderWidth: {
case SystemMetric::ResizeBorderWidth: {
const int bw = window->property(_flh_global::_flh_borderWidth_flag).toInt();
if ((bw > 0) && !forceSystemValue) {
ret = qRound(bw * dpr);
return qRound(static_cast<qreal>(bw) * (dpiScale ? window->devicePixelRatio() : 1.0));
} else {
const int result_nondpi = getSystemMetricsForWindow(SM_CXSIZEFRAME, false)
+ getSystemMetricsForWindow(SM_CXPADDEDBORDER, false);
const int result_dpi = getSystemMetricsForWindow(SM_CXSIZEFRAME, true)
+ getSystemMetricsForWindow(SM_CXPADDEDBORDER, true);
const int result = dpiAware ? result_dpi : result_nondpi;
ret = result > 0 ? result : qRound(g_defaultBorderWidth * dpr);
const int result = GetSystemMetrics(SM_CXSIZEFRAME) + GetSystemMetrics(SM_CXPADDEDBORDER);
if (result > 0) {
if (dpiScale) {
return result;
} else {
return qRound(static_cast<qreal>(result) / window->devicePixelRatio());
}
} break;
case SystemMetric::BorderHeight: {
} else {
if (dpiScale) {
return qRound(static_cast<qreal>(g_defaultResizeBorderWidth) * window->devicePixelRatio());
} else {
return g_defaultResizeBorderWidth;
}
}
}
}
case SystemMetric::ResizeBorderHeight: {
const int bh = window->property(_flh_global::_flh_borderHeight_flag).toInt();
if ((bh > 0) && !forceSystemValue) {
ret = qRound(bh * dpr);
return qRound(static_cast<qreal>(bh) * (dpiScale ? window->devicePixelRatio() : 1.0));
} else {
const int result_nondpi = getSystemMetricsForWindow(SM_CYSIZEFRAME, false)
+ getSystemMetricsForWindow(SM_CXPADDEDBORDER, false);
const int result_dpi = getSystemMetricsForWindow(SM_CYSIZEFRAME, true)
+ getSystemMetricsForWindow(SM_CXPADDEDBORDER, true);
const int result = dpiAware ? result_dpi : result_nondpi;
ret = result > 0 ? result : qRound(g_defaultBorderHeight * dpr);
// There is no "SM_CYPADDEDBORDER".
const int result = GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CXPADDEDBORDER);
if (result > 0) {
if (dpiScale) {
return result;
} else {
return qRound(static_cast<qreal>(result) / window->devicePixelRatio());
}
} else {
if (dpiScale) {
return qRound(static_cast<qreal>(g_defaultResizeBorderHeight) * window->devicePixelRatio());
} else {
return g_defaultResizeBorderHeight;
}
}
}
}
} break;
case SystemMetric::TitleBarHeight: {
const int tbh = window->property(_flh_global::_flh_titleBarHeight_flag).toInt();
if ((tbh > 0) && !forceSystemValue) {
// Special case: this is the user defined value,
// don't change it and just return it untouched.
return qRound(tbh * dpr);
return qRound(static_cast<qreal>(tbh) * (dpiScale ? window->devicePixelRatio() : 1.0));
} else {
const int result_nondpi = getSystemMetricsForWindow(SM_CYCAPTION, false);
const int result_dpi = getSystemMetricsForWindow(SM_CYCAPTION, true);
const int result = dpiAware ? result_dpi : result_nondpi;
ret = result > 0 ? result : qRound(g_defaultTitleBarHeight * dpr);
// There is no "SM_CYPADDEDBORDER".
const int result = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CXPADDEDBORDER);
if (result > 0) {
if (dpiScale) {
return result;
} else {
return qRound(static_cast<qreal>(result) / window->devicePixelRatio());
}
} break;
} else {
if (dpiScale) {
return qRound(static_cast<qreal>(g_defaultTitleBarHeight) * window->devicePixelRatio());
} else {
return g_defaultTitleBarHeight;
}
// When dpr = 1.0 (DPI = 96):
// SM_CXSIZEFRAME = SM_CYSIZEFRAME = 4px
// SM_CXPADDEDBORDER = 4px
// SM_CYCAPTION = 23px
// Border Width = Border Height = SM_C(X|Y)SIZEFRAME + SM_CXPADDEDBORDER = 8px
// Title Bar Height = Border Height + SM_CYCAPTION = 31px
// dpr = 1.25 --> Title Bar Height = 38px
// dpr = 1.5 --> Title Bar Height = 45px
// dpr = 1.75 --> Title Bar Height = 51px
ret += (metric == SystemMetric::TitleBarHeight) ? getSystemMetric(window, SystemMetric::BorderHeight, dpiAware) : 0;
return ret;
}
bool Utilities::isColorizationEnabled()
{
if (!isWin10OrGreater()) {
return false;
}
// TODO: Is there an official Win32 API to do this?
bool ok = false;
const QSettings registry(g_dwmRegistryKey, QSettings::NativeFormat);
const bool colorPrevalence = registry.value(QStringLiteral("ColorPrevalence"), 0).toULongLong(&ok) != 0;
return (ok && colorPrevalence);
}
QColor Utilities::getColorizationColor()
{
DWORD color = 0;
BOOL opaqueBlend = FALSE;
if (SUCCEEDED(DwmGetColorizationColor(&color, &opaqueBlend))) {
return QColor::fromRgba(color);
}
qWarning() << "DwmGetColorizationColor failed, reading from the registry instead.";
bool ok = false;
const QSettings settings(g_dwmRegistryKey, QSettings::NativeFormat);
const DWORD value = settings.value(QStringLiteral("ColorizationColor"), 0).toULongLong(&ok);
return ok ? QColor::fromRgba(value) : Qt::darkGray;
}
bool Utilities::isLightThemeEnabled()
{
return !isDarkThemeEnabled();
}
bool Utilities::isDarkThemeEnabled()
{
if (!isWin10OrGreater()) {
return false;
}
// We can't use ShouldAppsUseDarkMode due to the following reason:
// it's not exported publicly so we can only load it dynamically through its ordinal name,
// however, its ordinal name has changed in some unknown system versions so we can't find
// the actual function now. But ShouldSystemUseDarkMode is not affected, we can still
// use it in the latest version of Windows.
if (win32Data()->ShouldSystemUseDarkModePFN) {
return win32Data()->ShouldSystemUseDarkModePFN();
}
qDebug() << "ShouldSystemUseDarkMode() not available, reading from the registry instead.";
bool ok = false;
const QSettings settings(g_personalizeRegistryKey, QSettings::NativeFormat);
const bool lightThemeEnabled = settings.value(QStringLiteral("AppsUseLightTheme"), 0).toULongLong(&ok) != 0;
return (ok && !lightThemeEnabled);
return 0;
}
void Utilities::triggerFrameChange(const QWindow *window)
@ -272,12 +146,8 @@ void Utilities::triggerFrameChange(const QWindow *window)
return;
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
Q_ASSERT(hwnd);
if (!hwnd) {
return;
}
if (SetWindowPos(hwnd, nullptr, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER) == FALSE) {
qWarning() << "SetWindowPos failed.";
qWarning() << "SetWindowPos() failed.";
}
}
@ -285,7 +155,7 @@ void Utilities::updateFrameMargins(const QWindow *window, const bool reset)
{
// DwmExtendFrameIntoClientArea() will always fail if DWM Composition is disabled.
// No need to try in this case.
if (!isDwmBlurAvailable()) {
if (!isDwmCompositionAvailable()) {
return;
}
Q_ASSERT(window);
@ -293,101 +163,12 @@ void Utilities::updateFrameMargins(const QWindow *window, const bool reset)
return;
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
Q_ASSERT(hwnd);
if (!hwnd) {
return;
}
const MARGINS margins = reset ? MARGINS{0, 0, 0, 0} : MARGINS{1, 1, 1, 1};
if (FAILED(DwmExtendFrameIntoClientArea(hwnd, &margins))) {
qWarning() << "DwmExtendFrameIntoClientArea failed.";
qWarning() << "DwmExtendFrameIntoClientArea() failed.";
}
}
quint32 Utilities::getWindowDpi(const QWindow *window)
{
Q_ASSERT(window);
if (!window) {
return USER_DEFAULT_SCREEN_DPI;
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
Q_ASSERT(hwnd);
if (!hwnd) {
return USER_DEFAULT_SCREEN_DPI;
}
if (QCoreApplication::testAttribute(Qt::AA_Use96Dpi)) {
return USER_DEFAULT_SCREEN_DPI;
}
if (win32Data()->GetDpiForWindowPFN) {
return win32Data()->GetDpiForWindowPFN(hwnd);
} else if (win32Data()->GetSystemDpiForProcessPFN) {
return win32Data()->GetSystemDpiForProcessPFN(GetCurrentProcess());
} else if (win32Data()->GetDpiForSystemPFN) {
return win32Data()->GetDpiForSystemPFN();
} else if (win32Data()->GetDpiForMonitorPFN) {
const HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
if (monitor) {
UINT dpiX = USER_DEFAULT_SCREEN_DPI, dpiY = USER_DEFAULT_SCREEN_DPI;
if (SUCCEEDED(win32Data()->GetDpiForMonitorPFN(monitor, MDT_EFFECTIVE_DPI, &dpiX, &dpiY))) {
return dpiX;
} else {
qWarning() << "GetDpiForMonitor failed";
}
} else {
qWarning() << "MonitorFromWindow failed.";
}
}
// We can use Direct2D to get DPI since Win7 or Vista, but it's marked as deprecated by Microsoft
// in the latest SDK and we'll get compilation warnings because of that, so we just don't use it here.
const HDC hdc = GetDC(nullptr);
if (hdc) {
const int dpiX = GetDeviceCaps(hdc, LOGPIXELSX);
ReleaseDC(nullptr, hdc);
if (dpiX > 0) {
return dpiX;
} else {
qWarning() << "GetDeviceCaps failed.";
}
}
return USER_DEFAULT_SCREEN_DPI;
}
QMargins Utilities::getWindowNativeFrameMargins(const QWindow *window)
{
Q_ASSERT(window);
if (!window) {
return {};
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
Q_ASSERT(hwnd);
if (!hwnd) {
return {};
}
RECT rect = {0, 0, 0, 0};
const LONG_PTR style = GetWindowLongPtrW(hwnd, GWL_STYLE);
const LONG_PTR exStyle = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
if (win32Data()->AdjustWindowRectExForDpiPFN) {
if (win32Data()->AdjustWindowRectExForDpiPFN(&rect, style, FALSE, exStyle, getWindowDpi(window)) == FALSE) {
qWarning() << "AdjustWindowRectExForDpiPFN failed.";
}
} else {
if (AdjustWindowRectEx(&rect, style, FALSE, exStyle) == FALSE) {
qWarning() << "AdjustWindowRectEx failed.";
}
}
return {qAbs(rect.left), qAbs(rect.top), qAbs(rect.right), qAbs(rect.bottom)};
}
QColor Utilities::getNativeWindowFrameColor(const bool isActive)
{
if (!isActive) {
return Qt::darkGray;
}
if (!isWin10OrGreater()) {
return Qt::black;
}
return isColorizationEnabled() ? getColorizationColor() : (isDarkThemeEnabled() ? Qt::white : Qt::black);
}
void Utilities::updateQtFrameMargins(QWindow *window, const bool enable)
{
Q_ASSERT(window);
@ -395,8 +176,8 @@ void Utilities::updateQtFrameMargins(QWindow *window, const bool enable)
return;
}
const int tbh = enable ? Utilities::getSystemMetric(window, Utilities::SystemMetric::TitleBarHeight, true, true) : 0;
const int bw = enable ? Utilities::getSystemMetric(window, Utilities::SystemMetric::BorderWidth, true, true) : 0;
const int bh = enable ? Utilities::getSystemMetric(window, Utilities::SystemMetric::BorderHeight, true, true) : 0;
const int bw = enable ? Utilities::getSystemMetric(window, Utilities::SystemMetric::ResizeBorderWidth, true, true) : 0;
const int bh = enable ? Utilities::getSystemMetric(window, Utilities::SystemMetric::ResizeBorderHeight, true, true) : 0;
const QMargins margins = {-bw, -tbh, -bw, -bh}; // left, top, right, bottom
const QVariant marginsVar = QVariant::fromValue(margins);
window->setProperty("_q_windowsCustomMargins", marginsVar);
@ -440,79 +221,3 @@ bool Utilities::isWin10OrGreater()
return QSysInfo::WindowsVersion >= QSysInfo::WV_WINDOWS10;
#endif
}
bool Utilities::isWin10OrGreater(const int subVer)
{
#if (QT_VERSION >= QT_VERSION_CHECK(5, 9, 0))
return QOperatingSystemVersion::current() >= QOperatingSystemVersion(QOperatingSystemVersion::Windows, 10, 0, subVer);
#else
Q_UNUSED(ver);
return QSysInfo::WindowsVersion >= QSysInfo::WV_WINDOWS10;
#endif
}
void Utilities::displaySystemMenu(const QWindow *window, const QPointF &pos)
{
Q_ASSERT(window);
if (!window) {
return;
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
Q_ASSERT(hwnd);
if (!hwnd) {
return;
}
const HMENU hMenu = GetSystemMenu(hwnd, FALSE);
if (!hMenu) {
qWarning() << "Failed to acquire the system menu.";
return;
}
MENUITEMINFOW mii;
SecureZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STATE;
mii.fType = 0;
mii.fState = MF_ENABLED;
SetMenuItemInfoW(hMenu, SC_RESTORE, FALSE, &mii);
SetMenuItemInfoW(hMenu, SC_SIZE, FALSE, &mii);
SetMenuItemInfoW(hMenu, SC_MOVE, FALSE, &mii);
SetMenuItemInfoW(hMenu, SC_MAXIMIZE, FALSE, &mii);
SetMenuItemInfoW(hMenu, SC_MINIMIZE, FALSE, &mii);
mii.fState = MF_GRAYED;
const bool isMin = [window]{
return (window->windowState() == Qt::WindowMinimized);
}();
const bool isMax = [window]{
return (window->windowState() == Qt::WindowMaximized);
}();
const bool isFull = [window]{
return (window->windowState() == Qt::WindowFullScreen);
}();
const bool isNormal = [window]{
return (window->windowState() == Qt::WindowNoState);
}();
const bool isFix = isWindowFixedSize(window);
if (isFix || isMax || isFull) {
SetMenuItemInfoW(hMenu, SC_SIZE, FALSE, &mii);
SetMenuItemInfoW(hMenu, SC_MAXIMIZE, FALSE, &mii);
}
if (isFix || isFull || isNormal) {
SetMenuItemInfoW(hMenu, SC_RESTORE, FALSE, &mii);
}
if (isMax || isFull) {
SetMenuItemInfoW(hMenu, SC_MOVE, FALSE, &mii);
}
if (isMin) {
SetMenuItemInfoW(hMenu, SC_MINIMIZE, FALSE, &mii);
}
const bool isRtl = QGuiApplication::isRightToLeft();
const qreal dpr = window->devicePixelRatio();
const QPointF point = pos.isNull() ? QPointF(QCursor::pos(window->screen())) * dpr : QPointF(window->mapToGlobal(pos.toPoint())) * dpr;
const LPARAM cmd = TrackPopupMenu(hMenu,
(TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_TOPALIGN |
(isRtl ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
qRound(point.x()), qRound(point.y()), 0, hwnd, nullptr);
if (cmd) {
PostMessageW(hwnd, WM_SYSCOMMAND, cmd, 0);
}
}