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

wip

This commit is contained in:
Yuhang Zhao 2023-09-14 17:58:50 +08:00 committed by Zhao Yuhang
parent 26b9996ec6
commit b9238440e0
24 changed files with 1430 additions and 978 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
CMakeLists.txt
View File

@ -31,6 +31,7 @@ project(FramelessHelper
)
include(CMakeDependentOption)
include(cmake/utils.cmake)
# TODO: Use add_feature_info() for every option below? Is it worth doing?
option(FRAMELESSHELPER_BUILD_STATIC "Build FramelessHelper as a static library." OFF)
@ -61,16 +62,7 @@ option(FRAMELESSHELPER_NO_TRANSLATION "Don't bundle the I18N translations into t
option(FRAMELESSHELPER_NO_MICA_MATERIAL "Disable the cross-platform homemade Mica Material." OFF)
option(FRAMELESSHELPER_NO_BORDER_PAINTER "Disable the cross-platform window frame border painter." OFF)
option(FRAMELESSHELPER_NO_SYSTEM_BUTTON "Disable the pre-defined StandardSystemButton control." OFF)
if(FRAMELESSHELPER_NO_WINDOW AND FRAMELESSHELPER_BUILD_EXAMPLES)
message(WARNING "You can't build the examples when the FramelessWindow class is disabled at the same time!")
set(FRAMELESSHELPER_BUILD_EXAMPLES OFF)
endif()
set(FRAMELESSHELPER_64BIT_POSTFIX "")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(FRAMELESSHELPER_64BIT_POSTFIX "64")
endif()
cmake_dependent_option(FRAMELESSHELPER_NATIVE_IMPL "Use platform native implementation instead of Qt to get best experience." ON WIN32 OFF)
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core Gui)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Gui)
@ -78,10 +70,18 @@ find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Gui)
find_package(QT NAMES Qt6 Qt5 QUIET COMPONENTS Widgets Quick)
find_package(Qt${QT_VERSION_MAJOR} QUIET COMPONENTS Widgets Quick)
include(cmake/utils.cmake)
if(FRAMELESSHELPER_NATIVE_IMPL AND NOT WIN32)
message(WARNING "FRAMELESSHELPER_NATIVE_IMPL currently only supports the Windows platform!")
set(FRAMELESSHELPER_NATIVE_IMPL OFF)
endif()
if(NOT APPLE AND FRAMELESSHELPER_ENABLE_UNIVERSAL_BUILD)
message(WARNING "Current OS is not macOS, universal build will be disabled.")
if(FRAMELESSHELPER_NO_WINDOW AND FRAMELESSHELPER_BUILD_EXAMPLES)
message(WARNING "You can't build the examples when the FramelessWindow class is disabled at the same time!")
set(FRAMELESSHELPER_BUILD_EXAMPLES OFF)
endif()
if(FRAMELESSHELPER_ENABLE_UNIVERSAL_BUILD AND NOT APPLE)
message(WARNING "Universal build is a macOS only feature, it will be disabled on current platform.")
set(FRAMELESSHELPER_ENABLE_UNIVERSAL_BUILD OFF)
elseif(APPLE AND ((QT_VERSION VERSION_LESS "6.2" AND QT_VERSION VERSION_GREATER_EQUAL "6.0") OR (QT_VERSION VERSION_LESS "5.15.9")))
message(WARNING "Your Qt version ${QT_VERSION} doesn't support universal build, it will be disabled.")
@ -94,6 +94,29 @@ endif()
if(FRAMELESSHELPER_ENABLE_VCLTL AND NOT MSVC)
message(WARNING "VC-LTL is only available for the MSVC toolchain.")
set(FRAMELESSHELPER_ENABLE_VCLTL OFF)
endif()
if(FRAMELESSHELPER_ENABLE_YYTHUNKS AND NOT MSVC)
message(WARNING "YY-Thunks is only available for the MSVC toolchain.")
set(FRAMELESSHELPER_ENABLE_YYTHUNKS OFF)
endif()
if(NOT TARGET Qt${QT_VERSION_MAJOR}::Core OR NOT TARGET Qt${QT_VERSION_MAJOR}::Gui)
message(WARNING "Can't find the QtCore and/or QtGui module. Nothing will be built.")
set(FRAMELESSHELPER_BUILD_WIDGETS OFF)
set(FRAMELESSHELPER_BUILD_QUICK OFF)
set(FRAMELESSHELPER_BUILD_EXAMPLES OFF)
endif()
if(FRAMELESSHELPER_BUILD_QUICK AND NOT TARGET Qt${QT_VERSION_MAJOR}::Quick)
message(WARNING "Can't find the QtQuick module. FramelessHelper's QtQuick implementation and the QtQuick demo won't be built.")
set(FRAMELESSHELPER_BUILD_QUICK OFF)
endif()
set(FRAMELESSHELPER_64BIT_POSTFIX "")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(FRAMELESSHELPER_64BIT_POSTFIX "64")
endif()
set(FRAMELESSHELPER_LICENSE_HEADER "/*
@ -144,7 +167,6 @@ if(MINGW AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
set(FRAMELESSHELPER_ENABLE_CFGUARD OFF)
endif()
if(MSVC)
if(FRAMELESSHELPER_ENABLE_VCLTL)
include(cmake/VC-LTL.cmake)
if("x${SupportLTL}" STREQUAL "xtrue")
@ -162,7 +184,6 @@ if(MSVC)
set(YYTHUNKS_TARGET_OS "WinXP" CACHE STRING "" FORCE)
include(cmake/YY-Thunks.cmake)
endif()
endif()
set(__extra_flags "")
if(FRAMELESSHELPER_NO_INSTALL)
@ -175,11 +196,6 @@ prepare_package_export(
)
unset(__extra_flags)
if(FRAMELESSHELPER_BUILD_QUICK AND NOT TARGET Qt${QT_VERSION_MAJOR}::Quick)
message(WARNING "Can't find the QtQuick module. FramelessHelper's QtQuick implementation and the QtQuick demo won't be built.")
set(FRAMELESSHELPER_BUILD_QUICK OFF)
endif()
set(FRAMELESSHELPER_VERSION_FILE "${PROJECT_BINARY_DIR}/framelesshelper.version")
generate_project_version(
PATH "${FRAMELESSHELPER_VERSION_FILE}"
@ -202,14 +218,11 @@ add_project_config(KEY "translation" CONDITION NOT FRAMELESSHELPER_NO_TRANSLATIO
add_project_config(KEY "mica_material" CONDITION NOT FRAMELESSHELPER_NO_MICA_MATERIAL)
add_project_config(KEY "border_painter" CONDITION NOT FRAMELESSHELPER_NO_BORDER_PAINTER)
add_project_config(KEY "system_button" CONDITION NOT FRAMELESSHELPER_NO_SYSTEM_BUTTON)
add_project_config(KEY "native_impl" CONDITION FRAMELESSHELPER_NATIVE_IMPL)
generate_project_config(PATH "${FRAMELESSHELPER_CONFIG_FILE}")
if(TARGET Qt${QT_VERSION_MAJOR}::Core AND TARGET Qt${QT_VERSION_MAJOR}::Gui)
if(FRAMELESSHELPER_BUILD_WIDGETS OR FRAMELESSHELPER_BUILD_QUICK)
add_subdirectory(src)
else()
message(WARNING "Can't find the QtCore and QtGui module. Nothing will be built.")
set(FRAMELESSHELPER_BUILD_WIDGETS OFF)
set(FRAMELESSHELPER_BUILD_EXAMPLES OFF)
endif()
if(FRAMELESSHELPER_BUILD_EXAMPLES)

12
build/msvc.bat → build.bat
View File

@ -16,15 +16,15 @@ cmake --version
echo ninja build
ninja --version
cd /d "%~dp0"
if exist "%~dp0build.user.bat" call "%~dp0build.user.bat"
if not defined QTDIR set QTDIR=C:\Qt\6.6.0\msvc2019_64
if exist build.user.bat call build.user.bat
if not defined QTDIR set QTDIR=%SystemDrive%\Qt\6.6.0\msvc2019_64
echo QTDIR=%QTDIR%
if exist cmake rd /s /q cmake
md cmake
cd cmake
if exist build rd /s /q build
md build
cd build
cmake -DCMAKE_PREFIX_PATH="%QTDIR%" -DCMAKE_INSTALL_PREFIX="%~dp0cmake\install" -DCMAKE_CONFIGURATION_TYPES=Release;Debug -G"Ninja Multi-Config" -DFRAMELESSHELPER_ENABLE_VCLTL=ON -DFRAMELESSHELPER_ENABLE_YYTHUNKS=ON -DFRAMELESSHELPER_ENABLE_SPECTRE=ON -DFRAMELESSHELPER_ENABLE_EHCONTGUARD=ON -DFRAMELESSHELPER_ENABLE_INTELCET=ON -DFRAMELESSHELPER_ENABLE_INTELJCC=ON -DFRAMELESSHELPER_ENABLE_CFGUARD=ON -DFRAMELESSHELPER_FORCE_LTO=ON "%~dp0.."
md cmake
cd cmake
cmake -DCMAKE_PREFIX_PATH="%QTDIR%" -DCMAKE_INSTALL_PREFIX="%~dp0build\install" -DCMAKE_CONFIGURATION_TYPES=Release;Debug -G"Ninja Multi-Config" -DFRAMELESSHELPER_ENABLE_VCLTL=ON -DFRAMELESSHELPER_ENABLE_YYTHUNKS=ON -DFRAMELESSHELPER_ENABLE_SPECTRE=ON -DFRAMELESSHELPER_ENABLE_EHCONTGUARD=ON -DFRAMELESSHELPER_ENABLE_INTELCET=ON -DFRAMELESSHELPER_ENABLE_INTELJCC=ON -DFRAMELESSHELPER_ENABLE_CFGUARD=ON -DFRAMELESSHELPER_FORCE_LTO=ON "%~dp0"
cmake --build . --target all --config Release --parallel
cmake --build . --target all --config Debug --parallel
cmake --install . --config Release --strip

10
include/FramelessHelper/Core/framelesshelper_qt.h
View File

@ -26,9 +26,9 @@
#include <FramelessHelper/Core/framelesshelpercore_global.h>
FRAMELESSHELPER_BEGIN_NAMESPACE
#if !FRAMELESSHELPER_CONFIG(native_impl)
struct SystemParameters;
FRAMELESSHELPER_BEGIN_NAMESPACE
class FRAMELESSHELPER_CORE_API FramelessHelperQt : public QObject
{
@ -40,11 +40,13 @@ public:
explicit FramelessHelperQt(QObject *parent = nullptr);
~FramelessHelperQt() override;
static void addWindow(const SystemParameters *params);
static void removeWindow(const WId windowId);
static void addWindow(const QWindow *window);
static void removeWindow(const QWindow *window);
protected:
Q_NODISCARD bool eventFilter(QObject *object, QEvent *event) override;
};
FRAMELESSHELPER_END_NAMESPACE
#endif // !native_impl

10
include/FramelessHelper/Core/framelesshelper_win.h
View File

@ -29,9 +29,9 @@
#ifdef Q_OS_WINDOWS
FRAMELESSHELPER_BEGIN_NAMESPACE
#if FRAMELESSHELPER_CONFIG(native_impl)
struct SystemParameters;
FRAMELESSHELPER_BEGIN_NAMESPACE
class FRAMELESSHELPER_CORE_API FramelessHelperWin : public QAbstractNativeEventFilter
{
@ -41,12 +41,14 @@ public:
explicit FramelessHelperWin();
~FramelessHelperWin() override;
static void addWindow(const SystemParameters *params);
static void removeWindow(const WId windowId);
static void addWindow(const QObject *window);
static void removeWindow(const QObject *window);
Q_NODISCARD bool nativeEventFilter(const QByteArray &eventType, void *message, QT_NATIVE_EVENT_RESULT_TYPE *result) override;
};
FRAMELESSHELPER_END_NAMESPACE
#endif // native_impl
#endif // Q_OS_WINDOWS

134
include/FramelessHelper/Core/framelesshelper_windows.h
View File

@ -86,6 +86,46 @@
#include <FramelessHelper/Core/framelesshelpercore_global.h>
#ifndef SC_SIZE
# define SC_SIZE (0xF000)
#endif
#ifndef SC_SIZELEFT
# define SC_SIZELEFT (0xF001)
#endif
#ifndef SC_SIZERIGHT
# define SC_SIZERIGHT (0xF002)
#endif
#ifndef SC_SIZETOP
# define SC_SIZETOP (0xF003)
#endif
#ifndef SC_SIZETOPLEFT
# define SC_SIZETOPLEFT (0xF004)
#endif
#ifndef SC_SIZETOPRIGHT
# define SC_SIZETOPRIGHT (0xF005)
#endif
#ifndef SC_SIZEBOTTOM
# define SC_SIZEBOTTOM (0xF006)
#endif
#ifndef SC_SIZEBOTTOMLEFT
# define SC_SIZEBOTTOMLEFT (0xF007)
#endif
#ifndef SC_SIZEBOTTOMRIGHT
# define SC_SIZEBOTTOMRIGHT (0xF008)
#endif
#ifndef SC_DRAGMOVE
# define SC_DRAGMOVE (0xF012)
#endif
#ifndef WM_SIZEWAIT
# define WM_SIZEWAIT (0x0004)
#endif
@ -1107,7 +1147,7 @@ _AdjustWindowRectExForDpi2(
EXTERN_C_END
[[maybe_unused]] inline constexpr const int kAutoHideTaskBarThickness = 2; // The thickness of an auto-hide taskbar in pixels.
[[maybe_unused]] inline constexpr const unsigned char kAutoHideTaskBarThickness = 2; // The thickness of an auto-hide taskbar in pixels.
[[maybe_unused]] inline constexpr const wchar_t kDwmRegistryKey[] = LR"(Software\Microsoft\Windows\DWM)";
[[maybe_unused]] inline constexpr const wchar_t kPersonalizeRegistryKey[] = LR"(Software\Microsoft\Windows\CurrentVersion\Themes\Personalize)";
[[maybe_unused]] inline constexpr const wchar_t kThemeSettingChangeEventName[] = L"ImmersiveColorSet";
@ -1116,3 +1156,95 @@ EXTERN_C_END
[[maybe_unused]] inline constexpr const wchar_t kSystemLightThemeResourceName[] = L"Explorer";
[[maybe_unused]] inline constexpr const wchar_t kDesktopRegistryKey[] = LR"(Control Panel\Desktop)";
[[maybe_unused]] inline constexpr const wchar_t kDarkModePropertyName[] = L"UseImmersiveDarkModeColors";
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator==(const POINT &lhs, const POINT &rhs) noexcept
{
return ((lhs.x == rhs.x) && (lhs.y == rhs.y));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator!=(const POINT &lhs, const POINT &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator==(const SIZE &lhs, const SIZE &rhs) noexcept
{
return ((lhs.cx == rhs.cx) && (lhs.cy == rhs.cy));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator!=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator>(const SIZE &lhs, const SIZE &rhs) noexcept
{
return ((lhs.cx * lhs.cy) > (rhs.cx * rhs.cy));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator>=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator>(lhs, rhs) || operator==(lhs, rhs));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator<(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator!=(lhs, rhs) && !operator>(lhs, rhs));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator<=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator<(lhs, rhs) || operator==(lhs, rhs));
}
[[maybe_unused]] [[nodiscard]] 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));
}
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator!=(const RECT &lhs, const RECT &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[nodiscard]] inline constexpr QPoint point2qpoint(const POINT &point)
{
return QPoint{ int(point.x), int(point.y) };
}
[[nodiscard]] inline constexpr POINT qpoint2point(const QPoint &point)
{
return POINT{ LONG(point.x()), LONG(point.y()) };
}
[[nodiscard]] inline constexpr QSize size2qsize(const SIZE &size)
{
return QSize{ int(size.cx), int(size.cy) };
}
[[nodiscard]] inline constexpr SIZE qsize2size(const QSize &size)
{
return SIZE{ LONG(size.width()), LONG(size.height()) };
}
[[nodiscard]] 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)) } };
}
[[nodiscard]] inline constexpr RECT qrect2rect(const QRect &qrect)
{
return RECT{ LONG(qrect.left()), LONG(qrect.top()), LONG(qrect.right()), LONG(qrect.bottom()) };
}
[[nodiscard]] inline /*constexpr*/ QString hwnd2str(const WId windowId)
{
// NULL handle is allowed here.
return FRAMELESSHELPER_STRING_LITERAL("0x") + QString::number(windowId, 16).toUpper().rightJustified(8, u'0');
}
[[nodiscard]] inline /*constexpr*/ QString hwnd2str(const HWND hwnd)
{
// NULL handle is allowed here.
return hwnd2str(reinterpret_cast<WId>(hwnd));
}

2
include/FramelessHelper/Core/framelesshelpercore_global.h
View File

@ -316,7 +316,7 @@ Q_NAMESPACE_EXPORT(FRAMELESSHELPER_CORE_API)
enum class Option : quint8
{
UseCrossPlatformQtImplementation,
//UseCrossPlatformQtImplementation,
ForceHideWindowFrameBorder,
ForceShowWindowFrameBorder,
DisableWindowsSnapLayout,

5
include/FramelessHelper/Core/framelessmanager.h
View File

@ -28,7 +28,6 @@
FRAMELESSHELPER_BEGIN_NAMESPACE
struct SystemParameters;
class FramelessManagerPrivate;
class FRAMELESSHELPER_CORE_API FramelessManager : public QObject
@ -51,8 +50,8 @@ public:
Q_NODISCARD Global::WallpaperAspectStyle wallpaperAspectStyle() const;
public Q_SLOTS:
void addWindow(const SystemParameters *params);
void removeWindow(const WId windowId);
Q_NODISCARD bool addWindow(const QObject *window, const WId windowId);
Q_NODISCARD bool removeWindow(const QObject *window);
void setOverrideTheme(const Global::SystemTheme theme);
Q_SIGNALS:

76
include/FramelessHelper/Core/private/framelesshelpercore_global_p.h
View File

@ -25,7 +25,10 @@
#pragma once
#include <FramelessHelper/Core/framelesshelpercore_global.h>
#include <QtCore/qhash.h>
#include <QtGui/qwindowdefs.h>
#include <functional>
#include <memory>
QT_BEGIN_NAMESPACE
class QScreen;
@ -62,7 +65,7 @@ using GetWidgetHandleCallback = std::function<QObject *()>;
using ForceChildrenRepaintCallback = std::function<void(const int)>;
using ResetQtGrabbedControlCallback = std::function<bool()>;
struct SystemParameters
struct FRAMELESSHELPER_CORE_API FramelessCallbacks
{
GetWindowFlagsCallback getWindowFlags = nullptr;
SetWindowFlagsCallback setWindowFlags = nullptr;
@ -92,29 +95,84 @@ struct SystemParameters
GetWidgetHandleCallback getWidgetHandle = nullptr;
ForceChildrenRepaintCallback forceChildrenRepaint = nullptr;
ResetQtGrabbedControlCallback resetQtGrabbedControl = nullptr;
FramelessCallbacks();
virtual ~FramelessCallbacks();
using PtrType = std::shared_ptr<FramelessCallbacks>;
[[nodiscard]] static PtrType create();
private:
Q_DISABLE_COPY_MOVE(FramelessCallbacks)
};
using FramelessCallbacksPtr = FramelessCallbacks::PtrType;
enum class ExtraDataType : quint8
{
WindowsUtilities,
LinuxUtilities,
MacOSUtilities,
FramelessWidgetsHelper,
FramelessQuickHelper
};
using FramelessParams = SystemParameters *;
using FramelessParamsConst = const SystemParameters *;
using FramelessParamsRef = SystemParameters &;
using FramelessParamsConstRef = const SystemParameters &;
struct FRAMELESSHELPER_CORE_API FramelessExtraData
{
FramelessExtraData();
virtual ~FramelessExtraData();
using PtrType = std::shared_ptr<FramelessExtraData>;
private:
Q_DISABLE_COPY_MOVE(FramelessExtraData)
};
using FramelessExtraDataPtr = FramelessExtraData::PtrType;
using FramelessExtraDataPtrs = QList<FramelessExtraDataPtr>;
using FramelessExtraDataHash = QHash<ExtraDataType, FramelessExtraDataPtr>;
struct FRAMELESSHELPER_CORE_API FramelessData
{
QObject *window = nullptr;
WId windowId = 0;
QObject *winIdUpdater = nullptr;
bool frameless = false;
FramelessCallbacksPtr callbacks = nullptr;
FramelessExtraDataHash extraData = {};
FramelessData();
virtual ~FramelessData();
using PtrType = std::shared_ptr<FramelessData>;
[[nodiscard]] static PtrType create();
private:
Q_DISABLE_COPY_MOVE(FramelessData)
};
using FramelessDataPtr = FramelessData::PtrType;
using FramelessDataPtrs = QList<FramelessDataPtr>;
using FramelessDataHash = QHash<QObject *, FramelessDataPtr>;
FRAMELESSHELPER_END_NAMESPACE
#define DECLARE_SIZE_COMPARE_OPERATORS(Type1, Type2) \
[[maybe_unused]] [[nodiscard]] static inline constexpr bool operator>(const Type1 &lhs, const Type2 &rhs) noexcept \
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator>(const Type1 &lhs, const Type2 &rhs) noexcept \
{ \
return ((lhs.width() * lhs.height()) > (rhs.width() * rhs.height())); \
} \
[[maybe_unused]] [[nodiscard]] static inline constexpr bool operator>=(const Type1 &lhs, const Type2 &rhs) noexcept \
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator>=(const Type1 &lhs, const Type2 &rhs) noexcept \
{ \
return (operator>(lhs, rhs) || operator==(lhs, rhs)); \
} \
[[maybe_unused]] [[nodiscard]] static inline constexpr bool operator<(const Type1 &lhs, const Type2 &rhs) noexcept \
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator<(const Type1 &lhs, const Type2 &rhs) noexcept \
{ \
return (operator!=(lhs, rhs) && !operator>(lhs, rhs)); \
} \
[[maybe_unused]] [[nodiscard]] static inline constexpr bool operator<=(const Type1 &lhs, const Type2 &rhs) noexcept \
[[maybe_unused]] [[nodiscard]] inline constexpr bool operator<=(const Type1 &lhs, const Type2 &rhs) noexcept \
{ \
return (operator<(lhs, rhs) || operator==(lhs, rhs)); \
}
DECLARE_SIZE_COMPARE_OPERATORS(QSize, QSize)
DECLARE_SIZE_COMPARE_OPERATORS(QSizeF, QSizeF)
DECLARE_SIZE_COMPARE_OPERATORS(QSize, QSizeF)
DECLARE_SIZE_COMPARE_OPERATORS(QSizeF, QSize)

11
include/FramelessHelper/Core/private/framelessmanager_p.h
View File

@ -30,9 +30,10 @@
FRAMELESSHELPER_BEGIN_NAMESPACE
struct SystemParameters;
class FramelessManager;
struct FramelessData;
using FramelessDataPtr = std::shared_ptr<FramelessData>;
class FramelessManager;
class FRAMELESSHELPER_CORE_API FramelessManagerPrivate : public QObject
{
Q_OBJECT
@ -60,6 +61,12 @@ public:
void doNotifySystemThemeHasChangedOrNot();
void doNotifyWallpaperHasChangedOrNot();
Q_NODISCARD static FramelessDataPtr getData(const QObject *window);
Q_NODISCARD static FramelessDataPtr createData(const QObject *window, const WId windowId);
Q_NODISCARD static WId getWindowId(const QObject *window);
Q_NODISCARD static QObject *getWindow(const WId windowId);
static void updateWindowId(const QObject *window, const WId newWindowId);
FramelessManager *q_ptr = nullptr;
Global::SystemTheme systemTheme = Global::SystemTheme::Unknown;
std::optional<Global::SystemTheme> overrideTheme = std::nullopt;

62
include/FramelessHelper/Core/utils.h
View File

@ -25,9 +25,6 @@
#pragma once
#include <FramelessHelper/Core/framelesshelpercore_global.h>
#if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
# include <FramelessHelper/Core/framelesshelper_linux.h>
#endif // Q_OS_LINUX
#if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
QT_BEGIN_NAMESPACE
@ -37,30 +34,22 @@ QT_END_NAMESPACE
FRAMELESSHELPER_BEGIN_NAMESPACE
struct SystemParameters;
namespace Utils
{
[[nodiscard]] FRAMELESSHELPER_CORE_API
Qt::CursorShape calculateCursorShape(const QWindow *window, const QPoint &pos);
[[nodiscard]] FRAMELESSHELPER_CORE_API
Qt::Edges calculateWindowEdges(const QWindow *window, const QPoint &pos);
[[nodiscard]] FRAMELESSHELPER_CORE_API Qt::CursorShape calculateCursorShape(const QWindow *window, const QPoint &pos);
[[nodiscard]] FRAMELESSHELPER_CORE_API Qt::Edges calculateWindowEdges(const QWindow *window, const QPoint &pos);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool startSystemMove(QWindow *window, const QPoint &globalPos);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool startSystemResize(QWindow *window, const Qt::Edges edges, const QPoint &globalPos);
[[nodiscard]] FRAMELESSHELPER_CORE_API QString getSystemButtonGlyph(const Global::SystemButtonType button);
[[nodiscard]] FRAMELESSHELPER_CORE_API QWindow *findWindow(const WId windowId);
FRAMELESSHELPER_CORE_API void moveWindowToDesktopCenter(
const SystemParameters *params, const bool considerTaskBar);
[[nodiscard]] FRAMELESSHELPER_CORE_API Qt::WindowState windowStatesToWindowState(
const Qt::WindowStates states);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool moveWindowToDesktopCenter(const WId windowId, const bool considerTaskBar);
[[nodiscard]] FRAMELESSHELPER_CORE_API Qt::WindowState windowStatesToWindowState(const Qt::WindowStates states);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isThemeChangeEvent(const QEvent * const event);
[[nodiscard]] FRAMELESSHELPER_CORE_API QColor calculateSystemButtonBackgroundColor(
const Global::SystemButtonType button, const Global::ButtonState state);
[[nodiscard]] FRAMELESSHELPER_CORE_API QColor calculateSystemButtonBackgroundColor(const Global::SystemButtonType button, const Global::ButtonState state);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool shouldAppsUseDarkMode();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isTitleBarColorized();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool
setBlurBehindWindowEnabled(const WId windowId, const Global::BlurMode mode, const QColor &color);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setBlurBehindWindowEnabled(const WId windowId, const Global::BlurMode mode, const QColor &color);
[[nodiscard]] FRAMELESSHELPER_CORE_API QString getWallpaperFilePath();
[[nodiscard]] FRAMELESSHELPER_CORE_API Global::WallpaperAspectStyle getWallpaperAspectStyle();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isBlurBehindWindowSupported();
@ -100,31 +89,24 @@ FRAMELESSHELPER_CORE_API void moveWindowToDesktopCenter(
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isFullScreen(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isWindowNoState(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool syncWmPaintWithDwm();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool showSystemMenu(
const WId windowId, const QPoint &pos,
const bool selectFirstEntry, const SystemParameters *params);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool showSystemMenu(const WId windowId, const QPoint &pos, const bool selectFirstEntry);
[[nodiscard]] FRAMELESSHELPER_CORE_API QColor getDwmColorizationColor(bool *opaque = nullptr, bool *ok = nullptr);
[[nodiscard]] FRAMELESSHELPER_CORE_API Global::DwmColorizationArea getDwmColorizationArea();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isHighContrastModeEnabled();
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getPrimaryScreenDpi(const bool horizontal);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getWindowDpi(const WId windowId, const bool horizontal);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThicknessForDpi
(const bool horizontal, const quint32 dpi);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThickness(const WId windowId,
const bool horizontal,
const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThicknessForDpi(const bool horizontal, const quint32 dpi);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThickness(const WId windowId, const bool horizontal, const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getCaptionBarHeightForDpi(const quint32 dpi);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getCaptionBarHeight(const WId windowId, const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getTitleBarHeightForDpi(const quint32 dpi);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getTitleBarHeight(const WId windowId, const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getFrameBorderThicknessForDpi(const quint32 dpi);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getFrameBorderThickness(const WId windowId,
const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getFrameBorderThickness(const WId windowId, const bool scaled);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool maybeFixupQtInternals(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isWindowFrameBorderVisible();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isFrameBorderColorized();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool installWindowProcHook(
const WId windowId, const SystemParameters *params);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool installWindowProcHook(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool uninstallWindowProcHook(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setAeroSnappingEnabled(const WId windowId, const bool enable);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool tryToEnableHighestDpiAwarenessLevel();
@ -132,13 +114,11 @@ FRAMELESSHELPER_CORE_API void moveWindowToDesktopCenter(
[[nodiscard]] FRAMELESSHELPER_CORE_API bool shouldAppsUseDarkMode_windows();
[[nodiscard]] FRAMELESSHELPER_CORE_API QColor getAccentColor_windows();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setCornerStyleForWindow(const WId windowId, const Global::WindowCornerStyle style);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool hideOriginalTitleBarElements
(const WId windowId, const bool disable = true);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool hideOriginalTitleBarElements(const WId windowId, const bool disable = true);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setQtDarkModeAwareEnabled(const bool enable);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool refreshWin32ThemeResources(const WId windowId, const bool dark);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool enableNonClientAreaDpiScalingForWindow(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API
Global::DpiAwareness getDpiAwarenessForCurrentProcess(bool *highest = nullptr);
[[nodiscard]] FRAMELESSHELPER_CORE_API Global::DpiAwareness getDpiAwarenessForCurrentProcess(bool *highest = nullptr);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool fixupChildWindowsDpiMessage(const WId windowId);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool fixupDialogsDpiScaling();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setDarkModeAllowedForApp(const bool allow = true);
@ -156,8 +136,7 @@ FRAMELESSHELPER_CORE_API void printWin32Message(void *msg);
#endif // Q_OS_WINDOWS
#if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
[[nodiscard]] FRAMELESSHELPER_CORE_API QScreen *x11_findScreenForVirtualDesktop
(const int virtualDesktopNumber);
[[nodiscard]] FRAMELESSHELPER_CORE_API QScreen *x11_findScreenForVirtualDesktop(const int virtualDesktopNumber);
[[nodiscard]] FRAMELESSHELPER_CORE_API x11_return_type x11_appRootWindow(const int screen);
[[nodiscard]] FRAMELESSHELPER_CORE_API int x11_appScreen();
[[nodiscard]] FRAMELESSHELPER_CORE_API x11_return_type x11_appTime();
@ -166,11 +145,8 @@ FRAMELESSHELPER_CORE_API void printWin32Message(void *msg);
[[nodiscard]] FRAMELESSHELPER_CORE_API QByteArray x11_nextStartupId();
[[nodiscard]] FRAMELESSHELPER_CORE_API Display *x11_display();
[[nodiscard]] FRAMELESSHELPER_CORE_API xcb_connection_t *x11_connection();
[[nodiscard]] FRAMELESSHELPER_CORE_API QByteArray getWindowProperty
(const WId windowId, const xcb_atom_t prop, const xcb_atom_t type, const quint32 data_len);
FRAMELESSHELPER_CORE_API void setWindowProperty
(const WId windowId, const xcb_atom_t prop, const xcb_atom_t type,
const void *data, const quint32 data_len, const uint8_t format);
[[nodiscard]] FRAMELESSHELPER_CORE_API QByteArray getWindowProperty(const WId windowId, const xcb_atom_t prop, const xcb_atom_t type, const quint32 data_len);
FRAMELESSHELPER_CORE_API void setWindowProperty(const WId windowId, const xcb_atom_t prop, const xcb_atom_t type, const void *data, const quint32 data_len, const uint8_t format);
FRAMELESSHELPER_CORE_API void clearWindowProperty(const WId windowId, const xcb_atom_t prop);
[[nodiscard]] FRAMELESSHELPER_CORE_API xcb_atom_t internAtom(const char *name);
[[nodiscard]] FRAMELESSHELPER_CORE_API QString getWindowManagerName();
@ -180,11 +156,9 @@ FRAMELESSHELPER_CORE_API void clearWindowProperty(const WId windowId, const xcb_
FRAMELESSHELPER_CORE_API void openSystemMenu(const WId windowId, const QPoint &globalPos);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool shouldAppsUseDarkMode_linux();
[[nodiscard]] FRAMELESSHELPER_CORE_API QColor getAccentColor_linux();
FRAMELESSHELPER_CORE_API void sendMoveResizeMessage
(const WId windowId, const uint32_t action, const QPoint &globalPos, const Qt::MouseButton button = Qt::LeftButton);
FRAMELESSHELPER_CORE_API void sendMoveResizeMessage(const WId windowId, const uint32_t action, const QPoint &globalPos, const Qt::MouseButton button = Qt::LeftButton);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool isCustomDecorationSupported();
[[nodiscard]] FRAMELESSHELPER_CORE_API bool
setPlatformPropertiesForWindow(QWindow *window, const QVariantHash &props);
[[nodiscard]] FRAMELESSHELPER_CORE_API bool setPlatformPropertiesForWindow(QWindow *window, const QVariantHash &props);
#endif // Q_OS_LINUX
#ifdef Q_OS_MACOS

3
include/FramelessHelper/Quick/private/framelessquickhelper_p.h
View File

@ -40,7 +40,6 @@ class QuickMicaMaterial;
class QuickWindowBorder;
#endif
class FramelessQuickHelper;
struct FramelessQuickHelperData;
class FRAMELESSHELPER_QUICK_API FramelessQuickHelperPrivate : public QObject
{
@ -83,8 +82,6 @@ public:
Q_NODISCARD bool isInTitleBarDraggableArea(const QPoint &pos) const;
Q_NODISCARD bool shouldIgnoreMouseEvents(const QPoint &pos) const;
void setSystemButtonState(const QuickGlobal::SystemButtonType button, const QuickGlobal::ButtonState state);
Q_NODISCARD const FramelessQuickHelperData *getWindowData() const;
Q_NODISCARD FramelessQuickHelperData *getWindowDataMutable() const;
void rebindWindow();
FramelessQuickHelper *q_ptr = nullptr;

3
include/FramelessHelper/Widgets/private/framelesswidgetshelper_p.h
View File

@ -37,7 +37,6 @@ class MicaMaterial;
class WindowBorderPainter;
#endif
class FramelessWidgetsHelper;
struct FramelessWidgetsHelperData;
class WidgetsSharedHelper;
class FRAMELESSHELPER_WIDGETS_API FramelessWidgetsHelperPrivate : public QObject
@ -83,8 +82,6 @@ public:
Q_NODISCARD bool shouldIgnoreMouseEvents(const QPoint &pos) const;
void setSystemButtonState(const Global::SystemButtonType button, const Global::ButtonState state);
Q_NODISCARD QWidget *findTopLevelWindow() const;
Q_NODISCARD const FramelessWidgetsHelperData *getWindowData() const;
Q_NODISCARD FramelessWidgetsHelperData *getWindowDataMutable() const;
FramelessWidgetsHelper *q_ptr = nullptr;
QColor savedWindowBackgroundColor = {};

45
src/core/CMakeLists.txt
View File

@ -35,18 +35,18 @@ if(UNIX AND NOT APPLE)
endif()
find_package(X11 QUIET COMPONENTS xcb)
if(TARGET X11::xcb)
message("Found system XCB. The XCB wrapper will be disabled.")
message(STATUS "--- Found system XCB. The XCB wrapper will be disabled.")
else()
message("System XCB not found. The XCB wrapper will be used instead.")
message(STATUS "--- System XCB not found. The XCB wrapper will be used instead.")
endif()
find_package(PkgConfig QUIET)
if(PkgConfig_FOUND)
pkg_check_modules(GTK3 QUIET IMPORTED_TARGET gtk+-3.0)
endif()
if(TARGET PkgConfig::GTK3)
message("Found system GTK. The GTK wrapper will be disabled.")
message(STATUS "--- Found system GTK. The GTK wrapper will be disabled.")
else()
message("System GTK not found. The GTK wrapper will be used instead.")
message(STATUS "--- System GTK not found. The GTK wrapper will be used instead.")
endif()
endif()
@ -61,14 +61,12 @@ set(PUBLIC_HEADERS
${FRAMELESSHELPER_VERSION_FILE}
${FRAMELESSHELPER_CONFIG_FILE}
${INCLUDE_PREFIX}/framelesshelpercore_global.h
${INCLUDE_PREFIX}/framelesshelper_qt.h
${INCLUDE_PREFIX}/framelessmanager.h
${INCLUDE_PREFIX}/utils.h
)
set(PUBLIC_HEADERS_ALIAS
${INCLUDE_PREFIX}/Global
${INCLUDE_PREFIX}/FramelessHelper_Qt
${INCLUDE_PREFIX}/FramelessManager
${INCLUDE_PREFIX}/Utils
)
@ -84,7 +82,6 @@ set(PRIVATE_HEADERS
set(SOURCES
utils.cpp
framelesshelper_qt.cpp
framelessmanager.cpp
framelessconfig.cpp
sysapiloader.cpp
@ -92,14 +89,8 @@ set(SOURCES
)
if(WIN32)
list(APPEND PUBLIC_HEADERS
${INCLUDE_PREFIX}/framelesshelper_windows.h
${INCLUDE_PREFIX}/framelesshelper_win.h
)
list(APPEND PUBLIC_HEADERS_ALIAS
${INCLUDE_PREFIX}/FramelessHelper_Windows
${INCLUDE_PREFIX}/FramelessHelper_Win
)
list(APPEND PUBLIC_HEADERS ${INCLUDE_PREFIX}/framelesshelper_windows.h)
list(APPEND PUBLIC_HEADERS_ALIAS ${INCLUDE_PREFIX}/FramelessHelper_Windows)
list(APPEND PRIVATE_HEADERS
${INCLUDE_PREFIX}/private/registrykey_p.h
${INCLUDE_PREFIX}/private/winverhelper_p.h
@ -107,25 +98,35 @@ if(WIN32)
list(APPEND SOURCES
registrykey.cpp
utils_win.cpp
framelesshelper_win.cpp
winverhelper.cpp
platformsupport_win.cpp
)
elseif(APPLE)
list(APPEND SOURCES utils_mac.mm)
elseif(UNIX)
list(APPEND PUBLIC_HEADERS
${INCLUDE_PREFIX}/framelesshelper_linux.h
)
list(APPEND PUBLIC_HEADERS_ALIAS
${INCLUDE_PREFIX}/FramelessHelper_Linux
)
list(APPEND PUBLIC_HEADERS ${INCLUDE_PREFIX}/framelesshelper_linux.h)
list(APPEND PUBLIC_HEADERS_ALIAS ${INCLUDE_PREFIX}/FramelessHelper_Linux)
list(APPEND SOURCES
utils_linux.cpp
platformsupport_linux.cpp
)
endif()
if(FRAMELESSHELPER_NATIVE_IMPL)
if(WIN32)
list(APPEND PUBLIC_HEADERS ${INCLUDE_PREFIX}/framelesshelper_win.h)
list(APPEND PUBLIC_HEADERS_ALIAS ${INCLUDE_PREFIX}/FramelessHelper_Win)
list(APPEND SOURCES framelesshelper_win.cpp)
elseif(APPLE)
elseif(UNIX)
else()
endif()
else()
list(APPEND PUBLIC_HEADERS ${INCLUDE_PREFIX}/framelesshelper_qt.h)
list(APPEND PUBLIC_HEADERS_ALIAS ${INCLUDE_PREFIX}/FramelessHelper_Qt)
list(APPEND SOURCES framelesshelper_qt.cpp)
endif()
if(NOT FRAMELESSHELPER_NO_TITLEBAR)
list(APPEND PUBLIC_HEADERS ${INCLUDE_PREFIX}/chromepalette.h)
list(APPEND PUBLIC_HEADERS_ALIAS ${INCLUDE_PREFIX}/ChromePalette)

10
src/core/framelessconfig.cpp
View File

@ -56,7 +56,7 @@ struct FramelessConfigEntry
static constexpr const std::array<FramelessConfigEntry, static_cast<int>(Option::Last) + 1> FramelessOptionsTable =
{
FramelessConfigEntry{ "FRAMELESSHELPER_USE_CROSS_PLATFORM_QT_IMPLEMENTATION", "Options/UseCrossPlatformQtImplementation" },
//FramelessConfigEntry{ "FRAMELESSHELPER_USE_CROSS_PLATFORM_QT_IMPLEMENTATION", "Options/UseCrossPlatformQtImplementation" },
FramelessConfigEntry{ "FRAMELESSHELPER_FORCE_HIDE_WINDOW_FRAME_BORDER", "Options/ForceHideWindowFrameBorder" },
FramelessConfigEntry{ "FRAMELESSHELPER_FORCE_SHOW_WINDOW_FRAME_BORDER", "Options/ForceShowWindowFrameBorder" },
FramelessConfigEntry{ "FRAMELESSHELPER_DISABLE_WINDOWS_SNAP_LAYOUT", "Options/DisableWindowsSnapLayout" },
@ -85,14 +85,14 @@ Q_GLOBAL_STATIC(FramelessConfigData, g_framelessConfigData)
static inline void warnInappropriateOptions()
{
const FramelessConfig * const cfg = FramelessConfig::instance();
if (cfg->isSet(Option::UseCrossPlatformQtImplementation)) {
WARNING << "Option::UseCrossPlatformQtImplementation is deprecated and has no effect now. It will be removed in a future version.";
}
#ifdef Q_OS_WINDOWS
if (cfg->isSet(Option::DisableWindowsSnapLayout)) {
WARNING << "Option::DisableWindowsSnapLayout is deprecated and will removed in a future version. It has not effect now.";
WARNING << "Option::DisableWindowsSnapLayout is deprecated and has no effect now. It will be removed in a future version.";
}
#else
if (cfg->isSet(Option::UseCrossPlatformQtImplementation)) {
WARNING << "Option::UseCrossPlatformQtImplementation is default on non-Windows platforms.";
}
if (cfg->isSet(Option::ForceHideWindowFrameBorder)) {
WARNING << "Option::ForceHideWindowFrameBorder is only available on Windows.";
}

126
src/core/framelesshelper_qt.cpp
View File

@ -23,6 +23,9 @@
*/
#include "framelesshelper_qt.h"
#if !FRAMELESSHELPER_CONFIG(native_impl)
#include "framelessmanager.h"
#include "framelessmanager_p.h"
#include "framelessconfig_p.h"
@ -49,39 +52,36 @@ FRAMELESSHELPER_BEGIN_NAMESPACE
using namespace Global;
struct FramelessQtHelperData
using FramelessHelperQtPtr = std::shared_ptr<FramelessHelperQt>;
#define CreateFramelessHelperQt(...) std::make_shared<FramelessHelperQt>(__VA_ARGS__)
struct FramelessDataQt : public FramelessData
{
SystemParameters params = {};
FramelessHelperQt *eventFilter = nullptr;
FramelessHelperQtPtr eventFilter = nullptr;
bool cursorShapeChanged = false;
bool leftButtonPressed = false;
};
using FramelessDataQtPtr = std::shared_ptr<FramelessDataQt>;
#define CreateFramelessDataQt(...) std::make_shared<FramelessDataQt>(__VA_ARGS__)
using FramelessQtHelperInternal = QHash<WId, FramelessQtHelperData>;
Q_GLOBAL_STATIC(FramelessQtHelperInternal, g_framelessQtHelperData)
[[nodiscard]] FramelessDataQtPtr CreateEmptyDataQt() { return CreateFramelessDataQt(); }
FramelessHelperQt::FramelessHelperQt(QObject *parent) : QObject(parent) {}
FramelessHelperQt::~FramelessHelperQt() = default;
void FramelessHelperQt::addWindow(FramelessParamsConst params)
void FramelessHelperQt::addWindow(const QWindow *window)
{
Q_ASSERT(params);
if (!params) {
Q_ASSERT(window);
if (!window) {
return;
}
const WId windowId = params->getWindowId();
const auto it = g_framelessQtHelperData()->constFind(windowId);
if (it != g_framelessQtHelperData()->constEnd()) {
const auto data = std::dynamic_pointer_cast<FramelessDataQt>(FramelessManagerPrivate::getData(window));
Q_ASSERT(data->callbacks);
if (!data->callbacks) {
return;
}
FramelessQtHelperData data = {};
data.params = *params;
QWindow *window = params->getWindowHandle();
// Give it a parent so that it can be automatically deleted by Qt.
data.eventFilter = new FramelessHelperQt(window);
g_framelessQtHelperData()->insert(windowId, data);
data->eventFilter = CreateFramelessHelperQt();
const auto shouldApplyFramelessFlag = []() -> bool {
#ifdef Q_OS_MACOS
return false;
@ -95,31 +95,32 @@ void FramelessHelperQt::addWindow(FramelessParamsConst params)
window->setProperty("_q_mac_wantsLayer", 1);
#endif // (defined(Q_OS_MACOS) && (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)))
if (shouldApplyFramelessFlag) {
params->setWindowFlags(params->getWindowFlags() | Qt::FramelessWindowHint);
data->callbacks->setWindowFlags(data->callbacks->getWindowFlags() | Qt::FramelessWindowHint);
} else {
#if (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
std::ignore = Utils::tryHideSystemTitleBar(windowId, true);
std::ignore = Utils::tryHideSystemTitleBar(window, true);
#elif defined(Q_OS_MACOS)
Utils::setSystemTitleBarVisible(windowId, false);
Utils::setSystemTitleBarVisible(window, false);
#endif // Q_OS_LINUX
}
window->installEventFilter(data.eventFilter);
const_cast<QWindow *>(window)->installEventFilter(data->eventFilter.get());
FramelessHelperEnableThemeAware();
}
void FramelessHelperQt::removeWindow(const WId windowId)
void FramelessHelperQt::removeWindow(const QWindow *window)
{
Q_ASSERT(windowId);
if (!windowId) {
Q_ASSERT(window);
if (!window) {
return;
}
const auto it = g_framelessQtHelperData()->constFind(windowId);
if (it == g_framelessQtHelperData()->constEnd()) {
return;
const auto data = std::dynamic_pointer_cast<FramelessDataQt>(FramelessManagerPrivate::getData(window));
Q_ASSERT(data->eventFilter);
if (data->eventFilter) {
const_cast<QWindow *>(window)->removeEventFilter(data->eventFilter.get());
data->eventFilter = nullptr;
}
g_framelessQtHelperData()->erase(it);
#ifdef Q_OS_MACOS
Utils::removeWindowProxy(windowId);
Utils::removeWindowProxy(window);
#endif
}
@ -159,21 +160,15 @@ bool FramelessHelperQt::eventFilter(QObject *object, QEvent *event)
) {
return QObject::eventFilter(object, event);
}
const auto window = qobject_cast<QWindow *>(object);
const WId windowId = window->winId();
const auto it = g_framelessQtHelperData()->find(windowId);
if (it == g_framelessQtHelperData()->end()) {
return QObject::eventFilter(object, event);
}
const FramelessQtHelperData &data = it.value();
FramelessQtHelperData &muData = it.value();
const auto window = qobject_cast<const QWindow *>(object);
const auto data = std::dynamic_pointer_cast<FramelessDataQt>(FramelessManagerPrivate::getData(window));
#if (QT_VERSION >= QT_VERSION_CHECK(6, 6, 0))
if (type == QEvent::DevicePixelRatioChange)
#else // QT_VERSION < QT_VERSION_CHECK(6, 6, 0)
if (type == QEvent::ScreenChangeInternal)
#endif // (QT_VERSION >= QT_VERSION_CHECK(6, 6, 0))
{
data.params.forceChildrenRepaint(500);
data->callbacks->forceChildrenRepaint(500);
return QObject::eventFilter(object, event);
}
const auto mouseEvent = static_cast<QMouseEvent *>(event);
@ -185,64 +180,63 @@ bool FramelessHelperQt::eventFilter(QObject *object, QEvent *event)
const QPoint scenePos = mouseEvent->windowPos().toPoint();
const QPoint globalPos = mouseEvent->screenPos().toPoint();
#endif
const bool windowFixedSize = data.params.isWindowFixedSize();
const bool ignoreThisEvent = data.params.shouldIgnoreMouseEvents(scenePos);
const bool insideTitleBar = data.params.isInsideTitleBarDraggableArea(scenePos);
const bool dontOverrideCursor = data.params.getProperty(kDontOverrideCursorVar, false).toBool();
const bool dontToggleMaximize = data.params.getProperty(kDontToggleMaximizeVar, false).toBool();
const bool windowFixedSize = data->callbacks->isWindowFixedSize();
const bool ignoreThisEvent = data->callbacks->shouldIgnoreMouseEvents(scenePos);
const bool insideTitleBar = data->callbacks->isInsideTitleBarDraggableArea(scenePos);
const bool dontOverrideCursor = data->callbacks->getProperty(kDontOverrideCursorVar, false).toBool();
const bool dontToggleMaximize = data->callbacks->getProperty(kDontToggleMaximizeVar, false).toBool();
switch (type) {
case QEvent::MouseButtonPress: {
case QEvent::MouseButtonPress:
if (button == Qt::LeftButton) {
muData.leftButtonPressed = true;
data->leftButtonPressed = true;
if (!windowFixedSize) {
const Qt::Edges edges = Utils::calculateWindowEdges(window, scenePos);
if (edges != Qt::Edges{}) {
std::ignore = Utils::startSystemResize(window, edges, globalPos);
std::ignore = Utils::startSystemResize(const_cast<QWindow *>(window), edges, globalPos);
event->accept();
return true;
}
}
}
} break;
case QEvent::MouseButtonRelease: {
break;
case QEvent::MouseButtonRelease:
if (button == Qt::LeftButton) {
muData.leftButtonPressed = false;
}
if (button == Qt::RightButton) {
data->leftButtonPressed = false;
} else if (button == Qt::RightButton) {
if (!ignoreThisEvent && insideTitleBar) {
data.params.showSystemMenu(globalPos);
data->callbacks->showSystemMenu(globalPos);
event->accept();
return true;
}
}
} break;
case QEvent::MouseButtonDblClick: {
break;
case QEvent::MouseButtonDblClick:
if (!dontToggleMaximize && (button == Qt::LeftButton) && !windowFixedSize && !ignoreThisEvent && insideTitleBar) {
Qt::WindowState newWindowState = Qt::WindowNoState;
if (data.params.getWindowState() != Qt::WindowMaximized) {
if (data->callbacks->getWindowState() != Qt::WindowMaximized) {
newWindowState = Qt::WindowMaximized;
}
data.params.setWindowState(newWindowState);
data->callbacks->setWindowState(newWindowState);
event->accept();
return true;
}
} break;
break;
case QEvent::MouseMove: {
if (!dontOverrideCursor && !windowFixedSize) {
const Qt::CursorShape cs = Utils::calculateCursorShape(window, scenePos);
if (cs == Qt::ArrowCursor) {
if (data.cursorShapeChanged) {
data.params.unsetCursor();
muData.cursorShapeChanged = false;
if (data->cursorShapeChanged) {
data->callbacks->unsetCursor();
data->cursorShapeChanged = false;
}
} else {
data.params.setCursor(cs);
muData.cursorShapeChanged = true;
data->callbacks->setCursor(cs);
data->cursorShapeChanged = true;
}
}
if (data.leftButtonPressed) {
if (data->leftButtonPressed) {
if (!ignoreThisEvent && insideTitleBar) {
std::ignore = Utils::startSystemMove(window, globalPos);
std::ignore = Utils::startSystemMove(const_cast<QWindow *>(window), globalPos);
event->accept();
return true;
}
@ -255,3 +249,5 @@ bool FramelessHelperQt::eventFilter(QObject *object, QEvent *event)
}
FRAMELESSHELPER_END_NAMESPACE
#endif // !native_impl

247
src/core/framelesshelper_win.cpp
View File

@ -26,6 +26,8 @@
#ifdef Q_OS_WINDOWS
#if FRAMELESSHELPER_CONFIG(native_impl)
#include "framelessmanager.h"
#include "framelessmanager_p.h"
#include "framelessconfig_p.h"
@ -100,9 +102,8 @@ enum class WindowPart : quint8
TitleBar
};
struct FramelessWin32HelperData
struct FramelessDataWin : public FramelessData
{
SystemParameters params = {};
// Store the last hit test result, it's helpful to handle WM_MOUSEMOVE and WM_NCMOUSELEAVE.
WindowPart lastHitTestResult = WindowPart::Outside;
// True if we blocked a WM_MOUSELEAVE when mouse moves on chrome button, false when a
@ -112,36 +113,39 @@ struct FramelessWin32HelperData
#if (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
QRect restoreGeometry = {};
#endif // (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
};
struct FramelessWin32HelperInternal
FramelessDataWin();
~FramelessDataWin() override;
};
using FramelessDataWinPtr = std::shared_ptr<FramelessDataWin>;
FramelessDataWin::FramelessDataWin() = default;
FramelessDataWin::~FramelessDataWin() = default;
[[nodiscard]] FramelessDataPtr FramelessData::create()
{
std::unique_ptr<FramelessHelperWin> nativeEventFilter = nullptr;
QHash<WId, FramelessWin32HelperData> data = {};
return std::make_shared<FramelessDataWin>();
}
[[nodiscard]] static inline FramelessDataWinPtr tryGetData(const QObject *window)
{
Q_ASSERT(window);
if (!window) {
return nullptr;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return nullptr;
}
return std::dynamic_pointer_cast<FramelessDataWin>(data);
}
struct FramelessHelperWinInternal
{
std::unique_ptr<FramelessHelperWin> eventFilter = nullptr;
};
Q_GLOBAL_STATIC(FramelessWin32HelperInternal, g_framelessWin32HelperData)
[[nodiscard]] extern bool operator==(const POINT &lhs, const POINT &rhs) noexcept;
[[nodiscard]] extern bool operator!=(const POINT &lhs, const POINT &rhs) noexcept;
[[nodiscard]] extern bool operator==(const SIZE &lhs, const SIZE &rhs) noexcept;
[[nodiscard]] extern bool operator!=(const SIZE &lhs, const SIZE &rhs) noexcept;
[[nodiscard]] extern bool operator==(const RECT &lhs, const RECT &rhs) noexcept;
[[nodiscard]] extern bool operator!=(const RECT &lhs, const RECT &rhs) noexcept;
[[nodiscard]] extern QPoint point2qpoint(const POINT &point);
[[nodiscard]] extern POINT qpoint2point(const QPoint &point);
[[nodiscard]] extern QSize size2qsize(const SIZE &size);
[[nodiscard]] extern SIZE qsize2size(const QSize &size);
[[nodiscard]] extern QRect rect2qrect(const RECT &rect);
[[nodiscard]] extern RECT qrect2rect(const QRect &qrect);
[[nodiscard]] extern QString hwnd2str(const WId windowId);
[[nodiscard]] extern QString hwnd2str(const HWND hwnd);
Q_GLOBAL_STATIC(FramelessHelperWinInternal, g_internalData)
[[nodiscard]] extern std::optional<MONITORINFOEXW> getMonitorForWindow(const HWND hwnd);
@ -212,90 +216,77 @@ FramelessHelperWin::FramelessHelperWin() : QAbstractNativeEventFilter() {}
FramelessHelperWin::~FramelessHelperWin() = default;
void FramelessHelperWin::addWindow(FramelessParamsConst params)
void FramelessHelperWin::addWindow(const QObject *window)
{
Q_ASSERT(params);
if (!params) {
Q_ASSERT(window);
if (!window) {
return;
}
const WId windowId = params->getWindowId();
const auto it = g_framelessWin32HelperData()->data.constFind(windowId);
if (it != g_framelessWin32HelperData()->data.constEnd()) {
const FramelessDataWinPtr data = tryGetData(window);
if (!data || data->frameless || !data->callbacks) {
return;
}
FramelessWin32HelperData data = {};
data.params = *params;
data.dpi = {Utils::getWindowDpi(windowId, true), Utils::getWindowDpi(windowId, false)};
g_framelessWin32HelperData()->data.insert(windowId, data);
if (!g_framelessWin32HelperData()->nativeEventFilter) {
g_framelessWin32HelperData()->nativeEventFilter = std::make_unique<FramelessHelperWin>();
qApp->installNativeEventFilter(g_framelessWin32HelperData()->nativeEventFilter.get());
QWindow *qWindow = data->callbacks->getWindowHandle();
Q_ASSERT(qWindow);
if (!qWindow) {
return;
}
DEBUG.noquote() << "The DPI of window" << hwnd2str(windowId) << "is" << data.dpi;
const QWindow *window = params->getWindowHandle();
data->frameless = true;
data->dpi = Dpi{ Utils::getWindowDpi(data->windowId, true), Utils::getWindowDpi(data->windowId, false) };
DEBUG.noquote() << "The DPI of window" << hwnd2str(data->windowId) << "is" << data->dpi;
// Remove the bad window styles added by Qt (it's not that "bad" though).
std::ignore = Utils::maybeFixupQtInternals(windowId);
std::ignore = Utils::maybeFixupQtInternals(data->windowId);
#if 0
params->setWindowFlags(params->getWindowFlags() | Qt::FramelessWindowHint);
data->callbacks->setWindowFlags(data->callbacks->getWindowFlags() | Qt::FramelessWindowHint);
#else
// Qt maintains a frame margin internally, we need to update it accordingly
// otherwise we'll get lots of warning messages when we change the window
// geometry, it will also affect the final window geometry because QPA will
// always take it into account when setting window size and position.
std::ignore = Utils::updateInternalWindowFrameMargins(const_cast<QWindow *>(window), true);
std::ignore = Utils::updateInternalWindowFrameMargins(qWindow, true);
#endif
// Tell DWM our preferred frame margin.
std::ignore = Utils::updateWindowFrameMargins(windowId, false);
std::ignore = Utils::updateWindowFrameMargins(data->windowId, false);
// Tell DWM we don't use the window icon/caption/sysmenu, don't draw them.
std::ignore = Utils::hideOriginalTitleBarElements(windowId);
std::ignore = Utils::hideOriginalTitleBarElements(data->windowId);
// Without this hack, the child windows can't get DPI change messages from
// Windows, which means only the top level windows can be scaled to the correct
// size, we of course don't want such thing from happening.
std::ignore = Utils::fixupChildWindowsDpiMessage(windowId);
if (Utils::isWindowAccelerated(window) && Utils::isWindowTransparent(window)) {
std::ignore = Utils::updateFramebufferTransparency(windowId);
std::ignore = Utils::fixupChildWindowsDpiMessage(data->windowId);
if (Utils::isWindowAccelerated(qWindow) && Utils::isWindowTransparent(qWindow)) {
std::ignore = Utils::updateFramebufferTransparency(data->windowId);
}
if (WindowsVersionHelper::isWin10RS1OrGreater()) {
// Tell DWM we may need dark theme non-client area (title bar & frame border).
FramelessHelperEnableThemeAware();
if (WindowsVersionHelper::isWin10RS5OrGreater()) {
const bool dark = (FramelessManager::instance()->systemTheme() == SystemTheme::Dark);
const auto isWidget = [params]() -> bool {
const QObject *widget = params->getWidgetHandle();
const auto isWidget = [data]() -> bool {
const QObject *widget = data->callbacks->getWidgetHandle();
return (widget && widget->isWidgetType());
}();
if (!isWidget) {
// Tell UXTheme we may need dark theme controls.
// Causes some QtWidgets paint incorrectly, so only apply to Qt Quick applications.
std::ignore = Utils::updateGlobalWin32ControlsTheme(windowId, dark);
std::ignore = Utils::updateGlobalWin32ControlsTheme(data->windowId, dark);
}
std::ignore = Utils::refreshWin32ThemeResources(windowId, dark);
std::ignore = Utils::refreshWin32ThemeResources(data->windowId, dark);
if (WindowsVersionHelper::isWin11OrGreater()) {
if (FramelessConfig::instance()->isSet(Option::WindowUseSquareCorners)) {
std::ignore = Utils::setCornerStyleForWindow(windowId, WindowCornerStyle::Square);
std::ignore = Utils::setCornerStyleForWindow(data->windowId, WindowCornerStyle::Square);
}
}
}
}
if (!g_internalData()->eventFilter) {
g_internalData()->eventFilter = std::make_unique<FramelessHelperWin>();
qApp->installNativeEventFilter(g_internalData()->eventFilter.get());
}
}
void FramelessHelperWin::removeWindow(const WId windowId)
void FramelessHelperWin::removeWindow(const QObject *window)
{
Q_ASSERT(windowId);
if (!windowId) {
return;
}
const auto it = g_framelessWin32HelperData()->data.constFind(windowId);
if (it == g_framelessWin32HelperData()->data.constEnd()) {
return;
}
g_framelessWin32HelperData()->data.erase(it);
if (g_framelessWin32HelperData()->data.isEmpty()) {
if (g_framelessWin32HelperData()->nativeEventFilter) {
qApp->removeNativeEventFilter(g_framelessWin32HelperData()->nativeEventFilter.get());
g_framelessWin32HelperData()->nativeEventFilter.reset();
}
}
Q_UNUSED(window);
}
bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *message, QT_NATIVE_EVENT_RESULT_TYPE *result)
@ -317,15 +308,10 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// Anyway, we should skip the entire processing in this case.
return false;
}
const auto windowId = reinterpret_cast<WId>(hWnd);
// Let's be extra safe.
if (!Utils::isValidWindow(windowId, false, true)) {
return false;
}
const UINT uMsg = msg->message;
const UINT uMsg = msg->message;
// We should skip these messages otherwise we will get crashes.
// WM_QUIT won't be posted to the WindowProc function.
// NOTE: WM_QUIT won't be posted to the WindowProc function.
switch (uMsg) {
case WM_CLOSE:
case WM_DESTROY:
@ -338,19 +324,30 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
break;
}
const auto it = g_framelessWin32HelperData()->data.find(windowId);
if (it == g_framelessWin32HelperData()->data.end()) {
const auto windowId = reinterpret_cast<WId>(hWnd);
// Let's be extra safe.
if (!Utils::isValidWindow(windowId, false, true)) {
return false;
}
const FramelessWin32HelperData &data = it.value();
FramelessWin32HelperData &muData = it.value();
const QWindow *window = data.params.getWindowHandle();
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataWinPtr data = tryGetData(window);
if (!data || !data->frameless || !data->callbacks) {
return false;
}
QWindow *qWindow = data->callbacks->getWindowHandle();
const bool frameBorderVisible = Utils::isWindowFrameBorderVisible();
const WPARAM wParam = msg->wParam;
const LPARAM lParam = msg->lParam;
#if (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
const auto updateRestoreGeometry = [windowId, &data, &muData](const bool ignoreWindowState) -> void {
const auto updateRestoreGeometry = [windowId, &data](const bool ignoreWindowState) -> void {
if (!ignoreWindowState && !Utils::isWindowNoState(windowId)) {
return;
}
@ -359,10 +356,10 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
WARNING << "The calculated restore geometry is invalid.";
return;
}
if (Utils::isValidGeometry(data.restoreGeometry) && (data.restoreGeometry == rect)) {
if (Utils::isValidGeometry(data->restoreGeometry) && (data->restoreGeometry == rect)) {
return;
}
muData.restoreGeometry = rect;
data->restoreGeometry = rect;
};
#endif // (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
@ -463,15 +460,15 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// the reason above, and these superfluous mouse leave events cause Qt to think the
// mouse has left the control, and thus we actually lost the hover state.
// So we filter out these superfluous mouse leave events here to avoid this issue.
const QPoint qtScenePos = Utils::fromNativeLocalPosition(window, QPoint{ msg->pt.x, msg->pt.y });
const QPoint qtScenePos = Utils::fromNativeLocalPosition(qWindow, QPoint{ msg->pt.x, msg->pt.y });
SystemButtonType dummy = SystemButtonType::Unknown;
if (data.params.isInsideSystemButtons(qtScenePos, &dummy)) {
muData.mouseLeaveBlocked = true;
if (data->callbacks->isInsideSystemButtons(qtScenePos, &dummy)) {
data->mouseLeaveBlocked = true;
*result = FALSE;
return true;
}
}
muData.mouseLeaveBlocked = false;
data->mouseLeaveBlocked = false;
}
switch (uMsg) {
@ -809,8 +806,8 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// color, our homemade top border can almost have exactly the same
// appearance with the system's one.
const auto hitTestRecorder = qScopeGuard([&muData, &result](){
muData.lastHitTestResult = getHittedWindowPart(*result);
const auto hitTestRecorder = qScopeGuard([&data, &result](){
data->lastHitTestResult = getHittedWindowPart(*result);
});
const auto nativeGlobalPos = POINT{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
@ -828,9 +825,9 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
const auto clientWidth = RECT_WIDTH(clientRect);
const auto clientHeight = RECT_HEIGHT(clientRect);
const QPoint qtScenePos = Utils::fromNativeLocalPosition(window, QPoint(nativeLocalPos.x, nativeLocalPos.y));
const QPoint qtScenePos = Utils::fromNativeLocalPosition(qWindow, QPoint(nativeLocalPos.x, nativeLocalPos.y));
SystemButtonType sysButtonType = SystemButtonType::Unknown;
if (data.params.isInsideSystemButtons(qtScenePos, &sysButtonType)) {
if (data->callbacks->isInsideSystemButtons(qtScenePos, &sysButtonType)) {
// Even if the mouse is inside the chrome button area now, we should still allow the user
// to be able to resize the window with the top or right window border, this is also the
// normal behavior of a native Win32 window.
@ -879,10 +876,10 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
const bool full = Utils::isFullScreen(windowId);
const int frameSizeY = Utils::getResizeBorderThickness(windowId, false, true);
const bool isTop = (nativeLocalPos.y < frameSizeY);
const bool isTitleBar = data.params.isInsideTitleBarDraggableArea(qtScenePos);
const bool isFixedSize = data.params.isWindowFixedSize();
const bool dontOverrideCursor = data.params.getProperty(kDontOverrideCursorVar, false).toBool();
const bool dontToggleMaximize = data.params.getProperty(kDontToggleMaximizeVar, false).toBool();
const bool isTitleBar = data->callbacks->isInsideTitleBarDraggableArea(qtScenePos);
const bool isFixedSize = data->callbacks->isWindowFixedSize();
const bool dontOverrideCursor = data->callbacks->getProperty(kDontOverrideCursorVar, false).toBool();
const bool dontToggleMaximize = data->callbacks->getProperty(kDontToggleMaximizeVar, false).toBool();
if (dontToggleMaximize) {
static bool once = false;
@ -993,8 +990,8 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
return true;
}
case WM_MOUSEMOVE:
if ((data.lastHitTestResult != WindowPart::ChromeButton) && data.mouseLeaveBlocked) {
muData.mouseLeaveBlocked = false;
if ((data->lastHitTestResult != WindowPart::ChromeButton) && data->mouseLeaveBlocked) {
data->mouseLeaveBlocked = false;
std::ignore = requestForMouseLeaveMessage(hWnd, false);
}
break;
@ -1017,11 +1014,11 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
case WM_NCPOINTERUP:
#endif
case WM_NCMOUSEHOVER: {
const WindowPart currentWindowPart = data.lastHitTestResult;
const WindowPart currentWindowPart = data->lastHitTestResult;
if (uMsg == WM_NCMOUSEMOVE) {
if (currentWindowPart != WindowPart::ChromeButton) {
std::ignore = data.params.resetQtGrabbedControl();
if (muData.mouseLeaveBlocked) {
std::ignore = data->callbacks->resetQtGrabbedControl();
if (data->mouseLeaveBlocked) {
emulateClientAreaMessage(WM_NCMOUSELEAVE);
}
}
@ -1032,12 +1029,14 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// 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`.
muData.lastHitTestResult = WindowPart::Outside;
data->lastHitTestResult = WindowPart::Outside;
}
if (currentWindowPart == WindowPart::ChromeButton) {
emulateClientAreaMessage();
if (uMsg == WM_NCMOUSEMOVE) {
// ### FIXME: Calling DefWindowProc() here is really dangerous, investigate how
// to avoid doing this.
*result = ::DefWindowProcW(hWnd, WM_NCMOUSEMOVE, wParam, lParam);
} else {
*result = (((uMsg >= WM_NCXBUTTONDOWN) && (uMsg <= WM_NCXBUTTONDBLCLK)) ? TRUE : FALSE);
@ -1046,18 +1045,18 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
}
} break;
case WM_NCMOUSELEAVE: {
const WindowPart currentWindowPart = data.lastHitTestResult;
const WindowPart currentWindowPart = data->lastHitTestResult;
if (currentWindowPart == WindowPart::ChromeButton) {
// If we press on the chrome button and move mouse, Windows will take the 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.
if (muData.mouseLeaveBlocked) {
muData.mouseLeaveBlocked = false;
if (data->mouseLeaveBlocked) {
data->mouseLeaveBlocked = false;
std::ignore = requestForMouseLeaveMessage(hWnd, false);
}
} else {
if (data.mouseLeaveBlocked) {
if (data->mouseLeaveBlocked) {
// The mouse is moving from the chrome button to other non-client area, we should
// emulate a WM_MOUSELEAVE message to reset the button state.
emulateClientAreaMessage(WM_NCMOUSELEAVE);
@ -1069,7 +1068,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// the mouse leaves window from client area and enters window from non-client area,
// but it has no bad effect.
std::ignore = data.params.resetQtGrabbedControl();
std::ignore = data->callbacks->resetQtGrabbedControl();
}
}
} break;
@ -1083,9 +1082,9 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
// of the application a lot.
const auto windowPos = reinterpret_cast<LPWINDOWPOS>(lParam);
const QRect suggestedFrameGeometry{ windowPos->x, windowPos->y, windowPos->cx, windowPos->cy };
const QMargins frameMargins = (Utils::getWindowSystemFrameMargins(windowId) + Utils::getWindowCustomFrameMargins(window));
const QMargins frameMargins = (Utils::getWindowSystemFrameMargins(windowId) + Utils::getWindowCustomFrameMargins(qWindow));
const QRect suggestedGeometry = (suggestedFrameGeometry - frameMargins);
if (Utils::toNativePixels(window, window->size()) != suggestedGeometry.size()) {
if (Utils::toNativePixels(qWindow, window->size()) != suggestedGeometry.size()) {
windowPos->flags |= SWP_NOCOPYBITS;
}
} break;
@ -1125,7 +1124,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
}
#endif // (QT_VERSION <= QT_VERSION_CHECK(6, 4, 2))
case WM_DPICHANGED: {
const Dpi oldDpi = data.dpi;
const Dpi oldDpi = data->dpi;
const Dpi newDpi = {UINT(LOWORD(wParam)), UINT(HIWORD(wParam))};
if (Q_UNLIKELY(newDpi == oldDpi)) {
WARNING << "Wrong WM_DPICHANGED received: same DPI.";
@ -1133,14 +1132,14 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
}
DEBUG.noquote() << "New DPI for window" << hwnd2str(hWnd)
<< "is" << newDpi << "(was" << oldDpi << ").";
muData.dpi = newDpi;
data->dpi = newDpi;
#if (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
if (Utils::isValidGeometry(data.restoreGeometry)) {
if (Utils::isValidGeometry(data->restoreGeometry)) {
// Update the window size only. The position should not be changed.
muData.restoreGeometry.setSize(Utils::rescaleSize(data.restoreGeometry.size(), oldDpi.x, newDpi.x));
data->restoreGeometry.setSize(Utils::rescaleSize(data->restoreGeometry.size(), oldDpi.x, newDpi.x));
}
#endif // (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
data.params.forceChildrenRepaint(500);
data->callbacks->forceChildrenRepaint(500);
} break;
case WM_DWMCOMPOSITIONCHANGED:
// Re-apply the custom window frame if recovered from the basic theme.
@ -1155,7 +1154,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
if (wParam != SIZE_MAXIMIZED) {
break;
}
if (!Utils::isValidGeometry(data.restoreGeometry)) {
if (!Utils::isValidGeometry(data->restoreGeometry)) {
updateRestoreGeometry(true);
break;
}
@ -1167,11 +1166,11 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
break;
}
// The restore geometry is correct, no need to bother.
if (rect2qrect(wp.rcNormalPosition) == data.restoreGeometry) {
if (rect2qrect(wp.rcNormalPosition) == data->restoreGeometry) {
break;
}
// OK, the restore geometry is wrong, let's correct it then :)
wp.rcNormalPosition = qrect2rect(data.restoreGeometry);
wp.rcNormalPosition = qrect2rect(data->restoreGeometry);
if (::SetWindowPlacement(hWnd, &wp) == FALSE) {
WARNING << Utils::getSystemErrorMessage(kSetWindowPlacement);
}
@ -1268,7 +1267,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
}
if ((uMsg == WM_DWMCOMPOSITIONCHANGED) || (uMsg == WM_DWMCOLORIZATIONCOLORCHANGED)) {
if (Utils::isWindowAccelerated(window) && Utils::isWindowTransparent(window)) {
if (Utils::isWindowAccelerated(qWindow) && Utils::isWindowTransparent(qWindow)) {
std::ignore = Utils::updateFramebufferTransparency(windowId);
}
}
@ -1284,7 +1283,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
if (WindowsVersionHelper::isWin10RS5OrGreater()) {
const bool dark = (FramelessManager::instance()->systemTheme() == SystemTheme::Dark);
const auto isWidget = [&data]() -> bool {
const auto widget = data.params.getWidgetHandle();
const auto widget = data->callbacks->getWidgetHandle();
return (widget && widget->isWidgetType());
}();
if (!isWidget) {
@ -1315,4 +1314,6 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
FRAMELESSHELPER_END_NAMESPACE
#endif // native_impl
#endif // Q_OS_WINDOWS

17
src/core/framelesshelpercore_global.cpp
View File

@ -114,6 +114,23 @@ using namespace Global;
static_assert(std::size(WindowsVersions) == (static_cast<int>(WindowsVersion::Latest) + 1));
#endif
FramelessCallbacks::FramelessCallbacks() = default;
FramelessCallbacks::~FramelessCallbacks() = default;
FramelessCallbacksPtr FramelessCallbacks::create()
{
return std::make_shared<FramelessCallbacks>();
}
FramelessExtraData::FramelessExtraData() = default;
FramelessExtraData::~FramelessExtraData() = default;
FramelessData::FramelessData() = default;
FramelessData::~FramelessData() = default;
void FramelessHelperCoreInitialize()
{
static bool inited = false;

277
src/core/framelessmanager.cpp
View File

@ -24,12 +24,20 @@
#include "framelessmanager.h"
#include "framelessmanager_p.h"
#include "framelesshelper_qt.h"
#include "framelessconfig_p.h"
#include "framelesshelpercore_global_p.h"
#include "utils.h"
#if FRAMELESSHELPER_CONFIG(native_impl)
# ifdef Q_OS_WINDOWS
# include "framelesshelper_win.h"
# elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
# elif defined(Q_OS_MACOS)
# else
# endif
#else
# include "framelesshelper_qt.h"
#endif
#include "framelessconfig_p.h"
#include "utils.h"
#ifdef Q_OS_WINDOWS
# include "winverhelper_p.h"
#endif
#include <QtCore/qvariant.h>
@ -59,12 +67,26 @@ FRAMELESSHELPER_BEGIN_NAMESPACE
using namespace Global;
using FramelessManagerData = QList<WId>;
Q_GLOBAL_STATIC(FramelessManagerData, g_framelessManagerData)
static constexpr const int kEventDelayInterval = 1000;
struct InternalData
{
FramelessDataHash dataMap = {};
QHash<WId, QObject *> windowMap = {};
InternalData();
~InternalData();
private:
Q_DISABLE_COPY_MOVE(InternalData)
};
InternalData::InternalData() = default;
InternalData::~InternalData() = default;
Q_GLOBAL_STATIC(InternalData, g_internalData)
#if FRAMELESSHELPER_CONFIG(bundle_resource)
[[nodiscard]] static inline QString iconFontFamilyName()
{
@ -83,16 +105,65 @@ static constexpr const int kEventDelayInterval = 1000;
}
#endif
[[nodiscard]] static inline bool usePureQtImplementation()
class WinIdUpdater : public QObject
{
static const auto result = []() -> bool {
#ifdef Q_OS_WINDOWS
return FramelessConfig::instance()->isSet(Option::UseCrossPlatformQtImplementation);
#else
return true;
#endif
}();
return result;
Q_OBJECT
Q_DISABLE_COPY_MOVE(WinIdUpdater)
Q_PROPERTY(QObject* window READ window WRITE setWindow NOTIFY windowChanged FINAL)
public:
explicit WinIdUpdater(QObject *parent = nullptr);
~WinIdUpdater() override;
Q_NODISCARD QObject *window() const;
void setWindow(QObject *window);
Q_SIGNALS:
void windowChanged();
protected:
Q_NODISCARD bool eventFilter(QObject *object, QEvent *event) override;
private:
QObject *m_window = nullptr;
};
WinIdUpdater::WinIdUpdater(QObject *parent) : QObject(parent)
{
}
WinIdUpdater::~WinIdUpdater() = default;
QObject *WinIdUpdater::window() const
{
return m_window;
}
void WinIdUpdater::setWindow(QObject *window)
{
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
if (!window || !(window->isWidgetType() || window->isWindowType()) || (m_window == window)) {
return;
}
m_window = window;
Q_EMIT windowChanged();
}
bool WinIdUpdater::eventFilter(QObject *object, QEvent *event)
{
if (m_window && object && (object == m_window) && (event->type() == QEvent::WinIdChange)) {
if (const FramelessDataPtr data = FramelessManagerPrivate::getData(m_window)) {
if (data->frameless && data->callbacks) {
const WId windowId = data->callbacks->getWindowId();
Q_ASSERT(windowId);
if (windowId) {
FramelessManagerPrivate::updateWindowId(m_window, windowId);
}
}
}
}
return false;
}
FramelessManagerPrivate::FramelessManagerPrivate(FramelessManager *q) : QObject(q)
@ -133,7 +204,7 @@ void FramelessManagerPrivate::initializeIconFont()
return;
}
inited = true;
framelesshelpercore_initResource();
FramelessHelperCoreInitResource();
// We always register this font because it's our only fallback.
const int id = QFontDatabase::addApplicationFont(FRAMELESSHELPER_STRING_LITERAL(":/org.wangwenx190.FramelessHelper/resources/fonts/iconfont.ttf"));
if (id < 0) {
@ -229,6 +300,82 @@ void FramelessManagerPrivate::doNotifyWallpaperHasChangedOrNot()
}
}
FramelessDataPtr FramelessManagerPrivate::getData(const QObject *window)
{
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
if (!window || !(window->isWidgetType() || window->isWindowType())) {
return nullptr;
}
return g_internalData()->dataMap.value(const_cast<QObject *>(window));
}
FramelessDataPtr FramelessManagerPrivate::createData(const QObject *window, const WId windowId)
{
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
Q_ASSERT(windowId);
if (!window || !(window->isWidgetType() || window->isWindowType()) || !windowId) {
return nullptr;
}
const auto win = const_cast<QObject *>(window);
auto it = g_internalData()->dataMap.find(win);
if (it == g_internalData()->dataMap.end()) {
FramelessDataPtr data = FramelessData::create();
data->window = win;
data->windowId = windowId;
const auto winIdUpdater = new WinIdUpdater(data->window);
winIdUpdater->setWindow(data->window);
data->window->installEventFilter(winIdUpdater);
data->winIdUpdater = winIdUpdater;
it = g_internalData()->dataMap.insert(win, data);
g_internalData()->windowMap.insert(windowId, win);
}
return it.value();
}
WId FramelessManagerPrivate::getWindowId(const QObject *window)
{
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
if (!window || !(window->isWidgetType() || window->isWindowType())) {
return 0;
}
if (const FramelessDataPtr data = getData(window)) {
return data->windowId;
}
return 0;
}
QObject *FramelessManagerPrivate::getWindow(const WId windowId)
{
Q_ASSERT(windowId);
if (!windowId) {
return nullptr;
}
return g_internalData()->windowMap.value(windowId);
}
void FramelessManagerPrivate::updateWindowId(const QObject *window, const WId newWindowId)
{
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
Q_ASSERT(newWindowId);
if (!window || !(window->isWidgetType() || window->isWindowType()) || !newWindowId) {
return;
}
const auto win = const_cast<QObject *>(window);
const FramelessDataPtr data = g_internalData()->dataMap.value(win);
Q_ASSERT(data);
if (!data) {
return;
}
const WId oldWindowId = data->windowId;
data->windowId = newWindowId;
g_internalData()->windowMap.remove(oldWindowId);
g_internalData()->windowMap.insert(newWindowId, win);
}
bool FramelessManagerPrivate::isThemeOverrided() const
{
return (overrideTheme.value_or(SystemTheme::Unknown) != SystemTheme::Unknown);
@ -342,51 +489,85 @@ void FramelessManager::setOverrideTheme(const SystemTheme theme)
Q_EMIT systemThemeChanged();
}
void FramelessManager::addWindow(FramelessParamsConst params)
bool FramelessManager::addWindow(const QObject *window, const WId windowId)
{
Q_ASSERT(params);
if (!params) {
return;
Q_ASSERT(window);
Q_ASSERT(window->isWidgetType() || window->isWindowType());
Q_ASSERT(windowId);
if (!window || !(window->isWidgetType() || window->isWindowType()) || !windowId) {
return false;
}
const WId windowId = params->getWindowId();
if (g_framelessManagerData()->contains(windowId)) {
return;
FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (data && data->frameless) {
return false;
}
g_framelessManagerData()->append(windowId);
static const bool pureQt = usePureQtImplementation();
if (pureQt) {
FramelessHelperQt::addWindow(params);
if (!data) {
data = FramelessData::create();
data->window = const_cast<QObject *>(window);
data->windowId = windowId;
g_internalData()->dataMap.insert(data->window, data);
g_internalData()->windowMap.insert(windowId, data->window);
}
if (!data->winIdUpdater) {
const auto winIdUpdater = new WinIdUpdater(data->window);
winIdUpdater->setWindow(data->window);
data->window->installEventFilter(winIdUpdater);
data->winIdUpdater = winIdUpdater;
}
#if FRAMELESSHELPER_CONFIG(native_impl)
# ifdef Q_OS_WINDOWS
if (!pureQt) {
FramelessHelperWin::addWindow(params);
}
std::ignore = Utils::installWindowProcHook(windowId, params);
std::ignore = Utils::installWindowProcHook(windowId);
FramelessHelperWin::addWindow(window);
# elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
# elif defined(Q_OS_MACOS)
# else
# endif
connect(params->getWindowHandle(), &QWindow::destroyed, FramelessManager::instance(), [this, windowId](){ removeWindow(windowId); });
#else
FramelessHelperQt::addWindow(window);
#endif
connect(window, &QObject::destroyed, FramelessManager::instance(), [this, window](){ std::ignore = removeWindow(window); });
return true;
}
void FramelessManager::removeWindow(const WId windowId)
bool FramelessManager::removeWindow(const QObject *window)
{
Q_ASSERT(windowId);
if (!windowId) {
return;
Q_ASSERT(window);
if (!window) {
return false;
}
if (!g_framelessManagerData()->contains(windowId)) {
return;
const auto it = g_internalData()->dataMap.constFind(const_cast<QObject *>(window));
if (it == g_internalData()->dataMap.constEnd()) {
return false;
}
g_framelessManagerData()->removeAll(windowId);
static const bool pureQt = usePureQtImplementation();
if (pureQt) {
FramelessHelperQt::removeWindow(windowId);
const FramelessDataPtr data = it.value();
Q_ASSERT(data);
Q_ASSERT(data->window);
Q_ASSERT(data->windowId);
if (!data || !data->window || !data->windowId) {
return false;
}
if (data->winIdUpdater) {
data->window->removeEventFilter(data->winIdUpdater);
data->winIdUpdater->deleteLater();
data->winIdUpdater = nullptr;
}
#if FRAMELESSHELPER_CONFIG(native_impl)
# ifdef Q_OS_WINDOWS
if (!pureQt) {
FramelessHelperWin::removeWindow(windowId);
}
std::ignore = Utils::uninstallWindowProcHook(windowId);
std::ignore = Utils::removeMicaWindow(windowId);
FramelessHelperWin::removeWindow(window);
std::ignore = Utils::uninstallWindowProcHook(data->windowId);
std::ignore = Utils::removeMicaWindow(data->windowId);
# elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
# elif defined(Q_OS_MACOS)
# else
# endif
#else
FramelessHelperQt::removeWindow(window);
#endif
g_internalData()->dataMap.erase(it);
g_internalData()->windowMap.remove(data->windowId);
return true;
}
FRAMELESSHELPER_END_NAMESPACE
#include "framelessmanager.moc"

7
src/core/micamaterial.cpp
View File

@ -62,11 +62,6 @@ FRAMELESSHELPER_BEGIN_NAMESPACE
# define CRITICAL QT_NO_QDEBUG_MACRO()
#endif
DECLARE_SIZE_COMPARE_OPERATORS(QSize, QSize)
DECLARE_SIZE_COMPARE_OPERATORS(QSizeF, QSizeF)
DECLARE_SIZE_COMPARE_OPERATORS(QSize, QSizeF)
DECLARE_SIZE_COMPARE_OPERATORS(QSizeF, QSize)
using namespace Global;
[[maybe_unused]] static constexpr const QSize kMaximumPictureSize = { 1920, 1080 };
@ -657,7 +652,7 @@ void MicaMaterialPrivate::maybeGenerateBlurredWallpaper(const bool force)
void MicaMaterialPrivate::updateMaterialBrush()
{
#if FRAMELESSHELPER_CONFIG(bundle_resource)
framelesshelpercore_initResource();
FramelessHelperCoreInitResource();
static const QImage noiseTexture = QImage(FRAMELESSHELPER_STRING_LITERAL(":/org.wangwenx190.FramelessHelper/resources/images/noise.png"));
#endif // FRAMELESSHELPER_CORE_NO_BUNDLE_RESOURCE
QImage micaTexture = QImage(QSize(64, 64), kDefaultImageFormat);

86
src/core/platformsupport_win.cpp
View File

@ -50,11 +50,11 @@ _GetWindowCompositionAttribute(const HWND hWnd, PWINDOWCOMPOSITIONATTRIBDATA pvD
Q_ASSERT(hWnd);
Q_ASSERT(pvData);
if (!hWnd || !pvData) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!API_USER_AVAILABLE(GetWindowCompositionAttribute)) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return API_CALL_FUNCTION4(user32, GetWindowCompositionAttribute, hWnd, pvData);
@ -66,11 +66,11 @@ _SetWindowCompositionAttribute(const HWND hWnd, PWINDOWCOMPOSITIONATTRIBDATA pvD
Q_ASSERT(hWnd);
Q_ASSERT(pvData);
if (!hWnd || !pvData) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!API_USER_AVAILABLE(SetWindowCompositionAttribute)) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return API_CALL_FUNCTION4(user32, SetWindowCompositionAttribute, hWnd, pvData);
@ -111,14 +111,14 @@ _ShouldAppsUseDarkMode(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pShouldAppsUseDarkMode
= reinterpret_cast<ShouldAppsUseDarkModePtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(132)));
if (!pShouldAppsUseDarkMode) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pShouldAppsUseDarkMode();
@ -129,19 +129,19 @@ _AllowDarkModeForWindow(const HWND hWnd, const BOOL bAllow)
{
Q_ASSERT(hWnd);
if (!hWnd) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pAllowDarkModeForWindow
= reinterpret_cast<AllowDarkModeForWindowPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(133)));
if (!pAllowDarkModeForWindow) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pAllowDarkModeForWindow(hWnd, bAllow);
@ -152,14 +152,14 @@ _AllowDarkModeForApp(const BOOL bAllow)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pAllowDarkModeForApp
= reinterpret_cast<AllowDarkModeForAppPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(135)));
if (!pAllowDarkModeForApp) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pAllowDarkModeForApp(bAllow);
@ -170,14 +170,14 @@ _FlushMenuThemes(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return;
}
static const auto pFlushMenuThemes
= reinterpret_cast<FlushMenuThemesPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(136)));
if (!pFlushMenuThemes) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return;
}
pFlushMenuThemes();
@ -188,14 +188,14 @@ _RefreshImmersiveColorPolicyState(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return;
}
static const auto pRefreshImmersiveColorPolicyState
= reinterpret_cast<RefreshImmersiveColorPolicyStatePtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(104)));
if (!pRefreshImmersiveColorPolicyState) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return;
}
pRefreshImmersiveColorPolicyState();
@ -206,19 +206,19 @@ _IsDarkModeAllowedForWindow(const HWND hWnd)
{
Q_ASSERT(hWnd);
if (!hWnd) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pIsDarkModeAllowedForWindow
= reinterpret_cast<IsDarkModeAllowedForWindowPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(137)));
if (!pIsDarkModeAllowedForWindow) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pIsDarkModeAllowedForWindow(hWnd);
@ -229,14 +229,14 @@ _GetIsImmersiveColorUsingHighContrast(const IMMERSIVE_HC_CACHE_MODE mode)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pGetIsImmersiveColorUsingHighContrast
= reinterpret_cast<GetIsImmersiveColorUsingHighContrastPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(106)));
if (!pGetIsImmersiveColorUsingHighContrast) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pGetIsImmersiveColorUsingHighContrast(mode);
@ -248,19 +248,19 @@ _OpenNcThemeData(const HWND hWnd, LPCWSTR pszClassList)
Q_ASSERT(hWnd);
Q_ASSERT(pszClassList);
if (!hWnd || !pszClassList) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return nullptr;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return nullptr;
}
static const auto pOpenNcThemeData
= reinterpret_cast<OpenNcThemeDataPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(49)));
if (!pOpenNcThemeData) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return nullptr;
}
return pOpenNcThemeData(hWnd, pszClassList);
@ -271,14 +271,14 @@ _ShouldSystemUseDarkMode(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pShouldSystemUseDarkMode
= reinterpret_cast<ShouldSystemUseDarkModePtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(138)));
if (!pShouldSystemUseDarkMode) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pShouldSystemUseDarkMode();
@ -289,14 +289,14 @@ _SetPreferredAppMode(const PREFERRED_APP_MODE mode)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return PAM_MAX;
}
static const auto pSetPreferredAppMode
= reinterpret_cast<SetPreferredAppModePtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(135)));
if (!pSetPreferredAppMode) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return PAM_MAX;
}
return pSetPreferredAppMode(mode);
@ -307,14 +307,14 @@ _IsDarkModeAllowedForApp(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
static const auto pIsDarkModeAllowedForApp
= reinterpret_cast<IsDarkModeAllowedForAppPtr>(
SysApiLoader::resolve(kuxtheme, MAKEINTRESOURCEA(139)));
if (!pIsDarkModeAllowedForApp) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pIsDarkModeAllowedForApp();
@ -325,12 +325,12 @@ _EnableChildWindowDpiMessage2(const HWND hWnd, const BOOL fEnable)
{
Q_ASSERT(hWnd);
if (!hWnd) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
using EnableChildWindowDpiMessagePtr = decltype(&::_EnableChildWindowDpiMessage);
@ -355,7 +355,7 @@ _EnableChildWindowDpiMessage2(const HWND hWnd, const BOOL fEnable)
return nullptr;
}();
if (!pEnableChildWindowDpiMessage) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pEnableChildWindowDpiMessage(hWnd, fEnable);
@ -366,7 +366,7 @@ _EnablePerMonitorDialogScaling2(VOID)
{
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
using EnablePerMonitorDialogScalingPtr = decltype(&::_EnablePerMonitorDialogScaling);
@ -385,7 +385,7 @@ _EnablePerMonitorDialogScaling2(VOID)
return nullptr;
}();
if (!pEnablePerMonitorDialogScaling) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pEnablePerMonitorDialogScaling();
@ -396,12 +396,12 @@ _GetDpiForWindow2(const HWND hWnd)
{
Q_ASSERT(hWnd);
if (!hWnd) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
using GetDpiForWindowPtr = decltype(&::_GetDpiForWindow);
@ -424,7 +424,7 @@ _GetDpiForWindow2(const HWND hWnd)
return nullptr;
}();
if (!pGetDpiForWindow) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
return pGetDpiForWindow(hWnd);
@ -436,12 +436,12 @@ _GetSystemMetricsForDpi2(const int nIndex, const UINT dpi)
Q_ASSERT(nIndex >= 0);
Q_ASSERT(dpi != 0);
if ((nIndex < 0) || (dpi == 0)) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
using GetSystemMetricsForDpiPtr = decltype(&::_GetSystemMetricsForDpi);
@ -460,7 +460,7 @@ _GetSystemMetricsForDpi2(const int nIndex, const UINT dpi)
return nullptr;
}();
if (!pGetSystemMetricsForDpi) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return 0;
}
return pGetSystemMetricsForDpi(nIndex, dpi);
@ -473,12 +473,12 @@ _AdjustWindowRectExForDpi2(LPRECT lpRect, const DWORD dwStyle,
Q_ASSERT(lpRect);
Q_ASSERT(dpi != 0);
if (!lpRect || (dpi == 0)) {
SetLastError(ERROR_INVALID_PARAMETER);
::SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
FRAMELESSHELPER_USE_NAMESPACE
if (!WindowsVersionHelper::isWin10OrGreater()) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
using AdjustWindowRectExForDpiPtr = decltype(&::_AdjustWindowRectExForDpi);
@ -496,7 +496,7 @@ _AdjustWindowRectExForDpi2(LPRECT lpRect, const DWORD dwStyle,
return nullptr;
}();
if (!pAdjustWindowRectExForDpi) {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return pAdjustWindowRectExForDpi(lpRect, dwStyle, bMenu, dwExStyle, dpi);

38
src/core/utils.cpp
View File

@ -24,6 +24,7 @@
#include "utils.h"
#include "framelesshelpercore_global_p.h"
#include "framelessmanager_p.h"
#ifdef Q_OS_WINDOWS
# include "winverhelper_p.h"
#endif // Q_OS_WINDOWS
@ -210,29 +211,40 @@ QWindow *Utils::findWindow(const WId windowId)
return nullptr;
}
void Utils::moveWindowToDesktopCenter(FramelessParamsConst params, const bool considerTaskBar)
bool Utils::moveWindowToDesktopCenter(const WId windowId, const bool considerTaskBar)
{
Q_ASSERT(params);
if (!params) {
return;
Q_ASSERT(windowId);
if (!windowId) {
return false;
}
const QSize windowSize = params->getWindowSize();
if (windowSize.isEmpty() || (windowSize == kDefaultWindowSize)) {
return;
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
Q_ASSERT(window);
if (!window) {
return false;
}
const QScreen *screen = params->getWindowScreen();
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
Q_ASSERT(data);
if (!data || !data->callbacks) {
return false;
}
const QSize windowSize = data->callbacks->getWindowSize();
if (windowSize.isEmpty() || (windowSize <= kDefaultWindowSize)) {
return false;
}
const QScreen *screen = data->callbacks->getWindowScreen();
if (!screen) {
screen = QGuiApplication::primaryScreen();
}
Q_ASSERT(screen);
if (!screen) {
return;
return false;
}
const QSize screenSize = (considerTaskBar ? screen->availableSize() : screen->size());
const QPoint offset = (considerTaskBar ? screen->availableGeometry().topLeft() : QPoint(0, 0));
const int newX = std::round(qreal(screenSize.width() - windowSize.width()) / qreal(2));
const int newY = std::round(qreal(screenSize.height() - windowSize.height()) / qreal(2));
params->setWindowPosition(QPoint(newX + offset.x(), newY + offset.y()));
data->callbacks->setWindowPosition(QPoint(newX + offset.x(), newY + offset.y()));
return true;
}
Qt::WindowState Utils::windowStatesToWindowState(const Qt::WindowStates states)
@ -314,9 +326,9 @@ bool Utils::shouldAppsUseDarkMode()
qreal Utils::roundScaleFactor(const qreal factor)
{
// Qt can't handle scale factors less than 1.0 (according to the comments in qhighdpiscaling.cpp).
Q_ASSERT((factor > 1) || qFuzzyCompare(factor, qreal(1)));
if (factor < 1) {
return 1;
Q_ASSERT((factor > qreal(1)) || qFuzzyCompare(factor, qreal(1)));
if (factor < qreal(1)) {
return qreal(1);
}
#if (!FRAMELESSHELPER_CONFIG(private_qt) || (QT_VERSION < QT_VERSION_CHECK(6, 2, 1)))
# if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))

419
src/core/utils_win.cpp
View File

@ -28,6 +28,7 @@
#include "framelesshelper_windows.h"
#include "framelessmanager.h"
#include "framelessmanager_p.h"
#include "framelessconfig_p.h"
#include "sysapiloader_p.h"
#include "registrykey_p.h"
@ -193,19 +194,44 @@ FRAMELESSHELPER_STRING_CONSTANT(ScreenToClient)
FRAMELESSHELPER_STRING_CONSTANT(DwmFlush)
FRAMELESSHELPER_STRING_CONSTANT(GetCursorPos)
struct Win32UtilsData
struct UtilsWinExtraData : public FramelessExtraData
{
SystemParameters params = {};
};
struct Win32UtilsInternal
{
QHash<WId, Win32UtilsData> data = {};
WNDPROC qtWindowProc = nullptr;
QList<WId> micaWindowIds = {};
};
bool windowProcHooked = false;
bool mica = false;
Q_GLOBAL_STATIC(Win32UtilsInternal, g_win32UtilsData)
UtilsWinExtraData();
~UtilsWinExtraData() override;
[[nodiscard]] static FramelessExtraDataPtr create();
};
using UtilsWinExtraDataPtr = std::shared_ptr<UtilsWinExtraData>;
UtilsWinExtraData::UtilsWinExtraData() = default;
UtilsWinExtraData::~UtilsWinExtraData() = default;
FramelessExtraDataPtr UtilsWinExtraData::create()
{
return std::make_shared<UtilsWinExtraData>();
}
[[nodiscard]] static inline UtilsWinExtraDataPtr tryGetExtraData(const FramelessDataPtr &data, const bool create)
{
Q_ASSERT(data);
if (!data) {
return nullptr;
}
auto it = data->extraData.find(ExtraDataType::WindowsUtilities);
if (it == data->extraData.end()) {
if (create) {
it = data->extraData.insert(ExtraDataType::WindowsUtilities, UtilsWinExtraData::create());
} else {
return nullptr;
}
}
return std::dynamic_pointer_cast<UtilsWinExtraData>(it.value());
}
struct Win32Message
{
@ -583,99 +609,6 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
};
#undef DEFINE_WIN32_MESSAGE
[[nodiscard]] bool operator==(const POINT &lhs, const POINT &rhs) noexcept
{
return ((lhs.x == rhs.x) && (lhs.y == rhs.y));
}
[[nodiscard]] bool operator!=(const POINT &lhs, const POINT &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[nodiscard]] bool operator==(const SIZE &lhs, const SIZE &rhs) noexcept
{
return ((lhs.cx == rhs.cx) && (lhs.cy == rhs.cy));
}
[[nodiscard]] bool operator!=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[nodiscard]] bool operator>(const SIZE &lhs, const SIZE &rhs) noexcept
{
return ((lhs.cx * lhs.cy) > (rhs.cx * rhs.cy));
}
[[nodiscard]] bool operator>=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator>(lhs, rhs) || operator==(lhs, rhs));
}
[[nodiscard]] bool operator<(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator!=(lhs, rhs) && !operator>(lhs, rhs));
}
[[nodiscard]] bool operator<=(const SIZE &lhs, const SIZE &rhs) noexcept
{
return (operator<(lhs, rhs) || operator==(lhs, rhs));
}
[[nodiscard]] 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));
}
[[nodiscard]] bool operator!=(const RECT &lhs, const RECT &rhs) noexcept
{
return !operator==(lhs, rhs);
}
[[nodiscard]] QPoint point2qpoint(const POINT &point)
{
return QPoint{ int(point.x), int(point.y) };
}
[[nodiscard]] POINT qpoint2point(const QPoint &point)
{
return POINT{ LONG(point.x()), LONG(point.y()) };
}
[[nodiscard]] QSize size2qsize(const SIZE &size)
{
return QSize{ int(size.cx), int(size.cy) };
}
[[nodiscard]] SIZE qsize2size(const QSize &size)
{
return SIZE{ LONG(size.width()), LONG(size.height()) };
}
[[nodiscard]] QRect rect2qrect(const RECT &rect)
{
return QRect{ QPoint{ int(rect.left), int(rect.top) }, QSize{ int(RECT_WIDTH(rect)), int(RECT_HEIGHT(rect)) } };
}
[[nodiscard]] RECT qrect2rect(const QRect &qrect)
{
return RECT{ LONG(qrect.left()), LONG(qrect.top()), LONG(qrect.right()), LONG(qrect.bottom()) };
}
[[nodiscard]] QString hwnd2str(const WId windowId)
{
// NULL handle is allowed here.
return FRAMELESSHELPER_STRING_LITERAL("0x") + QString::number(windowId, 16).toUpper().rightJustified(8, u'0');
}
[[nodiscard]] QString hwnd2str(const HWND hwnd)
{
// NULL handle is allowed here.
return hwnd2str(reinterpret_cast<WId>(hwnd));
}
[[nodiscard]] std::optional<MONITORINFOEXW> getMonitorForWindow(const HWND hwnd)
{
Q_ASSERT(hwnd);
@ -734,8 +667,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
static const auto currentOsVer = []() -> std::optional<VersionNumber> {
if (API_NT_AVAILABLE(RtlGetVersion)) {
using RtlGetVersionPtr = _NTSTATUS(WINAPI *)(PRTL_OSVERSIONINFOW);
const auto pRtlGetVersion =
reinterpret_cast<RtlGetVersionPtr>(SysApiLoader::instance()->get(kntdll, kRtlGetVersion));
const auto pRtlGetVersion = reinterpret_cast<RtlGetVersionPtr>(SysApiLoader::instance()->get(kntdll, kRtlGetVersion));
RTL_OSVERSIONINFOEXW osvi;
SecureZeroMemory(&osvi, sizeof(osvi));
osvi.dwOSVersionInfoSize = sizeof(osvi);
@ -785,8 +717,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
return kErrorMessageTemplate.arg(function, QString::number(code), errorText);
#else // !FRAMELESSHELPER_CONFIG(private_qt)
LPWSTR buf = nullptr;
if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPWSTR>(&buf), 0, nullptr) == 0) {
if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPWSTR>(&buf), 0, nullptr) == 0) {
return FRAMELESSHELPER_STRING_LITERAL("FormatMessageW() returned empty string.");
}
const QString errorText = QString::fromWCharArray(buf).trimmed();
@ -839,16 +770,14 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
const int newWindowY = (activeMonitorRect.top + currentWindowOffsetY);
static constexpr const UINT flags =
(SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
if (::SetWindowPos(hwnd, nullptr, newWindowX, newWindowY,
currentWindowWidth, currentWindowHeight, flags) == FALSE) {
if (::SetWindowPos(hwnd, nullptr, newWindowX, newWindowY, currentWindowWidth, currentWindowHeight, flags) == FALSE) {
WARNING << Utils::getSystemErrorMessage(kSetWindowPos);
return false;
}
return true;
}
[[nodiscard]] static inline int getSystemMetrics2(const int index, const bool horizontal,
const quint32 dpi)
[[nodiscard]] static inline int getSystemMetrics2(const int index, const bool horizontal, const quint32 dpi)
{
Q_ASSERT(dpi != 0);
if (dpi == 0) {
@ -863,8 +792,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
return std::round(qreal(::GetSystemMetrics(index)) / currentDpr * requestedDpr);
}
[[nodiscard]] static inline int getSystemMetrics2(const WId windowId, const int index,
const bool horizontal, const bool scaled)
[[nodiscard]] static inline int getSystemMetrics2(const WId windowId, const int index, const bool horizontal, const bool scaled)
{
Q_ASSERT(windowId);
if (!windowId) {
@ -883,29 +811,29 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
return std::round(qreal(::GetSystemMetrics(index)) / dpr);
}
[[maybe_unused]] [[nodiscard]] static inline
[[maybe_unused]] [[nodiscard]] static inline constexpr
DWORD qtEdgesToWin32Orientation(const Qt::Edges edges)
{
if (edges == Qt::Edges{}) {
return 0;
} else if (edges == (Qt::LeftEdge)) {
return 0xF001; // SC_SIZELEFT
return SC_SIZELEFT;
} else if (edges == (Qt::RightEdge)) {
return 0xF002; // SC_SIZERIGHT
return SC_SIZERIGHT;
} else if (edges == (Qt::TopEdge)) {
return 0xF003; // SC_SIZETOP
return SC_SIZETOP;
} else if (edges == (Qt::TopEdge | Qt::LeftEdge)) {
return 0xF004; // SC_SIZETOPLEFT
return SC_SIZETOPLEFT;
} else if (edges == (Qt::TopEdge | Qt::RightEdge)) {
return 0xF005; // SC_SIZETOPRIGHT
return SC_SIZETOPRIGHT;
} else if (edges == (Qt::BottomEdge)) {
return 0xF006; // SC_SIZEBOTTOM
return SC_SIZEBOTTOM;
} else if (edges == (Qt::BottomEdge | Qt::LeftEdge)) {
return 0xF007; // SC_SIZEBOTTOMLEFT
return SC_SIZEBOTTOMLEFT;
} else if (edges == (Qt::BottomEdge | Qt::RightEdge)) {
return 0xF008; // SC_SIZEBOTTOMRIGHT
return SC_SIZEBOTTOMRIGHT;
} else {
return 0xF000; // SC_SIZE
return SC_SIZE;
}
}
@ -923,7 +851,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
return result;
}
[[nodiscard]] static inline bool isNonClientMessage(const UINT message)
[[nodiscard]] static inline constexpr bool isNonClientMessage(const UINT message)
{
if (((message >= WM_NCCREATE) && (message <= WM_NCACTIVATE))
|| ((message >= WM_NCMOUSEMOVE) && (message <= WM_NCMBUTTONDBLCLK))
@ -936,7 +864,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
}
}
[[nodiscard]] static inline bool isMouseMessage(const UINT message, bool *isNonClient = nullptr)
[[nodiscard]] static inline constexpr bool isMouseMessage(const UINT message, bool *isNonClient = nullptr)
{
if (((message >= WM_MOUSEFIRST) && (message <= WM_MOUSELAST))
|| ((message == WM_MOUSEHOVER) || (message == WM_MOUSELEAVE))) {
@ -956,18 +884,12 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
}
}
[[nodiscard]] static inline bool usePureQtImplementation()
{
static const bool result = FramelessConfig::instance()->isSet(Option::UseCrossPlatformQtImplementation);
return result;
}
[[nodiscard]] static inline LRESULT CALLBACK FramelessHelperHookWindowProc
(const HWND hWnd, const UINT uMsg, const WPARAM wParam, const LPARAM lParam)
{
Q_ASSERT(hWnd);
if (!hWnd) {
return 0;
return FALSE;
}
#if FRAMELESSHELPER_CONFIG(debug_output)
if (isWin32MessageDebuggingEnabled()) {
@ -981,10 +903,25 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
Utils::printWin32Message(&message);
}
#endif
const auto defaultWindowProcessing = [hWnd, uMsg, wParam, lParam]() -> LRESULT { return ::DefWindowProcW(hWnd, uMsg, wParam, lParam); };
const auto windowId = reinterpret_cast<WId>(hWnd);
const auto it = g_win32UtilsData()->data.constFind(windowId);
if (it == g_win32UtilsData()->data.constEnd()) {
return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return defaultWindowProcessing();
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data || !data->frameless || !data->callbacks) {
return defaultWindowProcessing();
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, false);
Q_ASSERT(extraData);
if (!extraData) {
return defaultWindowProcessing();
}
const QWindow *qWindow = data->callbacks->getWindowHandle();
Q_ASSERT(qWindow);
if (!qWindow) {
return defaultWindowProcessing();
}
// 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 unfiltered
@ -1004,7 +941,7 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
// (and correct client area size, especially when the window is maximized/fullscreen). So we still go through
// the normal code path of the original qWindowsWndProc() function, but only for this specific message. It should
// be OK because Qt won't prevent us from handling WM_NCCALCSIZE.
if (!usePureQtImplementation() && (uMsg != WM_NCCALCSIZE)) {
if (uMsg != WM_NCCALCSIZE) {
MSG message;
SecureZeroMemory(&message, sizeof(message));
message.hwnd = hWnd;
@ -1034,7 +971,6 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
return LRESULT(filterResult);
}
}
const Win32UtilsData &data = it.value();
const auto getNativePosFromMouse = [lParam]() -> QPoint {
return {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
};
@ -1073,8 +1009,8 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
switch (uMsg) {
case WM_RBUTTONUP: {
const QPoint nativeLocalPos = getNativePosFromMouse();
const QPoint qtScenePos = Utils::fromNativeLocalPosition(data.params.getWindowHandle(), nativeLocalPos);
if (data.params.isInsideTitleBarDraggableArea(qtScenePos)) {
const QPoint qtScenePos = Utils::fromNativeLocalPosition(qWindow, nativeLocalPos);
if (data->callbacks->isInsideTitleBarDraggableArea(qtScenePos)) {
POINT pos = {nativeLocalPos.x(), nativeLocalPos.y()};
if (::ClientToScreen(hWnd, &pos) == FALSE) {
WARNING << Utils::getSystemErrorMessage(kClientToScreen);
@ -1084,12 +1020,12 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
nativeGlobalPos = {pos.x, pos.y};
}
} break;
case WM_NCRBUTTONUP: {
case WM_NCRBUTTONUP:
if (wParam == HTCAPTION) {
shouldShowSystemMenu = true;
nativeGlobalPos = getNativePosFromMouse();
}
} break;
break;
case WM_SYSCOMMAND: {
const WPARAM filteredWParam = (wParam & 0xFFF0);
if ((filteredWParam == SC_KEYMENU) && (lParam == VK_SPACE)) {
@ -1112,20 +1048,20 @@ static constexpr const std::array<Win32Message, 333> g_win32MessageMap =
break;
}
if (shouldShowSystemMenu) {
std::ignore = Utils::showSystemMenu(windowId, nativeGlobalPos, broughtByKeyboard, &data.params);
std::ignore = Utils::showSystemMenu(windowId, nativeGlobalPos, broughtByKeyboard);
// QPA's internal code will handle system menu events separately, and its
// behavior is not what we would want to see because it doesn't know our
// window doesn't have any window frame now, so return early here to avoid
// entering Qt's own handling logic.
return 0; // Return 0 means we have handled this event.
return FALSE; // Return 0 means we have handled this event.
}
Q_ASSERT(g_win32UtilsData()->qtWindowProc);
if (g_win32UtilsData()->qtWindowProc) {
Q_ASSERT(extraData->qtWindowProc);
if (extraData->qtWindowProc) {
// Hand over to Qt's original window proc function for events we are not
// interested in.
return ::CallWindowProcW(g_win32UtilsData()->qtWindowProc, hWnd, uMsg, wParam, lParam);
return ::CallWindowProcW(extraData->qtWindowProc, hWnd, uMsg, wParam, lParam);
} else {
return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
return defaultWindowProcessing();
}
}
@ -1167,16 +1103,12 @@ bool Utils::triggerFrameChange(const WId windowId)
return false;
}
const auto hwnd = reinterpret_cast<HWND>(windowId);
static constexpr const UINT swpFlags =
(SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOSIZE
| SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
static constexpr const UINT swpFlags = (SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
if (::SetWindowPos(hwnd, nullptr, 0, 0, 0, 0, swpFlags) == FALSE) {
WARNING << getSystemErrorMessage(kSetWindowPos);
return false;
}
static constexpr const UINT rdwFlags =
(RDW_ERASE | RDW_FRAME | RDW_INVALIDATE
| RDW_UPDATENOW | RDW_ALLCHILDREN);
static constexpr const UINT rdwFlags = (RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
if (::RedrawWindow(hwnd, nullptr, nullptr, rdwFlags) == FALSE) {
WARNING << getSystemErrorMessage(kRedrawWindow);
return false;
@ -1193,19 +1125,31 @@ bool Utils::updateWindowFrameMargins(const WId windowId, const bool reset)
if (!API_DWM_AVAILABLE(DwmExtendFrameIntoClientArea)) {
return false;
}
// We can't extend the window frame when DWM composition is disabled.
// We can't extend the window frame when DWM composition is disabled anyway.
// No need to try further in this case.
if (!isDwmCompositionEnabled()) {
return false;
}
const bool micaEnabled = g_win32UtilsData()->micaWindowIds.contains(windowId);
const auto margins = [micaEnabled, reset]() -> MARGINS {
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return false;
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
const auto margins = [&extraData, reset]() -> MARGINS {
// To make Mica/Mica Alt work for normal Win32 windows, we have to
// let the window frame extend to the whole window (or disable the
// redirection surface, but this will break GDI's rendering, so we
// can't do this, unfortunately), so we can't change the window frame
// margins in this case, otherwise Mica/Mica Alt will be broken.
if (micaEnabled) {
if (extraData->mica) {
return {-1, -1, -1, -1};
}
if (reset || isWindowFrameBorderVisible()) {
@ -1342,12 +1286,19 @@ DwmColorizationArea Utils::getDwmColorizationArea()
return DwmColorizationArea::None;
}
bool Utils::showSystemMenu(const WId windowId, const QPoint &pos, const bool selectFirstEntry,
FramelessParamsConst params)
bool Utils::showSystemMenu(const WId windowId, const QPoint &pos, const bool selectFirstEntry)
{
Q_ASSERT(windowId);
Q_ASSERT(params);
if (!windowId || !params) {
if (!windowId) {
return false;
}
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data || !data->frameless || !data->callbacks) {
return false;
}
@ -1361,11 +1312,11 @@ bool Utils::showSystemMenu(const WId windowId, const QPoint &pos, const bool sel
}
// Tweak the menu items according to the current window status and user settings.
const bool disableRestore = params->getProperty(kSysMenuDisableRestoreVar, false).toBool();
const bool disableMinimize = params->getProperty(kSysMenuDisableMinimizeVar, false).toBool();
const bool disableMaximize = params->getProperty(kSysMenuDisableMaximizeVar, false).toBool();
const bool disableRestore = data->callbacks->getProperty(kSysMenuDisableRestoreVar, false).toBool();
const bool disableMinimize = data->callbacks->getProperty(kSysMenuDisableMinimizeVar, false).toBool();
const bool disableMaximize = data->callbacks->getProperty(kSysMenuDisableMaximizeVar, false).toBool();
const bool maxOrFull = (IsMaximized(hWnd) || isFullScreen(windowId));
const bool fixedSize = params->isWindowFixedSize();
const bool fixedSize = data->callbacks->isWindowFixedSize();
::EnableMenuItem(hMenu, SC_RESTORE, (MF_BYCOMMAND | ((maxOrFull && !fixedSize && !disableRestore) ? MFS_ENABLED : MFS_DISABLED)));
// The first menu item should be selected by default if the menu is brought
// up by keyboard. I don't know how to pre-select a menu item but it seems
@ -1399,14 +1350,13 @@ bool Utils::showSystemMenu(const WId windowId, const QPoint &pos, const bool sel
::SetMenuDefaultItem(hMenu, defaultItemId, FALSE);
// Popup the system menu at the required position.
const int result = ::TrackPopupMenu(hMenu, (TPM_RETURNCMD | (QGuiApplication::isRightToLeft()
? TPM_RIGHTALIGN : TPM_LEFTALIGN)), pos.x(), pos.y(), 0, hWnd, nullptr);
const int result = ::TrackPopupMenu(hMenu, (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN)), pos.x(), pos.y(), 0, hWnd, nullptr);
// Unhighlight the first menu item after the popup menu is closed, otherwise it will keep
// highlighting until we unhighlight it manually.
::HiliteMenuItem(hWnd, hMenu, SC_RESTORE, (MF_BYCOMMAND | MFS_UNHILITE));
if (result == 0) {
if (result == FALSE) {
// The user canceled the menu, no need to continue.
return true;
}
@ -1614,13 +1564,10 @@ quint32 Utils::getPrimaryScreenDpi(const bool horizontal)
// Using Direct2D to get the primary monitor's DPI is only available on Windows 7
// and onwards, but it has been marked as deprecated by Microsoft.
if (API_D2D_AVAILABLE(D2D1CreateFactory)) {
using D2D1CreateFactoryPtr =
HRESULT(WINAPI *)(D2D1_FACTORY_TYPE, REFIID, CONST D2D1_FACTORY_OPTIONS *, void **);
const auto pD2D1CreateFactory =
reinterpret_cast<D2D1CreateFactoryPtr>(SysApiLoader::instance()->get(kd2d1, kD2D1CreateFactory));
using D2D1CreateFactoryPtr = HRESULT(WINAPI *)(D2D1_FACTORY_TYPE, REFIID, CONST D2D1_FACTORY_OPTIONS *, void **);
const auto pD2D1CreateFactory = reinterpret_cast<D2D1CreateFactoryPtr>(SysApiLoader::instance()->get(kd2d1, kD2D1CreateFactory));
ID2D1Factory *d2dFactory = nullptr;
HRESULT hr = pD2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory),
nullptr, reinterpret_cast<void **>(&d2dFactory));
HRESULT hr = pD2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory), nullptr, reinterpret_cast<void **>(&d2dFactory));
if (SUCCEEDED(hr)) {
// We want to get the newest system DPI, so refresh the system metrics
// manually to ensure that.
@ -1740,11 +1687,9 @@ quint32 Utils::getResizeBorderThicknessForDpi(const bool horizontal, const quint
return 0;
}
if (horizontal) {
return (getSystemMetrics2(SM_CXSIZEFRAME, true, dpi)
+ getSystemMetrics2(SM_CXPADDEDBORDER, true, dpi));
return (getSystemMetrics2(SM_CXSIZEFRAME, true, dpi) + getSystemMetrics2(SM_CXPADDEDBORDER, true, dpi));
} else {
return (getSystemMetrics2(SM_CYSIZEFRAME, false, dpi)
+ getSystemMetrics2(SM_CYPADDEDBORDER, false, dpi));
return (getSystemMetrics2(SM_CYSIZEFRAME, false, dpi) + getSystemMetrics2(SM_CYPADDEDBORDER, false, dpi));
}
}
@ -1755,11 +1700,9 @@ quint32 Utils::getResizeBorderThickness(const WId windowId, const bool horizonta
return 0;
}
if (horizontal) {
return (getSystemMetrics2(windowId, SM_CXSIZEFRAME, true, scaled)
+ getSystemMetrics2(windowId, SM_CXPADDEDBORDER, true, scaled));
return (getSystemMetrics2(windowId, SM_CXSIZEFRAME, true, scaled) + getSystemMetrics2(windowId, SM_CXPADDEDBORDER, true, scaled));
} else {
return (getSystemMetrics2(windowId, SM_CYSIZEFRAME, false, scaled)
+ getSystemMetrics2(windowId, SM_CYPADDEDBORDER, false, scaled));
return (getSystemMetrics2(windowId, SM_CYSIZEFRAME, false, scaled) + getSystemMetrics2(windowId, SM_CYPADDEDBORDER, false, scaled));
}
}
@ -1830,13 +1773,12 @@ quint32 Utils::getFrameBorderThickness(const WId windowId, const bool scaled)
const qreal scaleFactor = (qreal(dpi) / qreal(USER_DEFAULT_SCREEN_DPI));
const auto hwnd = reinterpret_cast<HWND>(windowId);
UINT value = 0;
const HRESULT hr = API_CALL_FUNCTION(dwmapi, DwmGetWindowAttribute, hwnd,
_DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, &value, sizeof(value));
const HRESULT hr = API_CALL_FUNCTION(dwmapi, DwmGetWindowAttribute, hwnd, _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, &value, sizeof(value));
if (SUCCEEDED(hr)) {
const qreal dpr = (scaled ? 1.0 : scaleFactor);
const qreal dpr = (scaled ? qreal(1) : scaleFactor);
return std::round(qreal(value) / dpr);
} else {
const qreal dpr = (scaled ? scaleFactor : 1.0);
const qreal dpr = (scaled ? scaleFactor : qreal(1));
return std::round(qreal(kDefaultWindowFrameBorderThickness) * dpr);
}
}
@ -1949,7 +1891,7 @@ bool Utils::startSystemMove(QWindow *window, const QPoint &globalPos)
return false;
}
const auto hwnd = reinterpret_cast<HWND>(window->winId());
if (::PostMessageW(hwnd, WM_SYSCOMMAND, 0xF012 /*SC_DRAGMOVE*/, 0) == FALSE) {
if (::PostMessageW(hwnd, WM_SYSCOMMAND, SC_DRAGMOVE, 0) == FALSE) {
WARNING << getSystemErrorMessage(kPostMessageW);
return false;
}
@ -1986,10 +1928,8 @@ bool Utils::startSystemResize(QWindow *window, const Qt::Edges edges, const QPoi
bool Utils::isWindowFrameBorderVisible()
{
static const auto result = []() -> bool {
#if FRAMELESSHELPER_CONFIG(native_impl)
const FramelessConfig * const config = FramelessConfig::instance();
if (config->isSet(Option::UseCrossPlatformQtImplementation)) {
return false;
}
if (config->isSet(Option::ForceShowWindowFrameBorder)) {
return true;
}
@ -1997,6 +1937,9 @@ bool Utils::isWindowFrameBorderVisible()
return false;
}
return WindowsVersionHelper::isWin10OrGreater();
#else
return false;
#endif
}();
return result;
}
@ -2016,15 +1959,29 @@ bool Utils::isFrameBorderColorized()
return isTitleBarColorized();
}
bool Utils::installWindowProcHook(const WId windowId, FramelessParamsConst params)
bool Utils::installWindowProcHook(const WId windowId)
{
Q_ASSERT(windowId);
Q_ASSERT(params);
if (!windowId || !params) {
if (!windowId) {
return false;
}
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
Q_ASSERT(window);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
Q_ASSERT(data);
if (!data || data->frameless) {
return false;
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, true);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
const auto hwnd = reinterpret_cast<HWND>(windowId);
if (!g_win32UtilsData()->qtWindowProc) {
if (!extraData->qtWindowProc) {
::SetLastError(ERROR_SUCCESS);
const auto qtWindowProc = reinterpret_cast<WNDPROC>(::GetWindowLongPtrW(hwnd, GWLP_WNDPROC));
Q_ASSERT(qtWindowProc);
@ -2032,18 +1989,15 @@ bool Utils::installWindowProcHook(const WId windowId, FramelessParamsConst param
WARNING << getSystemErrorMessage(kGetWindowLongPtrW);
return false;
}
g_win32UtilsData()->qtWindowProc = qtWindowProc;
extraData->qtWindowProc = qtWindowProc;
}
const auto it = g_win32UtilsData()->data.constFind(windowId);
if (it == g_win32UtilsData()->data.constEnd()) {
Win32UtilsData data = {};
data.params = *params;
g_win32UtilsData()->data.insert(windowId, data);
if (!extraData->windowProcHooked) {
::SetLastError(ERROR_SUCCESS);
if (::SetWindowLongPtrW(hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(FramelessHelperHookWindowProc)) == 0) {
WARNING << getSystemErrorMessage(kSetWindowLongPtrW);
return false;
}
extraData->windowProcHooked = true;
}
return true;
}
@ -2054,19 +2008,30 @@ bool Utils::uninstallWindowProcHook(const WId windowId)
if (!windowId) {
return false;
}
const auto it = g_win32UtilsData()->data.constFind(windowId);
if (it != g_win32UtilsData()->data.constEnd()) {
g_win32UtilsData()->data.erase(it);
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data || !data->frameless) {
return false;
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, false);
if (!extraData || !extraData->windowProcHooked) {
return false;
}
Q_ASSERT(extraData->qtWindowProc);
if (!extraData->qtWindowProc) {
return false;
}
if (g_win32UtilsData()->data.isEmpty() && g_win32UtilsData()->qtWindowProc) {
const auto hwnd = reinterpret_cast<HWND>(windowId);
::SetLastError(ERROR_SUCCESS);
if (::SetWindowLongPtrW(hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(g_win32UtilsData()->qtWindowProc)) == 0) {
if (::SetWindowLongPtrW(hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(extraData->qtWindowProc)) == 0) {
WARNING << getSystemErrorMessage(kSetWindowLongPtrW);
return false;
}
g_win32UtilsData()->qtWindowProc = nullptr;
}
extraData->qtWindowProc = nullptr;
extraData->windowProcHooked = false;
return true;
}
@ -2323,6 +2288,19 @@ bool Utils::setBlurBehindWindowEnabled(const WId windowId, const BlurMode mode,
if (!windowId) {
return false;
}
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return false;
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
const auto hwnd = reinterpret_cast<HWND>(windowId);
if (WindowsVersionHelper::isWin8OrGreater()) {
if (!(API_DWM_AVAILABLE(DwmSetWindowAttribute)
@ -2330,8 +2308,8 @@ bool Utils::setBlurBehindWindowEnabled(const WId windowId, const BlurMode mode,
WARNING << "Blur behind window is not available on current platform.";
return false;
}
const auto restoreWindowFrameMargins = [windowId]() -> void {
g_win32UtilsData()->micaWindowIds.removeAll(windowId);
const auto restoreWindowFrameMargins = [windowId, &extraData]() -> void {
extraData->mica = false;
std::ignore = updateWindowFrameMargins(windowId, false);
};
static const bool preferMicaAlt = (qEnvironmentVariableIntValue("FRAMELESSHELPER_PREFER_MICA_ALT") != 0);
@ -2405,7 +2383,7 @@ bool Utils::setBlurBehindWindowEnabled(const WId windowId, const BlurMode mode,
return result;
} else {
if ((blurMode == BlurMode::Windows_Mica) || (blurMode == BlurMode::Windows_MicaAlt)) {
g_win32UtilsData()->micaWindowIds.append(windowId);
extraData->mica = true;
// By giving a negative value, DWM will extend the window frame into the whole
// client area. We need this step because the Mica material can only be applied
// to the non-client area of a window. Without this step, you'll get a window
@ -3077,7 +3055,20 @@ bool Utils::removeMicaWindow(const WId windowId)
if (!windowId) {
return false;
}
g_win32UtilsData()->micaWindowIds.removeAll(windowId);
const QObject *window = FramelessManagerPrivate::getWindow(windowId);
if (!window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return false;
}
const UtilsWinExtraDataPtr extraData = tryGetExtraData(data, false);
Q_ASSERT(extraData);
if (!extraData || !extraData->mica) {
return false;
}
extraData->mica = false;
return true;
}
@ -3127,7 +3118,7 @@ bool Utils::isValidWindow(const WId windowId, const bool checkVisible, const boo
return false;
}
const LONG_PTR exStyles = ::GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
if ((exStyles != 0) && (exStyles & WS_EX_TOOLWINDOW)) {
if ((exStyles == 0) || (exStyles & WS_EX_TOOLWINDOW)) {
return false;
}
RECT rect = { 0, 0, 0, 0 };
@ -3173,11 +3164,11 @@ bool Utils::updateFramebufferTransparency(const WId windowId)
DWM_BLURBEHIND bb;
SecureZeroMemory(&bb, sizeof(bb));
bb.dwFlags = (DWM_BB_ENABLE | DWM_BB_BLURREGION);
bb.hRgnBlur = CreateRectRgn(0, 0, -1, -1);
bb.hRgnBlur = ::CreateRectRgn(0, 0, -1, -1);
bb.fEnable = TRUE;
const HRESULT hr = API_CALL_FUNCTION(dwmapi, DwmEnableBlurBehindWindow, hwnd, &bb);
if (bb.hRgnBlur) {
if (DeleteObject(bb.hRgnBlur) == FALSE) {
if (::DeleteObject(bb.hRgnBlur) == FALSE) {
WARNING << getSystemErrorMessage(kDeleteObject);
}
}

337
src/quick/framelessquickhelper.cpp
View File

@ -32,6 +32,7 @@
#endif
#include <FramelessHelper/Core/framelessmanager.h>
#include <FramelessHelper/Core/utils.h>
#include <FramelessHelper/Core/private/framelessmanager_p.h>
#include <FramelessHelper/Core/private/framelessconfig_p.h>
#include <FramelessHelper/Core/private/framelesshelpercore_global_p.h>
#ifdef Q_OS_WINDOWS
@ -72,10 +73,8 @@ FRAMELESSHELPER_BEGIN_NAMESPACE
using namespace Global;
struct FramelessQuickHelperData
struct FramelessQuickHelperExtraData : public FramelessExtraData
{
bool ready = false;
SystemParameters params = {};
QPointer<QQuickItem> titleBarItem = nullptr;
QList<QPointer<QQuickItem>> hitTestVisibleItems = {};
QPointer<QQuickItem> windowIconButton = nullptr;
@ -84,11 +83,52 @@ struct FramelessQuickHelperData
QPointer<QQuickItem> maximizeButton = nullptr;
QPointer<QQuickItem> closeButton = nullptr;
QList<QRect> hitTestVisibleRects = {};
FramelessQuickHelperExtraData();
~FramelessQuickHelperExtraData() override;
[[nodiscard]] static FramelessExtraDataPtr create();
};
using FramelessQuickHelperExtraDataPtr = std::shared_ptr<FramelessQuickHelperExtraData>;
using FramelessQuickHelperInternal = QHash<WId, FramelessQuickHelperData>;
FramelessQuickHelperExtraData::FramelessQuickHelperExtraData() = default;
Q_GLOBAL_STATIC(FramelessQuickHelperInternal, g_framelessQuickHelperData)
FramelessQuickHelperExtraData::~FramelessQuickHelperExtraData() = default;
FramelessExtraDataPtr FramelessQuickHelperExtraData::create()
{
return std::make_shared<FramelessQuickHelperExtraData>();
}
[[nodiscard]] static inline FramelessQuickHelperExtraDataPtr tryGetExtraData(const FramelessDataPtr &data, const bool create)
{
Q_ASSERT(data);
if (!data) {
return nullptr;
}
auto it = data->extraData.find(ExtraDataType::FramelessQuickHelper);
if (it == data->extraData.end()) {
if (create) {
it = data->extraData.insert(ExtraDataType::FramelessQuickHelper, FramelessQuickHelperExtraData::create());
} else {
return nullptr;
}
}
return std::dynamic_pointer_cast<FramelessQuickHelperExtraData>(it.value());
}
[[nodiscard]] static inline FramelessQuickHelperExtraDataPtr tryGetExtraData(const QQuickWindow *window, const bool create)
{
Q_ASSERT(window);
if (!window) {
return nullptr;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return nullptr;
}
return tryGetExtraData(data, create);
}
FramelessQuickHelperPrivate::FramelessQuickHelperPrivate(FramelessQuickHelper *q) : QObject(q)
{
@ -124,59 +164,61 @@ const FramelessQuickHelperPrivate *FramelessQuickHelperPrivate::get(const Framel
void FramelessQuickHelperPrivate::attach()
{
Q_Q(FramelessQuickHelper);
QQuickWindow * const window = q->window();
QQuickWindow *window = q->window();
Q_ASSERT(window);
if (!window) {
return;
}
const WId windowId = window->winId();
FramelessQuickHelperData * const data = getWindowDataMutable();
if (!data || data->ready) {
const FramelessDataPtr data = FramelessManagerPrivate::createData(window, windowId);
Q_ASSERT(data);
if (!data || data->frameless) {
return;
}
SystemParameters params = {};
params.getWindowId = [window]() -> WId { return window->winId(); };
params.getWindowFlags = [window]() -> Qt::WindowFlags { return window->flags(); };
params.setWindowFlags = [window](const Qt::WindowFlags flags) -> void { window->setFlags(flags); };
params.getWindowSize = [window]() -> QSize { return window->size(); };
params.setWindowSize = [window](const QSize &size) -> void { window->resize(size); };
params.getWindowPosition = [window]() -> QPoint { return window->position(); };
params.setWindowPosition = [window](const QPoint &pos) -> void { window->setX(pos.x()); window->setY(pos.y()); };
params.getWindowScreen = [window]() -> QScreen * { return window->screen(); };
params.isWindowFixedSize = [q]() -> bool { return q->isWindowFixedSize(); };
params.setWindowFixedSize = [q](const bool value) -> void { q->setWindowFixedSize(value); };
params.getWindowState = [window]() -> Qt::WindowState { return window->windowState(); };
params.setWindowState = [window](const Qt::WindowState state) -> void { window->setWindowState(state); };
params.getWindowHandle = [window]() -> QWindow * { return window; };
params.windowToScreen = [window](const QPoint &pos) -> QPoint { return window->mapToGlobal(pos); };
params.screenToWindow = [window](const QPoint &pos) -> QPoint { return window->mapFromGlobal(pos); };
params.isInsideSystemButtons = [this](const QPoint &pos, SystemButtonType *button) -> bool {
if (!data->callbacks) {
data->callbacks = FramelessCallbacks::create();
data->callbacks->getWindowId = [window]() -> WId { return window->winId(); };
data->callbacks->getWindowFlags = [window]() -> Qt::WindowFlags { return window->flags(); };
data->callbacks->setWindowFlags = [window](const Qt::WindowFlags flags) -> void { window->setFlags(flags); };
data->callbacks->getWindowSize = [window]() -> QSize { return window->size(); };
data->callbacks->setWindowSize = [window](const QSize &size) -> void { window->resize(size); };
data->callbacks->getWindowPosition = [window]() -> QPoint { return window->position(); };
data->callbacks->setWindowPosition = [window](const QPoint &pos) -> void { window->setX(pos.x()); window->setY(pos.y()); };
data->callbacks->getWindowScreen = [window]() -> QScreen * { return window->screen(); };
data->callbacks->isWindowFixedSize = [q]() -> bool { return q->isWindowFixedSize(); };
data->callbacks->setWindowFixedSize = [q](const bool value) -> void { q->setWindowFixedSize(value); };
data->callbacks->getWindowState = [window]() -> Qt::WindowState { return window->windowState(); };
data->callbacks->setWindowState = [window](const Qt::WindowState state) -> void { window->setWindowState(state); };
data->callbacks->getWindowHandle = [q]() -> QWindow * { return q->window(); };
data->callbacks->windowToScreen = [window](const QPoint &pos) -> QPoint { return window->mapToGlobal(pos); };
data->callbacks->screenToWindow = [window](const QPoint &pos) -> QPoint { return window->mapFromGlobal(pos); };
data->callbacks->isInsideSystemButtons = [this](const QPoint &pos, SystemButtonType *button) -> bool {
QuickGlobal::SystemButtonType button2 = QuickGlobal::SystemButtonType::Unknown;
const bool result = isInSystemButtons(pos, &button2);
*button = FRAMELESSHELPER_ENUM_QUICK_TO_CORE(SystemButtonType, button2);
return result;
};
params.isInsideTitleBarDraggableArea = [this](const QPoint &pos) -> bool { return isInTitleBarDraggableArea(pos); };
params.getWindowDevicePixelRatio = [window]() -> qreal { return window->effectiveDevicePixelRatio(); };
params.setSystemButtonState = [this](const SystemButtonType button, const ButtonState state) -> void {
setSystemButtonState(FRAMELESSHELPER_ENUM_CORE_TO_QUICK(SystemButtonType, button),
FRAMELESSHELPER_ENUM_CORE_TO_QUICK(ButtonState, state));
data->callbacks->isInsideTitleBarDraggableArea = [this](const QPoint &pos) -> bool { return isInTitleBarDraggableArea(pos); };
data->callbacks->getWindowDevicePixelRatio = [window]() -> qreal { return window->effectiveDevicePixelRatio(); };
data->callbacks->setSystemButtonState = [this](const SystemButtonType button, const ButtonState state) -> void {
setSystemButtonState(FRAMELESSHELPER_ENUM_CORE_TO_QUICK(SystemButtonType, button), FRAMELESSHELPER_ENUM_CORE_TO_QUICK(ButtonState, state));
};
params.shouldIgnoreMouseEvents = [this](const QPoint &pos) -> bool { return shouldIgnoreMouseEvents(pos); };
params.showSystemMenu = [q](const QPoint &pos) -> void { q->showSystemMenu(pos); };
params.setProperty = [this](const char *name, const QVariant &value) -> void { setProperty(name, value); };
params.getProperty = [this](const char *name, const QVariant &defaultValue) -> QVariant { return getProperty(name, defaultValue); };
params.setCursor = [window](const QCursor &cursor) -> void { window->setCursor(cursor); };
params.unsetCursor = [window]() -> void { window->unsetCursor(); };
params.getWidgetHandle = []() -> QObject * { return nullptr; };
params.forceChildrenRepaint = [this](const int delay) -> void { repaintAllChildren(delay); };
params.resetQtGrabbedControl = []() -> bool { return false; };
data->callbacks->shouldIgnoreMouseEvents = [this](const QPoint &pos) -> bool { return shouldIgnoreMouseEvents(pos); };
data->callbacks->showSystemMenu = [q](const QPoint &pos) -> void { q->showSystemMenu(pos); };
data->callbacks->setProperty = [this](const char *name, const QVariant &value) -> void { setProperty(name, value); };
data->callbacks->getProperty = [this](const char *name, const QVariant &defaultValue) -> QVariant { return getProperty(name, defaultValue); };
data->callbacks->setCursor = [window](const QCursor &cursor) -> void { window->setCursor(cursor); };
data->callbacks->unsetCursor = [window]() -> void { window->unsetCursor(); };
data->callbacks->getWidgetHandle = []() -> QObject * { return nullptr; };
data->callbacks->forceChildrenRepaint = [this](const int delay) -> void { repaintAllChildren(delay); };
data->callbacks->resetQtGrabbedControl = []() -> bool { return false; };
}
FramelessManager::instance()->addWindow(&params);
std::ignore = tryGetExtraData(data, true);
data->params = params;
data->ready = true;
std::ignore = FramelessManager::instance()->addWindow(window, windowId);
// We have to wait for a little time before moving the top level window
// , because the platform window may not finish initializing by the time
@ -198,17 +240,11 @@ void FramelessQuickHelperPrivate::attach()
void FramelessQuickHelperPrivate::detach()
{
Q_Q(FramelessQuickHelper);
QQuickWindow * const w = q->window();
if (!w) {
const QQuickWindow *window = q->window();
if (!window) {
return;
}
const WId windowId = w->winId();
const auto it = g_framelessQuickHelperData()->constFind(windowId);
if (it == g_framelessQuickHelperData()->constEnd()) {
return;
}
g_framelessQuickHelperData()->erase(it);
FramelessManager::instance()->removeWindow(windowId);
std::ignore = FramelessManager::instance()->removeWindow(window);
}
void FramelessQuickHelperPrivate::emitSignalForAllInstances(const char *signal)
@ -433,37 +469,43 @@ bool FramelessQuickHelperPrivate::isInSystemButtons(const QPoint &pos, QuickGlob
if (!button) {
return false;
}
const FramelessQuickHelperData *data = getWindowData();
if (!data) {
Q_Q(const FramelessQuickHelper);
const QQuickWindow * const window = q->window();
if (!window) {
return false;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(window, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
*button = QuickGlobal::SystemButtonType::Unknown;
if (data->windowIconButton && data->windowIconButton->isVisible() && data->windowIconButton->isEnabled()) {
if (mapItemGeometryToScene(data->windowIconButton).contains(pos)) {
if (extraData->windowIconButton && extraData->windowIconButton->isVisible() && extraData->windowIconButton->isEnabled()) {
if (mapItemGeometryToScene(extraData->windowIconButton).contains(pos)) {
*button = QuickGlobal::SystemButtonType::WindowIcon;
return true;
}
}
if (data->contextHelpButton && data->contextHelpButton->isVisible() && data->contextHelpButton->isEnabled()) {
if (mapItemGeometryToScene(data->contextHelpButton).contains(pos)) {
if (extraData->contextHelpButton && extraData->contextHelpButton->isVisible() && extraData->contextHelpButton->isEnabled()) {
if (mapItemGeometryToScene(extraData->contextHelpButton).contains(pos)) {
*button = QuickGlobal::SystemButtonType::Help;
return true;
}
}
if (data->minimizeButton && data->minimizeButton->isVisible() && data->minimizeButton->isEnabled()) {
if (mapItemGeometryToScene(data->minimizeButton).contains(pos)) {
if (extraData->minimizeButton && extraData->minimizeButton->isVisible() && extraData->minimizeButton->isEnabled()) {
if (mapItemGeometryToScene(extraData->minimizeButton).contains(pos)) {
*button = QuickGlobal::SystemButtonType::Minimize;
return true;
}
}
if (data->maximizeButton && data->maximizeButton->isVisible() && data->maximizeButton->isEnabled()) {
if (mapItemGeometryToScene(data->maximizeButton).contains(pos)) {
if (extraData->maximizeButton && extraData->maximizeButton->isVisible() && extraData->maximizeButton->isEnabled()) {
if (mapItemGeometryToScene(extraData->maximizeButton).contains(pos)) {
*button = QuickGlobal::SystemButtonType::Maximize;
return true;
}
}
if (data->closeButton && data->closeButton->isVisible() && data->closeButton->isEnabled()) {
if (mapItemGeometryToScene(data->closeButton).contains(pos)) {
if (extraData->closeButton && extraData->closeButton->isVisible() && extraData->closeButton->isEnabled()) {
if (mapItemGeometryToScene(extraData->closeButton).contains(pos)) {
*button = QuickGlobal::SystemButtonType::Close;
return true;
}
@ -473,18 +515,6 @@ bool FramelessQuickHelperPrivate::isInSystemButtons(const QPoint &pos, QuickGlob
bool FramelessQuickHelperPrivate::isInTitleBarDraggableArea(const QPoint &pos) const
{
const FramelessQuickHelperData *data = getWindowData();
if (!data) {
return false;
}
if (!data->titleBarItem) {
// There's no title bar at all, the mouse will always be in the client area.
return false;
}
if (!data->titleBarItem->isVisible() || !data->titleBarItem->isEnabled()) {
// The title bar is hidden or disabled for some reason, treat it as there's no title bar.
return false;
}
Q_Q(const FramelessQuickHelper);
const QQuickWindow * const window = q->window();
if (!window) {
@ -492,8 +522,21 @@ bool FramelessQuickHelperPrivate::isInTitleBarDraggableArea(const QPoint &pos) c
// so we assume there's no title bar.
return false;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(window, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
if (!extraData->titleBarItem) {
// There's no title bar at all, the mouse will always be in the client area.
return false;
}
if (!extraData->titleBarItem->isVisible() || !extraData->titleBarItem->isEnabled()) {
// The title bar is hidden or disabled for some reason, treat it as there's no title bar.
return false;
}
const QRect windowRect = {QPoint(0, 0), window->size()};
const QRect titleBarRect = mapItemGeometryToScene(data->titleBarItem);
const QRect titleBarRect = mapItemGeometryToScene(extraData->titleBarItem);
if (!titleBarRect.intersects(windowRect)) {
// The title bar is totally outside of the window for some reason,
// also treat it as there's no title bar.
@ -501,24 +544,24 @@ bool FramelessQuickHelperPrivate::isInTitleBarDraggableArea(const QPoint &pos) c
}
QRegion region = titleBarRect;
const auto systemButtons = {
data->windowIconButton, data->contextHelpButton,
data->minimizeButton, data->maximizeButton,
data->closeButton
extraData->windowIconButton, extraData->contextHelpButton,
extraData->minimizeButton, extraData->maximizeButton,
extraData->closeButton
};
for (auto &&button : std::as_const(systemButtons)) {
if (button && button->isVisible() && button->isEnabled()) {
region -= mapItemGeometryToScene(button);
}
}
if (!data->hitTestVisibleItems.isEmpty()) {
for (auto &&item : std::as_const(data->hitTestVisibleItems)) {
if (!extraData->hitTestVisibleItems.isEmpty()) {
for (auto &&item : std::as_const(extraData->hitTestVisibleItems)) {
if (item && item->isVisible() && item->isEnabled()) {
region -= mapItemGeometryToScene(item);
}
}
}
if (!data->hitTestVisibleRects.isEmpty()) {
for (auto &&rect : std::as_const(data->hitTestVisibleRects)) {
if (!extraData->hitTestVisibleRects.isEmpty()) {
for (auto &&rect : std::as_const(extraData->hitTestVisibleRects)) {
if (rect.isValid()) {
region -= rect;
}
@ -556,38 +599,6 @@ void FramelessQuickHelperPrivate::setSystemButtonState(const QuickGlobal::System
Q_UNUSED(state);
}
const FramelessQuickHelperData *FramelessQuickHelperPrivate::getWindowData() const
{
Q_Q(const FramelessQuickHelper);
const QQuickWindow * const window = q->window();
//Q_ASSERT(window);
if (!window) {
return nullptr;
}
const WId windowId = window->winId();
auto it = g_framelessQuickHelperData()->find(windowId);
if (it == g_framelessQuickHelperData()->end()) {
it = g_framelessQuickHelperData()->insert(windowId, {});
}
return &it.value();
}
FramelessQuickHelperData *FramelessQuickHelperPrivate::getWindowDataMutable() const
{
Q_Q(const FramelessQuickHelper);
const QQuickWindow * const window = q->window();
//Q_ASSERT(window);
if (!window) {
return nullptr;
}
const WId windowId = window->winId();
auto it = g_framelessQuickHelperData()->find(windowId);
if (it == g_framelessQuickHelperData()->end()) {
it = g_framelessQuickHelperData()->insert(windowId, {});
}
return &it.value();
}
void FramelessQuickHelperPrivate::rebindWindow()
{
Q_Q(FramelessQuickHelper);
@ -668,33 +679,41 @@ void FramelessQuickHelper::setHitTestVisible_item(QQuickItem *item, const bool v
if (!item) {
return;
}
Q_D(FramelessQuickHelper);
FramelessQuickHelperData *data = d->getWindowDataMutable();
if (!data) {
const QQuickWindow * const w = window();
if (!w) {
return;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(w, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
if (visible) {
data->hitTestVisibleItems.append(item);
extraData->hitTestVisibleItems.append(item);
} else {
data->hitTestVisibleItems.removeAll(item);
extraData->hitTestVisibleItems.removeAll(item);
}
}
void FramelessQuickHelper::setHitTestVisible_rect(const QRect &rect, const bool visible)
{
Q_ASSERT(rect.isValid());
if (!rect.isValid()) {
Q_ASSERT(Utils::isValidGeometry(rect));
if (!Utils::isValidGeometry(rect)) {
return;
}
Q_D(FramelessQuickHelper);
FramelessQuickHelperData *data = d->getWindowDataMutable();
if (!data) {
const QQuickWindow * const w = window();
if (!w) {
return;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(w, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
if (visible) {
data->hitTestVisibleRects.append(rect);
extraData->hitTestVisibleRects.append(rect);
} else {
data->hitTestVisibleRects.removeAll(rect);
extraData->hitTestVisibleRects.removeAll(rect);
}
}
@ -714,9 +733,12 @@ void FramelessQuickHelper::setHitTestVisible_object(QObject *object, const bool
bool FramelessQuickHelper::isContentExtendedIntoTitleBar() const
{
Q_D(const FramelessQuickHelper);
const FramelessQuickHelperData *data = d->getWindowData();
return (data ? data->ready : false);
const QQuickWindow * const w = window();
if (!w) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(w);
return (data && data->frameless);
}
void FramelessQuickHelper::extendsContentIntoTitleBar(const bool value)
@ -736,9 +758,16 @@ void FramelessQuickHelper::extendsContentIntoTitleBar(const bool value)
QQuickItem *FramelessQuickHelper::titleBarItem() const
{
Q_D(const FramelessQuickHelper);
const FramelessQuickHelperData *data = d->getWindowData();
return (data ? data->titleBarItem : nullptr);
const QQuickWindow * const w = window();
if (!w) {
return nullptr;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(w, false);
Q_ASSERT(extraData);
if (!extraData) {
return nullptr;
}
return extraData->titleBarItem;
}
void FramelessQuickHelper::setTitleBarItem(QQuickItem *value)
@ -747,12 +776,17 @@ void FramelessQuickHelper::setTitleBarItem(QQuickItem *value)
if (!value) {
return;
}
Q_D(FramelessQuickHelper);
FramelessQuickHelperData *data = d->getWindowDataMutable();
if (!data || (data->titleBarItem == value)) {
const QQuickWindow * const w = window();
if (!w) {
return;
}
data->titleBarItem = value;
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(w, false);
Q_ASSERT(extraData);
if (!extraData || (extraData->titleBarItem == value)) {
return;
}
extraData->titleBarItem = value;
Q_D(FramelessQuickHelper);
d->emitSignalForAllInstances("titleBarItemChanged");
}
@ -763,27 +797,31 @@ void FramelessQuickHelper::setSystemButton(QQuickItem *item, const QuickGlobal::
if (!item || (buttonType == QuickGlobal::SystemButtonType::Unknown)) {
return;
}
Q_D(FramelessQuickHelper);
FramelessQuickHelperData *data = d->getWindowDataMutable();
if (!data) {
const QQuickWindow * const w = window();
if (!w) {
return;
}
const FramelessQuickHelperExtraDataPtr extraData = tryGetExtraData(w, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
switch (buttonType) {
case QuickGlobal::SystemButtonType::WindowIcon:
data->windowIconButton = item;
extraData->windowIconButton = item;
break;
case QuickGlobal::SystemButtonType::Help:
data->contextHelpButton = item;
extraData->contextHelpButton = item;
break;
case QuickGlobal::SystemButtonType::Minimize:
data->minimizeButton = item;
extraData->minimizeButton = item;
break;
case QuickGlobal::SystemButtonType::Maximize:
case QuickGlobal::SystemButtonType::Restore:
data->maximizeButton = item;
extraData->maximizeButton = item;
break;
case QuickGlobal::SystemButtonType::Close:
data->closeButton = item;
extraData->closeButton = item;
break;
case QuickGlobal::SystemButtonType::Unknown:
Q_UNREACHABLE();
@ -799,8 +837,7 @@ void FramelessQuickHelper::showSystemMenu(const QPoint &pos)
const WId windowId = w->winId();
const QPoint nativePos = Utils::toNativeGlobalPosition(w, pos);
#ifdef Q_OS_WINDOWS
Q_D(FramelessQuickHelper);
std::ignore = Utils::showSystemMenu(windowId, nativePos, false, &d->getWindowData()->params);
std::ignore = Utils::showSystemMenu(windowId, nativePos, false);
#elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
Utils::openSystemMenu(windowId, nativePos);
#else
@ -832,11 +869,11 @@ void FramelessQuickHelper::windowStartSystemResize2(const Qt::Edges edges, const
void FramelessQuickHelper::moveWindowToDesktopCenter()
{
if (!window()) {
const QQuickWindow * const w = window();
if (!w) {
return;
}
Q_D(FramelessQuickHelper);
Utils::moveWindowToDesktopCenter(&d->getWindowData()->params, true);
std::ignore = Utils::moveWindowToDesktopCenter(w->winId(), true);
}
void FramelessQuickHelper::bringWindowToFront()

314
src/widgets/framelesswidgetshelper.cpp
View File

@ -35,6 +35,7 @@
#include "widgetssharedhelper_p.h"
#include <FramelessHelper/Core/framelessmanager.h>
#include <FramelessHelper/Core/utils.h>
#include <FramelessHelper/Core/private/framelessmanager_p.h>
#include <FramelessHelper/Core/private/framelessconfig_p.h>
#include <FramelessHelper/Core/private/framelesshelpercore_global_p.h>
#include <QtCore/qhash.h>
@ -71,10 +72,8 @@ FRAMELESSHELPER_BEGIN_NAMESPACE
using namespace Global;
struct FramelessWidgetsHelperData
struct FramelessWidgetsHelperExtraData : public FramelessExtraData
{
bool ready = false;
SystemParameters params = {};
QPointer<QWidget> titleBarWidget = nullptr;
QList<QPointer<QWidget>> hitTestVisibleWidgets = {};
QPointer<QWidget> windowIconButton = nullptr;
@ -83,13 +82,54 @@ struct FramelessWidgetsHelperData
QPointer<QWidget> maximizeButton = nullptr;
QPointer<QWidget> closeButton = nullptr;
QList<QRect> hitTestVisibleRects = {};
FramelessWidgetsHelperExtraData();
~FramelessWidgetsHelperExtraData() override;
[[nodiscard]] static FramelessExtraDataPtr create();
};
using FramelessWidgetsHelperExtraDataPtr = std::shared_ptr<FramelessWidgetsHelperExtraData>;
using FramelessWidgetsHelperInternal = QHash<WId, FramelessWidgetsHelperData>;
FramelessWidgetsHelperExtraData::FramelessWidgetsHelperExtraData() = default;
Q_GLOBAL_STATIC(FramelessWidgetsHelperInternal, g_framelessWidgetsHelperData)
FramelessWidgetsHelperExtraData::~FramelessWidgetsHelperExtraData() = default;
[[nodiscard]] static inline bool isWidgetFixedSize(const QWidget * const widget)
FramelessExtraDataPtr FramelessWidgetsHelperExtraData::create()
{
return std::make_shared<FramelessWidgetsHelperExtraData>();
}
[[nodiscard]] static inline FramelessWidgetsHelperExtraDataPtr tryGetExtraData(const FramelessDataPtr &data, const bool create)
{
Q_ASSERT(data);
if (!data) {
return nullptr;
}
auto it = data->extraData.find(ExtraDataType::FramelessWidgetsHelper);
if (it == data->extraData.end()) {
if (create) {
it = data->extraData.insert(ExtraDataType::FramelessWidgetsHelper, FramelessWidgetsHelperExtraData::create());
} else {
return nullptr;
}
}
return std::dynamic_pointer_cast<FramelessWidgetsHelperExtraData>(it.value());
}
[[nodiscard]] static inline FramelessWidgetsHelperExtraDataPtr tryGetExtraData(const QWidget *window, const bool create)
{
Q_ASSERT(window);
if (!window) {
return nullptr;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
if (!data) {
return nullptr;
}
return tryGetExtraData(data, create);
}
[[nodiscard]] static inline bool isWidgetFixedSize(const QWidget *widget)
{
Q_ASSERT(widget);
if (!widget) {
@ -114,7 +154,7 @@ Q_GLOBAL_STATIC(FramelessWidgetsHelperInternal, g_framelessWidgetsHelperData)
return false;
}
static inline void forceWidgetRepaint(QWidget * const widget)
static inline void forceWidgetRepaint(QWidget *widget)
{
Q_ASSERT(widget);
if (!widget) {
@ -360,7 +400,7 @@ void FramelessWidgetsHelperPrivate::setReadyWaitTime(const quint32 time)
void FramelessWidgetsHelperPrivate::attach()
{
QWidget * const tlw = findTopLevelWindow();
QWidget *tlw = findTopLevelWindow();
Q_ASSERT(tlw);
if (!tlw) {
return;
@ -377,51 +417,54 @@ void FramelessWidgetsHelperPrivate::attach()
window->setAttribute(Qt::WA_NativeWindow);
}
FramelessWidgetsHelperData * const data = getWindowDataMutable();
if (!data || data->ready) {
const WId windowId = window->winId();
const FramelessDataPtr data = FramelessManagerPrivate::createData(window, windowId);
Q_ASSERT(data);
if (!data || data->frameless) {
return;
}
Q_Q(FramelessWidgetsHelper);
SystemParameters params = {};
params.getWindowId = [this]() -> WId { return window->winId(); };
params.getWindowFlags = [this]() -> Qt::WindowFlags { return window->windowFlags(); };
params.setWindowFlags = [this](const Qt::WindowFlags flags) -> void { window->setWindowFlags(flags); };
params.getWindowSize = [this]() -> QSize { return window->size(); };
params.setWindowSize = [this](const QSize &size) -> void { window->resize(size); };
params.getWindowPosition = [this]() -> QPoint { return window->pos(); };
params.setWindowPosition = [this](const QPoint &pos) -> void { window->move(pos); };
params.getWindowScreen = [this]() -> QScreen * {
if (!data->callbacks) {
data->callbacks = FramelessCallbacks::create();
data->callbacks->getWindowId = [this]() -> WId { return window->winId(); };
data->callbacks->getWindowFlags = [this]() -> Qt::WindowFlags { return window->windowFlags(); };
data->callbacks->setWindowFlags = [this](const Qt::WindowFlags flags) -> void { window->setWindowFlags(flags); };
data->callbacks->getWindowSize = [this]() -> QSize { return window->size(); };
data->callbacks->setWindowSize = [this](const QSize &size) -> void { window->resize(size); };
data->callbacks->getWindowPosition = [this]() -> QPoint { return window->pos(); };
data->callbacks->setWindowPosition = [this](const QPoint &pos) -> void { window->move(pos); };
data->callbacks->getWindowScreen = [this]() -> QScreen * {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
return window->screen();
#else
return window->windowHandle()->screen();
#endif
};
params.isWindowFixedSize = [q]() -> bool { return q->isWindowFixedSize(); };
params.setWindowFixedSize = [q](const bool value) -> void { q->setWindowFixedSize(value); };
params.getWindowState = [this]() -> Qt::WindowState { return Utils::windowStatesToWindowState(window->windowState()); };
params.setWindowState = [this](const Qt::WindowState state) -> void { window->setWindowState(state); };
params.getWindowHandle = [this]() -> QWindow * { return window->windowHandle(); };
params.windowToScreen = [this](const QPoint &pos) -> QPoint { return window->mapToGlobal(pos); };
params.screenToWindow = [this](const QPoint &pos) -> QPoint { return window->mapFromGlobal(pos); };
params.isInsideSystemButtons = [this](const QPoint &pos, SystemButtonType *button) -> bool { return isInSystemButtons(pos, button); };
params.isInsideTitleBarDraggableArea = [this](const QPoint &pos) -> bool { return isInTitleBarDraggableArea(pos); };
params.getWindowDevicePixelRatio = [this]() -> qreal { return window->devicePixelRatioF(); };
params.setSystemButtonState = [this](const SystemButtonType button, const ButtonState state) -> void { setSystemButtonState(button, state); };
params.shouldIgnoreMouseEvents = [this](const QPoint &pos) -> bool { return shouldIgnoreMouseEvents(pos); };
params.showSystemMenu = [q](const QPoint &pos) -> void { q->showSystemMenu(pos); };
params.setProperty = [this](const char *name, const QVariant &value) -> void { setProperty(name, value); };
params.getProperty = [this](const char *name, const QVariant &defaultValue) -> QVariant { return getProperty(name, defaultValue); };
params.setCursor = [this](const QCursor &cursor) -> void { window->setCursor(cursor); };
params.unsetCursor = [this]() -> void { window->unsetCursor(); };
params.getWidgetHandle = [this]() -> QObject * { return window; };
params.forceChildrenRepaint = [this](const int delay) -> void { repaintAllChildren(delay); };
params.resetQtGrabbedControl = []() -> bool {
data->callbacks->isWindowFixedSize = [q]() -> bool { return q->isWindowFixedSize(); };
data->callbacks->setWindowFixedSize = [q](const bool value) -> void { q->setWindowFixedSize(value); };
data->callbacks->getWindowState = [this]() -> Qt::WindowState { return Utils::windowStatesToWindowState(window->windowState()); };
data->callbacks->setWindowState = [this](const Qt::WindowState state) -> void { window->setWindowState(state); };
data->callbacks->getWindowHandle = [this]() -> QWindow * { return window->windowHandle(); };
data->callbacks->windowToScreen = [this](const QPoint &pos) -> QPoint { return window->mapToGlobal(pos); };
data->callbacks->screenToWindow = [this](const QPoint &pos) -> QPoint { return window->mapFromGlobal(pos); };
data->callbacks->isInsideSystemButtons = [this](const QPoint &pos, SystemButtonType *button) -> bool { return isInSystemButtons(pos, button); };
data->callbacks->isInsideTitleBarDraggableArea = [this](const QPoint &pos) -> bool { return isInTitleBarDraggableArea(pos); };
data->callbacks->getWindowDevicePixelRatio = [this]() -> qreal { return window->devicePixelRatioF(); };
data->callbacks->setSystemButtonState = [this](const SystemButtonType button, const ButtonState state) -> void { setSystemButtonState(button, state); };
data->callbacks->shouldIgnoreMouseEvents = [this](const QPoint &pos) -> bool { return shouldIgnoreMouseEvents(pos); };
data->callbacks->showSystemMenu = [q](const QPoint &pos) -> void { q->showSystemMenu(pos); };
data->callbacks->setProperty = [this](const char *name, const QVariant &value) -> void { setProperty(name, value); };
data->callbacks->getProperty = [this](const char *name, const QVariant &defaultValue) -> QVariant { return getProperty(name, defaultValue); };
data->callbacks->setCursor = [this](const QCursor &cursor) -> void { window->setCursor(cursor); };
data->callbacks->unsetCursor = [this]() -> void { window->unsetCursor(); };
data->callbacks->getWidgetHandle = [this]() -> QObject * { return window; };
data->callbacks->forceChildrenRepaint = [this](const int delay) -> void { repaintAllChildren(delay); };
data->callbacks->resetQtGrabbedControl = []() -> bool {
if (qt_button_down) {
static constexpr const auto invalidPos = QPoint{ -99999, -99999 };
const auto event = std::make_unique<QMouseEvent>(
const auto event = new QMouseEvent(
QEvent::MouseButtonRelease,
invalidPos,
invalidPos,
@ -429,17 +472,17 @@ void FramelessWidgetsHelperPrivate::attach()
Qt::LeftButton,
QGuiApplication::mouseButtons() ^ Qt::LeftButton,
QGuiApplication::keyboardModifiers());
QApplication::sendEvent(qt_button_down, event.get());
QApplication::postEvent(qt_button_down, event);
qt_button_down = nullptr;
return true;
}
return false;
};
}
FramelessManager::instance()->addWindow(&params);
std::ignore = tryGetExtraData(data, true);
data->params = params;
data->ready = true;
std::ignore = FramelessManager::instance()->addWindow(window, windowId);
// We have to wait for a little time before moving the top level window
// , because the platform window may not finish initializing by the time
@ -464,13 +507,7 @@ void FramelessWidgetsHelperPrivate::detach()
if (!window) {
return;
}
const WId windowId = window->winId();
const auto it = g_framelessWidgetsHelperData()->constFind(windowId);
if (it == g_framelessWidgetsHelperData()->constEnd()) {
return;
}
g_framelessWidgetsHelperData()->erase(it);
FramelessManager::instance()->removeWindow(windowId);
std::ignore = FramelessManager::instance()->removeWindow(window);
window = nullptr;
emitSignalForAllInstances("windowChanged");
}
@ -488,34 +525,6 @@ QWidget *FramelessWidgetsHelperPrivate::findTopLevelWindow() const
return nullptr;
}
const FramelessWidgetsHelperData *FramelessWidgetsHelperPrivate::getWindowData() const
{
//Q_ASSERT(window);
if (!window) {
return nullptr;
}
const WId windowId = window->winId();
auto it = g_framelessWidgetsHelperData()->find(windowId);
if (it == g_framelessWidgetsHelperData()->end()) {
it = g_framelessWidgetsHelperData()->insert(windowId, {});
}
return &it.value();
}
FramelessWidgetsHelperData *FramelessWidgetsHelperPrivate::getWindowDataMutable() const
{
//Q_ASSERT(window);
if (!window) {
return nullptr;
}
const WId windowId = window->winId();
auto it = g_framelessWidgetsHelperData()->find(windowId);
if (it == g_framelessWidgetsHelperData()->end()) {
it = g_framelessWidgetsHelperData()->insert(windowId, {});
}
return &it.value();
}
QRect FramelessWidgetsHelperPrivate::mapWidgetGeometryToScene(const QWidget * const widget) const
{
Q_ASSERT(widget);
@ -536,37 +545,41 @@ bool FramelessWidgetsHelperPrivate::isInSystemButtons(const QPoint &pos, SystemB
if (!button) {
return false;
}
const FramelessWidgetsHelperData *data = getWindowData();
if (!data) {
if (!window) {
return false;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(window, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
*button = SystemButtonType::Unknown;
if (data->windowIconButton && data->windowIconButton->isVisible() && data->windowIconButton->isEnabled()) {
if (mapWidgetGeometryToScene(data->windowIconButton).contains(pos)) {
if (extraData->windowIconButton && extraData->windowIconButton->isVisible() && extraData->windowIconButton->isEnabled()) {
if (mapWidgetGeometryToScene(extraData->windowIconButton).contains(pos)) {
*button = SystemButtonType::WindowIcon;
return true;
}
}
if (data->contextHelpButton && data->contextHelpButton->isVisible() && data->contextHelpButton->isEnabled()) {
if (mapWidgetGeometryToScene(data->contextHelpButton).contains(pos)) {
if (extraData->contextHelpButton && extraData->contextHelpButton->isVisible() && extraData->contextHelpButton->isEnabled()) {
if (mapWidgetGeometryToScene(extraData->contextHelpButton).contains(pos)) {
*button = SystemButtonType::Help;
return true;
}
}
if (data->minimizeButton && data->minimizeButton->isVisible() && data->minimizeButton->isEnabled()) {
if (mapWidgetGeometryToScene(data->minimizeButton).contains(pos)) {
if (extraData->minimizeButton && extraData->minimizeButton->isVisible() && extraData->minimizeButton->isEnabled()) {
if (mapWidgetGeometryToScene(extraData->minimizeButton).contains(pos)) {
*button = SystemButtonType::Minimize;
return true;
}
}
if (data->maximizeButton && data->maximizeButton->isVisible() && data->maximizeButton->isEnabled()) {
if (mapWidgetGeometryToScene(data->maximizeButton).contains(pos)) {
if (extraData->maximizeButton && extraData->maximizeButton->isVisible() && extraData->maximizeButton->isEnabled()) {
if (mapWidgetGeometryToScene(extraData->maximizeButton).contains(pos)) {
*button = SystemButtonType::Maximize;
return true;
}
}
if (data->closeButton && data->closeButton->isVisible() && data->closeButton->isEnabled()) {
if (mapWidgetGeometryToScene(data->closeButton).contains(pos)) {
if (extraData->closeButton && extraData->closeButton->isVisible() && extraData->closeButton->isEnabled()) {
if (mapWidgetGeometryToScene(extraData->closeButton).contains(pos)) {
*button = SystemButtonType::Close;
return true;
}
@ -576,25 +589,26 @@ bool FramelessWidgetsHelperPrivate::isInSystemButtons(const QPoint &pos, SystemB
bool FramelessWidgetsHelperPrivate::isInTitleBarDraggableArea(const QPoint &pos) const
{
const FramelessWidgetsHelperData *data = getWindowData();
if (!data) {
return false;
}
if (!data->titleBarWidget) {
// There's no title bar at all, the mouse will always be in the client area.
return false;
}
if (!data->titleBarWidget->isVisible() || !data->titleBarWidget->isEnabled()) {
// The title bar is hidden or disabled for some reason, treat it as there's no title bar.
return false;
}
if (!window) {
// The FramelessWidgetsHelper object has not been attached to a specific window yet,
// so we assume there's no title bar.
return false;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(window, false);
Q_ASSERT(extraData);
if (!extraData) {
return false;
}
if (!extraData->titleBarWidget) {
// There's no title bar at all, the mouse will always be in the client area.
return false;
}
if (!extraData->titleBarWidget->isVisible() || !extraData->titleBarWidget->isEnabled()) {
// The title bar is hidden or disabled for some reason, treat it as there's no title bar.
return false;
}
const QRect windowRect = {QPoint(0, 0), window->size()};
const QRect titleBarRect = mapWidgetGeometryToScene(data->titleBarWidget);
const QRect titleBarRect = mapWidgetGeometryToScene(extraData->titleBarWidget);
if (!titleBarRect.intersects(windowRect)) {
// The title bar is totally outside of the window for some reason,
// also treat it as there's no title bar.
@ -602,24 +616,24 @@ bool FramelessWidgetsHelperPrivate::isInTitleBarDraggableArea(const QPoint &pos)
}
QRegion region = titleBarRect;
const auto systemButtons = {
data->windowIconButton, data->contextHelpButton,
data->minimizeButton, data->maximizeButton,
data->closeButton
extraData->windowIconButton, extraData->contextHelpButton,
extraData->minimizeButton, extraData->maximizeButton,
extraData->closeButton
};
for (auto &&button : std::as_const(systemButtons)) {
if (button && button->isVisible() && button->isEnabled()) {
region -= mapWidgetGeometryToScene(button);
}
}
if (!data->hitTestVisibleWidgets.isEmpty()) {
for (auto &&widget : std::as_const(data->hitTestVisibleWidgets)) {
if (!extraData->hitTestVisibleWidgets.isEmpty()) {
for (auto &&widget : std::as_const(extraData->hitTestVisibleWidgets)) {
if (widget && widget->isVisible() && widget->isEnabled()) {
region -= mapWidgetGeometryToScene(widget);
}
}
}
if (!data->hitTestVisibleRects.isEmpty()) {
for (auto &&rect : std::as_const(data->hitTestVisibleRects)) {
if (!extraData->hitTestVisibleRects.isEmpty()) {
for (auto &&rect : std::as_const(extraData->hitTestVisibleRects)) {
if (rect.isValid()) {
region -= rect;
}
@ -660,7 +674,7 @@ void FramelessWidgetsHelper::moveWindowToDesktopCenter()
if (!d->window) {
return;
}
Utils::moveWindowToDesktopCenter(&d->getWindowData()->params, true);
std::ignore = Utils::moveWindowToDesktopCenter(d->window->winId(), true);
}
void FramelessWidgetsHelper::bringWindowToFront()
@ -692,7 +706,7 @@ void FramelessWidgetsHelper::showSystemMenu(const QPoint &pos)
const WId windowId = d->window->winId();
const QPoint nativePos = Utils::toNativeGlobalPosition(d->window->windowHandle(), pos);
#ifdef Q_OS_WINDOWS
std::ignore = Utils::showSystemMenu(windowId, nativePos, false, &d->getWindowData()->params);
std::ignore = Utils::showSystemMenu(windowId, nativePos, false);
#elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
Utils::openSystemMenu(windowId, nativePos);
#else
@ -730,26 +744,30 @@ void FramelessWidgetsHelper::setSystemButton(QWidget *widget, const SystemButton
return;
}
Q_D(FramelessWidgetsHelper);
FramelessWidgetsHelperData *data = d->getWindowDataMutable();
if (!data) {
if (!d->window) {
return;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(d->window, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
switch (buttonType) {
case SystemButtonType::WindowIcon:
data->windowIconButton = widget;
extraData->windowIconButton = widget;
break;
case SystemButtonType::Help:
data->contextHelpButton = widget;
extraData->contextHelpButton = widget;
break;
case SystemButtonType::Minimize:
data->minimizeButton = widget;
extraData->minimizeButton = widget;
break;
case SystemButtonType::Maximize:
case SystemButtonType::Restore:
data->maximizeButton = widget;
extraData->maximizeButton = widget;
break;
case SystemButtonType::Close:
data->closeButton = widget;
extraData->closeButton = widget;
break;
case SystemButtonType::Unknown:
Q_UNREACHABLE();
@ -895,8 +913,11 @@ void FramelessWidgetsHelper::waitForReady()
bool FramelessWidgetsHelper::isContentExtendedIntoTitleBar() const
{
Q_D(const FramelessWidgetsHelper);
const FramelessWidgetsHelperData *data = d->getWindowData();
return (data ? data->ready : false);
if (!d->window) {
return false;
}
const FramelessDataPtr data = FramelessManagerPrivate::getData(d->window);
return (data && data->frameless);
}
void FramelessWidgetsHelper::setTitleBarWidget(QWidget *widget)
@ -906,19 +927,30 @@ void FramelessWidgetsHelper::setTitleBarWidget(QWidget *widget)
return;
}
Q_D(FramelessWidgetsHelper);
FramelessWidgetsHelperData *data = d->getWindowDataMutable();
if (!data || (data->titleBarWidget == widget)) {
if (!d->window) {
return;
}
data->titleBarWidget = widget;
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(d->window, false);
Q_ASSERT(extraData);
if (!extraData || (extraData->titleBarWidget == widget)) {
return;
}
extraData->titleBarWidget = widget;
d->emitSignalForAllInstances("titleBarWidgetChanged");
}
QWidget *FramelessWidgetsHelper::titleBarWidget() const
{
Q_D(const FramelessWidgetsHelper);
const FramelessWidgetsHelperData *data = d->getWindowData();
return (data ? data->titleBarWidget : nullptr);
if (!d->window) {
return nullptr;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(d->window, false);
Q_ASSERT(extraData);
if (!extraData) {
return nullptr;
}
return extraData->titleBarWidget;
}
void FramelessWidgetsHelper::setHitTestVisible(QWidget *widget, const bool visible)
@ -928,32 +960,40 @@ void FramelessWidgetsHelper::setHitTestVisible(QWidget *widget, const bool visib
return;
}
Q_D(FramelessWidgetsHelper);
FramelessWidgetsHelperData *data = d->getWindowDataMutable();
if (!data) {
if (!d->window) {
return;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(d->window, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
if (visible) {
data->hitTestVisibleWidgets.append(widget);
extraData->hitTestVisibleWidgets.append(widget);
} else {
data->hitTestVisibleWidgets.removeAll(widget);
extraData->hitTestVisibleWidgets.removeAll(widget);
}
}
void FramelessWidgetsHelper::setHitTestVisible(const QRect &rect, const bool visible)
{
Q_ASSERT(rect.isValid());
if (!rect.isValid()) {
Q_ASSERT(Utils::isValidGeometry(rect));
if (!Utils::isValidGeometry(rect)) {
return;
}
Q_D(FramelessWidgetsHelper);
FramelessWidgetsHelperData *data = d->getWindowDataMutable();
if (!data) {
if (!d->window) {
return;
}
const FramelessWidgetsHelperExtraDataPtr extraData = tryGetExtraData(d->window, false);
Q_ASSERT(extraData);
if (!extraData) {
return;
}
if (visible) {
data->hitTestVisibleRects.append(rect);
extraData->hitTestVisibleRects.append(rect);
} else {
data->hitTestVisibleRects.removeAll(rect);
extraData->hitTestVisibleRects.removeAll(rect);
}
}