Merge lp:~nick-dedekind/unity8/desktop_menus.gmenumodel into lp:unity8

[Nick Dedekind]

Desktop Menus

Desktop Menus

[lp:~nick-dedekind/unity8/desktop_menus.gmenumodel]

2110. By Nick Dedekind on 2016-01-15

updated control

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:2109
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/90/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/90/rebuild

review: Needs Fixing (continuous-integration)

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:2110
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/91/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/91/rebuild

review: Needs Fixing (continuous-integration)

[lp:~nick-dedekind/unity8/desktop_menus.gmenumodel]

2111. By Nick Dedekind on 2016-01-15

merged with trunk

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:2111
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/92/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/92/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2110
http://jenkins.qa.ubuntu.com/job/unity8-ci/7078/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/6042/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-xenial-touch/493/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/1783/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-qmluitest-xenial-amd64/486/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/1678/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/1678/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-xenial-amd64-ci/485/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-xenial-i386-ci/484/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/6053/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-xenial-armhf/491/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7078/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2111
http://jenkins.qa.ubuntu.com/job/unity8-ci/7079/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/6043/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-xenial-touch/494/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/1784/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-qmluitest-xenial-amd64/487/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/1679/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/1679/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-xenial-amd64-ci/486/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-xenial-i386-ci/485/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/6054/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-xenial-armhf/492/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7079/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

2111. By Nick Dedekind on 2016-01-15

merged with trunk

2110. By Nick Dedekind on 2016-01-15

updated control

2109. By Nick Dedekind on 2016-01-15

desktop menus

2108. By Launchpad Translations on behalf of unity-team on 2016-01-08

Launchpad automatic translations update.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-16 13:58:39 +0000
+++ CMakeLists.txt	2016-01-15 13:11:04 +0000
@@ -57,7 +57,7 @@
 find_package(Qt5Concurrent 5.4 REQUIRED)
 find_package(Qt5Sql 5.4 REQUIRED)
 
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=12)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=13)
 
 # Standard install paths
 include(GNUInstallDirs)

=== modified file 'debian/control'
--- debian/control	2016-01-11 17:37:16 +0000
+++ debian/control	2016-01-15 13:11:04 +0000
@@ -29,7 +29,7 @@
                libqt5xmlpatterns5-dev,
                libsystemsettings-dev,
                libudev-dev,
-               libunity-api-dev (>= 7.105),
+               libunity-api-dev (>= 7.106),
                libusermetricsoutput1-dev,
 # Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop
                libx11-dev[!armhf],
@@ -102,7 +102,7 @@
          qml-module-qtquick-xmllistmodel,
          qml-module-qtsysteminfo,
          qtdeclarative5-gsettings1.0,
-         qtdeclarative5-qtmir-plugin (>= 0.4.5),
+         qtdeclarative5-qtmir-plugin (>= 0.4.7),
          qtdeclarative5-ubuntu-telephony0.1,
          qtdeclarative5-ubuntu-web-plugin,
          ubuntu-system-settings,

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2015-10-28 10:32:47 +0000
+++ plugins/Utils/CMakeLists.txt	2016-01-15 13:11:04 +0000
@@ -24,6 +24,7 @@
     easingcurve.cpp
     windowstatestorage.cpp
     timezoneFormatter.cpp
+    shortcutaction.cpp
     plugin.cpp
     )
 

=== modified file 'plugins/Utils/constants.cpp'
--- plugins/Utils/constants.cpp	2015-11-20 15:01:39 +0000
+++ plugins/Utils/constants.cpp	2016-01-15 13:11:04 +0000
@@ -24,4 +24,5 @@
     } else {
         m_indicatorValueTimeout = 5000;
     }
+    m_menuHoverOpenInterval = 250;
 }

=== modified file 'plugins/Utils/constants.h'
--- plugins/Utils/constants.h	2015-03-11 08:07:31 +0000
+++ plugins/Utils/constants.h	2016-01-15 13:11:04 +0000
@@ -30,14 +30,17 @@
 {
     Q_OBJECT
     Q_PROPERTY(int indicatorValueTimeout READ indicatorValueTimeout CONSTANT)
+    Q_PROPERTY(int menuHoverOpenInterval READ menuHoverOpenInterval CONSTANT)
 
 public:
     Constants(QObject *parent = 0);
 
     int indicatorValueTimeout() const { return m_indicatorValueTimeout; }
+    int menuHoverOpenInterval() const { return m_menuHoverOpenInterval; }
 
 private:
     int m_indicatorValueTimeout;
+    int m_menuHoverOpenInterval;
 };
 
 #endif

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2015-10-26 16:47:52 +0000
+++ plugins/Utils/plugin.cpp	2016-01-15 13:11:04 +0000
@@ -36,6 +36,7 @@
 #include "constants.h"
 #include "timezoneFormatter.h"
 #include "applicationsfiltermodel.h"
+#include "shortcutaction.h"
 
 static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
 {
@@ -68,6 +69,7 @@
                                                 [](QQmlEngine*, QJSEngine*) -> QObject* { return new TimezoneFormatter; });
     qmlRegisterType<ActiveFocusLogger>(uri, 0, 1, "ActiveFocusLogger");
     qmlRegisterType<ApplicationsFilterModel>(uri, 0, 1, "ApplicationsFilterModel");
+    qmlRegisterType<ShortcutAction>(uri, 0, 1, "ShortcutAction");
 }
 
 void UtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== added file 'plugins/Utils/shortcutaction.cpp'
--- plugins/Utils/shortcutaction.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Utils/shortcutaction.cpp	2016-01-15 13:11:04 +0000
@@ -0,0 +1,122 @@
+#include "shortcutaction.h"
+
+#include <QQuickItem>
+#include <QQuickWindow>
+#include <QVariant>
+#include <QShortcutEvent>
+#include <private/qguiapplication_p.h>
+
+namespace {
+
+bool qShortcutContextMatcher(QObject *o, Qt::ShortcutContext context)
+{
+    if (!static_cast<ShortcutAction*>(o)->isEnabled())
+        return false;
+
+    switch (context) {
+    case Qt::ApplicationShortcut:
+    case Qt::WindowShortcut:
+        break;
+    case Qt::WidgetShortcut: {
+        QQuickItem* target = static_cast<ShortcutAction*>(o)->target();
+        if (target && target->hasActiveFocus()) {
+            return true;
+        }
+        return true;
+    }
+    case Qt::WidgetWithChildrenShortcut:
+        break;
+    }
+
+    return false;
+}
+
+}
+
+
+ShortcutAction::ShortcutAction(QObject* parent)
+    : QObject(parent)
+    , m_enabled(true)
+{
+}
+
+ShortcutAction::~ShortcutAction()
+{
+    setShortcut(QString());
+}
+
+QVariant ShortcutAction::shortcut() const
+{
+    return m_shortcut.toString(QKeySequence::NativeText);
+}
+
+void ShortcutAction::setShortcut(const QVariant &arg)
+{
+    QKeySequence sequence;
+    if (arg.type() == QVariant::Int)
+        sequence = QKeySequence(static_cast<QKeySequence::StandardKey>(arg.toInt()));
+    else
+        sequence = QKeySequence::fromString(arg.toString());
+
+    if (sequence == m_shortcut)
+        return;
+
+    if (!m_shortcut.isEmpty())
+        QGuiApplicationPrivate::instance()->shortcutMap.removeShortcut(0, this, m_shortcut);
+
+    m_shortcut = sequence;
+
+    if (!m_shortcut.isEmpty()) {
+        Qt::ShortcutContext context = Qt::WidgetShortcut;
+        QGuiApplicationPrivate::instance()->shortcutMap.addShortcut(this, m_shortcut, context, qShortcutContextMatcher);
+    }
+    Q_EMIT shortcutChanged(shortcut());
+}
+
+void ShortcutAction::setEnabled(bool e)
+{
+    if (e == m_enabled) return;
+    m_enabled = e;
+
+    Q_EMIT enabledChanged();
+}
+
+void ShortcutAction::setTarget(QQuickItem *target)
+{
+    if (target == m_target) return;
+    m_target = target;
+
+    Q_EMIT targetChanged();
+}
+
+bool ShortcutAction::event(QEvent *e)
+{
+    if (!m_enabled)
+        return false;
+
+    if (e->type() != QEvent::Shortcut)
+        return false;
+
+    QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
+
+    Q_ASSERT_X(se->key() == m_shortcut,
+               "QQuickAction::event",
+               "Received shortcut event from incorrect shortcut");
+    if (se->isAmbiguous()) {
+        qWarning("QQuickAction::event: Ambiguous shortcut overload: %s", se->key().toString(QKeySequence::NativeText).toLatin1().constData());
+        return false;
+    }
+
+    trigger();
+
+    return true;
+}
+
+void ShortcutAction::trigger(QObject* source)
+{
+    if (!m_enabled)
+        return;
+
+    Q_EMIT triggered(source);
+}
+

=== added file 'plugins/Utils/shortcutaction.h'
--- plugins/Utils/shortcutaction.h	1970-01-01 00:00:00 +0000
+++ plugins/Utils/shortcutaction.h	2016-01-15 13:11:04 +0000
@@ -0,0 +1,44 @@
+#ifndef SHORTCUTACTION_H
+#define SHORTCUTACTION_H
+
+#include <QObject>
+#include <QKeySequence>
+#include <QQuickItem>
+
+class ShortcutAction : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(QVariant shortcut READ shortcut WRITE setShortcut NOTIFY shortcutChanged)
+    Q_PROPERTY(QQuickItem* target READ target WRITE setTarget NOTIFY targetChanged)
+
+public:
+    ShortcutAction(QObject* parent = nullptr);
+    ~ShortcutAction();
+
+    QVariant shortcut() const;
+    void setShortcut(const QVariant &shortcut);
+
+    bool isEnabled() const { return m_enabled; }
+    void setEnabled(bool e);
+
+    QQuickItem* target() const { return m_target; }
+    void setTarget(QQuickItem* target);
+
+    bool event(QEvent *e) override;
+
+    void trigger(QObject* source = nullptr);
+
+Q_SIGNALS:
+    void targetChanged();
+    void enabledChanged();
+    void triggered(QObject* source = nullptr);
+    void shortcutChanged(QVariant shortcut);
+
+private:
+    QKeySequence m_shortcut;
+    bool m_enabled;
+    QQuickItem* m_target;
+};
+
+#endif // SHORTCUTACTION_H

=== modified file 'plugins/Utils/windowkeysfilter.cpp'
--- plugins/Utils/windowkeysfilter.cpp	2015-10-22 17:37:26 +0000
+++ plugins/Utils/windowkeysfilter.cpp	2016-01-15 13:11:04 +0000
@@ -24,12 +24,14 @@
     : QQuickItem(parent),
       m_currentEventTimestamp(0)
 {
-    connect(this, &QQuickItem::windowChanged,
-            this, &WindowKeysFilter::setupFilterOnWindow);
+    connect(this, &QQuickItem::windowChanged, this, &WindowKeysFilter::setupFilter);
+    connect(this, &QQuickItem::enabledChanged, this, &WindowKeysFilter::setupFilter);
 }
 
 bool WindowKeysFilter::eventFilter(QObject *watched, QEvent *event)
 {
+    if (!isEnabled()) return false;
+
     Q_ASSERT(!m_filteredWindow.isNull());
     Q_ASSERT(watched == static_cast<QObject*>(m_filteredWindow.data()));
     Q_UNUSED(watched);
@@ -53,16 +55,19 @@
     }
 }
 
-void WindowKeysFilter::setupFilterOnWindow(QQuickWindow *window)
+void WindowKeysFilter::setupFilter()
 {
+    if (!m_filteredWindow.isNull() == isEnabled() && m_filteredWindow.data() == window()) return;
+
     if (!m_filteredWindow.isNull()) {
         m_filteredWindow->removeEventFilter(this);
         m_filteredWindow.clear();
     }
 
-    if (window) {
-        window->installEventFilter(this);
-        m_filteredWindow = window;
+    QQuickWindow *wnd = window();
+    if (wnd && isEnabled()) {
+        wnd->installEventFilter(this);
+        m_filteredWindow = wnd;
     }
 }
 

=== modified file 'plugins/Utils/windowkeysfilter.h'
--- plugins/Utils/windowkeysfilter.h	2015-10-22 17:37:26 +0000
+++ plugins/Utils/windowkeysfilter.h	2016-01-15 13:11:04 +0000
@@ -48,7 +48,7 @@
     void currentEventTimestampChanged();
 
 private Q_SLOTS:
-    void setupFilterOnWindow(QQuickWindow *window);
+    void setupFilter();
 
 private:
     QPointer<QQuickWindow> m_filteredWindow;

=== added directory 'qml/ApplicationMenus'
=== added file 'qml/ApplicationMenus/AppMenuUtils.js'
--- qml/ApplicationMenus/AppMenuUtils.js	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/AppMenuUtils.js	2016-01-15 13:11:04 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2015 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/>.
+ */
+
+.pragma library
+
+String.prototype.htmlLabelFromMenuLabel = function (underline) {
+    var replacements = [
+        {
+            char: "_",
+            searchExpr: /_/g,
+            doubleReplacement: "_"
+        }, {
+           char: "&",
+           searchExpr: /&(?!amp;)/g,
+           doubleReplacement: "&amp;"
+        }
+    ];
+    var text = this;
+
+    var i = 0;
+    for (; i < replacements.length; i++) {
+        text = parseShortcutChararacter(text, underline, replacements[i]);
+    }
+    return text;
+}
+
+function parseShortcutChararacter(text, underline, replacement) {
+    text = text.replace(new RegExp(replacement.char + replacement.char, "g"), replacement.doubleReplacement);
+
+    if (!underline) {
+        return text.replace(replacement.searchExpr, "");
+    }
+
+    var original = text;
+    var output = "";
+    var current = 0
+    var next = text.search(replacement.searchExpr);
+    if (next === -1) return text;
+
+    while (next !== -1) {
+        output += text.slice(current, next);
+        current = next+1;
+
+        var rest = text.slice(current);
+        text = "<u>" + rest[0] + "</u>" + rest.slice(1);
+        next = text.search(replacement.searchExpr);
+    }
+    output += text;
+    return output;
+}
+
+String.prototype.actionKeyFromMenuLabel = function () {
+    var replacements = [
+        {
+            char: "_",
+            searchExpr: /_/g,
+            doubleReplacement: "_"
+        }, {
+           char: "&",
+           searchExpr: /&(?!amp;)/g,
+           doubleReplacement: "&amp;"
+        }
+    ];
+    var text = this;
+
+    var i = 0;
+    var replaced = false;
+    for (; i < replacements.length; i++) {
+        var actionKey = parseActionKeyChararacter(text, replacements[i]);
+        if (actionKey !== "") return actionKey;
+    }
+    return "";
+}
+
+function parseActionKeyChararacter(original, replacement) {
+    var text = original.replace(new RegExp(replacement.char + replacement.char, "g"), replacement.doubleReplacement);
+
+    var output = "";
+    var iter = 0;
+    var next = text.search(replacement.searchExpr);
+    if (next === -1) return "";
+
+    while (next !== -1) {
+        var char = text.slice(next+1, next+2);
+        if (char === "") break;
+
+        if (iter > 0) output += "+";
+        output += char;
+
+        text = text.slice(next+2);
+        next = text.search(replacement.searchExpr)
+    }
+    return output;
+}

=== added file 'qml/ApplicationMenus/MenuBar.qml'
--- qml/ApplicationMenus/MenuBar.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuBar.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2015 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.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+
+MenuBase {
+    id: root
+    objectName: "menuBar"
+
+    property var focusWindow: undefined
+    property alias menuModel: rootDelegate.menuModel
+    implicitWidth: listView.width
+    readonly property bool hasChildren: repeater.count > 0
+    submenuOffset: -units.gu(1)
+
+    function close() {
+        closePopup();
+        listView.selectedItem = undefined;
+    }
+
+    FocusScope {
+        id: scope
+        anchors {
+            left: parent.left
+        }
+        width: listView.width
+        height: parent.height
+
+        Keys.onLeftPressed: listView.selectPrevious()
+        Keys.onRightPressed: listView.selectNext()
+        Keys.onEscapePressed: {
+            focus = false;
+            if (focusWindow !== undefined) {
+                focusWindow.forceActiveFocus();
+            }
+        }
+
+        onFocusChanged: {
+            if (!focus && root.openItem) {
+                root.close();
+            }
+        }
+
+        InverseMouseArea {
+            enabled: root.openItem !== undefined
+            acceptedButtons: Qt.LeftButton | Qt.MiddleButton | Qt.RightButton
+            anchors.fill: parent
+
+            onPressed: {
+                // stop the inverse mouse area stealing events from mouse areas under.
+                mouse.accepted = false;
+                root.close();
+            }
+        }
+
+        MenuItemDelegateBase {
+            id: rootDelegate
+            focusWindow: root.focusWindow
+        }
+
+        Row {
+            id: listView
+            anchors.left: parent.left
+            height: parent.height
+            spacing: units.gu(2)
+
+            property var selectedItem: undefined
+
+            function selectNext() {
+                var delegate;
+                var newIndex = 0;
+                if (listView.selectedItem === undefined && repeater.count > 0) {
+                    while (repeater.count > newIndex) {
+                        delegate = repeater.itemAt(newIndex++);
+                        if (delegate.enabled) {
+                            delegate.selected = true;
+                            break;
+                        }
+                    }
+                } else if (listView.selectedItem !== undefined && repeater.count > 1) {
+                    var startIndex = (listView.selectedItem.ownIndex + 1) % repeater.count;
+                    newIndex = startIndex;
+                    do {
+                        delegate = repeater.itemAt(newIndex);
+                        if (delegate.enabled) {
+                            delegate.selected = true;
+                            break;
+                        }
+                        newIndex = (newIndex + 1) % repeater.count;
+                    } while (newIndex !== startIndex)
+                }
+            }
+
+            function selectPrevious() {
+                var delegate;
+                var newIndex = repeater.count-1;
+                if (listView.selectedItem === undefined && repeater.count > 0) {
+                    while (repeater.count > newIndex) {
+                        delegate = repeater.itemAt(newIndex--);
+                        if (delegate.enabled) {
+                            delegate.selected = true;
+                            break;
+                        }
+                    }
+                } else if (listView.selectedItem !== undefined && repeater.count > 1) {
+                    var startIndex = listView.selectedItem.ownIndex - 1;
+                    newIndex = startIndex;
+                    do {
+                        if (newIndex < 0) newIndex = repeater.count - 1;
+                        delegate = repeater.itemAt(newIndex--);
+                        if (delegate.enabled) {
+                            delegate.selected = true;
+                            break;
+                        }
+                    } while (newIndex !== startIndex)
+                }
+            }
+
+            Repeater {
+                id: repeater
+                model: rootDelegate.submenuItems
+
+                MenuBarItem {
+                    id: repeaterItem
+                    height: listView.height
+
+                    enableMnemonic: root.enableMnemonic
+                    menuItemDelegate: model.delegate
+
+                    property int modelIndex: index
+                    property bool selected: false
+                    enabled: model.delegate.sensitive && !model.delegate.isSeparator
+
+                    Rectangle {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                            bottom: parent.bottom
+                            leftMargin: -units.gu(1)
+                            rightMargin: -units.gu(1)
+                        }
+                        height: units.dp(4)
+                        color: "#E95420"
+                        visible: root.openItem == menuItem
+                    }
+
+                    MenuItemBase {
+                        id: menuItem
+                        objectName: root.objectName + "-menu" + index
+                        property int ownIndex: index
+
+                        anchors.fill: parent
+                        delegate: model.delegate
+
+                        mnemonicAction {
+                            property string action: model.delegate.label.actionKeyFromMenuLabel()
+                            enabled: enableMnemonic && repeaterItem.enabled
+                            shortcut: action !== "" ? "Alt+" + action : ""
+
+                            onTriggered: {
+                                if (model.delegate.hasSubmenu) {
+                                    root.open(menuItem, true);
+                                }
+                                else {
+                                    model.delegate.activate();
+                                }
+                            }
+                        }
+                    }
+
+                    MouseArea {
+                        id: titleMouseArea
+                        anchors.fill: parent
+                        hoverEnabled: listView.selectedItem !== undefined
+
+                        onEntered: {
+                            if (listView.selectedItem !== undefined && !repeaterItem.selected) {
+                                repeaterItem.selected = true;
+                            }
+                        }
+                        onClicked: {
+                            if (model.delegate.hasSubmenu) {
+                                root.open(menuItem, true);
+                            }
+                            else if (root.enabled) {
+                                model.delegate.activate()
+                            }
+                        }
+                    }
+
+                    onSelectedChanged: {
+                        if (selected)  {
+                            listView.selectedItem = menuItem;
+                            if (model.delegate.hasSubmenu && root.openItem !== menuItem) {
+                                root.open(menuItem, true);
+                            }
+                        }
+                        else if (listView.selectedItem === menuItem) {
+                            listView.selectedItem = undefined;
+                            if  (root.openItem == menuItem) {
+                                root.closePopup();
+                            }
+                        }
+                    }
+
+                    Connections {
+                        target: listView
+                        onSelectedItemChanged: {
+                            if (repeaterItem.selected && (listView.selectedItem === undefined || listView.selectedItem !== menuItem)) {
+                                repeaterItem.selected = false;
+                                if (root.openItem == menuItem) {
+                                    root.closePopup();
+                                }
+                            }
+                        }
+                    }
+
+                    Connections {
+                        target: root
+                        onOpenItemChanged: {
+                            if (root.openItem == menuItem) {
+                                repeaterItem.selected = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuBarItem.qml'
--- qml/ApplicationMenus/MenuBarItem.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuBarItem.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2015 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.4
+import Ubuntu.Settings.Menus 0.1 as Menus
+import Ubuntu.Components.ListItems 1.3 as ListItems
+import Ubuntu.Components 1.3
+import QtQuick.Layouts 1.1
+
+import "AppMenuUtils.js" as AppMenuUtils
+
+Item {
+    id: root
+    property var menuItemDelegate: undefined
+    property bool enableMnemonic: false
+
+    implicitWidth: column.implicitWidth
+    implicitHeight: column.height
+
+    RowLayout {
+        id: column
+        spacing: units.gu(1)
+        anchors {
+            centerIn: parent
+        }
+
+        Icon {
+            Layout.preferredWidth: units.gu(2)
+            Layout.preferredHeight: units.gu(2)
+            Layout.alignment: Qt.AlignVCenter
+
+            visible: menuItemDelegate && menuItemDelegate.icon
+            source: menuItemDelegate && menuItemDelegate.icon || ""
+        }
+
+        Label {
+            id: _title
+            text: menuItemDelegate.label.htmlLabelFromMenuLabel(enableMnemonic) || ""
+            horizontalAlignment: Text.AlignLeft
+            color: enabled ? "white" : "#5d5d5d"
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuBase.qml'
--- qml/ApplicationMenus/MenuBase.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuBase.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2015 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.4
+import Utils 0.1
+
+Item {
+    id: root
+
+    property bool enableMnemonic: false
+    property bool opensVertically: true
+    readonly property alias openItem: d._openItem
+    property real submenuOffset: 0
+
+    function open(menuItem, focus, focusIndex) {
+        openDelayTimer.stop();
+
+        if (d._openItem !== menuItem && menuItem.delegate.hasSubmenu) {
+            d.closePopup();
+
+            var menuPageComponent = Qt.createComponent("MenuPage.qml");
+
+            if (menuPageComponent.status === Component.Ready) {
+                d._requestedOpenItem = menuItem;
+                d.popup = menuPageComponent.createObject(menuItem,
+                                                         {
+                                                             "objectName": root.objectName + "-subMenu" + menuItem.delegate.index,
+                                                             "vertical": true,
+                                                             "x": opensVertically ? submenuOffset : menuItem.width,
+                                                             "y": opensVertically ? menuItem.height : submenuOffset,
+                                                             "delegateModel": menuItem.delegate.submenuItems
+                                                         });
+            } else if (menuPageComponent.status === Component.Error) {
+                console.log(menuPageComponent.errorString());
+            }
+        }
+        if (focus && d.popup) d.popup.forceActiveFocus();
+        if (focusIndex !== undefined && d.popup) d.popup.setSelectedItem(focusIndex);
+    }
+
+    function openWithDelay(menuItem, focus, index) {
+        openDelayTimer.stop();
+        if (d._openItem === menuItem) {
+            open(menuItem, focus, index);
+        } else {
+            d._requestedOpenItem = menuItem;
+            openDelayTimer.openFocus = focus;
+            openDelayTimer.openIndex = index;
+            openDelayTimer.restart();
+        }
+    }
+
+    function closePopup(focus) {
+        openDelayTimer.stop();
+        if (openItem !== undefined) {
+            d.closePopup();
+        }
+        if (focus) {
+            forceActiveFocus();
+        }
+    }
+
+    Timer {
+        id: openDelayTimer
+
+        property var openFocus
+        property var openIndex
+
+        interval: Constants.menuHoverOpenInterval
+        onTriggered: {
+            open(d._requestedOpenItem, openDelayTimer.openFocus, openDelayTimer.openIndex);
+        }
+    }
+
+    QtObject {
+        id: d
+        property var _requestedOpenItem: undefined
+        property var _openItem: undefined
+
+        property QtObject popup: null
+        onPopupChanged: {
+            d._openItem = popup !== null ? _requestedOpenItem : undefined
+        }
+
+        signal closePopup
+    }
+
+    Connections {
+        target: d
+        onClosePopup: {
+            if (d.popup) {
+                // recusive close to preserve focusing
+                d.popup.closePopup(false);
+                d.popup.visible = false;
+                d.popup.destroy();
+                d.popup = null;
+
+                d._openItem = undefined;
+                d._requestedOpenItem = undefined;
+            }
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuItemBase.qml'
--- qml/ApplicationMenus/MenuItemBase.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuItemBase.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2015 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.4
+import QtQuick.Controls 1.3 as Controls
+
+// Item which represents visual location of a menu item
+// Also contains common convenience properties.
+Item {
+    id: root
+
+    property var delegate: undefined
+    property alias mnemonicAction: mnemonic
+
+    /* Quick action. eg "F" from "_File" in the label. Only available while bar/popup is opened */
+    Controls.Action {
+        id: mnemonic
+    }
+}

=== added file 'qml/ApplicationMenus/MenuItemDelegate.qml'
--- qml/ApplicationMenus/MenuItemDelegate.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuItemDelegate.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2015 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.4
+import QtQuick.Controls 1.3 as Controls
+import Utils 0.1 as UnityUtils
+
+MenuItemDelegateBase {
+    id: root
+    property var index: undefined
+    property var menuData: undefined
+
+    readonly property string label: menuData ? menuData.label : ""
+    readonly property string action: menuData ? menuData.action : ""
+    readonly property string icon: menuData ? menuData.icon : ""
+    readonly property var shortcut: menuData ? menuData.shortcut : undefined
+    readonly property bool sensitive: menuData ? menuData.sensitive : false
+    readonly property bool hasSubmenu: menuData ? menuData.hasSubmenu : false
+    readonly property bool isSeparator: menuData ? menuData.isSeparator : false
+    readonly property bool isCheck: menuData ? menuData.isCheck : false
+    readonly property bool isRadio: menuData ? menuData.isRadio : false
+    readonly property bool isToggled: menuData ? menuData.isToggled : false
+
+    signal activate()
+
+    UnityUtils.ShortcutAction {
+        shortcut: root.shortcut
+        target: focusWindow ? focusWindow : null
+
+        onTriggered: {
+            if (root.enabled) {
+                activate();
+            }
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuItemDelegateBase.qml'
--- qml/ApplicationMenus/MenuItemDelegateBase.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuItemDelegateBase.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2015 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.4
+import Utils 0.1
+
+Item {
+    id: root
+    property alias menuModel: subMenuRepeater.model
+    readonly property alias submenuItems: submenuDelegates
+    property var focusWindow: undefined
+
+    ListModel {
+        id: submenuDelegates
+    }
+
+    Repeater {
+        id: subMenuRepeater
+
+        onItemAdded: {
+            submenuDelegates.insert(index, { delegate: item.item });
+        }
+        onItemRemoved: {
+            for (var i = 0; i < submenuDelegates.count; i++) {
+                if (item.item === submenuDelegates.get(i).delegate) {
+                    submenuDelegates.remove(i, 1);
+                    return;
+                }
+            }
+        }
+        onCountChanged: {
+            if (count == 0) {
+                submenuDelegates.clear();
+            }
+        }
+
+        delegate: Loader {
+            id: loader
+            source: "MenuItemDelegate.qml"
+
+            property int modelIndex: index
+
+            Binding {
+                target: loader.item
+                property: "index"
+                value: loader.modelIndex
+            }
+            Binding {
+                target: loader.item
+                property: "menuModel"
+                value: model.hasSubmenu ? menuModel.submenu(loader.modelIndex) : undefined
+            }
+            Binding {
+                target: loader.item
+                property: "menuData"
+                value: model
+            }
+            Binding {
+                target: loader.item
+                property: "focusWindow"
+                value: focusWindow
+            }
+            Connections {
+                target: loader.item
+                onActivate: menuModel.activate(loader.modelIndex)
+            }
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuItemFactory.qml'
--- qml/ApplicationMenus/MenuItemFactory.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuItemFactory.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2015 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.4
+import Ubuntu.Settings.Menus 0.1 as Menus
+import Ubuntu.Components.ListItems 1.3 as ListItems
+import Ubuntu.Components 1.3
+import QtQuick.Layouts 1.1
+
+import "AppMenuUtils.js" as AppMenuUtils
+
+Loader {
+    id: root
+
+    property bool showShortcut: true
+    property var menuItemDelegate: undefined
+
+    property string text: menuItemDelegate && menuItemDelegate.label || ""
+
+    sourceComponent: {
+        if (menuItemDelegate.isSeparator) {
+            return separatorMenu;
+        }
+        if (menuItemDelegate.hasSubmenu) {
+            return subMenu;
+        }
+        if (menuItemDelegate.isCheck || menuItemDelegate.isRadio) {
+            return checkableMenu;
+        }
+        return standardMenu;
+    }
+
+    Component {
+        id: separatorMenu
+
+        Item {
+            implicitHeight: units.dp(6)
+            anchors {
+                left: parent.left
+                right: parent.right
+            }
+
+            Rectangle {
+                height: units.dp(2)
+                color: "#5D5D5D"
+                anchors {
+                    left: parent.left
+                    right: parent.right
+                    verticalCenter: parent.verticalCenter
+                }
+            }
+        }
+    }
+
+    Component {
+        id: standardMenu
+
+        Item {
+            implicitWidth: column.implicitWidth + units.gu(2)
+            implicitHeight: column.implicitHeight + units.gu(2)
+
+            RowLayout {
+                id: column
+                spacing: units.gu(0.5)
+                anchors {
+                    left: parent.left
+                    right: parent.right
+                    top: parent.top
+                    margins: units.gu(1)
+                }
+
+                Item {
+                    Layout.preferredWidth: units.gu(1.5)
+                    Layout.preferredHeight: units.gu(1.5)
+                }
+
+                Icon {
+                    Layout.preferredWidth: units.gu(2)
+                    Layout.preferredHeight: units.gu(2)
+                    Layout.alignment: Qt.AlignVCenter
+
+                    visible: menuItemDelegate && menuItemDelegate.icon || false
+                    source: menuItemDelegate && menuItemDelegate.icon || ""
+                }
+
+                RowLayout {
+                    Layout.fillWidth: true
+                    spacing: units.gu(5)
+
+                    Label {
+                        text: menuItemDelegate ? menuItemDelegate.label.htmlLabelFromMenuLabel(showShortcut) : ""
+                        Layout.fillWidth: true
+                        horizontalAlignment: Text.AlignLeft
+                        color: enabled ? "#FFFFFF" : "#888888"
+                        textFormat: Text.StyledText
+                        fontSize: "small"
+                    }
+
+                    Label {
+                        text: menuItemDelegate && menuItemDelegate.shortcut !== undefined ? menuItemDelegate.shortcut : ""
+                        Layout.alignment: Qt.AlignRight
+                        color: "#5D5D5D"
+                        fontSize: "small"
+                    }
+                }
+            }
+        }
+    }
+
+    Component {
+        id: subMenu
+
+        Item {
+            implicitWidth: column.implicitWidth + units.gu(2)
+            implicitHeight: column.implicitHeight + units.gu(2)
+
+            RowLayout {
+                id: column
+                spacing: units.gu(0.5)
+                anchors {
+                    left: parent.left
+                    right: parent.right
+                    top: parent.top
+                    margins: units.gu(1)
+                }
+
+                Item {
+                    Layout.preferredWidth: units.gu(1.5)
+                    Layout.preferredHeight: units.gu(1.5)
+                }
+
+                Icon {
+                    Layout.preferredWidth: units.gu(2)
+                    Layout.preferredHeight: units.gu(2)
+                    Layout.alignment: Qt.AlignVCenter
+
+                    visible: menuItemDelegate && menuItemDelegate.icon || false
+                    source: menuItemDelegate && menuItemDelegate.icon || ""
+                }
+
+                Label {
+                    id: _title
+                    text: menuItemDelegate && menuItemDelegate.label.htmlLabelFromMenuLabel(showShortcut) || ""
+                    Layout.fillWidth: true
+                    horizontalAlignment: Text.AlignLeft
+                    color: enabled ? "#FFFFFF" : "#5D5D5D"
+                    textFormat: Text.StyledText
+                    fontSize: "small"
+                }
+
+                Icon {
+                    id: chevron
+                    visible: menuItemDelegate.hasSubmenu
+
+                    Layout.preferredHeight: units.gu(1.5)
+                    Layout.alignment: Qt.AlignVCenter
+                    name: "chevron"
+                    color: enabled ? "#FFFFFF" : "#5D5D5D"
+                }
+            }
+        }
+    }
+
+
+    Component {
+        id: checkableMenu
+
+        Item {
+            implicitWidth: column.implicitWidth + units.gu(2)
+            implicitHeight: column.height + units.gu(2)
+
+            RowLayout {
+                id: column
+                spacing: units.gu(0.5)
+                anchors {
+                    left: parent.left
+                    right: parent.right
+                    top: parent.top
+                    margins: units.gu(1)
+                }
+
+                Item {
+                    Layout.preferredWidth: units.gu(1.5)
+                    Layout.preferredHeight: units.gu(1.5)
+                    Layout.alignment: Qt.AlignVCenter
+
+                    Icon {
+                        anchors.fill: parent
+                        visible: menuItemDelegate && menuItemDelegate.isToggled
+                        name: "tick"
+                        color: enabled ? "#FFFFFF" : "#5D5D5D"
+                    }
+                }
+
+                Icon {
+                    Layout.preferredWidth: units.gu(2)
+                    Layout.preferredHeight: units.gu(2)
+                    Layout.alignment: Qt.AlignVCenter
+
+                    visible: menuItemDelegate && menuItemDelegate.icon
+                    source: menuItemDelegate && menuItemDelegate.icon || ""
+                }
+
+                RowLayout {
+                    Layout.fillWidth: true
+                    spacing: units.gu(5)
+
+                    Label {
+                        text: menuItemDelegate ? menuItemDelegate.label.htmlLabelFromMenuLabel(showShortcut) : ""
+                        Layout.fillWidth: true
+                        horizontalAlignment: Text.AlignLeft
+                        color: enabled ? "#FFFFFF" : "#888888"
+                        textFormat: Text.StyledText
+                        fontSize: "small"
+                    }
+
+                    Label {
+                        text: menuItemDelegate && menuItemDelegate.shortcut !== undefined ? menuItemDelegate.shortcut : ""
+                        Layout.alignment: Qt.AlignRight
+                        color: "#5D5D5D"
+                        fontSize: "small"
+                    }
+                }
+            }
+        }
+    }
+}

=== added file 'qml/ApplicationMenus/MenuPage.qml'
--- qml/ApplicationMenus/MenuPage.qml	1970-01-01 00:00:00 +0000
+++ qml/ApplicationMenus/MenuPage.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,277 @@
+/*
+ * Copyright 2015 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.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+
+MenuBase {
+    id: root
+    objectName: "menuPage"
+
+    property bool vertical: false
+    property alias delegateModel: repeater.model
+
+    width: listView.width
+    height: listView.height
+    opensVertically: false
+    enableMnemonic: focus
+
+    Keys.onDownPressed: {
+        listView.selectNext();
+        event.accepted = true;
+    }
+    Keys.onUpPressed: {
+        listView.selectPrevious();
+        event.accepted = true;
+    }
+
+    Keys.onLeftPressed: {
+        if (root.openItem !== undefined) {
+            if (!focus) {
+                // If we don't have the focus, then a child must.
+                // Close the child and let our parent handle the left press
+                root.closePopup(true);
+                event.accepted = true;
+                return;
+            }
+        }
+        event.accepted = false;
+    }
+    Keys.onRightPressed: {
+        if (listView.selectedItem) {
+            if (listView.selectedItem.delegate.hasSubmenu) {
+                root.open(listView.selectedItem, true, 0);
+                event.accepted = true;
+                return;
+            }
+        }
+        event.accepted = false;
+    }
+    Keys.onReturnPressed: {
+        if (listView.selectedItem) {
+            if (listView.selectedItem.delegate.hasSubmenu) {
+                root.open(listView.selectedItem, true, 0);
+                event.accepted = true;
+                return;
+            } else {
+                listView.selectedItem.delegate.activate();
+                event.accepted = true;
+            }
+        }
+    }
+
+    function setSelectedItem(index) {
+        if (repeater.count <= index) return;
+        var item = repeater.itemAt(index);
+        item.selected = true;
+    }
+
+    BorderImage {
+        anchors {
+            fill: root
+            margins: -units.gu(1)
+        }
+        source: "../Stages/graphics/dropshadow2gu.sci"
+        opacity: 0.3
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: "#292929"
+    }
+
+    ColumnLayout {
+        id: listView
+        objectName: root.objectName+"-ListView"
+        spacing: 0
+
+        property var selectedItem: undefined
+
+        function selectNext() {
+            var delegate;
+            var newIndex = 0;
+            if (listView.selectedItem === undefined && repeater.count > 0) {
+                while (repeater.count > newIndex) {
+                    delegate = repeater.itemAt(newIndex++);
+                    if (delegate.enabled) {
+                        delegate.selected = true;
+                        break;
+                    }
+                }
+            } else if (listView.selectedItem !== undefined && repeater.count > 1) {
+                var startIndex = (listView.selectedItem.ownIndex + 1) % repeater.count;
+                newIndex = startIndex;
+                do {
+                    delegate = repeater.itemAt(newIndex);
+                    if (delegate.enabled) {
+                        delegate.selected = true;
+                        break;
+                    }
+                    newIndex = (newIndex + 1) % repeater.count;
+                } while (newIndex !== startIndex)
+            }
+        }
+
+        function selectPrevious() {
+            var delegate;
+            var newIndex = repeater.count-1;
+            if (listView.selectedItem === undefined && repeater.count > 0) {
+                while (repeater.count > newIndex) {
+                    delegate = repeater.itemAt(newIndex--);
+                    if (delegate.enabled) {
+                        delegate.selected = true;
+                        break;
+                    }
+                }
+            } else if (listView.selectedItem !== undefined && repeater.count > 1) {
+                var startIndex = listView.selectedItem.ownIndex - 1;
+                newIndex = startIndex;
+                do {
+                    if (newIndex < 0) newIndex = repeater.count - 1;
+                    delegate = repeater.itemAt(newIndex--);
+                    if (delegate.enabled) {
+                        delegate.selected = true;
+                        break;
+                    }
+                } while (newIndex !== startIndex)
+            }
+        }
+
+        Repeater {
+            id: repeater
+
+            // This fixes the ordering issues with using repeater in Layouts.
+            onCountChanged: {
+                var i = 0;
+                for (; i < repeater.count; i++) {
+                    var item = repeater.itemAt(i)
+                    item.parent = null;
+                    item.parent = listView;
+                }
+            }
+            onItemRemoved: {
+                if (item.menuItem === listView.selectedItem) {
+                    if  (root.openItem == item.menuItem) {
+                        root.closePopup(true);
+                    }
+                    listView.selectedItem = undefined;
+                }
+            }
+
+            delegate: MenuItemFactory {
+                id: repeaterItem
+                property bool selected: false
+                enabled: model.delegate.sensitive && !model.delegate.isSeparator
+
+                menuItemDelegate: model.delegate
+                showShortcut: enableMnemonic
+
+                Layout.fillWidth: true
+                Layout.preferredHeight: repeaterItem.implicitHeight
+
+                Rectangle {
+                    visible: repeaterItem.selected
+                    anchors.fill: parent
+                    gradient: UbuntuColors.orangeGradient
+                }
+
+                property alias menuItem: _menuItem
+
+                MenuItemBase {
+                    id: _menuItem
+                    objectName: root.objectName + "-menu" + index
+                    property int ownIndex: index
+
+                    anchors.fill: parent
+                    delegate: model.delegate
+
+                    mnemonicAction {
+                        property string action: model.delegate.label.actionKeyFromMenuLabel()
+                        enabled: enableMnemonic && repeaterItem.enabled
+                        shortcut: action !== "" ? action : ""
+
+                        onTriggered: {
+                            if (model.delegate.hasSubmenu) {
+                                root.open(menuItem, true, 0);
+                            }
+                            else {
+                                model.delegate.activate();
+                            }
+                        }
+                    }
+                }
+
+                MouseArea {
+                    anchors.fill: parent
+                    hoverEnabled: true
+                    z: 100
+
+                    onEntered: {
+                        repeaterItem.selected = true;
+                    }
+                    onClicked: {
+                        if (model.delegate.hasSubmenu) {
+                            root.open(menuItem, true);
+                        }
+                        else if (root.enabled) {
+                            model.delegate.activate()
+                        }
+                    }
+                }
+
+                onSelectedChanged: {
+                    if (selected)  {
+                        listView.selectedItem = menuItem;
+                        if (root.openItem !== menuItem) {
+                            root.closePopup(true);
+                            if (model.delegate.hasSubmenu) {
+                                root.openWithDelay(menuItem, false);
+                            }
+                        }
+                    }
+                    else if (listView.selectedItem === menuItem) {
+                        listView.selectedItem = undefined;
+                        if  (root.openItem == menuItem) {
+                            root.closePopup(true);
+                        }
+                    }
+                }
+
+                Connections {
+                    target: listView
+                    onSelectedItemChanged: {
+                        if (repeaterItem.selected && (listView.selectedItem === undefined || listView.selectedItem !== menuItem)) {
+                            repeaterItem.selected = false;
+                            if (root.openItem == menuItem) {
+                                root.closePopup(true);
+                            }
+                        }
+                    }
+                }
+
+                Connections {
+                    target: root
+                    onOpenItemChanged: {
+                        if (root.openItem == menuItem) {
+                            repeaterItem.selected = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

=== modified file 'qml/CMakeLists.txt'
--- qml/CMakeLists.txt	2015-03-06 04:44:11 +0000
+++ qml/CMakeLists.txt	2016-01-15 13:11:04 +0000
@@ -5,6 +5,7 @@
     )
 
 set(QML_DIRS
+    ApplicationMenus
     Components
     Dash
     graphics

=== modified file 'qml/Components/PanelState/PanelState.qml'
--- qml/Components/PanelState/PanelState.qml	2015-11-20 13:06:14 +0000
+++ qml/Components/PanelState/PanelState.qml	2016-01-15 13:11:04 +0000
@@ -21,9 +21,10 @@
     id: root
 
     property string title: ""
-    property bool buttonsVisible: false
+    property bool decorationsVisible: false
     property bool dropShadow: false
     property int panelHeight: units.gu(3)
+    property string maximizedApplication: ""
 
     signal close()
     signal minimize()

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2015-11-25 13:57:34 +0000
+++ qml/Panel/Panel.qml	2016-01-15 13:11:04 +0000
@@ -17,6 +17,9 @@
 import QtQuick 2.4
 import Ubuntu.Components 1.3
 import Unity.Application 0.1
+import Unity.Indicators 0.1
+import Utils 0.1
+import "../ApplicationMenus"
 import "../Components"
 import "../Components/PanelState"
 import ".."
@@ -101,13 +104,14 @@
         }
 
         MouseArea {
+            id: decorationMouseArea
             anchors {
                 top: parent.top
                 left: parent.left
                 right: indicators.left
             }
             height: indicators.minimizedPanelHeight
-            hoverEnabled: true
+            hoverEnabled: !indicators.shown
             onClicked: callHint.visible ? callHint.showLiveCall() : PanelState.focusMaximizedApp()
             onDoubleClicked: PanelState.maximize()
 
@@ -124,12 +128,80 @@
                     bottomMargin: units.gu(0.5)
                 }
                 height: indicators.minimizedPanelHeight - anchors.topMargin - anchors.bottomMargin
-                visible: PanelState.buttonsVisible && parent.containsMouse && !root.locked && !callHint.visible
-                active: PanelState.buttonsVisible
+                visible: d.showDecorations
+                active: PanelState.decorationsVisible
                 onClose: PanelState.close()
                 onMinimize: PanelState.minimize()
                 onMaximize: PanelState.maximize()
             }
+
+            WindowKeysFilter {
+                id: altFilter
+                property bool altPressed: false
+                property bool longAltPressed: false
+                enabled: d.enableMenus
+                Keys.onPressed: {
+                    if (event.key === Qt.Key_Alt && !event.isAutoRepeat) {
+                        altPressed = true;
+                        longAltPressed = false;
+                        menuBarShortcutTimer.start();
+                        return;
+                    }
+                    event.accepted = false;
+                }
+                Keys.onReleased: {
+                    if (event.key === Qt.Key_Alt) {
+                        menuBarShortcutTimer.stop();
+                        altPressed = false;
+                        longAltPressed = false;
+                        return;
+                    }
+                    event.accepted = false
+                }
+
+                Timer {
+                    id: menuBarShortcutTimer
+                    interval: 200
+                    repeat: false
+                    onTriggered: {
+                        altFilter.longAltPressed = true;
+                    }
+                }
+            }
+
+            Loader {
+                id: menuBarLoader
+                anchors {
+                    left: windowControlButtons.right
+                    leftMargin: units.gu(3)
+                    top: parent.top
+                }
+                height: parent.height
+                visible: d.showDecorations
+
+                sourceComponent: PanelState.maximizedApplication ? menuBarComponent : undefined
+                Component {
+                    id: menuBarComponent
+                    MenuBar {
+                        id: menuBar
+                        height: menuBarLoader.height
+                        enableMnemonic: altFilter.altPressed
+                        enabled: d.enableMenus
+                        menuModel: sharedAppModel.model
+
+                        SharedUnityMenuModel {
+                            id: sharedAppModel
+
+                            property var application: ApplicationManager.findApplication(PanelState.maximizedApplication)
+                            property var surface: application ? application.session ? application.session.lastSurface : null : null
+
+                            busName: surface ? surface.dbusMenuName : ""
+                            menuObjectPath: surface ? surface.dbusMenuObjectPath : ""
+                            actions: surface && surface.dbusMenuObjectPath ? { "unity": surface.dbusMenuObjectPath } : {}
+                        }
+                    }
+                }
+            }
         }
 
         IndicatorsMenu {
@@ -162,6 +234,9 @@
                     callHint.showLiveCall();
                 }
             }
+            onShownChanged: {
+                if (d.menuBar) d.menuBar.close();
+            }
         }
 
         Label {
@@ -174,17 +249,15 @@
                 topMargin: units.gu(0.5)
                 bottomMargin: units.gu(0.5)
             }
-            color: PanelState.buttonsVisible ? "#ffffff" : "#5d5d5d"
+            color: PanelState.decorationsVisible ? "#ffffff" : "#5d5d5d"
             height: indicators.minimizedPanelHeight - anchors.topMargin - anchors.bottomMargin
-            visible: !windowControlButtons.visible && !root.locked && !callHint.visible
+            visible: !d.showDecorations
             verticalAlignment: Text.AlignVCenter
             fontSize: "medium"
             font.weight: Font.Normal
             text: PanelState.title
         }
 
-        // TODO here would the Locally integrated menus come
-
         ActiveCallHint {
             id: __callHint
             anchors {
@@ -200,6 +273,17 @@
         id: d
         objectName: "panelPriv"
         readonly property real indicatorHeight: indicators.minimizedPanelHeight
+
+        property var menuBar: menuBarLoader.item
+
+        property bool enableMenus: PanelState.decorationsVisible && !root.locked && !callHint.visible &&
+                                   menuBar &&
+                                   menuBar.hasChildren
+
+        property bool showDecorations : PanelState.decorationsVisible && !root.locked && !callHint.visible &&
+                                        (altFilter.longAltPressed ||
+                                         (decorationMouseArea.hoverEnabled && decorationMouseArea.containsMouse) ||
+                                         (menuBar && menuBar.openItem !== undefined))
     }
 
     states: [

=== modified file 'qml/Stages/DecoratedWindow.qml'
--- qml/Stages/DecoratedWindow.qml	2015-11-23 15:09:45 +0000
+++ qml/Stages/DecoratedWindow.qml	2016-01-15 13:11:04 +0000
@@ -19,6 +19,11 @@
 import QtQuick 2.4
 import Ubuntu.Components 1.3
 import Unity.Application 0.1
+import Unity.Indicators 0.1 as Indicators
+import GlobalShortcut 1.0
+import "../Components/PanelState"
+
+import QMenuModel 0.1 as MenuModel
 
 FocusScope {
     id: root
@@ -69,22 +74,6 @@
         enabled: !fullscreen
     }
 
-    WindowDecoration {
-        id: decoration
-        target: root.parent
-        objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"
-        anchors { left: parent.left; top: parent.top; right: parent.right }
-        height: units.gu(3)
-        width: root.width
-        title: window.title
-        visible: root.decorationShown
-
-        onClose: root.close();
-        onMaximize: { root.decorationPressed(); root.maximize(); }
-        onMinimize: root.minimize();
-        onPressed: root.decorationPressed();
-    }
-
     ApplicationWindow {
         id: applicationWindow
         objectName: application ? "appWindow_" + application.appId : "appWindow_null"
@@ -95,4 +84,49 @@
         interactive: true
         focus: true
     }
+
+    MouseArea {
+        anchors { left: parent.left; top: parent.top; right: parent.right }
+        height: units.gu(3)
+
+        drag.target: root.parent
+        drag.filterChildren: true
+        drag.threshold: 0
+        drag.minimumY: PanelState.panelHeight
+        drag.onActiveChanged: {
+            Mir.cursorName = active ? "grabbing" : ""
+        }
+
+        // Parent is handling drag, this handles clicks.
+        MouseArea {
+            anchors.fill: parent
+            onPressed: root.decorationPressed()
+            onDoubleClicked: root.maximize()
+        }
+
+        WindowDecoration {
+            id: decoration
+            objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"
+            anchors.fill: parent
+            appId: application ? application.appId : ""
+            title: window.title
+            visible: root.decorationShown
+
+            onClose: root.close();
+            onMaximize: { root.decorationPressed(); root.maximize(); }
+            onMinimize: root.minimize();
+
+            menu: sharedAppModel.model
+            target: applicationWindow
+
+            Indicators.SharedUnityMenuModel {
+                id: sharedAppModel
+                property var surface: application ? application.session ? application.session.lastSurface : null : null
+
+                busName: surface ? surface.dbusMenuName : ""
+                menuObjectPath: surface ? surface.dbusMenuObjectPath : ""
+                actions: surface && surface.dbusMenuObjectPath ? { "unity": surface.dbusMenuObjectPath } : {}
+            }
+        }
+    }
 }

=== modified file 'qml/Stages/DesktopStage.qml'
--- qml/Stages/DesktopStage.qml	2016-01-08 13:29:03 +0000
+++ qml/Stages/DesktopStage.qml	2016-01-15 13:11:04 +0000
@@ -187,13 +187,20 @@
 
     Binding {
         target: PanelState
-        property: "buttonsVisible"
-        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus
+        property: "decorationsVisible"
+        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized
                && spread.state == ""
     }
 
     Binding {
         target: PanelState
+        property: "maximizedApplication"
+        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized
+               && spread.state == "" ? priv.focusedAppId : ""
+    }
+
+    Binding {
+        target: PanelState
         property: "title"
         value: {
             if (priv.focusedAppDelegate !== null && spread.state == "") {
@@ -215,7 +222,7 @@
 
     Component.onDestruction: {
         PanelState.title = "";
-        PanelState.buttonsVisible = false;
+        PanelState.decorationsVisible = false;
         PanelState.dropShadow = false;
     }
 

=== modified file 'qml/Stages/WindowDecoration.qml'
--- qml/Stages/WindowDecoration.qml	2015-11-25 13:57:34 +0000
+++ qml/Stages/WindowDecoration.qml	2016-01-15 13:11:04 +0000
@@ -15,90 +15,162 @@
  */
 
 import QtQuick 2.4
+import QtQuick.Layouts 1.1
 import Unity.Application 0.1 // For Mir singleton
 import Ubuntu.Components 1.3
+import Utils 0.1
 import "../Components"
 import "../Components/PanelState"
+import "../ApplicationMenus"
 
-MouseArea {
+Item {
     id: root
-    clip: true
 
     property Item target
+    property string appId
     property alias title: titleLabel.text
     property bool active: false
-    hoverEnabled: true
+    property var menu: undefined
 
     signal close()
     signal minimize()
     signal maximize()
 
-    onDoubleClicked: root.maximize()
-
     QtObject {
         id: priv
         property real distanceX
         property real distanceY
         property bool dragging
-    }
-
-    onPressedChanged: {
-        if (pressed) {
-            var pos = mapToItem(root.target, mouseX, mouseY);
-            priv.distanceX = pos.x;
-            priv.distanceY = pos.y;
-            priv.dragging = true;
-        } else {
-            priv.dragging = false;
-            Mir.cursorName = "";
-        }
-    }
-
-    onPositionChanged: {
-        if (priv.dragging) {
-            Mir.cursorName = "grabbing";
-            var pos = mapToItem(root.target.parent, mouseX, mouseY);
-            root.target.x = pos.x - priv.distanceX;
-            root.target.y = Math.max(pos.y - priv.distanceY, PanelState.panelHeight);
-        }
-    }
-
-    Rectangle {
-        anchors.fill: parent
-        anchors.bottomMargin: -radius
+
+        property var menuBar: menuBarLoader.item
+
+        property bool enableMenus: root.active &&
+                                   (!PanelState.decorationsVisible || PanelState.maximizedApplication !== appId) &&
+                                   menuBar &&
+                                   menuBar.hasChildren
+
+        property bool shouldShowMenus : enableMenus &&
+                                        (altFilter.longAltPressed || menuBarHover.containsMouse || menuBar.openItem !== undefined)
+    }
+
+    WindowKeysFilter {
+        id: altFilter
+        property bool altPressed: false
+        property bool longAltPressed: false
+        enabled: priv.enableMenus
+        Keys.onPressed: {
+            if (event.key === Qt.Key_Alt && !event.isAutoRepeat) {
+                altPressed = true;
+                longAltPressed = false;
+                menuBarShortcutTimer.start();
+                return;
+            }            
+            event.accepted = false;
+        }
+        Keys.onReleased: {
+            if (event.key === Qt.Key_Alt) {
+                menuBarShortcutTimer.stop();
+                altPressed = false;
+                longAltPressed = false;
+                return;
+            }            
+            event.accepted = false
+        }
+
+        Timer {
+            id: menuBarShortcutTimer
+            interval: 200
+            repeat: false
+            onTriggered: {
+                altFilter.longAltPressed = true;
+            }
+        }
+    }
+
+    // non rounded for bottom of decoration
+    Rectangle {
+        anchors.fill: parent
+        anchors.topMargin: units.gu(.5)
+        color: "#292929"
+    }
+
+    // rounded for top of decoration
+    Rectangle {
+        anchors.fill: parent
         radius: units.gu(.5)
         color: "#292929"
     }
 
-    Row {
+    RowLayout {
         anchors {
             fill: parent
             leftMargin: units.gu(1)
             rightMargin: units.gu(1)
-            topMargin: units.gu(0.5)
-            bottomMargin: units.gu(0.5)
         }
         spacing: units.gu(3)
 
         WindowControlButtons {
             id: buttons
-            height: parent.height
+            anchors {
+                top: parent.top
+                bottom: parent.bottom
+                topMargin: units.gu(0.5)
+                bottomMargin: units.gu(0.5)
+            }
             active: root.active
             onClose: root.close();
             onMinimize: root.minimize();
             onMaximize: root.maximize();
         }
 
-        Label {
-            id: titleLabel
-            objectName: "windowDecorationTitle"
-            color: root.active ? "white" : "#5d5d5d"
-            height: parent.height
-            width: parent.width - buttons.width - parent.anchors.rightMargin - parent.anchors.leftMargin
-            verticalAlignment: Text.AlignVCenter
-            fontSize: "medium"
-            font.weight: root.active ? Font.Light : Font.Normal
-            elide: Text.ElideRight
+        Item {
+            Layout.preferredHeight: parent.height
+            Layout.fillWidth: true
+
+            MouseArea {
+                id: menuBarHover
+                hoverEnabled: true
+                anchors.fill: parent
+                onPressed: { mouse.accepted = false; } // just monitoring
+            }
+
+            Label {
+                id: titleLabel
+                objectName: "windowDecorationTitle"
+                color: root.active ? "white" : "#5d5d5d"
+                height: parent.height
+                width: parent.width
+                verticalAlignment: Text.AlignVCenter
+                fontSize: "medium"
+                font.weight: root.active ? Font.Light : Font.Normal
+                elide: Text.ElideRight
+
+                opacity: priv.shouldShowMenus ? 0 : 1
+                Behavior on opacity { UbuntuNumberAnimation { } }
+            }
+
+            Loader {
+                id: menuBarLoader
+                objectName: "windowDecorationMenuBarLoader"
+                anchors.bottom: parent.bottom
+                height: parent.height
+                width: parent.width
+                sourceComponent: root.menu ? menuBarComponent : undefined
+                Component {
+                    id: menuBarComponent
+                    MenuBar {
+                        id: menuBar
+                        height: menuBarLoader.height
+                        focusWindow: root.target
+                        menuModel: root.menu
+                        enableMnemonic: altFilter.altPressed
+                        enabled: priv.enableMenus
+                    }
+                }
+
+                opacity: priv.shouldShowMenus ? 1 : 0
+                Behavior on opacity { UbuntuNumberAnimation { } }
+            }
         }
     }
 }

=== modified file 'tests/imports/check_imports.py'
--- tests/imports/check_imports.py	2015-07-15 15:13:18 +0000
+++ tests/imports/check_imports.py	2016-01-15 13:11:04 +0000
@@ -53,6 +53,7 @@
 quick_good_pat = re.compile(r'.*import QtQuick 2\.4.*$')
 quick_layouts_good_pat = re.compile(r'.*import QtQuick.Layouts 1\.1.*$')
 quick_window_good_pat = re.compile(r'.*import QtQuick.Window 2\.2.*$')
+quick_controls_good_pat = re.compile(r'.*import QtQuick.Controls 1\.4.*$')
 
 # Ubuntu Components patterns
 ubuntu_components_pat = re.compile(r'.*import Ubuntu.Components.*')
@@ -111,7 +112,7 @@
         for file in files:
             path = os.path.join(root, file)
             if not (ignore and path.startswith(ignore)) and pat.match(file):
-                quick_good_pats = [quick_good_pat, quick_layouts_good_pat, quick_window_good_pat]
+                quick_good_pats = [quick_good_pat, quick_layouts_good_pat, quick_window_good_pat, quick_controls_good_pat]
                 if scan_for_bad_import(path, quick_pat, quick_good_pats):
                     found_bad_import = True
                 if scan_for_bad_import(path, ubuntu_components_pat, [ubuntu_good_components_pat]):

=== modified file 'tests/mocks/QMenuModel/QMenuModel.qmltypes'
--- tests/mocks/QMenuModel/QMenuModel.qmltypes	2015-02-13 09:01:16 +0000
+++ tests/mocks/QMenuModel/QMenuModel.qmltypes	2016-01-15 13:11:04 +0000
@@ -1,4 +1,4 @@
-import QtQuick.tooling 1.1
+import QtQuick.tooling 1.2
 
 // This file describes the plugin-supplied types contained in the library.
 // It is used for QML tooling purposes only.
@@ -57,6 +57,10 @@
         Property { name: "actionStateParser"; type: "ActionStateParser"; isPointer: true }
         Property { name: "nameOwner"; type: "string"; isReadonly: true }
         Property { name: "modelData"; type: "QVariant" }
+        Signal {
+            name: "activated"
+            Parameter { name: "action"; type: "string" }
+        }
         Method {
             name: "insertRow"
             Parameter { name: "row"; type: "int" }

=== modified file 'tests/mocks/QMenuModel/unitymenumodel.cpp'
--- tests/mocks/QMenuModel/unitymenumodel.cpp	2014-10-07 10:28:59 +0000
+++ tests/mocks/QMenuModel/unitymenumodel.cpp	2016-01-15 13:11:04 +0000
@@ -18,6 +18,8 @@
 
 #include "unitymenumodel.h"
 
+#include <QDebug>
+
 enum MenuRoles {
     LabelRole  = Qt::DisplayRole + 1,
     SensitiveRole,
@@ -29,7 +31,9 @@
     ActionStateRole,
     IsCheckRole,
     IsRadioRole,
-    IsToggledRole
+    IsToggledRole,
+    ShortcutRole,
+    HasSubmenuRole
 };
 
 UnityMenuModel::UnityMenuModel(QObject *parent)
@@ -149,7 +153,10 @@
     if (m_modelData.count() <= row) {
         return QVariantMap();
     }
-    return m_modelData[row].toMap()["rowData"].toMap();
+    QVariantMap vRow = m_modelData[row].toMap();
+    QVariantMap map = vRow["rowData"].toMap();
+    map["hasSubmenu"] = vRow.contains("submenu");
+    return map;
 }
 
 QVariant UnityMenuModel::subMenuData(int row) const
@@ -182,6 +189,8 @@
     names[IsCheckRole] = "isCheck";
     names[IsRadioRole] = "isRadio";
     names[IsToggledRole] = "isToggled";
+    names[ShortcutRole] = "shortcut";
+    names[HasSubmenuRole] = "hasSubmenu";
 
     return names;
 }
@@ -201,6 +210,7 @@
         UnityMenuModel*& model = submenus[position];
         if (!model) {
             model = new UnityMenuModel(this);
+            connect(model, &UnityMenuModel::activated, this, &UnityMenuModel::activated);
         }
         if (model->modelData() != submenuData) {
             model->setModelData(submenuData);
@@ -228,8 +238,20 @@
     return this->data(this->index(row, 0), roles[role]);
 }
 
-void UnityMenuModel::activate(int, const QVariant&)
+void UnityMenuModel::activate(int row, const QVariant&)
 {
+    QVariantMap vModelData = m_modelData[row].toMap();
+    QVariantMap rd = vModelData["rowData"].toMap();
+
+    bool isCheckable = rd[roleNames()[IsCheckRole]].toBool() || rd[roleNames()[IsRadioRole]].toBool();
+    if (isCheckable) {
+        rd[roleNames()[IsToggledRole]] = !rd[roleNames()[IsToggledRole]].toBool();
+        vModelData["rowData"] = rd;
+        m_modelData[row] = vModelData;
+
+        dataChanged(index(row, 0), index(row, 0),  QVector<int>() << IsToggledRole);
+    }
+    Q_EMIT activated(rd[roleNames()[ActionRole]].toString());
 }
 
 void UnityMenuModel::changeState(int, const QVariant&)

=== modified file 'tests/mocks/QMenuModel/unitymenumodel.h'
--- tests/mocks/QMenuModel/unitymenumodel.h	2015-04-30 09:31:51 +0000
+++ tests/mocks/QMenuModel/unitymenumodel.h	2016-01-15 13:11:04 +0000
@@ -88,6 +88,8 @@
     // Internal mock usage
     void modelDataChanged();
 
+    void activated(const QString& action);
+
 private:
     QVariantMap rowData(int row) const;
     QVariant subMenuData(int row) const;

=== modified file 'tests/mocks/Unity/Application/MirSurface.cpp'
--- tests/mocks/Unity/Application/MirSurface.cpp	2015-11-06 15:52:24 +0000
+++ tests/mocks/Unity/Application/MirSurface.cpp	2016-01-15 13:11:04 +0000
@@ -129,6 +129,16 @@
     Q_EMIT orientationAngleChanged(angle);
 }
 
+QString MirSurface::dbusMenuName() const
+{
+    return name();
+}
+
+QString MirSurface::dbusMenuObjectPath() const
+{
+    return QString("/%1").arg(name());
+}
+
 
 
 void MirSurface::registerView(qintptr viewId)

=== modified file 'tests/mocks/Unity/Application/MirSurface.h'
--- tests/mocks/Unity/Application/MirSurface.h	2015-11-06 15:52:24 +0000
+++ tests/mocks/Unity/Application/MirSurface.h	2016-01-15 13:11:04 +0000
@@ -66,6 +66,9 @@
     Mir::OrientationAngle orientationAngle() const override;
     void setOrientationAngle(Mir::OrientationAngle) override;
 
+    QString dbusMenuName() const override;
+    QString dbusMenuObjectPath() const override;
+
     ////
     // API for tests
 

=== modified file 'tests/mocks/Utils/CMakeLists.txt'
--- tests/mocks/Utils/CMakeLists.txt	2015-10-28 10:32:47 +0000
+++ tests/mocks/Utils/CMakeLists.txt	2016-01-15 13:11:04 +0000
@@ -19,6 +19,7 @@
     ${CMAKE_SOURCE_DIR}/plugins/Utils/easingcurve.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/inputwatcher.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/applicationsfiltermodel.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/Utils/shortcutaction.cpp
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
     constants.cpp
     plugin.cpp

=== modified file 'tests/mocks/Utils/constants.cpp'
--- tests/mocks/Utils/constants.cpp	2015-04-15 14:52:01 +0000
+++ tests/mocks/Utils/constants.cpp	2016-01-15 13:11:04 +0000
@@ -20,4 +20,11 @@
    : QObject(parent)
 {
     m_indicatorValueTimeout = 5000;
+    m_menuHoverOpenInterval = 250;
+}
+
+void Constants::setMenuHoverOpenInterval(int menuHoverOpenInterval)
+{
+    m_menuHoverOpenInterval = menuHoverOpenInterval;
+    Q_EMIT menuHoverOpenIntervalChanged();
 }

=== modified file 'tests/mocks/Utils/constants.h'
--- tests/mocks/Utils/constants.h	2015-04-15 14:52:01 +0000
+++ tests/mocks/Utils/constants.h	2016-01-15 13:11:04 +0000
@@ -30,14 +30,21 @@
 {
     Q_OBJECT
     Q_PROPERTY(int indicatorValueTimeout READ indicatorValueTimeout CONSTANT)
+    Q_PROPERTY(int menuHoverOpenInterval READ menuHoverOpenInterval WRITE setMenuHoverOpenInterval NOTIFY menuHoverOpenIntervalChanged)
 
 public:
     Constants(QObject *parent = 0);
 
     int indicatorValueTimeout() const { return m_indicatorValueTimeout; }
+    int menuHoverOpenInterval() const { return m_menuHoverOpenInterval; }
+    void setMenuHoverOpenInterval(int menuHoverOpenInterval);
+
+Q_SIGNALS:
+    void menuHoverOpenIntervalChanged();
 
 private:
     int m_indicatorValueTimeout;
+    int m_menuHoverOpenInterval;
 };
 
 #endif

=== modified file 'tests/mocks/Utils/plugin.cpp'
--- tests/mocks/Utils/plugin.cpp	2015-10-28 10:32:47 +0000
+++ tests/mocks/Utils/plugin.cpp	2016-01-15 13:11:04 +0000
@@ -36,6 +36,7 @@
 #include <windowscreenshotprovider.h>
 #include <easingcurve.h>
 #include <applicationsfiltermodel.h>
+#include <shortcutaction.h>
 
 static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
 {
@@ -65,6 +66,7 @@
     qmlRegisterSingletonType<Constants>(uri, 0, 1, "Constants", createConstants);
     qmlRegisterType<ActiveFocusLogger>(uri, 0, 1, "ActiveFocusLogger");
     qmlRegisterType<ApplicationsFilterModel>(uri, 0, 1, "ApplicationsFilterModel");
+    qmlRegisterType<ShortcutAction>(uri, 0, 1, "ShortcutAction");
 }
 
 void FakeUtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== added directory 'tests/qmltests/ApplicationMenus'
=== added file 'tests/qmltests/ApplicationMenus/tst_MenuBar.qml'
--- tests/qmltests/ApplicationMenus/tst_MenuBar.qml	1970-01-01 00:00:00 +0000
+++ tests/qmltests/ApplicationMenus/tst_MenuBar.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import Ubuntu.Components 1.3
+import Ubuntu.Components.ListItems 1.3
+import Unity.Application 0.1
+import QMenuModel 0.1
+import Unity.Test 0.1
+import Utils 0.1
+
+import "../../../qml/ApplicationMenus"
+import "../Stages"
+
+Item {
+    id: root
+    width:  units.gu(100)
+    height:  units.gu(50)
+
+    Component.onCompleted: {
+        Constants.menuHoverOpenInterval = 1;
+    }
+
+    DesktopMenuData { id: desktopMenuData }
+
+    Rectangle {
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: parent.top
+            margins: units.gu(1)
+        }
+        height: units.gu(3)
+        color: "grey"
+
+        MenuBar {
+            id: menuBar
+            anchors.fill: parent
+
+            focusWindow: root
+            enableMnemonic: true
+            menuModel: UnityMenuModel {
+                id: menuBackend
+                modelData: desktopMenuData.testData
+            }
+        }
+    }
+
+    SignalSpy {
+        id: activatedSpy
+        target: menuBackend
+        signalName: "activated"
+    }
+
+    UnityTestCase {
+        id: testCase
+        name: "MenuPage"
+        when: windowShown
+
+        property bool clickNavigate: true
+
+        function init() {
+            menuBar.closePopup();
+            menuBackend.modelData = desktopMenuData.generateTestData(3, 2, 0);
+            activatedSpy.clear();
+        }
+
+        function test_mnemonics_data() {
+            return [
+                { tag: "a" },
+                { tag: "b" },
+            ]
+        }
+
+        function test_mnemonics(data) {
+            menuBackend.modelData = desktopMenuData.generateTestData(3, 2, 0);
+
+            keyPress(data.tag, Qt.AltModifier, 100);
+            tryCompareFunction(function() { return menuBar.openItem !== undefined; }, true);
+        }
+
+        function test_navigateRight(data) {
+            var menuItem0 = findChild(menuBar, "menuBar-menu0"); verify(menuItem0);
+            var menuItem1 = findChild(menuBar, "menuBar-menu1"); verify(menuItem1);
+            var menuItem2 = findChild(menuBar, "menuBar-menu2"); verify(menuItem2);
+
+            menuBar.open(menuItem0, true);
+            compare(menuBar.openItem, menuItem0);
+
+            keyClick(Qt.Key_Right, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem1);
+
+            keyClick(Qt.Key_Right, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem2);
+
+            keyClick(Qt.Key_Right, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem0);
+        }
+
+        function test_navigateLeft(data) {
+            var menuItem0 = findChild(menuBar, "menuBar-menu0"); verify(menuItem0);
+            var menuItem1 = findChild(menuBar, "menuBar-menu1"); verify(menuItem1);
+            var menuItem2 = findChild(menuBar, "menuBar-menu2"); verify(menuItem2);
+
+            menuBar.open(menuItem0, true);
+            compare(menuBar.openItem, menuItem0);
+
+            keyClick(Qt.Key_Left, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem2);
+
+            keyClick(Qt.Key_Left, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem1);
+
+            keyClick(Qt.Key_Left, Qt.NoModifier);
+            compare(menuBar.openItem, menuItem0);
+        }
+    }
+}

=== added file 'tests/qmltests/ApplicationMenus/tst_MenuPage.qml'
--- tests/qmltests/ApplicationMenus/tst_MenuPage.qml	1970-01-01 00:00:00 +0000
+++ tests/qmltests/ApplicationMenus/tst_MenuPage.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import Ubuntu.Components 1.3
+import Ubuntu.Components.ListItems 1.3
+import Unity.Application 0.1
+import QMenuModel 0.1
+import Unity.Test 0.1
+import Utils 0.1
+
+import "../../../qml/ApplicationMenus"
+import "../Stages"
+
+Item {
+    id: root
+    width:  Math.max(units.gu(100), page.width + units.gu(6))
+    height:  Math.max(units.gu(50), page.height + units.gu(6))
+
+    Component.onCompleted: {
+        Constants.menuHoverOpenInterval = 1;
+    }
+
+    DesktopMenuData { id: desktopMenuData }
+
+    Keys.onEscapePressed: {
+        page.closePopup(true);
+    }
+
+    MenuPage {
+        id: page
+        focus: true
+
+        anchors {
+            left: parent.left
+            top: parent.top
+            leftMargin: units.gu(3)
+            topMargin: units.gu(3)
+        }
+
+        delegateModel: rootDelegate.submenuItems
+        MenuItemDelegateBase {
+            id: rootDelegate
+            menuModel: UnityMenuModel {
+                id: menuBackend
+                modelData: desktopMenuData.generateTestData(3, 3, 0);
+            }
+        }
+    }
+
+    SignalSpy {
+        id: activatedSpy
+        target: menuBackend
+        signalName: "activated"
+    }
+
+    UnityTestCase {
+        id: testCase
+        name: "MenuPage"
+        when: windowShown
+
+        property bool clickNavigate: true
+
+        function init() {
+            page.closePopup(true);
+            menuBackend.modelData = desktopMenuData.generateTestData(3, 3, 0);
+            activatedSpy.clear();
+        }
+
+        // visit and verify that all the backend menus have been created
+        function recurseMenuConstruction(rows, menuPageName) {
+            for (var i = 0; i < rows.length; ++i) {
+                var rowData = rows[i]["rowData"];
+
+                var menuPage = findChild(page, menuPageName);
+                verify(menuPage);
+                var menuItem = findChild(menuPage, menuPageName+"-menu"+i);
+                verify(menuItem);
+
+                // recurse into submenu
+                var submenu = rows[i]["submenu"];
+                if (submenu) {
+                    if (clickNavigate) {
+                        mouseClick(menuItem, menuItem.width/2, menuItem.height/2);
+                    } else {
+                        mouseMove(menuItem, menuItem.width/2, menuItem.height/2);
+                    }
+                    tryCompare(menuPage, "openItem", menuItem);
+                    recurseMenuConstruction(submenu, menuPageName+"-subMenu"+i);
+                }
+            }
+        }
+
+        function test_hoverNavigation_data() {
+            return [
+                { tag: "long", testData: desktopMenuData.generateTestData(4, 2, 0) },
+                { tag: "deep", testData: desktopMenuData.generateTestData(2, 4, 0) }
+            ]
+        }
+
+        function test_hoverNavigation(data) {
+            clickNavigate = false;
+            menuBackend.modelData = data.testData;
+
+            recurseMenuConstruction(data.testData, "menuPage");
+        }
+
+        function test_clickNavigation_data() {
+            return [
+                { tag: "long", testData: desktopMenuData.generateTestData(4, 2, 0) },
+                { tag: "deep", testData: desktopMenuData.generateTestData(2, 4, 0) }
+            ]
+        }
+
+        function test_clickNavigation(data) {
+            clickNavigate = true;
+            menuBackend.modelData = data.testData;
+
+            recurseMenuConstruction(data.testData, "menuPage");
+        }
+
+        function test_checkableMenuTogglesOnClick() {
+            menuBackend.modelData = desktopMenuData.singleCheckable;
+
+            var menuItem = findChild(page, "menuPage-menu0");
+            verify(menuItem);
+            verify(menuItem.delegate.isCheck);
+            verify(menuItem.delegate.isToggled === false);
+
+            mouseClick(menuItem, menuItem.width/2, menuItem.height/2);
+
+            compare(menuItem.delegate.isToggled, true, "Checkable menu should have toggled");
+        }
+
+        function test_keyboardNavigation_DownKeySelectsAndOpensNextMenuItemAndRotates() {
+            menuBackend.modelData = desktopMenuData.generateTestData(4, 2, 3);
+            var listView = findChild(page, "menuPage-ListView");
+            verify(listView);
+
+            var menuItem0 = findChild(page, "menuPage-menu0"); verify(menuItem0);
+            var menuItem1 = findChild(page, "menuPage-menu1"); verify(menuItem1);
+            var menuItem2 = findChild(page, "menuPage-menu2"); verify(menuItem2);
+            verify(menuItem2.delegate.isSeparator);
+            var menuItem3 = findChild(page, "menuPage-menu3"); verify(menuItem3);
+
+            keyClick(Qt.Key_Down, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem0);
+            tryCompare(page, "openItem", menuItem0);
+
+            keyClick(Qt.Key_Down, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem1);
+            tryCompare(page, "openItem", menuItem1);
+
+            // Skip separator
+
+            keyClick(Qt.Key_Down, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem3);
+            tryCompare(page, "openItem", menuItem3);
+
+            keyClick(Qt.Key_Down, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem0);
+            tryCompare(page, "openItem", menuItem0);
+        }
+
+        function test_keyboardNavigation_UpKeySelectsAndOpensPreviousMenuItemAndRotates() {
+            menuBackend.modelData = desktopMenuData.generateTestData(4, 2, 3);
+            var listView = findChild(page, "menuPage-ListView");
+            verify(listView);
+
+            var menuItem0 = findChild(page, "menuPage-menu0"); verify(menuItem0);
+            var menuItem1 = findChild(page, "menuPage-menu1"); verify(menuItem1);
+            var menuItem2 = findChild(page, "menuPage-menu2"); verify(menuItem2);
+            verify(menuItem2.delegate.isSeparator);
+            var menuItem3 = findChild(page, "menuPage-menu3"); verify(menuItem3);
+
+            keyClick(Qt.Key_Up, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem3);
+            tryCompare(page, "openItem", menuItem3);
+
+            // Skip separator
+
+            keyClick(Qt.Key_Up, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem1);
+            tryCompare(page, "openItem", menuItem1);
+
+            keyClick(Qt.Key_Up, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem0);
+            tryCompare(page, "openItem", menuItem0);
+
+            keyClick(Qt.Key_Up, Qt.NoModifier, 100);
+            compare(listView.selectedItem, menuItem3);
+            tryCompare(page, "openItem", menuItem3);
+        }
+
+        function test_keyboardNavigation_RightKeyEntersSubMenu() {
+            menuBackend.modelData = desktopMenuData.generateTestData(2, 2, 0);
+
+            var menuItem = findChild(page, "menuPage-menu0");
+            verify(menuItem);
+            page.open(menuItem, true);
+            compare(page.openItem, menuItem);
+
+            var submenu = findChild(page, "menuPage-subMenu0");
+            verify(submenu);
+            var listView = findChild(page, "menuPage-subMenu0-ListView");
+            verify(listView);
+            menuItem = findChild(page, "menuPage-subMenu0-menu0");
+            verify(menuItem);
+
+            keyClick(Qt.Key_Right, Qt.NoModifier);
+            compare(listView.selectedItem, menuItem);
+        }
+
+        function test_keyboardNavigation_LeftKeyClosesSubMenu() {
+            menuBackend.modelData = desktopMenuData.generateTestData(2, 2, 0);
+
+            var menuItem = findChild(page, "menuPage-menu0");
+            verify(menuItem);
+            page.open(menuItem, true, 0); // quick open & select item 0
+
+            compare(page.openItem, menuItem);
+            keyClick(Qt.Key_Left, Qt.NoModifier);
+            compare(page.openItem, undefined);
+        }
+
+        function test_mnemonics() {
+            var menuItem0 = findChild(page, "menuPage-menu0"); verify(menuItem0);
+
+            keyClick(Qt.Key_A, Qt.NoModifier);
+            tryCompare(page, "openItem", menuItem0);
+
+            var submenu0 = findChild(menuItem0, "menuPage-subMenu0"); verify(submenu0);
+            var submenu0_menuItem1 = findChild(submenu0, "menuPage-subMenu0-menu1"); verify(submenu0_menuItem1);
+
+            keyClick(Qt.Key_B, Qt.NoModifier);
+            tryCompare(submenu0, "openItem", submenu0_menuItem1);
+
+            keyClick(Qt.Key_B, Qt.NoModifier);
+            compare(activatedSpy.signalArguments, [{ "0": "menuA.B.B" }], "Activate should have been emmited once");
+        }
+    }
+}

=== modified file 'tests/qmltests/CMakeLists.txt'
--- tests/qmltests/CMakeLists.txt	2016-01-11 17:37:50 +0000
+++ tests/qmltests/CMakeLists.txt	2016-01-15 13:11:04 +0000
@@ -5,6 +5,8 @@
 add_unity8_qmltest(. DisabledScreenNotice)
 add_unity8_qmltest(. Shell LIGHTDM)
 add_unity8_qmltest(. ShellWithPin LIGHTDM)
+add_unity8_qmltest(ApplicationMenus MenuBar)
+add_unity8_qmltest(ApplicationMenus MenuPage)
 add_unity8_qmltest(Components Background)
 add_unity8_qmltest(Components Carousel)
 add_unity8_qmltest(Components Dialogs LIGHTDM)
@@ -85,6 +87,7 @@
 add_unity8_qmltest(Stages SessionContainer)
 add_unity8_qmltest(Stages TabletStage)
 add_unity8_qmltest(Stages WindowResizeArea)
+add_unity8_qmltest(Stages WindowDecoration)
 add_unity8_qmltest(Stages Splash)
 add_unity8_qmltest(Tutorial Tutorial LIGHTDM)
 add_unity8_qmltest(Wizard Wizard ENVIRONMENT "OXIDE_NO_SANDBOX=1")

=== modified file 'tests/qmltests/Panel/tst_Panel.qml'
--- tests/qmltests/Panel/tst_Panel.qml	2015-11-18 15:12:56 +0000
+++ tests/qmltests/Panel/tst_Panel.qml	2016-01-15 13:11:04 +0000
@@ -24,10 +24,11 @@
 import Ubuntu.Telephony 0.1 as Telephony
 import "../../../qml/Panel"
 import "../../../qml/Components/PanelState"
+import "../Stages"
 
 IndicatorTest {
     id: root
-    width: units.gu(100)
+    width: units.gu(120)
     height: units.gu(71)
     color: "white"
 
@@ -37,6 +38,17 @@
         value: !windowControlsCB.checked
     }
 
+    DesktopMenuData { id: appMenuData }
+
+    Component.onCompleted: {
+        Indicators.UnityMenuModelCache.setCachedModelData("/dialer-app", appMenuData.dialerData);
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: "darkgrey"
+    }
+
     RowLayout {
         anchors.fill: parent
         anchors.margins: units.gu(1)
@@ -105,10 +117,11 @@
                 Layout.fillWidth: true
                 CheckBox {
                     id: windowControlsCB
-                    onClicked: PanelState.buttonsVisible = checked
+                    onClicked: PanelState.decorationsVisible = checked
                 }
                 Label {
-                    text: "Show window controls"
+                    text: "Show window decorations"
+                    color: "white"
                 }
             }
 
@@ -124,6 +137,7 @@
                 }
                 Label {
                     text: "Show fake window title"
+                    color: "white"
                 }
             }
 
@@ -133,6 +147,19 @@
                 color: "black"
             }
 
+            ApplicationCheckBox {
+                id: applicationCheckBox
+                Layout.fillWidth: true
+                appId: "dialer-app"
+                onTriggered: PanelState.maximizedApplication = checked ? "dialer-app" : "";
+            }
+
+            Rectangle {
+                Layout.preferredHeight: units.dp(1);
+                Layout.fillWidth: true;
+                color: "black"
+            }
+
             Repeater {
                 model: root.originalModelData
                 RowLayout {
@@ -143,6 +170,7 @@
                     Label {
                         Layout.fillWidth: true
                         text: modelData["identifier"]
+                        color: "white"
                     }
 
                     CheckBox {
@@ -151,6 +179,7 @@
                     }
                     Label {
                         text: "visible"
+                        color: "white"
                     }
                 }
             }
@@ -161,7 +190,10 @@
                 color: "black"
             }
 
-            MouseTouchEmulationCheckbox { id: mouseEmulation }
+            MouseTouchEmulationCheckbox {
+                id: mouseEmulation
+                color: "white"
+            }
         }
     }
 
@@ -492,5 +524,25 @@
             compare(panel.indicators.shown, false);
             tryCompare(panel.indicators, "fullyClosed", true);
         }
+
+        function test_showsDecorations() {
+            compare(panel.indicators.shown, false);
+            verify(panel.indicators.fullyClosed);
+
+            mouseClick(panel.indicators,
+                    panel.indicators.width / 2,
+                    panel.indicators.minimizedPanelHeight / 2);
+
+            compare(panel.indicators.shown, true);
+            tryCompare(panel.indicators, "fullyOpened", true);
+
+            var handle = findChild(panel.indicators, "handle");
+            verify(handle);
+
+            mouseClick(handle);
+
+            compare(panel.indicators.shown, false);
+            tryCompare(panel.indicators, "fullyClosed", true);
+        }
     }
 }

=== modified file 'tests/qmltests/Stages/ApplicationCheckBox.qml'
--- tests/qmltests/Stages/ApplicationCheckBox.qml	2015-08-11 11:41:08 +0000
+++ tests/qmltests/Stages/ApplicationCheckBox.qml	2016-01-15 13:11:04 +0000
@@ -24,6 +24,8 @@
     property string appId
     property bool checked: false
 
+    signal triggered
+
     enabled: appId !== "unity8-dash"
 
     onCheckedChanged: {
@@ -35,6 +37,7 @@
         } else {
             ApplicationManager.stopApplication(root.appId);
         }
+        root.triggered();
         d.bindGuard = false;
     }
 
@@ -69,6 +72,7 @@
             } else {
                 ApplicationManager.stopApplication(root.appId);
             }
+            root.triggered();
             d.bindGuard = false;
         }
         onCheckedChanged: {

=== added file 'tests/qmltests/Stages/DesktopMenuData.qml'
--- tests/qmltests/Stages/DesktopMenuData.qml	1970-01-01 00:00:00 +0000
+++ tests/qmltests/Stages/DesktopMenuData.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,702 @@
+import QtQuick 2.4
+
+QtObject {
+
+    property var dialerData: [{
+        "rowData": {                // 1.1
+            "label": "_dialer1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "dialer1",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": "Alt+F"
+        },
+        "submenu": [{
+            "rowData": {                // 1.1
+                "label": "menu1.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu1.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": "Alt+0"
+            }}, {
+           "rowData": {                // 1.2
+               "label": "menu1.2",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.2",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": "Alt+1"
+           },
+           "submenu": [{
+                "rowData": {                // 1.2.1
+                    "label": "menu1.2.1",
+                    "sensitive": true,
+                    "isSeparator": false,
+                    "icon": "",
+                    "type": "com.canonical.indicator.test",
+                    "ext": {},
+                    "action": "menu1.2.1",
+                    "actionState": {},
+                    "isCheck": false,
+                    "isRadio": false,
+                    "isToggled": false,
+                    "shortcut": ""
+                }}, {
+               "rowData": {                // 1.2.2
+                   "label": "menu1.2.2",
+                   "sensitive": true,
+                   "isSeparator": false,
+                   "icon": "",
+                   "type": "com.canonical.indicator.test",
+                   "ext": {},
+                   "action": "menu1.2.2",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": false,
+                   "shortcut": ""
+               }}, {
+               "rowData": {                // 1.2.3
+                   "label": "",
+                   "sensitive": false,
+                   "isSeparator": true,
+                   "icon": "",
+                   "type": "",
+                   "ext": {},
+                   "action": "",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": false,
+                   "shortcut": ""
+               }}, {
+               "rowData": {                // row 1.2.4
+                   "label": "menu1.2.4",
+                   "sensitive": true,
+                   "isSeparator": false,
+                   "icon": "",
+                   "type": "com.canonical.indicator.test",
+                   "ext": {},
+                   "action": "menu1.2.4",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": true,
+                   "shortcut": ""
+               }}
+            ]}, {
+           "rowData": {                // 1.3
+               "label": "",
+               "sensitive": false,
+               "isSeparator": true,
+               "icon": "",
+               "type": "",
+               "ext": {},
+               "action": "",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}, {
+           "rowData": {                // row 1.4
+               "label": "menu1.4",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.4",
+               "actionState": {},
+               "isCheck": true,
+               "isRadio": false,
+               "isToggled": true,
+               "shortcut": "Alt+2"
+           }}
+        ]}, {
+       "rowData": {                // 2
+           "label": "d_ialer2",
+           "sensitive": true,
+           "isSeparator": false,
+           "icon": "",
+           "type": "com.canonical.indicator.test",
+           "ext": {},
+           "action": "dialer2",
+           "actionState": {},
+           "isCheck": false,
+           "isRadio": false,
+           "isToggled": false,
+           "shortcut": "Alt+E"
+        },
+        "submenu": [{
+            "rowData": {                // 2.1
+                "label": "menu2.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu2.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}
+        ]}, {
+        "rowData": {                // row 3
+            "label": "di_aler3",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "dialer3",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": ""
+        },
+        "submenu": [{
+            "rowData": {                // 3.1
+                "label": "menu3.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu3.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}
+        ]}
+    ]
+
+    property var cameraData: [{
+        "rowData": {                // 1.1
+            "label": "camera1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "camera1",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": ""
+        },
+        "submenu": [{
+            "rowData": {                // 1.1
+                "label": "menu1.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu1.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}, {
+           "rowData": {                // 1.2
+               "label": "menu1.2",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.2",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}, {
+           "rowData": {                // row 1.2
+               "label": "menu1.2",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.2",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}
+        ]}, {
+       "rowData": {                // 2
+           "label": "camera2",
+           "sensitive": true,
+           "isSeparator": false,
+           "icon": "",
+           "type": "com.canonical.indicator.test",
+           "ext": {},
+           "action": "camera2",
+           "actionState": {},
+           "isCheck": false,
+           "isRadio": false,
+           "isToggled": false,
+           "shortcut": ""
+       }}
+    ]
+
+    property var galleryData: [{
+        "rowData": {                // 1.1
+            "label": "gallery1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "gallery1",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": ""
+        },
+        "submenu": [{
+            "rowData": {                // 1.1
+                "label": "menu0",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu0",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}, {
+           "rowData": {                // 1.2
+               "label": "menu1",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}, {
+           "rowData": {                // 1.2
+               "label": "",
+               "sensitive": false,
+               "isSeparator": true,
+               "icon": "",
+               "type": "",
+               "ext": {},
+               "action": "",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}, {
+           "rowData": {                // row 1.2
+               "label": "menu2",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu2",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}
+        ]}, {
+       "rowData": {                // 2
+           "label": "gallery2",
+           "sensitive": true,
+           "isSeparator": false,
+           "icon": "",
+           "type": "com.canonical.indicator.test",
+           "ext": {},
+           "action": "gallery2",
+           "actionState": {},
+           "isCheck": false,
+           "isRadio": false,
+           "isToggled": false,
+           "shortcut": ""
+       }}, {
+       "rowData": {                // row 2
+           "label": "gallery3",
+           "sensitive": true,
+           "isSeparator": false,
+           "icon": "",
+           "type": "com.canonical.indicator.test",
+           "ext": {},
+           "action": "gallery3",
+           "actionState": {},
+           "isCheck": false,
+           "isRadio": false,
+           "isToggled": false,
+           "shortcut": ""
+       }}
+    ]
+
+    property var testData: [{
+        "rowData": {                // 1
+            "label": "_menu1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "menu1",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": "Alt+F"
+        },
+        "submenu": [{
+            "rowData": {                // 1.1
+                "label": "menu1.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu1.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": "Alt+0"
+            }}, {
+           "rowData": {                // 1.2
+               "label": "m_enu1.2",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.2",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": "Alt+1"
+           },
+           "submenu": [{
+                "rowData": {                // 1.2.1
+                    "label": "menu1.2.1",
+                    "sensitive": true,
+                    "isSeparator": false,
+                    "icon": "",
+                    "type": "com.canonical.indicator.test",
+                    "ext": {},
+                    "action": "menu1.2.1",
+                    "actionState": {},
+                    "isCheck": false,
+                    "isRadio": false,
+                    "isToggled": false,
+                    "shortcut": ""
+                }}, {
+               "rowData": {                // 1.2.2
+                   "label": "men_u1.2.2",
+                   "sensitive": true,
+                   "isSeparator": false,
+                   "icon": "",
+                   "type": "com.canonical.indicator.test",
+                   "ext": {},
+                   "action": "menu1.2.2",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": false,
+                   "shortcut": ""
+               }}, {
+               "rowData": {                // 1.2.3
+                   "label": "",
+                   "sensitive": false,
+                   "isSeparator": true,
+                   "icon": "",
+                   "type": "",
+                   "ext": {},
+                   "action": "",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": false,
+                   "shortcut": ""
+               }}, {
+               "rowData": {                // row 1.2.4
+                   "label": "menu1.2.4",
+                   "sensitive": true,
+                   "isSeparator": false,
+                   "icon": "",
+                   "type": "com.canonical.indicator.test",
+                   "ext": {},
+                   "action": "menu1.2.4",
+                   "actionState": {},
+                   "isCheck": false,
+                   "isRadio": false,
+                   "isToggled": true,
+                   "shortcut": ""
+               }}
+            ]}, {
+           "rowData": {                // 1.3
+               "label": "",
+               "sensitive": false,
+               "isSeparator": true,
+               "icon": "",
+               "type": "",
+               "ext": {},
+               "action": "",
+               "actionState": {},
+               "isCheck": false,
+               "isRadio": false,
+               "isToggled": false,
+               "shortcut": ""
+           }}, {
+           "rowData": {                // row 1.4
+               "label": "menu1.4",
+               "sensitive": true,
+               "isSeparator": false,
+               "icon": "",
+               "type": "com.canonical.indicator.test",
+               "ext": {},
+               "action": "menu1.4",
+               "actionState": {},
+               "isCheck": true,
+               "isRadio": false,
+               "isToggled": true,
+               "shortcut": "Alt+2"
+           }}
+        ]}, {
+       "rowData": {                // 2
+           "label": "menu2",
+           "sensitive": true,
+           "isSeparator": false,
+           "icon": "",
+           "type": "com.canonical.indicator.test",
+           "ext": {},
+           "action": "menu2",
+           "actionState": {},
+           "isCheck": false,
+           "isRadio": false,
+           "isToggled": false,
+           "shortcut": "Alt+E"
+        },
+        "submenu": [{
+            "rowData": {                // 2.1
+                "label": "menu2.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu2.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}
+        ]}, {
+        "rowData": {                // row 3
+            "label": "me_nu3",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "dialer3",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": ""
+        },
+        "submenu": [{
+            "rowData": {                // 3.1
+                "label": "menu3.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu3.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            }}
+        ]}
+    ]
+
+    property var deepTestData: [{
+        "rowData": {                // 1
+            "label": "_menu1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "menu1",
+            "actionState": {},
+            "isCheck": false,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": "Alt+F"
+        },
+        "submenu": [{
+            "rowData": {                // 1.1
+                "label": "menu1.1",
+                "sensitive": true,
+                "isSeparator": false,
+                "icon": "",
+                "type": "com.canonical.indicator.test",
+                "ext": {},
+                "action": "menu1.1",
+                "actionState": {},
+                "isCheck": false,
+                "isRadio": false,
+                "isToggled": false,
+                "shortcut": ""
+            },
+            "submenu": [{
+                "rowData": {                // 1.1.1
+                    "label": "menu1.1.1",
+                    "sensitive": true,
+                    "isSeparator": false,
+                    "icon": "",
+                    "type": "com.canonical.indicator.test",
+                    "ext": {},
+                    "action": "menu1.1.1",
+                    "actionState": {},
+                    "isCheck": false,
+                    "isRadio": false,
+                    "isToggled": false,
+                    "shortcut": ""
+                },
+                "submenu": [{
+                    "rowData": {                // 1.1.1
+                        "label": "menu1.1.1.1",
+                        "sensitive": true,
+                        "isSeparator": false,
+                        "icon": "",
+                        "type": "com.canonical.indicator.test",
+                        "ext": {},
+                        "action": "menu1.1.1.1",
+                        "actionState": {},
+                        "isCheck": false,
+                        "isRadio": false,
+                        "isToggled": false,
+                        "shortcut": ""
+                    },
+                    "submenu": [{
+                        "rowData": {                // 1.1.1.1
+                            "label": "menu1.1.1.1.1",
+                            "sensitive": true,
+                            "isSeparator": false,
+                            "icon": "",
+                            "type": "com.canonical.indicator.test",
+                            "ext": {},
+                            "action": "menu1.1.1.1.1",
+                            "actionState": {},
+                            "isCheck": false,
+                            "isRadio": false,
+                            "isToggled": false,
+                            "shortcut": ""
+                        }}
+                    ]}
+                ]}
+            ]}
+        ]}
+    ]
+
+    property var singleCheckable: [{
+        "rowData": {                // 1
+            "label": "checkable1",
+            "sensitive": true,
+            "isSeparator": false,
+            "icon": "",
+            "type": "com.canonical.indicator.test",
+            "ext": {},
+            "action": "checkable1",
+            "actionState": {},
+            "isCheck": true,
+            "isRadio": false,
+            "isToggled": false,
+            "shortcut": "Alt+F"
+        }
+    }]
+
+    function generateTestData(length, depth, separatorInterval, prefix) {
+        var data = [];
+
+        if (prefix === undefined) prefix = "menu"
+
+        for (var i = 0; i < length; i++) {
+
+            var menuCode = String.fromCharCode(i+65);
+
+            var isSeparator = separatorInterval > 0 && ((i+1) % separatorInterval == 0);
+            var row = {
+                "rowData": {                // 1
+                    "label": prefix + "&" + menuCode,
+                    "sensitive": true,
+                    "isSeparator": isSeparator,
+                    "icon": "",
+                    "type": "com.canonical.indicator.test",
+                    "ext": {},
+                    "action": prefix + menuCode,
+                    "actionState": {},
+                    "isCheck": false,
+                    "isRadio": false,
+                    "isToggled": false,
+                    "shortcut": ""
+                }
+            }
+            if (!isSeparator && depth > 1) {
+                var submenu = generateTestData(length, depth-1, separatorInterval, prefix + menuCode + ".");
+                row["submenu"] = submenu;
+            }
+            data[i] = row;
+        }
+        return data;
+    }
+}
+

=== modified file 'tests/qmltests/Stages/tst_DesktopStage.qml'
--- tests/qmltests/Stages/tst_DesktopStage.qml	2016-01-07 14:00:21 +0000
+++ tests/qmltests/Stages/tst_DesktopStage.qml	2016-01-15 13:11:04 +0000
@@ -19,8 +19,10 @@
 import Ubuntu.Components 1.3
 import Ubuntu.Components.ListItems 1.3
 import Unity.Application 0.1
+import Unity.Indicators 0.1 as Indicators
 import Unity.Test 0.1
 import Utils 0.1
+import QMenuModel 0.1
 
 import ".." // For EdgeBarrierControls
 import "../../../qml/Stages"
@@ -40,7 +42,17 @@
         value: false
     }
 
-    Component.onCompleted: resetGeometry()
+    DesktopMenuData {
+        id: appMenuData
+    }
+
+    Component.onCompleted: {
+        resetGeometry();
+
+        Indicators.UnityMenuModelCache.setCachedModelData("/dialer-app", appMenuData.dialerData);
+        Indicators.UnityMenuModelCache.setCachedModelData("/camera-app", appMenuData.cameraData);
+        Indicators.UnityMenuModelCache.setCachedModelData("/gallery-app", appMenuData.galleryData);
+    }
 
     function resetGeometry() {
         // ensures apps which are tested decorations are in view.

=== added file 'tests/qmltests/Stages/tst_WindowDecoration.qml'
--- tests/qmltests/Stages/tst_WindowDecoration.qml	1970-01-01 00:00:00 +0000
+++ tests/qmltests/Stages/tst_WindowDecoration.qml	2016-01-15 13:11:04 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+import Ubuntu.Components.ListItems 1.3
+import Unity.Application 0.1
+import Unity.Test 0.1
+import Utils 0.1
+import QMenuModel 0.1
+
+import "../../../qml/Stages"
+
+Item {
+    id: root
+    width:  units.gu(70)
+    height:  units.gu(50)
+
+    Binding {
+        target: MouseTouchAdaptor
+        property: "enabled"
+        value: false
+    }
+
+    DesktopMenuData { id: desktopMenuData }
+
+    Rectangle {
+        anchors {
+            left: parent.left
+            right: parent.right
+            bottom: parent.bottom
+            margins: units.gu(1)
+        }
+        height: units.gu(20)
+        border.width: 1
+        border.color: "black"
+
+        TextArea {
+            id: log
+            anchors.fill: parent
+            readOnly: true
+        }
+    }
+
+    WindowDecoration {
+        id: decoration
+        anchors { left: parent.left; right: parent.right; top: parent.top }
+        anchors.margins: units.gu(1)
+        title: "TestTitle - Doing something"
+        active: true
+        height: units.gu(3)
+        menu: menuBackend
+        UnityMenuModel {
+            id: menuBackend
+            modelData: desktopMenuData.testData
+            onActivated: log.text = "Activated " + action + "\n" + log.text
+        }
+
+        onClose: log.text = "Close\n" + log.text
+        onMinimize: log.text = "Minimize\n" + log.text
+        onMaximize: log.text = "Maximize\n" + log.text
+    }
+
+    SignalSpy {
+        id: signalSpy
+        target: decoration
+    }
+
+    UnityTestCase {
+        id: testCase
+        name: "MenuPage"
+        when: windowShown
+
+        function init() {
+            decoration.menu = menuBackend;
+            signalSpy.clear();
+        }
+
+        function test_windowControlButtons_data() {
+            return [ { tag: "close", controlName: "closeWindowButton", signal: "close"},
+                    { tag: "minimize", controlName: "minimizeWindowButton", signal: "minimize"},
+                    { tag: "maximize", controlName: "maximizeWindowButton", signal: "maximize"}];
+        }
+
+        function test_windowControlButtons(data) {
+            signalSpy.signalName = data.signal;
+            var controlButton = findChild(decoration, data.controlName);
+            verify(controlButton !== null);
+
+            mouseClick(controlButton, controlButton.width/2, controlButton.height/2);
+            compare(signalSpy.count, 1);
+        }
+
+        function test_titleRemainsWhenHoveringOnTitleBarWithNoMenu() {
+            decoration.menu = undefined;
+
+            var menuLoader = findChild(decoration, "windowDecorationMenuBarLoader");
+            verify(menuLoader);
+            mouseMove(menuLoader, menuLoader.width/2, menuLoader.height/2);
+            wait(200);
+
+            var titleLabel = findChild(decoration, "windowDecorationTitle");
+            verify(menuLoader);
+
+            compare(menuLoader.opacity, 0, "Menu should not show when present")
+            compare(titleLabel.opacity, 1, "Title should always show when app menu not present")
+        }
+
+        function test_menuShowsWhenHoveringOnTitleBar() {
+            var menuLoader = findChild(decoration, "windowDecorationMenuBarLoader");
+            verify(menuLoader);
+            mouseMove(menuLoader, menuLoader.width/2, menuLoader.height/2)
+
+            var titleLabel = findChild(decoration, "windowDecorationTitle");
+            verify(menuLoader);
+
+            tryCompare(menuLoader, "opacity", 1);
+            tryCompare(titleLabel, "opacity", 0);
+
+            mouseMove(menuLoader, menuLoader.width/2, menuLoader.height * 2);
+
+            tryCompare(menuLoader, "opacity", 0);
+            tryCompare(titleLabel, "opacity", 1);
+        }
+
+        function test_showMenuBarWithShortcutsOnLongAltPress() {
+            var menuLoader = findChild(decoration, "windowDecorationMenuBarLoader");
+            verify(menuLoader);
+
+            var titleLabel = findChild(decoration, "windowDecorationTitle");
+            verify(menuLoader);
+
+            var menuBar = findChild(decoration, "menuBar");
+            verify(menuBar);
+            verify(menuBar.enableMnemonic === false, "Menubar should not show shortcuts")
+
+            keyPress(Qt.Key_Alt, Qt.NoModifier);
+            tryCompare(menuLoader, "opacity", 1);
+            tryCompare(titleLabel, "opacity", 0);
+            compare(menuBar.enableMnemonic, true, "Menubar should show shortcuts when long alt pressed");
+
+            keyRelease(Qt.Key_Alt, Qt.NoModifier);
+            tryCompare(menuLoader, "opacity", 0);
+            tryCompare(titleLabel, "opacity", 1);
+            compare(menuBar.enableMnemonic, false, "Menubar should not show shortcuts after long alt pressed");
+        }
+    }
+}

=== modified file 'tests/qmltests/tst_Shell.qml'
--- tests/qmltests/tst_Shell.qml	2015-12-08 15:37:51 +0000
+++ tests/qmltests/tst_Shell.qml	2016-01-15 13:11:04 +0000
@@ -30,6 +30,7 @@
 import Powerd 0.1
 import Wizard 0.1 as Wizard
 import Utils 0.1
+import Unity.Indicators 0.1 as Indicators
 
 import "../../qml"
 import "../../qml/Components"
@@ -47,6 +48,14 @@
         LightDM.Greeter.mockMode = "single";
         LightDM.Users.mockMode = "single";
         shellLoader.active = true;
+
+        Indicators.UnityMenuModelCache.setCachedModelData("/dialer-app", appMenuData.dialerData);
+        Indicators.UnityMenuModelCache.setCachedModelData("/camera-app", appMenuData.cameraData);
+        Indicators.UnityMenuModelCache.setCachedModelData("/gallery-app", appMenuData.galleryData);
+    }
+
+    DesktopMenuData {
+        id: appMenuData
     }
 
     Item {
@@ -1752,17 +1761,17 @@
             var maximizeButton = findChild(appDelegate, "maximizeWindowButton");
 
             tryCompare(appDelegate, "state", "normal");
-            tryCompare(PanelState, "buttonsVisible", false)
+            tryCompare(PanelState, "decorationsVisible", false)
 
             mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);
             tryCompare(appDelegate, "state", "maximized");
-            tryCompare(PanelState, "buttonsVisible", true)
+            tryCompare(PanelState, "decorationsVisible", true)
 
             ApplicationManager.stopApplication(appId);
-            tryCompare(PanelState, "buttonsVisible", false)
+            tryCompare(PanelState, "decorationsVisible", false)
 
             ApplicationManager.startApplication(appId);
-            tryCompare(PanelState, "buttonsVisible", true)
+            tryCompare(PanelState, "decorationsVisible", true)
         }
 
         function test_newAppHasValidGeometry() {