Merge lp:~nick-dedekind/ubuntu-ui-toolkit/menus into lp:ubuntu-ui-toolkit/staging

[Nick Dedekind]

API for MenuBar, Menus, MenuItem & MenuSeparator

[Zsombor Egri (zsombi)]

Nice, clean code!!!

A section in UITK Gallery would be also nice to have...

One small hint: UC prefix is no longer mandated, as we have the namespace added.

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

> Nice, clean code!!!
>
> A section in UITK Gallery would be also nice to have...

This is only the menu "backend" which gets translated into QPA menus; there are no UI elements, so I don't think there's anything to show in the gallery yet.

>
> One small hint: UC prefix is no longer mandated, as we have the namespace
> added.

Removed the prefix.

[Zsombor Egri (zsombi)]

All clear! Thanks for this too!

review: Approve

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-i386-gles-stable/1045/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5495/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-i386-gles-stable/1045/rebuild

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-stable/1295/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5496/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-stable/1295/rebuild

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1282/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5497/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1282/rebuild

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-devel/1078/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5503/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-devel/1078/rebuild

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Autolanding.
More details in the following jenkins job:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-autolanding/474/
Executed test runs:
    FAILURE: https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1282/console
    FAILURE: https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-stable/1295/console
    FAILURE: https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-amd64-devel/1078/console
    FAILURE: https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-i386-gles-stable/1045/console
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-land-mp/483/console
    SUCCESS: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5497
    SUCCESS: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5496
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5503/console
    SUCCESS: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5495

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1283/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5504/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1283/rebuild

review: Needs Fixing (continuous-integration)

[ubuntu-sdk-build-bot (ubuntu-sdk-build-bot)]

FAILED: Continuous integration, rev:1357
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1285/
Executed test runs:
    None: https://jenkins.ubuntu.com/ubuntu-sdk/job/generic-update-mp/5505/console

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/ubuntu-sdk/job/ubuntu-ui-toolkit-ci-armhf-stable/1285/rebuild

review: Needs Fixing (continuous-integration)

[Zoltan Balogh (bzoltan)]

I have manualy merged this branch to rev2077

[Tim Peeters (tpeeters)]

I reverted this in r2080 because it breaks compilation.

review: Needs Resubmitting

Unmerged revisions

1359. By Nick Dedekind on 2016-08-25

fixed broken build

=== modified file 'src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro'
--- src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-08-22 16:02:17 +0000
+++ src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-08-22 16:02:17 +0000
@@ -44,7 +44,12 @@
     mousetouchadaptor_p.h \
     mousetouchadaptor_p_p.h \
     propertychange_p.h \
-    ubuntutoolkitmodule.h
+    ubuntutoolkitmodule.h \
+    menu_p_p.h \
+    menubar_p_p.h \
+    menu_p.h \
+    menubar_p.h \
+    menugroup_p.h
 
 SOURCES += \ 
     colorutils.cpp \
@@ -52,7 +57,10 @@
     asyncloader.cpp \
     mousetouchadaptor.cpp \
     propertychange.cpp \
-    ubuntutoolkitmodule.cpp
+    ubuntutoolkitmodule.cpp \
+    menu.cpp \
+    menubar.cpp \
+    menugroup.cpp
 
 HEADERS += \
     uctheme_p.h \

=== added file 'src/Ubuntu/UbuntuToolkit/menu.cpp'
--- src/Ubuntu/UbuntuToolkit/menu.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu.cpp	2016-08-22 16:02:17 +0000
@@ -0,0 +1,669 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "menu_p.h"
+#include "menu_p_p.h"
+#include "menubar_p.h"
+#include "actionlist_p.h"
+#include "menugroup_p.h"
+
+// Qt
+#include <QtGui/qpa/qplatformtheme.h>
+#include <QtGui/qpa/qplatformmenu.h>
+#include <QQuickItem>
+#include <private/qguiapplication_p.h>
+#include <private/qquickitem_p.h>
+#include <QPointer>
+#include <functional>
+
+Q_LOGGING_CATEGORY(ucMenu, "ubuntu.components.Menu", QtMsgType::QtWarningMsg)
+
+UT_NAMESPACE_BEGIN
+
+namespace {
+
+QWindow* findWindowForObject(QObject* object)
+{
+    QObject* window = object;
+    while (window && !window->isWindowType()) {
+        window = window->parent();
+        if (QQuickItem* item = qobject_cast<QQuickItem*>(window)) {
+            window = item->window();
+        }
+    }
+    return qobject_cast<QWindow*>(window);
+}
+
+// recursively get the all the object from the menu group which are not lists or groups.
+QObjectList getActionsFromMenuGroup(MenuGroup* menuGroup) {
+
+    QObjectList objectList;
+
+    Q_FOREACH(QObject* data, menuGroup->list()) {
+
+        if (auto actionList = qobject_cast<ActionList*>(data)) {
+            Q_FOREACH(UCAction* action, actionList->list()) {
+                objectList << action;
+            }
+        } else if (auto subMenuGroup = qobject_cast<MenuGroup*>(data)) {
+            objectList << getActionsFromMenuGroup(subMenuGroup);
+        } else {
+            objectList << data;
+        }
+    }
+    return objectList;
+}
+
+// recursively get the first object from the menu group which is not a list or a group.
+QObject* getFirstObject(MenuGroup* menuGroup) {
+
+    Q_FOREACH(QObject* data, menuGroup->list()) {
+
+        if (auto subMenuGroup = qobject_cast<MenuGroup*>(data)) {
+            QObject* object = getFirstObject(subMenuGroup);
+            if (object) { return object; }
+        } else if (auto actionList = qobject_cast<ActionList*>(data)) {
+            return actionList->list().count() > 0 ? actionList->list()[0] : 0;
+        } else {
+            return data;
+        }
+    }
+    return Q_NULLPTR;
+}
+
+}
+
+MenuPrivate::MenuPrivate(Menu *qq)
+    : q_ptr(qq)
+    , m_platformMenu(QGuiApplicationPrivate::platformTheme()->createPlatformMenu())
+{
+}
+
+MenuPrivate::~MenuPrivate()
+{
+    qDeleteAll(m_platformItems);
+    m_platformItems.clear();
+
+    delete m_platformMenu;
+    m_platformMenu = Q_NULLPTR;
+}
+
+void MenuPrivate::insertObject(int index, QObject *o)
+{
+    Q_Q(Menu);
+    if (!o) return;
+    qCInfo(ucMenu).nospace() << "Menu::insertObject(index="<< index << ", object=" << o << ")";
+
+    if (!m_platformMenu) {
+        m_data.insert(m_data.count() > index ? index : m_data.count(), o);
+        return;
+    }
+
+    // If the menus contains lists or groups, we need to alter the insertion index to account for them.
+    int actualIndex = 0;
+    bool insertSeparator = false;
+    for (int i = 0; i < index && i < m_data.count(); i++) {
+        QObject* data = m_data[i];
+
+        int dataObjectCount = 0;
+        if (auto menuGroup = qobject_cast<MenuGroup*>(data)) {
+            dataObjectCount = getActionsFromMenuGroup(menuGroup).count();
+        } else if (auto list = qobject_cast<ActionList*>(data)) {
+            dataObjectCount = list->list().count();
+        } else {
+            dataObjectCount = 1;
+        }
+        actualIndex += dataObjectCount;
+        // insert a separator before the new item if there are previous items.
+        insertSeparator |= dataObjectCount > 0;
+
+        // account for item separators if it's not the last data item.
+        actualIndex += dataObjectCount > 0 && (i+1 < index && i+1 < m_data.count()) ? 1: 0;
+    }
+
+    // need to make sure the item after the insertion index has a separator
+    if (index < m_data.count()) {
+        QObject* data = m_data.at(index);
+        QObject* objectToSeparate(Q_NULLPTR);
+
+        if (auto menuGroup = qobject_cast<MenuGroup*>(data)) {
+            objectToSeparate = getFirstObject(menuGroup);
+        } else if (auto actionList = qobject_cast<ActionList*>(data)) {
+            objectToSeparate = actionList->list().count() > 0 ? actionList->list()[0] : 0;
+        } else {
+            objectToSeparate = data;
+        }
+
+        if (objectToSeparate && m_platformItems.contains(objectToSeparate)) {
+            m_platformItems.value(objectToSeparate)->setSeparator();
+        }
+    }
+
+    m_data.insert(m_data.count() > index ? index : m_data.count(), o);
+
+    // if an object changes, we need to remove and re-add it.
+    std::function<void()> refreshObject = [o, this]() {
+        int index = m_data.indexOf(o);
+        if (index >= 0)  {
+            removeObject(o);
+            insertObject(index, o);
+        }
+    };
+
+    // Get All the menu item objects
+    QObjectList objects;
+    if (auto menuGroup = qobject_cast<MenuGroup*>(o)) {
+        Q_FOREACH(QObject* menuGroupObject, getActionsFromMenuGroup(menuGroup)) {
+            objects << menuGroupObject;
+        }
+        // connect to content changes
+        QObject::connect(menuGroup, &MenuGroup::changed, q, refreshObject);
+    } else if (auto actionList = qobject_cast<ActionList*>(o)) {
+        Q_FOREACH(UCAction* action, actionList->list()) {
+            objects << action;
+        }
+        // connect to content changes
+        QObject::connect(actionList, &ActionList::added, q, refreshObject);
+        QObject::connect(actionList, &ActionList::removed, q, refreshObject);
+    } else {
+        objects << o;
+    }
+
+    Q_FOREACH(QObject* platformObject, objects) {
+        // add to platform
+        auto platformWrapper = new PlatformItemWrapper(platformObject, q);
+        platformWrapper->insert(actualIndex++, insertSeparator);
+        if (platformWrapper->hasSeparator()) { // we also inserted an separator, need to increment for next position.
+            actualIndex++;
+        }
+        insertSeparator = false;
+        m_platformItems[platformObject] = platformWrapper;
+        // map the inserted item with the object which sources the platformItem info.
+        if (!m_dataPlatformObjectMap.contains(o, platformObject)) {
+            m_dataPlatformObjectMap.insertMulti(o, platformObject);
+        }
+
+        QObject::connect(platformObject, &QObject::destroyed, q, [o, this](QObject* platformObject) {
+            m_dataPlatformObjectMap.remove(o, platformObject);
+
+            if (m_platformItems.contains(platformObject)) {
+                PlatformItemWrapper* wrapper = m_platformItems.take(platformObject);
+                wrapper->remove();
+                delete wrapper;
+            }
+        });
+    }
+}
+
+void MenuPrivate::removeObject(QObject *o)
+{
+    Q_Q(Menu);
+    m_data.removeOne(o);
+    qCInfo(ucMenu).nospace() << "Menu::removeObject(" << o << ")";
+
+    if (m_platformMenu) {
+        if (auto menuGroup = qobject_cast<MenuGroup*>(o)) {
+            // disconnect from content changes
+            QObject::disconnect(menuGroup, &MenuGroup::changed, q, 0);
+        }  else if (ActionList* actionList = qobject_cast<ActionList*>(o)) {
+            // disconnect from content changes
+            QObject::disconnect(actionList, &ActionList::added, q, 0);
+            QObject::disconnect(actionList, &ActionList::removed, q, 0);
+        }
+
+        QList<QObject*> platformObjects = m_dataPlatformObjectMap.values(o);
+        m_dataPlatformObjectMap.remove(o);
+
+        Q_FOREACH(QObject* platformObject, platformObjects) {
+            // remove from platform.
+            if (m_platformItems.contains(platformObject)) {
+                PlatformItemWrapper* wrapper = m_platformItems.take(platformObject);
+                wrapper->remove();
+                delete wrapper;
+            }
+        }
+    }
+}
+
+void MenuPrivate::_q_updateEnabled()
+{
+    Q_Q(Menu);
+
+    bool isEnabled = q->isEnabled();
+    if (m_platformMenu) { m_platformMenu->setEnabled(isEnabled); }
+}
+
+void MenuPrivate::_q_updateText()
+{
+    Q_Q(Menu);
+
+    QString text = q->text();
+    if (m_platformMenu) { m_platformMenu->setText(text); }
+}
+
+void MenuPrivate::_q_updateIcon()
+{
+    Q_Q(Menu);
+
+    QIcon icon;
+    if (!q->iconSource().isEmpty()) {
+        icon = QIcon(q->iconSource().path());
+    } else if (!q->iconName().isEmpty()) {
+        icon = QIcon::fromTheme(q->iconName());
+    }
+
+    if (m_platformMenu) { m_platformMenu->setIcon(icon); }
+}
+
+void MenuPrivate::_q_updateVisible()
+{
+    Q_Q(Menu);
+
+    bool visible = q->visible();
+    if (m_platformMenu) { m_platformMenu->setVisible(visible); }
+}
+
+void MenuPrivate::data_append(QQmlListProperty<QObject> *prop, QObject *o)
+{
+    Menu *q = qobject_cast<Menu *>(prop->object);
+    q->appendObject(o);
+}
+
+int MenuPrivate::data_count(QQmlListProperty<QObject> *prop)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    return p->m_data.count();
+}
+
+QObject *MenuPrivate::data_at(QQmlListProperty<QObject> *prop, int index)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    return p->m_data.value(index, Q_NULLPTR);
+}
+
+void MenuPrivate::data_clear(QQmlListProperty<QObject> *prop)
+{
+    MenuPrivate *p = static_cast<MenuPrivate *>(prop->data);
+    p->m_data.clear();
+}
+
+/*!
+ * \qmltype Menu
+ * \inqmlmodule Ubuntu.Components
+ * \ingroup ubuntu
+ * \brief Menu defines a context menu or submenu structure of a MenuBar
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * Menu {
+ *     text: "&File"
+ *
+ *     MenuGroup {
+ *         Action {
+ *             text: "&New"
+ *             shortcut: "Ctrl+N"
+ *         }
+ *
+ *         Action {
+ *             text: "&Open"
+ *             shortcut: "Ctrl+O"
+ *         }
+ *     }
+ *
+ *     Menu {
+ *         text: "Recent Files"
+ *
+ *         ActionList {
+ *             Action { text: "1.txt" }
+ *             Action { text: "2.txt" }
+ *             Action { text: "3.txt" }
+ *         }
+ *     }
+ *
+ *     Action {
+ *         action: Action {
+ *             text: "E&xit"
+ *             shortcut: "Ctrl+X"
+ *         }
+ *     }
+ * }
+ * \endqml
+ */
+Menu::Menu(QObject *parent)
+    : UCAction(parent)
+    , d_ptr(new MenuPrivate(this))
+{
+    Q_D(Menu);
+
+    connect(this, SIGNAL(enabledChanged()), this, SLOT(_q_updateEnabled()));
+    connect(this, SIGNAL(textChanged()), this, SLOT(_q_updateText()));
+    connect(this, SIGNAL(iconNameChanged()), this, SLOT(_q_updateIcon()));
+    connect(this, SIGNAL(iconSourceChanged()), this, SLOT(_q_updateIcon()));
+    connect(this, SIGNAL(visibleChanged()), this, SLOT(_q_updateVisible()));
+}
+
+Menu::~Menu()
+{
+}
+
+/*!
+ * \qmlproperty list<Object> Menu::data
+ * \default
+ * List of objects representing menu items within the menu.
+ *
+ * Currently supports Menu, Action, AcionList & MenuGroup objects.
+ * \note Item object which do not support platformItem will not be exported for native menus.
+ */
+QQmlListProperty<QObject> Menu::data()
+{
+    Q_D(Menu);
+    return QQmlListProperty<QObject>(this, d,
+                                     &MenuPrivate::data_append,
+                                     &MenuPrivate::data_count,
+                                     &MenuPrivate::data_at,
+                                     &MenuPrivate::data_clear);
+}
+
+/*!
+ * \qmlmethod Menu::appendObject(object o)
+ * Add a object tto the menu
+ */
+void Menu::appendObject(QObject *o)
+{
+    Q_D(Menu);
+
+    insertObject(d->m_data.count(), o);
+}
+
+/*!
+ * \qmlmethod Menu::insertObject(int index, object o)
+ * Inserts an item at the index in the menu.
+ *
+ * Currently supports Menu, Action, AcionList & MenuGroup objects.
+ * \note Item object which do not support platformItem will not be exported for native menus.
+ */
+void Menu::insertObject(int index, QObject *o)
+{
+    Q_D(Menu);
+    d->insertObject(index, o);
+}
+
+/*!
+ * \qmlmethod Menu::removeObject(object o)
+ * Removes the item from the menu.
+ */
+void Menu::removeObject(QObject *o)
+{
+    Q_D(Menu);
+    qCInfo(ucMenu) << "Menu::removeObject" << o;
+
+    d->removeObject(o);
+}
+
+QPlatformMenu* Menu::platformMenu() const
+{
+    Q_D(const Menu);
+    return d->m_platformMenu;
+}
+
+/*!
+ * \qmlmethod Menu::show(point point)
+ * Show the menu popup at the given point
+ */
+void Menu::show(const QPoint &point)
+{
+    Q_D(Menu);
+    qCInfo(ucMenu, "Menu::popup(%s, point(%d,%d))", qPrintable(text()), point.x(), point.y());
+
+    if (d->m_platformMenu) {
+        d->m_platformMenu->showPopup(findWindowForObject(this), QRect(point, QSize()), Q_NULLPTR);
+    }
+}
+
+/*!
+ * \qmlmethod Menu::dismiss()
+ * Dismiss and destroy the menu popup.
+ */
+void Menu::dismiss()
+{
+    Q_D(Menu);
+    qCInfo(ucMenu, "Menu::dismiss(%s)", qPrintable(text()));
+
+    if (d->m_platformMenu) {
+        d->m_platformMenu->dismiss();
+    }
+}
+
+
+PlatformItemWrapper::PlatformItemWrapper(QObject *target, Menu* menu)
+    : QObject(menu)
+    , m_target(target)
+    , m_menu(menu)
+    , m_platformItem(menu->platformMenu() ? menu->platformMenu()->createMenuItem() : Q_NULLPTR)
+    , m_platformItemSeparator(Q_NULLPTR)
+    , m_inserted(false)
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) {
+            m_platformItem->setMenu(menu->platformMenu());
+        }
+
+        connect(menu, &Menu::visibleChanged, this, &PlatformItemWrapper::updateVisible);
+        connect(menu, &Menu::textChanged, this, &PlatformItemWrapper::updateText);
+        connect(menu, &Menu::enabledChanged, this, &PlatformItemWrapper::updateEnabled);
+        connect(menu, &Menu::iconSourceChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(menu, &Menu::iconNameChanged, this, &PlatformItemWrapper::updateIcon);
+
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+
+        connect(action, &UCAction::visibleChanged, this, &PlatformItemWrapper::updateVisible);
+        connect(action, &UCAction::textChanged, this, &PlatformItemWrapper::updateText);
+        connect(action, &UCAction::enabledChanged, this, &PlatformItemWrapper::updateEnabled);
+        connect(action, &UCAction::iconSourceChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(action, &UCAction::iconNameChanged, this, &PlatformItemWrapper::updateIcon);
+        connect(action, &UCAction::shortcutChanged, this, &PlatformItemWrapper::updateShortcut);
+        connect(action, &UCAction::checkableChanged, this, &PlatformItemWrapper::updateCheck);
+        connect(action, &UCAction::toggled, this, &PlatformItemWrapper::updateCheck);
+
+        if (m_platformItem) {
+            // Connect to activate (with inversion for checkables)
+            connect(m_platformItem, &QPlatformMenuItem::activated, action, [action]() {
+                action->trigger();
+            });
+        }
+
+    }
+    syncPlatformItem();
+}
+
+PlatformItemWrapper::~PlatformItemWrapper()
+{
+    if (m_inserted && m_menu && m_menu->platformMenu()) {
+        m_menu->platformMenu()->removeMenuItem(m_platformItem);
+        if (m_platformItemSeparator) {
+            m_menu->platformMenu()->removeMenuItem(m_platformItemSeparator);
+            delete m_platformItemSeparator;
+        }
+    }
+    delete m_platformItem;
+}
+
+void PlatformItemWrapper::insert(int index, bool withSeparator)
+{
+    if (m_inserted) return;
+    qCInfo(ucMenu).nospace() << " PlatformItemWrapper::insert(menu=" << m_menu
+                                                        << ", index=" << index
+                                                        << ", object=" << m_target << ")";
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+    if (!m_platformItem) return;
+
+    QPlatformMenuItem* before = platformMenu->menuItemAt(index);
+    platformMenu->insertMenuItem(m_platformItem, before);
+    m_inserted = true;
+
+    if (withSeparator) setSeparator();
+}
+
+void PlatformItemWrapper::remove()
+{
+    if (!m_inserted) return;
+    qCInfo(ucMenu).nospace() << " PlatformItemWrapper::remove(menu=" << m_menu
+                                                        << ", object=" << m_target << ")";
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+    if (!m_platformItem) return;
+
+    platformMenu->removeMenuItem(m_platformItem);
+    m_inserted = false;
+
+    if (m_platformItemSeparator) {
+        qCInfo(ucMenu).nospace() << " PlatformItemWrapper::removeSeparator(menu=" << m_menu
+                                                            << ", object=" << m_target << ")";
+        platformMenu->removeMenuItem(m_platformItemSeparator);
+        delete m_platformItemSeparator;
+        m_platformItemSeparator = Q_NULLPTR;
+    }
+}
+
+void PlatformItemWrapper::setSeparator()
+{
+    // already created
+    if (m_platformItemSeparator) return;
+    // not inserted yet.
+    if (!m_inserted) return;
+
+    auto platformMenu = m_menu->platformMenu();
+    if (!platformMenu) return;
+
+    // insert separator before?
+    m_platformItemSeparator = platformMenu->createMenuItem();
+    if (m_platformItemSeparator) {
+        qCInfo(ucMenu).nospace() << " PlatformItemWrapper::setSeparator(menu=" << m_menu
+                                                            << ", object=" << m_target << ")";
+
+        m_platformItemSeparator->setIsSeparator(true);
+        platformMenu->insertMenuItem(m_platformItemSeparator, m_platformItem);
+    }
+}
+
+void PlatformItemWrapper::updateVisible()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setVisible(menu->visible());
+        if (menu->platformMenu()) menu->platformMenu()->setVisible(menu->visible());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setVisible(action->visible());
+    }
+}
+
+void PlatformItemWrapper::updateEnabled()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setEnabled(menu->isEnabled());
+        if (menu->platformMenu()) menu->platformMenu()->setEnabled(menu->isEnabled());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setEnabled(action->isEnabled());
+    }
+}
+
+void PlatformItemWrapper::updateText()
+{
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+        if (m_platformItem) m_platformItem->setText(menu->text());
+        if (menu->platformMenu()) menu->platformMenu()->setText(menu->text());
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        if (m_platformItem) m_platformItem->setText(action->text());
+    }
+}
+
+void PlatformItemWrapper::updateIcon()
+{
+    QIcon icon;
+    if (Menu* menu = qobject_cast<Menu*>(m_target)) {
+
+        if (!menu->iconSource().isEmpty()) {
+            icon = QIcon(menu->iconSource().path());
+        } else if (!menu->iconName().isEmpty()) {
+            icon = QIcon::fromTheme(menu->iconName());
+        }
+        if (menu->platformMenu()) menu->platformMenu()->setIcon(icon);
+
+    } else if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+
+        if (!action->iconSource().isEmpty()) {
+            icon = QIcon(action->iconSource().path());
+        } else if (!action->iconName().isEmpty()) {
+            icon = QIcon::fromTheme(action->iconName());
+        }
+    }
+
+    if (m_platformItem) { m_platformItem->setIcon(icon); }
+}
+
+
+inline QKeySequence sequenceFromVariant(const QVariant& variant)
+{
+    if (variant.type() == QVariant::Int) {
+        return static_cast<QKeySequence::StandardKey>(variant.toInt());
+    }
+    if (variant.type() == QVariant::String) {
+        return QKeySequence::fromString(variant.toString());
+    }
+    return QKeySequence();
+}
+
+void PlatformItemWrapper::updateShortcut()
+{
+    if (!m_platformItem) return;
+
+    if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        m_platformItem->setShortcut(sequenceFromVariant(action->shortcut()));
+    }
+}
+
+void PlatformItemWrapper::updateCheck()
+{
+    if (!m_platformItem) return;
+
+    if (UCAction* action = qobject_cast<UCAction*>(m_target)) {
+        bool checkable = action->isCheckable();
+        m_platformItem->setCheckable(checkable);
+        m_platformItem->setChecked(checkable && action->isChecked());
+    }
+}
+
+void PlatformItemWrapper::syncPlatformItem()
+{
+    updateVisible();
+    updateEnabled();
+    updateText();
+    updateIcon();
+    updateShortcut();
+    updateCheck();
+
+    if (m_menu->platformMenu() && m_platformItem) {
+        m_menu->platformMenu()->syncMenuItem(m_platformItem);
+    }
+}
+
+UT_NAMESPACE_END
+
+#include "moc_menu_p.cpp"

=== added file 'src/Ubuntu/UbuntuToolkit/menu_p.h'
--- src/Ubuntu/UbuntuToolkit/menu_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu_p.h	2016-08-22 16:02:17 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MENU_P_H
+#define MENU_P_H
+
+#include <QQmlListProperty>
+#include <QLoggingCategory>
+#include <QPointer>
+#include <ubuntutoolkitglobal.h>
+
+#include "ucaction_p.h"
+
+Q_DECLARE_LOGGING_CATEGORY(ucMenu);
+
+class QPlatformMenu;
+class QPlatformMenuItem;
+class QQuickItem;
+
+UT_NAMESPACE_BEGIN
+
+class MenuPrivate;
+class MenuBar;
+class UCAction;
+class UBUNTUTOOLKIT_EXPORT Menu : public UCAction
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data FINAL)
+    Q_CLASSINFO("DefaultProperty", "data")
+
+public:
+    explicit Menu(QObject *parent = 0);
+    ~Menu();
+
+    QQmlListProperty<QObject> data();
+
+    Q_INVOKABLE void appendObject(QObject* obj);
+    Q_INVOKABLE void insertObject(int index, QObject* obj);
+    Q_INVOKABLE void removeObject(QObject* obj);
+
+    QPlatformMenu *platformMenu() const;
+
+public Q_SLOTS:
+    void show(const QPoint& pt);
+    void dismiss();
+
+private:
+    Q_DISABLE_COPY(Menu)
+    Q_DECLARE_PRIVATE(Menu)
+    QScopedPointer<MenuPrivate> d_ptr;
+
+    Q_PRIVATE_SLOT(d_func(), void _q_updateEnabled())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateText())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateIcon())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateVisible())
+};
+
+UT_NAMESPACE_END
+
+#endif // MENU_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menu_p_p.h'
--- src/Ubuntu/UbuntuToolkit/menu_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menu_p_p.h	2016-08-22 16:02:17 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MENU_P_P_H
+#define MENU_P_P_H
+
+#include "menu_p.h"
+#include <ubuntutoolkitglobal.h>
+
+class QObject;
+class QQmlComponent;
+
+UT_NAMESPACE_BEGIN
+
+class UCAction;
+class Menu;
+class PlatformItemWrapper;
+
+class MenuPrivate
+{
+    Q_DECLARE_PUBLIC(Menu)
+public:
+    MenuPrivate(Menu *qq);
+    virtual ~MenuPrivate();
+
+    void insertObject(int index, QObject *obj);
+    void removeObject(QObject *obj);
+
+    void _q_updateEnabled();
+    void _q_updateText();
+    void _q_updateIcon();
+    void _q_updateVisible();
+
+    static void data_append(QQmlListProperty<QObject> *prop, QObject *o);
+    static int data_count(QQmlListProperty<QObject> *prop);
+    static QObject *data_at(QQmlListProperty<QObject> *prop, int index);
+    static void data_clear(QQmlListProperty<QObject> *prop);
+
+    Menu* q_ptr;
+    QPlatformMenu* m_platformMenu;
+    UCAction* m_action;
+
+    QHash<QObject*, PlatformItemWrapper*> m_platformItems;
+    QMultiHash<QObject*, QObject*> m_dataPlatformObjectMap;
+    QVector<QObject*> m_data;
+};
+
+class PlatformItemWrapper : public QObject
+{
+    Q_OBJECT
+public:
+    PlatformItemWrapper(QObject *target, Menu* menu);
+    ~PlatformItemWrapper();
+
+    void insert(int index, bool withSeparator);
+    void remove();
+    void setSeparator();
+
+    bool hasSeparator() const { return m_platformItemSeparator != Q_NULLPTR; }
+
+public Q_SLOTS:
+    void updateVisible();
+    void updateEnabled();
+    void updateText();
+    void updateIcon();
+    void updateShortcut();
+    void updateCheck();
+
+private:
+    void syncPlatformItem();
+
+    QObject* m_target;
+    QPointer<Menu> m_menu;
+    QPlatformMenuItem* m_platformItem;
+    QPlatformMenuItem* m_platformItemSeparator;
+    bool m_inserted;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENU_P_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menubar.cpp'
--- src/Ubuntu/UbuntuToolkit/menubar.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar.cpp	2016-08-22 16:02:17 +0000
@@ -0,0 +1,339 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "menubar_p.h"
+#include "menubar_p_p.h"
+
+// Qt
+#include <QQuickItem>
+#include <QQuickWindow>
+#include <private/qguiapplication_p.h>
+#include <QtGui/qpa/qplatformtheme.h>
+#include <QtGui/qpa/qplatformmenu.h>
+
+UT_NAMESPACE_BEGIN
+
+MenuBarPrivate::MenuBarPrivate(MenuBar *qq)
+    : q_ptr(qq)
+{
+    m_platformBar = QGuiApplicationPrivate::platformTheme()->createPlatformMenuBar();
+}
+
+MenuBarPrivate::~MenuBarPrivate()
+{
+    qDeleteAll(m_platformMenus);
+    m_platformMenus.clear();
+
+    delete m_platformBar;
+    m_platformBar = Q_NULLPTR;
+}
+
+void MenuBarPrivate::insertMenu(int index, Menu* menu)
+{
+    Q_Q(MenuBar);
+    Menu* prevMenu = m_menus.count() > index ? m_menus[index] : Q_NULLPTR;
+
+    m_menus.insert(index, menu);
+
+    // add to platform
+    if (m_platformBar && menu->platformMenu()) {
+        auto platformWrapper = new PlatformMenuWrapper(menu, q);
+        platformWrapper->insert(prevMenu ? prevMenu->platformMenu() : Q_NULLPTR);
+        m_platformMenus[menu] = platformWrapper;
+
+        QObject::connect(menu, &QObject::destroyed, q, [this](QObject* object) {
+            if (m_platformMenus.contains(object)) {
+                PlatformMenuWrapper* wrapper = m_platformMenus.take(object);
+                wrapper->remove();
+                delete wrapper;
+            }
+        });
+    }
+}
+
+void MenuBarPrivate::removeMenu(Menu *menu)
+{
+    m_menus.removeOne(menu);
+
+    if (m_platformBar) {
+        if (m_platformMenus.contains(menu)) {
+            PlatformMenuWrapper* wrapper = m_platformMenus.take(menu);
+            wrapper->remove();
+            delete wrapper;
+        }
+    }
+}
+
+void MenuBarPrivate::menu_append(QQmlListProperty<Menu> *prop, Menu *o)
+{
+    MenuBarPrivate *q = static_cast<MenuBarPrivate *>(prop->data);
+    // menubar is the menus parent
+    o->setParent(prop->object);
+    q->insertMenu(q->m_menus.count(), o);
+}
+
+int MenuBarPrivate::menu_count(QQmlListProperty<Menu> *prop)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    return p->m_menus.count();
+}
+
+Menu *MenuBarPrivate::menu_at(QQmlListProperty<Menu> *prop, int index)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    return p->m_menus.value(index);
+}
+
+void MenuBarPrivate::menu_clear(QQmlListProperty<Menu> *prop)
+{
+    MenuBarPrivate *p = static_cast<MenuBarPrivate *>(prop->data);
+    p->m_menus.clear();
+}
+
+/*!
+ * \qmltype MenuBar
+ * \inqmlmodule Ubuntu.Components 1.3
+ * \ingroup ubuntu
+ * \brief MenuBar defines an application menu bar structure
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * MainView {
+ *     MenuBar {
+ *         Menu {
+ *             text: "_File"
+ *
+ *             MenuItem {
+ *                 text: "_New"
+ *                 shortcut: "Ctrl+N"
+ *             }
+ *
+ *             MenuItem {
+ *                 text: "_Open"
+ *                 shortcut: "Ctrl+O"
+ *             }
+ *
+ *             MenuSeparator {}
+ *
+ *             MenuItem {
+ *                 action: exitAction
+ *             }
+ *         }
+ *
+ *         Menu {
+ *             text: "_Edit"
+ *
+ *             MenuItem {
+ *                 text: "_Undo"
+ *                 iconSource: "image://theme/undo"
+ *             }
+ *         }
+ *         Menu {
+ *             text: "_Window"
+ *
+ *             MenuItem {
+ *                 text: "Fullscreen"
+ *                 checkable: true
+ *                 checked: false
+ *             }
+ *         }
+ *     }
+ *     Action {
+ *         id: boundAction
+ *         text: "E_xit"
+ *         onTriggered: {
+ *             Qt.quit();
+ *         }
+ *     }
+ * }
+ * \endqml
+ */
+MenuBar::MenuBar(QObject *parent)
+    : QObject(parent)
+    , d_ptr(new MenuBarPrivate(this))
+{
+}
+
+MenuBar::~MenuBar()
+{
+}
+
+/*!
+  * \qmlmethod void MenuBar::appendMenu(Menu menu)
+  * Append a Menu to the MenuBar
+ */
+void MenuBar::appendMenu(Menu *menu)
+{
+    Q_D(MenuBar);
+    insertMenu(d->m_menus.count(), menu);
+}
+
+/*!
+  * \qmlmethod void MenuBar::insertMenu(int index, Menu menu)
+  * Insert a Menu to the MenuBar at the specified position
+ */
+void MenuBar::insertMenu(int index, Menu *menu)
+{
+    Q_D(MenuBar);
+    if (!menu) return;
+
+    d->insertMenu(index, menu);
+    Q_EMIT menusChanged();
+}
+
+/*!
+  * \qmlmethod void MenuBar::removeMenu(Menu menu)
+  * Remove a Menu from the MenuBar
+ */
+void MenuBar::removeMenu(Menu *menu)
+{
+    Q_D(MenuBar);
+    if (!menu) return;
+
+    d->removeMenu(menu);
+    Q_EMIT menusChanged();
+}
+/*!
+ * \qmlproperty list<Menu> MenuBar::menus
+ * \default
+ * List of Menus in this MenuBar.
+ */
+QQmlListProperty<Menu> MenuBar::menus()
+{
+    Q_D(MenuBar);
+    return QQmlListProperty<Menu>(this, d,
+                                     &MenuBarPrivate::menu_append,
+                                     &MenuBarPrivate::menu_count,
+                                     &MenuBarPrivate::menu_at,
+                                    &MenuBarPrivate::menu_clear);
+}
+
+QPlatformMenuBar *MenuBar::platformMenuBar() const
+{
+    Q_D(const MenuBar);
+    return d->m_platformBar;
+}
+
+void MenuBar::classBegin()
+{
+}
+
+void MenuBar::componentComplete()
+{
+    Q_D(MenuBar);
+
+    auto parentItem = qobject_cast<QQuickItem*>(parent());
+    if (parentItem && d->m_platformBar) {
+        d->m_platformBar->handleReparent(parentItem->window());
+    }
+}
+
+
+PlatformMenuWrapper::PlatformMenuWrapper(Menu *target, MenuBar* bar)
+    : QObject(bar)
+    , m_bar(bar)
+    , m_target(target)
+    , m_inserted(false)
+{
+    connect(m_target, &Menu::visibleChanged, this, &PlatformMenuWrapper::updateVisible);
+    connect(m_target, &Menu::textChanged, this, &PlatformMenuWrapper::updateText);
+    connect(m_target, &Menu::enabledChanged, this, &PlatformMenuWrapper::updateEnabled);
+    connect(m_target, &Menu::iconSourceChanged, this, &PlatformMenuWrapper::updateIcon);
+    connect(m_target, &Menu::iconNameChanged, this, &PlatformMenuWrapper::updateIcon);
+
+    syncPlatformMenu();
+}
+
+PlatformMenuWrapper::~PlatformMenuWrapper()
+{
+    if (m_inserted && m_bar && m_bar->platformMenuBar()) {
+        if (m_target && m_target->platformMenu()) {
+            m_bar->platformMenuBar()->removeMenu(m_target->platformMenu());
+        }
+    }
+}
+
+void PlatformMenuWrapper::insert(QPlatformMenu *before)
+{
+    if (m_inserted) return;
+    qCInfo(ucMenu).nospace() << " PlatformMenuWrapper::insert(bar=" << m_bar
+                                                        << ", before=" << before
+                                                        << ", menu=" << m_target << ")";
+
+    auto platformBar = m_bar->platformMenuBar();
+    if (!platformBar) return;
+    auto platformMenu = m_target->platformMenu();
+    if (!platformMenu) return;
+
+    platformBar->insertMenu(platformMenu, before);
+    m_inserted = true;
+}
+
+void PlatformMenuWrapper::remove()
+{
+    if (!m_inserted) return;
+    qCInfo(ucMenu).nospace() << " PlatformMenuWrapper::remove(bar=" << m_bar
+                                                        << ", menu=" << m_target << ")";
+
+    auto platformBar = m_bar->platformMenuBar();
+    if (!platformBar) return;
+    auto platformMenu = m_target->platformMenu();
+    if (!platformMenu) return;
+
+    platformBar->removeMenu(platformMenu);
+    m_inserted = false;
+}
+
+void PlatformMenuWrapper::updateVisible()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setVisible(m_target->visible());
+}
+
+void PlatformMenuWrapper::updateEnabled()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setEnabled(m_target->isEnabled());
+}
+
+void PlatformMenuWrapper::updateText()
+{
+    if (m_target->platformMenu()) m_target->platformMenu()->setText(m_target->text());
+}
+
+void PlatformMenuWrapper::updateIcon()
+{
+    QIcon icon;
+    if (!m_target->iconSource().isEmpty()) {
+        icon = QIcon(m_target->iconSource().path());
+    } else if (!m_target->iconName().isEmpty()) {
+        icon = QIcon::fromTheme(m_target->iconName());
+    }
+    if (m_target->platformMenu()) m_target->platformMenu()->setIcon(icon);
+}
+
+void PlatformMenuWrapper::syncPlatformMenu()
+{
+    updateVisible();
+    updateEnabled();
+    updateText();
+    updateIcon();
+}
+
+UT_NAMESPACE_END
+
+#include "moc_menubar_p.cpp"

=== added file 'src/Ubuntu/UbuntuToolkit/menubar_p.h'
--- src/Ubuntu/UbuntuToolkit/menubar_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar_p.h	2016-08-22 16:02:17 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MENUBAR_P_H
+#define MENUBAR_P_H
+
+#include "menu_p.h"
+#include <ubuntutoolkitglobal.h>
+
+#include <QQmlParserStatus>
+
+class QPlatformMenuBar;
+
+UT_NAMESPACE_BEGIN
+
+class MenuBarPrivate;
+class UBUNTUTOOLKIT_EXPORT MenuBar : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+
+    Q_PROPERTY(QQmlListProperty<UT_PREPEND_NAMESPACE(Menu)> menus READ menus NOTIFY menusChanged FINAL)
+    Q_CLASSINFO("DefaultProperty", "menus")
+
+public:
+    explicit MenuBar(QObject *parent = 0);
+    ~MenuBar();
+
+    Q_INVOKABLE void appendMenu(Menu *menu);
+    Q_INVOKABLE void insertMenu(int index, Menu *menu);
+    Q_INVOKABLE void removeMenu(Menu *menu);
+
+    QQmlListProperty<Menu> menus();
+
+    QPlatformMenuBar *platformMenuBar() const;
+
+    void classBegin() Q_DECL_OVERRIDE;
+    void componentComplete() Q_DECL_OVERRIDE;
+
+Q_SIGNALS:
+    void menusChanged();
+
+private:
+    Q_DISABLE_COPY(MenuBar)
+    Q_DECLARE_PRIVATE(MenuBar)
+    QScopedPointer<MenuBarPrivate> d_ptr;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUBAR_P_H

=== added file 'src/Ubuntu/UbuntuToolkit/menubar_p_p.h'
--- src/Ubuntu/UbuntuToolkit/menubar_p_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menubar_p_p.h	2016-08-22 16:02:17 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MENUBAR_P_P_H
+#define MENUBAR_P_P_H
+
+#include "menubar_p.h"
+#include <ubuntutoolkitglobal.h>
+
+class QPlatformMenuBar;
+
+UT_NAMESPACE_BEGIN
+
+class PlatformMenuWrapper;
+
+class MenuBarPrivate
+{
+    Q_DECLARE_PUBLIC(MenuBar)
+public:
+    MenuBarPrivate(MenuBar *qq);
+    ~MenuBarPrivate();
+
+    void insertMenu(int index, Menu *menu);
+    void removeMenu(Menu *menu);
+
+    static void menu_append(QQmlListProperty<Menu> *prop, Menu *o);
+    static int menu_count(QQmlListProperty<Menu> *prop);
+    static Menu *menu_at(QQmlListProperty<Menu> *prop, int index);
+    static void menu_clear(QQmlListProperty<Menu> *prop);
+
+    MenuBar* q_ptr;
+    QPlatformMenuBar* m_platformBar;
+    QVector<Menu*> m_menus;
+    QHash<QObject*, PlatformMenuWrapper*> m_platformMenus;
+};
+
+class PlatformMenuWrapper : public QObject
+{
+    Q_OBJECT
+public:
+    PlatformMenuWrapper(Menu *target, MenuBar *bar);
+    ~PlatformMenuWrapper();
+
+    void insert(QPlatformMenu *before);
+    void remove();
+
+public Q_SLOTS:
+    void updateVisible();
+    void updateEnabled();
+    void updateText();
+    void updateIcon();
+
+private:
+    void syncPlatformMenu();
+
+    QPointer<MenuBar> m_bar;
+    QPointer<Menu> m_target;
+    bool m_inserted;
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUBAR_P_P_H
+

=== added file 'src/Ubuntu/UbuntuToolkit/menugroup.cpp'
--- src/Ubuntu/UbuntuToolkit/menugroup.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menugroup.cpp	2016-08-22 16:02:17 +0000
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "menugroup_p.h"
+#include "actionlist_p.h"
+#include "ucaction_p.h"
+
+UT_NAMESPACE_BEGIN
+
+/*!
+ * \qmltype MenuGroup
+ * \inqmlmodule Ubuntu.Components
+ * \ingroup ubuntu
+ * \brief Logical list of items for a menu.
+ *
+ * Example usage:
+ * \qml
+ * import QtQuick 2.4
+ * import Ubuntu.Components 1.3
+ * Menu {
+ *     text: "Edit"
+ *
+ *     MenuGroup {
+ *         Action { text: "Undo" }
+ *         Action { text: "Redo" }
+ *     }
+ *
+ *     MenuGroup {
+ *         Action { text: "Cut" }
+ *         ActionList {
+ *             Action { text: "Copy" }
+ *             Action { text: "Paste" }
+ *         }
+ *     }
+ *
+ *     MenuGroup {
+ *         Action { text: "Select All" }
+ *     }
+ * }
+ * \endqml
+ */
+/*!
+ * \qmlsignal MenuGroup::added(Object action)
+ * Signal called when a action is added to the list
+ */
+
+/*!
+ * \qmlsignal MenuGroup::removed(Object action)
+ * Signal called when a action is removed from the list
+ */
+/*!
+ * \qmlsignal MenuGroup::changed()
+ * Signal called when the contents of the group change,
+ * including child content changes (eg. \l ActionList child add/remove)
+ */
+MenuGroup::MenuGroup(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+ * \qmlmethod MenuGroup::addObject(Object object)
+ * Adds an Object to the list programatically.
+ */
+void MenuGroup::addObject(QObject *object)
+{
+    if (m_data.contains(object)) {
+        return;
+    }
+    m_data.push_back(object);
+
+    if (auto childGroup = qobject_cast<MenuGroup*>(object)) {
+        connect(childGroup, &MenuGroup::changed, this, &MenuGroup::changed);
+    } else if (auto actionList = qobject_cast<ActionList*>(object)) {
+        connect(actionList, &ActionList::added, this, &MenuGroup::changed);
+        connect(actionList, &ActionList::removed, this, &MenuGroup::changed);
+    }
+
+    Q_EMIT added(object);
+    Q_EMIT changed();
+}
+
+/*!
+ * \qmlmethod MenuGroup::removeObject(Object object)
+ * Removes an object from the list programatically.
+ */
+void MenuGroup::removeObject(QObject *object)
+{
+    if (!object) {
+        return;
+    }
+    if (m_data.removeOne(object)) {
+        disconnect(object, 0, this, 0);
+        Q_EMIT removed(object);
+        Q_EMIT changed();
+    }
+}
+
+/*!
+
+ * \qmlproperty list<Object> MenuGroup::data
+ * \default
+ * List of Objects in this MenuGroup
+ * Note that when you set this property, the children of the MenuGroup will be ignored,
+ * so do not set the list and define children.
+ */
+QQmlListProperty<QObject> MenuGroup::data()
+{
+    return QQmlListProperty<QObject>(this, 0, MenuGroup::append, MenuGroup::count, MenuGroup::at, MenuGroup::clear);
+}
+
+const QVector<QObject*> &MenuGroup::list() const
+{
+    return m_data;
+}
+
+void MenuGroup::append(QQmlListProperty<QObject> *list, QObject *object)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        menuGroup->addObject(object);
+    }
+}
+
+int MenuGroup::count(QQmlListProperty<QObject> *list)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        return menuGroup->m_data.count();
+    }
+    return 0;
+}
+
+QObject* MenuGroup::at(QQmlListProperty<QObject> *list, int index)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup && index >=0 && menuGroup->m_data.count() > index) {
+        return menuGroup->m_data[index];
+    }
+    return Q_NULLPTR;
+}
+
+void MenuGroup::clear(QQmlListProperty<QObject> *list)
+{
+    MenuGroup *menuGroup = qobject_cast<MenuGroup*>(list->object);
+    if (menuGroup) {
+        menuGroup->m_data.clear();
+    }
+}
+
+UT_NAMESPACE_END

=== added file 'src/Ubuntu/UbuntuToolkit/menugroup_p.h'
--- src/Ubuntu/UbuntuToolkit/menugroup_p.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/menugroup_p.h	2016-08-22 16:02:17 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MENUGROUP_P_H
+#define MENUGROUP_P_H
+
+#include <ubuntutoolkitglobal.h>
+
+#include <QObject>
+#include <QVector>
+#include <QQmlListProperty>
+
+UT_NAMESPACE_BEGIN
+
+class MenuGroup : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlListProperty<QObject> data READ data)
+    Q_CLASSINFO("DefaultProperty", "data")
+public:
+    explicit MenuGroup(QObject *parent = 0);
+
+    QQmlListProperty<QObject> data();
+
+    const QVector<QObject*> &list() const;
+
+public Q_SLOTS:
+    void addObject(QObject *object);
+    void removeObject(QObject *object);
+
+Q_SIGNALS:
+    void added(QObject *object);
+    void removed(QObject *object);
+    void changed();
+
+protected:
+    QVector<QObject*> m_data;
+
+    static void append(QQmlListProperty<QObject> *list, QObject *action);
+    static int count(QQmlListProperty<QObject> *list);
+    static QObject* at(QQmlListProperty<QObject> *list, int);
+    static void clear(QQmlListProperty<QObject> *list);
+};
+
+UT_NAMESPACE_END
+
+#endif // MENUGROUP_P_H

=== modified file 'src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp'
--- src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp	2016-08-22 16:02:17 +0000
+++ src/Ubuntu/UbuntuToolkit/ubuntutoolkitmodule.cpp	2016-08-22 16:02:17 +0000
@@ -91,6 +91,9 @@
 #include <privates/ucscrollbarutils_p.h>
 #include <actionlist_p.h>
 #include <exclusivegroup_p.h>
+#include <menu_p.h>
+#include <menubar_p.h>
+#include <menugroup_p.h>
 
 // styles
 #include <ucbottomedgestyle_p.h>
@@ -414,9 +417,9 @@
 
 void UbuntuLabsModule::defineModule(const char *uri)
 {
-    Q_UNUSED(uri);
-    // a fake component so we can have the module types file created
-    qmlRegisterType<QObject>(uri, 1, 0, "ZiObject");
+    qmlRegisterType<Menu>(uri, 1, 0, "Menu");
+    qmlRegisterType<MenuBar>(uri, 1, 0, "MenuBar");
+    qmlRegisterType<MenuGroup>(uri, 1, 0, "MenuGroup");
 }
 
 void UbuntuLabsModule::undefineModule()

=== modified file 'src/Ubuntu/UbuntuToolkit/ucaction.cpp'
--- src/Ubuntu/UbuntuToolkit/ucaction.cpp	2016-08-22 16:02:17 +0000
+++ src/Ubuntu/UbuntuToolkit/ucaction.cpp	2016-08-22 16:02:17 +0000
@@ -271,43 +271,6 @@
  * \endqml
  */
 
-/*!
- * \qmlproperty enum Action::parameterType
- * Type of the parameter passed to \l trigger and \l triggered.
- * Type is an enumeration:
- * \list
- *  \li \b Action.None: No paramater. (default)
- *  \li \b Action.String: String parameter.
- *  \li \b Action.Integer: Integer parameter.
- *  \li \b Action.Bool: Boolean parameter.
- *  \li \b Action.Real: Single precision floating point parameter.
- *  \li \b Action.Object: The parameter is an object.
- * \endlist
- * \qml
- * Action {
- *     id: action
- *     parameterType: Action.String
- *     onTriggered: {
- *         // value arguments now contain strings
- *         console.log(value);
- *     }
- *     Component.onCompleted: action.trigger("Hello World")
- * }
- * \endqml
- */
-
-/*!
- * \qmlproperty bool Action::enabled
- * If set to false the action can not be triggered. Components visualizing the
- * action migth either hide the action or make it insensitive. However visibility
- * can be controlled separately using the \l visible property.
- */
-
-/*!
- * \qmlproperty bool Action::visible
- * Specifies whether the action is visible to the user. Defaults to true.
- */
-
 UCAction::UCAction(QObject *parent)
     : QObject(parent)
     , m_exclusiveGroup(Q_NULLPTR)
@@ -461,6 +424,68 @@
 }
 
 /*!
+ * \qmlproperty bool Action::visible
+ * Specifies whether the action is visible to the user. Defaults to true.
+ */
+void UCAction::setVisible(bool visible)
+{
+    if (m_visible == visible) {
+        return;
+    }
+    m_visible = visible;
+    Q_EMIT visibleChanged();
+}
+
+/*!
+ * \qmlproperty bool Action::enabled
+ * If set to false the action can not be triggered. Components visualizing the
+ * action migth either hide the action or make it insensitive. However visibility
+ * can be controlled separately using the \l visible property.
+ */
+void UCAction::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled) {
+        return;
+    }
+    m_enabled = enabled;
+    Q_EMIT enabledChanged();
+
+}
+
+/*!
+ * \qmlproperty enum Action::parameterType
+ * Type of the parameter passed to \l trigger and \l triggered.
+ * Type is an enumeration:
+ * \list
+ *  \li \b Action.None: No paramater. (default)
+ *  \li \b Action.String: String parameter.
+ *  \li \b Action.Integer: Integer parameter.
+ *  \li \b Action.Bool: Boolean parameter.
+ *  \li \b Action.Real: Single precision floating point parameter.
+ *  \li \b Action.Object: The parameter is an object.
+ * \endlist
+ * \qml
+ * Action {
+ *     id: action
+ *     parameterType: Action.String
+ *     onTriggered: {
+ *         // value arguments now contain strings
+ *         console.log(value);
+ *     }
+ *     Component.onCompleted: action.trigger("Hello World")
+ * }
+ * \endqml
+ */
+void UCAction::setParameterType(UCAction::Type type)
+{
+    if (m_parameterType == type) {
+        return;
+    }
+    m_parameterType = type;
+    Q_EMIT parameterTypeChanged();
+}
+
+/*!
  * \qmlproperty bool Action::checkable
  * \since Ubuntu.Components 1.3
  * Whether the action can be checked. Defaults to false.

=== modified file 'src/Ubuntu/UbuntuToolkit/ucaction_p.h'
--- src/Ubuntu/UbuntuToolkit/ucaction_p.h	2016-08-22 16:02:17 +0000
+++ src/Ubuntu/UbuntuToolkit/ucaction_p.h	2016-08-22 16:02:17 +0000
@@ -62,23 +62,23 @@
     Q_ENUMS(Type)
     Q_PROPERTY(QString name MEMBER m_name WRITE setName NOTIFY nameChanged)
     Q_PROPERTY(QString text READ text WRITE setText RESET resetText NOTIFY textChanged)
-    Q_PROPERTY(QString iconName MEMBER m_iconName WRITE setIconName NOTIFY iconNameChanged)
+    Q_PROPERTY(QString iconName READ iconName WRITE setIconName NOTIFY iconNameChanged)
     Q_PROPERTY(QString description MEMBER m_description NOTIFY descriptionChanged)
     Q_PROPERTY(QString keywords MEMBER m_keywords NOTIFY keywordsChanged)
-    Q_PROPERTY(bool enabled MEMBER m_enabled NOTIFY enabledChanged)
-    Q_PROPERTY(Type parameterType MEMBER m_parameterType NOTIFY parameterTypeChanged)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(Type parameterType READ parameterType WRITE setParameterType NOTIFY parameterTypeChanged)
 
     Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY checkableChanged REVISION 1)
     Q_PROPERTY(bool checked READ isChecked WRITE setChecked NOTIFY toggled REVISION 1)
     Q_PROPERTY(ExclusiveGroup* exclusiveGroup READ exclusiveGroup WRITE setExclusiveGroup NOTIFY exclusiveGroupChanged REVISION 1)
 
     // Toolkit Actions API
-    Q_PROPERTY(QUrl iconSource MEMBER m_iconSource WRITE setIconSource NOTIFY iconSourceChanged)
-    Q_PROPERTY(bool visible MEMBER m_visible NOTIFY visibleChanged)
+    Q_PROPERTY(QUrl iconSource READ iconSource WRITE setIconSource NOTIFY iconSourceChanged)
+    Q_PROPERTY(bool visible READ visible WRITE setVisible NOTIFY visibleChanged)
     Q_PROPERTY(QQmlComponent *itemHint MEMBER m_itemHint WRITE setItemHint)
 
     // QtQuickControls.Action
-    Q_PROPERTY(QVariant shortcut MEMBER m_shortcut WRITE setShortcut RESET resetShortcut NOTIFY shortcutChanged REVISION 1)
+    Q_PROPERTY(QVariant shortcut READ shortcut WRITE setShortcut RESET resetShortcut NOTIFY shortcutChanged REVISION 1)
 public:
     enum Type {
         None,
@@ -112,11 +112,19 @@
     QString text();
     void setText(const QString &text);
     void resetText();
+    QString iconName() const { return m_iconName; }
     void setIconName(const QString &name);
+    QUrl iconSource() const { return m_iconSource; }
     void setIconSource(const QUrl &url);
     void setItemHint(QQmlComponent *);
+    QVariant shortcut() const { return m_shortcut; }
     void setShortcut(const QVariant&);
     void resetShortcut();
+    bool visible() const { return m_visible; }
+    void setVisible(bool visible);
+    void setEnabled(bool enabled);
+    void setParameterType(Type type);
+    Type parameterType() const { return m_parameterType; }
     void setCheckable(bool checkable);
     bool isCheckable() const { return m_checkable; }
     void setChecked(bool checked);

=== added file 'tests/unit/components/tst_menu.qml'
--- tests/unit/components/tst_menu.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/components/tst_menu.qml	2016-08-22 16:02:17 +0000
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.Components 1.3
+
+TestCase {
+    name: "MenuAPI"
+
+    TestUtil {
+        id: util
+    }
+
+    function test_menubar() {
+        compare(menuBar.menus.length, 2, "Incorrect number of menus in menubar")
+        compare(menuBar.menus[0], submenu1, "Incorrect element found at menu bar index")
+        compare(menuBar.menus[1], submenu2, "Incorrect element found at menu bar index")
+    }
+
+    function test_menu() {
+        compare(floatingMenu.data.length, 5, "Incorrect number of menu items in menu");
+        compare(floatingMenu.data[0], actionList, "Incorrect element found at menu index");
+        compare(floatingMenu.data[1], menuGroup, "Incorrect element found at menu index");
+        compare(floatingMenu.data[2], action1, "Incorrect element found at menu index");
+        compare(floatingMenu.data[3], action2, "Incorrect element found at menu index");
+        compare(floatingMenu.data[4], menu1, "Incorrect element found at menu index");
+    }
+
+    function test_menugroup() {
+        compare(group.data.length, 4, "Incorrect number of menu items in MenuGroup");
+        compare(group.data[0], groupAction, "Action not found at correct index in MenuGroup");
+        compare(group.data[1], groupList, "ActionList not found at correct index in MenuGroup");
+        compare(group.data[2], groupMenu, "Menu not found at correct index in MenuGroup");
+        compare(group.data[3], groupGroup, "MenuGroup not found at correct index in MenuGroup");
+    }
+
+    function test_dynamic_append() {
+        dynamicMenu.appendObject(floatingAction);
+        compare(dynamicMenu.data.length, 1, "Action not added to menu");
+
+        dynamicMenu.removeObject(floatingAction);
+        compare(dynamicMenu.data.length, 0, "Action not removed from menu");
+    }
+
+    function test_dynamic_action_list_append() {
+        dynamicMenu.appendObject(floatingList);
+        compare(dynamicMenu.data.length, 1, "ActionList not added to menu");
+
+        dynamicMenu.removeObject(floatingList);
+        compare(dynamicMenu.data.length, 0, "ActionList not removed from menu");
+    }
+
+    function test_dynamic_insert() {
+        dynamicMenu.insertObject(0, floatingAction);
+        dynamicMenu.insertObject(0, floatingList);
+        compare(dynamicMenu.data.length, 2, "ActionList not removed from menu");
+
+        compare(dynamicMenu.data[0], floatingList, "Object was not inserted at correct index");
+        compare(dynamicMenu.data[1], floatingAction, "Object was not inserted at correct index");
+
+        dynamicMenu.removeObject(floatingAction);
+        dynamicMenu.removeObject(floatingList);
+        compare(dynamicMenu.data.length, 0, "Menu should be empty");
+    }
+
+    MenuBar {
+        id: menuBar
+        Menu {
+            id: submenu1
+        }
+        Menu {
+            id: submenu2
+        }
+    }
+
+    Menu {
+        id: floatingMenu
+        ActionList {
+            id: actionList
+        }
+        MenuGroup {
+            id: menuGroup
+        }
+        Action {
+            id: action1
+        }
+        Action {
+            id: action2
+        }
+        Menu {
+            id: menu1
+        }
+    }
+
+    MenuGroup {
+        id: group
+        Action {
+            id: groupAction
+        }
+        ActionList {
+            id: groupList
+        }
+        Menu {
+            id: groupMenu
+        }
+        MenuGroup {
+            id: groupGroup
+        }
+    }
+
+    Menu {
+        id: dynamicMenu
+    }
+
+    Action {
+        id: floatingAction
+    }
+
+    ActionList {
+        id: floatingList
+    }
+}