AWC: fix window attribute handler

SineStriker

2025-02-11 e9f790d3533ebaee1f782e91b6e13b2c6375c86a

 src/core/contexts/abstractwindowcontext.cpp

@@ -1,3 +1,7 @@
// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
// SPDX-License-Identifier: Apache-2.0

#include "abstractwindowcontext_p.h"

#include <QtGui/QPen>
@@ -18,34 +22,31 @@
        }
        m_host = host;
        m_delegate.reset(delegate);
        setEnabled(true);
        m_winIdChangeEventFilter.reset(delegate->createWinIdEventFilter(host, this));
        notifyWinIdChange();
    }

    void AbstractWindowContext::setWindowAttribute(const QString &key, const QVariant &var) {
        auto it = m_windowAttributes.find(key);
        if (it.value() == var)
            return;

        auto newVar = var;
        auto oldVar = it.value();
        void *a[] = {
            &const_cast<QString &>(key),
            &newVar,
            &oldVar,
        };
        virtual_hook(WindowAttributeChangedHook, a);
    }

    bool AbstractWindowContext::setHitTestVisible(const QObject *obj, bool visible) {
    bool AbstractWindowContext::setHitTestVisible(QObject *obj, bool visible) {
        Q_ASSERT(obj);
        if (!obj) {
            return false;
        }

        auto it = m_hitTestVisibleItems.find(obj);
        if (visible) {
            if (it != m_hitTestVisibleItems.end()) {
                return true;
            }
            connect(obj, &QObject::destroyed, this,
                    &AbstractWindowContext::_q_hitTestVisibleItemDestroyed);
            m_hitTestVisibleItems.insert(obj);
        } else {
            m_hitTestVisibleItems.remove(obj);
            if (it == m_hitTestVisibleItems.end()) {
                return false;
            }
            disconnect(obj, &QObject::destroyed, this,
                       &AbstractWindowContext::_q_hitTestVisibleItemDestroyed);
            m_hitTestVisibleItems.erase(it);
        }
        return true;
    }
@@ -57,8 +58,18 @@
            return false;
        }

        if (m_systemButtons[button] == obj) {
            return false;
        auto org = m_systemButtons[button];
        if (org == obj) {
            return true;
        }

        if (org) {
            disconnect(org, &QObject::destroyed, this,
                       &AbstractWindowContext::_q_systemButtonDestroyed);
        }
        if (obj) {
            connect(obj, &QObject::destroyed, this,
                    &AbstractWindowContext::_q_systemButtonDestroyed);
        }
        m_systemButtons[button] = obj;
        return true;
@@ -66,16 +77,27 @@

    bool AbstractWindowContext::setTitleBar(QObject *item) {
        Q_ASSERT(item);
        if (m_titleBar == item) {
        auto org = m_titleBar;
        if (org == item) {
            return false;
        }

        if (org) {
            // Since the title bar is changed, all items inside it should be dereferenced right away
            removeSystemButtonsAndHitTestItems();
            disconnect(org, &QObject::destroyed, this,
                       &AbstractWindowContext::_q_titleBarDistroyed);
        }
        if (item) {
            connect(item, &QObject::destroyed, this, &AbstractWindowContext::_q_titleBarDistroyed);
        }
        m_titleBar = item;
        return true;
    }

#ifdef Q_OS_MAC
    void AbstractWindowContext::setSystemButtonArea(const QRect &rect) {
        m_systemButtonArea = rect;
    void AbstractWindowContext::setSystemButtonAreaCallback(const ScreenRectCallback &callback) {
        m_systemButtonAreaCallback = callback;
        virtual_hook(SystemButtonAreaChangedHook, nullptr);
    }
#endif
@@ -152,16 +174,24 @@
    void AbstractWindowContext::virtual_hook(int id, void *data) {
        switch (id) {
            case CentralizeHook: {
                if (!m_windowId)
                    return;

                QRect windowGeometry = m_delegate->getGeometry(m_host);
                QRect screenGeometry = m_windowHandle->screen()->geometry();
                int x = (screenGeometry.width() - m_windowHandle->width()) / 2;
                int y = (screenGeometry.height() - m_windowHandle->height()) / 2;
                int x = (screenGeometry.width() - windowGeometry.width()) / 2;
                int y = (screenGeometry.height() - windowGeometry.height()) / 2;
                QPoint pos(x, y);
                pos += screenGeometry.topLeft();
                m_windowHandle->setPosition(pos);
                m_delegate->setGeometry(m_host, QRect(pos, windowGeometry.size()));
                return;
            }

            case RaiseWindowHook: {
                if (!m_windowId)
                    return;

                m_delegate->setWindowVisible(m_host, true);
                Qt::WindowStates state = m_delegate->getWindowState(m_host);
                if (state & Qt::WindowMinimized) {
                    m_delegate->setWindowState(m_host, state & ~Qt::WindowMinimized);
@@ -190,39 +220,130 @@
    }

    void AbstractWindowContext::notifyWinIdChange() {
        if (!m_internalEnabled)
            return;
        auto oldWinId = m_windowId;
        m_windowId = m_winIdChangeEventFilter->winId();

        auto oldWindow = m_windowHandle;
        if (oldWindow == m_windowHandle)
            return;
        auto isDestroyed = oldWindow && m_windowHandleCache.isNull();
        m_windowHandle = m_delegate->window(m_host);
        m_windowHandleCache = m_windowHandle;
        winIdChanged(oldWindow, isDestroyed);
    }

    void AbstractWindowContext::setEnabled(bool enabled) {
        if (enabled == m_internalEnabled)
            return;
        m_internalEnabled = enabled;

        if (enabled) {
            m_windowHandle = m_delegate->window(m_host);
            m_windowHandleCache = m_windowHandle;
            if (m_windowHandle) {
                winIdChanged(nullptr, false);
            }
            return;
        // In Qt6, after QWidget::close() is called, the related QWindow's all surfaces and the
        // platform window will be removed, and the WinId will be set to 0. After that, when the
        // QWidget is shown again, the whole things will be recreated again.
        // As a result, we must update our WindowContext each time the WinId changes.
        if (m_windowHandle) {
            removeEventFilter(m_windowHandle);
        }

        if (!m_windowHandle)
            return;
        auto oldWindowHandle = m_windowHandle.data();
        m_windowHandle = m_delegate->hostWindow(m_host);

        auto oldWindow = m_windowHandle;
        m_windowHandle = nullptr;
        m_windowHandleCache.clear();
        winIdChanged(oldWindow, false);
        if (oldWinId != m_windowId) {
            winIdChanged(m_windowId, oldWinId);

            if (m_windowId) {
                // Installing twice has no side-effect.
                m_windowHandle->installEventFilter(this);

                // Refresh window attributes
                for (auto it = m_windowAttributesOrder.begin();
                     it != m_windowAttributesOrder.end();) {
                    if (!windowAttributeChanged(it->first, it->second, {})) {
                        m_windowAttributes.remove(it->first);
                        it = m_windowAttributesOrder.erase(it);
                        continue;
                    }
                    ++it;
                }
            }

            // Send to shared dispatchers
            QEvent e(QEvent::WinIdChange);
            sharedDispatch(m_host, &e);
        }
    }

    QVariant AbstractWindowContext::windowAttribute(const QString &key) const {
        auto it = m_windowAttributes.find(key);
        if (it == m_windowAttributes.end()) {
            return {};
        }
        return it.value()->second;
    }

    bool AbstractWindowContext::setWindowAttribute(const QString &key, const QVariant &attribute) {
        auto it = m_windowAttributes.find(key);
        if (it == m_windowAttributes.end()) {
            if (!attribute.isValid()) {
                return true;
            }
            if (m_windowId && !windowAttributeChanged(key, attribute, {})) {
                return false;
            }
            m_windowAttributes.insert(
                key, m_windowAttributesOrder.insert(m_windowAttributesOrder.end(),
                                                    std::make_pair(key, attribute)));
            return true;
        }

        auto &listIter = it.value();
        auto &oldAttr = listIter->second;
        if (m_windowId && !windowAttributeChanged(key, attribute, oldAttr)) {
            return false;
        }

        if (attribute.isValid()) {
            oldAttr = attribute;
            m_windowAttributesOrder.splice(m_windowAttributesOrder.end(), m_windowAttributesOrder,
                                           listIter);
        } else {
            m_windowAttributesOrder.erase(listIter);
            m_windowAttributes.erase(it);
        }
        return true;
    }

    bool AbstractWindowContext::eventFilter(QObject *obj, QEvent *event) {
        if (obj == m_windowHandle && sharedDispatch(obj, event)) {
            return true;
        }
        return QObject::eventFilter(obj, event);
    }

    bool AbstractWindowContext::windowAttributeChanged(const QString &key,
                                                       const QVariant &attribute,
                                                       const QVariant &oldAttribute) {
        return false;
    }

    void AbstractWindowContext::removeSystemButtonsAndHitTestItems() {
        for (auto &button : m_systemButtons) {
            if (!button) {
                continue;
            }
            disconnect(button, &QObject::destroyed, this,
                       &AbstractWindowContext::_q_systemButtonDestroyed);
            button = nullptr;
        }
        for (auto &item : m_hitTestVisibleItems) {
            disconnect(item, &QObject::destroyed, this,
                       &AbstractWindowContext::_q_hitTestVisibleItemDestroyed);
        }
        m_hitTestVisibleItems.clear();
    }

    void AbstractWindowContext::_q_titleBarDistroyed(QObject *obj) {
        Q_UNUSED(obj)
        removeSystemButtonsAndHitTestItems();
        m_titleBar = nullptr;
    }

    void AbstractWindowContext::_q_hitTestVisibleItemDestroyed(QObject *obj) {
        m_hitTestVisibleItems.remove(obj);
    }

    void AbstractWindowContext::_q_systemButtonDestroyed(QObject *obj) {
        for (auto &item : m_systemButtons) {
            if (item == obj) {
                item = nullptr;
            }
        }
    }

}