Merge lp:~unity-team/unity8/disable-flaky-adt into lp:unity8

[Michael Zanetti]

disabling some tests that are flaky in adt but can't be made fail on our machines

[lp:~unity-team/unity8/disable-flaky-adt]

2281. By Michael Zanetti on 2016-03-16

skip not working for some reason

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-03-03 18:41:20 +0000
+++ CMakeLists.txt	2016-03-16 20:46:19 +0000
@@ -57,7 +57,8 @@
 find_package(Qt5Concurrent 5.4 REQUIRED)
 find_package(Qt5Sql 5.4 REQUIRED)
 
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=13)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=14)
+pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)
 pkg_check_modules(GIO REQUIRED gio-2.0>=2.32)
 pkg_check_modules(GLIB REQUIRED glib-2.0>=2.32)
 pkg_check_modules(QMENUMODEL REQUIRED qmenumodel)

=== modified file 'CODING'
--- CODING	2015-06-23 07:51:27 +0000
+++ CODING	2016-03-16 20:46:19 +0000
@@ -54,6 +54,8 @@
 Notes
 -----
 - to navigate, utilize the mouse left button as you would your finger
+- a three point drag (for side stage operations) can be performed by using
+  the Shift+Control+Alt (all together) keyboard modifiers while using the mouse.
 - to get the translations work, currently you have to do make install to
   put the *.mo files into correct structure. We'll look for a better solution
   later.

=== modified file 'debian/control'
--- debian/control	2016-03-10 22:42:34 +0000
+++ debian/control	2016-03-16 20:46:19 +0000
@@ -8,13 +8,14 @@
                doxyqml,
 # To allow cross-compiling to work, we also must append :native
 # to g++ so we don't try to run armhf g++
-# on an x86 CPU for eaxmple, when cross-compiling.
+# on an x86 CPU for example, when cross-compiling.
                g++:native,
                libandroid-properties-dev,
                graphviz,
                gsettings-ubuntu-schemas (>= 0.0.2+14.10.20140815),
                libconnectivity-qt1-dev (>= 0.7.1),
                libevdev-dev,
+               libgeonames-dev (>= 0.2),
                libgl1-mesa-dev[!armhf] | libgl-dev[!armhf],
                libgl1-mesa-dri,
                libgles2-mesa-dev[armhf],
@@ -29,7 +30,7 @@
                libqt5xmlpatterns5-dev,
                libsystemsettings-dev,
                libudev-dev,
-               libunity-api-dev (>= 7.107),
+               libunity-api-dev (>= 7.108),
                libusermetricsoutput1-dev,
 # Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop
                libx11-dev[!armhf],
@@ -101,7 +102,7 @@
          qml-module-qt-labs-folderlistmodel,
          qml-module-qtquick-xmllistmodel,
          qml-module-qtsysteminfo,
-         qtdeclarative5-qtmir-plugin (>= 0.4.5),
+         qtdeclarative5-qtmir-plugin (>= 0.4.8),
          qtdeclarative5-ubuntu-telephony0.1,
          qtdeclarative5-ubuntu-web-plugin,
          ubuntu-system-settings,
@@ -130,7 +131,7 @@
          qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1845) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1845),
          qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
          ubuntu-thumbnailer-impl-0,
-         unity-application-impl-13,
+         unity-application-impl-14,
          unity-notifications-impl-3,
          unity-plugin-scopes | unity-scopes-impl,
          unity-scopes-impl-10,
@@ -176,7 +177,7 @@
 Depends: ${misc:Depends},
          ${shlibs:Depends},
 Provides: unity-application-impl,
-          unity-application-impl-13,
+          unity-application-impl-14,
 Replaces: unity8-autopilot (<< 8.02+15.04.20150422-0ubuntu1)
 Description: Fake environment for running Unity 8 shell
  Provides fake implementations of some QML modules used by Unity 8 shell

=== modified file 'libs/UbuntuGestures/Timer.h'
--- libs/UbuntuGestures/Timer.h	2015-04-24 13:19:24 +0000
+++ libs/UbuntuGestures/Timer.h	2016-03-16 20:46:19 +0000
@@ -35,6 +35,11 @@
     virtual int interval() const = 0;
     virtual void setInterval(int msecs) = 0;
     virtual void start() { m_isRunning = true; }
+    virtual void start(int msecs)
+    {
+        setInterval(msecs);
+        start();
+    }
     virtual void stop() { m_isRunning = false; }
     bool isRunning() const { return m_isRunning; }
     virtual bool isSingleShot() const = 0;

=== modified file 'libs/UbuntuGestures/TouchRegistry.cpp'
--- libs/UbuntuGestures/TouchRegistry.cpp	2015-09-14 09:11:08 +0000
+++ libs/UbuntuGestures/TouchRegistry.cpp	2016-03-16 20:46:19 +0000
@@ -359,10 +359,6 @@
 
 void TouchRegistry::requestTouchOwnership(int id, QQuickItem *candidate)
 {
-    #if TOUCHREGISTRY_DEBUG
-    UG_DEBUG << "requestTouchOwnership id " << id << "candidate" << candidate;
-    #endif
-
     Pool<TouchInfo>::Iterator touchInfo = findTouchInfo(id);
     if (!touchInfo) { qFatal("TouchRegistry: Failed to find TouchInfo"); }
 
@@ -379,6 +375,9 @@
             break;
         }
     }
+    #if TOUCHREGISTRY_DEBUG
+    UG_DEBUG << "requestTouchOwnership id " << id << "candidate" << candidate << "index: " << candidateIndex;
+    #endif
 
     // add it as a candidate if not present yet
     if (candidateIndex < 0) {
@@ -533,16 +532,22 @@
         << " gained) to candidate" << candidates[0].item;
     #endif
 
+    // need to take a copy of the item list in case
+    // we call back in to remove candidate during the lost ownership event.
+    QList<QPointer<QQuickItem>> items;
+    Q_FOREACH(const CandidateInfo& info, candidates) {
+        items << info.item;
+    }
+
     TouchOwnershipEvent gainedOwnershipEvent(id, true /*gained*/);
-    QCoreApplication::sendEvent(candidates[0].item, &gainedOwnershipEvent);
-
+    QCoreApplication::sendEvent(items[0], &gainedOwnershipEvent);
 
     TouchOwnershipEvent lostOwnershipEvent(id, false /*gained*/);
-    for (int i = 1; i < candidates.count(); ++i) {
+    for (int i = 1; i < items.count(); ++i) {
         #if TOUCHREGISTRY_DEBUG
-        UG_DEBUG << "sending TouchWonershipEvent(id =" << id << " lost) to candidate"
-            << candidates[i].item;
+        UG_DEBUG << "sending TouchOwnershipEvent(id =" << id << " lost) to candidate"
+            << items[i];
         #endif
-        QCoreApplication::sendEvent(candidates[i].item, &lostOwnershipEvent);
+        QCoreApplication::sendEvent(items[i], &lostOwnershipEvent);
     }
 }

=== modified file 'plugins/AccountsService/AccountsService.cpp'
--- plugins/AccountsService/AccountsService.cpp	2016-02-25 10:57:17 +0000
+++ plugins/AccountsService/AccountsService.cpp	2016-03-16 20:46:19 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013, 2015 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
@@ -12,8 +12,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Michael Terry <[e-mail]>
  */
 
 #include "AccountsService.h"
@@ -34,6 +32,7 @@
 
 #define PROP_BACKGROUND_FILE                   QStringLiteral("BackgroundFile")
 #define PROP_DEMO_EDGES                        QStringLiteral("demo-edges")
+#define PROP_EMAIL                             QStringLiteral("Email")
 #define PROP_ENABLE_INDICATORS_WHILE_LOCKED    QStringLiteral("EnableIndicatorsWhileLocked")
 #define PROP_ENABLE_LAUNCHER_WHILE_LOCKED      QStringLiteral("EnableLauncherWhileLocked")
 #define PROP_FAILED_LOGINS                     QStringLiteral("FailedLogins")
@@ -44,6 +43,7 @@
 #define PROP_MOUSE_PRIMARY_BUTTON              QStringLiteral("MousePrimaryButton")
 #define PROP_MOUSE_SCROLL_SPEED                QStringLiteral("MouseScrollSpeed")
 #define PROP_PASSWORD_DISPLAY_HINT             QStringLiteral("PasswordDisplayHint")
+#define PROP_REAL_NAME                         QStringLiteral("RealName")
 #define PROP_STATS_WELCOME_SCREEN              QStringLiteral("StatsWelcomeScreen")
 #define PROP_TOUCHPAD_CURSOR_SPEED             QStringLiteral("TouchpadCursorSpeed")
 #define PROP_TOUCHPAD_DISABLE_WHILE_TYPING     QStringLiteral("TouchpadDisableWhileTyping")
@@ -80,6 +80,8 @@
     connect(m_service, &AccountsServiceDBusAdaptor::maybeChanged, this, &AccountsService::onMaybeChanged);
 
     registerProperty(IFACE_ACCOUNTS_USER, PROP_BACKGROUND_FILE, QStringLiteral("backgroundFileChanged"));
+    registerProperty(IFACE_ACCOUNTS_USER, PROP_EMAIL, QStringLiteral("emailChanged"));
+    registerProperty(IFACE_ACCOUNTS_USER, PROP_REAL_NAME, QStringLiteral("realNameChanged"));
     registerProperty(IFACE_LOCATION_HERE, PROP_LICENSE_ACCEPTED, QStringLiteral("hereEnabledChanged"));
     registerProperty(IFACE_LOCATION_HERE, PROP_LICENSE_BASE_PATH, QStringLiteral("hereLicensePathChanged"));
     registerProperty(IFACE_UBUNTU_SECURITY, PROP_ENABLE_LAUNCHER_WHILE_LOCKED, QStringLiteral("enableLauncherWhileLockedChanged"));
@@ -206,6 +208,28 @@
     return !value.toString().isNull();
 }
 
+QString AccountsService::realName() const
+{
+    auto value = getProperty(IFACE_ACCOUNTS_USER, PROP_REAL_NAME);
+    return value.toString();
+}
+
+void AccountsService::setRealName(const QString &realName)
+{
+    setProperty(IFACE_ACCOUNTS_USER, PROP_REAL_NAME, realName);
+}
+
+QString AccountsService::email() const
+{
+    auto value = getProperty(IFACE_ACCOUNTS_USER, PROP_EMAIL);
+    return value.toString();
+}
+
+void AccountsService::setEmail(const QString &email)
+{
+    setProperty(IFACE_ACCOUNTS_USER, PROP_EMAIL, email);
+}
+
 uint AccountsService::failedLogins() const
 {
     return getProperty(IFACE_UNITY_PRIVATE, PROP_FAILED_LOGINS).toUInt();

=== modified file 'plugins/AccountsService/AccountsService.h'
--- plugins/AccountsService/AccountsService.h	2016-02-25 10:57:17 +0000
+++ plugins/AccountsService/AccountsService.h	2016-03-16 20:46:19 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013, 2015 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
@@ -12,8 +12,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Michael Terry <[e-mail]>
  */
 
 #ifndef UNITY_ACCOUNTSSERVICE_H
@@ -68,6 +66,8 @@
     Q_PROPERTY(bool hereLicensePathValid // qml sees a null string as "", so we use proxy setting for that
                READ hereLicensePathValid
                NOTIFY hereLicensePathChanged)
+    Q_PROPERTY(QString realName READ realName WRITE setRealName NOTIFY realNameChanged)
+    Q_PROPERTY(QString email READ email WRITE setEmail NOTIFY emailChanged)
 
 public:
     enum PasswordDisplayHint {
@@ -93,6 +93,10 @@
     void setHereEnabled(bool enabled);
     QString hereLicensePath() const;
     bool hereLicensePathValid() const;
+    QString realName() const;
+    void setRealName(const QString &realName);
+    QString email() const;
+    void setEmail(const QString &email);
 
 Q_SIGNALS:
     void userChanged();
@@ -105,6 +109,8 @@
     void failedLoginsChanged();
     void hereEnabledChanged();
     void hereLicensePathChanged();
+    void realNameChanged();
+    void emailChanged();
 
 private Q_SLOTS:
     void onPropertiesChanged(const QString &user, const QString &interface, const QStringList &changed);

=== added file 'plugins/Cursor/Cursor.qmltypes'
--- plugins/Cursor/Cursor.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/Cursor.qmltypes	2016-03-16 20:46:19 +0000
@@ -0,0 +1,78 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable Cursor 1.0 plugins'
+
+Module {
+    Component {
+        name: "MirMousePointerInterface"
+        defaultProperty: "data"
+        prototype: "QQuickItem"
+        Property { name: "cursorName"; type: "string"; isReadonly: true }
+        Property { name: "themeName"; type: "string"; isReadonly: true }
+        Property { name: "hotspotX"; type: "double"; isReadonly: true }
+        Property { name: "hotspotY"; type: "double"; isReadonly: true }
+        Signal {
+            name: "cursorNameChanged"
+            Parameter { name: "name"; type: "string" }
+        }
+        Signal {
+            name: "themeNameChanged"
+            Parameter { name: "name"; type: "string" }
+        }
+        Signal {
+            name: "hotspotXChanged"
+            Parameter { name: "value"; type: "double" }
+        }
+        Signal {
+            name: "hotspotYChanged"
+            Parameter { name: "value"; type: "double" }
+        }
+        Method {
+            name: "handleMouseEvent"
+            Parameter { name: "timestamp"; type: "ulong" }
+            Parameter { name: "movement"; type: "QPointF" }
+            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
+            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
+        }
+        Method {
+            name: "handleWheelEvent"
+            Parameter { name: "timestamp"; type: "ulong" }
+            Parameter { name: "angleDelta"; type: "QPoint" }
+            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
+        }
+    }
+    Component {
+        name: "MousePointer"
+        defaultProperty: "data"
+        prototype: "MirMousePointerInterface"
+        exports: ["Cursor/MousePointer 1.0"]
+        exportMetaObjectRevisions: [0]
+        Signal {
+            name: "pushedLeftBoundary"
+            Parameter { name: "amount"; type: "double" }
+            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
+        }
+        Signal {
+            name: "pushedRightBoundary"
+            Parameter { name: "amount"; type: "double" }
+            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
+        }
+        Method {
+            name: "handleMouseEvent"
+            Parameter { name: "timestamp"; type: "ulong" }
+            Parameter { name: "movement"; type: "QPointF" }
+            Parameter { name: "buttons"; type: "Qt::MouseButtons" }
+            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
+        }
+        Method {
+            name: "handleWheelEvent"
+            Parameter { name: "timestamp"; type: "ulong" }
+            Parameter { name: "angleDelta"; type: "QPoint" }
+            Parameter { name: "modifiers"; type: "Qt::KeyboardModifiers" }
+        }
+    }
+}

=== added file 'plugins/GlobalShortcut/GlobalShortcut.qmltypes'
--- plugins/GlobalShortcut/GlobalShortcut.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/GlobalShortcut/GlobalShortcut.qmltypes	2016-03-16 20:46:19 +0000
@@ -0,0 +1,31 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable GlobalShortcut 1.0 plugins'
+
+Module {
+    Component {
+        name: "GlobalShortcut"
+        defaultProperty: "data"
+        prototype: "QQuickItem"
+        exports: ["GlobalShortcut/GlobalShortcut 1.0"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "shortcut"; type: "QVariant" }
+        Property { name: "active"; type: "bool" }
+        Signal {
+            name: "shortcutChanged"
+            Parameter { name: "shortcut"; type: "QVariant" }
+        }
+        Signal {
+            name: "triggered"
+            Parameter { name: "shortcut"; type: "string" }
+        }
+        Signal {
+            name: "activeChanged"
+            Parameter { name: "active"; type: "bool" }
+        }
+    }
+}

=== modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
--- plugins/Ubuntu/Gestures/CMakeLists.txt	2015-05-27 09:37:34 +0000
+++ plugins/Ubuntu/Gestures/CMakeLists.txt	2016-03-16 20:46:19 +0000
@@ -11,6 +11,7 @@
     PressedOutsideNotifier.cpp
     TouchDispatcher.cpp
     TouchGate.cpp
+    TouchGestureArea.cpp
 )
 
 add_definitions(-DUBUNTUGESTURESQML_LIBRARY)

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2015-12-16 18:28:21 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2016-03-16 20:46:19 +0000
@@ -606,6 +606,9 @@
             Q_EMIT q->pressedChanged(true);
             break;
         case Recognized:
+            if (oldStatus == WaitingForTouch) { // for immediate recognition
+                Q_EMIT q->pressedChanged(true);
+            }
             Q_EMIT q->draggingChanged(true);
             break;
         default:

=== modified file 'plugins/Ubuntu/Gestures/Gestures.qmltypes'
--- plugins/Ubuntu/Gestures/Gestures.qmltypes	2015-02-13 09:01:16 +0000
+++ plugins/Ubuntu/Gestures/Gestures.qmltypes	2016-03-16 20:46:19 +0000
@@ -34,7 +34,8 @@
                 "Leftwards": 1,
                 "Downwards": 2,
                 "Upwards": 3,
-                "Horizontal": 4
+                "Horizontal": 4,
+                "Vertical": 5
             }
         }
         Method {
@@ -59,14 +60,6 @@
         prototype: "QQuickItem"
         exports: ["Ubuntu.Gestures/DirectionalDragArea 0.1"]
         exportMetaObjectRevisions: [0]
-        Enum {
-            name: "Status"
-            values: {
-                "WaitingForTouch": 0,
-                "Undecided": 1,
-                "Recognized": 2
-            }
-        }
         Property { name: "direction"; type: "Direction::Type" }
         Property { name: "distance"; type: "double"; isReadonly: true }
         Property { name: "sceneDistance"; type: "double"; isReadonly: true }
@@ -74,27 +67,22 @@
         Property { name: "touchY"; type: "double"; isReadonly: true }
         Property { name: "touchSceneX"; type: "double"; isReadonly: true }
         Property { name: "touchSceneY"; type: "double"; isReadonly: true }
-        Property { name: "status"; type: "Status"; isReadonly: true }
         Property { name: "dragging"; type: "bool"; isReadonly: true }
-        Property { name: "maxDeviation"; type: "double" }
-        Property { name: "wideningAngle"; type: "double" }
-        Property { name: "distanceThreshold"; type: "double" }
-        Property { name: "minSpeed"; type: "double" }
-        Property { name: "maxSilenceTime"; type: "int" }
-        Property { name: "compositionTime"; type: "int" }
+        Property { name: "pressed"; type: "bool"; isReadonly: true }
+        Property { name: "immediateRecognition"; type: "bool" }
         Signal {
             name: "directionChanged"
             Parameter { name: "direction"; type: "Direction::Type" }
         }
         Signal {
-            name: "statusChanged"
-            Parameter { name: "value"; type: "Status" }
-        }
-        Signal {
             name: "draggingChanged"
             Parameter { name: "value"; type: "bool" }
         }
         Signal {
+            name: "pressedChanged"
+            Parameter { name: "value"; type: "bool" }
+        }
+        Signal {
             name: "distanceChanged"
             Parameter { name: "value"; type: "double" }
         }
@@ -103,30 +91,6 @@
             Parameter { name: "value"; type: "double" }
         }
         Signal {
-            name: "maxDeviationChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "wideningAngleChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "distanceThresholdChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "minSpeedChanged"
-            Parameter { name: "value"; type: "double" }
-        }
-        Signal {
-            name: "maxSilenceTimeChanged"
-            Parameter { name: "value"; type: "int" }
-        }
-        Signal {
-            name: "compositionTimeChanged"
-            Parameter { name: "value"; type: "int" }
-        }
-        Signal {
             name: "touchXChanged"
             Parameter { name: "value"; type: "double" }
         }
@@ -142,7 +106,35 @@
             name: "touchSceneYChanged"
             Parameter { name: "value"; type: "double" }
         }
-        Signal { name: "tapped" }
+        Signal {
+            name: "immediateRecognitionChanged"
+            Parameter { name: "value"; type: "bool" }
+        }
+        Method { name: "removeTimeConstraints" }
+    }
+    Component {
+        name: "FloatingFlickable"
+        defaultProperty: "data"
+        prototype: "QQuickItem"
+        exports: ["Ubuntu.Gestures/FloatingFlickable 0.1"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "contentWidth"; type: "double" }
+        Property { name: "contentHeight"; type: "double" }
+        Property { name: "contentX"; type: "double" }
+        Property { name: "contentY"; type: "double" }
+        Property { name: "direction"; type: "Direction::Type" }
+    }
+    Component {
+        name: "GestureTouchPoint"
+        prototype: "QObject"
+        exports: ["Ubuntu.Gestures/GestureTouchPoint 0.1"]
+        isCreatable: false
+        exportMetaObjectRevisions: [0]
+        Property { name: "pointId"; type: "int"; isReadonly: true }
+        Property { name: "pressed"; type: "bool"; isReadonly: true }
+        Property { name: "x"; type: "double"; isReadonly: true }
+        Property { name: "y"; type: "double"; isReadonly: true }
+        Property { name: "dragging"; type: "bool"; isReadonly: true }
     }
     Component {
         name: "PressedOutsideNotifier"
@@ -163,6 +155,55 @@
             name: "targetItemChanged"
             Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
         }
-        Signal { name: "pressed" }
+    }
+    Component {
+        name: "TouchGestureArea"
+        defaultProperty: "data"
+        prototype: "QQuickItem"
+        exports: ["Ubuntu.Gestures/TouchGestureArea 0.1"]
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "Status"
+            values: {
+                "WaitingForTouch": 0,
+                "Undecided": 1,
+                "Recognized": 2,
+                "Rejected": 3
+            }
+        }
+        Property { name: "touchPoints"; type: "GestureTouchPoint"; isList: true; isReadonly: true }
+        Property { name: "dragging"; type: "bool"; isReadonly: true }
+        Property { name: "minimumTouchPoints"; type: "int" }
+        Property { name: "maximumTouchPoints"; type: "int" }
+        Signal {
+            name: "statusChanged"
+            Parameter { name: "status"; type: "Status" }
+        }
+        Signal { name: "touchPointsUpdated" }
+        Signal {
+            name: "draggingChanged"
+            Parameter { name: "dragging"; type: "bool" }
+        }
+        Signal {
+            name: "minimumTouchPointsChanged"
+            Parameter { name: "value"; type: "bool" }
+        }
+        Signal {
+            name: "maximumTouchPointsChanged"
+            Parameter { name: "value"; type: "bool" }
+        }
+        Signal {
+            name: "pressed"
+            Parameter { name: "points"; type: "QList<QObject*>" }
+        }
+        Signal {
+            name: "released"
+            Parameter { name: "points"; type: "QList<QObject*>" }
+        }
+        Signal {
+            name: "updated"
+            Parameter { name: "points"; type: "QList<QObject*>" }
+        }
+        Signal { name: "clicked" }
     }
 }

=== added file 'plugins/Ubuntu/Gestures/TouchGestureArea.cpp'
--- plugins/Ubuntu/Gestures/TouchGestureArea.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/TouchGestureArea.cpp	2016-03-16 20:46:19 +0000
@@ -0,0 +1,875 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TouchGestureArea.h"
+
+// local
+#include "TouchOwnershipEvent.h"
+#include "TouchRegistry.h"
+#include "UnownedTouchEvent.h"
+
+#include <QGuiApplication>
+#include <QStyleHints>
+#include <private/qquickwindow_p.h>
+
+#define TOUCHGESTUREAREA_DEBUG 0
+
+// TODO - understand more about why we lose touch event releases.
+// Workaround for now is to monitor all the touch points from first touch till
+// all have been released; no matter if we've rejected the gesture.
+
+namespace {
+
+struct InternalStatus {
+    enum Status {
+        WaitingForTouch,
+        WaitingForMoreTouches,
+        WaitingForOwnership, //Recognizing,
+        Recognized,
+        WaitingForRejection,
+        Rejected
+    };
+};
+
+TouchGestureArea::Status internalStatusToGestureStatus(int internalStatus) {
+    switch (internalStatus) {
+        case InternalStatus::WaitingForTouch: return TouchGestureArea::WaitingForTouch;
+        case InternalStatus::WaitingForMoreTouches: return TouchGestureArea::Undecided;
+        case InternalStatus::WaitingForOwnership: return TouchGestureArea::Undecided;
+        case InternalStatus::Recognized: return TouchGestureArea::Recognized;
+        case InternalStatus::WaitingForRejection: return TouchGestureArea::Recognized;
+        case InternalStatus::Rejected: return TouchGestureArea::Rejected;
+    }
+    return TouchGestureArea::WaitingForTouch;
+}
+
+}
+
+#if TOUCHGESTUREAREA_DEBUG
+#define tgaDebug(params) qDebug().nospace() << "[TGA(" << qPrintable(objectName()) << ")] " << params
+#include "DebugHelpers.h"
+
+namespace {
+
+const char *statusToString(int status)
+{
+    if (status == InternalStatus::WaitingForTouch) {
+        return "WaitingForTouch";
+    } else if (status == InternalStatus::WaitingForMoreTouches) {
+        return "WaitingForMoreTouches";
+    } else if (status == InternalStatus::WaitingForOwnership) {
+        return "WaitingForOwnership";
+    } else if (status == InternalStatus::Rejected) {
+        return "Rejected";
+    } else if (status == InternalStatus::WaitingForRejection) {
+        return "WaitingForRejection";
+    } else {
+        return "Recognized";
+    }
+    return "Unknown";
+}
+
+QString touchState(Qt::TouchPointState state) {
+    switch (state) {
+        case Qt::TouchPointPressed: return "pressed";
+        case Qt::TouchPointMoved: return "moved";
+        case Qt::TouchPointStationary: return "stationary";
+        case Qt::TouchPointReleased: return "released";
+        break;
+    }
+    return "unknown";
+}
+
+QString touchesString(const QList<QObject*> touches) {
+    QString str;
+    Q_FOREACH(QObject* object, touches) {
+        GestureTouchPoint* touchPoint = qobject_cast<GestureTouchPoint*>(object);
+        if (touchPoint) {
+            str += QStringLiteral("[%1 @ (%2, %3)], ").arg(touchPoint->id())
+                                                      .arg(touchPoint->x())
+                                                      .arg(touchPoint->y());
+        }
+    }
+    return str;
+}
+
+QString touchEventString(QTouchEvent* event) {
+    if (!event) return QString();
+    QString str;
+    Q_FOREACH(const auto& touchPoint, event->touchPoints()) {
+        str += QStringLiteral("[%1:%2 @ (%3, %4)], ").arg(touchPoint.id())
+                                                     .arg(touchState(touchPoint.state()))
+                                                     .arg(touchPoint.pos().x())
+                                                     .arg(touchPoint.pos().y());
+    }
+    return str;
+}
+
+
+} // namespace {
+#else // TOUCHGESTUREAREA_DEBUG
+#define tgaDebug(params) ((void)0)
+#endif // TOUCHGESTUREAREA_DEBUG
+
+TouchGestureArea::TouchGestureArea(QQuickItem* parent)
+    : QQuickItem(parent)
+    , m_status(WaitingForTouch)
+    , m_recognitionTimer(nullptr)
+    , m_dragging(false)
+    , m_minimumTouchPoints(1)
+    , m_maximumTouchPoints(INT_MAX)
+    , m_recognitionPeriod(50)
+    , m_releaseRejectPeriod(100)
+{
+    setRecognitionTimer(new UbuntuGestures::Timer(this));
+    m_recognitionTimer->setInterval(m_recognitionPeriod);
+    m_recognitionTimer->setSingleShot(true);
+}
+
+TouchGestureArea::~TouchGestureArea()
+{
+    clearTouchLists();
+    qDeleteAll(m_liveTouchPoints);
+    m_liveTouchPoints.clear();
+    qDeleteAll(m_cachedTouchPoints);
+    m_cachedTouchPoints.clear();
+}
+
+bool TouchGestureArea::event(QEvent *event)
+{
+    // Process unowned touch events (handles update/release for incomplete gestures)
+    if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
+        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
+        return true;
+    } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
+        unownedTouchEvent(static_cast<UnownedTouchEvent *>(event)->touchEvent());
+        return true;
+    }
+
+    return QQuickItem::event(event);
+}
+
+void TouchGestureArea::touchOwnershipEvent(TouchOwnershipEvent *event)
+{
+    int touchId = event->touchId();
+    tgaDebug("touchOwnershipEvent - id:" << touchId << ", gained:" << event->gained());
+
+    if (event->gained()) {
+        grabTouchPoints(QVector<int>() << touchId);
+        m_candidateTouches.remove(touchId);
+        TouchRegistry::instance()->addTouchWatcher(touchId, this);
+        m_watchedTouches.insert(touchId);
+
+        if (m_watchedTouches.count() >= m_minimumTouchPoints) {
+            setInternalStatus(InternalStatus::Recognized);
+        }
+    } else {
+        rejectGesture();
+    }
+}
+
+void TouchGestureArea::touchEvent(QTouchEvent *event)
+{
+    if (!isEnabled() || !isVisible()) {
+        tgaDebug(QString("NOT ENABLED touchEvent(%1) %2").arg(statusToString(m_status)).arg(touchEventString(event)));
+        QQuickItem::touchEvent(event);
+        return;
+    }
+
+    tgaDebug(QString("touchEvent(%1) %2").arg(statusToString(m_status)).arg(touchEventString(event)));
+
+    switch (m_status) {
+        case InternalStatus::WaitingForTouch:
+            touchEvent_waitingForTouch(event);
+            break;
+        case InternalStatus::WaitingForMoreTouches:
+            touchEvent_waitingForMoreTouches(event);
+            break;
+        case InternalStatus::WaitingForOwnership:
+            touchEvent_waitingForOwnership(event);
+            break;
+        case InternalStatus::Recognized:
+        case InternalStatus::WaitingForRejection:
+            touchEvent_recognized(event);
+            break;
+        case InternalStatus::Rejected:
+            touchEvent_rejected(event);
+            break;
+        default: // Recognized:
+            break;
+    }
+
+    updateTouchPoints(event);
+}
+
+void TouchGestureArea::touchEvent_waitingForTouch(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_candidateTouches.contains(touchId)) {
+                TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, this);
+                m_candidateTouches.insert(touchId);
+            }
+        }
+    }
+    event->ignore();
+
+    if (m_candidateTouches.count() > m_maximumTouchPoints) {
+        rejectGesture();
+    } else if (m_candidateTouches.count() >= m_minimumTouchPoints) {
+        setInternalStatus(InternalStatus::WaitingForOwnership);
+
+        QSet<int> tmpCandidates(m_candidateTouches);
+        Q_FOREACH(int candidateTouchId, tmpCandidates) {
+            TouchRegistry::instance()->requestTouchOwnership(candidateTouchId, this);
+        }
+        // We accept the gesture; so don't pass to lower items
+        event->accept();
+    } else if (m_candidateTouches.count() > 0) {
+        setInternalStatus(InternalStatus::WaitingForMoreTouches);
+    }
+}
+
+void TouchGestureArea::touchEvent_waitingForMoreTouches(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_candidateTouches.contains(touchId)) {
+                TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, this);
+                m_candidateTouches.insert(touchId);
+            }
+        }
+    }
+    event->ignore();
+
+    if (m_candidateTouches.count() > m_maximumTouchPoints) {
+        rejectGesture();
+    } else if (m_candidateTouches.count() >= m_minimumTouchPoints) {
+        setInternalStatus(InternalStatus::WaitingForOwnership);
+
+        QSet<int> tmpCandidates(m_candidateTouches);
+        Q_FOREACH(int candidateTouchId, tmpCandidates) {
+            TouchRegistry::instance()->requestTouchOwnership(candidateTouchId, this);
+        }
+        // We accept the gesture; so don't pass to lower items
+        event->accept();
+    }
+}
+
+void TouchGestureArea::touchEvent_waitingForOwnership(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_watchedTouches.contains(touchId)) {
+                TouchRegistry::instance()->addTouchWatcher(touchId, this);
+                m_watchedTouches.insert(touchId);
+            }
+        }
+    }
+}
+
+void TouchGestureArea::touchEvent_recognized(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_watchedTouches.contains(touchId)) {
+                TouchRegistry::instance()->addTouchWatcher(touchId, this);
+                m_watchedTouches.insert(touchId);
+            }
+        }
+    }
+
+    if (m_watchedTouches.count() > m_maximumTouchPoints) {
+        rejectGesture();
+    } else if (m_watchedTouches.count() >= m_minimumTouchPoints &&
+               m_status==InternalStatus::WaitingForRejection) {
+        setInternalStatus(InternalStatus::Recognized);
+    }
+}
+
+void TouchGestureArea::touchEvent_rejected(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_watchedTouches.contains(touchId)) {
+                TouchRegistry::instance()->addTouchWatcher(touchId, this);
+                m_watchedTouches.insert(touchId);
+            }
+        }
+    }
+}
+
+void TouchGestureArea::unownedTouchEvent(QTouchEvent *unownedTouchEvent)
+{
+    tgaDebug(QString("unownedTouchEvent(%1) %2").arg(statusToString(m_status)).arg(touchEventString(unownedTouchEvent)));
+
+    // Only monitor unowned touch events for presses/releases
+    if ((unownedTouchEvent->touchPointStates() & (Qt::TouchPointPressed|Qt::TouchPointReleased)) == 0) {
+        return;
+    }
+
+    switch (m_status) {
+        case InternalStatus::WaitingForTouch:
+            break;
+        case InternalStatus::WaitingForMoreTouches:
+            unownedTouchEvent_waitingForMoreTouches(unownedTouchEvent);
+            // do nothing
+            break;
+        case InternalStatus::WaitingForOwnership:
+            unownedTouchEvent_waitingForOwnership(unownedTouchEvent);
+            break;
+        case InternalStatus::Recognized:
+        case InternalStatus::WaitingForRejection:
+            unownedTouchEvent_recognised(unownedTouchEvent);
+            break;
+        case InternalStatus::Rejected:
+            unownedTouchEvent_rejected(unownedTouchEvent);
+            break;
+        default:
+            break;
+    }
+
+    updateTouchPoints(unownedTouchEvent);
+}
+
+void TouchGestureArea::unownedTouchEvent_waitingForMoreTouches(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointReleased) {
+            if (m_candidateTouches.contains(touchId)) {
+                TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, this);
+                m_candidateTouches.remove(touchId);
+            }
+        }
+    }
+
+    if (m_candidateTouches.count() == 0) {
+        setInternalStatus(InternalStatus::WaitingForTouch);
+    }
+}
+
+void TouchGestureArea::unownedTouchEvent_waitingForOwnership(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointReleased) {
+            if (m_candidateTouches.contains(touchId)) {
+                TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, this);
+                m_candidateTouches.remove(touchId);
+            }
+            if (m_watchedTouches.contains(touchId)) {
+                m_watchedTouches.remove(touchId);
+            }
+        }
+    }
+
+    if (m_candidateTouches.count() + m_watchedTouches.count() == 0) {
+        setInternalStatus(InternalStatus::WaitingForTouch);
+    }
+}
+
+void TouchGestureArea::unownedTouchEvent_recognised(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointReleased) {
+            if (m_watchedTouches.contains(touchId)) {
+                m_watchedTouches.remove(touchId);
+            }
+        }
+    }
+
+    if (m_watchedTouches.count() < m_minimumTouchPoints && m_status==InternalStatus::Recognized) {
+       setInternalStatus(InternalStatus::WaitingForRejection);
+    }
+}
+
+void TouchGestureArea::unownedTouchEvent_rejected(QTouchEvent *event)
+{
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, event->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState == Qt::TouchPointPressed) {
+            if (!m_watchedTouches.contains(touchId)) {
+                TouchRegistry::instance()->addTouchWatcher(touchId, this);
+                m_watchedTouches.insert(touchId);
+            }
+        }
+        if (touchPointState == Qt::TouchPointReleased) {
+            if (m_watchedTouches.contains(touchId)) {
+                m_watchedTouches.remove(touchId);
+            }
+        }
+    }
+
+    if (m_watchedTouches.count() == 0) {
+        setInternalStatus(InternalStatus::WaitingForTouch);
+    }
+}
+
+void TouchGestureArea::updateTouchPoints(QTouchEvent *touchEvent)
+{
+    bool added = false;
+    bool ended = false;
+    bool moved = false;
+
+    const int dragThreshold = qApp->styleHints()->startDragDistance();
+    const int dragVelocity = qApp->styleHints()->startDragVelocity();
+
+    clearTouchLists();
+    bool updateable = m_status != InternalStatus::WaitingForRejection;
+
+    Q_FOREACH(const QTouchEvent::TouchPoint& touchPoint, touchEvent->touchPoints()) {
+        Qt::TouchPointState touchPointState = touchPoint.state();
+        int touchId = touchPoint.id();
+
+        if (touchPointState & Qt::TouchPointReleased) {
+            GestureTouchPoint* gtp = m_liveTouchPoints.value(touchId);
+            if (!gtp) continue;
+
+            gtp->setPos(touchPoint.pos());
+            gtp->setPressed(false);
+            m_releasedTouchPoints.append(gtp);
+            m_liveTouchPoints.remove(touchId);
+
+            if (updateable) {
+                if (m_cachedTouchPoints.contains(touchId)) {
+                    GestureTouchPoint* cachedPoint = m_cachedTouchPoints.take(touchId);
+                    cachedPoint->deleteLater();
+                }
+            }
+            ended = true;
+        } else {
+            GestureTouchPoint* gtp = m_liveTouchPoints.value(touchPoint.id(), nullptr);
+            if (!gtp) {
+                gtp = addTouchPoint(&touchPoint);
+                m_pressedTouchPoints.append(gtp);
+
+                if (updateable) {
+                    if (m_cachedTouchPoints.contains(touchId)) {
+                        m_cachedTouchPoints[touchId]->setPos(touchPoint.pos());
+                    } else {
+                        m_cachedTouchPoints[touchId] = new GestureTouchPoint(*gtp);
+                    }
+                }
+                added = true;
+            } else if (touchPointState & Qt::TouchPointMoved) {
+                gtp->setPos(touchPoint.pos());
+                m_movedTouchPoints.append(gtp);
+                moved = true;
+
+                const QPointF &currentPos = touchPoint.scenePos();
+                const QPointF &startPos = touchPoint.startScenePos();
+
+                bool overDragThreshold = false;
+                bool supportsVelocity = (touchEvent->device()->capabilities() & QTouchDevice::Velocity) && dragVelocity;
+                overDragThreshold |= qAbs(currentPos.x() - startPos.x()) > dragThreshold ||
+                                     qAbs(currentPos.y() - startPos.y()) > dragThreshold;
+                if (supportsVelocity) {
+                    QVector2D velocityVec = touchPoint.velocity();
+                    overDragThreshold |= qAbs(velocityVec.x()) > dragVelocity;
+                    overDragThreshold |= qAbs(velocityVec.y()) > dragVelocity;
+                }
+
+                if (overDragThreshold) {
+                    gtp->setDragging(true);
+                }
+
+                if (updateable) {
+                    if (m_cachedTouchPoints.contains(touchId)) {
+                        m_cachedTouchPoints[touchId]->setPos(touchPoint.pos());
+                        if (overDragThreshold) {
+                            m_cachedTouchPoints[touchId]->setDragging(true);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (updateable) {
+        if (!dragging() && m_status == InternalStatus::Recognized) {
+            bool allWantDrag = !m_liveTouchPoints.isEmpty();
+            Q_FOREACH(auto point, m_liveTouchPoints) {
+                allWantDrag &= point->dragging();
+            }
+            // only dragging if all points are dragging.
+            if (allWantDrag) {
+                setDragging(true);
+            }
+        }
+
+        if (ended) {
+            if (m_liveTouchPoints.isEmpty()) {
+                if (!dragging()) Q_EMIT clicked();
+                setDragging(false);
+            }
+            tgaDebug("Released " << touchesString(m_releasedTouchPoints));
+            Q_EMIT released(m_releasedTouchPoints);
+        }
+        if (added) {
+            tgaDebug("Pressed " << touchesString(m_pressedTouchPoints));
+            Q_EMIT pressed(m_pressedTouchPoints);
+        }
+        if (moved) {
+            tgaDebug("Updated " << touchesString(m_movedTouchPoints));
+            Q_EMIT updated(m_movedTouchPoints);
+        }
+        if (added || ended || moved) {
+            Q_EMIT touchPointsUpdated();
+        }
+    }
+}
+
+void TouchGestureArea::clearTouchLists()
+{
+    Q_FOREACH (QObject *gtp, m_releasedTouchPoints) {
+        delete gtp;
+    }
+    m_releasedTouchPoints.clear();
+    m_pressedTouchPoints.clear();
+    m_movedTouchPoints.clear();
+}
+
+void TouchGestureArea::setInternalStatus(uint newStatus)
+{
+    if (newStatus == m_status)
+        return;
+
+    uint oldStatus = m_status;
+
+    m_status = newStatus;
+    Q_EMIT statusChanged(status());
+
+    if (oldStatus == InternalStatus::WaitingForMoreTouches || oldStatus == InternalStatus::WaitingForRejection) {
+        m_recognitionTimer->stop();
+    }
+
+    tgaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
+
+    switch (newStatus) {
+        case InternalStatus::WaitingForTouch:
+            resyncCachedTouchPoints();
+            break;
+        case InternalStatus::WaitingForMoreTouches:
+            m_recognitionTimer->start(m_recognitionPeriod);
+            break;
+        case InternalStatus::Recognized:
+            resyncCachedTouchPoints();
+            break;
+        case InternalStatus::WaitingForRejection:
+            m_recognitionTimer->start(m_releaseRejectPeriod);
+            break;
+        case InternalStatus::Rejected:
+            resyncCachedTouchPoints();
+            break;
+        default:
+            // no-op
+            break;
+    }
+}
+
+void TouchGestureArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
+{
+    int interval = 0;
+    bool timerWasRunning = false;
+    bool wasSingleShot = false;
+
+    // can be null when called from the constructor
+    if (m_recognitionTimer) {
+        interval = m_recognitionTimer->interval();
+        timerWasRunning = m_recognitionTimer->isRunning();
+        if (m_recognitionTimer->parent() == this) {
+            delete m_recognitionTimer;
+        }
+    }
+
+    m_recognitionTimer = timer;
+    timer->setInterval(interval);
+    timer->setSingleShot(wasSingleShot);
+    connect(timer, SIGNAL(timeout()),
+            this, SLOT(rejectGesture()));
+    if (timerWasRunning) {
+        m_recognitionTimer->start();
+    }
+}
+
+int TouchGestureArea::status() const
+{
+    return internalStatusToGestureStatus(m_status);
+}
+
+bool TouchGestureArea::dragging() const
+{
+    return m_dragging;
+}
+
+QQmlListProperty<GestureTouchPoint> TouchGestureArea::touchPoints()
+{
+    return QQmlListProperty<GestureTouchPoint>(this,
+                                                    0,
+                                                    nullptr,
+                                                    TouchGestureArea::touchPoint_count,
+                                                    TouchGestureArea::touchPoint_at,
+                                               0);
+}
+
+int TouchGestureArea::minimumTouchPoints() const
+{
+    return m_minimumTouchPoints;
+}
+
+void TouchGestureArea::setMinimumTouchPoints(int value)
+{
+    if (m_minimumTouchPoints != value) {
+        m_minimumTouchPoints = value;
+        Q_EMIT minimumTouchPointsChanged(value);
+    }
+}
+
+int TouchGestureArea::maximumTouchPoints() const
+{
+    return m_maximumTouchPoints;
+}
+
+void TouchGestureArea::setMaximumTouchPoints(int value)
+{
+    if (m_maximumTouchPoints != value) {
+        m_maximumTouchPoints = value;
+        Q_EMIT maximumTouchPointsChanged(value);
+    }
+}
+
+int TouchGestureArea::recognitionPeriod() const
+{
+    return m_recognitionPeriod;
+}
+
+void TouchGestureArea::setRecognitionPeriod(int value)
+{
+    if (value != m_recognitionPeriod) {
+        m_recognitionPeriod = value;
+        Q_EMIT recognitionPeriodChanged(value);
+    }
+}
+
+int TouchGestureArea::releaseRejectPeriod() const
+{
+    return m_releaseRejectPeriod;
+}
+
+void TouchGestureArea::setReleaseRejectPeriod(int value)
+{
+    if (value != m_releaseRejectPeriod) {
+        m_releaseRejectPeriod = value;
+        Q_EMIT releaseRejectPeriodChanged(value);
+    }
+}
+
+void TouchGestureArea::rejectGesture()
+{
+    tgaDebug("rejectGesture");
+    ungrabTouchPoints();
+
+    Q_FOREACH(int touchId, m_candidateTouches) {
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, this);
+    }
+
+    // Monitor the candidates
+    Q_FOREACH(int touchId, m_candidateTouches) {
+        TouchRegistry::instance()->addTouchWatcher(touchId, this);
+        m_watchedTouches.insert(touchId);
+    }
+    m_candidateTouches.clear();
+
+    if (m_watchedTouches.count() == 0) {
+        setInternalStatus(InternalStatus::WaitingForTouch);
+    } else {
+        setInternalStatus(InternalStatus::Rejected);
+    }
+}
+
+void TouchGestureArea::resyncCachedTouchPoints()
+{
+    clearTouchLists();
+
+    bool added = false;
+    bool ended = false;
+    bool moved = false;
+    bool wantsDrag = false;
+
+    // list of deletes
+    QMutableHashIterator<int, GestureTouchPoint*> removeIter(m_cachedTouchPoints);
+    while(removeIter.hasNext()) {
+        removeIter.next();
+        if (!m_liveTouchPoints.contains(removeIter.key())) {
+            m_releasedTouchPoints.append(removeIter.value());
+            removeIter.remove();
+            ended = true;
+        }
+    }
+
+    // list of adds/moves
+    Q_FOREACH(GestureTouchPoint* touchPoint, m_liveTouchPoints) {
+        if (m_cachedTouchPoints.contains(touchPoint->id())) {
+            GestureTouchPoint* cachedPoint = m_cachedTouchPoints[touchPoint->id()];
+
+            if (*cachedPoint != *touchPoint) {
+                *cachedPoint = *touchPoint;
+                m_movedTouchPoints.append(touchPoint);
+                moved = true;
+            }
+        } else {
+            m_cachedTouchPoints.insert(touchPoint->id(), new GestureTouchPoint(*touchPoint));
+            m_pressedTouchPoints.append(touchPoint);
+            added = true;
+        }
+    }
+
+    if (wantsDrag && !dragging()) {
+        setDragging(true);
+    }
+
+    if (ended) {
+        if (m_cachedTouchPoints.isEmpty()) {
+            if (!dragging()) Q_EMIT clicked();
+            setDragging(false);
+        }
+        tgaDebug("Cached Release " << touchesString(m_releasedTouchPoints));
+        Q_EMIT released(m_releasedTouchPoints);
+    }
+    if (added) {
+        tgaDebug("Cached Press " << touchesString(m_pressedTouchPoints));
+        Q_EMIT pressed(m_pressedTouchPoints);
+    }
+    if (moved) {
+        tgaDebug("Cached Update " << touchesString(m_movedTouchPoints));
+        Q_EMIT updated(m_movedTouchPoints);
+    }
+    if (added || ended || moved) Q_EMIT touchPointsUpdated();
+}
+
+int TouchGestureArea::touchPoint_count(QQmlListProperty<GestureTouchPoint> *list)
+{
+    TouchGestureArea *q = static_cast<TouchGestureArea*>(list->object);
+    return q->m_cachedTouchPoints.count();
+}
+
+GestureTouchPoint *TouchGestureArea::touchPoint_at(QQmlListProperty<GestureTouchPoint> *list, int index)
+{
+    TouchGestureArea *q = static_cast<TouchGestureArea*>(list->object);
+    return (q->m_cachedTouchPoints.begin()+index).value();
+}
+
+GestureTouchPoint* TouchGestureArea::addTouchPoint(QTouchEvent::TouchPoint const* tp)
+{
+    GestureTouchPoint* gtp = new GestureTouchPoint();
+    gtp->setId(tp->id());
+    gtp->setPressed(true);
+    gtp->setPos(tp->pos());
+    m_liveTouchPoints.insert(tp->id(), gtp);
+    return gtp;
+}
+
+void TouchGestureArea::itemChange(ItemChange change, const ItemChangeData &value)
+{
+    if (change == QQuickItem::ItemSceneChange) {
+        if (value.window != nullptr) {
+            value.window->installEventFilter(TouchRegistry::instance());
+        }
+    }
+}
+
+void TouchGestureArea::setDragging(bool dragging)
+{
+    if (m_dragging == dragging)
+        return;
+
+    tgaDebug("setDragging " << dragging);
+
+    m_dragging = dragging;
+    Q_EMIT draggingChanged(m_dragging);
+}
+
+void GestureTouchPoint::setId(int id)
+{
+    if (m_id == id)
+        return;
+    m_id = id;
+    Q_EMIT idChanged();
+}
+
+void GestureTouchPoint::setPressed(bool pressed)
+{
+    if (m_pressed == pressed)
+        return;
+    m_pressed = pressed;
+    Q_EMIT pressedChanged();
+}
+
+void GestureTouchPoint::setX(qreal x)
+{
+    if (m_x == x)
+        return;
+    m_x = x;
+    Q_EMIT xChanged();
+}
+
+void GestureTouchPoint::setY(qreal y)
+{
+    if (m_y == y)
+        return;
+    m_y = y;
+    Q_EMIT yChanged();
+}
+
+void GestureTouchPoint::setDragging(bool dragging)
+{
+    if (m_dragging == dragging)
+        return;
+
+    m_dragging = dragging;
+    Q_EMIT draggingChanged();
+}
+
+void GestureTouchPoint::setPos(const QPointF &pos)
+{
+    setX(pos.x());
+    setY(pos.y());
+}

=== added file 'plugins/Ubuntu/Gestures/TouchGestureArea.h'
--- plugins/Ubuntu/Gestures/TouchGestureArea.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/TouchGestureArea.h	2016-03-16 20:46:19 +0000
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TOUCHGESTUREAREA_H
+#define TOUCHGESTUREAREA_H
+
+#include "UbuntuGesturesQmlGlobal.h"
+
+#include <QQuickItem>
+
+// lib UbuntuGestures
+#include <Timer.h>
+
+class TouchOwnershipEvent;
+class UnownedTouchEvent;
+
+class GestureTouchPoint : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int id READ id NOTIFY idChanged)
+    Q_PROPERTY(bool pressed READ pressed NOTIFY pressedChanged)
+    Q_PROPERTY(qreal x READ x NOTIFY xChanged)
+    Q_PROPERTY(qreal y READ y NOTIFY yChanged)
+    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
+public:
+    GestureTouchPoint()
+        : m_id(-1)
+        , m_pressed(false)
+        , m_x(0)
+        , m_y(0)
+        , m_dragging(false)
+    {
+    }
+
+    GestureTouchPoint(const GestureTouchPoint& other)
+    : QObject(nullptr)
+    {
+        operator=(other);
+    }
+
+    int id() const { return m_id; }
+    void setId(int id);
+
+    bool pressed() const { return m_pressed; }
+    void setPressed(bool pressed);
+
+    qreal x() const { return m_x; }
+    void setX(qreal x);
+
+    qreal y() const { return m_y; }
+    void setY(qreal y);
+
+    bool dragging() const { return m_dragging; }
+    void setDragging(bool dragging);
+
+    GestureTouchPoint& operator=(const GestureTouchPoint& rhs) {
+        if (&rhs == this) return *this;
+        m_id = rhs.m_id;
+        m_pressed = rhs.m_pressed;
+        m_x = rhs.m_x;
+        m_y = rhs.m_y;
+        m_dragging = rhs.m_dragging;
+        return *this;
+    }
+
+    bool operator=(const GestureTouchPoint& rhs) const {
+        if (&rhs == this) return true;
+        return m_id == rhs.m_id &&
+                m_pressed == rhs.m_pressed &&
+                m_x == rhs.m_x &&
+                m_y == rhs.m_y &&
+                m_dragging == rhs.m_dragging;
+    }
+    bool operator!=(const GestureTouchPoint& rhs) const { return !operator=(rhs); }
+
+    void setPos(const QPointF &pos);
+
+Q_SIGNALS:
+    void idChanged();
+    void pressedChanged();
+    void xChanged();
+    void yChanged();
+    void draggingChanged();
+
+private:
+    int m_id;
+    bool m_pressed;
+    qreal m_x;
+    qreal m_y;
+    bool m_dragging;
+};
+
+/*
+ An area that detects multi-finger gestures.
+
+ We can use this to detect gestures contstrained by a minimim and/or maximum number of touch points.
+ This components uses the touch registry to apply for ownership of touch points.
+ This way we can use the component in conjuntion with the directional drag area to compete for ownwership
+ or gestures; unlike the MultiPointTouchArea.
+ */
+class UBUNTUGESTURESQML_EXPORT TouchGestureArea : public QQuickItem
+{
+    Q_OBJECT
+    Q_ENUMS(Status)
+
+    Q_PROPERTY(int status READ status NOTIFY statusChanged)
+    Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
+    Q_PROPERTY(QQmlListProperty<GestureTouchPoint> touchPoints READ touchPoints NOTIFY touchPointsUpdated)
+
+    Q_PROPERTY(int minimumTouchPoints READ minimumTouchPoints WRITE setMinimumTouchPoints NOTIFY minimumTouchPointsChanged)
+    Q_PROPERTY(int maximumTouchPoints READ maximumTouchPoints WRITE setMaximumTouchPoints NOTIFY maximumTouchPointsChanged)
+
+    // Time(ms) the component will wait for after receiving an initial touch to recognise a gesutre before rejecting it.
+    Q_PROPERTY(int recognitionPeriod READ recognitionPeriod WRITE setRecognitionPeriod NOTIFY recognitionPeriodChanged)
+    // Time(ms) the component will allow a recognised gesture to intermitently release a touch point before rejecting the gesture.
+    // This is so we will not immediately reject a gesture if there are fleeting touch point releases while dragging.
+    Q_PROPERTY(int releaseRejectPeriod READ releaseRejectPeriod WRITE setReleaseRejectPeriod NOTIFY releaseRejectPeriodChanged)
+
+public:
+    // Describes the state of the touch gesture area.
+    enum Status {
+        WaitingForTouch,
+        Undecided,
+        Recognized,
+        Rejected
+    };
+    TouchGestureArea(QQuickItem* parent = NULL);
+    ~TouchGestureArea();
+
+    bool event(QEvent *e) override;
+
+    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
+
+    int status() const;
+    bool dragging() const;
+    QQmlListProperty<GestureTouchPoint> touchPoints();
+
+    int minimumTouchPoints() const;
+    void setMinimumTouchPoints(int value);
+
+    int maximumTouchPoints() const;
+    void setMaximumTouchPoints(int value);
+
+    int recognitionPeriod() const;
+    void setRecognitionPeriod(int value);
+
+    int releaseRejectPeriod() const;
+    void setReleaseRejectPeriod(int value);
+
+Q_SIGNALS:
+    void statusChanged(int status);
+
+    void touchPointsUpdated();
+    void draggingChanged(bool dragging);
+    void minimumTouchPointsChanged(bool value);
+    void maximumTouchPointsChanged(bool value);
+    void recognitionPeriodChanged(bool value);
+    void releaseRejectPeriodChanged(bool value);
+
+    void pressed(const QList<QObject*>& points);
+    void released(const QList<QObject*>& points);
+    void updated(const QList<QObject*>& points);
+    void clicked();
+
+protected:
+    void itemChange(ItemChange change, const ItemChangeData &value);
+
+private Q_SLOTS:
+    void rejectGesture();
+
+private:
+    void touchEvent(QTouchEvent *event) override;
+    void touchEvent_waitingForTouch(QTouchEvent *event);
+    void touchEvent_waitingForMoreTouches(QTouchEvent *event);
+    void touchEvent_waitingForOwnership(QTouchEvent *event);
+    void touchEvent_recognized(QTouchEvent *event);
+    void touchEvent_rejected(QTouchEvent *event);
+
+    void unownedTouchEvent(QTouchEvent *unownedTouchEvent);
+    void unownedTouchEvent_waitingForMoreTouches(QTouchEvent *unownedTouchEvent);
+    void unownedTouchEvent_waitingForOwnership(QTouchEvent *unownedTouchEvent);
+    void unownedTouchEvent_recognised(QTouchEvent *unownedTouchEvent);
+    void unownedTouchEvent_rejected(QTouchEvent *unownedTouchEvent);
+
+    void touchOwnershipEvent(TouchOwnershipEvent *event);
+    void updateTouchPoints(QTouchEvent *event);
+
+    GestureTouchPoint* addTouchPoint(const QTouchEvent::TouchPoint *tp);
+    void clearTouchLists();
+    void setDragging(bool dragging);
+    void setInternalStatus(uint status);
+    void resyncCachedTouchPoints();
+
+    static int touchPoint_count(QQmlListProperty<GestureTouchPoint> *list);
+    static GestureTouchPoint* touchPoint_at(QQmlListProperty<GestureTouchPoint> *list, int index);
+
+    uint m_status;
+    QSet<int> m_candidateTouches;
+    QSet<int> m_watchedTouches;
+    UbuntuGestures::AbstractTimer *m_recognitionTimer;
+
+    bool m_dragging;
+    QHash<int, GestureTouchPoint*> m_liveTouchPoints;
+    QHash<int, GestureTouchPoint*> m_cachedTouchPoints;
+    QList<QObject*> m_releasedTouchPoints;
+    QList<QObject*> m_pressedTouchPoints;
+    QList<QObject*> m_movedTouchPoints;
+    int m_minimumTouchPoints;
+    int m_maximumTouchPoints;
+    int m_recognitionPeriod;
+    int m_releaseRejectPeriod;
+};
+
+QML_DECLARE_TYPE(GestureTouchPoint)
+
+#endif // TOUCHGESTUREAREA_H

=== modified file 'plugins/Ubuntu/Gestures/plugin.cpp'
--- plugins/Ubuntu/Gestures/plugin.cpp	2015-05-27 09:37:34 +0000
+++ plugins/Ubuntu/Gestures/plugin.cpp	2016-03-16 20:46:19 +0000
@@ -21,6 +21,7 @@
 #include "FloatingFlickable.h"
 #include "PressedOutsideNotifier.h"
 #include "TouchGate.h"
+#include "TouchGestureArea.h"
 
 #include <qqml.h>
 
@@ -38,4 +39,6 @@
     qmlRegisterType<FloatingFlickable>(uri, 0, 1, "FloatingFlickable");
     qmlRegisterType<PressedOutsideNotifier>(uri, 0, 1, "PressedOutsideNotifier");
     qmlRegisterType<TouchGate>(uri, 0, 1, "TouchGate");
+    qmlRegisterType<TouchGestureArea>(uri, 0, 1, "TouchGestureArea");
+    qmlRegisterUncreatableType<GestureTouchPoint>(uri, 0, 1, "GestureTouchPoint", "Cannot create GestureTouchPoints");
 }

=== added file 'plugins/Unity/InputInfo/InputInfo.qmltypes'
--- plugins/Unity/InputInfo/InputInfo.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/InputInfo.qmltypes	2016-03-16 20:46:19 +0000
@@ -0,0 +1,71 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable Unity.InputInfo 0.1 plugins'
+
+Module {
+    Component {
+        name: "QDeclarativeInputDeviceModel"
+        prototype: "QAbstractListModel"
+        exports: ["Unity.InputInfo/InputDeviceModel 0.1"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "deviceFilter"; type: "QInputDevice::InputType" }
+        Property { name: "count"; type: "int"; isReadonly: true }
+        Signal {
+            name: "deviceAdded"
+            Parameter { name: "devicePath"; type: "string" }
+        }
+        Signal {
+            name: "deviceRemoved"
+            Parameter { name: "devicePath"; type: "string" }
+        }
+        Signal {
+            name: "deviceFilterChanged"
+            Parameter { name: "filter"; type: "QInputDevice::InputType" }
+        }
+        Method { name: "updateDeviceList" }
+        Method {
+            name: "indexOf"
+            type: "int"
+            Parameter { name: "devicePath"; type: "string" }
+        }
+        Method {
+            name: "get"
+            type: "QInputDevice*"
+            Parameter { name: "index"; type: "int" }
+        }
+    }
+    Component {
+        name: "QInputDevice"
+        prototype: "QObject"
+        exports: ["Unity.InputInfo/InputInfo 0.1"]
+        exportMetaObjectRevisions: [0]
+        Enum {
+            name: "InputType"
+            values: {
+                "Unknown": 0,
+                "Button": 1,
+                "Mouse": 2,
+                "TouchPad": 4,
+                "TouchScreen": 8,
+                "Keyboard": 16,
+                "Switch": 32
+            }
+        }
+        Enum {
+            name: "InputTypeFlags"
+            values: {
+                "Unknown": 0,
+                "Button": 1,
+                "Mouse": 2,
+                "TouchPad": 4,
+                "TouchScreen": 8,
+                "Keyboard": 16,
+                "Switch": 32
+            }
+        }
+    }
+}

=== added file 'plugins/Unity/Platform/Platform.qmltypes'
--- plugins/Unity/Platform/Platform.qmltypes	1970-01-01 00:00:00 +0000
+++ plugins/Unity/Platform/Platform.qmltypes	2016-03-16 20:46:19 +0000
@@ -0,0 +1,20 @@
+import QtQuick.tooling 1.1
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by:
+// 'qmlplugindump -notrelocatable Unity.Platform 1.0 plugins'
+
+Module {
+    Component {
+        name: "Platform"
+        prototype: "QObject"
+        exports: ["Unity.Platform/Platform 1.0"]
+        isCreatable: false
+        isSingleton: true
+        exportMetaObjectRevisions: [0]
+        Property { name: "chassis"; type: "string"; isReadonly: true }
+        Property { name: "isPC"; type: "bool"; isReadonly: true }
+    }
+}

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2016-02-11 16:59:40 +0000
+++ plugins/Utils/CMakeLists.txt	2016-03-16 20:46:19 +0000
@@ -24,6 +24,7 @@
     timezoneFormatter.cpp
     inputeventgenerator.cpp
     deviceconfigparser.cpp
+    globalfunctions.cpp
     plugin.cpp
     )
 

=== added file 'plugins/Utils/globalfunctions.cpp'
--- plugins/Utils/globalfunctions.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Utils/globalfunctions.cpp	2016-03-16 20:46:19 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "globalfunctions.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-pedantic"
+#include <private/qquickitem_p.h>
+#pragma GCC diagnostic pop
+#include <QQmlEngine>
+
+GlobalFunctions::GlobalFunctions(QObject *parent)
+    : QObject(parent)
+{
+}
+
+QQuickItem *GlobalFunctions::itemAt(QQuickItem* parent, int x, int y, QJSValue matcher)
+{
+    if (!parent) return nullptr;
+    QList<QQuickItem *> children = QQuickItemPrivate::get(parent)->paintOrderChildItems();
+
+    for (int i = children.count() - 1; i >= 0; --i) {
+        QQuickItem *child = children.at(i);
+
+        // Map coordinates to the child element's coordinate space
+        QPointF point = parent->mapToItem(child, QPointF(x, y));
+        if (child->isVisible() && point.x() >= 0
+                && child->width() >= point.x()
+                && point.y() >= 0
+                && child->height() >= point.y()) {
+            if (!matcher.isCallable()) return child;
+
+            QQmlEngine* engine = qmlEngine(child);
+            if (!engine) return child;
+
+            QJSValue newObj = engine->newQObject(child);
+            if (matcher.call(QJSValueList() << newObj).toBool()) {
+                return child;
+            }
+        }
+    }
+    return nullptr;
+}

=== added file 'plugins/Utils/globalfunctions.h'
--- plugins/Utils/globalfunctions.h	1970-01-01 00:00:00 +0000
+++ plugins/Utils/globalfunctions.h	2016-03-16 20:46:19 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef GLOBALFUNCTIONS_H
+#define GLOBALFUNCTIONS_H
+
+#include <QObject>
+#include <QJSValue>
+class QQuickItem;
+
+/**
+ * @brief The GlobalFunctions class
+ *
+ * This singleton class exposes utility functions to QML
+ *
+ */
+class GlobalFunctions : public QObject
+{
+    Q_OBJECT
+public:
+    explicit GlobalFunctions(QObject *parent = 0);
+
+    static Q_INVOKABLE QQuickItem* itemAt(QQuickItem* parent,
+                                          int x,
+                                          int y,
+                                          QJSValue matcher);
+};
+
+#endif // GLOBALFUNCTIONS_H

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2016-02-11 16:59:40 +0000
+++ plugins/Utils/plugin.cpp	2016-03-16 20:46:19 +0000
@@ -38,6 +38,7 @@
 #include "applicationsfiltermodel.h"
 #include "inputeventgenerator.h"
 #include "deviceconfigparser.h"
+#include "globalfunctions.h"
 
 static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
 {
@@ -53,6 +54,13 @@
     return new Constants();
 }
 
+static QObject *createGlobalFunctions(QQmlEngine *engine, QJSEngine *scriptEngine)
+{
+    Q_UNUSED(engine)
+    Q_UNUSED(scriptEngine)
+    return new GlobalFunctions();
+}
+
 void UtilsPlugin::registerTypes(const char *uri)
 {
     Q_ASSERT(uri == QLatin1String("Utils"));
@@ -72,6 +80,7 @@
     qmlRegisterType<ApplicationsFilterModel>(uri, 0, 1, "ApplicationsFilterModel");
     qmlRegisterType<InputEventGenerator>(uri, 0, 1, "InputEventGenerator");
     qmlRegisterType<DeviceConfigParser>(uri, 0, 1, "DeviceConfigParser");
+    qmlRegisterSingletonType<GlobalFunctions>(uri, 0, 1, "Functions", createGlobalFunctions);
 }
 
 void UtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'plugins/Utils/timezoneFormatter.cpp'
--- plugins/Utils/timezoneFormatter.cpp	2015-11-20 15:01:39 +0000
+++ plugins/Utils/timezoneFormatter.cpp	2016-03-16 20:46:19 +0000
@@ -33,3 +33,13 @@
     }
     return QString();
 }
+
+QString TimezoneFormatter::currentTimeInTimezoneWithAbbrev(const QVariant &tzId) const
+{
+    QTimeZone tz(tzId.toByteArray());
+    if (tz.isValid()) {
+        const QDateTime now = QDateTime::currentDateTime().toTimeZone(tz);
+        return QStringLiteral("%1 %2").arg(now.time().toString(QStringLiteral("h:mm"))).arg(tz.abbreviation(now));
+    }
+    return QString();
+}

=== modified file 'plugins/Utils/timezoneFormatter.h'
--- plugins/Utils/timezoneFormatter.h	2015-09-17 13:42:15 +0000
+++ plugins/Utils/timezoneFormatter.h	2016-03-16 20:46:19 +0000
@@ -27,6 +27,7 @@
     ~TimezoneFormatter() = default;
 
     Q_INVOKABLE QString currentTimeInTimezone(const QVariant &tzId) const;
+    Q_INVOKABLE QString currentTimeInTimezoneWithAbbrev(const QVariant &tzId) const;
 };
 
 #endif

=== modified file 'plugins/Utils/windowstatestorage.cpp'
--- plugins/Utils/windowstatestorage.cpp	2015-11-20 15:01:39 +0000
+++ plugins/Utils/windowstatestorage.cpp	2016-03-16 20:46:19 +0000
@@ -23,9 +23,14 @@
 #include <QSqlError>
 #include <QSqlResult>
 #include <QRect>
+#include <unity/shell/application/ApplicationInfoInterface.h>
 
 QMutex WindowStateStorage::s_mutex;
 
+inline QString sanitiseString(QString string) {
+    return string.remove("\"").remove("'").remove("\\");
+}
+
 WindowStateStorage::WindowStateStorage(QObject *parent):
     QObject(parent)
 {
@@ -50,7 +55,7 @@
 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(sanitiseString(windowId))
             .arg((int)state);
 
     saveValue(queryString);
@@ -59,7 +64,7 @@
 WindowStateStorage::WindowState WindowStateStorage::getState(const QString &windowId, WindowStateStorage::WindowState defaultValue) const
 {
     const QString queryString = QStringLiteral("SELECT * FROM state WHERE windowId = '%1';")
-            .arg(windowId);
+            .arg(sanitiseString(windowId));
 
     QSqlQuery query = getValue(queryString);
 
@@ -72,7 +77,7 @@
 void WindowStateStorage::saveGeometry(const QString &windowId, const QRect rect)
 {
     const QString queryString = QStringLiteral("INSERT OR REPLACE INTO geometry (windowId, x, y, width, height) values ('%1', '%2', '%3', '%4', '%5');")
-            .arg(windowId)
+            .arg(sanitiseString(windowId))
             .arg(rect.x())
             .arg(rect.y())
             .arg(rect.width())
@@ -81,6 +86,28 @@
     saveValue(queryString);
 }
 
+void WindowStateStorage::saveStage(const QString &appId, int stage)
+{
+    const QString queryString = QStringLiteral("INSERT OR REPLACE INTO stage (appId, stage) values ('%1', '%2');")
+            .arg(sanitiseString(appId))
+            .arg((int)stage);
+
+    saveValue(queryString);
+}
+
+int WindowStateStorage::getStage(const QString &appId) const
+{
+    const QString queryString = QStringLiteral("SELECT * FROM stage WHERE appId = '%1';")
+            .arg(sanitiseString(appId));
+
+    QSqlQuery query = getValue(queryString);
+
+    if (!query.first()) {
+        return unity::shell::application::ApplicationInfoInterface::MainStage;
+    }
+    return query.value("stage").toInt();
+}
+
 void WindowStateStorage::executeAsyncQuery(const QString &queryString)
 {
     QMutexLocker l(&s_mutex);
@@ -97,7 +124,7 @@
 QRect WindowStateStorage::getGeometry(const QString &windowId, const QRect defaultValue) const
 {
     QString queryString = QStringLiteral("SELECT * FROM geometry WHERE windowId = '%1';")
-            .arg(windowId);
+            .arg(sanitiseString(windowId));
 
     QSqlQuery query = getValue(queryString);
 
@@ -124,6 +151,11 @@
         QSqlQuery query;
         query.exec(QStringLiteral("CREATE TABLE state(windowId TEXT UNIQUE, state INTEGER);"));
     }
+
+    if (!m_db.tables().contains(QStringLiteral("stage"))) {
+        QSqlQuery query;
+        query.exec(QStringLiteral("CREATE TABLE stage(appId TEXT UNIQUE, stage INTEGER);"));
+    }
 }
 
 void WindowStateStorage::saveValue(const QString &queryString)

=== modified file 'plugins/Utils/windowstatestorage.h'
--- plugins/Utils/windowstatestorage.h	2015-11-20 15:01:39 +0000
+++ plugins/Utils/windowstatestorage.h	2016-03-16 20:46:19 +0000
@@ -38,6 +38,9 @@
     Q_INVOKABLE void saveGeometry(const QString &windowId, const QRect rect);
     Q_INVOKABLE QRect getGeometry(const QString &windowId, const QRect defaultValue) const;
 
+    Q_INVOKABLE void saveStage(const QString &appId, int stage);
+    Q_INVOKABLE int getStage(const QString &appId) const;
+
 private:
     void initdb();
 

=== modified file 'plugins/Wizard/CMakeLists.txt'
--- plugins/Wizard/CMakeLists.txt	2014-11-14 17:47:00 +0000
+++ plugins/Wizard/CMakeLists.txt	2016-03-16 20:46:19 +0000
@@ -1,10 +1,16 @@
+include_directories(${GLIB_INCLUDE_DIRS} ${GEONAMES_INCLUDE_DIRS})
+
 add_library(Wizard-qml MODULE
     plugin.cpp
     PageList.cpp
     System.cpp
+    LocalePlugin.cpp
+    timezonemodel.cpp
+    Status.cpp
 )
 
-qt5_use_modules(Wizard-qml DBus Qml)
+qt5_use_modules(Wizard-qml DBus Qml Concurrent)
+target_link_libraries(Wizard-qml ${GLIB_LDFLAGS} ${GEONAMES_LDFLAGS})
 add_unity8_plugin(Wizard 0.1 Wizard TARGETS Wizard-qml)
 
 set(POLKIT_LIB_DIR "${CMAKE_INSTALL_LOCALSTATEDIR}/lib/polkit-1")

=== added file 'plugins/Wizard/LocalePlugin.cpp'
--- plugins/Wizard/LocalePlugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/LocalePlugin.cpp	2016-03-16 20:46:19 +0000
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 <QLocale>
+#include <QStringList>
+
+#include <libintl.h>
+
+#include "LocalePlugin.h"
+
+class LocalePrivate {
+public:
+    LocalePrivate() {
+        m_mccCodes = QHash<int, QString>
+                ({{202,"gr"},
+                  {204,"nl"},
+                  {206,"be"},
+                  {208,"fr"},
+                  {212,"mc"},
+                  {213,"ad"},
+                  {214,"es"},
+                  {216,"hu"},
+                  {218,"ba"},
+                  {219,"hr"},
+                  {220,"rs"},
+                  {222,"it"},
+                  {226,"ro"},
+                  {228,"ch"},
+                  {230,"cz"},
+                  {231,"sk"},
+                  {232,"at"},
+                  {234,"gb"},
+                  {235,"gb"},
+                  {238,"dk"},
+                  {240,"se"},
+                  {242,"no"},
+                  {244,"fi"},
+                  {246,"lt"},
+                  {247,"lv"},
+                  {248,"ee"},
+                  {250,"ru"},
+                  {255,"ua"},
+                  {257,"by"},
+                  {259,"md"},
+                  {260,"pl"},
+                  {262,"de"},
+                  {266,"gi"},
+                  {268,"pt"},
+                  {270,"lu"},
+                  {272,"ie"},
+                  {274,"is"},
+                  {276,"al"},
+                  {278,"mt"},
+                  {280,"cy"},
+                  {282,"ge"},
+                  {283,"am"},
+                  {284,"bg"},
+                  {286,"tr"},
+                  {288,"fo"},
+                  {289,"ge"},
+                  {290,"gl"},
+                  {292,"sm"},
+                  {293,"si"},
+                  {294,"mk"},
+                  {295,"li"},
+                  {297,"me"},
+                  {302,"ca"},
+                  {308,"pm"},
+                  {310,"gu"},
+                  {310,"us"},
+                  {311,"gu"},
+                  {311,"us"},
+                  {312,"us"},
+                  {316,"us"},
+                  {330,"pr"},
+                  {334,"mx"},
+                  {338,"jm"},
+                  {340,"fg"},
+                  {340,"gp"},
+                  {340,"mq"},
+                  {342,"bb"},
+                  {344,"ag"},
+                  {346,"ky"},
+                  {348,"vg"},
+                  {350,"bm"},
+                  {352,"gd"},
+                  {354,"ms"},
+                  {356,"kn"},
+                  {358,"lc"},
+                  {360,"vc"},
+                  {362,"an"},
+                  {362,"cw"},
+                  {363,"aw"},
+                  {364,"bs"},
+                  {365,"ai"},
+                  {366,"dm"},
+                  {368,"cu"},
+                  {370,"do"},
+                  {372,"ht"},
+                  {374,"tt"},
+                  {376,"tc"},
+                  {376,"vi"},
+                  {400,"az"},
+                  {401,"kz"},
+                  {402,"bt"},
+                  {404,"in"},
+                  {405,"in"},
+                  {410,"pk"},
+                  {412,"af"},
+                  {413,"lk"},
+                  {414,"mm"},
+                  {415,"lb"},
+                  {416,"jo"},
+                  {417,"sy"},
+                  {418,"iq"},
+                  {419,"kw"},
+                  {420,"sa"},
+                  {421,"ye"},
+                  {422,"om"},
+                  {424,"ae"},
+                  {425,"il"},
+                  {425,"ps"},
+                  {426,"bh"},
+                  {427,"qa"},
+                  {428,"mn"},
+                  {429,"np"},
+                  {430,"ae"},
+                  {431,"ae"},
+                  {432,"ir"},
+                  {434,"uz"},
+                  {436,"tk"},
+                  {437,"kg"},
+                  {438,"tm"},
+                  {440,"jp"},
+                  {441,"jp"},
+                  {450,"kr"},
+                  {452,"vn"},
+                  {454,"hk"},
+                  {455,"mo"},
+                  {456,"kh"},
+                  {457,"la"},
+                  {460,"cn"},
+                  {466,"tw"},
+                  {467,"kp"},
+                  {470,"bd"},
+                  {472,"mv"},
+                  {502,"my"},
+                  {505,"au"},
+                  {510,"id"},
+                  {514,"tp"},
+                  {515,"ph"},
+                  {520,"th"},
+                  {525,"sg"},
+                  {528,"bn"},
+                  {530,"nz"},
+                  {537,"pg"},
+                  {539,"to"},
+                  {540,"sb"},
+                  {541,"vu"},
+                  {542,"fj"},
+                  {544,"as"},
+                  {545,"ki"},
+                  {546,"nc"},
+                  {547,"pf"},
+                  {548,"ck"},
+                  {549,"ws"},
+                  {550,"fm"},
+                  {552,"pw"},
+                  {553,"tv"},
+                  {555,"nu"},
+                  {602,"eg"},
+                  {603,"dz"},
+                  {604,"ma"},
+                  {605,"tn"},
+                  {606,"ly"},
+                  {607,"gm"},
+                  {608,"sn"},
+                  {609,"mr"},
+                  {610,"ml"},
+                  {611,"gn"},
+                  {612,"ci"},
+                  {613,"bf"},
+                  {614,"ne"},
+                  {615,"tg"},
+                  {616,"bj"},
+                  {617,"mu"},
+                  {618,"lr"},
+                  {619,"sl"},
+                  {620,"gh"},
+                  {621,"ng"},
+                  {622,"td"},
+                  {623,"cf"},
+                  {624,"cm"},
+                  {625,"cv"},
+                  {626,"st"},
+                  {627,"gq"},
+                  {628,"ga"},
+                  {629,"cg"},
+                  {630,"cd"},
+                  {631,"ao"},
+                  {632,"gw"},
+                  {633,"sc"},
+                  {634,"sd"},
+                  {635,"rw"},
+                  {636,"et"},
+                  {637,"so"},
+                  {638,"dj"},
+                  {639,"ke"},
+                  {640,"tz"},
+                  {641,"ug"},
+                  {642,"bi"},
+                  {643,"mz"},
+                  {645,"zm"},
+                  {646,"mg"},
+                  {647,"re"},
+                  {648,"zw"},
+                  {649,"na"},
+                  {650,"mw"},
+                  {651,"ls"},
+                  {652,"bw"},
+                  {653,"sz"},
+                  {654,"km"},
+                  {655,"za"},
+                  {657,"er"},
+                  {659,"ss"},
+                  {702,"bz"},
+                  {704,"gt"},
+                  {706,"sv"},
+                  {708,"hn"},
+                  {710,"ni"},
+                  {712,"cr"},
+                  {714,"pa"},
+                  {716,"pe"},
+                  {722,"ar"},
+                  {724,"br"},
+                  {730,"cl"},
+                  {732,"co"},
+                  {734,"ve"},
+                  {736,"bo"},
+                  {738,"gy"},
+                  {740,"ec"},
+                  {744,"py"},
+                  {746,"sr"},
+                  {748,"uy"},
+                  {750,"fk"}}
+                 );
+    }
+
+    QString mccToCountryCode(int mcc) const {
+        return m_mccCodes.value(mcc, "us").toUpper();
+    }
+
+private:
+    // MCC = Mobile Country Code, see https://en.wikipedia.org/wiki/Mobile_country_code
+    QHash<int,QString> m_mccCodes;
+};
+
+Q_GLOBAL_STATIC(LocalePrivate, d)
+
+LocaleAttached::LocaleAttached(QObject* parent)
+    : QObject(parent)
+{
+}
+
+QString LocaleAttached::mccToCountryCode(int mcc) const
+{
+    return d->mccToCountryCode(mcc);
+}
+
+LocalePlugin::LocalePlugin(QObject* parent)
+    : QObject(parent)
+{
+}
+
+LocaleAttached* LocalePlugin::qmlAttachedProperties(QObject* parent)
+{
+    return new LocaleAttached(parent);
+}

=== added file 'plugins/Wizard/LocalePlugin.h'
--- plugins/Wizard/LocalePlugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/LocalePlugin.h	2016-03-16 20:46:19 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 LOCALE_PLUGIN_H
+#define LOCALE_PLUGIN_H
+
+#include <QObject>
+#include <QString>
+#include <QJsonObject>
+#include <QtQml>
+
+class LocaleAttached: public QObject
+{
+    Q_OBJECT
+protected:
+    explicit LocaleAttached(QObject *parent = 0);
+
+public:
+    Q_INVOKABLE QString mccToCountryCode(int mcc) const;
+
+    friend class LocalePlugin;
+};
+
+/**
+ * A simplified wrapper around QLocale.
+ *
+ * The wrapper is implemented as an attached property, which makes it possible
+ * to use it as if its methods were static:
+ *
+ * @code
+ * var langs = LocalePlugin.languages();
+ * @endcode
+ */
+class LocalePlugin: public QObject
+{
+    Q_OBJECT
+public:
+    explicit LocalePlugin(QObject *parent = 0);
+
+    static LocaleAttached* qmlAttachedProperties(QObject *parent);
+};
+
+QML_DECLARE_TYPEINFO(LocalePlugin, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // LOCALE_PLUGIN_H

=== modified file 'plugins/Wizard/PageList.cpp'
--- plugins/Wizard/PageList.cpp	2015-09-14 09:11:08 +0000
+++ plugins/Wizard/PageList.cpp	2016-03-16 20:46:19 +0000
@@ -40,20 +40,20 @@
       m_index(-1),
       m_pages()
 {
-    QString qmlSuffix = QStringLiteral(".qml");
-    QString disabledSuffix = QStringLiteral(".disabled");
+    const QString qmlSuffix = QStringLiteral(".qml");
+    const QString disabledSuffix = QStringLiteral(".disabled");
     QSet<QString> disabledPages;
     QStringList dataDirs;
 
     if (!isRunningInstalled() && getenv("WIZARD_TESTING") == nullptr) {
-        dataDirs = QStringList() << qmlDirectory();
+        dataDirs << qmlDirectory();
     } else {
         dataDirs = shellDataDirs();
     }
 
     Q_FOREACH(const QString &dataDir, dataDirs) {
         QDir dir(dataDir + "/Wizard/Pages");
-        QStringList entries = dir.entryList(QStringList(QStringLiteral("[0-9]*")), QDir::Files | QDir::Readable);
+        const QStringList entries = dir.entryList(QStringList(QStringLiteral("[0-9]*")), QDir::Files | QDir::Readable);
         Q_FOREACH(const QString &entry, entries) {
             if (!m_pages.contains(entry) && entry.endsWith(qmlSuffix))
                 m_pages.insert(entry, dir.absoluteFilePath(entry));

=== added file 'plugins/Wizard/Status.cpp'
--- plugins/Wizard/Status.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/Status.cpp	2016-03-16 20:46:19 +0000
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 <QDebug>
+#include <QDBusConnection>
+
+#include "Status.h"
+
+Status::Status()
+{
+    initNM();
+    initUPower();
+}
+
+void Status::initNM()
+{
+    m_nmIface = new QDBusInterface("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.NetworkManager",
+                                   QDBusConnection::systemBus(), this);
+
+    QDBusConnection::systemBus().connect("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.NetworkManager", "PropertiesChanged",
+                                         this, SLOT(onNMPropertiesChanged(QVariantMap)));
+}
+
+void Status::onNMPropertiesChanged(const QVariantMap &changedProps)
+{
+    if (changedProps.contains("State") || changedProps.contains("Connectivity")) {
+        Q_EMIT onlineChanged();
+        Q_EMIT networkIconChanged();
+    }
+
+    if (changedProps.contains("PrimaryConnection") || changedProps.contains("SpecificObject") || changedProps.contains("Strength")) {
+        Q_EMIT networkIconChanged();
+    }
+}
+
+bool Status::online() const
+{
+    if (!m_nmIface->isValid())
+        return false;
+
+    return m_nmIface->property("State").toUInt() == 70;
+}
+
+QString Status::networkIcon()
+{
+    QString iconName = QStringLiteral("nm-no-connection");
+
+    if (!online()) {
+        return iconName;
+    }
+
+    const QString primaryConn = m_nmIface->property("PrimaryConnection").value<QDBusObjectPath>().path();
+    const QString primaryConnType = m_nmIface->property("PrimaryConnectionType").toString();
+
+    if (primaryConn.isEmpty()) {
+        qWarning() << "Empty primary connection";
+        return iconName;
+    }
+
+    if (primaryConnType == "802-11-wireless") {
+        QDBusInterface activeConn("org.freedesktop.NetworkManager", primaryConn, "org.freedesktop.NetworkManager.Connection.Active", QDBusConnection::systemBus());
+
+        if (activeConn.isValid()) {
+            const QString apPath = activeConn.property("SpecificObject").value<QDBusObjectPath>().path();
+
+            if (apPath.isEmpty()) {
+                qWarning() << "No AP path";
+                return iconName;
+            }
+
+            QDBusConnection::systemBus().connect("org.freedesktop.NetworkManager", primaryConn, "org.freedesktop.NetworkManager.Connection.Active", "PropertiesChanged",
+                                                 this, SLOT(onNMPropertiesChanged(QVariantMap)));
+
+            QDBusInterface ap("org.freedesktop.NetworkManager", apPath, "org.freedesktop.NetworkManager.AccessPoint", QDBusConnection::systemBus());
+
+            if (!ap.isValid()) {
+                qWarning() << "Invalid AP";
+                return iconName;
+            }
+
+            QDBusConnection::systemBus().connect("org.freedesktop.NetworkManager", apPath, "org.freedesktop.NetworkManager.AccessPoint", "PropertiesChanged",
+                                                 this, SLOT(onNMPropertiesChanged(QVariantMap)));
+
+            const uint strength = ap.property("Strength").toUInt();
+            const uint flags = ap.property("Flags").toUInt();
+
+            if (strength == 0) {
+                iconName = "nm-signal-00";
+            } else if (strength <= 25) {
+                iconName = "nm-signal-25";
+            } else if (strength <= 50) {
+                iconName = "nm-signal-50";
+            } else if (strength <= 75) {
+                iconName = "nm-signal-75";
+            } else if (strength <= 100) {
+                iconName = "nm-signal-100";
+            }
+
+            if (flags >= 1) {
+                iconName += "-secure";
+            }
+        }
+    }
+
+    return iconName;
+}
+
+void Status::initUPower()
+{
+    m_upowerIface = new QDBusInterface("org.freedesktop.UPower", "/org/freedesktop/UPower/devices/DisplayDevice", "org.freedesktop.UPower.Device",
+                                       QDBusConnection::systemBus(), this);
+    QDBusConnection::systemBus().connect("org.freedesktop.UPower", "/org/freedesktop/UPower/devices/DisplayDevice", "org.freedesktop.DBus.Properties",
+                                         "PropertiesChanged", this, SLOT(onUPowerPropertiesChanged(QString,QVariantMap,QStringList)));
+}
+
+void Status::onUPowerPropertiesChanged(const QString &iface, const QVariantMap &changedProps, const QStringList &invalidatedProps)
+{
+    Q_UNUSED(iface)
+    Q_UNUSED(invalidatedProps)
+
+    if (changedProps.contains("IconName")) {
+        Q_EMIT batteryIconChanged();
+    }
+}
+
+QString Status::batteryIcon() const
+{
+    const QString iconName = m_upowerIface->property("IconName").toString();
+    return iconName;
+}

=== added file 'plugins/Wizard/Status.h'
--- plugins/Wizard/Status.h	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/Status.h	2016-03-16 20:46:19 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 WIZARD_STATUS_H
+#define WIZARD_STATUS_H
+
+#include <QObject>
+#include <QString>
+#include <QDBusInterface>
+
+class Status: public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool online READ online NOTIFY onlineChanged)
+    Q_PROPERTY(QString networkIcon READ networkIcon NOTIFY networkIconChanged)
+    Q_PROPERTY(QString batteryIcon READ batteryIcon NOTIFY batteryIconChanged)
+public:
+    Status();
+    ~Status() = default;
+
+    bool online() const;
+    QString networkIcon();
+
+    QString batteryIcon() const;
+
+Q_SIGNALS:
+    void networkIconChanged();
+    void onlineChanged();
+    void batteryIconChanged();
+
+private Q_SLOTS:
+    void onNMPropertiesChanged(const QVariantMap &changedProps);
+    void onUPowerPropertiesChanged(const QString &iface, const QVariantMap &changedProps, const QStringList &invalidatedProps);
+
+private:
+    Q_DISABLE_COPY(Status)
+
+    // network status
+    void initNM();
+    QDBusInterface * m_nmIface = nullptr;
+
+    // battery status
+    void initUPower();
+    QDBusInterface * m_upowerIface = nullptr;
+};
+
+#endif

=== modified file 'plugins/Wizard/System.cpp'
--- plugins/Wizard/System.cpp	2015-09-23 15:14:01 +0000
+++ plugins/Wizard/System.cpp	2016-03-16 20:46:19 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical Ltd.
+ * Copyright (C) 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -25,10 +25,10 @@
 #include <QLocale>
 #include <QMap>
 #include <QProcess>
+#include <QDebug>
 
 System::System()
-    : QObject(),
-      m_fsWatcher()
+    : QObject()
 {
     // Register the argument needed for UpdateActivationEnvironment below
     qDBusRegisterMetaType<QMap<QString,QString>>();
@@ -88,7 +88,7 @@
     QDBusConnection::sessionBus().asyncCall(msg);
 }
 
-void System::updateSessionLanguage(const QString &locale)
+void System::updateSessionLocale(const QString &locale)
 {
     const QString language = locale.split(QStringLiteral("."))[0];
 
@@ -106,5 +106,6 @@
                                      initctl stop smart-scopes-proxy; \
                                      initctl emit --no-wait indicator-services-start; \
                                      initctl restart --no-wait maliit-server; \
+                                     initctl restart --no-wait indicator-messages; \
                                      initctl restart --no-wait unity8-dash\""));
 }

=== modified file 'plugins/Wizard/System.h'
--- plugins/Wizard/System.h	2015-05-21 16:05:57 +0000
+++ plugins/Wizard/System.h	2016-03-16 20:46:19 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical Ltd.
+ * Copyright (C) 2014-2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -28,12 +28,13 @@
 
 public:
     System();
+    ~System() = default;
 
     bool wizardEnabled() const;
     void setWizardEnabled(bool enabled);
 
 public Q_SLOTS:
-    void updateSessionLanguage(const QString &locale);
+    void updateSessionLocale(const QString &locale);
 
 Q_SIGNALS:
     void wizardEnabledChanged();

=== modified file 'plugins/Wizard/plugin.cpp'
--- plugins/Wizard/plugin.cpp	2014-11-21 19:28:16 +0000
+++ plugins/Wizard/plugin.cpp	2016-03-16 20:46:19 +0000
@@ -17,19 +17,18 @@
 #include "plugin.h"
 #include "PageList.h"
 #include "System.h"
+#include "timezonemodel.h"
+#include "LocalePlugin.h"
+#include "Status.h"
 
 #include <QtQml/qqml.h>
 
-static QObject *system_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
-{
-    Q_UNUSED(engine)
-    Q_UNUSED(scriptEngine)
-    return new System();
-}
-
 void WizardPlugin::registerTypes(const char *uri)
 {
     Q_ASSERT(uri == QLatin1String("Wizard"));
     qmlRegisterType<PageList>(uri, 0, 1, "PageList");
-    qmlRegisterSingletonType<System>(uri, 0, 1, "System", system_provider);
+    qmlRegisterSingletonType<System>(uri, 0, 1, "System", [](QQmlEngine*, QJSEngine*) -> QObject* { return new System; });
+    qmlRegisterSingletonType<Status>(uri, 0, 1, "Status", [](QQmlEngine*, QJSEngine*) -> QObject* { return new Status; });
+    qmlRegisterType<TimeZoneLocationModel>(uri, 0, 1, "TimeZoneModel");
+    qmlRegisterType<LocalePlugin>(uri, 0, 1, "LocalePlugin");
 }

=== modified file 'plugins/Wizard/plugin.h'
--- plugins/Wizard/plugin.h	2015-04-30 09:31:51 +0000
+++ plugins/Wizard/plugin.h	2016-03-16 20:46:19 +0000
@@ -17,13 +17,12 @@
 #ifndef WIZARD_PLUGIN_H
 #define WIZARD_PLUGIN_H
 
-#include <QtQml/QQmlEngine>
 #include <QtQml/QQmlExtensionPlugin>
 
 class WizardPlugin : public QQmlExtensionPlugin
 {
     Q_OBJECT
-    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+    Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
 
 public:
     void registerTypes(const char *uri) override;

=== added file 'plugins/Wizard/timezonemodel.cpp'
--- plugins/Wizard/timezonemodel.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/timezonemodel.cpp	2016-03-16 20:46:19 +0000
@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 <QDebug>
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "LocalePlugin.h"
+#include "timezonemodel.h"
+
+TimeZoneLocationModel::TimeZoneLocationModel(QObject *parent):
+    QAbstractListModel(parent),
+    m_listUpdating(false),
+    m_cancellable(nullptr)
+{
+    m_roleNames[Qt::DisplayRole] = "displayName";
+    m_roleNames[TimeZoneRole] = "timeZone";
+    m_roleNames[CityRole] = "city";
+    m_roleNames[CountryRole] = "country";
+    m_roleNames[OffsetRole] = "offset";
+    m_roleNames[LatitudeRole] = "latitude";
+    m_roleNames[LongitudeRole] = "longitude";
+}
+
+int TimeZoneLocationModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    } else if (m_filter.isEmpty()) {
+        return m_countryLocations.count();
+    } else {
+        return m_locations.count();
+    }
+}
+
+QVariant TimeZoneLocationModel::data(const QModelIndex &index, int role) const
+{
+    GeonamesCity *city;
+    if (m_filter.isEmpty()) {
+        city = m_countryLocations.value(index.row());
+    } else {
+        city = m_locations.value(index.row());
+    }
+    if (!city)
+        return QVariant();
+
+    switch (role) {
+    case Qt::DisplayRole:
+        return QStringLiteral("%1, %2, %3").arg(geonames_city_get_name(city))
+                                           .arg(geonames_city_get_state(city))
+                                           .arg(geonames_city_get_country(city));
+    case SimpleRole:
+        return QStringLiteral("%1, %2").arg(geonames_city_get_name(city))
+                                       .arg(geonames_city_get_country(city));
+    case TimeZoneRole:
+        return geonames_city_get_timezone(city);
+    case CountryRole:
+        return geonames_city_get_country(city);
+    case CityRole:
+        return geonames_city_get_name(city);
+    case OffsetRole: {
+        QTimeZone tmp(geonames_city_get_timezone(city));
+        return static_cast<double>(tmp.standardTimeOffset(QDateTime::currentDateTime())) / 3600;
+    }
+    case LatitudeRole:
+        return geonames_city_get_latitude(city);
+    case LongitudeRole:
+        return geonames_city_get_longitude(city);
+    default:
+        qWarning() << Q_FUNC_INFO << "Unknown role";
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> TimeZoneLocationModel::roleNames() const
+{
+    return m_roleNames;
+}
+
+void TimeZoneLocationModel::setModel(const QList<GeonamesCity *> &locations)
+{
+    beginResetModel();
+
+    Q_FOREACH(GeonamesCity *city, m_locations) {
+        geonames_city_free(city);
+    }
+
+    m_locations = locations;
+    endResetModel();
+}
+
+void TimeZoneLocationModel::filterFinished(GObject      *source_object,
+                                           GAsyncResult *res,
+                                           gpointer      user_data)
+{
+    Q_UNUSED(source_object);
+
+    g_autofree gint *cities = nullptr;
+    guint cities_len = 0;
+    g_autoptr(GError) error = nullptr;
+
+    cities = geonames_query_cities_finish(res, &cities_len, &error);
+    if (error) {
+        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+            TimeZoneLocationModel *model = static_cast<TimeZoneLocationModel *>(user_data);
+            g_clear_object(&model->m_cancellable);
+            model->setListUpdating(false);
+            qWarning() << "Could not filter timezones:" << error->message;
+        }
+        return;
+    }
+
+    QList<GeonamesCity *> locations;
+
+    for (guint i = 0; i < cities_len; ++i) {
+        GeonamesCity *city = geonames_get_city(cities[i]);
+        if (city) {
+            locations.append(city);
+        }
+    }
+
+    TimeZoneLocationModel *model = static_cast<TimeZoneLocationModel *>(user_data);
+
+    g_clear_object(&model->m_cancellable);
+
+    model->setModel(locations);
+    model->setListUpdating(false);
+}
+
+bool TimeZoneLocationModel::listUpdating() const
+{
+    return m_listUpdating;
+}
+
+void TimeZoneLocationModel::setListUpdating(bool listUpdating)
+{
+    if (m_listUpdating != listUpdating) {
+        m_listUpdating = listUpdating;
+        Q_EMIT listUpdatingChanged();
+    }
+}
+
+QString TimeZoneLocationModel::filter() const
+{
+    return m_filter;
+}
+
+void TimeZoneLocationModel::setFilter(const QString &filter)
+{
+    if (filter != m_filter) {
+        m_filter = filter;
+        Q_EMIT filterChanged();
+    }
+
+    setListUpdating(true);
+
+    if (m_cancellable) {
+        g_cancellable_cancel(m_cancellable);
+        g_clear_object(&m_cancellable);
+    }
+
+    setModel(QList<GeonamesCity *>());
+
+    if (filter.isEmpty()) {
+        setListUpdating(false);
+        return;
+    }
+
+    m_cancellable = g_cancellable_new();
+    geonames_query_cities(filter.toUtf8().data(),
+                          GEONAMES_QUERY_DEFAULT,
+                          m_cancellable,
+                          filterFinished,
+                          this);
+}
+
+QString TimeZoneLocationModel::country() const
+{
+    return m_country;
+}
+
+static bool citycmp(GeonamesCity *a, GeonamesCity *b)
+{
+    return geonames_city_get_population(b) < geonames_city_get_population(a);
+}
+
+void TimeZoneLocationModel::setCountry(const QString &country)
+{
+    if (m_country == country)
+        return;
+
+    m_country = country;
+
+    Q_FOREACH(GeonamesCity *city, m_countryLocations) {
+        geonames_city_free(city);
+    }
+
+    gint num_cities = geonames_get_n_cities();
+    for (gint i = 0; i < num_cities; i++) {
+        GeonamesCity *city = geonames_get_city(i);
+        if (city && m_country == geonames_city_get_country_code(city)) {
+            m_countryLocations.append(city);
+        }
+    }
+
+    std::sort(m_countryLocations.begin(), m_countryLocations.end(), citycmp);
+
+    Q_EMIT countryChanged(country);
+}
+
+TimeZoneLocationModel::~TimeZoneLocationModel()
+{
+    if (m_cancellable) {
+        g_cancellable_cancel(m_cancellable);
+        g_clear_object(&m_cancellable);
+    }
+
+    Q_FOREACH(GeonamesCity *city, m_countryLocations) {
+        geonames_city_free(city);
+    }
+
+    Q_FOREACH(GeonamesCity *city, m_locations) {
+        geonames_city_free(city);
+    }
+}

=== added file 'plugins/Wizard/timezonemodel.h'
--- plugins/Wizard/timezonemodel.h	1970-01-01 00:00:00 +0000
+++ plugins/Wizard/timezonemodel.h	2016-03-16 20:46:19 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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 TIMEZONEMODEL_H
+#define TIMEZONEMODEL_H
+
+#include <geonames.h>
+#include <glib.h>
+#include <QAbstractListModel>
+
+class TimeZoneLocationModel: public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(bool listUpdating READ listUpdating NOTIFY listUpdatingChanged)
+    Q_PROPERTY(QString filter READ filter WRITE setFilter NOTIFY filterChanged)
+    Q_PROPERTY(QString country READ country WRITE setCountry NOTIFY countryChanged)
+    Q_ENUMS(Roles)
+
+public:
+    explicit TimeZoneLocationModel(QObject *parent = nullptr);
+    ~TimeZoneLocationModel();
+
+    enum Roles {
+        TimeZoneRole = Qt::UserRole + 1,
+        CityRole,
+        CountryRole,
+        SimpleRole,
+        OffsetRole,
+        LatitudeRole,
+        LongitudeRole
+    };
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    bool listUpdating() const;
+
+    QString filter() const;
+    void setFilter(const QString &filter);
+
+    QString country() const;
+    void setCountry(const QString &country);
+
+Q_SIGNALS:
+    void listUpdatingChanged();
+    void filterChanged();
+    void countryChanged(const QString &country);
+
+private:
+    void setModel(const QList<GeonamesCity *> &locations);
+    void setListUpdating(bool listUpdating);
+    static void filterFinished(GObject      *source_object,
+                               GAsyncResult *res,
+                               gpointer      user_data);
+
+
+    bool m_listUpdating;
+    QString m_filter;
+    QString m_country;
+    GCancellable *m_cancellable;
+    QHash<int, QByteArray> m_roleNames;
+    QList<GeonamesCity *> m_locations;
+    QList<GeonamesCity *> m_countryLocations;
+};
+
+#endif

=== modified file 'qml/Components/Showable.qml'
--- qml/Components/Showable.qml	2015-07-15 15:07:19 +0000
+++ qml/Components/Showable.qml	2016-03-16 20:46:19 +0000
@@ -31,6 +31,7 @@
     property bool required
     property bool __shouldShow: false
     property bool __skipShowAnimation: false
+    property bool __skipHideAnimation: false
 
     property list<QtObject> hides
     property var showAnimation
@@ -120,12 +121,21 @@
             if (!hideAnimation.running) {
                 hideAnimation.restart()
             }
+            if (__skipHideAnimation) {
+                hideAnimation.complete();
+            }
         } else {
             visible = false
             required = false
         }
 
         shown = false
+        __skipHideAnimation = false;
+    }
+
+    function hideNow() {
+        __skipHideAnimation = true;
+        hide();
     }
 
     Connections {

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2016-03-10 22:37:44 +0000
+++ qml/Shell.qml	2016-03-16 20:46:19 +0000
@@ -120,9 +120,7 @@
         if (ApplicationManager.findApplication(appId)) {
             ApplicationManager.requestFocusApplication(appId);
         } else {
-            var execFlags = shell.usageScenario === "phone" ? ApplicationManager.ForceMainStage
-                                                            : ApplicationManager.NoFlag;
-            ApplicationManager.startApplication(appId, execFlags);
+            ApplicationManager.startApplication(appId);
         }
     }
 
@@ -547,9 +545,7 @@
                 greeterShown: greeter.shown
             }
 
-            readonly property bool topmostApplicationIsFullscreen:
-                ApplicationManager.focusedApplicationId &&
-                    ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).fullscreen
+            readonly property bool topmostApplicationIsFullscreen: mainApp && mainApp.fullscreen
 
             fullscreenMode: (topmostApplicationIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)
                             || greeter.hasLockedApp
@@ -632,7 +628,6 @@
             id: wizard
             objectName: "wizard"
             anchors.fill: parent
-            background: wallpaperResolver.background
 
             function unlockWhenDoneWithWizard() {
                 if (!active) {

=== modified file 'qml/Stages/AbstractStage.qml'
--- qml/Stages/AbstractStage.qml	2016-03-10 22:41:22 +0000
+++ qml/Stages/AbstractStage.qml	2016-03-16 20:46:19 +0000
@@ -44,7 +44,7 @@
 
     // To be read from outside
     property var mainApp: null
-    property int mainAppWindowOrientationAngle
+    property int mainAppWindowOrientationAngle: 0
     property bool orientationChangesEnabled
     property int supportedOrientations: Qt.PortraitOrientation
                                       | Qt.LandscapeOrientation

=== modified file 'qml/Stages/ApplicationWindow.qml'
--- qml/Stages/ApplicationWindow.qml	2016-02-12 00:10:54 +0000
+++ qml/Stages/ApplicationWindow.qml	2016-03-16 20:46:19 +0000
@@ -24,12 +24,14 @@
     implicitHeight: sessionContainer.implicitHeight
 
     // to be read from outside
-    readonly property bool fullscreen: application ? application.fullscreen : false
     property alias interactive: sessionContainer.interactive
     property bool orientationChangesEnabled: d.supportsSurfaceResize ? d.surfaceOldEnoughToBeResized : true
     readonly property string title: sessionContainer.surface && sessionContainer.surface.name !== "" ?
                                         sessionContainer.surface.name : d.name
 
+    // overridable from outside
+    property bool fullscreen: application ? application.fullscreen : false
+
     // to be set from outside
     property QtObject application
     property int surfaceOrientationAngle

=== added file 'qml/Stages/SideStage.qml'
--- qml/Stages/SideStage.qml	1970-01-01 00:00:00 +0000
+++ qml/Stages/SideStage.qml	2016-03-16 20:46:19 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+import Ubuntu.Gestures 0.1
+import "../Components"
+
+Showable {
+    id: root
+    property bool showHint: true
+    property int panelWidth: units.gu(40)
+    readonly property alias dragging: hideSideStageDragArea.dragging
+    readonly property real progress: width / panelWidth
+
+    width: 0
+    shown: false
+
+    Item {
+        id: sideStageDragHandle
+        anchors {
+            right: root.left
+            top: root.top
+            bottom: root.bottom
+        }
+        width: units.gu(2)
+
+        opacity: root.shown ? 1 : 0
+        Behavior on opacity { UbuntuNumberAnimation {} }
+
+        Image {
+            anchors.centerIn: parent
+            width: hideSideStageDragArea.pressed ? parent.width * 2 : parent.width
+            height: parent.height
+            source: "graphics/[e-mail]"
+            Behavior on width { UbuntuNumberAnimation {} }
+        }
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: Qt.rgba(0,0,0,0.95)
+    }
+
+    Column {
+        anchors.verticalCenter: parent.verticalCenter
+        width: panelWidth - units.gu(6)
+        x: panelWidth/2 - width/2
+        spacing: units.gu(3)
+        opacity: 0.8
+        visible: showHint
+
+        Icon {
+            width: units.gu(30)
+            anchors.horizontalCenter: parent.horizontalCenter
+            source: "graphics/sidestage_drag.svg"
+            color: enabled ? Qt.rgba(1,1,1,1) : Qt.rgba(1,0,0,1)
+            keyColor: Qt.rgba(1,1,1,1)
+        }
+
+        Label {
+            text: i18n.tr("Drag using 3 fingers any application from one window to the other")
+            width: parent.width
+            wrapMode: Text.WordWrap
+            color: enabled ? Qt.rgba(1,1,1,1) : Qt.rgba(1,0,0,1)
+        }
+    }
+
+    showAnimation: NumberAnimation {
+        property: "width"
+        to: panelWidth
+        duration: UbuntuAnimation.BriskDuration
+        easing.type: Easing.OutCubic
+    }
+
+    hideAnimation: NumberAnimation {
+        property: "width"
+        to: 0
+        duration: UbuntuAnimation.BriskDuration
+        easing.type: Easing.OutCubic
+    }
+
+    DragHandle {
+        id: hideSideStageDragArea
+        objectName: "hideSideStageDragArea"
+
+        direction: Direction.Leftwards
+        rotation: 180
+        enabled: root.shown
+        anchors.right: root.left
+        width: sideStageDragHandle.width
+        height: root.height
+        stretch: true
+
+        immediateRecognition: true
+        maxTotalDragDistance: panelWidth
+        autoCompleteDragThreshold: panelWidth / 2
+    }
+
+    // SideStage mouse event eater
+    MouseArea {
+        anchors.fill: parent
+    }
+}

=== modified file 'qml/Stages/SpreadDelegate.qml'
--- qml/Stages/SpreadDelegate.qml	2016-03-10 09:19:38 +0000
+++ qml/Stages/SpreadDelegate.qml	2016-03-16 20:46:19 +0000
@@ -32,6 +32,11 @@
     readonly property alias appWindowOrientationAngle: appWindowWithShadow.orientationAngle
     readonly property alias appWindowRotation: appWindowWithShadow.rotation
     readonly property alias orientationChangesEnabled: appWindow.orientationChangesEnabled
+    property int supportedOrientations: application ? application.supportedOrientations :
+                                                      Qt.PortraitOrientation
+                                                      | Qt.LandscapeOrientation
+                                                      | Qt.InvertedPortraitOrientation
+                                                      | Qt.InvertedLandscapeOrientation
 
     // to be set from outside
     property bool interactive: true
@@ -45,6 +50,9 @@
     property QtObject orientations
     property bool highlightShown: false
 
+    // overrideable from outside
+    property alias fullscreen: appWindow.fullscreen
+
     function matchShellOrientation() {
         if (!root.application)
             return;
@@ -154,7 +162,8 @@
                             if (!root.application || root.application.rotatesWindowContents) {
                                 return 0;
                             }
-                            var supportedOrientations = root.application.supportedOrientations;
+
+                            var supportedOrientations = root.supportedOrientations;
 
                             if (supportedOrientations === Qt.PrimaryOrientation) {
                                 supportedOrientations = root.orientations.primary;

=== modified file 'qml/Stages/SurfaceContainer.qml'
--- qml/Stages/SurfaceContainer.qml	2015-11-30 12:18:40 +0000
+++ qml/Stages/SurfaceContainer.qml	2016-03-16 20:46:19 +0000
@@ -118,6 +118,7 @@
 
 
     TouchGate {
+        objectName: "touchGate-"+name
         targetItem: surfaceItem
         anchors.fill: root
         enabled: surfaceItem.enabled

=== added file 'qml/Stages/TabletSideStageTouchGesture.qml'
--- qml/Stages/TabletSideStageTouchGesture.qml	1970-01-01 00:00:00 +0000
+++ qml/Stages/TabletSideStageTouchGesture.qml	2016-03-16 20:46:19 +0000
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import Ubuntu.Gestures 0.1
+
+TouchGestureArea {
+    id: root
+    minimumTouchPoints: 3
+    maximumTouchPoints: 3
+
+    property bool enableDrag: true
+    property Component dragComponent
+    property var dragComponentProperties: undefined
+
+    readonly property bool recognisedPress: status == TouchGestureArea.Recognized &&
+                                            touchPoints.length >= minimumTouchPoints &&
+                                            touchPoints.length <= maximumTouchPoints
+    readonly property bool recognisedDrag: priv.wasRecognisedPress && dragging
+
+    signal pressed(int x, int y)
+    signal clicked
+    signal dragStarted
+    signal dropped
+    signal cancelled
+
+    onEnabledChanged: {
+        if (!enabled) {
+            if (priv.dragObject) root.cancelled();
+            priv.wasRecognisedDrag = false;
+            priv.wasRecognisedPress = false;
+        }
+    }
+
+    onRecognisedPressChanged: {
+        if (recognisedPress) {
+            // get the app at the center of the gesture
+            var centerX = 0;
+            var centerY = 0;
+            for (var i = 0; i < touchPoints.length; i++) {
+                centerX += touchPoints[i].x;
+                centerY += touchPoints[i].y;
+            }
+            centerX = centerX/touchPoints.length;
+            centerY = centerY/touchPoints.length;
+
+            pressed(centerX, centerY);
+            priv.wasRecognisedPress = true;
+        }
+    }
+
+    onStatusChanged: {
+        if (status != TouchGestureArea.Recognized) {
+            if (status == TouchGestureArea.Rejected) {
+                root.cancelled();
+            } else if (status == TouchGestureArea.WaitingForTouch) {
+                if (priv.wasRecognisedPress) {
+                    if (!priv.wasRecognisedDrag) {
+                        root.clicked();
+                    } else {
+                        root.dropped();
+                    }
+                }
+            }
+            priv.wasRecognisedDrag = false;
+            priv.wasRecognisedPress = false;
+        }
+    }
+
+    onRecognisedDragChanged: {
+        if (enableDrag && recognisedDrag) {
+            priv.wasRecognisedDrag = true;
+            root.dragStarted()
+        }
+    }
+
+    QtObject {
+        id: priv
+        property var dragObject: null
+
+        property bool wasRecognisedPress: false
+        property bool wasRecognisedDrag: false
+    }
+
+    onCancelled: {
+        if (priv.dragObject) {
+            var obj = priv.dragObject;
+            priv.dragObject = null;
+
+            obj.Drag.cancel();
+            obj.destroy();
+        }
+    }
+
+    onDragStarted: {
+        if (dragComponentProperties) {
+            priv.dragObject = dragComponent.createObject(root, dragComponentProperties);
+        } else {
+            priv.dragObject = dragComponent.createObject(root);
+        }
+        priv.dragObject.Drag.start();
+    }
+
+    onDropped: {
+        if (priv.dragObject) {
+            var obj = priv.dragObject;
+            priv.dragObject = null;
+
+            obj.Drag.drop();
+            obj.destroy();
+        }
+    }
+
+    Binding {
+        target: priv.dragObject
+        when: priv.dragObject && priv.wasRecognisedDrag
+        property: "x"
+        value: {
+            if (!priv.dragObject) return 0;
+            var sum = 0;
+            for (var i = 0; i < root.touchPoints.length; i++) {
+                sum += root.touchPoints[i].x;
+            }
+            return sum/root.touchPoints.length - priv.dragObject.width/2;
+        }
+    }
+
+    Binding {
+        target: priv.dragObject
+        when: priv.dragObject && priv.wasRecognisedDrag
+        property: "y"
+        value: {
+            if (!priv.dragObject) return 0;
+            var sum = 0;
+            for (var i = 0; i < root.touchPoints.length; i++) {
+                sum += root.touchPoints[i].y;
+            }
+            return sum/root.touchPoints.length - priv.dragObject.height/2;
+        }
+    }
+}

=== modified file 'qml/Stages/TabletStage.qml'
--- qml/Stages/TabletStage.qml	2016-03-10 09:19:38 +0000
+++ qml/Stages/TabletStage.qml	2016-03-16 20:46:19 +0000
@@ -46,7 +46,7 @@
             if (delta < 0) { delta += 360; }
             delta = delta % 360;
 
-            var supportedOrientations = spreadDelegate.application.supportedOrientations;
+            var supportedOrientations = spreadDelegate.supportedOrientations;
             if (supportedOrientations === Qt.PrimaryOrientation) {
                 supportedOrientations = spreadDelegate.orientations.primary;
             }
@@ -78,9 +78,24 @@
 
     orientationChangesEnabled: priv.mainAppOrientationChangesEnabled
 
-    supportedOrientations: mainApp ? mainApp.supportedOrientations
-                                   : (Qt.PortraitOrientation | Qt.LandscapeOrientation
-                                      | Qt.InvertedPortraitOrientation | Qt.InvertedLandscapeOrientation)
+    supportedOrientations: {
+        if (mainApp) {
+            var orientations = mainApp.supportedOrientations;
+            orientations |= Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation;
+            if (priv.sideStageAppId && !spreadView.surfaceDragging) {
+                // If we have a sidestage app, support Portrait orientation
+                // so that it will switch the sidestage app to mainstage on rotate
+                orientations |= Qt.PortraitOrientation|Qt.InvertedPortraitOrientation;
+            }
+            return orientations;
+        } else {
+            // we just don't care
+            return Qt.PortraitOrientation |
+                   Qt.LandscapeOrientation |
+                   Qt.InvertedPortraitOrientation |
+                   Qt.InvertedLandscapeOrientation;
+        }
+    }
 
     onWidthChanged: {
         spreadView.selectedIndex = -1;
@@ -88,13 +103,6 @@
         spreadView.contentX = -spreadView.shift;
     }
 
-    onShellOrientationChanged: {
-        if (shellOrientation == Qt.PortraitOrientation || shellOrientation == Qt.InvertedPortraitOrientation) {
-            ApplicationManager.focusApplication(priv.mainStageAppId);
-            priv.sideStageAppId = "";
-        }
-    }
-
     onInverseProgressChanged: {
         // This can't be a simple binding because that would be triggered after this handler
         // while we need it active before doing the anition left/right
@@ -170,20 +178,7 @@
 
         property int highlightIndex: 0
 
-        onFocusedAppIdChanged: {
-            if (priv.focusedAppId.length > 0) {
-                var focusedApp = ApplicationManager.findApplication(focusedAppId);
-                if (focusedApp.stage == ApplicationInfoInterface.SideStage) {
-                    priv.sideStageAppId = focusedAppId;
-                } else {
-                    priv.mainStageAppId = focusedAppId;
-                    root.mainApp = focusedApp;
-                }
-            }
-
-            appId0 = ApplicationManager.count >= 1 ? ApplicationManager.get(0).appId : "";
-            appId1 = ApplicationManager.count > 1 ? ApplicationManager.get(1).appId : "";
-        }
+        onFocusedAppIdChanged: updateStageApps()
 
         onFocusedAppDelegateChanged: {
             if (focusedAppDelegate) {
@@ -229,6 +224,46 @@
         onHighlightIndexChanged: {
             spreadView.contentX = highlightIndex * spreadView.contentWidth / (spreadRepeater.count + 2)
         }
+
+        function getTopApp(stage) {
+            for (var i = 0; i < ApplicationManager.count; i++) {
+                var app = ApplicationManager.get(i)
+                if (app.stage === stage) {
+                    return app;
+                }
+            }
+            return null;
+        }
+
+        function setAppStage(appId, stage, save) {
+            var app = ApplicationManager.findApplication(appId);
+            if (app) {
+                app.stage = stage;
+                if (save) {
+                    WindowStateStorage.saveStage(appId, stage);
+                }
+            }
+        }
+
+        function updateStageApps() {
+            var app = priv.getTopApp(ApplicationInfoInterface.MainStage);
+            priv.mainStageAppId = app ? app.appId : ""
+            root.mainApp = app;
+
+            if (sideStage.shown) {
+                app = priv.getTopApp(ApplicationInfoInterface.SideStage);
+                priv.sideStageAppId = app ? app.appId : ""
+            } else {
+                priv.sideStageAppId = "";
+            }
+
+            appId0 = ApplicationManager.count >= 1 ? ApplicationManager.get(0).appId : "";
+            appId1 = ApplicationManager.count > 1 ? ApplicationManager.get(1).appId : "";
+        }
+
+        readonly property bool sideStageEnabled: root.shellOrientation == Qt.LandscapeOrientation ||
+                                                 root.shellOrientation == Qt.InvertedLandscapeOrientation
+        Component.onCompleted: updateStageApps();
     }
 
     Connections {
@@ -256,7 +291,8 @@
                 ApplicationManager.focusApplication("unity8-dash")
             }
             if (priv.sideStageAppId == appId) {
-                priv.sideStageAppId = "";
+                var app = priv.getTopApp(ApplicationInfoInterface.SideStage);
+                priv.sideStageAppId = app === null ? "" : app.appId;
             }
 
             if (ApplicationManager.count == 0) {
@@ -267,6 +303,7 @@
                 // lets make sure the spread doesn't mess up by the changing app list.
                 spreadView.phase = 0;
                 spreadView.contentX = -spreadView.shift;
+
                 ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
             }
         }
@@ -322,6 +359,7 @@
         property int selectedIndex: -1
         property int draggedDelegateCount: 0
         property int closingIndex: -1
+        property var selectedApplication: selectedIndex !== -1 ? ApplicationManager.get(selectedIndex) : null
 
         // FIXME: Workaround Flickable's not keepping its contentX still when resized
         onContentXChanged: { forceItToRemainStillIfBeingResized(); }
@@ -343,15 +381,8 @@
             }
         }
 
-        property bool sideStageDragging: sideStageDragHandle.dragging
-        property real sideStageDragProgress: sideStageDragHandle.progress
-
-        onSideStageDragProgressChanged: {
-            if (sideStageDragProgress == 1) {
-                ApplicationManager.focusApplication(priv.mainStageAppId);
-                priv.sideStageAppId = "";
-            }
-        }
+        property real sideStageDragProgress: sideStage.progress
+        property bool surfaceDragging: triGestureArea.recognisedDrag
 
         // In case the ApplicationManager already holds an app when starting up we're missing animations
         // Make sure we end up in the same state
@@ -402,7 +433,7 @@
             }
         ]
         state: {
-            if (priv.mainStageAppId && !priv.sideStageAppId) {
+            if ((priv.mainStageAppId && !priv.sideStageAppId) || !priv.sideStageEnabled) {
                 return "main";
             }
             if (!priv.mainStageAppId && priv.sideStageAppId) {
@@ -419,12 +450,26 @@
                 // Flickabe.contentX wiggles during resizes. Don't react to it.
                 return;
             }
-            if (spreadView.phase == 0 && spreadView.shiftedContentX > spreadView.width * spreadView.positionMarker2) {
-                spreadView.phase = 1;
-            } else if (spreadView.phase == 1 && spreadView.shiftedContentX > spreadView.width * spreadView.positionMarker4) {
-                spreadView.phase = 2;
-            } else if (spreadView.phase == 1 && spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
-                spreadView.phase = 0;
+
+            switch (phase) {
+            case 0:
+                // the "spreadEnabled" part is because when code does "phase = 0; contentX = -shift" to
+                // dismiss the spread because spreadEnabled went to false, for some reason, during tests,
+                // Flickable might jump in and change contentX value back, causing the code below to do
+                // "phase = 1" which will make the spread stay.
+                // It sucks that we have no control whatsoever over whether or when Flickable animates its
+                // contentX.
+                if (root.spreadEnabled && shiftedContentX > width * positionMarker2) {
+                    phase = 1;
+                }
+                break;
+            case 1:
+                if (shiftedContentX < width * positionMarker2) {
+                    phase = 0;
+                } else if (shiftedContentX >= width * positionMarker4 && !spreadDragArea.dragging) {
+                    phase = 2;
+                }
+                break;
             }
         }
 
@@ -446,6 +491,7 @@
         }
 
         function snapTo(index) {
+            snapAnimation.stop();
             spreadView.selectedIndex = index;
             snapAnimation.targetContentX = -shift;
             snapAnimation.start();
@@ -455,55 +501,41 @@
         // We don't want to really reorder them in the model because that allows us to keep track
         // of the last focused order.
         function indexToZIndex(index) {
+            // only shuffle when we've got a main and overlay
+            if (state !== "mainAndOverlay") return index;
+
             var app = ApplicationManager.get(index);
             if (!app) {
                 return index;
             }
 
-            var active = app.appId == priv.mainStageAppId || app.appId == priv.sideStageAppId;
-            if (active && app.stage == ApplicationInfoInterface.MainStage) {
-                // if this app is active, and its the MainStage, always put it to index 0
+            // don't shuffle indexes greater than "actives or next"
+            if (index > 2) return index;
+
+            if (app.appId === priv.mainStageAppId) {
+                // Active main stage always at 0
                 return 0;
             }
-            if (active && app.stage == ApplicationInfoInterface.SideStage) {
-                if (!priv.mainStageAppId) {
-                    // Only have SS apps running. Put the active one at 0
-                    return 0;
-                }
-
-                // Precondition now: There's an active MS app and this is SS app:
-                if (spreadView.nextInStack >= 0 && ApplicationManager.get(spreadView.nextInStack).stage == ApplicationInfoInterface.MainStage) {
-                    // If the next app coming from the right is a MS app, we need to elevate this SS ap above it.
-                    // Put it to at least level 2, or higher if there's more apps coming in before this one.
-                    return Math.max(index, 2);
-                } else {
-                    // if this is no next app to come in from the right, place this one at index 1, just on top the active MS app.
-                    return 1;
-                }
-            }
-            if (index <= 2 && app.stage == ApplicationInfoInterface.MainStage && priv.sideStageAppId) {
-                // Ok, this is an inactive MS app. If there's an active SS app around, we need to place this one
-                // in between the active MS app and the active SS app, so that it comes in from there when dragging from the right.
-                // If there's now active SS app, just leave it where it is.
-                return priv.indexOf(priv.sideStageAppId) < index ? index - 1 : index;
-            }
-            if (index == spreadView.nextInStack && app.stage == ApplicationInfoInterface.SideStage) {
-                // This is a SS app and the next one to come in from the right:
-                if (priv.sideStageAppId && priv.mainStageAppId) {
-                    // If there's both, an active MS and an active SS app, put this one right on top of that
-                    return 2;
-                }
-                // Or if there's only one other active app, put it on top of that.
-                // The case that there isn't any other active app is already handled above.
-                return 1;
-            }
-            if (index == 2 && spreadView.nextInStack == 1 && priv.sideStageAppId) {
-                // If its index 2 but not the next one to come in, it means
-                // we've pulled another one down to index 2. Move this one up to 2 instead.
-                return 3;
-            }
-            // don't touch all others... (mostly index > 3 + simple cases where the above doesn't shuffle much)
-            return index;
+
+            if (spreadView.nextInStack > 0) {
+                var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);
+
+                if (index === spreadView.nextInStack) {
+                    // this is the next app in stack.
+
+                    if (app.stage ===  ApplicationInfoInterface.SideStage) {
+                        // if the next app in stack is a sidestage app, it must order on top of other side stage app
+                        return Math.min(2, ApplicationManager.count-1);
+                    }
+                    return 1;
+                }
+                if (nextAppInStack.stage ===  ApplicationInfoInterface.SideStage) {
+                    // if the next app in stack is a sidestage app, it must order on top of other side stage app
+                    return 1;
+                }
+                return Math.min(2, ApplicationManager.count-1);
+            }
+            return Math.min(index+1, ApplicationManager.count-1);
         }
 
         SequentialAnimation {
@@ -521,8 +553,12 @@
                 script: {
                     if (spreadView.selectedIndex >= 0) {
                         var newIndex = spreadView.selectedIndex;
+                        var application = ApplicationManager.get(newIndex);
+                        if (application.stage === ApplicationInfoInterface.SideStage) {
+                            sideStage.showNow();
+                        }
                         spreadView.selectedIndex = -1;
-                        ApplicationManager.focusApplication(ApplicationManager.get(newIndex).appId);
+                        ApplicationManager.focusApplication(application.appId);
                         spreadView.phase = 0;
                         spreadView.contentX = -spreadView.shift;
                     }
@@ -545,87 +581,82 @@
                 spreadView.snapTo(0);
             }
 
-            Rectangle {
-                id: sideStageBackground
-                color: "black"
-                width: spreadView.sideStageWidth * (1 - sideStageDragHandle.progress)
+            DropArea {
+                objectName: "MainStageDropArea"
+                anchors {
+                    left: parent.left
+                    top: parent.top
+                    bottom: parent.bottom
+                }
+                width: spreadView.width - sideStage.width
+                enabled: priv.sideStageEnabled
+
+                onDropped: {
+                    priv.setAppStage(drag.source.appId, ApplicationInfoInterface.MainStage, true);
+                    ApplicationManager.focusApplication(drag.source.appId);
+                }
+                keys: "SideStage"
+            }
+
+            SideStage {
+                id: sideStage
+                objectName: "sideStage"
                 height: priv.landscapeHeight
                 x: spreadView.width - width
-                z: spreadView.indexToZIndex(priv.indexOf(priv.sideStageAppId))
-                opacity: spreadView.phase == 0 ? 1 : 0
-                Behavior on opacity { UbuntuNumberAnimation {} }
-            }
-
-            Item {
-                id: sideStageDragHandle
-                anchors.right: sideStageBackground.left
-                anchors.top: sideStageBackground.top
-                width: units.gu(2)
-                height: priv.landscapeHeight
-                z: sideStageBackground.z
-                opacity: spreadView.phase <= 0 && spreadView.sideStageVisible ? 1 : 0
-                property real progress: 0
-                property bool dragging: false
-
-                Behavior on opacity { UbuntuNumberAnimation {} }
-
-                Connections {
-                    target: spreadView
-                    onSideStageVisibleChanged: {
-                        if (spreadView.sideStageVisible) {
-                            sideStageDragHandle.progress = 0;
+                z: {
+                    if (!priv.mainStageAppId) return 0;
+
+                    if (priv.sideStageAppId && spreadView.nextInStack > 0) {
+                        var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);
+
+                        if (nextAppInStack.stage ===  ApplicationInfoInterface.MainStage) {
+                            // if the next app in stack is a main stage app, put the sidestage on top of it.
+                            return 2;
                         }
-                    }
-                }
-
-                Image {
-                    anchors.centerIn: parent
-                    width: sideStageDragHandleMouseArea.pressed ? parent.width * 2 : parent.width
-                    height: parent.height
-                    source: "graphics/[e-mail]"
-                    Behavior on width { UbuntuNumberAnimation {} }
-                }
-
-                MouseArea {
-                    id: sideStageDragHandleMouseArea
+                        return 1;
+                    }
+
+                    return 1;
+                }
+                visible: progress != 0
+                enabled: priv.sideStageEnabled && sideStageDropArea.dropAllowed
+                opacity: priv.sideStageEnabled && !spreadView.active ? 1 : 0
+                Behavior on opacity { UbuntuNumberAnimation {} }
+
+                onShownChanged: {
+                    if (!shown && ApplicationManager.focusedApplicationId == priv.sideStageAppId) {
+                        ApplicationManager.requestFocusApplication(priv.mainStageAppId);
+                    }
+                    priv.updateStageApps();
+                    if (shown && priv.sideStageAppId) {
+                        ApplicationManager.requestFocusApplication(priv.sideStageAppId);
+                    }
+                }
+
+                DropArea {
+                    id: sideStageDropArea
+                    objectName: "SideStageDropArea"
                     anchors.fill: parent
-                    enabled: spreadView.shiftedContentX == 0
-                    property int startX
-                    property var gesturePoints: new Array()
-                    property real totalDiff
-
-                    onPressed: {
-                        gesturePoints = [];
-                        startX = mouseX;
-                        totalDiff = 0.0;
-                        sideStageDragHandle.progress = 0;
-                        sideStageDragHandle.dragging = true;
-                    }
-                    onMouseXChanged: {
-                        totalDiff += mouseX - startX;
-                        if (priv.mainStageAppId) {
-                            sideStageDragHandle.progress = Math.max(0, totalDiff / spreadView.sideStageWidth);
-                        }
-                        gesturePoints.push(mouseX);
-                    }
-                    onReleased: {
-                        if (priv.mainStageAppId) {
-                            var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
-                            sideStageDragSnapAnimation.to = sideStageDragHandle.progress > 0.5 || oneWayFlick ? 1 : 0;
-                            sideStageDragSnapAnimation.start();
-                        } else {
-                            sideStageDragHandle.dragging = false;
-                        }
-                    }
-                }
-                UbuntuNumberAnimation {
-                    id: sideStageDragSnapAnimation
-                    target: sideStageDragHandle
-                    property: "progress"
-
-                    onRunningChanged: {
-                        if (!running) {
-                            sideStageDragHandle.dragging = false;
+
+                    property bool dropAllowed: true
+
+                    onEntered: {
+                        dropAllowed = drag.keys != "Disabled";
+                    }
+                    onExited: {
+                        dropAllowed = true;
+                    }
+                    onDropped: {
+                        if (drop.keys == "MainStage") {
+                            priv.setAppStage(drop.source.appId, ApplicationInfoInterface.SideStage, true);
+                            ApplicationManager.requestFocusApplication(drop.source.appId);
+                        }
+                    }
+                    drag {
+                        onSourceChanged: {
+                            if (!sideStageDropArea.drag.source) {
+                                dropAllowed = true;
+                            }
                         }
                     }
                 }
@@ -640,37 +671,53 @@
                     id: spreadTile
                     objectName: model.appId ? "tabletSpreadDelegate_" + model.appId
                                             : "tabletSpreadDelegate_null";
-                    width: {
-                        if (wantsMainStage) {
-                            return spreadView.width;
-                        } else {
-                            return spreadView.sideStageWidth;
-                        }
-                    }
-                    height: {
-                        if (wantsMainStage) {
-                            return spreadView.height;
-                        } else {
-                            return priv.landscapeHeight;
-                        }
-                    }
-                    active: model.appId == priv.mainStageAppId || model.appId == priv.sideStageAppId
-                    zIndex: spreadView.indexToZIndex(index)
+                    width: spreadView.width
+                    height: spreadView.height
+                    active: appId == priv.mainStageAppId || appId == priv.sideStageAppId
+                    zIndex: selected && stage == ApplicationInfoInterface.MainStage ? 0 : spreadView.indexToZIndex(index)
                     selected: spreadView.selectedIndex == index
                     otherSelected: spreadView.selectedIndex >= 0 && !selected
-                    isInSideStage: priv.sideStageAppId == model.appId
+                    isInSideStage: priv.sideStageAppId === appId
                     interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive
                     swipeToCloseEnabled: spreadView.interactive && !snapAnimation.running
                     maximizedAppTopMargin: root.maximizedAppTopMargin
-                    dragOffset: !isDash && model.appId == priv.mainStageAppId && root.inverseProgress > 0 && spreadView.phase === 0 ? root.inverseProgress : 0
+                    dragOffset: !isDash && appId == priv.mainStageAppId && root.inverseProgress > 0 && spreadView.phase === 0 ? root.inverseProgress : 0
                     application: ApplicationManager.get(index)
                     closeable: !isDash
                     highlightShown: root.altTabPressed && priv.highlightIndex == zIndex
 
                     readonly property bool wantsMainStage: model.stage == ApplicationInfoInterface.MainStage
 
+                    readonly property string appId: model.appId
                     readonly property bool isDash: model.appId == "unity8-dash"
 
+                    stage: model.stage
+                    fullscreen: {
+                        if (mainApp && stage === ApplicationInfoInterface.SideStage) {
+                            return mainApp.fullscreen;
+                        }
+                        return application ? application.fullscreen : false;
+                    }
+
+                    supportedOrientations: {
+                        if (application) {
+                            var orientations = application.supportedOrientations;
+                            if (stage == ApplicationInfoInterface.MainStage) {
+                                // When an app is in the mainstage, it always supports Landscape|InvertedLandscape
+                                // so that we can drag it from the main stage to the side stage
+                                orientations |= Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation;
+                            }
+                            return orientations;
+                        } else {
+                            // we just don't care
+                            return Qt.PortraitOrientation |
+                                   Qt.LandscapeOrientation |
+                                   Qt.InvertedPortraitOrientation |
+                                   Qt.InvertedLandscapeOrientation;
+                        }
+                    }
+
+
                     Binding {
                         target: spreadTile.application
                         property: "exemptFromLifecycle"
@@ -701,6 +748,28 @@
                         enabled: spreadView.closingIndex >= 0
                         UbuntuNumberAnimation {}
                     }
+                    Connections {
+                        target: priv
+                        onSideStageEnabledChanged: refreshStage()
+                    }
+
+                    Component.onCompleted: {
+                        refreshStage()
+                        stageChanged.connect(priv.updateStageApps);
+                    }
+
+                    function refreshStage() {
+                        var stage = ApplicationInfoInterface.MainStage;
+                        if (priv.sideStageEnabled) {
+                            if (application && application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {
+                                stage = WindowStateStorage.getStage(appId);
+                            }
+                        }
+
+                        if (model.stage !== stage) {
+                            priv.setAppStage(appId, stage, false);
+                        }
+                    }
 
                     // This is required because none of the bindings are triggered in some cases:
                     // When an app is closed, it might happen that ApplicationManager.get(nextInStack)
@@ -725,7 +794,7 @@
 
                     // TODO: Hiding tile when progress is such that it will be off screen.
                     property bool occluded: {
-                        if (spreadView.active) return false;
+                        if (spreadView.active && !offScreen) return false;
                         else if (spreadTile.active) return false;
                         else if (xTranslateAnimating) return false;
                         else if (z <= 1 && priv.focusedAppDelegateIsDislocated) return false;
@@ -749,17 +818,87 @@
                         return progress;
                     }
 
-                    shellOrientationAngle: wantsMainStage ? root.shellOrientationAngle : 0
-                    shellOrientation: wantsMainStage ? root.shellOrientation : Qt.PortraitOrientation
-                    orientations: Orientations {
-                        primary: spreadTile.wantsMainStage ? root.orientations.primary : Qt.PortraitOrientation
-                        native_: spreadTile.wantsMainStage ? root.orientations.native_ : Qt.PortraitOrientation
+                    shellOrientationAngle: root.shellOrientationAngle
+                    shellOrientation: root.shellOrientation
+                    orientations: root.orientations
+
+                    states: [
+                        State {
+                            name: "MainStage"
+                            when: spreadTile.stage == ApplicationInfoInterface.MainStage
+                        },
+                        State {
+                            name: "SideStage"
+                            when: spreadTile.stage == ApplicationInfoInterface.SideStage
+
+                            PropertyChanges {
+                                target: spreadTile
+                                width: spreadView.sideStageWidth
+                                height: priv.landscapeHeight
+
+                                supportedOrientations: Qt.PortraitOrientation
+                                shellOrientationAngle: 0
+                                shellOrientation: Qt.PortraitOrientation
+                                orientations: sideStageOrientations
+                            }
+                        }
+                    ]
+
+                    Orientations {
+                        id: sideStageOrientations
+                        primary: Qt.PortraitOrientation
+                        native_: Qt.PortraitOrientation
                         portrait: root.orientations.portrait
                         invertedPortrait: root.orientations.invertedPortrait
                         landscape: root.orientations.landscape
                         invertedLandscape: root.orientations.invertedLandscape
                     }
 
+                    transitions: [
+                        Transition {
+                            to: "SideStage"
+                            SequentialAnimation {
+                                PropertyAction {
+                                    target: spreadTile
+                                    properties: "width,height,supportedOrientations,shellOrientationAngle,shellOrientation,orientations"
+                                }
+                                ScriptAction {
+                                    script: {
+                                        // rotate immediately.
+                                        spreadTile.matchShellOrientation();
+                                        if (ApplicationManager.focusedApplicationId === spreadTile.appId &&
+                                                priv.sideStageEnabled && !sideStage.shown) {
+                                            // Sidestage was focused, so show the side stage.
+                                            sideStage.show();
+                                        // if we've switched to a main app which doesnt support portrait, hide the side stage.
+                                        } else if (mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {
+                                            sideStage.hideNow();
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        Transition {
+                            from: "SideStage"
+                            SequentialAnimation {
+                                ScriptAction {
+                                    script: {
+                                        if (priv.sideStageAppId === spreadTile.appId &&
+                                                mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {
+                                            // The mainstage app did not natively support portrait orientation, so focus the sidestage.
+                                            ApplicationManager.requestFocusApplication(spreadTile.appId);
+                                        }
+                                    }
+                                }
+                                PropertyAction {
+                                    target: spreadTile
+                                    properties: "width,height,supportedOrientations,shellOrientationAngle,shellOrientation,orientations"
+                                }
+                                ScriptAction { script: { spreadTile.matchShellOrientation(); } }
+                            }
+                        }
+                    ]
+
                     onClicked: {
                         if (spreadView.phase == 2) {
                             spreadView.snapTo(index);
@@ -779,6 +918,16 @@
                         ApplicationManager.stopApplication(ApplicationManager.get(index).appId);
                     }
 
+                    onFocusChanged: {
+                        if (focus && ApplicationManager.focusedApplicationId !== appId) {
+                            ApplicationManager.focusApplication(appId);
+                        }
+
+                        if (focus && priv.sideStageEnabled && stage === ApplicationInfoInterface.SideStage) {
+                            sideStage.show();
+                        }
+                    }
+
                     Binding {
                         target: root
                         when: model.appId == priv.mainStageAppId
@@ -803,6 +952,71 @@
         }
     }
 
+    TabletSideStageTouchGesture {
+        id: triGestureArea
+        anchors.fill: parent
+        enabled: priv.sideStageEnabled && !spreadView.active
+        property var dragObject: null
+        property string appId: ""
+        dragComponent: dragComponent
+        dragComponentProperties: { "appId": appId }
+
+        onPressed: {
+            function matchDelegate(obj) { return String(obj.objectName).indexOf("tabletSpreadDelegate") >= 0; }
+
+            var delegateAtCenter = Functions.itemAt(spreadRow, x, y, matchDelegate);
+            if (!delegateAtCenter) return;
+
+            appId = delegateAtCenter.appId;
+        }
+
+        onClicked: {
+            if (sideStage.shown) {
+               sideStage.hide();
+            } else  {
+               sideStage.show();
+            }
+        }
+
+        onDragStarted: {
+            // If we're dragging to the sidestage.
+            if (!sideStage.shown) {
+                sideStage.show();
+            }
+        }
+
+        Component {
+            id: dragComponent
+            SessionContainer {
+                property string appId: ""
+                property var application: ApplicationManager.findApplication(appId)
+
+                session: application ? application.session : null
+                interactive: false
+                resizeSurface: false
+                focus: false
+
+                width: units.gu(40)
+                height: units.gu(40)
+
+                Drag.hotSpot.x: width/2
+                Drag.hotSpot.y: height/2
+                // only accept opposite stage.
+                Drag.keys: {
+                    if (!application) return "Disabled";
+
+                    if (application.stage === ApplicationInfo.MainStage) {
+                        if (application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {
+                            return "MainStage";
+                        }
+                        return "Disabled";
+                    }
+                    return "SideStage";
+                }
+            }
+        }
+    }
+
     //eat touch events during the right edge gesture
     MouseArea {
         anchors.fill: parent
@@ -812,7 +1026,8 @@
     DirectionalDragArea {
         id: spreadDragArea
         objectName: "spreadDragArea"
-        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
+        x: parent.width - root.dragAreaWidth
+        anchors { top: parent.top; bottom: parent.bottom }
         width: root.dragAreaWidth
         direction: Direction.Leftwards
         enabled: (spreadView.phase != 2 && root.spreadEnabled) || dragging

=== modified file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
--- qml/Stages/TransformedTabletSpreadDelegate.qml	2015-11-04 14:58:05 +0000
+++ qml/Stages/TransformedTabletSpreadDelegate.qml	2016-03-16 20:46:19 +0000
@@ -31,6 +31,7 @@
     // Set this to true when this tile a currently active on either the MS or the SS.
     property bool active: false
 
+    property int stage
     property int zIndex
     property real progress: 0
     property real animatedProgress: 0
@@ -49,10 +50,11 @@
 
     property int dragOffset: 0
     readonly property alias xTranslateAnimating: xTranslateAnimation.running
+    readonly property bool offScreen: priv.xTranslate >= 0
 
     dropShadow: spreadView.active ||
                 (active
-                 && (model.stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)
+                 && (stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)
                  && priv.xTranslate != 0)
 
     onSelectedChanged: {
@@ -141,9 +143,9 @@
             enabled: !spreadView.active &&
                      !snapAnimation.running &&
                      model.appId !== "unity8-dash" &&
-                     !spreadView.sideStageDragging &&
                      spreadView.animateX &&
-                     !spreadView.beingResized
+                     !spreadView.beingResized &&
+                     priv.state !== "sideStage"
             UbuntuNumberAnimation {
                 id: xTranslateAnimation
                 duration: UbuntuAnimation.FastDuration
@@ -153,21 +155,20 @@
         property real xTranslate: {
             var newTranslate = 0;
 
-            if (otherSelected) {
-                return priv.selectedXTranslate;
-            }
-
-            if (isSelected) {
-                if (model.stage == ApplicationInfoInterface.MainStage) {
+            // selected app or opposite stage active app.
+            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
+                if (stage == ApplicationInfoInterface.MainStage) {
                     return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.width, root.progress);
                 } else {
                     return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.sideStageWidth, root.progress);
                 }
+            } else if (otherSelected) {
+                return selectedXTranslate;
             }
 
             // The tile should move a bit to the left if a new one comes on top of it, but not for the Side Stage and not
             // when we're only dragging the side stage in on top of a main stage app
-            var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && model.stage === ApplicationInfoInterface.MainStage &&
+            var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && stage === ApplicationInfoInterface.MainStage &&
                     ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;
 
             if (active) {
@@ -177,36 +178,45 @@
                     newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);
                 }
                 newTranslate += root.dragOffset;
-            }
-            if (!spreadView.active && model.appId == "unity8-dash" && !root.active) {
+            } else if (!spreadView.active && model.appId == "unity8-dash") {
                 newTranslate -= root.width;
             }
 
-            if (nextInStack && spreadView.phase == 0) {
-                if (model.stage == ApplicationInfoInterface.MainStage) {
-                    if (spreadView.sideStageVisible && root.progress > 0) {
-                        // Move it so it appears from behind the side stage immediately
-                        newTranslate += -spreadView.sideStageWidth;
-                    }
-                }
-
-                if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
-                    // This is when we only drag the side stage in, without rotation or snapping
-                    newTranslate = linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth, root.progress);
-                } else {
-                    newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth * spreadView.snapPosition, root.animatedProgress);
+            if (!spreadView.active) {
+                return newTranslate;
+            }
+
+            var shadowOffset = units.gu(2);
+
+            if (spreadView.phase == 0) {
+                if (nextInStack) {
+                    if (stage == ApplicationInfoInterface.MainStage) {
+                        if (spreadView.sideStageVisible && root.progress > 0) {
+                            // Move it so it appears from behind the side stage immediately
+                            newTranslate += -spreadView.sideStageWidth;
+                        }
+                    }
+
+                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
+                        // This is when we only drag the side stage in, without rotation or snapping
+                        newTranslate = linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth, root.animatedProgress);
+                    } else {
+                        newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth * spreadView.snapPosition, root.animatedProgress);
+                    }
+                } else if (!root.active) {
+                    newTranslate += shadowOffset;
                 }
             }
 
             if (spreadView.phase == 1) {
                 if (nextInStack) {
-                    if (model.stage == ApplicationInfoInterface.MainStage) {
+                    if (stage == ApplicationInfoInterface.MainStage) {
                         var startValue = -spreadView.sideStageWidth * spreadView.snapPosition + (spreadView.sideStageVisible ? -spreadView.sideStageWidth : 0);
                         newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startValue, priv.phase2StartTranslate, root.animatedProgress);
                     } else {
                         var endValue = -spreadView.width + spreadView.width * root.zIndex / 6;
                         if (!spreadView.sideStageVisible) {
-                            newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, -spreadView.sideStageWidth, priv.phase2StartTranslate, root.progress);
+                            newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, -spreadView.sideStageWidth, priv.phase2StartTranslate, root.animatedProgress);
                         } else {
                             newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, -spreadView.sideStageWidth * spreadView.snapPosition, priv.phase2StartTranslate, root.animatedProgress);
                         }
@@ -215,16 +225,20 @@
                     var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
                     var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
                     var startTranslate = -root.width + (shouldMoveAway ? -units.gu(4) : 0);
-                    newTranslate = linearAnimation(startProgress, endProgress, startTranslate, priv.phase2StartTranslate, root.progress);
+                    newTranslate = linearAnimation(startProgress, endProgress, startTranslate, priv.phase2StartTranslate, root.animatedProgress);
                 } else {
                     var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
                     var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
-                    newTranslate = linearAnimation(startProgress, endProgress, 0, priv.phase2StartTranslate, root.progress);
+                    newTranslate = linearAnimation(startProgress, endProgress, shadowOffset * Math.max(0, zIndex-2), priv.phase2StartTranslate, root.animatedProgress);
                 }
             }
 
             if (spreadView.phase == 2) {
-                newTranslate = -easingCurve.value * (spreadView.width - root.zIndex * animatedEndDistance);
+                if (easingCurve.value == 0 && !nextInStack) {
+                    newTranslate = shadowOffset;
+                } else {
+                    newTranslate = -easingCurve.value * (spreadView.width - root.zIndex * animatedEndDistance);
+                }
             }
 
             return newTranslate;
@@ -235,33 +249,30 @@
                 return 1;
             }
 
-            if (otherSelected) {
+            // selected app or opposite stage active app.
+            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
+                return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);
+            } else if (otherSelected) {
                 return selectedScale;
             }
 
-            if (isSelected) {
-                return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);
-            }
-
             if (spreadView.phase == 0) {
                 if (nextInStack) {
-                    if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
+                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                         return 1;
                     } else {
                         var targetScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
                         return linearAnimation(0, spreadView.positionMarker2, root.dragStartScale, targetScale, root.animatedProgress);
                     }
-                } else if (active) {
+                } else {
                     return 1;
-                } else {
-                    return linearAnimation(0, spreadView.positionMarker2, root.startScale, root.endScale, root.progress);
                 }
             }
 
             if (spreadView.phase == 1) {
                 if (nextInStack) {
                     var startScale = 1;
-                    if (model.stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {
+                    if (stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {
                         startScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
                     }
                     return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startScale, priv.phase2StartScale, root.animatedProgress);
@@ -283,21 +294,22 @@
                 return 0;
             }
 
-            if (otherSelected) {
+            // selected app or opposite stage active app.
+            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
+                return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);
+            } else if (otherSelected) {
                 return selectedAngle;
             }
-            if (isSelected) {
-                return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);
-            }
 
             // The tile should rotate a bit when another one comes on top, but not when only dragging the side stage in
-            var shouldMoveAway = spreadView.nextInStack >= 0 && movedActive &&
+            var shouldMoveAway = spreadView.nextInStack == -1 ||
+                    spreadView.nextInStack >= 0 && priv.movedActive &&
                     (ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||
-                     model.stage == ApplicationInfoInterface.SideStage);
+                     stage == ApplicationInfoInterface.SideStage);
 
             if (spreadView.phase == 0) {
                 if (nextInStack) {
-                    if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
+                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                         return 0;
                     } else {
                         return linearAnimation(0, spreadView.positionMarker2, root.startAngle, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);
@@ -309,7 +321,7 @@
             }
             if (spreadView.phase == 1) {
                 if (nextInStack) {
-                    if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
+                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                         return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, 0, priv.phase2StartAngle, root.animatedProgress);
                     } else {
                         return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, root.startAngle * (1-spreadView.snapPosition), priv.phase2StartAngle, root.animatedProgress);
@@ -328,31 +340,47 @@
         }
 
         property real opacityTransform: {
-            if (otherSelected && spreadView.phase == 2) {
+            // animate opacity for items not snapping into view.
+            if (spreadView.phase !== 2) return 1;
+            if (root.isSelected) return 1;
+
+            if (otherSelected) {
+                if (root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage) {
+                    return 1;
+                }
                 return linearAnimation(selectedProgress, negativeProgress, selectedOpacity, 0, root.progress);
             }
-
             return 1;
         }
 
         property real topMarginProgress: {
-            if (priv.isSelected) {
+            // selected app or opposite stage active app.
+            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
                 return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);
             }
-            switch (spreadView.phase) {
-            case 0:
+
+            if (spreadView.phase == 0) {
                 return 0;
-            case 1:
-                return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4,
-                                       0, priv.phase2StartTopMarginProgress, root.progress);
+            } else if (spreadView.phase == 1) {
+                if (nextInStack) {
+                    return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4,
+                                           0, 1, root.progress);
+                }
+                var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
+                var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
+                return linearAnimation(startProgress, endProgress, 0, 1, root.progress);
             }
             return 1;
         }
 
         states: [
             State {
-                name: "sideStageDragging"; when: spreadView.sideStageDragging && root.isInSideStage
-                PropertyChanges { target: priv; xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * spreadView.sideStageDragProgress }
+                name: "sideStage";
+                when: root.isInSideStage && spreadView.shiftedContentX == 0 && spreadView.phase == 0
+                PropertyChanges {
+                    target: priv;
+                    xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * (1-spreadView.sideStageDragProgress)
+                }
             }
         ]
     }

=== added file 'qml/Stages/graphics/sidestage_drag.svg'
--- qml/Stages/graphics/sidestage_drag.svg	1970-01-01 00:00:00 +0000
+++ qml/Stages/graphics/sidestage_drag.svg	2016-03-16 20:46:19 +0000
@@ -0,0 +1,207 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="540"
+   height="324"
+   id="svg4874"
+   version="1.1"
+   inkscape:version="0.91+devel r"
+   viewBox="0 0 540 324"
+   sodipodi:docname="gesture_3f_touch.svg">
+  <defs
+     id="defs4876" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#292929"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="1"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.1785993"
+     inkscape:cx="-19.084613"
+     inkscape:cy="11.707485"
+     inkscape:document-units="px"
+     inkscape:current-layer="g4780"
+     showgrid="false"
+     showborder="true"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:snap-bbox="true"
+     inkscape:bbox-paths="true"
+     inkscape:bbox-nodes="true"
+     inkscape:snap-bbox-edge-midpoints="true"
+     inkscape:snap-bbox-midpoints="true"
+     inkscape:object-paths="true"
+     inkscape:snap-intersection-paths="true"
+     inkscape:object-nodes="true"
+     inkscape:snap-smooth-nodes="true"
+     inkscape:snap-midpoints="true"
+     inkscape:snap-object-midpoints="true"
+     inkscape:snap-center="true"
+     showguides="false"
+     inkscape:guide-bbox="true"
+     inkscape:snap-global="true"
+     inkscape:snap-others="false"
+     inkscape:snap-page="true">
+    <inkscape:grid
+       type="xygrid"
+       id="grid5451"
+       empspacing="8"
+       originx="-2.7715014e-06"
+       originy="-2.5124622e-06" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="7.9999972,-8.0000025"
+       id="guide4063"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="3.9999972,-8.0000025"
+       id="guide4065"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-8.0000027,87.999998"
+       id="guide4067"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-8.0000027,91.999998"
+       id="guide4069"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="104,3.9999975"
+       id="guide4071"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-5.0000027,7.9999975"
+       id="guide4073"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="91.999996,-8.0000025"
+       id="guide4075"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="87.999997,-8.0000025"
+       id="guide4077"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-8.0000027,83.999998"
+       id="guide4074"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="11.999997,-8.0000025"
+       id="guide4076"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-5.0000027,11.999997"
+       id="guide4078"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="83.999997,-9.0000025"
+       id="guide4080"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       position="47.999997,-8.0000025"
+       orientation="1,0"
+       id="guide4170"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       position="-8.0000027,47.999997"
+       orientation="0,1"
+       id="guide4172"
+       inkscape:locked="false" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata4879">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(67.857143,149.49498)">
+    <g
+       transform="matrix(0,-1,-1,0,373.50506,516.50504)"
+       id="g4845"
+       style="display:inline">
+      <g
+         inkscape:export-ydpi="90"
+         inkscape:export-xdpi="90"
+         inkscape:export-filename="next01.png"
+         transform="matrix(-0.9996045,0,0,1,575.94296,-611.00001)"
+         id="g4778"
+         inkscape:label="Layer 1">
+        <g
+           transform="matrix(-1,0,0,1,575.99999,611)"
+           id="g4780"
+           style="display:inline">
+          <path
+             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:53.6204567px;line-height:125%;font-family:Ubuntu;-inkscape-font-specification:Ubuntu;text-align:end;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:end;display:inline;fill:none;fill-opacity:1;stroke:#f7f7f7;stroke-width:4.00079107;stroke-miterlimit:4;stroke-dasharray:none"
+             d="m 526.90578,343.72628 c 14.3803,3.85163 8.37809,26.10701 -5.96811,22.26448 l -10e-6,10e-6 -50.91437,-13.63709 67.92084,18.21108 c 15.93089,4.26693 9.28148,28.92202 -6.61162,24.66516 l -10e-6,1e-5 -67.93497,-18.15834 58.38757,15.63874 c 15.85637,4.24702 9.23761,28.78845 -6.58115,24.5515 v -2e-5 l 1e-5,-2e-5 -71.03537,-19.00646 -33.09607,-8.85524 -0.18781,-0.0503 v 0 l -6.91408,-1.85189 18.07353,23.47068 c 8.45364,10.48525 11.9521,17.66446 -3.54852,27.89697 l -43.91145,-37.31132 c -28.38683,-22.97811 -35.17793,-41.86133 -27.95127,-70.42985 10.25002,-40.5206 40.5632,-49.89857 76.24862,-40.34047 4.5224,1.21129 36.24839,9.63672 40.29164,10.71968 14.0412,3.76084 12.54552,13.74563 6.76936,26.96549 z"
+             id="path4845-6"
+             inkscape:connector-curvature="0"
+             sodipodi:nodetypes="ccccccccccccccccccccssscc" />
+          <path
+             style="color:#000000;display:inline;overflow:visible;visibility:visible;opacity:0.25;fill:#f7f7f7;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:2.51758671;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;enable-background:accumulate"
+             d="m 571.27587,383.27233 a 35.064884,35.05101 0 0 1 -16.02978,29.39649 35.064884,35.05101 0 0 1 -34.38665,28.3418 35.064884,35.05101 0 0 1 -34.85362,-31.56055 l 29.19904,7.8125 c 15.81876,4.23695 22.4371,-20.30571 6.58073,-24.55274 l -28.91769,-7.74609 a 35.064884,35.05101 0 0 1 0.01,-0.0137 l 38.45466,10.2793 c 15.8931,4.25686 22.54288,-20.39714 6.61199,-24.66407 l -48.41758,-12.98242 a 35.064884,35.05101 0 0 1 0,-0.006 l 31.41086,8.41407 c 14.3462,3.84253 20.34945,-18.414 5.96915,-22.26563 l -31.70199,-8.49023 a 35.064884,35.05101 0 0 1 29.21468,-15.70704 35.064884,35.05101 0 0 1 35.06465,35.05274 35.064884,35.05101 0 0 1 -0.0879,2.45312 35.064884,35.05101 0 0 1 11.8797,26.23828 z"
+             id="ellipse4239-1"
+             inkscape:connector-curvature="0" />
+          <g
+             style="display:inline"
+             id="g5379"
+             transform="matrix(-0.99999722,0,0,-0.99999722,645.25394,919.46958)">
+            <path
+               style="color:#000000;display:inline;overflow:visible;visibility:visible;fill:none;stroke:#f7f7f7;stroke-width:4.00079107;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;enable-background:accumulate"
+               id="path4116"
+               sodipodi:type="arc"
+               sodipodi:cx="808.72699"
+               sodipodi:cy="244.79436"
+               sodipodi:rx="250.36082"
+               sodipodi:ry="263.63275"
+               sodipodi:start="3.8048178"
+               sodipodi:end="5.6286868"
+               sodipodi:open="true"
+               d="M 611.43997,82.485822 A 250.36082,263.63275 0 0 1 809.81939,-18.835885 250.36082,263.63275 0 0 1 1007.3516,84.304899"
+               inkscape:transform-center-x="-17.044876"
+               inkscape:transform-center-y="-0.0015034578"
+               transform="matrix(0,1,1,0,0,0)" />
+            <path
+               inkscape:transform-center-y="4.9738279"
+               inkscape:transform-center-x="2.0443183"
+               inkscape:connector-curvature="0"
+               id="path4198"
+               d="m 73.559638,1014.0226 14.78221,-18.91287 c 0,0 6.80763,12.50667 9.95238,23.00047 -10.9469,-0.5114 -24.73459,-4.0876 -24.73459,-4.0876 z"
+               style="color:#000000;display:inline;overflow:visible;visibility:visible;opacity:1;fill:#f7f7f7;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:3.00059342;marker:none;enable-background:accumulate" />
+          </g>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>

=== added file 'qml/Stages/graphics/sidestage_open.svg'
--- qml/Stages/graphics/sidestage_open.svg	1970-01-01 00:00:00 +0000
+++ qml/Stages/graphics/sidestage_open.svg	2016-03-16 20:46:19 +0000
@@ -0,0 +1,181 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="162"
+   height="230"
+   id="svg4874"
+   version="1.1"
+   inkscape:version="0.91+devel r"
+   viewBox="0 0 162 230"
+   sodipodi:docname="gesture_3f_tap.svg"
+   style="shape-rendering:crispEdges">
+  <defs
+     id="defs4876" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#292929"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="1"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.8415614"
+     inkscape:cx="162.13161"
+     inkscape:cy="116.01485"
+     inkscape:document-units="px"
+     inkscape:current-layer="g4780"
+     showgrid="false"
+     showborder="true"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:snap-bbox="true"
+     inkscape:bbox-paths="true"
+     inkscape:bbox-nodes="true"
+     inkscape:snap-bbox-edge-midpoints="true"
+     inkscape:snap-bbox-midpoints="true"
+     inkscape:object-paths="true"
+     inkscape:snap-intersection-paths="true"
+     inkscape:object-nodes="true"
+     inkscape:snap-smooth-nodes="true"
+     inkscape:snap-midpoints="true"
+     inkscape:snap-object-midpoints="true"
+     inkscape:snap-center="true"
+     showguides="false"
+     inkscape:guide-bbox="true"
+     inkscape:snap-global="false"
+     inkscape:snap-others="false"
+     inkscape:snap-page="true">
+    <inkscape:grid
+       type="xygrid"
+       id="grid5451"
+       empspacing="8"
+       originx="-2.7715014e-06"
+       originy="-2.5124622e-06" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="7.9999972,-8.0000026"
+       id="guide4063"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="1,0"
+       position="3.9999972,-8.0000026"
+       id="guide4065"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-8.0000027,87.999998"
+       id="guide4067"
+       inkscape:locked="false" />
+    <sodipodi:guide
+       orientation="0,1"
+       position="-8.0000027,91.999998"