clean codes

Sine Striker

2023-12-11 b1cc4e7de641a9e6ef866744d7775d45813bad8d

clean codes

 src/core/contexts/abstractwindowcontext.cpp

@@ -7,8 +7,14 @@

namespace QWK {

    AbstractWindowContext::AbstractWindowContext() {
    }
    static volatile constexpr const struct {
        const quint32 activeLight = MAKE_RGBA_COLOR(210, 233, 189, 226);
        const quint32 activeDark = MAKE_RGBA_COLOR(177, 205, 190, 240);
        const quint32 inactiveLight = MAKE_RGBA_COLOR(193, 195, 211, 203);
        const quint32 inactiveDark = MAKE_RGBA_COLOR(240, 240, 250, 255);
    } kSampleColorSet;

    AbstractWindowContext::AbstractWindowContext() = default;

    AbstractWindowContext::~AbstractWindowContext() = default;

@@ -28,7 +34,7 @@

        if (!setupHost()) {
            m_host = nullptr;
            m_delegate = nullptr;
            m_delegate.reset();
            m_windowHandle = nullptr;
            return false;
        }
@@ -172,13 +178,6 @@
        return {};
    }

    static constexpr struct {
        const quint32 grass = MAKE_RGBA_COLOR(210, 233, 189, 226);
        const quint32 pink = MAKE_RGBA_COLOR(177, 205, 190, 240);
        const quint32 tile = MAKE_RGBA_COLOR(193, 195, 211, 203);
        const quint32 azure = MAKE_RGBA_COLOR(240, 240, 250, 255);
    } kSampleColorSet;

    void AbstractWindowContext::virtual_hook(int id, void *data) {
        switch (id) {
            case NeedsDrawBordersHook: {
@@ -186,28 +185,26 @@
                result = false;
                return;
            }
            case DrawBordersHook: {

            case BorderThicknessHook: {
                auto args = static_cast<void **>(data);
                auto &painter = *static_cast<QPainter *>(args[0]);
                const auto &rect = *static_cast<const QRect *>(args[1]);

                // Top
                painter.setPen(kSampleColorSet.grass);
                painter.drawLine(rect.topLeft(), rect.topRight());

                // Right
                painter.setPen(kSampleColorSet.pink);
                painter.drawLine(rect.topRight(), rect.bottomRight());

                // Bottom
                painter.setPen(kSampleColorSet.tile);
                painter.drawLine(rect.bottomLeft(), rect.bottomRight());

                // Right
                painter.setPen(kSampleColorSet.azure);
                painter.drawLine(rect.topLeft(), rect.bottomLeft());
                const bool requireNative = *static_cast<const bool *>(args[0]);
                quint32 &thickness = *static_cast<quint32 *>(args[1]);
                std::ignore = requireNative;
                thickness = 1;
                return;
            }

            case BorderColorsHook: {
                auto arr = *reinterpret_cast<QList<QColor> *>(data);
                arr.clear();
                arr.push_back(kSampleColorSet.activeLight);
                arr.push_back(kSampleColorSet.activeDark);
                arr.push_back(kSampleColorSet.inactiveLight);
                arr.push_back(kSampleColorSet.inactiveDark);
                return;
            }

            default:
                break;
        }

 src/core/contexts/abstractwindowcontext_p.h

@@ -47,8 +47,9 @@
            CentralizeHook = 1,
            ShowSystemMenuHook,
            NeedsDrawBordersHook,
            BorderThicknessHook,
            BorderColorsHook,
            DrawBordersHook,
            QueryBorderThicknessHook
        };
        virtual void virtual_hook(int id, void *data);

@@ -56,9 +57,9 @@
        virtual bool setupHost() = 0;

    protected:
        QObject *m_host;
        QObject *m_host{};
        std::unique_ptr<WindowItemDelegate> m_delegate;
        QWindow *m_windowHandle;
        QWindow *m_windowHandle{};

        QSet<const QObject *> m_hitTestVisibleItems;
        QList<QRect> m_hitTestVisibleRects;

 src/core/contexts/win32windowcontext.cpp

@@ -27,6 +27,7 @@
#include <timeapi.h>

#include "nativeeventfilter.h"
#include "qwkglobal_p.h"

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
Q_DECLARE_METATYPE(QMargins)
@@ -34,37 +35,42 @@

namespace QWK {

    using _DWMWINDOWATTRIBUTE = enum _DWMWINDOWATTRIBUTE {
        _DWMWA_USE_HOSTBACKDROPBRUSH =
            17, // [set] BOOL, Allows the use of host backdrop brushes for the window.
        _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 =
            19, // Undocumented, the same with DWMWA_USE_IMMERSIVE_DARK_MODE, but available on
                // systems before Win10 20H1.
        _DWMWA_USE_IMMERSIVE_DARK_MODE =
            20, // [set] BOOL, Allows a window to either use the accent color, or dark, according to
                // the user Color Mode preferences.
        _DWMWA_WINDOW_CORNER_PREFERENCE = 33, // [set] WINDOW_CORNER_PREFERENCE, Controls the policy
                                              // that rounds top-level window corners
        _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS =
            37,  // [get] UINT, width of the visible border around a thick frame window
        _DWMWA_SYSTEMBACKDROP_TYPE =
            38,  // [get, set] SYSTEMBACKDROP_TYPE, Controls the system-drawn backdrop material of a
                 // window, including behind the non-client area.
        _DWMWA_MICA_EFFECT =
            1029 // Undocumented, use this value to enable Mica material on Win11 21H2. You should
                 // use DWMWA_SYSTEMBACKDROP_TYPE instead on Win11 22H2 and newer.
    enum _DWMWINDOWATTRIBUTE {
        // [set] BOOL, Allows the use of host backdrop brushes for the window.
        _DWMWA_USE_HOSTBACKDROPBRUSH = 17,

        // Undocumented, the same with DWMWA_USE_IMMERSIVE_DARK_MODE, but available on systems
        // before Win10 20H1.
        _DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 = 19,

        // [set] BOOL, Allows a window to either use the accent color, or dark, according to the
        // user Color Mode preferences.
        _DWMWA_USE_IMMERSIVE_DARK_MODE = 20,

        // [set] WINDOW_CORNER_PREFERENCE, Controls the policy that rounds top-level window corners
        _DWMWA_WINDOW_CORNER_PREFERENCE = 33,

        // [get] UINT, width of the visible border around a thick frame window
        _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS = 37,

        // [get, set] SYSTEMBACKDROP_TYPE, Controls the system-drawn backdrop material of a window,
        // including behind the non-client area.
        _DWMWA_SYSTEMBACKDROP_TYPE = 38,

        // Undocumented, use this value to enable Mica material on Win11 21H2. You should use
        // DWMWA_SYSTEMBACKDROP_TYPE instead on Win11 22H2 and newer.
        _DWMWA_MICA_EFFECT = 1029
    };

    // The thickness of an auto-hide taskbar in pixels.
    static constexpr const auto kAutoHideTaskBarThickness = quint8{2};
    static constexpr const quint8 kAutoHideTaskBarThickness = 2;

    static inline constexpr const auto kFrameBorderActiveColorLight =
        QColor{110, 110, 110};                                                           // #6E6E6E
    static inline constexpr const auto kFrameBorderActiveColorDark = QColor{51, 51, 51}; // #333333
    static inline constexpr const auto kFrameBorderInactiveColorLight =
        QColor{167, 167, 167};                                                           // #A7A7A7
    static inline constexpr const auto kFrameBorderInactiveColorDark =
        QColor{61, 61, 62};                                                              // #3D3D3E
    static constexpr const struct {
        const uint32_t activeLight = MAKE_RGBA_COLOR(110, 110, 110, 255);   // #6E6E6E
        const uint32_t activeDark = MAKE_RGBA_COLOR(51, 51, 51, 255);       // #333333
        const uint32_t inactiveLight = MAKE_RGBA_COLOR(167, 167, 167, 255); // #A7A7A7
        const uint32_t inactiveDark = MAKE_RGBA_COLOR(61, 61, 62, 255);     // #3D3D3E
    } kWindowsColorSet;

    // hWnd -> context
    using WndProcHash = QHash<HWND, Win32WindowContext *>;
@@ -352,7 +358,7 @@
    }

    static inline quint32 getWindowFrameBorderThickness(HWND hwnd) {
        UINT result{0};
        UINT result = 0;
        const DynamicApis &apis = DynamicApis::instance();
        if (SUCCEEDED(apis.pDwmGetWindowAttribute(hwnd, _DWMWA_VISIBLE_FRAME_BORDER_THICKNESS,
                                                  &result, sizeof(result)))) {
@@ -794,6 +800,7 @@
                moveToDesktopCenter(hwnd);
                return;
            }

            case ShowSystemMenuHook: {
                const auto &pos = *static_cast<const QPoint *>(data);
                auto hWnd = reinterpret_cast<HWND>(m_windowHandle->winId());
@@ -801,45 +808,69 @@
                                m_delegate->isHostSizeFixed(m_host));
                return;
            }

            case NeedsDrawBordersHook: {
                auto &result = *static_cast<bool *>(data);
                result = isWin10OrGreater() && !isWin11OrGreater();
                return;
            }

            case BorderThicknessHook: {
                auto args = static_cast<void **>(data);
                const bool requireNative = *static_cast<const bool *>(args[0]);
                quint32 &thickness = *static_cast<quint32 *>(args[1]);
                const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());
                const auto nativeThickness = getWindowFrameBorderThickness(hwnd);
                thickness = requireNative
                                ? nativeThickness
                                : QHighDpi::fromNativePixels(nativeThickness, m_windowHandle);
                return;
            }

            case BorderColorsHook: {
                auto arr = *reinterpret_cast<QList<QColor> *>(data);
                arr.clear();
                arr.push_back(kWindowsColorSet.activeLight);
                arr.push_back(kWindowsColorSet.activeDark);
                arr.push_back(kWindowsColorSet.inactiveLight);
                arr.push_back(kWindowsColorSet.inactiveDark);
                return;
            }

            case DrawBordersHook: {
                auto args = static_cast<void **>(data);
                auto &painter = *static_cast<QPainter *>(args[0]);
                const auto &rect = *static_cast<const QRect *>(args[1]);
                const auto &region = *static_cast<const QRegion *>(args[2]);
                const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());

                QPen pen;
                const auto borderThickness = int(QHighDpi::fromNativePixels(
                    getWindowFrameBorderThickness(hwnd), m_windowHandle));
                pen.setWidth(borderThickness * 2);
                const bool active = m_host->isWidgetType()
                                        ? m_host->property("isActiveWindow").toBool()
                                        : m_host->property("active").toBool();
                const bool active = m_delegate->isWindowActive(m_host);
                const bool dark = isDarkThemeActive() && isDarkWindowFrameEnabled(hwnd);

                if (active) {
                    if (isWindowFrameBorderColorized()) {
                        pen.setColor(getAccentColor());
                    } else {
                        if (dark) {
                            pen.setColor(kFrameBorderActiveColorDark);
                        } else {
                            pen.setColor(kFrameBorderActiveColorLight);
                        }
                        static QColor frameBorderActiveColorLight(kWindowsColorSet.activeLight);
                        static QColor frameBorderActiveColorDark(kWindowsColorSet.activeDark);
                        pen.setColor(dark ? frameBorderActiveColorDark
                                          : frameBorderActiveColorLight);
                    }
                } else {
                    if (dark) {
                        pen.setColor(kFrameBorderInactiveColorDark);
                    } else {
                        pen.setColor(kFrameBorderInactiveColorLight);
                    }
                    static QColor frameBorderInactiveColorLight(kWindowsColorSet.inactiveLight);
                    static QColor frameBorderInactiveColorDark(kWindowsColorSet.inactiveDark);
                    pen.setColor(dark ? frameBorderInactiveColorDark
                                      : frameBorderInactiveColorLight);
                }
                painter.save();
                painter.setRenderHint(
                    QPainter::Antialiasing); // ### TODO: do we need to enable or disable it?

                // ### TODO: do we need to enable or disable it?
                painter.setRenderHint(QPainter::Antialiasing);

                painter.setPen(pen);
                painter.drawLine(QLine{
                    QPoint{0,            0},
@@ -848,19 +879,7 @@
                painter.restore();
                return;
            }
            case QueryBorderThicknessHook: {
                auto args = static_cast<void **>(data);
                const bool requireNative = *static_cast<const bool *>(args[0]);
                quint32 &thickness = *static_cast<quint32 *>(args[1]);
                const auto hwnd = reinterpret_cast<HWND>(m_windowHandle->winId());
                const auto nativeThickness = getWindowFrameBorderThickness(hwnd);
                if (requireNative) {
                    thickness = nativeThickness;
                } else {
                    thickness = QHighDpi::fromNativePixels(nativeThickness, m_windowHandle);
                }
                return;
            }

            default: {
                // unreachable
                break;

 src/core/windowitemdelegate_p.h

@@ -24,6 +24,7 @@
        // Host property query
        virtual QWindow *hostWindow(const QObject *host) const = 0;
        virtual bool isHostSizeFixed(const QObject *host) const = 0;
        virtual bool isWindowActive(const QObject *host) const = 0;

        // Callbacks
        virtual void resetQtGrabbedControl() const;

 src/quick/quickitemdelegate.cpp

@@ -38,4 +38,8 @@
        return false;
    }

    bool QuickItemDelegate::isWindowActive(const QObject *host) const {
        return static_cast<QQuickWindow *>(const_cast<QObject *>(host))->isActive();
    }

}

 src/quick/quickitemdelegate_p.h

@@ -22,6 +22,7 @@

        QWindow * hostWindow(const QObject *host) const override;
        bool isHostSizeFixed(const QObject *host) const override;
        bool isWindowActive(const QObject *host) const override;
    };

}

 src/quick/quickwindowagent.cpp

@@ -11,26 +11,29 @@

    class BorderItem : public QQuickPaintedItem {
        Q_OBJECT

    public:
        explicit BorderItem(AbstractWindowContext *ctx, QQuickItem *parent = nullptr);
        ~BorderItem() override;

        void updateHeight();

    public:
        void paint(QPainter *painter) override;

        void itemChange(ItemChange change, const ItemChangeData &data) override;

    private:
        AbstractWindowContext *context;

        void _q_windowActivityChanged();
    };

    BorderItem::BorderItem(AbstractWindowContext *ctx, QQuickItem *parent) : QQuickPaintedItem(parent), context(ctx) {
        setAntialiasing(true); // ### FIXME: do we need to enable or disable this?
        setMipmap(true); // ### FIXME: do we need to enable or disable this?
        setFillColor({}); // Will improve the performance a little bit.
        setOpaquePainting(true); // Will also improve the performance, we don't draw semi-transparent borders of course.
    BorderItem::BorderItem(AbstractWindowContext *ctx, QQuickItem *parent)
        : QQuickPaintedItem(parent), context(ctx) {
        setAntialiasing(true);   // ### FIXME: do we need to enable or disable this?
        setMipmap(true);         // ### FIXME: do we need to enable or disable this?
        setFillColor({});        // Will improve the performance a little bit.
        setOpaquePainting(true); // Will also improve the performance, we don't draw
                                 // semi-transparent borders of course.

        auto parentPri = QQuickItemPrivate::get(parent);
        auto anchors = QQuickItemPrivate::get(this)->anchors();
@@ -46,18 +49,21 @@
    void BorderItem::updateHeight() {
        bool native = false;
        quint32 thickness = 0;
        void *args[] = { &native, &thickness };
        context->virtual_hook(AbstractWindowContext::QueryBorderThicknessHook, &args);
        void *args[] = {
            &native,
            &thickness,
        };
        context->virtual_hook(AbstractWindowContext::BorderThicknessHook, &args);
        setHeight(thickness);
    }

    void BorderItem::paint(QPainter *painter) {
        auto rect = QRect{ QPoint{ 0, 0}, size().toSize() };
        auto region = QRegion{ rect };
        QRect rect(QPoint(0, 0), size().toSize());
        QRegion region(rect);
        void *args[] = {
            painter,
            &rect,
            &region
            &region,
        };
        context->virtual_hook(AbstractWindowContext::DrawBordersHook, args);
    }
@@ -67,7 +73,8 @@
        switch (change) {
            case ItemSceneChange:
                if (data.window) {
                    connect(data.window, &QQuickWindow::activeChanged, this, [this](){ update(); });
                    connect(data.window, &QQuickWindow::activeChanged, this,
                            &BorderItem::_q_windowActivityChanged);
                }
                Q_FALLTHROUGH();
            case ItemVisibleHasChanged:
@@ -79,6 +86,10 @@
        }
    }

    void BorderItem::_q_windowActivityChanged() {
        update();
    }

    QuickWindowAgentPrivate::QuickWindowAgentPrivate() {
    }


 src/widgets/widgetitemdelegate.cpp

@@ -56,6 +56,10 @@
        return false;
    }

    bool WidgetItemDelegate::isWindowActive(const QObject *host) const {
        return static_cast<const QWidget *>(host)->isActiveWindow();
    }

    void WidgetItemDelegate::resetQtGrabbedControl() const {
        if (!qt_button_down) {
            return;

 src/widgets/widgetitemdelegate_p.h

@@ -22,6 +22,7 @@

        QWindow * hostWindow(const QObject *host) const override;
        bool isHostSizeFixed(const QObject *host) const override;
        bool isWindowActive(const QObject *host) const override;

        void resetQtGrabbedControl() const override;
    };

 src/widgets/widgetwindowagent.cpp

@@ -12,15 +12,26 @@
    class WidgetBorderHandler : public QObject {
    public:
        WidgetBorderHandler(QWidget *widget, AbstractWindowContext *ctx)
            : widget(widget), ctx(ctx) {
            : widget(widget), ctx(ctx), m_thickness(0) {
            updateThickness();
            widget->installEventFilter(this);
        }

        void updateThickness() {
            // Query thickness
            bool native = false;
            void *a[] = {
                &native,
                &m_thickness,
            };
            ctx->virtual_hook(AbstractWindowContext::BorderThicknessHook, &a);
        }

        void updateMargins() {
            if (widget->windowState() & (Qt::WindowMaximized | Qt::WindowFullScreen)) {
                widget->setContentsMargins({});
            } else {
                widget->setContentsMargins({0, 1, 0, 0});
                widget->setContentsMargins({0, int(m_thickness), 0, 0});
            }
        }

@@ -48,6 +59,15 @@
                    updateMargins();
                    break;
                }

                case QEvent::WindowActivate:
                case QEvent::WindowDeactivate: {
                    widget->update();
                    break;
                }

                    // TODO: Handle DPI Change

                default:
                    break;
            }
@@ -56,6 +76,7 @@

        QWidget *widget;
        AbstractWindowContext *ctx;
        quint32 m_thickness;
    };

    WidgetWindowAgentPrivate::WidgetWindowAgentPrivate() {