Merge lp:~mzanetti/unity8/ubuntuanimations into lp:unity8

[Michael Zanetti]

use UbuntuNumberAnimations instead of linear ones for window state transitions

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

see prereq

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

yes

 * Did you make sure that your branch does not contain spurious tags?

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?

changed as peer design feedback

[lp:~mzanetti/unity8/ubuntuanimations]

2027. By Michael Zanetti on 2015-11-09

merge prereq

2028. By Michael Zanetti on 2015-11-09

update after merging

2029. By Michael Zanetti on 2015-11-12

mrege prereq

2030. By Michael Zanetti on 2015-11-12

wait for animations to be finished before destroying the test

Unmerged revisions

=== modified file 'plugins/Utils/windowstatestorage.cpp'
--- plugins/Utils/windowstatestorage.cpp	2015-09-14 09:11:08 +0000
+++ plugins/Utils/windowstatestorage.cpp	2015-11-03 11:00:18 +0000
@@ -47,26 +47,38 @@
     m_db.close();
 }
 
+void WindowStateStorage::saveState(const QString &windowId, WindowStateStorage::WindowState state)
+{
+    const QString queryString = QStringLiteral("INSERT OR REPLACE INTO state (windowId, state) values ('%1', '%2');")
+            .arg(windowId)
+            .arg((int)state);
+
+    saveValue(queryString);
+}
+
+WindowStateStorage::WindowState WindowStateStorage::getState(const QString &windowId, WindowStateStorage::WindowState defaultValue) const
+{
+    const QString queryString = QStringLiteral("SELECT * FROM state WHERE windowId = '%1';")
+            .arg(windowId);
+
+    QSqlQuery query = getValue(queryString);
+
+    if (!query.first()) {
+        return defaultValue;
+    }
+    return (WindowState)query.value("state").toInt();
+}
+
 void WindowStateStorage::saveGeometry(const QString &windowId, const QRect &rect)
 {
-    QMutexLocker mutexLocker(&s_mutex);
-
-    QString queryString = QStringLiteral("INSERT OR REPLACE INTO geometry (windowId, x, y, width, height) values ('%1', '%2', '%3', '%4', '%5');")
+    const QString queryString = QStringLiteral("INSERT OR REPLACE INTO geometry (windowId, x, y, width, height) values ('%1', '%2', '%3', '%4', '%5');")
             .arg(windowId)
             .arg(rect.x())
             .arg(rect.y())
             .arg(rect.width())
             .arg(rect.height());
 
-    QFuture<void> future = QtConcurrent::run(executeAsyncQuery, queryString);
-    m_asyncQueries.append(future);
-
-    QFutureWatcher<void> *futureWatcher = new QFutureWatcher<void>();
-    futureWatcher->setFuture(future);
-    connect(futureWatcher, &QFutureWatcher<void>::finished,
-            this,
-            [=](){ m_asyncQueries.removeAll(futureWatcher->future());
-                   futureWatcher->deleteLater(); });
+    saveValue(queryString);
 }
 
 void WindowStateStorage::executeAsyncQuery(const QString &queryString)
@@ -82,20 +94,13 @@
     }
 }
 
-QRect WindowStateStorage::getGeometry(const QString &windowId, const QRect &defaultValue)
+QRect WindowStateStorage::getGeometry(const QString &windowId, const QRect &defaultValue) const
 {
-    QMutexLocker l(&s_mutex);
     QString queryString = QStringLiteral("SELECT * FROM geometry WHERE windowId = '%1';")
             .arg(windowId);
-    QSqlQuery query;
-
-    bool ok = query.exec(queryString);
-    if (!ok) {
-        qWarning() << "Error retrieving window state for" << windowId
-                   << "Driver error:" << query.lastError().driverText()
-                   << "Database error:" << query.lastError().databaseText();
-        return defaultValue;
-    }
+
+    QSqlQuery query = getValue(queryString);
+
     if (!query.first()) {
         return defaultValue;
     }
@@ -114,4 +119,38 @@
         QSqlQuery query;
         query.exec(QStringLiteral("CREATE TABLE geometry(windowId TEXT UNIQUE, x INTEGER, y INTEGER, width INTEGER, height INTEGER);"));
     }
+
+    if (!m_db.tables().contains("state")) {
+        QSqlQuery query;
+        query.exec("CREATE TABLE state(windowId TEXT UNIQUE, state INTEGER);");
+    }
+}
+
+void WindowStateStorage::saveValue(const QString &queryString)
+{
+    QMutexLocker mutexLocker(&s_mutex);
+
+    QFuture<void> future = QtConcurrent::run(executeAsyncQuery, queryString);
+    m_asyncQueries.append(future);
+
+    QFutureWatcher<void> *futureWatcher = new QFutureWatcher<void>();
+    futureWatcher->setFuture(future);
+    connect(futureWatcher, &QFutureWatcher<void>::finished,
+            this,
+            [=](){ m_asyncQueries.removeAll(futureWatcher->future());
+        futureWatcher->deleteLater(); });
+}
+
+QSqlQuery WindowStateStorage::getValue(const QString &queryString) const
+{
+    QMutexLocker l(&s_mutex);
+    QSqlQuery query;
+
+    bool ok = query.exec(queryString);
+    if (!ok) {
+        qWarning() << "Error retrieving database query:" << queryString
+                   << "Driver error:" << query.lastError().driverText()
+                   << "Database error:" << query.lastError().databaseText();
+    }
+    return query;
 }

=== modified file 'plugins/Utils/windowstatestorage.h'
--- plugins/Utils/windowstatestorage.h	2015-03-13 19:01:32 +0000
+++ plugins/Utils/windowstatestorage.h	2015-11-03 11:00:18 +0000
@@ -22,16 +22,28 @@
 class WindowStateStorage: public QObject
 {
     Q_OBJECT
+    Q_ENUMS(WindowState)
 public:
+    enum WindowState {
+        WindowStateNormal,
+        WindowStateMaximized
+    };
+
     WindowStateStorage(QObject *parent = 0);
     virtual ~WindowStateStorage();
 
+    Q_INVOKABLE void saveState(const QString &windowId, WindowState state);
+    Q_INVOKABLE WindowState getState(const QString &windowId, WindowState defaultValue) const;
+
     Q_INVOKABLE void saveGeometry(const QString &windowId, const QRect &rect);
-    Q_INVOKABLE QRect getGeometry(const QString &windowId, const QRect &defaultValue);
+    Q_INVOKABLE QRect getGeometry(const QString &windowId, const QRect &defaultValue) const;
 
 private:
     void initdb();
 
+    void saveValue(const QString &queryString);
+    QSqlQuery getValue(const QString &queryString) const;
+
     static void executeAsyncQuery(const QString &queryString);
     static QMutex s_mutex;
 

=== modified file 'qml/Components/PanelState/PanelState.qml'
--- qml/Components/PanelState/PanelState.qml	2014-11-24 11:21:38 +0000
+++ qml/Components/PanelState/PanelState.qml	2015-11-03 11:00:18 +0000
@@ -23,6 +23,8 @@
     property string title: ""
     property bool buttonsVisible: false
 
+    property int panelHeight: 0
+
     signal close()
     signal minimize()
     signal maximize()

=== modified file 'qml/Components/WindowControlButtons.qml'
--- qml/Components/WindowControlButtons.qml	2014-11-24 11:21:38 +0000
+++ qml/Components/WindowControlButtons.qml	2015-11-03 11:00:18 +0000
@@ -28,6 +28,7 @@
     signal maximize()
 
     Rectangle {
+        objectName: "closeWindowButton"
         height: parent.height; width: height; radius: height / 2
         gradient: Gradient {
             GradientStop { color: "#F49073"; position: 0 }
@@ -38,6 +39,7 @@
         MouseArea { anchors.fill: parent; onClicked: root.close() }
     }
     Rectangle {
+        objectName: "minimizeWindowButton"
         height: parent.height; width: height; radius: height / 2
         gradient: Gradient {
             GradientStop { color: "#92918C"; position: 0 }
@@ -48,6 +50,7 @@
         MouseArea { anchors.fill: parent; onClicked: root.minimize() }
     }
     Rectangle {
+        objectName: "maximizeWindowButton"
         height: parent.height; width: height; radius: height / 2
         gradient: Gradient {
             GradientStop { color: "#92918C"; position: 0 }

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2015-09-29 12:48:46 +0000
+++ qml/Panel/Panel.qml	2015-11-03 11:00:18 +0000
@@ -28,9 +28,16 @@
     property alias callHint: __callHint
     property bool fullscreenMode: false
     property real indicatorAreaShowProgress: 1.0
+    property bool locked: false
 
     opacity: fullscreenMode && indicators.fullyClosed ? 0.0 : 1.0
 
+    Binding {
+        target: PanelState
+        property: "panelHeight"
+        value: root.panelHeight
+    }
+
     Rectangle {
         id: darkenedArea
         property real darkenedOpacity: 0.6
@@ -136,7 +143,7 @@
             }
 
             shown: false
-            width: root.width - (PanelState.buttonsVisible ? windowControlButtons.width : 0)
+            width: root.width - (windowControlButtons.visible ? windowControlButtons.width + titleLabel.width : 0)
             minimizedPanelHeight: units.gu(3)
             expandedPanelHeight: units.gu(7)
             openedHeight: root.height - indicatorOrangeLine.height
@@ -164,18 +171,36 @@
 
         WindowControlButtons {
             id: windowControlButtons
+            objectName: "panelWindowControlButtons"
             anchors {
                 left: parent.left
                 top: parent.top
                 margins: units.gu(0.7)
             }
             height: indicators.minimizedPanelHeight - anchors.margins * 2
-            visible: PanelState.buttonsVisible
+            visible: PanelState.buttonsVisible && !root.locked
             onClose: PanelState.close()
             onMinimize: PanelState.minimize()
             onMaximize: PanelState.maximize()
         }
 
+        Label {
+            id: titleLabel
+            objectName: "windowDecorationTitle"
+            anchors {
+                left: windowControlButtons.right
+                top: parent.top
+                margins: units.gu(0.7)
+            }
+            color: "#DFDBD2"
+            height: windowControlButtons.height
+            visible: windowControlButtons.visible
+            verticalAlignment: Text.AlignVCenter
+            fontSize: "small"
+            font.bold: true
+            text: PanelState.title
+        }
+
         PanelSeparatorLine {
             id: indicatorOrangeLine
             anchors {
@@ -189,7 +214,7 @@
             id: __callHint
             anchors {
                 top: parent.top
-                left: PanelState.buttonsVisible ? windowControlButtons.right : parent.left
+                left: windowControlButtons.visible ? windowControlButtons.right : parent.left
             }
             height: indicators.minimizedPanelHeight
             visible: active && indicators.state == "initial"

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2015-10-16 17:11:54 +0000
+++ qml/Shell.qml	2015-11-03 11:00:18 +0000
@@ -57,6 +57,7 @@
     property bool beingResized
     property string usageScenario: "phone" // supported values: "phone", "tablet" or "desktop"
     property string mode: "full-greeter"
+    property bool cursorVisible: false
     function updateFocusedAppOrientation() {
         applicationsDisplayLoader.item.updateFocusedAppOrientation();
     }
@@ -536,6 +537,7 @@
 
             fullscreenMode: (topmostApplicationIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)
                             || greeter.hasLockedApp
+            locked: greeter && greeter.active
         }
 
         Launcher {

=== modified file 'qml/Stages/DecoratedWindow.qml'
--- qml/Stages/DecoratedWindow.qml	2015-09-29 23:09:06 +0000
+++ qml/Stages/DecoratedWindow.qml	2015-11-03 11:00:18 +0000
@@ -26,6 +26,7 @@
     property alias window: applicationWindow
     property alias application: applicationWindow.application
     property alias active: decoration.active
+    property alias title: decoration.title
 
     property bool decorationShown: true
     property bool highlightShown: false
@@ -66,7 +67,8 @@
         objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"
         anchors { left: parent.left; top: parent.top; right: parent.right }
         height: units.gu(3)
-        title: window.title !== "" ? window.title : model.name
+        width: root.width
+        title: window.title !== "" ? window.title : ""
         onClose: root.close();
         onMaximize: root.maximize();
         onMinimize: root.minimize();

=== modified file 'qml/Stages/DesktopSpread.qml'
--- qml/Stages/DesktopSpread.qml	2015-09-21 12:22:29 +0000
+++ qml/Stages/DesktopSpread.qml	2015-11-03 11:00:18 +0000
@@ -87,7 +87,7 @@
     function focusSelected() {
         if (spreadRepeater.highlightedIndex != -1) {
             var application = ApplicationManager.get(spreadRepeater.highlightedIndex);
-            ApplicationManager.focusApplication(application.appId);
+            ApplicationManager.requestFocusApplication(application.appId);
         }
     }
 

=== modified file 'qml/Stages/DesktopSpreadDelegate.qml'
--- qml/Stages/DesktopSpreadDelegate.qml	2015-09-18 11:03:48 +0000
+++ qml/Stages/DesktopSpreadDelegate.qml	2015-11-03 11:00:18 +0000
@@ -29,8 +29,8 @@
     property bool highlightShown: false
     property real shadowOpacity: 1
 
-    property int windowWidth: application.session && application.session.surface ? application.session.surface.size.width : 0
-    property int windowHeight: application.session && application.session.surface ? application.session.surface.size.height : 0
+    property int windowWidth: application && application.session && application.session.surface ? application.session.surface.size.width : 0
+    property int windowHeight: application && application.session && application.session.surface ? application.session.surface.size.height : 0
 
     state: "normal"
     states: [

=== modified file 'qml/Stages/DesktopStage.qml'
--- qml/Stages/DesktopStage.qml	2015-10-19 14:27:57 +0000
+++ qml/Stages/DesktopStage.qml	2015-11-03 11:00:18 +0000
@@ -24,6 +24,7 @@
 import "../Components/PanelState"
 import Utils 0.1
 import Ubuntu.Gestures 0.1
+import GlobalShortcut 1.0
 
 Rectangle {
     id: root
@@ -63,21 +64,72 @@
                 spread.state = "";
             }
 
-            ApplicationManager.requestFocusApplication(appId)
+            ApplicationManager.focusApplication(appId);
+        }
+
+        onApplicationRemoved: {
+            priv.focusNext();
         }
 
         onFocusRequested: {
             var appIndex = priv.indexOf(appId);
             var appDelegate = appRepeater.itemAt(appIndex);
-            appDelegate.minimized = false;
-            ApplicationManager.focusApplication(appId)
+            appDelegate.restoreFromMinimized();
 
             if (spread.state == "altTab") {
-                spread.cancel()
+                spread.cancel();
             }
         }
     }
 
+    GlobalShortcut {
+        id: closeWindowShortcut
+        shortcut: Qt.AltModifier|Qt.Key_F4
+        onTriggered: ApplicationManager.stopApplication(priv.focusedAppId)
+        active: priv.focusedAppId !== ""
+    }
+
+    GlobalShortcut {
+        id: showSpreadShortcut
+        shortcut: Qt.MetaModifier|Qt.Key_W
+        onTriggered: spread.state = "altTab"
+    }
+
+    GlobalShortcut {
+        id: minimizeAllShortcut
+        shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_D
+        onTriggered: priv.minimizeAllWindows()
+    }
+
+    GlobalShortcut {
+        id: maximizeWindowShortcut
+        shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_Up
+        onTriggered: priv.focusedAppDelegate.maximize()
+        active: priv.focusedAppDelegate !== null
+    }
+
+    GlobalShortcut {
+        id: maximizeWindowLeftShortcut
+        shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_Left
+        onTriggered: priv.focusedAppDelegate.maximizeLeft()
+        active: priv.focusedAppDelegate !== null
+    }
+
+    GlobalShortcut {
+        id: maximizeWindowRightShortcut
+        shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_Right
+        onTriggered: priv.focusedAppDelegate.maximizeRight()
+        active: priv.focusedAppDelegate !== null
+    }
+
+    GlobalShortcut {
+        id: minimizeRestoreShortcut
+        shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_Down
+        onTriggered: priv.focusedAppDelegate.maximized || priv.focusedAppDelegate.maximizedLeft || priv.focusedAppDelegate.maximizedRight
+                     ? priv.focusedAppDelegate.restore() : priv.focusedAppDelegate.minimize(true)
+        active: priv.focusedAppDelegate !== null
+    }
+
     QtObject {
         id: priv
 
@@ -95,6 +147,28 @@
             }
             return -1;
         }
+
+        function minimizeAllWindows() {
+            for (var i = 0; i < appRepeater.count; i++) {
+                var appDelegate = appRepeater.itemAt(i);
+                if (appDelegate && !appDelegate.minimized) {
+                    appDelegate.minimize(false); // minimize but don't switch focus
+                }
+            }
+
+            ApplicationManager.unfocusCurrentApplication(); // no app should have focus at this point
+        }
+
+        function focusNext() {
+            ApplicationManager.unfocusCurrentApplication();
+            for (var i = 0; i < appRepeater.count; i++) {
+                var appDelegate = appRepeater.itemAt(i);
+                if (appDelegate && !appDelegate.minimized) {
+                    ApplicationManager.focusApplication(appDelegate.appId);
+                    return;
+                }
+            }
+        }
     }
 
     Connections {
@@ -102,15 +176,24 @@
         onClose: {
             ApplicationManager.stopApplication(ApplicationManager.focusedApplicationId)
         }
-        onMinimize: appRepeater.itemAt(0).minimize();
-        onMaximize: appRepeater.itemAt(0).unmaximize();
+        onMinimize: appRepeater.itemAt(0).minimize(true);
+        onMaximize: appRepeater.itemAt(0).restore();
     }
 
     Binding {
         target: PanelState
         property: "buttonsVisible"
-        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.state === "maximized"
-    }
+        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized
+    }
+
+    Binding {
+        target: PanelState
+        property: "title"
+        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.title
+        when: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized
+    }
+
+    Component.onDestruction: PanelState.buttonsVisible = false;
 
     FocusScope {
         id: appContainer
@@ -132,18 +215,32 @@
 
             delegate: FocusScope {
                 id: appDelegate
+                objectName: "appDelegate_" + appId
                 z: ApplicationManager.count - index
                 y: units.gu(3)
                 width: units.gu(60)
                 height: units.gu(50)
-                focus: model.appId === priv.focusedAppId
-
-                property bool maximized: false
-                property bool minimized: false
+                focus: appId === priv.focusedAppId
+
+                QtObject {
+                    id: appDelegatePrivate
+                    property bool maximized: false
+                    property bool maximizedLeft: false
+                    property bool maximizedRight: false
+                    property bool minimized: false
+                }
+                readonly property alias maximized: appDelegatePrivate.maximized
+                readonly property alias maximizedLeft: appDelegatePrivate.maximizedLeft
+                readonly property alias maximizedRight: appDelegatePrivate.maximizedRight
+                readonly property alias minimized: appDelegatePrivate.minimized
+
+                readonly property string appId: model.appId
+                property bool animationsEnabled: true
+                property alias title: decoratedWindow.title
 
                 onFocusChanged: {
-                    if (focus && ApplicationManager.focusedApplicationId !== model.appId) {
-                        ApplicationManager.focusApplication(model.appId);
+                    if (focus && ApplicationManager.focusedApplicationId !== appId) {
+                        ApplicationManager.focusApplication(appId);
                     }
                 }
 
@@ -158,44 +255,92 @@
                     value: ApplicationInfoInterface.RequestedRunning // Always running for now
                 }
 
-                function maximize() {
-                    minimized = false;
-                    maximized = true;
-                }
-                function minimize() {
-                    maximized = false;
-                    minimized = true;
-                }
-                function unmaximize() {
-                    minimized = false;
-                    maximized = false;
+                function maximize(animated) {
+                    animationsEnabled = (animated === undefined) || animated;
+                    appDelegatePrivate.minimized = false;
+                    appDelegatePrivate.maximized = true;
+                    appDelegatePrivate.maximizedLeft = false;
+                    appDelegatePrivate.maximizedRight = false;
+                }
+                function maximizeLeft() {
+                    appDelegatePrivate.minimized = false;
+                    appDelegatePrivate.maximized = false;
+                    appDelegatePrivate.maximizedLeft = true;
+                    appDelegatePrivate.maximizedRight = false;
+                }
+                function maximizeRight() {
+                    appDelegatePrivate.minimized = false;
+                    appDelegatePrivate.maximized = false;
+                    appDelegatePrivate.maximizedLeft = false;
+                    appDelegatePrivate.maximizedRight = true;
+                }
+                function minimize(animated) {
+                    animationsEnabled = (animated === undefined) || animated;
+                    appDelegatePrivate.minimized = true;
+                }
+                function restore(animated) {
+                    animationsEnabled = (animated === undefined) || animated;
+                    appDelegatePrivate.minimized = false;
+                    appDelegatePrivate.maximized = false;
+                    appDelegatePrivate.maximizedLeft = false;
+                    appDelegatePrivate.maximizedRight = false;
+                }
+                function restoreFromMinimized(animated) {
+                    animationsEnabled = (animated === undefined) || animated;
+                    appDelegatePrivate.minimized = false;
+                    if (maximized)
+                        maximize();
+                    else if (maximizedLeft)
+                        maximizeLeft();
+                    else if (maximizedRight)
+                        maximizeRight();
+                    ApplicationManager.focusApplication(appId);
                 }
 
                 states: [
                     State {
                         name: "normal"; when: !appDelegate.maximized && !appDelegate.minimized
+                                              && !appDelegate.maximizedLeft && !appDelegate.maximizedRight
                     },
                     State {
-                        name: "maximized"; when: appDelegate.maximized
+                        name: "maximized"; when: appDelegate.maximized && !appDelegate.minimized
                         PropertyChanges { target: appDelegate; x: 0; y: 0; width: root.width; height: root.height }
                     },
                     State {
+                        name: "maximizedLeft"; when: appDelegate.maximizedLeft && !appDelegate.minimized
+                        PropertyChanges { target: appDelegate; x: 0; y: units.gu(3); width: root.width/2; height: root.height - units.gu(3) }
+                    },
+                    State {
+                        name: "maximizedRight"; when: appDelegate.maximizedRight && !appDelegate.minimized
+                        PropertyChanges { target: appDelegate; x: root.width/2; y: units.gu(3); width: root.width/2; height: root.height - units.gu(3) }
+                    },
+                    State {
                         name: "minimized"; when: appDelegate.minimized
                         PropertyChanges { target: appDelegate; x: -appDelegate.width / 2; scale: units.gu(5) / appDelegate.width; opacity: 0 }
                     }
                 ]
                 transitions: [
                     Transition {
-                        from: "maximized,minimized,normal,"
-                        to: "maximized,minimized,normal,"
-                        PropertyAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale" }
+                        from: "maximized,maximizedLeft,maximizedRight,minimized,normal,"
+                        to: "maximized,maximizedLeft,maximizedRight,minimized,normal,"
+                        enabled: appDelegate.animationsEnabled
+                        SequentialAnimation {
+                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale"; duration: UbuntuAnimation.FastDuration }
+                            ScriptAction {
+                                script: {
+                                    if (animationsEnabled && state === "minimized" ) {
+                                        priv.focusNext();
+                                    }
+                                }
+                            }
+                        }
                     },
                     Transition {
                         from: ""
                         to: "altTab"
                         PropertyAction { target: appDelegate; properties: "y,angle,z,itemScale,itemScaleOriginY" }
                         PropertyAction { target: decoratedWindow; properties: "anchors.topMargin" }
-                        PropertyAnimation {
+                        UbuntuNumberAnimation {
                             target: appDelegate; properties: "x"
                             from: root.width
                             duration: rightEdgePushArea.containsMouse ? UbuntuAnimation.FastDuration :0
@@ -218,6 +363,8 @@
                     minHeight: units.gu(10)
                     borderThickness: units.gu(2)
                     windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing
+                    screenWidth: root.width
+                    screenHeight: root.height
 
                     onPressed: { ApplicationManager.focusApplication(model.appId) }
                 }
@@ -234,8 +381,9 @@
                     focus: true
 
                     onClose: ApplicationManager.stopApplication(model.appId)
-                    onMaximize: appDelegate.maximize()
-                    onMinimize: appDelegate.minimize()
+                    onMaximize: appDelegate.maximized || appDelegate.maximizedLeft || appDelegate.maximizedRight
+                                ? appDelegate.restore() : appDelegate.maximize()
+                    onMinimize: appDelegate.minimize(true)
                     onDecorationPressed: { ApplicationManager.focusApplication(model.appId) }
                 }
             }

=== modified file 'qml/Stages/WindowDecoration.qml'
--- qml/Stages/WindowDecoration.qml	2015-10-19 19:05:23 +0000
+++ qml/Stages/WindowDecoration.qml	2015-11-03 11:00:18 +0000
@@ -18,6 +18,7 @@
 import Unity.Application 0.1 // For Mir singleton
 import Ubuntu.Components 1.1
 import "../Components"
+import "../Components/PanelState"
 
 MouseArea {
     id: root
@@ -45,17 +46,18 @@
             priv.distanceX = pos.x;
             priv.distanceY = pos.y;
             priv.dragging = true;
-            Mir.cursorName = "grabbing";
         } 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 = pos.y - priv.distanceY;
+            root.target.y = Math.max(pos.y - priv.distanceY, PanelState.panelHeight);
         }
     }
 
@@ -70,11 +72,12 @@
     }
 
     Row {
-        anchors { left: parent.left; top: parent.top; bottom: parent.bottom; margins: units.gu(0.7) }
+        anchors { fill: parent; margins: units.gu(0.7) }
         spacing: units.gu(1)
         opacity: root.active ? 1 : 0.5
 
         WindowControlButtons {
+            id: buttons
             height: parent.height
             onClose: root.close();
             onMinimize: root.minimize();
@@ -86,9 +89,11 @@
             objectName: "windowDecorationTitle"
             color: "#DFDBD2"
             height: parent.height
+            width: parent.width - buttons.width - parent.anchors.rightMargin - parent.anchors.leftMargin
             verticalAlignment: Text.AlignVCenter
             fontSize: "small"
             font.bold: true
+            elide: Text.ElideRight
         }
     }
 }

=== modified file 'qml/Stages/WindowResizeArea.qml'
--- qml/Stages/WindowResizeArea.qml	2015-09-29 12:48:46 +0000
+++ qml/Stages/WindowResizeArea.qml	2015-11-03 11:00:18 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 1.1
 import Utils 0.1
 import Unity.Application 0.1 // for Mir.cursorName
+import "../Components/PanelState"
 
 MouseArea {
     id: root
@@ -35,19 +36,52 @@
     property int borderThickness: 0
     property int minWidth: 0
     property int minHeight: 0
+    property int screenWidth: 0
+    property int screenHeight: 0
+
+    QtObject {
+        id: priv
+
+        property int normalX: 0
+        property int normalY: 0
+        property int normalWidth: 0
+        property int normalHeight: 0
+
+        function updateNormalGeometry() {
+            if (root.target.state == "normal") {
+                normalX = root.target.x
+                normalY = root.target.y
+                normalWidth = root.target.width
+                normalHeight = root.target.height
+            }
+        }
+    }
+
+    Connections {
+        target: root.target
+        onXChanged: priv.updateNormalGeometry();
+        onYChanged: priv.updateNormalGeometry();
+        onWidthChanged: priv.updateNormalGeometry();
+        onHeightChanged: priv.updateNormalGeometry();
+    }
 
     Component.onCompleted: {
-        var windowState = windowStateStorage.getGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
-        if (windowState !== undefined) {
-            target.x = windowState.x
-            target.y = windowState.y
-            target.width = windowState.width
-            target.height = windowState.height
+        var windowGeometry = windowStateStorage.getGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
+        if (windowGeometry !== undefined) {
+            target.width = Math.min(windowGeometry.width, root.screenWidth)
+            target.height = Math.min(windowGeometry.height, root.screenHeight - PanelState.panelHeight)
+            target.x = Math.max(Math.min(windowGeometry.x, root.screenWidth - target.width), 0)
+            target.y = Math.max(Math.min(windowGeometry.y, root.screenHeight - target.height), PanelState.panelHeight)
+        }
+        var windowState = windowStateStorage.getState(root.windowId, WindowStateStorage.WindowStateNormal)
+        if (windowState === WindowStateStorage.WindowStateMaximized) {
+            target.maximize(false)
         }
     }
 
     Component.onDestruction: {
-        windowStateStorage.saveGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
+        windowStateStorage.saveState(root.windowId, target.state == "maximized" ? WindowStateStorage.WindowStateMaximized : WindowStateStorage.WindowStateNormal)
+        windowStateStorage.saveGeometry(root.windowId, Qt.rect(priv.normalX, priv.normalY, priv.normalWidth, priv.normalHeight))
     }
 
     QtObject {

=== modified file 'tests/mocks/Utils/windowstatestorage.cpp'
--- tests/mocks/Utils/windowstatestorage.cpp	2015-08-24 15:39:53 +0000
+++ tests/mocks/Utils/windowstatestorage.cpp	2015-11-03 11:00:18 +0000
@@ -44,3 +44,20 @@
     if (!m_geometry.contains(windowId)) return defaultValue;
     return m_geometry.value(windowId).toRect();
 }
+
+void WindowStateStorage::clear()
+{
+    m_state.clear();
+    m_geometry.clear();
+}
+
+void WindowStateStorage::saveState(const QString &windowId, WindowState state)
+{
+    m_state[windowId] = state;
+}
+
+WindowStateStorage::WindowState WindowStateStorage::getState(const QString &windowId, WindowStateStorage::WindowState defaultValue)
+{
+    if (!m_state.contains(windowId)) return defaultValue;
+    return m_state.value(windowId);
+}

=== modified file 'tests/mocks/Utils/windowstatestorage.h'
--- tests/mocks/Utils/windowstatestorage.h	2015-08-24 15:39:53 +0000
+++ tests/mocks/Utils/windowstatestorage.h	2015-11-03 11:00:18 +0000
@@ -22,12 +22,23 @@
 {
     Q_OBJECT
     Q_PROPERTY(QVariantMap geometry READ geometry WRITE setGeometry NOTIFY geometryChanged)
+    Q_ENUMS(WindowState)
 public:
+    enum WindowState {
+        WindowStateNormal,
+        WindowStateMaximized
+    };
     WindowStateStorage(QObject *parent = 0);
 
+    Q_INVOKABLE void saveState(const QString &windowId, WindowState state);
+    Q_INVOKABLE WindowState getState(const QString &windowId, WindowState defaultValue);
+
     Q_INVOKABLE void saveGeometry(const QString &windowId, const QRect &rect);
     Q_INVOKABLE QRect getGeometry(const QString &windowId, const QRect &defaultValue);
 
+    // Only in the mock, to easily restore a fresh state
+    Q_INVOKABLE void clear();
+
 Q_SIGNALS:
     void geometryChanged(const QVariantMap& geometry);
 
@@ -35,5 +46,6 @@
     void setGeometry(const QVariantMap& geometry);
     QVariantMap geometry() const;
 
+    QHash<QString, WindowState> m_state;
     QVariantMap m_geometry;
 };

=== modified file 'tests/qmltests/Stages/tst_DesktopStage.qml'
--- tests/qmltests/Stages/tst_DesktopStage.qml	2015-09-17 12:25:29 +0000
+++ tests/qmltests/Stages/tst_DesktopStage.qml	2015-11-03 11:00:18 +0000
@@ -53,14 +53,10 @@
 
         focus: true
 
-        property bool itemDestroyed: false
         sourceComponent: Component {
             DesktopStage {
                 color: "darkblue"
                 anchors.fill: parent
-                Component.onDestruction: {
-                    desktopStageLoader.itemDestroyed = true;
-                }
             }
         }
     }
@@ -95,16 +91,10 @@
         property Item desktopStage: desktopStageLoader.status === Loader.Ready ? desktopStageLoader.item : null
 
         function cleanup() {
-            desktopStageLoader.itemDestroyed = false;
             desktopStageLoader.active = false;
 
             tryCompare(desktopStageLoader, "status", Loader.Null);
             tryCompare(desktopStageLoader, "item", null);
-            // Loader.status might be Loader.Null and Loader.item might be null but the Loader
-            // actually took place. Likely because Loader waits until the next event loop
-            // iteration to do its work. So to ensure the reload, we will wait until the
-            // Shell instance gets destroyed.
-            tryCompare(desktopStageLoader, "itemDestroyed", true);
 
             killAllRunningApps();
 
@@ -117,7 +107,7 @@
                 var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0
                 ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);
             }
-            compare(ApplicationManager.count, 1)
+            compare(ApplicationManager.count, 1);
         }
 
         function waitUntilAppSurfaceShowsUp(appId) {
@@ -147,10 +137,7 @@
         }
 
         function test_appFocusSwitch(data) {
-            var i;
-            for (i = 0; i < data.apps.length; i++) {
-                startApplication(data.apps[i]);
-            }
+            data.apps.forEach(startApplication);
 
             ApplicationManager.requestFocusApplication(data.apps[data.focusfrom]);
             tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).session.surface, "activeFocus", true);
@@ -167,10 +154,7 @@
         }
 
         function test_tappingOnWindowChangesFocusedApp(data) {
-            var i;
-            for (i = 0; i < data.apps.length; i++) {
-                startApplication(data.apps[i]);
-            }
+            data.apps.forEach(startApplication);
             var fromAppId = data.apps[data.focusfrom];
             var toAppId = data.apps[data.focusTo]
 
@@ -187,18 +171,37 @@
             compare(ApplicationManager.focusedApplicationId, toAppId);
         }
 
+        function test_clickingOnWindowChangesFocusedApp_data() {
+            return test_tappingOnWindowChangesFocusedApp_data(); // reuse test data
+        }
+
+        function test_clickingOnWindowChangesFocusedApp(data) {
+            data.apps.forEach(startApplication);
+            var fromAppId = data.apps[data.focusfrom];
+            var toAppId = data.apps[data.focusTo]
+
+            var fromAppWindow = findChild(desktopStage, "appWindow_" + fromAppId);
+            verify(fromAppWindow);
+            mouseClick(fromAppWindow);
+            compare(fromAppWindow.application.session.surface.activeFocus, true);
+            compare(ApplicationManager.focusedApplicationId, fromAppId);
+
+            var toAppWindow = findChild(desktopStage, "appWindow_" + toAppId);
+            verify(toAppWindow);
+            mouseClick(toAppWindow);
+            compare(toAppWindow.application.session.surface.activeFocus, true);
+            compare(ApplicationManager.focusedApplicationId, toAppId);
+        }
+
         function test_tappingOnDecorationFocusesApplication_data() {
             return [
-                {tag: "dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 0, focusTo: 1 },
-                {tag: "dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 1, focusTo: 0 },
+                {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 0, focusTo: 1 },
+                {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 1, focusTo: 0 },
             ]
         }
 
         function test_tappingOnDecorationFocusesApplication(data) {
-            var i;
-            for (i = 0; i < data.apps.length; i++) {
-                startApplication(data.apps[i]);
-            }
+            data.apps.forEach(startApplication);
 
             var fromAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusfrom]);
             verify(fromAppDecoration);
@@ -210,5 +213,109 @@
             tap(toAppDecoration);
             tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.surface, "activeFocus", true);
         }
+
+        function test_clickingOnDecorationFocusesApplication_data() {
+            return test_tappingOnDecorationFocusesApplication_data(); // reuse test data
+        }
+
+        function test_clickingOnDecorationFocusesApplication(data) {
+            data.apps.forEach(startApplication);
+
+            var fromAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusfrom]);
+            verify(fromAppDecoration);
+            mouseClick(fromAppDecoration);
+            tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).session.surface, "activeFocus", true);
+
+            var toAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusTo]);
+            verify(toAppDecoration);
+            mouseClick(toAppDecoration);
+            tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.surface, "activeFocus", true);
+        }
+
+        function test_windowMaximize() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            var appName = "dialer-app";
+            var appDelegate = findChild(desktopStage, "appDelegate_" + appName);
+            verify(appDelegate);
+            ApplicationManager.focusApplication(appName);
+            keyClick(Qt.Key_Up, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Up shortcut to maximize
+            tryCompare(appDelegate, "maximized", true);
+            tryCompare(appDelegate, "minimized", false);
+        }
+
+        function test_windowMaximizeLeft() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            var appName = "dialer-app";
+            var appDelegate = findChild(desktopStage, "appDelegate_" + appName);
+            verify(appDelegate);
+            ApplicationManager.focusApplication(appName);
+            keyClick(Qt.Key_Left, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Left shortcut to maximizeLeft
+            tryCompare(appDelegate, "maximized", false);
+            tryCompare(appDelegate, "minimized", false);
+            tryCompare(appDelegate, "maximizedLeft", true);
+            tryCompare(appDelegate, "maximizedRight", false);
+        }
+
+        function test_windowMaximizeRight() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            var appName = "dialer-app";
+            var appDelegate = findChild(desktopStage, "appDelegate_" + appName);
+            verify(appDelegate);
+            ApplicationManager.focusApplication(appName);
+            keyClick(Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Right shortcut to maximizeRight
+            tryCompare(appDelegate, "maximized", false);
+            tryCompare(appDelegate, "minimized", false);
+            tryCompare(appDelegate, "maximizedLeft", false);
+            tryCompare(appDelegate, "maximizedRight", true);
+        }
+
+        function test_windowMinimize() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            var appName = "dialer-app";
+            var appDelegate = findChild(desktopStage, "appDelegate_" + appName);
+            verify(appDelegate);
+            ApplicationManager.focusApplication(appName);
+            keyClick(Qt.Key_Down, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+Down shortcut to minimize
+            tryCompare(appDelegate, "maximized", false);
+            tryCompare(appDelegate, "minimized", true);
+            verify(ApplicationManager.focusedApplicationId != ""); // verify we don't lose focus when minimizing an app
+        }
+
+        function test_windowMinimizeAll() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            verify(ApplicationManager.count == 3);
+            keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all
+            tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify no app is focused
+        }
+
+        function test_windowClose() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            verify(ApplicationManager.count == 3);
+            var appName = "dialer-app";
+            var appDelegate = findChild(desktopStage, "appDelegate_" + appName);
+            verify(appDelegate);
+            ApplicationManager.focusApplication(appName);
+            keyClick(Qt.Key_F4, Qt.AltModifier); // Alt+F4 shortcut to close
+            verify(ApplicationManager.count == 2); // verify the app is gone
+            verify(ApplicationManager.findApplication(appName) === null); // and it's not in running apps
+        }
+
+        function test_smashCursorKeys() {
+            var apps = ["unity8-dash", "dialer-app", "camera-app"];
+            apps.forEach(startApplication);
+            verify(ApplicationManager.count == 3);
+            keyClick(Qt.Key_D, Qt.MetaModifier|Qt.ControlModifier); // Ctrl+Super+D shortcut to minimize all
+            tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify no app is focused
+
+            // now try pressing all 4 arrow keys + ctrl + meta
+            keyClick(Qt.Key_Up | Qt.Key_Down | Qt.Key_Left | Qt.Key_Right, Qt.MetaModifier|Qt.ControlModifier); // smash it!!!
+            tryCompare(ApplicationManager, "focusedApplicationId", ""); // verify still no app is focused
+        }
     }
 }

=== modified file 'tests/qmltests/Stages/tst_WindowResizeArea.qml'
--- tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-10-08 14:27:12 +0000
+++ tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-11-03 11:00:18 +0000
@@ -19,6 +19,7 @@
 import QtTest 1.0
 import Unity.Test 0.1
 import ".."
+import "../../../qml/Components/PanelState"
 import "../../../qml/Stages"
 import Ubuntu.Components 0.1
 import Ubuntu.Components.ListItems 1.0 as ListItem
@@ -31,6 +32,12 @@
 
     property var fakeWindow: windowLoader.item
 
+    Binding {
+        target: PanelState
+        property: "panelHeight"
+        value: units.gu(2)
+    }
+
     Component {
         id: fakeWindowComponent
 
@@ -44,8 +51,11 @@
             width: units.gu(20)
             property int windowHeight: height
             property int windowWidth: width
-            onWindowHeightChanged: height = windowHeight
-            onWindowWidthChanged: width = windowWidth
+            state: "normal"
+
+            function maximize() {
+                state = "maximized"
+            }
 
             WindowResizeArea {
                 id: windowResizeArea
@@ -54,6 +64,8 @@
                 minWidth: units.gu(15)
                 minHeight: units.gu(10)
                 windowId: "test-window-id"
+                screenWidth: root.width
+                screenHeight: root.height
             }
 
             Rectangle {
@@ -195,5 +207,69 @@
             tryCompare(fakeWindow, "width", initialWindowWidth);
             tryCompare(fakeWindow, "height", initialWindowHeight);
         }
+
+        function test_saveRestoreMaximized() {
+            var initialWindowX = fakeWindow.x;
+            var initialWindowY = fakeWindow.y;
+
+            var moveDelta = units.gu(5);
+
+            fakeWindow.x = initialWindowX + moveDelta
+            fakeWindow.y = initialWindowY + moveDelta
+
+            // Now change the state to maximized. The window should not keep updating the stored values
+            fakeWindow.state = "maximized"
+            fakeWindow.x = 31415 // 0 is too risky to pass the test even when broken
+            fakeWindow.y = 31415
+
+            // This will destroy the window and recreate it
+            windowLoader.active = false;
+            waitForRendering(root);
+            windowLoader.active = true;
+
+            // Make sure it's again where we left it in normal state before destroying
+            tryCompare(fakeWindow, "x", initialWindowX + moveDelta)
+            tryCompare(fakeWindow, "y", initialWindowX + moveDelta)
+
+            // Make sure maximize() has been called after restoring
+            tryCompare(fakeWindow, "state", "maximized")
+
+            // clean up
+            fakeWindow.state = "normal"
+        }
+
+
+        function test_restoreMovesIntoBounds_data() {
+            return [
+                        {tag: "left off", x: -units.gu(5), y: units.gu(5), w: units.gu(10), h: units.gu(10)},
+                        {tag: "top off", x: units.gu(5), y: -units.gu(5), w: units.gu(10), h: units.gu(10)},
+                        {tag: "right off", x: root.width - units.gu(5), y: units.gu(5), w: units.gu(10), h: units.gu(10)},
+                        {tag: "bottom off", x: units.gu(5), y: root.height - units.gu(5), w: units.gu(10), h: units.gu(10)},
+                        {tag: "width too large", x: units.gu(5), y: units.gu(5), w: root.width * 2, h: units.gu(10)},
+                        {tag: "height too large", x: units.gu(5), y: units.gu(5), w: units.gu(10), h: root.height * 2}
+                ]
+        }
+
+        function test_restoreMovesIntoBounds(data) {
+            fakeWindow.x = data.x;
+            fakeWindow.y = data.y;
+            fakeWindow.width = data.w;
+            fakeWindow.height = data.h;
+            waitForRendering(root);
+
+            // This will destroy the window and recreate it
+            windowLoader.active = false;
+            waitForRendering(root);
+            windowLoader.active = true;
+            waitForRendering(root)
+
+            // Make sure it's again where we left it in normal state before destroying
+            compare(fakeWindow.x >= 0, true)
+            compare(fakeWindow.y >= PanelState.panelHeight, true)
+            compare(fakeWindow.x + fakeWindow.width <= root.width, true)
+            compare(fakeWindow.y + fakeWindow.height <= root.height, true)
+
+            waitForRendering(root)
+        }
     }
 }

=== modified file 'tests/qmltests/tst_Shell.qml'
--- tests/qmltests/tst_Shell.qml	2015-10-20 08:10:03 +0000
+++ tests/qmltests/tst_Shell.qml	2015-11-03 11:00:18 +0000
@@ -29,8 +29,10 @@
 import Unity.Test 0.1
 import Powerd 0.1
 import Wizard 0.1 as Wizard
+import Utils 0.1
 
 import "../../qml"
+import "../../qml/Components/PanelState"
 import "Stages"
 
 Rectangle {
@@ -302,6 +304,7 @@
             mouseEmulation.checked = true;
             tryCompare(shell, "enabled", true); // make sure greeter didn't leave us in disabled state
             tearDown();
+            WindowStateStorage.clear();
         }
 
         function loadShell(formFactor) {
@@ -329,9 +332,9 @@
             var app2 = ApplicationManager.startApplication("webbrowser-app")
             var app3 = ApplicationManager.startApplication("camera-app")
             var app4 = ApplicationManager.startApplication("facebook-webapp")
+            var app7 = ApplicationManager.startApplication("camera-app")
+            var app6 = ApplicationManager.startApplication("gallery-app")
             var app5 = ApplicationManager.startApplication("calendar-app")
-            var app6 = ApplicationManager.startApplication("gallery-app")
-            var app7 = ApplicationManager.startApplication("camera-app")
             waitUntilAppWindowIsFullyLoaded(app7);
         }
 
@@ -1693,11 +1696,11 @@
             keyPress(Qt.Key_Control)
             keyClick(Qt.Key_Tab);
 
-
             tryCompare(desktopSpread, "state", "altTab")
 
-            mouseMove(shell, 0, 0);
+            mouseMove(shell, 0, shell.height / 2);
             tryCompare(launcher, "state", "visibleTemporary")
+            waitForRendering(shell)
 
             mouseClick(bfb, bfb.width / 2, bfb.height / 2)
             tryCompare(launcher, "state", "")
@@ -1707,5 +1710,106 @@
 
             keyRelease(Qt.Key_Control);
         }
+
+        // regression test for http://pad.lv/1443319
+        function test_closeMaximizedAndRestart() {
+            loadDesktopShellWithApps();
+
+            var appRepeater = findChild(shell, "appRepeater")
+            var appId = ApplicationManager.get(0).appId;
+            var appDelegate = appRepeater.itemAt(0);
+            var maximizeButton = findChild(appDelegate, "maximizeWindowButton");
+
+            wait(5000)
+            tryCompare(appDelegate, "state", "normal");
+            tryCompare(PanelState, "buttonsVisible", false)
+
+            wait(5000)
+            mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);
+            tryCompare(appDelegate, "state", "maximized");
+            tryCompare(PanelState, "buttonsVisible", true)
+
+            ApplicationManager.stopApplication(appId);
+            tryCompare(PanelState, "buttonsVisible", false)
+
+            ApplicationManager.startApplication(appId);
+            tryCompare(PanelState, "buttonsVisible", true)
+        }
+
+        // bug http://pad.lv/1431566
+        function test_switchToStagedHidesPanelButtons() {
+            loadDesktopShellWithApps();
+            var appRepeater = findChild(shell, "appRepeater")
+            var appId = ApplicationManager.get(0).appId;
+            var appDelegate = appRepeater.itemAt(0);
+            var panelButtons = findChild(shell, "panelWindowControlButtons")
+
+            tryCompare(appDelegate, "state", "normal");
+            tryCompare(panelButtons, "visible", false);
+
+            appDelegate.maximize(false);
+            tryCompare(panelButtons, "visible", true);
+
+            shell.usageScenario = "phone";
+            waitForRendering(shell);
+            tryCompare(panelButtons, "visible", false);
+
+            shell.usageScenario = "desktop";
+            waitForRendering(shell);
+            tryCompare(panelButtons, "visible", true);
+        }
+
+        function test_lockingGreeterHidesPanelButtons() {
+            loadDesktopShellWithApps();
+            var appRepeater = findChild(shell, "appRepeater")
+            var appId = ApplicationManager.get(0).appId;
+            var appDelegate = appRepeater.itemAt(0);
+            var panelButtons = findChild(shell, "panelWindowControlButtons")
+
+            tryCompare(appDelegate, "state", "normal");
+            tryCompare(panelButtons, "visible", false);
+
+            appDelegate.maximize(false);
+            tryCompare(panelButtons, "visible", true);
+
+            LightDM.Greeter.showGreeter();
+            waitForRendering(shell);
+            tryCompare(panelButtons, "visible", false);
+
+            LightDM.Greeter.hideGreeter();
+            waitForRendering(shell);
+            tryCompare(panelButtons, "visible", true);
+        }
+
+        function test_cantMoveWindowUnderPanel() {
+            loadDesktopShellWithApps();
+            var appRepeater = findChild(shell, "appRepeater")
+            var appDelegate = appRepeater.itemAt(0);
+
+            mousePress(appDelegate, appDelegate.width / 2, units.gu(1))
+            mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))
+
+            compare(appDelegate.y >= PanelState.panelHeight, true);
+        }
+
+        function test_restoreWindowStateFixesIfUnderPanel() {
+            loadDesktopShellWithApps();
+            var appRepeater = findChild(shell, "appRepeater")
+            var appId = ApplicationManager.get(0).appId;
+            var appDelegate = appRepeater.itemAt(0);
+
+            // Move it under the panel programmatically (might happen later with an alt+drag)
+            appDelegate.y = -units.gu(10)
+
+            ApplicationManager.stopApplication(appId)
+            ApplicationManager.startApplication(appId)
+            waitForRendering(shell)
+
+            // Make sure the newly started one is at index 0 again
+            tryCompare(ApplicationManager.get(0), "appId", appId);
+
+            appDelegate = appRepeater.itemAt(0);
+            compare(appDelegate.y >= PanelState.panelHeight, true);
+        }
     }
 }