Revision control
++ // 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
++ // Qt-Security score:significant reason:default
++
++ #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
++
++ /*!
++ \qmltype Menu
++ \inherits QtObject
++ //! \nativetype QQuickLabsPlatformMenu
++ \inqmlmodule Qt.labs.platform
++ \since 5.8
++ \brief A native menu.
++
++ The Menu type provides a QML API for native platform menu popups.
++
++ \image {qtlabsplatform-menu.png} {A native popup menu}
++
++ Menu can be used in a \l MenuBar, or as a stand-alone context menu.
++ The following example shows how to open a context menu on right mouse
++ click:
++
++ \code
++ MouseArea {
++ anchors.fill: parent
++ acceptedButtons: Qt.RightButton
++ onClicked: zoomMenu.open()
++ }
++
++ Menu {
++ id: zoomMenu
++
++ MenuItem {
++ text: qsTr("Zoom In")
++ shortcut: StandardKey.ZoomIn
++ onTriggered: zoomIn()
++ }
++
++ MenuItem {
++ text: qsTr("Zoom Out")
++ shortcut: StandardKey.ZoomOut
++ onTriggered: zoomOut()
++ }
++ }
++ \endcode
++
++ \section2 Submenus
++
++ To create submenus, declare a Menu as a child of another Menu:
++
++ \qml
++ Menu {
++ title: qsTr("Edit")
++
++ Menu {
++ title: qsTr("Advanced")
++
++ MenuItem {
++ text: qsTr("Auto-indent Selection")
++ onTriggered: autoIndentSelection()
++ }
++
++ MenuItem {
++ text: qsTr("Rewrap Paragraph")
++ onTriggered: rewrapParagraph()
++ }
++ }
++ }
++ \endqml
++
++ \section2 Dynamically generating menu items
++
++ You can dynamically generate menu items with \l Instantiator. The following
++ code shows how you can implement a "Recent Files" submenu, where the items
++ come from a list of files stored in settings:
++
++ \snippet qtlabsplatform-menu-instantiator.qml menu
++
++ \section2 Availability
++
++ A native platform menu is currently available on the following platforms:
++
++ \list
++ \li macOS
++ \li iOS
++ \li Android
++ \li Linux (only available as a stand-alone context menu when running with the GTK+ platform theme)
++ \endlist
++
++ \input includes/widgets.qdocinc 1
++
++ \labs
++
++ \sa MenuItem, MenuSeparator, MenuBar
++ */
++
++ /*!
++ \qmlsignal Qt.labs.platform::Menu::aboutToShow()
++
++ This signal is emitted when the menu is about to be shown to the user.
++ */
++
++ /*!
++ \qmlsignal Qt.labs.platform::Menu::aboutToHide()
++
++ This signal is emitted when the menu is about to be hidden from the user.
++ */
++
++ 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();
++ }
++
++ /*!
++ \qmldefault
++ \qmlproperty list<QtObject> Qt.labs.platform::Menu::data
++
++ This default property holds the list of all objects declared as children of
++ the menu. The data property includes objects that are not \l MenuItem instances,
++ such as \l Timer and \l QtObject.
++
++ \sa items
++ */
++ QQmlListProperty<QObject> QQuickLabsPlatformMenu::data()
++ {
++ return QQmlListProperty<QObject>(this, nullptr, data_append, data_count, data_at, data_clear);
++ }
++
++ /*!
++ \qmlproperty list<MenuItem> Qt.labs.platform::Menu::items
++
++ This property holds the list of items in the menu.
++ */
++ QQmlListProperty<QQuickLabsPlatformMenuItem> QQuickLabsPlatformMenu::items()
++ {
++ return QQmlListProperty<QQuickLabsPlatformMenuItem>(this, nullptr, items_append, items_count, items_at, items_clear);
++ }
++
++ /*!
++ \readonly
++ \qmlproperty MenuBar Qt.labs.platform::Menu::menuBar
++
++ This property holds the menubar that the menu belongs to, or \c null if the
++ menu is not in a menubar.
++ */
++ QQuickLabsPlatformMenuBar *QQuickLabsPlatformMenu::menuBar() const
++ {
++ return m_menuBar;
++ }
++
++ void QQuickLabsPlatformMenu::setMenuBar(QQuickLabsPlatformMenuBar *menuBar)
++ {
++ if (m_menuBar == menuBar)
++ return;
++
++ m_menuBar = menuBar;
++ destroy();
++ emit menuBarChanged();
++ }
++
++ /*!
++ \readonly
++ \qmlproperty Menu Qt.labs.platform::Menu::parentMenu
++
++ This property holds the parent menu that the menu belongs to, or \c null if the
++ menu is not a sub-menu.
++ */
++ 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)
++ /*!
++ \readonly
++ \qmlproperty SystemTrayIcon Qt.labs.platform::Menu::systemTrayIcon
++
++ This property holds the system tray icon that the menu belongs to, or \c null
++ if the menu is not in a system tray icon.
++ */
++ QQuickLabsPlatformSystemTrayIcon *QQuickLabsPlatformMenu::systemTrayIcon() const
++ {
++ return m_systemTrayIcon;
++ }
++
++ void QQuickLabsPlatformMenu::setSystemTrayIcon(QQuickLabsPlatformSystemTrayIcon *icon)
++ {
++ if (m_systemTrayIcon == icon)
++ return;
++
++ m_systemTrayIcon = icon;
++ destroy();
++ emit systemTrayIconChanged();
++ }
++ #endif
++
++ /*!
++ \readonly
++ \qmlproperty MenuItem Qt.labs.platform::Menu::menuItem
++
++ This property holds the item that presents the menu (in a parent menu).
++ */
++ 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;
++ }
++
++ /*!
++ \qmlproperty bool Qt.labs.platform::Menu::enabled
++
++ This property holds whether the menu is enabled. The default value is \c true.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlproperty bool Qt.labs.platform::Menu::visible
++
++ This property holds whether the menu is visible. The default value is \c true.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlproperty int Qt.labs.platform::Menu::minimumWidth
++
++ This property holds the minimum width of the menu. The default value is \c -1 (no minimum width).
++ */
++ int QQuickLabsPlatformMenu::minimumWidth() const
++ {
++ return m_minimumWidth;
++ }
++
++ void QQuickLabsPlatformMenu::setMinimumWidth(int width)
++ {
++ if (m_minimumWidth == width)
++ return;
++
++ m_minimumWidth = width;
++ sync();
++ emit minimumWidthChanged();
++ }
++
++ /*!
++ \qmlproperty enumeration Qt.labs.platform::Menu::type
++
++ This property holds the type of the menu.
++
++ Available values:
++ \value Menu.DefaultMenu A normal menu (default).
++ \value Menu.EditMenu An edit menu with pre-populated cut, copy and paste items.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlproperty string Qt.labs.platform::Menu::title
++
++ This property holds the menu's title.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlproperty font Qt.labs.platform::Menu::font
++
++ This property holds the menu's font.
++
++ \sa title
++ */
++ QFont QQuickLabsPlatformMenu::font() const
++ {
++ return m_font;
++ }
++
++ void QQuickLabsPlatformMenu::setFont(const QFont& font)
++ {
++ if (m_font == font)
++ return;
++
++ m_font = font;
++ sync();
++ emit fontChanged();
++ }
++
++ /*!
++ \since Qt.labs.platform 1.1 (Qt 5.12)
++ \qmlproperty url Qt.labs.platform::Menu::icon.source
++ \qmlproperty string Qt.labs.platform::Menu::icon.name
++ \qmlproperty bool Qt.labs.platform::Menu::icon.mask
++
++ This property holds the menu item's icon.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::addItem(MenuItem item)
++
++ Adds an \a item to the end of the menu.
++ */
++ void QQuickLabsPlatformMenu::addItem(QQuickLabsPlatformMenuItem *item)
++ {
++ insertItem(m_items.size(), item);
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::insertItem(int index, MenuItem item)
++
++ Inserts an \a item at the specified \a index in the menu.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::removeItem(MenuItem item)
++
++ Removes an \a item from the menu.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::addMenu(Menu submenu)
++
++ Adds a \a submenu to the end of the menu.
++ */
++ void QQuickLabsPlatformMenu::addMenu(QQuickLabsPlatformMenu *menu)
++ {
++ insertMenu(m_items.size(), menu);
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::insertMenu(int index, Menu submenu)
++
++ Inserts a \a submenu at the specified \a index in the menu.
++ */
++ void QQuickLabsPlatformMenu::insertMenu(int index, QQuickLabsPlatformMenu *menu)
++ {
++ if (!menu)
++ return;
++
++ menu->setParentMenu(this);
++ insertItem(index, menu->menuItem());
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::removeMenu(Menu submenu)
++
++ Removes a \a submenu from the menu.
++ */
++ void QQuickLabsPlatformMenu::removeMenu(QQuickLabsPlatformMenu *menu)
++ {
++ if (!menu)
++ return;
++
++ menu->setParentMenu(nullptr);
++ removeItem(menu->menuItem());
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::clear()
++
++ Removes all items from the menu.
++ */
++ 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();
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::open(MenuItem item)
++
++ Opens the menu at the current mouse position, optionally aligned to a menu \a item.
++ */
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::open(Item target, MenuItem item)
++
++ Opens the menu at the specified \a target item, optionally aligned to a menu \a item.
++ */
++ 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::toNativeLocalPosition(targetRect, window),
++ menuItem ? menuItem->handle() : nullptr);
++ }
++
++ /*!
++ \qmlmethod void Qt.labs.platform::Menu::close()
++
++ Closes the menu.
++ */
++ 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"