qquicklabsplatformmenu.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquicklabsplatformmenu_p.h"
#include "qquicklabsplatformmenubar_p.h"
#include "qquicklabsplatformmenuitem_p.h"
#include "qquicklabsplatformiconloader_p.h"
 
#include <QtCore/qloggingcategory.h>
#include <QtGui/qicon.h>
#include <QtGui/qcursor.h>
#include <QtGui/qpa/qplatformtheme.h>
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/private/qhighdpiscaling_p.h>
#include <QtQml/private/qqmlengine_p.h>
#include <QtQml/private/qv4scopedvalue_p.h>
#include <QtQml/private/qv4qobjectwrapper_p.h>
#include <QtQuick/qquickrendercontrol.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickitem.h>
 
#include "widgets/qwidgetplatform_p.h"
 
#if QT_CONFIG(systemtrayicon)
#include "qquicklabsplatformsystemtrayicon_p.h"
#endif
 
QT_BEGIN_NAMESPACE
 
 
Q_LOGGING_CATEGORY(qtLabsPlatformMenus, "qt.labs.platform.menus")
 
QQuickLabsPlatformMenu::QQuickLabsPlatformMenu(QObject *parent)
    : QObject(parent),
      m_complete(false),
      m_enabled(true),
      m_visible(true),
      m_minimumWidth(-1),
      m_type(QPlatformMenu::DefaultMenu),
      m_menuBar(nullptr),
      m_parentMenu(nullptr),
      m_systemTrayIcon(nullptr),
      m_menuItem(nullptr),
      m_iconLoader(nullptr),
      m_handle(nullptr)
{
}
 
QQuickLabsPlatformMenu::~QQuickLabsPlatformMenu()
{
    if (m_menuBar)
        m_menuBar->removeMenu(this);
    if (m_parentMenu)
        m_parentMenu->removeMenu(this);
 
    unparentSubmenus();
 
    delete m_iconLoader;
    m_iconLoader = nullptr;
    delete m_handle;
    m_handle = nullptr;
}
 
void QQuickLabsPlatformMenu::unparentSubmenus()
{
    for (QQuickLabsPlatformMenuItem *item : std::as_const(m_items)) {
        if (QQuickLabsPlatformMenu *subMenu = item->subMenu())
            subMenu->setParentMenu(nullptr);
        item->setMenu(nullptr);
    }
}
 
QPlatformMenu *QQuickLabsPlatformMenu::handle() const
{
    return m_handle;
}
 
QPlatformMenu * QQuickLabsPlatformMenu::create()
{
    if (!m_handle) {
        if (m_menuBar && m_menuBar->handle())
            m_handle = m_menuBar->handle()->createMenu();
        else if (m_parentMenu && m_parentMenu->handle())
            m_handle = m_parentMenu->handle()->createSubMenu();
#if QT_CONFIG(systemtrayicon)
        else if (m_systemTrayIcon && m_systemTrayIcon->handle())
            m_handle = m_systemTrayIcon->handle()->createMenu();
#endif
 
        // TODO: implement ^
        // - QCocoaMenuBar::createMenu()
        // - QCocoaMenu::createSubMenu()
        // - QCocoaSystemTrayIcon::createMenu()
        if (!m_handle)
            m_handle = QGuiApplicationPrivate::platformTheme()->createPlatformMenu();
 
        if (!m_handle)
            m_handle = QWidgetPlatform::createMenu();
 
        qCDebug(qtLabsPlatformMenus) << "Menu ->" << m_handle;
 
        if (m_handle) {
            connect(m_handle, &QPlatformMenu::aboutToShow, this, &QQuickLabsPlatformMenu::aboutToShow);
            connect(m_handle, &QPlatformMenu::aboutToHide, this, &QQuickLabsPlatformMenu::aboutToHide);
 
            for (QQuickLabsPlatformMenuItem *item : std::as_const(m_items))
                m_handle->insertMenuItem(item->create(), nullptr);
 
            if (m_menuItem) {
                if (QPlatformMenuItem *handle = m_menuItem->create())
                    handle->setMenu(m_handle);
            }
        }
    }
    return m_handle;
}
 
void QQuickLabsPlatformMenu::destroy()
{
    if (!m_handle)
        return;
 
    // Ensure that all submenus are unparented before we are destroyed,
    // so that they don't try to access a destroyed menu.
    unparentSubmenus();
 
    delete m_handle;
    m_handle = nullptr;
}
 
void QQuickLabsPlatformMenu::sync()
{
    if (!m_complete || !create())
        return;
 
    m_handle->setText(m_title);
    m_handle->setEnabled(m_enabled);
    m_handle->setVisible(m_visible);
    m_handle->setMinimumWidth(m_minimumWidth);
    m_handle->setMenuType(m_type);
    m_handle->setFont(m_font);
 
    if (m_menuBar && m_menuBar->handle())
        m_menuBar->handle()->syncMenu(m_handle);
#if QT_CONFIG(systemtrayicon)
    else if (m_systemTrayIcon && m_systemTrayIcon->handle())
        m_systemTrayIcon->handle()->updateMenu(m_handle);
#endif
 
    for (QQuickLabsPlatformMenuItem *item : std::as_const(m_items))
        item->sync();
}
 
QQmlListProperty<QObject> QQuickLabsPlatformMenu::data()
{
    return QQmlListProperty<QObject>(this, nullptr, data_append, data_count, data_at, data_clear);
}
 
QQmlListProperty<QQuickLabsPlatformMenuItem> QQuickLabsPlatformMenu::items()
{
    return QQmlListProperty<QQuickLabsPlatformMenuItem>(this, nullptr, items_append, items_count, items_at, items_clear);
}
 
QQuickLabsPlatformMenuBar *QQuickLabsPlatformMenu::menuBar() const
{
    return m_menuBar;
}
 
void QQuickLabsPlatformMenu::setMenuBar(QQuickLabsPlatformMenuBar *menuBar)
{
    if (m_menuBar == menuBar)
        return;
 
    m_menuBar = menuBar;
    destroy();
    emit menuBarChanged();
}
 
QQuickLabsPlatformMenu *QQuickLabsPlatformMenu::parentMenu() const
{
    return m_parentMenu;
}
 
void QQuickLabsPlatformMenu::setParentMenu(QQuickLabsPlatformMenu *menu)
{
    if (m_parentMenu == menu)
        return;
 
    m_parentMenu = menu;
    destroy();
    emit parentMenuChanged();
}
 
#if QT_CONFIG(systemtrayicon)
QQuickLabsPlatformSystemTrayIcon *QQuickLabsPlatformMenu::systemTrayIcon() const
{
    return m_systemTrayIcon;
}
 
void QQuickLabsPlatformMenu::setSystemTrayIcon(QQuickLabsPlatformSystemTrayIcon *icon)
{
    if (m_systemTrayIcon == icon)
        return;
 
    m_systemTrayIcon = icon;
    destroy();
    emit systemTrayIconChanged();
}
#endif
 
QQuickLabsPlatformMenuItem *QQuickLabsPlatformMenu::menuItem() const
{
    if (!m_menuItem) {
        QQuickLabsPlatformMenu *that = const_cast<QQuickLabsPlatformMenu *>(this);
        m_menuItem = new QQuickLabsPlatformMenuItem(that);
        m_menuItem->setSubMenu(that);
        m_menuItem->setText(m_title);
        m_menuItem->setIcon(icon());
        m_menuItem->setVisible(m_visible);
        m_menuItem->setEnabled(m_enabled);
        m_menuItem->componentComplete();
    }
    return m_menuItem;
}
 
bool QQuickLabsPlatformMenu::isEnabled() const
{
    return m_enabled;
}
 
void QQuickLabsPlatformMenu::setEnabled(bool enabled)
{
    if (m_enabled == enabled)
        return;
 
    if (m_menuItem)
        m_menuItem->setEnabled(enabled);
 
    m_enabled = enabled;
    sync();
    emit enabledChanged();
}
 
bool QQuickLabsPlatformMenu::isVisible() const
{
    return m_visible;
}
 
void QQuickLabsPlatformMenu::setVisible(bool visible)
{
    if (m_visible == visible)
        return;
 
    if (m_menuItem)
        m_menuItem->setVisible(visible);
 
    m_visible = visible;
    sync();
    emit visibleChanged();
}
 
int QQuickLabsPlatformMenu::minimumWidth() const
{
    return m_minimumWidth;
}
 
void QQuickLabsPlatformMenu::setMinimumWidth(int width)
{
    if (m_minimumWidth == width)
        return;
 
    m_minimumWidth = width;
    sync();
    emit minimumWidthChanged();
}
 
QPlatformMenu::MenuType QQuickLabsPlatformMenu::type() const
{
    return m_type;
}
 
void QQuickLabsPlatformMenu::setType(QPlatformMenu::MenuType type)
{
    if (m_type == type)
        return;
 
    m_type = type;
    sync();
    emit typeChanged();
}
 
QString QQuickLabsPlatformMenu::title() const
{
    return m_title;
}
 
void QQuickLabsPlatformMenu::setTitle(const QString &title)
{
    if (m_title == title)
        return;
 
    if (m_menuItem)
        m_menuItem->setText(title);
 
    m_title = title;
    sync();
    emit titleChanged();
}
 
QFont QQuickLabsPlatformMenu::font() const
{
    return m_font;
}
 
void QQuickLabsPlatformMenu::setFont(const QFont& font)
{
    if (m_font == font)
        return;
 
    m_font = font;
    sync();
    emit fontChanged();
}
 
QQuickLabsPlatformIcon QQuickLabsPlatformMenu::icon() const
{
    if (!m_iconLoader)
        return QQuickLabsPlatformIcon();
 
    return iconLoader()->icon();
}
 
void QQuickLabsPlatformMenu::setIcon(const QQuickLabsPlatformIcon &icon)
{
    if (iconLoader()->icon() == icon)
        return;
 
    if (m_menuItem)
        m_menuItem->setIcon(icon);
 
    iconLoader()->setIcon(icon);
    emit iconChanged();
}
 
void QQuickLabsPlatformMenu::addItem(QQuickLabsPlatformMenuItem *item)
{
    insertItem(m_items.size(), item);
}
 
void QQuickLabsPlatformMenu::insertItem(int index, QQuickLabsPlatformMenuItem *item)
{
    if (!item || m_items.contains(item))
        return;
 
    m_items.insert(index, item);
    m_data.append(item);
    item->setMenu(this);
    if (m_handle && item->create()) {
        QQuickLabsPlatformMenuItem *before = m_items.value(index + 1);
        m_handle->insertMenuItem(item->handle(), before ? before->create() : nullptr);
    }
    sync();
    emit itemsChanged();
}
 
void QQuickLabsPlatformMenu::removeItem(QQuickLabsPlatformMenuItem *item)
{
    if (!item || !m_items.removeOne(item))
        return;
 
    m_data.removeOne(item);
    if (m_handle)
        m_handle->removeMenuItem(item->handle());
    item->setMenu(nullptr);
    sync();
    emit itemsChanged();
}
 
void QQuickLabsPlatformMenu::addMenu(QQuickLabsPlatformMenu *menu)
{
    insertMenu(m_items.size(), menu);
}
 
void QQuickLabsPlatformMenu::insertMenu(int index, QQuickLabsPlatformMenu *menu)
{
    if (!menu)
        return;
 
    menu->setParentMenu(this);
    insertItem(index, menu->menuItem());
}
 
void QQuickLabsPlatformMenu::removeMenu(QQuickLabsPlatformMenu *menu)
{
    if (!menu)
        return;
 
    menu->setParentMenu(nullptr);
    removeItem(menu->menuItem());
}
 
void QQuickLabsPlatformMenu::clear()
{
    if (m_items.isEmpty())
        return;
 
    for (QQuickLabsPlatformMenuItem *item : std::as_const(m_items)) {
        m_data.removeOne(item);
        if (m_handle)
            m_handle->removeMenuItem(item->handle());
        item->setMenu(nullptr);
        delete item;
    }
 
    m_items.clear();
    sync();
    emit itemsChanged();
}
 
void QQuickLabsPlatformMenu::open(QQmlV4FunctionPtr args)
{
    if (!m_handle)
        return;
 
    if (args->length() > 2) {
        args->v4engine()->throwTypeError();
        return;
    }
 
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
 
    QQuickItem *targetItem = nullptr;
    if (args->length() > 0) {
        QV4::ScopedValue value(scope, (*args)[0]);
        QV4::Scoped<QV4::QObjectWrapper> object(scope, value->as<QV4::QObjectWrapper>());
        if (object)
            targetItem = qobject_cast<QQuickItem *>(object->object());
    }
 
    QQuickLabsPlatformMenuItem *menuItem = nullptr;
    if (args->length() > 1) {
        QV4::ScopedValue value(scope, (*args)[1]);
        QV4::Scoped<QV4::QObjectWrapper> object(scope, value->as<QV4::QObjectWrapper>());
        if (object)
            menuItem = qobject_cast<QQuickLabsPlatformMenuItem *>(object->object());
    }
 
    QPoint offset;
    QWindow *window = findWindow(targetItem, &offset);
 
    QRect targetRect;
    if (targetItem) {
        QRectF sceneBounds = targetItem->mapRectToScene(targetItem->boundingRect());
        targetRect = sceneBounds.toAlignedRect().translated(offset);
    } else {
#if QT_CONFIG(cursor)
        QPoint pos = QCursor::pos();
        if (window)
            pos = window->mapFromGlobal(pos);
        targetRect.moveTo(pos);
#endif
    }
    m_handle->showPopup(window,
                        QHighDpi::toNativePixels(targetRect, window),
                        menuItem ? menuItem->handle() : nullptr);
}
 
void QQuickLabsPlatformMenu::close()
{
    if (m_handle)
        m_handle->dismiss();
}
 
void QQuickLabsPlatformMenu::classBegin()
{
}
 
void QQuickLabsPlatformMenu::componentComplete()
{
    m_complete = true;
    if (m_handle && m_iconLoader)
        m_iconLoader->setEnabled(true);
    sync();
}
 
QQuickLabsPlatformIconLoader *QQuickLabsPlatformMenu::iconLoader() const
{
    if (!m_iconLoader) {
        QQuickLabsPlatformMenu *that = const_cast<QQuickLabsPlatformMenu *>(this);
        static int slot = staticMetaObject.indexOfSlot("updateIcon()");
        m_iconLoader = new QQuickLabsPlatformIconLoader(slot, that);
        m_iconLoader->setEnabled(m_complete);
    }
    return m_iconLoader;
}
 
static QWindow *effectiveWindow(QWindow *window, QPoint *offset)
{
    QQuickWindow *quickWindow = qobject_cast<QQuickWindow *>(window);
    if (quickWindow) {
        QWindow *renderWindow = QQuickRenderControl::renderWindowFor(quickWindow, offset);
        if (renderWindow)
            return renderWindow;
    }
    return window;
}
 
QWindow *QQuickLabsPlatformMenu::findWindow(QQuickItem *target, QPoint *offset) const
{
    if (target)
        return effectiveWindow(target->window(), offset);
 
    if (m_menuBar && m_menuBar->window())
        return effectiveWindow(m_menuBar->window(), offset);
 
    QObject *obj = parent();
    while (obj) {
        QWindow *window = qobject_cast<QWindow *>(obj);
        if (window)
            return effectiveWindow(window, offset);
 
        QQuickItem *item = qobject_cast<QQuickItem *>(obj);
        if (item && item->window())
            return effectiveWindow(item->window(), offset);
 
        obj = obj->parent();
    }
    return nullptr;
}
 
void QQuickLabsPlatformMenu::data_append(QQmlListProperty<QObject> *property, QObject *object)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    if (QQuickLabsPlatformMenuItem *item = qobject_cast<QQuickLabsPlatformMenuItem *>(object))
        menu->addItem(item);
    else if (QQuickLabsPlatformMenu *subMenu = qobject_cast<QQuickLabsPlatformMenu *>(object))
        menu->addMenu(subMenu);
    else
        menu->m_data.append(object);
}
 
qsizetype QQuickLabsPlatformMenu::data_count(QQmlListProperty<QObject> *property)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    return menu->m_data.size();
}
 
QObject *QQuickLabsPlatformMenu::data_at(QQmlListProperty<QObject> *property, qsizetype index)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    return menu->m_data.value(index);
}
 
void QQuickLabsPlatformMenu::data_clear(QQmlListProperty<QObject> *property)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    menu->m_data.clear();
}
 
void QQuickLabsPlatformMenu::items_append(QQmlListProperty<QQuickLabsPlatformMenuItem> *property, QQuickLabsPlatformMenuItem *item)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    menu->addItem(item);
}
 
qsizetype QQuickLabsPlatformMenu::items_count(QQmlListProperty<QQuickLabsPlatformMenuItem> *property)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    return menu->m_items.size();
}
 
QQuickLabsPlatformMenuItem *QQuickLabsPlatformMenu::items_at(QQmlListProperty<QQuickLabsPlatformMenuItem> *property, qsizetype index)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    return menu->m_items.value(index);
}
 
void QQuickLabsPlatformMenu::items_clear(QQmlListProperty<QQuickLabsPlatformMenuItem> *property)
{
    QQuickLabsPlatformMenu *menu = static_cast<QQuickLabsPlatformMenu *>(property->object);
    menu->clear();
}
 
void QQuickLabsPlatformMenu::updateIcon()
{
    if (!m_handle || !m_iconLoader)
        return;
 
    m_handle->setIcon(m_iconLoader->toQIcon());
    sync();
}
 
QT_END_NAMESPACE
 
#include "moc_qquicklabsplatformmenu_p.cpp"