Unity 8

Merge lp:~aacid/unity8/doubleClickMaximize into lp:unity8

doubleClickMaximize
Merge into trunk

Proposed by Albert Astals Cid on 2017-01-19

Status:

Superseded

Proposed branch:

lp:~aacid/unity8/doubleClickMaximize

Merge into:

lp:unity8

Prerequisite:

lp:~dandrader/unity8/simplifyWindowDecoration

Diff against target:

1463 lines (+829/-216)

16 files modified

plugins/Utils/CMakeLists.txt (+1/-0)
plugins/Utils/expressionfiltermodel.cpp (+49/-0)
plugins/Utils/expressionfiltermodel.h (+42/-0)
plugins/Utils/plugin.cpp (+2/-0)
qml/ApplicationMenus/ApplicationMenusLimits.qml (+24/-0)
qml/ApplicationMenus/MenuBar.qml (+320/-168)
qml/ApplicationMenus/MenuItem.qml (+3/-8)
qml/ApplicationMenus/MenuNavigator.qml (+23/-0)
qml/ApplicationMenus/MenuPopup.qml (+118/-27)
qml/ApplicationMenus/qmldir (+1/-0)
qml/Panel/Panel.qml (+3/-1)
tests/mocks/Utils/CMakeLists.txt (+1/-0)
tests/mocks/Utils/plugin.cpp (+2/-0)
tests/qmltests/ApplicationMenus/tst_MenuBar.qml (+49/-8)
tests/qmltests/ApplicationMenus/tst_MenuPopup.qml (+14/-0)
tests/qmltests/Stage/tst_DesktopStage.qml (+177/-4)

To merge this branch:

bzr merge lp:~aacid/unity8/doubleClickMaximize

Undecided

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot	continuous-integration		Approve on 2017-01-23
Daniel d'Andrada (community)		2017-01-19	Approve on 2017-01-23
Review via email: mp+315147@code.launchpad.net

This proposal supersedes a proposal from 2017-01-19.

This proposal has been superseded by a proposal from 2017-01-31.

Commit message

Make double click on the window decoration maximize

And fix test and add a new one

Description of the change

* Are there any related MPs required for this MP to build/function as expected?
No

* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

* If you changed the UI, has there been a design review?
N/A

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-19:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-20:

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

review: Approve (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2017-01-20:

With kate, after I double click to maximize. the cursor stays with the "closed hand" shape, as if I were dragging something.

In "make tryDesktopStage", when you double click on unity8-dash then move the mouse over the maximized tittle bar, things go crazy. Might be another symptom of the same bug. Some unresolved mouse press+release pair in some MouseArea.

Revision history for this message

Albert Astals Cid (aacid) wrote on 2017-01-23:

> In "make tryDesktopStage", when you double click on unity8-dash then move the mouse over the
> maximized tittle bar, things go crazy.

Interestingly doesn't seem to happen in tryShell

lp:~aacid/unity8/doubleClickMaximize updated on 2017-01-23

2771. By Albert Astals Cid on 2017-01-23: Dfiferent way of making double click work on window decoration

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-23:

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

review: Approve (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2017-01-23:

In test_hideMaximizeButtonWhenSizeConstrained():

"""
mouseMove(deco, deco.width - units.gu(1), deco.height/2);
"""

I think it deserves a comment on why are you clicking specifically near the right corner of the window title (ie, explain that you're evading the menu bar because double-clicking there doens't trigger maximization).

lp:~aacid/unity8/doubleClickMaximize updated on 2017-01-23

2772. By Albert Astals Cid on 2017-01-23: comment++
2773. By Albert Astals Cid on 2017-01-23: i'm tyopeing moar than usual

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2017-01-23:

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

* Did CI run pass? If not, please explain why.
Yes.

review: Approve

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-01-23:

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

review: Approve (continuous-integration)

lp:~aacid/unity8/doubleClickMaximize updated on 2017-01-31

2774. By Albert Astals Cid on 2017-01-31: Merge ~nick-dedekind/unity8/menu.overflow

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Albert Astals Cid

Mohammad Rakibul Hasan

Unity Team

 === modified file 'plugins/Utils/CMakeLists.txt'
 --- plugins/Utils/CMakeLists.txt	2016-12-21 10:20:36 +0000
 +++ plugins/Utils/CMakeLists.txt	2017-01-31 14:13:11 +0000
@@ -35,6 +35,7 @@
      globalfunctions.cpp
      URLDispatcher.cpp
      tabfocusfence.cpp
++    expressionfiltermodel.cpp
      plugin.cpp
+     )
 === added file 'plugins/Utils/expressionfiltermodel.cpp'
 --- plugins/Utils/expressionfiltermodel.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/expressionfiltermodel.cpp	2017-01-31 14:13:11 +0000
@@ -0,0 +1,49 @@
++/*
++ * Copyright (C) 2017 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/>.
++ */
++
++#include "expressionfiltermodel.h"
++
++ExpressionFilterModel::ExpressionFilterModel(QObject *parent)
++    : UnitySortFilterProxyModelQML(parent)
++{
++}
++
++QJSValue ExpressionFilterModel::matchExpression() const
++{
++    return m_matchExpression;
++}
++
++void ExpressionFilterModel::setMatchExpression(const QJSValue &value)
++{
++    m_matchExpression = value;
++    invalidateFilter();
++}
++
++bool
++ExpressionFilterModel::filterAcceptsRow(int sourceRow,
++                                           const QModelIndex &sourceParent) const
++{
++    if (m_matchExpression.isCallable()) {
++        QJSValueList args;
++        args << sourceRow;
++        QJSValue ret = m_matchExpression.call(args);
++        if (ret.isBool()) {
++            return ret.toBool();
++        }
++    }
++
++    return UnitySortFilterProxyModelQML::filterAcceptsRow(sourceRow, sourceParent);
++}
 === added file 'plugins/Utils/expressionfiltermodel.h'
 --- plugins/Utils/expressionfiltermodel.h	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/expressionfiltermodel.h	2017-01-31 14:13:11 +0000
@@ -0,0 +1,42 @@
++/*
++ * Copyright (C) 2017 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/>.
++ */
++
++#ifndef EXPRESSIONFILTERMODEL_H
++#define EXPRESSIONFILTERMODEL_H
++
++#include "unitysortfilterproxymodelqml.h"
++#include <QJSValue>
++
++class ExpressionFilterModel : public UnitySortFilterProxyModelQML
++{
++    Q_OBJECT
++    Q_PROPERTY(QJSValue matchExpression READ matchExpression WRITE setMatchExpression NOTIFY matchExpressionChanged)
++public:
++    explicit ExpressionFilterModel(QObject *parent = 0);
++
++    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
++
++    QJSValue matchExpression() const;
++    void setMatchExpression(const QJSValue& value);
++
++Q_SIGNALS:
++    void matchExpressionChanged();
++
++private:
++    mutable QJSValue m_matchExpression;
++};
++
++#endif // EXPRESSIONFILTERMODEL_H
 === modified file 'plugins/Utils/plugin.cpp'
 --- plugins/Utils/plugin.cpp	2017-01-03 12:16:00 +0000
 +++ plugins/Utils/plugin.cpp	2017-01-31 14:13:11 +0000
@@ -41,6 +41,7 @@
  #include "URLDispatcher.h"
  #include "appdrawerproxymodel.h"
  #include "tabfocusfence.h"
++#include "expressionfiltermodel.h"
  static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
+ {
@@ -86,4 +87,5 @@
      qmlRegisterType<URLDispatcher>(uri, 0, 1, "URLDispatcher");
      qmlRegisterType<AppDrawerProxyModel>(uri, 0, 1, "AppDrawerProxyModel");
      qmlRegisterType<TabFocusFenceItem>(uri, 0, 1, "TabFocusFence");
++    qmlRegisterType<ExpressionFilterModel>(uri, 0, 1, "ExpressionFilterModel");
+ }
 === added file 'qml/ApplicationMenus/ApplicationMenusLimits.qml'
 --- qml/ApplicationMenus/ApplicationMenusLimits.qml	1970-01-01 00:00:00 +0000
 +++ qml/ApplicationMenus/ApplicationMenusLimits.qml	2017-01-31 14:13:11 +0000
@@ -0,0 +1,24 @@
++/*
++ * Copyright (C) 2017 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/>.
++ */
++
++pragma Singleton
++import QtQuick 2.4
++import QtQuick.Window 2.2
++
++QtObject {
++    property real screenWidth: Screen.width
++    property real screenHeight: Screen.height
++}
 === modified file 'qml/ApplicationMenus/MenuBar.qml'
 --- qml/ApplicationMenus/MenuBar.qml	2017-01-17 09:45:22 +0000
 +++ qml/ApplicationMenus/MenuBar.qml	2017-01-31 14:13:11 +0000
@@ -24,12 +24,13 @@
      id: root
      objectName: "menuBar"
++    // set from outside
      property alias unityMenuModel: rowRepeater.model
++    property bool enableKeyFilter: false
++    property real overflowWidth: width
++    // read from outside
      readonly property bool valid: rowRepeater.count > 0
--
--    property bool enableKeyFilter: false
--
      readonly property bool showRequested: d.longAltPressed || d.currentItem != null
      implicitWidth: row.width
@@ -75,189 +76,336 @@
          acceptedButtons: Qt.LeftButton | Qt.MiddleButton | Qt.RightButton
          anchors.fill: parent
          enabled: d.currentItem != null
++        hoverEnabled: enabled && d.currentItem && d.currentItem.__popup != null
          onPressed: d.dismissAll()
+     }
--    Item {
--        id: clippingItem
--
--        height: root.height
--        width: root.width
--        clip: true
--
--        Row {
--            id: row
--            spacing: units.gu(2)
--            height: parent.height
--
--            ActionContext {
--                id: menuBarContext
--                objectName: "barContext"
--                active: !d.currentItem && enableKeyFilter
--            }
--
--            Repeater {
--                id: rowRepeater
--
--                Item {
--                    id: visualItem
--                    objectName: root.objectName + "-item" + __ownIndex
--
--                    readonly property int __ownIndex: index
--                    property Item __popup: null;
--                    property bool popupVisible: __popup && __popup.visible
--
--                    implicitWidth: column.implicitWidth
--                    implicitHeight: row.height
--                    enabled: model.sensitive
--
--                    function show() {
--                        if (!__popup) {
--                            __popup = menuComponent.createObject(root, { objectName: visualItem.objectName + "-menu" });
--                            // force the current item to be the newly popped up menu
--                        } else {
--                            __popup.show();
--                        }
--                        d.currentItem = visualItem;
--                    }
--                    function hide() {
--                        if (__popup) {
--                            __popup.hide();
--
--                            if (d.currentItem === visualItem) {
--                                d.currentItem = null;
--                            }
--                        }
--                    }
--                    function dismiss() {
--                        if (__popup) {
--                            __popup.destroy();
--                            __popup = null;
--
--                            if (d.currentItem === visualItem) {
--                                d.currentItem = null;
--                            }
--                        }
--                    }
--
--                    Connections {
--                        target: d
--                        onDismissAll: visualItem.dismiss()
--                    }
--
--                    Component {
--                        id: menuComponent
--                        MenuPopup {
--                            x: visualItem.x - units.gu(1)
--                            anchors.top: parent.bottom
--                            unityMenuModel: root.unityMenuModel.submenu(visualItem.__ownIndex)
--
--                            Component.onCompleted: reset();
--                        }
--                    }
--
--                    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: model.icon || false
--                            source: model.icon || ""
--                        }
--
--                        ActionItem {
--                            id: actionItem
--                            width: _title.width
--                            height: _title.height
--
--                            action: Action {
--                                // FIXME - SDK Action:text modifies menu text with html underline for mnemonic
--                                text: model.label.replace("_", "&").replace("<u>", "&").replace("</u>", "")
--
--                                onTriggered: {
--                                    visualItem.show();
--                                }
--                            }
--
--                            Label {
--                                id: _title
--                                text: actionItem.text
--                                horizontalAlignment: Text.AlignLeft
--                                color: enabled ? "white" : "#5d5d5d"
--                            }
--                        }
--                    }
--                } // Item ( delegate )
--            } // Repeater
--        } // Row
--
--        MouseArea {
--            anchors.fill: parent
--            hoverEnabled: d.currentItem
--
--            onEntered: {
--                if (d.currentItem) {
--                    updateCurrentItemFromPosition(Qt.point(mouseX, mouseY))
--                }
--            }
--            onPositionChanged: {
--                if (d.currentItem) {
--                    updateCurrentItemFromPosition(Qt.point(mouse.x, mouse.y))
--                }
--            }
--            onClicked: updateCurrentItemFromPosition(Qt.point(mouse.x, mouse.y))
--
--            function updateCurrentItemFromPosition(point) {
--                var pos = mapToItem(row, point.x, point.y);
--
--                if (!d.hoveredItem || !d.currentItem || !d.hoveredItem.contains(Qt.point(pos.x - d.currentItem.x, pos.y - d.currentItem.y))) {
--                    d.hoveredItem = row.childAt(pos.x, pos.y);
--                    if (!d.hoveredItem || !d.hoveredItem.enabled)
--                        return false;
--                    if (d.currentItem != d.hoveredItem) {
--                        d.currentItem = d.hoveredItem;
--                    }
--                }
--                return true;
--            }
--        }
--
--        Rectangle {
--            id: underline
--            anchors {
--                bottom: row.bottom
--            }
--            x: d.currentItem ? row.x + d.currentItem.x - units.gu(1) : 0
--            width: d.currentItem ? d.currentItem.width + units.gu(2) : 0
--            height: units.dp(4)
--            color: UbuntuColors.orange
--            visible: d.currentItem
--        }
++    Row {
++        id: row
++        spacing: units.gu(2)
++        height: parent.height
++
++        ActionContext {
++            id: menuBarContext
++            objectName: "barContext"
++            active: !d.currentItem && enableKeyFilter
++        }
++
++        Connections {
++            target: root.unityMenuModel
++            onModelReset: d.firstInvisibleIndex = undefined
++        }
++
++        Repeater {
++            id: rowRepeater
++
++            onItemAdded: d.recalcFirstInvisibleIndexAdded(index, item)
++            onCountChanged: d.recalcFirstInvisibleIndex()
++
++            Item {
++                id: visualItem
++                objectName: root.objectName + "-item" + __ownIndex
++
++                readonly property int __ownIndex: index
++                property Item __popup: null;
++                property bool popupVisible: __popup && __popup.visible
++                property bool shouldDisplay: x + width + ((__ownIndex < rowRepeater.count-1) ? units.gu(2) : 0) <
++                                                root.overflowWidth - ((__ownIndex < rowRepeater.count-1) ? overflowButton.width : 0)
++
++                implicitWidth: column.implicitWidth
++                implicitHeight: row.height
++                enabled: model.sensitive && shouldDisplay
++                opacity: shouldDisplay ? 1 : 0
++
++                function show() {
++                    if (!__popup) {
++                        __popup = menuComponent.createObject(root, { objectName: visualItem.objectName + "-menu" });
++                        __popup.childActivated.connect(dismiss);
++                        // force the current item to be the newly popped up menu
++                    } else {
++                        __popup.show();
++                    }
++                    d.currentItem = visualItem;
++                }
++                function hide() {
++                    if (__popup) {
++                        __popup.hide();
++
++                        if (d.currentItem === visualItem) {
++                            d.currentItem = null;
++                        }
++                    }
++                }
++                function dismiss() {
++                    if (__popup) {
++                        __popup.destroy();
++                        __popup = null;
++
++                        if (d.currentItem === visualItem) {
++                            d.currentItem = null;
++                        }
++                    }
++                }
++
++                onVisibleChanged: {
++                    if (!visible && __popup) dismiss();
++                }
++
++                Component.onCompleted: {
++                    shouldDisplayChanged.connect(function() {
++                        if ((!shouldDisplay && d.firstInvisibleIndex == undefined) || __ownIndex <= d.firstInvisibleIndex) {
++                            d.recalcFirstInvisibleIndex();
++                        }
++                    });
++                }
++
++                Connections {
++                    target: d
++                    onDismissAll: visualItem.dismiss()
++                }
++
++                Component {
++                    id: menuComponent
++                    MenuPopup {
++                        desiredX: visualItem.x - units.gu(1)
++                        desiredY: parent.height
++                        unityMenuModel: root.unityMenuModel.submenu(visualItem.__ownIndex)
++
++                        Component.onCompleted: reset();
++                    }
++                }
++
++                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: model.icon || false
++                        source: model.icon || ""
++                    }
++
++                    ActionItem {
++                        id: actionItem
++                        width: _title.width
++                        height: _title.height
++
++                        action: Action {
++                            enabled: visualItem.enabled
++                            // FIXME - SDK Action:text modifies menu text with html underline for mnemonic
++                            text: model.label.replace("_", "&").replace("<u>", "&").replace("</u>", "")
++
++                            onTriggered: {
++                                visualItem.show();
++                            }
++                        }
++
++                        Label {
++                            id: _title
++                            text: actionItem.text
++                            horizontalAlignment: Text.AlignLeft
++                            color: enabled ? "white" : "#5d5d5d"
++                        }
++                    }
++                }
++            } // Item ( delegate )
++        } // Repeater
++    } // Row
++
++    MouseArea {
++        anchors.fill: row
++        hoverEnabled: d.currentItem
++
++        onEntered: {
++            if (d.currentItem) {
++                updateCurrentItemFromPosition(Qt.point(mouseX, mouseY))
++            }
++        }
++        onPositionChanged: {
++            if (d.currentItem) {
++                updateCurrentItemFromPosition(Qt.point(mouse.x, mouse.y))
++            }
++        }
++        onClicked: {
++            var prevItem = d.currentItem;
++            updateCurrentItemFromPosition(Qt.point(mouse.x, mouse.y))
++            if (prevItem && d.currentItem == prevItem) {
++                prevItem.hide();
++            }
++        }
++
++        function updateCurrentItemFromPosition(point) {
++            var pos = mapToItem(row, point.x, point.y);
++
++            if (!d.hoveredItem || !d.currentItem || !d.hoveredItem.contains(Qt.point(pos.x - d.currentItem.x, pos.y - d.currentItem.y))) {
++                d.hoveredItem = row.childAt(pos.x, pos.y);
++                if (!d.hoveredItem || !d.hoveredItem.enabled)
++                    return;
++                if (d.currentItem != d.hoveredItem) {
++                    d.currentItem = d.hoveredItem;
++                }
++            }
++        }
++    }
++
++    MouseArea {
++        id: overflowButton
++        objectName: "overflow"
++
++        hoverEnabled: d.currentItem
++        onEntered: d.currentItem = this
++        onPositionChanged: d.currentItem = this
++        onClicked: d.currentItem = this
++
++        property Item __popup: null;
++        property bool popupVisible: __popup && __popup.visible
++        property Item firstInvisibleItem: d.firstInvisibleIndex !== undefined ? rowRepeater.itemAt(d.firstInvisibleIndex) : null
++
++        visible: d.firstInvisibleIndex != undefined
++        x: firstInvisibleItem ? firstInvisibleItem.x : 0
++
++        height: parent.height
++        width: units.gu(4)
++
++        onVisibleChanged: {
++            if (!visible && __popup) dismiss();
++        }
++
++        Icon {
++            id: icon
++            width: units.gu(2)
++            height: units.gu(2)
++            anchors.centerIn: parent
++            color: theme.palette.normal.overlayText
++            name: "toolkit_chevron-down_2gu"
++        }
++
++        function show() {
++            if (!__popup) {
++                __popup = overflowComponent.createObject(root, { objectName: overflowButton.objectName + "-menu" });
++                __popup.childActivated.connect(dismiss);
++                // force the current item to be the newly popped up menu
++            } else {
++                __popup.show();
++            }
++            d.currentItem = overflowButton;
++        }
++        function hide() {
++            if (__popup) {
++                __popup.hide();
++
++                if (d.currentItem === overflowButton) {
++                    d.currentItem = null;
++                }
++            }
++        }
++        function dismiss() {
++            if (__popup) {
++                __popup.destroy();
++                __popup = null;
++
++                if (d.currentItem === overflowButton) {
++                    d.currentItem = null;
++                }
++            }
++        }
++
++        Connections {
++            target: d
++            onDismissAll: overflowButton.dismiss()
++        }
++
++        Component {
++            id: overflowComponent
++            MenuPopup {
++                id: overflowPopup
++                desiredX: overflowButton.x - units.gu(1)
++                desiredY: parent.height
++                unityMenuModel: overflowModel
++
++                ExpressionFilterModel {
++                    id: overflowModel
++                    sourceModel: root.unityMenuModel
++                    matchExpression: function(index) {
++                        if (d.firstInvisibleIndex === undefined) return false;
++                        return index >= d.firstInvisibleIndex;
++                    }
++
++                    function submenu(index) {
++                        return sourceModel.submenu(mapRowToSource(index));
++                    }
++                    function activate(index) {
++                        return sourceModel.activate(mapRowToSource(index));
++                    }
++                }
++
++                Connections {
++                    target: d
++                    onFirstInvisibleIndexChanged: overflowModel.invalidate()
++                }
++            }
++        }
++    }
++
++    Rectangle {
++        id: underline
++        anchors {
++            bottom: row.bottom
++        }
++        x: d.currentItem ? row.x + d.currentItem.x - units.gu(1) : 0
++        width: d.currentItem ? d.currentItem.width + units.gu(2) : 0
++        height: units.dp(4)
++        color: UbuntuColors.orange
++        visible: d.currentItem
+     }
      MenuNavigator {
          id: d
          objectName: "d"
          itemView: rowRepeater
++        hasOverflow: overflowButton.visible
          property Item currentItem: null
          property Item hoveredItem: null
          property Item prevCurrentItem: null
--
--        readonly property int currentIndex: currentItem ? currentItem.__ownIndex : -1
--
          property bool altPressed: false
          property bool longAltPressed: false
++        property var firstInvisibleIndex: undefined
++
++        readonly property int currentIndex: currentItem && currentItem.hasOwnProperty("__ownIndex") ? currentItem.__ownIndex : -1
          signal dismissAll()
++        function recalcFirstInvisibleIndexAdded(index, item) {
++            if (firstInvisibleIndex === undefined) {
++                if (!item.shouldDisplay) {
++                    firstInvisibleIndex = index;
++                }
++            } else if (index <= firstInvisibleIndex) {
++                if (!item.shouldDisplay) {
++                    firstInvisibleIndex = index;
++                } else {
++                    firstInvisibleIndex++;
++                }
++            }
++        }
++
++        function recalcFirstInvisibleIndex() {
++            for (var i = 0; i < rowRepeater.count; i++) {
++                if (!rowRepeater.itemAt(i).shouldDisplay) {
++                    firstInvisibleIndex = i;
++                    return;
++                }
++            }
++            firstInvisibleIndex = undefined;
++        }
++
          onSelect: {
              var delegate = rowRepeater.itemAt(index);
              if (delegate) {
@@ -265,6 +413,10 @@
+             }
+         }
++        onOverflow: {
++            d.currentItem = overflowButton;
++        }
++
          onCurrentItemChanged: {
              if (prevCurrentItem && prevCurrentItem != currentItem) {
                  if (currentItem) {
 === modified file 'qml/ApplicationMenus/MenuItem.qml'
 --- qml/ApplicationMenus/MenuItem.qml	2016-12-13 09:56:20 +0000
 +++ qml/ApplicationMenus/MenuItem.qml	2017-01-31 14:13:11 +0000
@@ -46,6 +46,8 @@
      enabled: menuData ? menuData.sensitive : false
      action: Action {
++        enabled: root.enabled
++
          // FIXME - SDK Action:text modifies menu text with html underline for mnemonic
          text: menuData.label.replace("_", "&").replace("<u>", "&").replace("</u>", "")
          checkable: menuData.isCheck || menuData.isRadio
@@ -137,14 +139,7 @@
                               theme.palette.disabled.backgroundSecondaryText
              visible: root.hasSubmenu
--            name: "chevron"
--        }
--    }
--
--    MouseArea {
--        anchors.fill: parent
--        onClicked: {
--            root.trigger(action && action.checkable ? !action.checked : undefined);
++            name: "toolkit_chevron-ltr_2gu"
+         }
+     }
+ }
 === modified file 'qml/ApplicationMenus/MenuNavigator.qml'
 --- qml/ApplicationMenus/MenuNavigator.qml	2016-11-28 13:44:30 +0000
 +++ qml/ApplicationMenus/MenuNavigator.qml	2017-01-31 14:13:11 +0000
@@ -18,8 +18,10 @@
  QtObject {
      property Item itemView: null
++    property bool hasOverflow: false
      signal select(int index)
++    signal overflow()
      function selectNext(currentIndex) {
          var menu;
@@ -32,6 +34,11 @@
                      break;
+                 }
                  newIndex++;
++
++                if (hasOverflow && newIndex === itemView.count) {
++                    overflow()
++                    break;
++                }
+             }
          } else if (currentIndex !== -1 && itemView.count > 1) {
              var startIndex = (currentIndex + 1) % itemView.count;
@@ -42,6 +49,12 @@
                      select(newIndex);
                      break;
+                 }
++
++                if (hasOverflow && newIndex + 1 === itemView.count) {
++                    overflow()
++                    break;
++                }
++
                  newIndex = (newIndex + 1) % itemView.count;
              } while (newIndex !== startIndex)
+         }
@@ -58,12 +71,21 @@
                      break;
+                 }
                  newIndex--;
++
++                if (hasOverflow && newIndex < 0 ) {
++                    overflow();
++                    break;
++                }
+             }
          } else if (currentIndex !== -1 && itemView.count > 1) {
              var startIndex = currentIndex - 1;
              newIndex = startIndex;
              do {
                  if (newIndex < 0) {
++                    if (hasOverflow) {
++                        overflow();
++                        break;
++                    }
                      newIndex = itemView.count - 1;
+                 }
                  menu = itemView.itemAt(newIndex);
@@ -72,6 +94,7 @@
                      break;
+                 }
                  newIndex--;
++
              } while (newIndex !== startIndex)
+         }
+     }
 === modified file 'qml/ApplicationMenus/MenuPopup.qml'
 --- qml/ApplicationMenus/MenuPopup.qml	2017-01-18 12:08:05 +0000
 +++ qml/ApplicationMenus/MenuPopup.qml	2017-01-31 14:13:11 +0000
@@ -16,16 +16,50 @@
  import QtQuick 2.4
  import QtQuick.Layouts 1.1
--import QtQuick.Window 2.2
  import Ubuntu.Components 1.3
  import Ubuntu.Components.ListItems 1.3 as ListItems
  import "../Components"
++import "."
  UbuntuShape {
      id: root
      objectName: "menu"
      backgroundColor: theme.palette.normal.overlay
++    signal childActivated()
++
++    // true for submenus that need to show on the other side of their parent
++    // if they don't fit when growing right
++    property bool substractWidth: false
++
++    property real desiredX
++    x: {
++        var dummy = visible; // force recalc when shown/hidden
++        var parentTopLeft = parent.mapToItem(null, 0, 0);
++        var farX = ApplicationMenusLimits.screenWidth;
++        if (parentTopLeft.x + width + desiredX <= farX) {
++            return desiredX;
++        } else {
++            if (substractWidth) {
++                return -width;
++            } else {
++                return farX - parentTopLeft.x - width;
++            }
++        }
++    }
++
++    property real desiredY
++    y: {
++        var dummy = visible; // force recalc when shown/hidden
++        var parentTopLeft = parent.mapToItem(null, 0, 0);
++        var bottomY = ApplicationMenusLimits.screenHeight;
++        if (parentTopLeft.y + height + desiredY <= bottomY) {
++            return desiredY;
++        } else {
++            return bottomY - parentTopLeft.y - height;
++        }
++    }
++
      property alias unityMenuModel: repeater.model
      function show() {
@@ -64,9 +98,9 @@
          readonly property int currentIndex: currentItem ? currentItem.__ownIndex : -1
          property real __minimumWidth: units.gu(20)
--        property real __maximumWidth: Screen.width * 0.7
++        property real __maximumWidth: ApplicationMenusLimits.screenWidth * 0.7
          property real __minimumHeight: units.gu(2)
--        property real __maximumHeight: Screen.height * 0.7
++        property real __maximumHeight: ApplicationMenusLimits.screenHeight
          signal dismissAll()
@@ -76,6 +110,8 @@
              } else {
                  hoveredItem = null;
+             }
++
++            submenuHoverTimer.stop();
+         }
          onSelect: {
@@ -147,8 +183,20 @@
+                 }
                  MouseArea {
++                    id: previousMA
                      anchors.fill: parent
--                    onPressed: {
++                    hoverEnabled: enabled
++                    onPressed: progress()
++
++                    Timer {
++                        running: previousMA.containsMouse && !listView.atYBeginning
++                        interval: 1000
++                        repeat: true
++                        onTriggered: previousMA.progress()
++                    }
++
++                    function progress() {
++                        console.log("progress!")
                          var item = menuColumn.childAt(0, listView.contentY);
                          if (item) {
                              var previousItem = item;
@@ -176,10 +224,15 @@
                  contentHeight: menuColumn.height
                  interactive: height < contentHeight
++                Timer {
++                    id: submenuHoverTimer
++                    interval: 225 // GTK MENU_POPUP_DELAY, Qt SH_Menu_SubMenuPopupDelay in QCommonStyle is 256
++                    onTriggered: d.currentItem.item.trigger();
++                }
++
                  MouseArea {
                      anchors.fill: parent
                      hoverEnabled: true
--                    propagateComposedEvents: true // propogate events so we send clicks to children.
                      z: 1 // on top so we override any other hovers
                      onEntered: updateCurrentItemFromPosition(Qt.point(mouseX, mouseY))
                      onPositionChanged: updateCurrentItemFromPosition(Qt.point(mouse.x, mouse.y))
@@ -189,12 +242,25 @@
                          if (!d.hoveredItem || !d.currentItem ||
                                  !d.hoveredItem.contains(Qt.point(pos.x - d.currentItem.x, pos.y - d.currentItem.y))) {
++                            submenuHoverTimer.stop();
++
                              d.hoveredItem = menuColumn.childAt(pos.x, pos.y)
                              if (!d.hoveredItem || !d.hoveredItem.enabled)
--                                return false;
++                                return;
                              d.currentItem = d.hoveredItem;
--                        }
--                        return true;
++
++                            if (!d.currentItem.__isSeparator && d.currentItem.item.hasSubmenu && d.currentItem.item.enabled) {
++                                submenuHoverTimer.start();
++                            }
++                        }
++                    }
++
++                    onClicked: {
++                        var pos = mapToItem(listView.contentItem, mouse.x, mouse.y);
++                        var clickedItem = menuColumn.childAt(pos.x, pos.y);
++                        if (clickedItem.enabled && !clickedItem.__isSeparator) {
++                            clickedItem.item.trigger();
++                        }
+                     }
+                 }
@@ -249,6 +315,8 @@
                                      width: MathUtils.clamp(implicitWidth, d.__minimumWidth, d.__maximumWidth)
                                      action.onTriggered: {
++                                        submenuHoverTimer.stop();
++
                                          d.currentItem = loader;
                                          if (hasSubmenu) {
@@ -257,22 +325,29 @@
                                                  popup = submenuComponent.createObject(focusScope, {
                                                                                            objectName: loader.objectName + "-",
                                                                                            unityMenuModel: model,
--                                                                                          x: Qt.binding(function() { return root.width }),
--                                                                                          y: Qt.binding(function() {
++                                                                                          substractWidth: true,
++                                                                                          desiredX: Qt.binding(function() { return root.width }),
++                                                                                          desiredY: Qt.binding(function() {
                                                                                                var dummy = listView.contentY; // force a recalc on contentY change.
                                                                                                return mapToItem(container, 0, y).y;
                                                                                            })
                                                                                        });
++                                                popup.retreat.connect(function() {
++                                                    popup.destroy();
++                                                    popup = null;
++                                                    menuItem.forceActiveFocus();
++                                                });
++                                                popup.childActivated.connect(function() {
++                                                    popup.destroy();
++                                                    popup = null;
++                                                    root.childActivated();
++                                                });
                                              } else if (popup) {
                                                  popup.visible = true;
+                                             }
--                                            popup.retreat.connect(function() {
--                                                popup.destroy();
--                                                popup = null;
--                                                menuItem.forceActiveFocus();
--                                            })
                                          } else {
                                              root.unityMenuModel.activate(__ownIndex);
++                                            root.childActivated();
+                                         }
+                                     }
@@ -349,8 +424,19 @@
+                 }
                  MouseArea {
++                    id: nextMA
                      anchors.fill: parent
--                    onPressed: {
++                    hoverEnabled: enabled
++                    onPressed: progress()
++
++                    Timer {
++                        running: nextMA.containsMouse && !listView.atYEnd
++                        interval: 1000
++                        repeat: true
++                        onTriggered: nextMA.progress()
++                    }
++
++                    function progress() {
                          var item = menuColumn.childAt(0, listView.contentY + listView.height);
                          if (item) {
                              var nextItem = item;
@@ -375,23 +461,28 @@
                  id: submenuLoader
                  source: "MenuPopup.qml"
++                property real desiredX
++                property real desiredY
++                property bool substractWidth
                  property var unityMenuModel: null
                  signal retreat()
--
--                Binding {
--                    target: item
--                    property: "unityMenuModel"
--                    value: submenuLoader.unityMenuModel
--                }
--
--                Binding {
--                    target: item
--                    property: "objectName"
--                    value: submenuLoader.objectName + "menu"
++                signal childActivated()
++
++                onLoaded: {
++                    item.unityMenuModel = Qt.binding(function() { return submenuLoader.unityMenuModel; });
++                    item.objectName = Qt.binding(function() { return submenuLoader.objectName + "menu"; });
++                    item.desiredX = Qt.binding(function() { return submenuLoader.desiredX; });
++                    item.desiredY = Qt.binding(function() { return submenuLoader.desiredY; });
++                    item.substractWidth = Qt.binding(function() { return submenuLoader.substractWidth; });
+                 }
                  Keys.onLeftPressed: retreat()
++                Connections {
++                    target: item
++                    onChildActivated: childActivated();
++                }
++
                  Component.onCompleted: item.select(0);
                  onVisibleChanged: if (visible) { item.select(0); }
+             }
 === added file 'qml/ApplicationMenus/qmldir'
 --- qml/ApplicationMenus/qmldir	1970-01-01 00:00:00 +0000
 +++ qml/ApplicationMenus/qmldir	2017-01-31 14:13:11 +0000
@@ -0,0 +1,1 @@
++singleton ApplicationMenusLimits 0.1 ApplicationMenusLimits.qml
 === modified file 'qml/Panel/Panel.qml'
 --- qml/Panel/Panel.qml	2017-01-09 14:10:17 +0000
 +++ qml/Panel/Panel.qml	2017-01-31 14:13:11 +0000
@@ -209,6 +209,8 @@
                      Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }
                      active: __applicationMenus.model
++                    width: parent.width - windowControlButtons.width - units.gu(2) - __indicators.barWidth
++
                      property bool menusRequested: menuBarLoader.item ? menuBarLoader.item.showRequested : false
                      sourceComponent: MenuBar {
@@ -385,7 +387,7 @@
+             }
              enabled: !applicationMenus.expanded
--            opacity: !applicationMenus.expanded ? 1 : 0
++            opacity: !callHint.visible && !applicationMenus.expanded ? 1 : 0
              Behavior on opacity { UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration } }
              onEnabledChanged: {
 === modified file 'tests/mocks/Utils/CMakeLists.txt'
 --- tests/mocks/Utils/CMakeLists.txt	2016-12-21 10:20:36 +0000
 +++ tests/mocks/Utils/CMakeLists.txt	2017-01-31 14:13:11 +0000
@@ -26,6 +26,7 @@
      ${CMAKE_SOURCE_DIR}/plugins/Utils/globalfunctions.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Utils/appdrawerproxymodel.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Utils/tabfocusfence.cpp
++    ${CMAKE_SOURCE_DIR}/plugins/Utils/expressionfiltermodel.cpp
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
 === modified file 'tests/mocks/Utils/plugin.cpp'
 --- tests/mocks/Utils/plugin.cpp	2017-01-03 12:16:00 +0000
 +++ tests/mocks/Utils/plugin.cpp	2017-01-31 14:13:11 +0000
@@ -42,6 +42,7 @@
  #include <globalfunctions.h>
  #include <appdrawerproxymodel.h>
  #include <tabfocusfence.h>
++#include <expressionfiltermodel.h>
  static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
+ {
@@ -86,4 +87,5 @@
      qmlRegisterType<URLDispatcher>(uri, 0, 1, "URLDispatcher");
      qmlRegisterType<AppDrawerProxyModel>(uri, 0, 1, "AppDrawerProxyModel");
      qmlRegisterType<TabFocusFenceItem>(uri, 0, 1, "TabFocusFence");
++    qmlRegisterType<ExpressionFilterModel>(uri, 0, 1, "ExpressionFilterModel");
+ }
 === modified file 'tests/qmltests/ApplicationMenus/tst_MenuBar.qml'
 --- tests/qmltests/ApplicationMenus/tst_MenuBar.qml	2017-01-24 07:41:35 +0000
 +++ tests/qmltests/ApplicationMenus/tst_MenuBar.qml	2017-01-31 14:13:11 +0000
@@ -28,8 +28,8 @@
  Item {
      id: root
--    width:  units.gu(100)
--    height:  units.gu(50)
++    width:  units.gu(120)
++    height:  units.gu(70)
      Component.onCompleted: {
          QuickUtils.keyboardAttached = true;
@@ -51,11 +51,11 @@
      Rectangle {
          anchors {
              left: parent.left
--            right: parent.right
              top: parent.top
              margins: units.gu(1)
+         }
          height: units.gu(3)
++        width: parent.width * 2/3
          color: "grey"
          MenuBar {
@@ -65,7 +65,7 @@
              unityMenuModel: UnityMenuModel {
                  id: menuBackend
--                modelData: appMenuData.generateTestData(17,5,2,3)
++                modelData: appMenuData.generateTestData(10,5,2,3)
+             }
+         }
+     }
@@ -83,12 +83,12 @@
          function init() {
              menuBar.dismiss();
--            menuBackend.modelData = appMenuData.generateTestData(5,5,2,3)
++            menuBackend.modelData = appMenuData.generateTestData(5,5,2,3, "menu")
              activatedSpy.clear();
+         }
          function test_mouseNavigation() {
--            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0);
++            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0, "menu");
              wait(50) // wait for row to build
              var priv = findInvisibleChild(menuBar, "d");
@@ -114,7 +114,7 @@
+         }
          function test_keyboardNavigation_RightKeySelectsNextMenuItem(data) {
--            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0);
++            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0, "menu");
              var priv = findInvisibleChild(menuBar, "d");
              var menuItem0 = findChild(menuBar, "menuBar-item0"); verify(menuItem0);
@@ -139,7 +139,7 @@
+         }
          function test_keyboardNavigation_LeftKeySelectsPreviousMenuItem(data) {
--            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0);
++            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0, "menu");
              var priv = findInvisibleChild(menuBar, "d");
              var menuItem0 = findChild(menuBar, "menuBar-item0"); verify(menuItem0);
@@ -192,5 +192,46 @@
              keyClick(Qt.Key_F10, Qt.AltModifier);
              compare(priv.currentItem, menuItem1, "First enabled item should be opened");
+         }
++
++        function test_clickOpenMenuClosesMenu() {
++            menuBackend.modelData = appMenuData.generateTestData(3,3,0,0,"menu");
++            var priv = findInvisibleChild(menuBar, "d");
++
++            var menuItem = findChild(menuBar, "menuBar-item0");
++            waitForRendering(menuItem);
++            mouseClick(menuItem);
++            compare(priv.currentItem, menuItem, "CurrentItem should be set to item 0");
++            compare(priv.currentItem.popupVisible, true, "Popup should be visible");
++
++            waitForRendering(menuItem);
++            mouseClick(menuItem);
++            compare(priv.currentItem, null, "CurrentItem should be null");
++        }
++
++        function test_overfow() {
++            menuBackend.modelData = appMenuData.generateTestData(5,2,0,0,"menu");
++
++            var overflow = findChild(menuBar, "overflow");
++            compare(overflow.visible, false, "Overflow should not be visible");
++
++            var menu = { "rowData": { "label": "Short" } };
++            tryCompareFunction(function() {
++                menuBackend.insertRow(0, menu);
++                wait(1);
++                if (overflow.visible) {
++                    return true;
++                }
++                return false;
++            }, true);
++
++            tryCompareFunction(function() {
++                menuBackend.removeRow(0);
++                wait(1);
++                if (!overflow.visible) {
++                    return true;
++                }
++                return false;
++            }, true);
++        }
+     }
+ }
 === modified file 'tests/qmltests/ApplicationMenus/tst_MenuPopup.qml'
 --- tests/qmltests/ApplicationMenus/tst_MenuPopup.qml	2017-01-18 12:08:14 +0000
 +++ tests/qmltests/ApplicationMenus/tst_MenuPopup.qml	2017-01-31 14:13:11 +0000
@@ -223,6 +223,20 @@
              tryCompareFunction(function() { return menuItem.popup !== null && menuItem.popup.visible }, false);
+         }
++        function test_mouseHoverOpensSubMenu() {
++            menu.unityMenuModel.modelData = appMenuData.generateTestData(3,3,1,0,"menu",false);
++
++            var menuItem = findChild(menu, "menu-item0");
++
++            var priv = findInvisibleChild(menu, "d");
++            priv.currentItem = menuItem;
++
++            mouseMove(menuItem, menuItem.width/2, menuItem.height/2);
++            verify(!menuItem.popup);
++
++            tryCompareFunction(function() { return menuItem.popup != null; }, true);
++        }
++
          function test_differentSizes() {
              var differentSizesMenu = [{
                  "rowData": { "label": "Short" }}, {
 === modified file 'tests/qmltests/Stage/tst_DesktopStage.qml'
 --- tests/qmltests/Stage/tst_DesktopStage.qml	2017-01-10 14:44:29 +0000
 +++ tests/qmltests/Stage/tst_DesktopStage.qml	2017-01-31 14:13:11 +0000
@@ -29,6 +29,7 @@
  import "../../../qml/Stage"
  import "../../../qml/Components"
  import "../../../qml/Components/PanelState"
++import "../../../qml/ApplicationMenus"
  Item {
      id: root
@@ -44,6 +45,8 @@
+     }
      Component.onCompleted: {
++        ApplicationMenusLimits.screenWidth = Qt.binding( function() { return stageLoader.width; } );
++        ApplicationMenusLimits.screenHeight = Qt.binding( function() { return stageLoader.height; } );
          QuickUtils.keyboardAttached = true;
          theme.name = "Ubuntu.Components.Themes.SuruDark";
          resetGeometry();
@@ -695,10 +698,18 @@
              var sizeBefore = Qt.size(dialerDelegate.width, dialerDelegate.height);
              var deco = findChild(dialerDelegate, "appWindowDecoration");
              verify(deco);
--            tryCompare(deco, "maximizeButtonShown", false);
--            mouseDoubleClick(deco);
--            var sizeAfter = Qt.size(dialerDelegate.width, dialerDelegate.height);
--            tryCompareFunction(function(){ return sizeBefore; }, sizeAfter);
++            // deco.width - units.gu(1) to make sure we're outside the "menu" area of the decoration
++            mouseMove(deco, deco.width - units.gu(1), deco.height/2);
++            var menuBarLoader = findChild(deco, "menuBarLoader");
++            tryCompare(menuBarLoader.item, "visible", true);
++            mouseDoubleClick(deco, deco.width - units.gu(1), deco.height/2)
++            expectFail("", "Double click should not maximize in a size restricted window");
++            tryCompareFunction(function() {
++                    var sizeAfter = Qt.size(dialerDelegate.width, dialerDelegate.height);
++                    return sizeAfter.width > sizeBefore.width && sizeAfter.height > sizeBefore.height;
++                },
++                true
++            );
              // remove restrictions, the maximize button should again be visible
              dialerDelegate.surface.setMaximumWidth(0);
@@ -706,6 +717,29 @@
              tryCompare(dialerMaximizeButton, "visible", true);
+         }
++        function test_doubleClickMaximizes() {
++            var dialerDelegate = startApplication("dialer-app");
++
++            var dialerMaximizeButton = findChild(dialerDelegate, "maximizeWindowButton");
++            tryCompare(dialerMaximizeButton, "visible", true);
++
++            // try double clicking the decoration, should maximize it
++            var sizeBefore = Qt.size(dialerDelegate.width, dialerDelegate.height);
++            var deco = findChild(dialerDelegate, "appWindowDecoration");
++            verify(deco);
++            // deco.width - units.gu(1) to make sure we're outside the "menu" area of the decoration
++            mouseMove(deco, deco.width - units.gu(1), deco.height/2);
++            var menuBarLoader = findChild(deco, "menuBarLoader");
++            tryCompare(menuBarLoader.item, "visible", true);
++            mouseDoubleClick(deco, deco.width - units.gu(1), deco.height/2);
++            tryCompareFunction(function() {
++                    var sizeAfter = Qt.size(dialerDelegate.width, dialerDelegate.height);
++                    return sizeAfter.width > sizeBefore.width && sizeAfter.height > sizeBefore.height;
++                },
++                true
++            );
++        }
++
          function test_canMoveWindowWithLeftMouseButtonOnly_data() {
              return [
                  {tag: "left mouse button", button: Qt.LeftButton },
@@ -830,5 +864,144 @@
              mouseRelease(decoration);
              tryCompare(Mir, "cursorName", "");
+         }
++
++        function test_menuPositioning_data() {
++            return [
++                {tag: "good",
++                    windowPosition: Qt.point(units.gu(10),  units.gu(10))
++                },
++                {tag: "collides right",
++                    windowPosition: Qt.point(units.gu(100), units.gu(10)),
++                    minimumXDifference: units.gu(8)
++                },
++                {tag: "collides bottom",
++                    windowPosition: Qt.point(units.gu(10),  units.gu(80)),
++                    minimumYDifference: units.gu(7)
++                },
++            ]
++        }
++
++        function test_menuPositioning(data) {
++            var appDelegate = startApplication("dialer-app");
++            appDelegate.windowedX = data.windowPosition.x;
++            appDelegate.windowedY = data.windowPosition.y;
++
++            var menuItem = findChild(appDelegate, "menuBar-item3");
++            menuItem.show();
++
++            var menu = findChild(appDelegate, "menuBar-item3-menu");
++            tryCompare(menu, "visible", true);
++
++            var normalPositioningX = menuItem.x - units.gu(1);
++            var normalPositioningY = menuItem.height;
++
++            // We do this fuzzy checking because otherwise we would be duplicating the code
++            // that calculates the coordinates and any bug it may have, what we want is really
++            // to check that on collision with the border the menu is shifted substantially
++            if (data.minimumXDifference) {
++                verify(menu.x < normalPositioningX - data.minimumXDifference);
++            } else {
++                compare(menu.x, normalPositioningX);
++            }
++
++            if (data.minimumYDifference) {
++                verify(menu.y < normalPositioningY - data.minimumYDifference);
++            } else {
++                compare(menu.y, normalPositioningY);
++            }
++        }
++
++        function test_submenuPositioning_data() {
++            return [
++                {tag: "good",
++                    windowPosition: Qt.point(units.gu(10),  units.gu(10))
++                },
++                {tag: "collides right",
++                    windowPosition: Qt.point(units.gu(100), units.gu(10)),
++                    minimumXDifference: units.gu(35)
++                },
++                {tag: "collides bottom",
++                    windowPosition: Qt.point(units.gu(10),  units.gu(80)),
++                    minimumYDifference: units.gu(8)
++                },
++            ]
++        }
++
++        function test_submenuPositioning(data) {
++            var appDelegate = startApplication("dialer-app");
++            appDelegate.windowedX = data.windowPosition.x;
++            appDelegate.windowedY = data.windowPosition.y;
++
++            var menuItem = findChild(appDelegate, "menuBar-item3");
++            menuItem.show();
++
++            var menu = findChild(appDelegate, "menuBar-item3-menu");
++            menuItem = findChild(menu, "menuBar-item3-menu-item3-actionItem");
++            tryCompare(menuItem, "visible", true);
++            mouseMove(menuItem);
++            mouseClick(menuItem);
++
++            menu = findChild(appDelegate, "menuBar-item3-menu-item3-menu");
++
++            var normalPositioningX = menuItem.width;
++            var normalPositioningY = menuItem.parent.y;
++
++            // We do this fuzzy checking because otherwise we would be duplicating the code
++            // that calculates the coordinates and any bug it may have, what we want is really
++            // to check that on collision with the border the menu is shifted substantially
++            if (data.minimumXDifference) {
++                verify(menu.x < normalPositioningX - data.minimumXDifference);
++            } else {
++                compare(menu.x, normalPositioningX);
++            }
++
++            if (data.minimumYDifference) {
++                verify(menu.y < normalPositioningY - data.minimumYDifference);
++            } else {
++                compare(menu.y, normalPositioningY);
++            }
++        }
++
++        function test_menuDoubleClickNoMaximizeWindowBehind() {
++            var appDelegate1 = startApplication("dialer-app");
++            var appDelegate2 = startApplication("gmail-webapp");
++
++            // Open menu
++            var menuItem = findChild(appDelegate2, "menuBar-item3");
++            menuItem.show();
++            var menu = findChild(appDelegate2, "menuBar-item3-menu");
++            menuItem = findChild(menu, "menuBar-item3-menu-item3-actionItem");
++            tryCompare(menuItem, "visible", true);
++
++            // Place the other application window decoration under the menu
++            var pos = menuItem.mapToItem(null, menuItem.width / 2, menuItem.height / 2);
++            appDelegate1.windowedX = pos.x - appDelegate1.width / 2;
++            appDelegate1.windowedY = pos.y - units.gu(1);
++
++            var previousWindowState = appDelegate1.windowState;
++
++            mouseMove(menuItem);
++            mouseDoubleClickSequence(menuItem);
++
++            expectFail("", "Double clicking a menu should not change the window below");
++            tryCompareFunction(function() { return appDelegate1.windowState != previousWindowState; }, true);
++        }
++
++        function test_openMenuEatsHoverOutsideIt() {
++            var appDelegate = startApplication("gmail-webapp");
++
++            var wd = findChild(appDelegate, "appWindowDecoration");
++            var closeButton = findChild(wd, "closeWindowButton");
++
++            // Open menu
++            var menuItem = findChild(appDelegate, "menuBar-item3");
++            menuItem.show();
++            var menu = findChild(appDelegate, "menuBar-item3-menu");
++            tryCompare(menu, "visible", true);
++
++            mouseMove(closeButton, closeButton.width/2, closeButton.height/2);
++            expectFail("", "Hovering the window controls should be ignored when the menu is open");
++            tryCompare(closeButton, "containsMouse", true);
++        }
+     }
+ }