wip

2023-09-14 22:29:40 +08:00 · 2023-09-14 17:58:50 +08:00
18 changed files with 939 additions and 807 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -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,25 +167,23 @@ 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")
-            # Make sure we will always overwrite the previous settings.
-            unset(CMAKE_MSVC_RUNTIME_LIBRARY)
-            unset(CMAKE_MSVC_RUNTIME_LIBRARY CACHE)
-            #unset(CMAKE_MSVC_RUNTIME_LIBRARY PARENT_SCOPE)
-            set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>" CACHE STRING "" FORCE)
-        endif()
-    endif()
-    if(FRAMELESSHELPER_ENABLE_YYTHUNKS)
-        unset(YYTHUNKS_TARGET_OS)
-        unset(YYTHUNKS_TARGET_OS CACHE)
-        #unset(YYTHUNKS_TARGET_OS PARENT_SCOPE)
-        set(YYTHUNKS_TARGET_OS "WinXP" CACHE STRING "" FORCE)
-        include(cmake/YY-Thunks.cmake)
+if(FRAMELESSHELPER_ENABLE_VCLTL)
+    include(cmake/VC-LTL.cmake)
+    if("x${SupportLTL}" STREQUAL "xtrue")
+        # Make sure we will always overwrite the previous settings.
+        unset(CMAKE_MSVC_RUNTIME_LIBRARY)
+        unset(CMAKE_MSVC_RUNTIME_LIBRARY CACHE)
+        #unset(CMAKE_MSVC_RUNTIME_LIBRARY PARENT_SCOPE)
+        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>" CACHE STRING "" FORCE)
    endif()
 endif()
+if(FRAMELESSHELPER_ENABLE_YYTHUNKS)
+    unset(YYTHUNKS_TARGET_OS)
+    unset(YYTHUNKS_TARGET_OS CACHE)
+    #unset(YYTHUNKS_TARGET_OS PARENT_SCOPE)
+    set(YYTHUNKS_TARGET_OS "WinXP" CACHE STRING "" FORCE)
+    include(cmake/YY-Thunks.cmake)
+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)
--- a/include/FramelessHelper/Core/framelesshelper_qt.h
+++ b/include/FramelessHelper/Core/framelesshelper_qt.h
@ -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
--- a/include/FramelessHelper/Core/framelesshelper_win.h
+++ b/include/FramelessHelper/Core/framelesshelper_win.h
@ -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 QWindow *window);
+    static void removeWindow(const QWindow *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
--- a/include/FramelessHelper/Core/framelesshelper_windows.h
+++ b/include/FramelessHelper/Core/framelesshelper_windows.h
@ -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,89 @@ 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 HWND hwnd)
+{
+    // NULL handle is allowed here.
+    return FRAMELESSHELPER_STRING_LITERAL("0x") + QString::number(reinterpret_cast<WId>(hwnd), 16).toUpper().rightJustified(8, u'0');
+}
--- a/include/FramelessHelper/Core/framelesshelpercore_global.h
+++ b/include/FramelessHelper/Core/framelesshelpercore_global.h
@ -312,7 +312,7 @@ Q_NAMESPACE_EXPORT(FRAMELESSHELPER_CORE_API)

 enum class Option : quint8
 {
-    UseCrossPlatformQtImplementation,
+    //UseCrossPlatformQtImplementation,
    ForceHideWindowFrameBorder,
    ForceShowWindowFrameBorder,
    DisableWindowsSnapLayout,
--- a/include/FramelessHelper/Core/framelessmanager.h
+++ b/include/FramelessHelper/Core/framelessmanager.h
@ -28,7 +28,6 @@

 FRAMELESSHELPER_BEGIN_NAMESPACE

-struct SystemParameters;
 class FramelessManagerPrivate;

 class FRAMELESSHELPER_CORE_API FramelessManager : public QObject
@ -45,14 +44,15 @@ class FRAMELESSHELPER_CORE_API FramelessManager : public QObject
 public:
    Q_NODISCARD static FramelessManager *instance();

+    Q_NODISCARD bool isFramelessWindow(const QWindow *window) const;
    Q_NODISCARD Global::SystemTheme systemTheme() const;
    Q_NODISCARD QColor systemAccentColor() const;
    Q_NODISCARD QString wallpaper() const;
    Q_NODISCARD Global::WallpaperAspectStyle wallpaperAspectStyle() const;

 public Q_SLOTS:
-    void addWindow(const SystemParameters *params);
-    void removeWindow(const WId windowId);
+    Q_NODISCARD bool addWindow(const QWindow *window);
+    Q_NODISCARD bool removeWindow(const QWindow *window);
    void setOverrideTheme(const Global::SystemTheme theme);

 Q_SIGNALS:
--- a/include/FramelessHelper/Core/private/framelesshelpercore_global_p.h
+++ b/include/FramelessHelper/Core/private/framelesshelpercore_global_p.h
@ -25,7 +25,10 @@
 #pragma once

 #include <FramelessHelper/Core/framelesshelpercore_global.h>
+#include <QtCore/qhash.h>
+#include <QtGui/qwindow.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 FramelessCallbacks
 {
    GetWindowFlagsCallback getWindowFlags = nullptr;
    SetWindowFlagsCallback setWindowFlags = nullptr;
@ -92,29 +95,68 @@ struct SystemParameters
    GetWidgetHandleCallback getWidgetHandle = nullptr;
    ForceChildrenRepaintCallback forceChildrenRepaint = nullptr;
    ResetQtGrabbedControlCallback resetQtGrabbedControl = nullptr;
-};

-using FramelessParams = SystemParameters *;
-using FramelessParamsConst = const SystemParameters *;
-using FramelessParamsRef = SystemParameters &;
-using FramelessParamsConstRef = const SystemParameters &;
+    using PtrType = std::shared_ptr<FramelessCallbacks>;
+    [[nodiscard]] static PtrType create();
+
+private:
+    Q_DISABLE_COPY_MOVE(FramelessCallbacks)
+};
+using FramelessCallbacksPtr = FramelessCallbacks::PtrType;
+
+struct FramelessData
+{
+    bool frameless = false;
+    FramelessCallbacksPtr callbacks = nullptr;
+    struct {
+        void *ptr = nullptr;
+        using DeleterFunctionPrototype = void(*)(void*);
+        DeleterFunctionPrototype deleter = nullptr;
+    } extraData = {};
+    
+    using PtrType = std::shared_ptr<FramelessData>;
+    [[nodiscard]] static PtrType create();
+
+    ~FramelessData();
+
+private:
+    Q_DISABLE_COPY_MOVE(FramelessData)
+};
+using FramelessDataPtr = FramelessData::PtrType;
+
+using FramelessDataHash = QHash<const QWindow *, FramelessDataPtr>;
+
+template<typename T>
+[[nodiscard]] T qWindowId(const QWindow *window)
+{
+    Q_ASSERT(window);
+    if (!window) {
+        return reinterpret_cast<T>(nullptr);
+    }
+    return reinterpret_cast<T>(window->winId());
+}

 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)
--- a/include/FramelessHelper/Core/private/framelessmanager_p.h
+++ b/include/FramelessHelper/Core/private/framelessmanager_p.h
@ -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,9 @@ public:
    void doNotifySystemThemeHasChangedOrNot();
    void doNotifyWallpaperHasChangedOrNot();

+    Q_NODISCARD static FramelessDataPtr getData(const QWindow *window);
+    static void removeData(const QWindow *window);
+
    FramelessManager *q_ptr = nullptr;
    Global::SystemTheme systemTheme = Global::SystemTheme::Unknown;
    std::optional<Global::SystemTheme> overrideTheme = std::nullopt;
--- a/include/FramelessHelper/Core/utils.h
+++ b/include/FramelessHelper/Core/utils.h
@ -42,25 +42,19 @@ 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 QWindow *window, 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 QWindow *window, 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();
@ -93,71 +87,61 @@ FRAMELESSHELPER_CORE_API void moveWindowToDesktopCenter(
 #ifdef Q_OS_WINDOWS
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool isWindowsVersionOrGreater(const Global::WindowsVersion version);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool isDwmCompositionEnabled();
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool triggerFrameChange(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateWindowFrameMargins(const WId windowId, const bool reset);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool triggerFrameChange(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateWindowFrameMargins(const QWindow *window, const bool reset);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool updateInternalWindowFrameMargins(QWindow *window, const bool enable);
 [[nodiscard]] FRAMELESSHELPER_CORE_API QString getSystemErrorMessage(const QString &function);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool isFullScreen(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool isWindowNoState(const WId windowId);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool isFullScreen(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool isWindowNoState(const QWindow *window);
 [[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 QWindow *window, 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 getWindowDpi(const QWindow *window, const bool horizontal);
+[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThicknessForDpi(const bool horizontal, const quint32 dpi);
+[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getResizeBorderThickness(const QWindow *window, 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 getCaptionBarHeight(const QWindow *window, 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 getTitleBarHeight(const QWindow *window, 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 bool maybeFixupQtInternals(const WId windowId);
+[[nodiscard]] FRAMELESSHELPER_CORE_API quint32 getFrameBorderThickness(const QWindow *window, const bool scaled);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool maybeFixupQtInternals(const QWindow *window);
 [[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 uninstallWindowProcHook(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool setAeroSnappingEnabled(const WId windowId, const bool enable);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool installWindowProcHook(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool uninstallWindowProcHook(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool setAeroSnappingEnabled(const QWindow *window, const bool enable);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool tryToEnableHighestDpiAwarenessLevel();
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateGlobalWin32ControlsTheme(const WId windowId, const bool dark);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateGlobalWin32ControlsTheme(const QWindow *window, const bool dark);
 [[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 setCornerStyleForWindow(const QWindow *window, const Global::WindowCornerStyle style);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool hideOriginalTitleBarElements(const QWindow *window, 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 bool fixupChildWindowsDpiMessage(const WId windowId);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool refreshWin32ThemeResources(const QWindow *window, const bool dark);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool enableNonClientAreaDpiScalingForWindow(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API Global::DpiAwareness getDpiAwarenessForCurrentProcess(bool *highest = nullptr);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool fixupChildWindowsDpiMessage(const QWindow *window);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool fixupDialogsDpiScaling();
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool setDarkModeAllowedForApp(const bool allow = true);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool bringWindowToFront(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API QPoint getWindowPlacementOffset(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API QRect getWindowRestoreGeometry(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool removeMicaWindow(const WId windowId);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool bringWindowToFront(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API QPoint getWindowPlacementOffset(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API QRect getWindowRestoreGeometry(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool removeMicaWindow(const QWindow *window);
 [[nodiscard]] FRAMELESSHELPER_CORE_API quint64 getKeyState();
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool isValidWindow(const WId windowId, const bool checkVisible, const bool checkTopLevel);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateFramebufferTransparency(const WId windowId);
-[[nodiscard]] FRAMELESSHELPER_CORE_API QMargins getWindowSystemFrameMargins(const WId windowId);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool isValidWindow(const QWindow *window, const bool checkVisible, const bool checkTopLevel);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool updateFramebufferTransparency(const QWindow *window);
+[[nodiscard]] FRAMELESSHELPER_CORE_API QMargins getWindowSystemFrameMargins(const QWindow *window);
 [[nodiscard]] FRAMELESSHELPER_CORE_API QMargins getWindowCustomFrameMargins(const QWindow *window);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool updateAllDirectXSurfaces();
 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,32 +150,27 @@ 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);
-FRAMELESSHELPER_CORE_API void clearWindowProperty(const WId windowId, const xcb_atom_t prop);
+[[nodiscard]] FRAMELESSHELPER_CORE_API QByteArray getWindowProperty(const QWindow *window, const xcb_atom_t prop, const xcb_atom_t type, const quint32 data_len);
+FRAMELESSHELPER_CORE_API void setWindowProperty(const QWindow *window, 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 QWindow *window, const xcb_atom_t prop);
 [[nodiscard]] FRAMELESSHELPER_CORE_API xcb_atom_t internAtom(const char *name);
 [[nodiscard]] FRAMELESSHELPER_CORE_API QString getWindowManagerName();
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool isSupportedByWindowManager(const xcb_atom_t atom);
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool isSupportedByRootWindow(const xcb_atom_t atom);
-[[nodiscard]] FRAMELESSHELPER_CORE_API bool tryHideSystemTitleBar(const WId windowId, const bool hide = true);
-FRAMELESSHELPER_CORE_API void openSystemMenu(const WId windowId, const QPoint &globalPos);
+[[nodiscard]] FRAMELESSHELPER_CORE_API bool tryHideSystemTitleBar(const QWindow *window, const bool hide = true);
+FRAMELESSHELPER_CORE_API void openSystemMenu(const QWindow *window, 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 QWindow *window, 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
 [[nodiscard]] FRAMELESSHELPER_CORE_API bool shouldAppsUseDarkMode_macos();
 [[nodiscard]] FRAMELESSHELPER_CORE_API QColor getAccentColor_macos();
-FRAMELESSHELPER_CORE_API void setSystemTitleBarVisible(const WId windowId, const bool visible);
-FRAMELESSHELPER_CORE_API void removeWindowProxy(const WId windowId);
+FRAMELESSHELPER_CORE_API void setSystemTitleBarVisible(const QWindow *window, const bool visible);
+FRAMELESSHELPER_CORE_API void removeWindowProxy(const QWindow *window);
 #endif // Q_OS_MACOS
 } // namespace Utils

--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@ -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)
--- a/src/core/framelesshelper_qt.cpp
+++ b/src/core/framelesshelper_qt.cpp
@ -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
--- a/src/core/framelesshelper_win.cpp
+++ b/src/core/framelesshelper_win.cpp
@ -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
@ -114,34 +115,14 @@ struct FramelessWin32HelperData
 #endif // (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
 };

-struct FramelessWin32HelperInternal
+#define GetFramelessDataWin(Window) std::dynamic_pointer_cast<FramelessDataWin>(FramelessManagerPrivate::getData(Window))
+
+[[nodiscard]] FramelessDataPtr FramelessData::create()
 {
-    std::unique_ptr<FramelessHelperWin> nativeEventFilter = nullptr;
-    QHash<WId, FramelessWin32HelperData> data = {};
-};
+    return std::make_shared<FramelessDataWin>();
+}

-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);
+static std::unique_ptr<FramelessHelperWin> g_framelessHelperWin = nullptr;

 [[nodiscard]] extern std::optional<MONITORINFOEXW> getMonitorForWindow(const HWND hwnd);

@ -212,31 +193,24 @@ FramelessHelperWin::FramelessHelperWin() : QAbstractNativeEventFilter() {}

 FramelessHelperWin::~FramelessHelperWin() = default;

-void FramelessHelperWin::addWindow(FramelessParamsConst params)
+void FramelessHelperWin::addWindow(const QWindow *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 auto data = GetFramelessDataWin(window);
+    Q_ASSERT(data);
+    if (!data || data->frameless) {
        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());
-    }
-    DEBUG.noquote() << "The DPI of window" << hwnd2str(windowId) << "is" << data.dpi;
-    const QWindow *window = params->getWindowHandle();
+    data->frameless = true;
+    data->dpi = Dpi{ Utils::getWindowDpi(window, true), Utils::getWindowDpi(window, false) };
+    DEBUG.noquote() << "The DPI of window" << hwnd2str(qWindowId<HWND>(window)) << "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(window);
 #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
@ -245,57 +219,47 @@ void FramelessHelperWin::addWindow(FramelessParamsConst params)
    std::ignore = Utils::updateInternalWindowFrameMargins(const_cast<QWindow *>(window), true);
 #endif
    // Tell DWM our preferred frame margin.
-    std::ignore = Utils::updateWindowFrameMargins(windowId, false);
+    std::ignore = Utils::updateWindowFrameMargins(window, 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(window);
    // 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);
+    std::ignore = Utils::fixupChildWindowsDpiMessage(window);
    if (Utils::isWindowAccelerated(window) && Utils::isWindowTransparent(window)) {
-        std::ignore = Utils::updateFramebufferTransparency(windowId);
+        std::ignore = Utils::updateFramebufferTransparency(window);
    }
    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(window, dark);
            }
-            std::ignore = Utils::refreshWin32ThemeResources(windowId, dark);
+            std::ignore = Utils::refreshWin32ThemeResources(window, dark);
            if (WindowsVersionHelper::isWin11OrGreater()) {
                if (FramelessConfig::instance()->isSet(Option::WindowUseSquareCorners)) {
-                    std::ignore = Utils::setCornerStyleForWindow(windowId, WindowCornerStyle::Square);
+                    std::ignore = Utils::setCornerStyleForWindow(window, WindowCornerStyle::Square);
                }
            }
        }
    }
+    if (!g_framelessHelperWin) {
+        g_framelessHelperWin = std::make_unique<FramelessHelperWin>();
+        qApp->installNativeEventFilter(g_framelessHelperWin.get());
+    }
 }

-void FramelessHelperWin::removeWindow(const WId windowId)
+void FramelessHelperWin::removeWindow(const QWindow *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 +281,27 @@ 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)) {
+
+    const QWindow *window = Utils::findWindow(reinterpret_cast<WId>(hWnd));
+    if (!window) {
        return false;
    }
+
+    // Let's be extra safe.
+    if (!Utils::isValidWindow(window, false, true)) {
+        return false;
+    }
+
+    const auto data = GetFramelessDataWin(window);
+    Q_ASSERT(data);
+    if (!data || !data->frameless) {
+        return false;
+    }
+
    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,31 +314,24 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
        break;
    }

-    const auto it = g_framelessWin32HelperData()->data.find(windowId);
-    if (it == g_framelessWin32HelperData()->data.end()) {
-        return false;
-    }
-    const FramelessWin32HelperData &data = it.value();
-    FramelessWin32HelperData &muData = it.value();
-    const QWindow *window = data.params.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 {
-        if (!ignoreWindowState && !Utils::isWindowNoState(windowId)) {
+    const auto updateRestoreGeometry = [window, &data](const bool ignoreWindowState) -> void {
+        if (!ignoreWindowState && !Utils::isWindowNoState(window)) {
            return;
        }
-        const QRect rect = Utils::getWindowRestoreGeometry(windowId);
+        const QRect rect = Utils::getWindowRestoreGeometry(window);
        if (!Utils::isValidGeometry(rect)) {
            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))

@ -465,13 +434,13 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
            // 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 });
            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) {
@ -483,7 +452,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
        // If we are using the PMv2 DPI awareness mode, the non-client area
        // of the window will be scaled by the OS automatically, so there will
        // be no need to do this in that case.
-        Utils::enableNonClientAreaDpiScalingForWindow(windowId);
+        Utils::enableNonClientAreaDpiScalingForWindow(window);
    } break;
 #endif
    case WM_NCCALCSIZE: {
@ -599,7 +568,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
            clientRect->top = originalTop;
        }
        const bool max = IsMaximized(hWnd);
-        const bool full = Utils::isFullScreen(windowId);
+        const bool full = Utils::isFullScreen(window);
        // We don't need this correction when we're fullscreen. We will
        // have the WS_POPUP size, so we don't have to worry about
        // borders, and the default frame will be fine.
@ -610,11 +579,11 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
            // then the window is clipped to the monitor so that the resize handle
            // do not appear because you don't need them (because you can't resize
            // a window when it's maximized unless you restore it).
-            const int frameSizeY = Utils::getResizeBorderThickness(windowId, false, true);
+            const int frameSizeY = Utils::getResizeBorderThickness(window, false, true);
            clientRect->top += frameSizeY;
            if (!frameBorderVisible) {
                clientRect->bottom -= frameSizeY;
-                const int frameSizeX = Utils::getResizeBorderThickness(windowId, true, true);
+                const int frameSizeX = Utils::getResizeBorderThickness(window, true, true);
                clientRect->left += frameSizeX;
                clientRect->right -= frameSizeX;
            }
@ -809,8 +778,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) };
@ -830,7 +799,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me

        const QPoint qtScenePos = Utils::fromNativeLocalPosition(window, 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.
@ -876,13 +845,13 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
        // are we hitting.

        const bool max = IsMaximized(hWnd);
-        const bool full = Utils::isFullScreen(windowId);
-        const int frameSizeY = Utils::getResizeBorderThickness(windowId, false, true);
+        const bool full = Utils::isFullScreen(window);
+        const int frameSizeY = Utils::getResizeBorderThickness(window, 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;
@ -940,7 +909,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
                const bool isBottom = (nativeLocalPos.y >= (clientHeight - frameSizeY));
                // Make the border a little wider to let the user easy to resize on corners.
                const auto scaleFactor = ((isTop || isBottom) ? qreal(2) : qreal(1));
-                const int frameSizeX = Utils::getResizeBorderThickness(windowId, true, true);
+                const int frameSizeX = Utils::getResizeBorderThickness(window, true, true);
                const int scaledFrameSizeX = std::round(qreal(frameSizeX) * scaleFactor);
                const bool isLeft = (nativeLocalPos.x < scaledFrameSizeX);
                const bool isRight = (nativeLocalPos.x >= (clientWidth - scaledFrameSizeX));
@ -993,8 +962,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 +986,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 +1001,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 +1017,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 +1040,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,7 +1054,7 @@ 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(window) + Utils::getWindowCustomFrameMargins(window));
        const QRect suggestedGeometry = (suggestedFrameGeometry - frameMargins);
        if (Utils::toNativePixels(window, window->size()) != suggestedGeometry.size()) {
            windowPos->flags |= SWP_NOCOPYBITS;
@ -1125,7 +1096,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,18 +1104,18 @@ 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));
+            muData.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.
-        std::ignore = Utils::updateWindowFrameMargins(windowId, false);
+        std::ignore = Utils::updateWindowFrameMargins(window, false);
        break;
 #if (QT_VERSION < QT_VERSION_CHECK(6, 5, 1))
    case WM_ENTERSIZEMOVE: // Sent to a window when the user drags the title bar or the resize border.
@ -1155,7 +1126,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 +1138,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);
        }
@ -1183,7 +1154,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
        // down the monitor (only a suggestion to the OS, the OS can still ignore
        // our request).
        if ((filteredWParam == SC_SCREENSAVE) || (filteredWParam == SC_MONITORPOWER)) {
-            if (Utils::isFullScreen(windowId)) {
+            if (Utils::isFullScreen(window)) {
                *result = FALSE;
                return true;
            }
@ -1251,14 +1222,14 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me
                WARNING << Utils::getSystemErrorMessage(kSetWindowLongPtrW);
                break;
            }
-            std::ignore = Utils::triggerFrameChange(windowId);
+            std::ignore = Utils::triggerFrameChange(window);
            const LRESULT originalResult = ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
            ::SetLastError(ERROR_SUCCESS);
            if (::SetWindowLongPtrW(hWnd, GWL_STYLE, static_cast<LONG_PTR>(oldStyle)) == 0) {
                WARNING << Utils::getSystemErrorMessage(kSetWindowLongPtrW);
                break;
            }
-            std::ignore = Utils::triggerFrameChange(windowId);
+            std::ignore = Utils::triggerFrameChange(window);
            *result = originalResult;
            return true;
        }
@ -1269,7 +1240,7 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me

    if ((uMsg == WM_DWMCOMPOSITIONCHANGED) || (uMsg == WM_DWMCOLORIZATIONCOLORCHANGED)) {
        if (Utils::isWindowAccelerated(window) && Utils::isWindowTransparent(window)) {
-            std::ignore = Utils::updateFramebufferTransparency(windowId);
+            std::ignore = Utils::updateFramebufferTransparency(window);
        }
    }

@ -1284,14 +1255,14 @@ 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) {
                        // Causes some QtWidgets paint incorrectly, so only apply to Qt Quick applications.
-                        std::ignore = Utils::updateGlobalWin32ControlsTheme(windowId, dark);
+                        std::ignore = Utils::updateGlobalWin32ControlsTheme(window, dark);
                    }
-                    std::ignore = Utils::refreshWin32ThemeResources(windowId, dark);
+                    std::ignore = Utils::refreshWin32ThemeResources(window, dark);
                }
            }
        }
@ -1315,4 +1286,6 @@ bool FramelessHelperWin::nativeEventFilter(const QByteArray &eventType, void *me

 FRAMELESSHELPER_END_NAMESPACE

+#endif // native_impl
+
 #endif // Q_OS_WINDOWS
--- a/src/core/framelesshelpercore_global.cpp
+++ b/src/core/framelesshelpercore_global.cpp
@ -114,6 +114,23 @@ using namespace Global;
 static_assert(std::size(WindowsVersions) == (static_cast<int>(WindowsVersion::Latest) + 1));
 #endif

+FramelessCallbacksPtr FramelessCallbacks::create()
+{
+    return std::make_shared<FramelessCallbacks>();
+}
+
+FramelessData::~FramelessData()
+{
+    if (extraData.ptr) {
+        Q_ASSERT(extraData.deleter);
+        if (extraData.deleter) {
+            extraData.deleter(extraData.ptr);
+            extraData.deleter = nullptr;
+        }
+        extraData.ptr = nullptr;
+    }
+}
+
 void FramelessHelperCoreInitialize()
 {
    static bool inited = false;
--- a/src/core/framelessmanager.cpp
+++ b/src/core/framelessmanager.cpp
@ -59,9 +59,7 @@ FRAMELESSHELPER_BEGIN_NAMESPACE

 using namespace Global;

-using FramelessManagerData = QList<WId>;
-
-Q_GLOBAL_STATIC(FramelessManagerData, g_framelessManagerData)
+Q_GLOBAL_STATIC(FramelessDataHash, g_internalData)

 static constexpr const int kEventDelayInterval = 1000;

@ -83,18 +81,6 @@ static constexpr const int kEventDelayInterval = 1000;
 }
 #endif

-[[nodiscard]] static inline bool usePureQtImplementation()
-{
-    static const auto result = []() -> bool {
-#ifdef Q_OS_WINDOWS
-        return FramelessConfig::instance()->isSet(Option::UseCrossPlatformQtImplementation);
-#else
-        return true;
-#endif
-    }();
-    return result;
-}
-
 FramelessManagerPrivate::FramelessManagerPrivate(FramelessManager *q) : QObject(q)
 {
    Q_ASSERT(q);
@ -133,7 +119,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 +215,32 @@ void FramelessManagerPrivate::doNotifyWallpaperHasChangedOrNot()
    }
 }

+FramelessDataPtr FramelessManagerPrivate::getData(const QWindow *window)
+{
+    Q_ASSERT(window);
+    if (!window) {
+        return nullptr;
+    }
+    auto it = g_internalData()->find(window);
+    if (it == g_internalData()->end()) {
+        it = g_internalData()->insert(window, FramelessData::create());
+    }
+    return it.value();
+}
+
+void FramelessManagerPrivate::removeData(const QWindow *window)
+{
+    Q_ASSERT(window);
+    if (!window) {
+        return;
+    }
+    const auto it = g_internalData()->constFind(window);
+    if (it == g_internalData()->constEnd()) {
+        return;
+    }
+    g_internalData()->erase(it);
+}
+
 bool FramelessManagerPrivate::isThemeOverrided() const
 {
    return (overrideTheme.value_or(SystemTheme::Unknown) != SystemTheme::Unknown);
@ -299,6 +311,15 @@ FramelessManager *FramelessManager::instance()
    return &manager;
 }

+bool FramelessManager::isFramelessWindow(const QWindow *window) const
+{
+    Q_ASSERT(window);
+    if (!window) {
+        return false;
+    }
+    return FramelessManagerPrivate::getData(window)->frameless;
+}
+
 SystemTheme FramelessManager::systemTheme() const
 {
    Q_D(const FramelessManager);
@ -342,51 +363,56 @@ void FramelessManager::setOverrideTheme(const SystemTheme theme)
    Q_EMIT systemThemeChanged();
 }

-void FramelessManager::addWindow(FramelessParamsConst params)
+bool FramelessManager::addWindow(const QWindow *window)
 {
-    Q_ASSERT(params);
-    if (!params) {
-        return;
+    Q_ASSERT(window);
+    if (!window) {
+        return false;
    }
-    const WId windowId = params->getWindowId();
-    if (g_framelessManagerData()->contains(windowId)) {
-        return;
+    const FramelessDataPtr data = FramelessManagerPrivate::getData(window);
+    Q_ASSERT(data);
+    if (!data || data->frameless) {
+        return false;
    }
-    g_framelessManagerData()->append(windowId);
-    static const bool pureQt = usePureQtImplementation();
-    if (pureQt) {
-        FramelessHelperQt::addWindow(params);
-    }
-#ifdef Q_OS_WINDOWS
-    if (!pureQt) {
-        FramelessHelperWin::addWindow(params);
-    }
-    std::ignore = Utils::installWindowProcHook(windowId, params);
+#if FRAMELESSHELPER_CONFIG(native_impl)
+#  ifdef Q_OS_WINDOWS
+    std::ignore = Utils::installWindowProcHook(window);
+    FramelessHelperWin::addWindow(window);
+#  elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
+#  elif defined(Q_OS_MACOS)
+#  else
+#  endif
+#else
+    FramelessHelperQt::addWindow(window);
 #endif
-    connect(params->getWindowHandle(), &QWindow::destroyed, FramelessManager::instance(), [this, windowId](){ removeWindow(windowId); });
+    connect(window, &QWindow::destroyed, FramelessManager::instance(), [this, window](){ std::ignore = removeWindow(window); });
+    return true;
 }

-void FramelessManager::removeWindow(const WId windowId)
+bool FramelessManager::removeWindow(const QWindow *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()->constFind(window);
+    if (it == g_internalData()->constEnd()) {
+        return false;
    }
-    g_framelessManagerData()->removeAll(windowId);
-    static const bool pureQt = usePureQtImplementation();
-    if (pureQt) {
-        FramelessHelperQt::removeWindow(windowId);
-    }
-#ifdef Q_OS_WINDOWS
-    if (!pureQt) {
-        FramelessHelperWin::removeWindow(windowId);
-    }
-    std::ignore = Utils::uninstallWindowProcHook(windowId);
-    std::ignore = Utils::removeMicaWindow(windowId);
+#if FRAMELESSHELPER_CONFIG(native_impl)
+#  ifdef Q_OS_WINDOWS
+    FramelessHelperWin::removeWindow(window);
+    std::ignore = Utils::uninstallWindowProcHook(window);
+    std::ignore = Utils::removeMicaWindow(window);
+#  elif (defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID))
+#  elif defined(Q_OS_MACOS)
+#  else
+#  endif
+#else
+    FramelessHelperQt::removeWindow(window);
 #endif
+    g_internalData()->erase(it);
+    return true;
 }

 FRAMELESSHELPER_END_NAMESPACE
--- a/src/core/micamaterial.cpp
+++ b/src/core/micamaterial.cpp
@ -657,7 +657,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);
--- a/src/core/platformsupport_win.cpp
+++ b/src/core/platformsupport_win.cpp
@ -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);
--- a/src/core/utils.cpp
+++ b/src/core/utils.cpp
@ -210,29 +210,35 @@ QWindow *Utils::findWindow(const WId windowId)
    return nullptr;
 }

-void Utils::moveWindowToDesktopCenter(FramelessParamsConst params, const bool considerTaskBar)
+bool Utils::moveWindowToDesktopCenter(const QWindow *window, const bool considerTaskBar)
 {
-    Q_ASSERT(params);
-    if (!params) {
-        return;
+    Q_ASSERT(window);
+    if (!window) {
+        return false;
    }
-    const QSize windowSize = params->getWindowSize();
-    if (windowSize.isEmpty() || (windowSize == kDefaultWindowSize)) {
-        return;
+    const FramelessDataPtr data = FramelessHelperExtractData(window);
+    Q_ASSERT(data);
+    if (!data) {
+        return false;
    }
-    const QScreen *screen = params->getWindowScreen();
+    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 +320,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))
--- a/src/core/utils_win.cpp
+++ b/src/core/utils_win.cpp
Author	SHA1	Message	Date
Zhao Yuhang	099da347e8	wip	2023-09-14 22:29:40 +08:00
Yuhang Zhao	ae9c4ae5c8	wip	2023-09-14 17:58:50 +08:00