Merge lp:~mzanetti/unity8/inputinfo-plugin into lp:unity8

[Michael Zanetti]

Add a snapshot of Qt's WIP InputDeviceInfo API as a local plugin.

https://codereview.qt-project.org/#/c/101049/

This is supposed to be temporary and should be removed in favor of the upstream API when that one is ready/merged.

WIP: Just trying to get it through Jenkins once.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1746
http://jenkins.qa.ubuntu.com/job/unity8-ci/5675/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2628/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/840/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/840/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/840/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2626/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1746
http://jenkins.qa.ubuntu.com/job/unity8-ci/5696/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2695
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/861/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/861
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/862
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/2328
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2693
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2693/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/20330

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1746
http://jenkins.qa.ubuntu.com/job/unity8-ci/5699/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2700
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/865
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/864
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/865
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/2332
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2698
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2698/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/20350

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

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity8/inputinfo-plugin]

1747. By Michael Zanetti on 2015-05-18

[ Albert Astals Cid ]
* Workarounds for concierge mode.
[ CI Train Bot ]
* New rebuild forced.
* Resync trunk.
[ Albert Astals Cid ]
* Make runtests fake a test error if make fails
* Make the test more stable
* Use dbus-test-runner instead of dbus-launch
[ Daniel d'Andrada ]
* DirectionalDragArea: improvements & API grooming (LP: #1417920)
* Fix EdgeDragEvaluator when a drag can happen both ways
  (Direction.Horizontal)
[ Josh Arenson ]
* Remove panelHeight property as it is unused.
[ Leo Arias ]
* Initial clean up of the autopilot tests set up. Removed the touch
  device from the test case. Moved the restart of unity to a fixture.
  Removed the unused DragMixin. Updated the setUpClass to use
  process_helpers. Removed the workaround for bug #1238417, already
  fixed. Use the toolkit helper to set the testability environment
  variable. Fixed the indicators base class that was restarting unity
  twice. (LP: #1238417, #1447206)
* Use the base class from the toolkit in autopilot tests.
[ Michael Zanetti ]
* emit application-stop when we're going down (LP: #1326513)
[ Michał Sawicz ]
* UNITY_SCOPES_LIST is no more
[ handsome_feng<email address hidden> ]
* When click the favorite scope in Dash Manager , it just return to
  the corresponding scope page. (LP: #1447056)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1747
http://jenkins.qa.ubuntu.com/job/unity8-ci/5733/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-wily-touch/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-wily-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-wily-i386-ci/11
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-wily-mako/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/12
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/12/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/20580

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

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity8/inputinfo-plugin]

1748. By Michael Zanetti on 2015-05-18

rebase on shellRotation

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1748
http://jenkins.qa.ubuntu.com/job/unity8-ci/5735/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-wily-touch/14/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-amd64-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-wily-i386-ci/13/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-wily-armhf/14/console

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

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity8/inputinfo-plugin]

1749. By Michael Zanetti on 2015-06-17

merge trunk

1750. By Michael Zanetti on 2015-06-22

drop debug print

1751. By Michael Zanetti on 2015-06-22

merge trunk

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-12 13:59:07 +0000
+++ CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -56,6 +56,8 @@
 find_package(Qt5Concurrent 5.2 REQUIRED)
 find_package(Qt5Sql 5.2 REQUIRED)
 
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=6)
+
 # Standard install paths
 include(GNUInstallDirs)
 

=== modified file 'data/unity8-dash.desktop.in'
--- data/unity8-dash.desktop.in	2014-09-04 13:23:09 +0000
+++ data/unity8-dash.desktop.in	2015-05-18 22:06:13 +0000
@@ -7,3 +7,4 @@
 Icon=
 NoDisplay=true
 X-Ubuntu-Touch=true
+X-Ubuntu-Supported-Orientations=primary

=== modified file 'debian/changelog'
--- debian/changelog	2015-05-11 08:29:58 +0000
+++ debian/changelog	2015-05-18 22:06:13 +0000
@@ -1,3 +1,9 @@
+unity8 (8.10-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Implement full-shell rotation (LP: #1210199)
+
+ -- Michał Sawicz <[e-mail]>  Wed, 15 Apr 2015 14:47:17 +0200
+
 unity8 (8.02+15.04.20150511-0ubuntu1) vivid; urgency=medium
 
   [ Albert Astals Cid ]

=== modified file 'debian/control'
--- debian/control	2015-04-22 14:43:17 +0000
+++ debian/control	2015-05-18 22:06:13 +0000
@@ -12,9 +12,11 @@
 # append :native to g++-4.9 so we don't try to run armhf g++
 # on an x86 CPU for eaxmple, when cross-compiling.
                g++-4.9:native,
+               libandroid-properties-dev,
                graphviz,
                gsettings-ubuntu-schemas (>= 0.0.2+14.10.20140815),
                libconnectivity-qt1-dev,
+               libevdev-dev,
                libgl1-mesa-dev[!armhf] | libgl-dev[!armhf],
                libgl1-mesa-dri,
                libgles2-mesa-dev[armhf],
@@ -27,7 +29,8 @@
                libqmenumodel-dev (>= 0.2.9),
                libqt5xmlpatterns5-dev,
                libsystemsettings-dev,
-               libunity-api-dev (>= 7.96),
+               libudev-dev,
+               libunity-api-dev (>= 7.97),
                libusermetricsoutput1-dev,
                libxcb1-dev,
                pkg-config,
@@ -94,7 +97,7 @@
          qml-module-qtquick-xmllistmodel,
          qml-module-qtsysteminfo,
          qtdeclarative5-gsettings1.0,
-         qtdeclarative5-qtmir-plugin (>= 0.4.4),
+         qtdeclarative5-qtmir-plugin (>= 0.4.5),
          qtdeclarative5-ubuntu-telephony0.1,
          qtdeclarative5-ubuntu-web-plugin,
          ubuntu-system-settings,
@@ -124,7 +127,7 @@
          qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.1.1239) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.1.1239),
          qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
          ubuntu-thumbnailer-impl-0,
-         unity-application-impl-4,
+         unity-application-impl-6,
          unity-notifications-impl-3,
          unity-plugin-scopes | unity-scopes-impl,
          unity-scopes-impl-6,
@@ -168,7 +171,7 @@
 Depends: ${misc:Depends},
          ${shlibs:Depends},
 Provides: unity-application-impl,
-          unity-application-impl-4,
+          unity-application-impl-6,
 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 'debian/unity8.install'
--- debian/unity8.install	2015-04-21 15:22:53 +0000
+++ debian/unity8.install	2015-05-18 22:06:13 +0000
@@ -8,6 +8,9 @@
 usr/share/unity8/Greeter
 usr/share/unity8/Launcher
 usr/share/unity8/Panel
+usr/share/unity8/Rotation
+usr/share/unity8/DeviceConfiguration.qml
+usr/share/unity8/OrientedShell.qml
 usr/share/unity8/Shell.qml
 usr/share/unity8/Stages
 usr/share/unity8/Tutorial

=== modified file 'plugins/Greeter/Unity/Launcher/CMakeLists.txt'
--- plugins/Greeter/Unity/Launcher/CMakeLists.txt	2015-04-22 14:45:11 +0000
+++ plugins/Greeter/Unity/Launcher/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=6)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=5)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=6)
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 
 add_definitions(-DSM_BUSNAME=systemBus)

=== modified file 'plugins/Unity/CMakeLists.txt'
--- plugins/Unity/CMakeLists.txt	2014-08-25 10:05:13 +0000
+++ plugins/Unity/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -3,3 +3,4 @@
 add_subdirectory(Launcher)
 add_subdirectory(Session)
 add_subdirectory(DashCommunicator)
+add_subdirectory(InputInfo)

=== added directory 'plugins/Unity/InputInfo'
=== added file 'plugins/Unity/InputInfo/CMakeLists.txt'
--- plugins/Unity/InputInfo/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -0,0 +1,41 @@
+# This is a temporary snapshot of the WIP QInputInfo API as we
+# require this in unity now but upstream isn't finished yet.
+# Eventually this should be dropped in favor of the upstream
+# QInputInfo API.
+
+project(InputInfo)
+
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Quick REQUIRED)
+
+pkg_check_modules(LIBUDEV REQUIRED libudev)
+pkg_check_modules(LIBEVDEV REQUIRED libevdev)
+
+message("blabla ${LIBUDEV_INCLUDE_DIRS}  ${LIBEVDEV_INCLUDE_DIRS}   ${LIBUDEV_LDFLAGS}    ${LIBEVDEV_LDFLAGS}")
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${LIBUDEV_INCLUDE_DIRS}
+    ${LIBEVDEV_INCLUDE_DIRS}
+)
+
+set(InputInfo_SOURCES
+    plugin.cpp
+    qinputinfo.cpp
+    qdeclarativeinputdeviceinfo.cpp
+    linux/qinputdeviceinfo_linux.cpp
+)
+
+add_library(InputInfo SHARED
+    ${InputInfo_SOURCES}
+)
+
+target_link_libraries(InputInfo
+    ${LIBUDEV_LDFLAGS}
+    ${LIBEVDEV_LDFLAGS}
+)
+
+qt5_use_modules(InputInfo Core Qml Quick)
+
+add_unity8_plugin(Unity.InputInfo 0.1 Unity/InputInfo TARGETS InputInfo)

=== added directory 'plugins/Unity/InputInfo/linux'
=== added file 'plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux.cpp'
--- plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,249 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd. and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qinputdeviceinfo_linux_p.h"
+
+#include <libudev.h>
+#include <libevdev/libevdev.h>
+#include <fcntl.h>
+#include <QDebug>
+#include <QSocketNotifier>
+#include <QTimer>
+
+QInputDeviceInfoPrivate::QInputDeviceInfoPrivate(QObject *parent) :
+    QObject(parent)
+  , udev(0)
+{
+    QTimer::singleShot(250,this,SLOT(init()));
+}
+
+void QInputDeviceInfoPrivate::init()
+{
+    if (!udev)
+        udev = udev_new();
+
+    struct udev_list_entry *devices, *dev_list_entry;
+    struct udev_device *dev;
+
+    QString subsystem = QStringLiteral("input");
+    struct udev_enumerate *enumerate = 0;
+
+    if (udev) {
+
+        udevMonitor = udev_monitor_new_from_netlink(udev, "udev");
+        udev_monitor_filter_add_match_subsystem_devtype(udevMonitor, subsystem.toLatin1(), NULL);
+        enumerate = udev_enumerate_new(udev);
+        udev_enumerate_add_match_subsystem(enumerate, subsystem.toLatin1());
+
+
+        udev_monitor_enable_receiving(udevMonitor);
+        notifierFd = udev_monitor_get_fd(udevMonitor);
+
+        notifier = new QSocketNotifier(notifierFd, QSocketNotifier::Read, this);
+        connect(notifier, SIGNAL(activated(int)), this, SLOT(onUDevChanges()));
+
+
+        udev_enumerate_scan_devices(enumerate);
+        devices = udev_enumerate_get_list_entry(enumerate);
+
+        udev_list_entry_foreach(dev_list_entry, devices) {
+            const char *path;
+            path = udev_list_entry_get_name(dev_list_entry);
+
+            dev = udev_device_new_from_syspath(udev, path);
+
+            QString eventPath = QString::fromLatin1(udev_device_get_sysname(dev));
+
+            if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {
+
+                if (eventPath.contains(QStringLiteral("event"))) {
+                    eventPath.prepend(QStringLiteral("/dev/input/"));
+
+                    QInputDevice *iDevice = addDevice(eventPath);
+                    if (!iDevice)
+                        continue;
+
+                    qDebug() << "*** ADDING DEVICE" << eventPath;
+
+                    iDevice->setTypes(getInputTypes(dev));
+
+                if (iDevice->switches().count() > 0 && iDevice->buttons().count() == 0)
+                    iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Switch);
+
+                if (iDevice->buttons().count() > 0 && iDevice->types() == QInputDeviceInfo::Unknown)
+                    iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Button);
+
+                deviceList.append(iDevice);
+                deviceMap.insert(eventPath,iDevice);
+                Q_EMIT newDevice(eventPath);
+
+                }
+            }
+        }
+        udev_enumerate_unref(enumerate);
+    }
+    Q_EMIT ready();
+}
+
+QInputDeviceInfo::InputTypes QInputDeviceInfoPrivate::getInputTypes( struct udev_device *dev)
+{
+    qDebug() << "******* have input type Keyboard" << udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD");
+    qDebug() << "******* have input type Mouse" << udev_device_get_property_value(dev, "ID_INPUT_MOUSE");
+    qDebug() << "******* have input type Touchpad" << udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD");
+    qDebug() << "******* have input type Touchscreen" << udev_device_get_property_value(dev, "ID_INPUT_TOUCHSCREEN");
+    qDebug() << "******* have input type Tablet" << udev_device_get_property_value(dev, "ID_INPUT_TABLET");
+    qDebug() << "******* have input type joystick" << udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK");
+    QInputDeviceInfo::InputTypes types = QInputDeviceInfo::Unknown;
+    if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD"), "1") == 0 )
+       types |= QInputDeviceInfo::Keyboard;
+
+    if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_MOUSE"), "1") == 0)
+        types |= QInputDeviceInfo::Mouse;
+
+    if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD"), "1") == 0)
+       types |= QInputDeviceInfo::TouchPad;
+
+    if (qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TOUCHSCREEN"), "1") == 0
+            || qstrcmp(udev_device_get_property_value(dev, "ID_INPUT_TABLET"), "1") == 0)
+      types |= QInputDeviceInfo::TouchScreen;
+
+    return types;
+}
+
+QInputDevice *QInputDeviceInfoPrivate::addDevice(const QString &path)
+{
+    QInputDevice *inputDevice = new QInputDevice(this);
+
+    struct libevdev *dev = NULL;
+    int fd;
+    int rc = 1;
+    fd = open(path.toLatin1(), O_RDONLY|O_NONBLOCK);
+
+    if (fd == -1) {
+        qDebug() << "Failed to open";
+        return inputDevice;
+    }
+    rc = libevdev_new_from_fd(fd, &dev);
+    if (rc < 0) {
+        qDebug() << "Failed to init libevdev ("<< strerror(-rc) << ")";
+        return inputDevice;
+    }
+
+    inputDevice->setName(QString::fromLatin1(libevdev_get_name(dev)));
+    inputDevice->setDevicePath(path);
+    for (int i = 0; i < EV_MAX; i++) {
+        if (i == EV_KEY || i == EV_SW || i == EV_REL
+                || i == EV_REL || i == EV_ABS) {
+            for (int j = 0; j <  libevdev_event_type_get_max(i); j++) {
+                if (libevdev_has_event_code(dev, i, j)) {
+                    switch (i) {
+                    case EV_KEY:
+                        inputDevice->addButton(j);
+                        break;
+                    case EV_SW:
+                        inputDevice->addSwitch(j);
+                        break;
+                    case EV_REL:
+                        inputDevice->addRelativeAxis(j);
+                        break;
+                    case EV_ABS:
+                        inputDevice->addAbsoluteAxis(j);
+                        break;
+                    };
+                }
+            }
+        }
+    }
+    return inputDevice;
+}
+
+void QInputDeviceInfoPrivate::removeDevice(const QString &path)
+{
+    for (int i = 0; i < deviceList.size(); ++i) {
+        if (deviceList.at(i)->devicePath() == path) {
+            delete deviceList.takeAt(i);
+            deviceMap.remove(path);
+            Q_EMIT deviceRemoved(path);
+        }
+    }
+}
+
+void QInputDeviceInfoPrivate::onUDevChanges()
+{
+    struct udev_device *dev = udev_monitor_receive_device(udevMonitor);
+    if (dev) {
+        if (qstrcmp(udev_device_get_subsystem(dev), "input") == 0 ) {
+            QString eventPath = QString::fromLatin1(udev_device_get_sysname(dev));
+
+            if (eventPath.contains(QStringLiteral("input")))
+                return;
+
+            QString action = QString::fromStdString(udev_device_get_action(dev));
+
+            if (!eventPath.contains(QStringLiteral("/dev/input/")))
+                eventPath.prepend(QStringLiteral("/dev/input/"));
+
+            if (action == QStringLiteral("add")) {
+
+                QInputDevice *iDevice = addDevice(eventPath);
+                if (!iDevice)
+                    return;
+
+                    iDevice->setTypes(getInputTypes(dev));
+                    udev_device_unref(dev);
+
+                if (iDevice->switches().count() > 0 && iDevice->buttons().count() == 0)
+                    iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Switch);
+
+                if (iDevice->buttons().count() > 0 && iDevice->types() == QInputDeviceInfo::Unknown)
+                    iDevice->setTypes(iDevice->types() | QInputDeviceInfo::Button);
+
+                deviceList.append(iDevice);
+                deviceMap.insert(eventPath,iDevice);
+
+                Q_EMIT newDevice(eventPath);
+
+            } else if (action == QStringLiteral("remove")) {
+                removeDevice(eventPath);
+            }
+        }
+    }
+}

=== added file 'plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux_p.h'
--- plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux_p.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/linux/qinputdeviceinfo_linux_p.h	2015-05-18 22:06:13 +0000
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd. and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QINPUTDEVICEINFO_LINUX_P_H
+#define QINPUTDEVICEINFO_LINUX_P_H
+
+#include <QObject>
+#include "qinputinfo.h"
+#include <libudev.h>
+
+class QInputDevicePrivate : public QObject
+{
+    Q_OBJECT
+public:
+    explicit QInputDevicePrivate(QObject *parent = 0);
+
+    QString name;
+    QString devicePath;
+    QList <int> buttons; //keys
+    QList <int> switches;
+    QList <int> relativeAxis;
+    QList <int> absoluteAxis;
+    QInputDeviceInfo::InputTypes types;
+};
+
+class QInputDeviceInfoPrivate : public QObject
+{
+    Q_OBJECT
+public:
+    explicit QInputDeviceInfoPrivate(QObject *parent = 0);
+    QVector <QInputDevice *> deviceList;
+    QMap <QString, QInputDevice *> deviceMap;
+
+Q_SIGNALS:
+    void newDevice(const QString &);
+    void deviceRemoved(const QString &);
+    void ready();
+
+private:
+    struct udev *udev;
+    QInputDevice *addDevice(const QString &path);
+    void removeDevice(const QString &path);
+    QSocketNotifier *notifier;
+    int notifierFd;
+    struct udev_monitor *udevMonitor;
+    QInputDeviceInfo::InputTypes getInputTypes( struct udev_device *);
+
+private Q_SLOTS:
+    void onUDevChanges();
+    void init();
+};
+
+#endif // QINPUTDEVICEINFO_LINUX_P_H

=== added file 'plugins/Unity/InputInfo/plugin.cpp'
--- plugins/Unity/InputInfo/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/plugin.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Qt
+#include <QtQml/qqml.h>
+
+// self
+#include "plugin.h"
+
+// local
+#include "qdeclarativeinputdeviceinfo_p.h"
+
+void InputInfoPlugin::registerTypes(const char *uri)
+{
+    int major = 0;
+    int minor = 1;
+    qmlRegisterType<QDeclarativeInputDeviceInfo>(uri, major, minor, "InputDeviceInfo");
+    qmlRegisterType<QInputDevice>(uri, major, minor, "InputInfo");
+}

=== added file 'plugins/Unity/InputInfo/plugin.h'
--- plugins/Unity/InputInfo/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/plugin.h	2015-05-18 22:06:13 +0000
@@ -0,0 +1,30 @@
+/*
+ * 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 INPUTINFO_PLUGIN_H
+#define INPUTINFO_PLUGIN_H
+
+#include <QtQml/QQmlExtensionPlugin>
+
+class InputInfoPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif // INPUTINFO_PLUGIN_H

=== added file 'plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo.cpp'
--- plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Jolla.
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qdeclarativeinputdeviceinfo_p.h"
+
+QDeclarativeInputDeviceInfo::QDeclarativeInputDeviceInfo(QObject *parent) :
+    QAbstractListModel(parent),
+    deviceInfo(new QInputDeviceInfo)
+{
+    connect(deviceInfo,SIGNAL(ready()),this,SLOT(updateDeviceList()));
+    connect(deviceInfo, &QInputDeviceInfo::deviceAdded,this,&QDeclarativeInputDeviceInfo::addedDevice);
+    connect(deviceInfo, &QInputDeviceInfo::deviceRemoved,this,&QDeclarativeInputDeviceInfo::removedDevice);
+}
+
+QDeclarativeInputDeviceInfo::~QDeclarativeInputDeviceInfo()
+{
+    delete deviceInfo;
+}
+
+QVariant QDeclarativeInputDeviceInfo::data(const QModelIndex &index, int role) const
+{
+    switch (role) {
+    case ServiceRole:
+        return QVariant::fromValue(static_cast<QObject *>(inputDevices.value(index.row())));
+    }
+
+    return QVariant();
+}
+
+int QDeclarativeInputDeviceInfo::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+
+    return inputDevices.count();
+}
+
+int QDeclarativeInputDeviceInfo::indexOf(const QString &devicePath) const
+{
+    int idx(-1);
+    Q_FOREACH (QInputDevice *device, inputDevices) {
+        idx++;
+        if (device->devicePath() == devicePath) return idx;
+    }
+
+    return -1;
+}
+
+QInputDevice *QDeclarativeInputDeviceInfo::get(int index) const
+{
+    if (index < 0 || index > inputDevices.count())
+        return 0;
+    return inputDevices.value(index);
+}
+
+void QDeclarativeInputDeviceInfo::updateDeviceList()
+{
+   QVector <QInputDevice *> newDevices = deviceInfo->deviceList();
+
+    int numNew = newDevices.count();
+
+    for (int i = 0; i < numNew; i++) {
+        int j = inputDevices.indexOf(newDevices.value(i));
+        if (j == -1) {
+            // not found -> remove from list
+            beginInsertRows(QModelIndex(), i, i);
+            inputDevices.insert(i, newDevices.value(i));
+            endInsertRows();
+        } else if (i != j) {
+            // changed its position -> move it
+            QInputDevice* device = inputDevices.value(j);
+            beginMoveRows(QModelIndex(), j, j, QModelIndex(), i);
+            inputDevices.remove(j);
+            inputDevices.insert(i, device);
+            endMoveRows();
+        } else {
+            QModelIndex changedIndex(this->index(j, 0, QModelIndex()));
+            Q_EMIT dataChanged(changedIndex, changedIndex);
+        }
+    }
+
+    int numOld = inputDevices.count();
+    if (numOld > numNew) {
+        beginRemoveRows(QModelIndex(), numNew, numOld - 1);
+        inputDevices.remove(numNew, numOld - numNew);
+        endRemoveRows();
+    }
+}
+
+void QDeclarativeInputDeviceInfo::addedDevice(const QString &devicePath)
+{
+    updateDeviceList();
+    Q_EMIT newDevice(devicePath);
+}
+
+void QDeclarativeInputDeviceInfo::removedDevice(const QString &devicePath)
+{
+    updateDeviceList();
+    Q_EMIT deviceRemoved(devicePath);
+}
+
+QHash<int, QByteArray> QDeclarativeInputDeviceInfo::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles.insert(ServiceRole, "service");
+    return roles;
+}

=== added file 'plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo_p.h'
--- plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo_p.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/qdeclarativeinputdeviceinfo_p.h	2015-05-18 22:06:13 +0000
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Jolla.
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEINPUTDEVICEINFO_H
+#define QDECLARATIVEINPUTDEVICEINFO_H
+
+#include <QObject>
+#include <QAbstractListModel>
+#include "qinputinfo.h"
+
+class QDeclarativeInputDeviceInfo : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(QDeclarativeInputDeviceInfo)
+
+public:
+    enum ItemRoles {
+        ServiceRole = Qt::UserRole + 1
+    };
+
+    explicit QDeclarativeInputDeviceInfo(QObject *parent = 0);
+    virtual ~QDeclarativeInputDeviceInfo();
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+
+    QHash<int, QByteArray> roleNames() const;
+
+    Q_INVOKABLE int indexOf(const QString &devicePath) const;
+
+    Q_INVOKABLE QInputDevice *get(int index) const;
+
+Q_SIGNALS:
+    void newDevice(const QString &devicePath);
+    void deviceRemoved(const QString &devicePath);
+
+public Q_SLOTS:
+    void updateDeviceList();
+private:
+    QInputDeviceInfo *deviceInfo;
+    QVector<QInputDevice *> inputDevices;
+private Q_SLOTS:
+    void addedDevice(const QString &);
+    void removedDevice(const QString &path);
+
+};
+
+#endif // QDECLARATIVEINPUTDEVICEINFO_H

=== added file 'plugins/Unity/InputInfo/qinputinfo.cpp'
--- plugins/Unity/InputInfo/qinputinfo.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/qinputinfo.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,159 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd. and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qinputinfo.h"
+
+#if defined(Q_OS_LINUX)
+#include "linux/qinputdeviceinfo_linux_p.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+
+QInputDevicePrivate::QInputDevicePrivate(QObject *parent) :
+    QObject(parent),
+    types(QInputDeviceInfo::Unknown)
+{
+}
+
+QInputDevice::QInputDevice(QObject *parent) :
+    QObject(parent),
+    d_ptr(new QInputDevicePrivate(this))
+{
+}
+
+QString QInputDevice::name() const
+{
+    return d_ptr->name;
+}
+
+void QInputDevice::setName(const QString &name)
+{
+    d_ptr->name = name;
+}
+
+QString QInputDevice::devicePath() const
+{
+    return d_ptr->devicePath;
+}
+
+void QInputDevice::setDevicePath(const QString &path)
+{
+    d_ptr->devicePath = path;
+}
+
+QList <int> QInputDevice::buttons() const
+{
+    return d_ptr->buttons;
+}
+
+void QInputDevice::addButton(int buttonCode)
+{
+    d_ptr->buttons.append(buttonCode);
+}
+
+QList <int> QInputDevice::switches() const
+{
+    return d_ptr->switches;
+}
+
+void QInputDevice::addSwitch(int switchCode)
+{
+    d_ptr->switches.append(switchCode);
+}
+
+QList <int> QInputDevice::relativeAxis() const
+{
+    return d_ptr->relativeAxis;
+}
+
+void QInputDevice::addRelativeAxis(int axisCode)
+{
+    d_ptr->relativeAxis.append(axisCode);
+}
+
+QList <int> QInputDevice::absoluteAxis() const
+{
+    return d_ptr->absoluteAxis;
+}
+
+void QInputDevice::addAbsoluteAxis(int axisCode)
+{
+    d_ptr->absoluteAxis.append(axisCode);
+}
+
+QInputDeviceInfo::InputTypes QInputDevice::types()
+{
+    return d_ptr->types;
+}
+
+void QInputDevice::setTypes(QInputDeviceInfo::InputTypes types)
+{
+    d_ptr->types = types;
+}
+
+
+QInputDeviceInfo::QInputDeviceInfo(QObject *parent) :
+    QObject(parent),
+    d_ptr(new QInputDeviceInfoPrivate(this))
+{
+    connect(d_ptr, &QInputDeviceInfoPrivate::newDevice,this,&QInputDeviceInfo::addedDevice);
+    connect(d_ptr, &QInputDeviceInfoPrivate::deviceRemoved,this,&QInputDeviceInfo::deviceRemoved);
+
+    connect(d_ptr,SIGNAL(ready()),this,SIGNAL(ready()));
+}
+
+QVector <QInputDevice *> QInputDeviceInfo::deviceList()
+{
+    return d_ptr->deviceList;
+}
+
+QMap <QString, QInputDevice *> QInputDeviceInfo::deviceMap()
+{
+    return d_ptr->deviceMap;
+}
+
+void QInputDeviceInfo::addedDevice(const QString & devicePath)
+{
+    Q_EMIT deviceAdded(devicePath);
+}
+
+QT_END_NAMESPACE

=== added file 'plugins/Unity/InputInfo/qinputinfo.h'
--- plugins/Unity/InputInfo/qinputinfo.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/qinputinfo.h	2015-05-18 22:06:13 +0000
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Canonical, Ltd. and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtSystems module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QINPUTINFO_H
+#define QINPUTINFO_H
+
+#include <QObject>
+#include <QVector>
+#include <QMap>
+#include <QSocketNotifier>
+#include <QDebug>
+
+class QInputDeviceInfoPrivate;
+class QInputDevicePrivate;
+class QInputDevice;
+
+class QInputDeviceInfoPrivate;
+class QInputDeviceInfo : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int deviceCount READ deviceCount)
+public:
+
+    enum InputType {
+        Unknown = 0,
+        Button = 1,
+        Mouse = 2,
+        TouchPad = 4,
+        TouchScreen = 8,
+        Keyboard = 16,
+        Switch = 32
+    };
+    Q_ENUMS(InputType)
+    Q_FLAGS(InputTypes)
+    Q_DECLARE_FLAGS(InputTypes, InputType)
+
+    explicit QInputDeviceInfo(QObject *parent = 0);
+
+    Q_INVOKABLE QVector <QInputDevice *> deviceList();
+
+    Q_INVOKABLE QMap <QString, QInputDevice *> deviceMap();
+    int deviceCount() { return deviceList().count(); }
+Q_SIGNALS:
+
+    void deviceAdded(const QString & devicePath);
+    void deviceRemoved(const QString & devicePath);
+
+    void ready();
+
+public Q_SLOTS:
+    void addedDevice(const QString & devicePath);
+
+private:
+    Q_DISABLE_COPY(QInputDeviceInfo)
+#if !defined(QT_SIMULATOR)
+    QInputDeviceInfoPrivate *const d_ptr;
+    Q_DECLARE_PRIVATE(QInputDeviceInfo)
+#endif
+};
+
+class QInputDevice : public QObject
+{
+    friend class QInputDeviceInfoPrivate;
+    Q_OBJECT
+    Q_ENUMS(InputType)
+    Q_FLAGS(InputTypes)
+    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
+    Q_PROPERTY(QString devicePath READ devicePath NOTIFY devicePathChanged)
+    Q_PROPERTY(QList <int> buttons READ buttons NOTIFY buttonsChanged)
+    Q_PROPERTY(QList <int> switches READ switches NOTIFY switchesChanged)
+    Q_PROPERTY(QList <int> relativeAxis READ relativeAxis NOTIFY relativeAxisChanged)
+    Q_PROPERTY(QList <int> absoluteAxis READ absoluteAxis NOTIFY absoluteAxisChanged)
+    Q_PROPERTY(QInputDeviceInfo::InputTypes types READ types NOTIFY typesChanged)
+
+public:
+    explicit QInputDevice(QObject *parent = 0);
+
+    QString name() const;
+    QString devicePath() const;
+    QList <int> buttons() const; //keys event code
+    QList <int> switches() const;
+    QList <int> relativeAxis() const;
+    QList <int> absoluteAxis() const;
+
+    QInputDeviceInfo::InputTypes types();
+Q_SIGNALS:
+    void nameChanged();
+    void devicePathChanged();
+    void buttonsChanged();
+    void switchesChanged();
+    void relativeAxisChanged();
+    void absoluteAxisChanged();
+    void typesChanged();
+private:
+    QInputDevicePrivate *d_ptr;
+    void setName(const QString &);
+    void setDevicePath(const QString &);
+    void addButton(int);
+    void addSwitch(int);
+    void addRelativeAxis(int);
+    void addAbsoluteAxis(int);
+    void setTypes(QInputDeviceInfo::InputTypes);
+};
+
+#endif // QINPUTINFO_H

=== added file 'plugins/Unity/InputInfo/qmldir'
--- plugins/Unity/InputInfo/qmldir	1970-01-01 00:00:00 +0000
+++ plugins/Unity/InputInfo/qmldir	2015-05-18 22:06:13 +0000
@@ -0,0 +1,3 @@
+module Unity.InputInfo
+plugin InputInfo
+typeinfo InputInfo.qmltypes

=== modified file 'plugins/Unity/Launcher/CMakeLists.txt'
--- plugins/Unity/Launcher/CMakeLists.txt	2015-04-13 09:33:28 +0000
+++ plugins/Unity/Launcher/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=6)
-pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=5)
+pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=6)
 pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
 
 add_definitions(-DSM_BUSNAME=systemBus)

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2015-04-22 10:40:54 +0000
+++ plugins/Utils/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -18,6 +18,7 @@
     Timer.cpp
     unitymenumodelpaths.cpp
     windowkeysfilter.cpp
+    windowscreenshotprovider.cpp
     easingcurve.cpp
     windowstatestorage.cpp
     plugin.cpp

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2015-04-22 10:40:54 +0000
+++ plugins/Utils/plugin.cpp	2015-05-18 22:06:13 +0000
@@ -23,6 +23,7 @@
 #include "plugin.h"
 
 // local
+#include "easingcurve.h"
 #include "HomeKeyWatcher.h"
 #include "inputwatcher.h"
 #include "qlimitproxymodelqml.h"
@@ -31,7 +32,7 @@
 #include "timeformatter.h"
 #include "unitymenumodelpaths.h"
 #include "windowkeysfilter.h"
-#include "easingcurve.h"
+#include "windowscreenshotprovider.h"
 #include "windowstatestorage.h"
 #include "constants.h"
 
@@ -70,4 +71,6 @@
 void UtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 {
     QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    engine->addImageProvider(QLatin1String("window"), new WindowScreenshotProvider);
 }

=== added file 'plugins/Utils/windowscreenshotprovider.cpp'
--- plugins/Utils/windowscreenshotprovider.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Utils/windowscreenshotprovider.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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 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 "windowscreenshotprovider.h"
+
+#include <QGuiApplication>
+#include <QQuickWindow>
+
+WindowScreenshotProvider::WindowScreenshotProvider()
+    : QQuickImageProvider(QQmlImageProviderBase::Image, 0)
+{
+}
+
+// A very simple implementation where we assume that there's only one window and that it's a
+// QQuickWindow. Thus the id parameter is irrelevant.
+//
+// Idea: Make the id contain the objectName of the QQuickWindow once we care about a multi-display
+//       compositor?
+//       Strictly speaking that could be the actual QWindow::winId(), but that's mostly a
+//       meaningless arbitrary number.
+QImage WindowScreenshotProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
+{
+    Q_UNUSED(id);
+    Q_UNUSED(requestedSize);
+
+    QWindowList windows = QGuiApplication::topLevelWindows();
+
+    if (windows.count() != 1) {
+        size->rwidth() = 0;
+        size->rheight() = 0;
+        return QImage();
+    }
+
+    QQuickWindow *quickWindow = qobject_cast<QQuickWindow *>(windows[0]);
+
+    if (!quickWindow) {
+        size->rwidth() = 0;
+        size->rheight() = 0;
+        return QImage();
+    }
+
+    QImage image = quickWindow->grabWindow();
+    size->rwidth() = image.width();
+    size->rheight() = image.height();
+    return image;
+}

=== added file 'plugins/Utils/windowscreenshotprovider.h'
--- plugins/Utils/windowscreenshotprovider.h	1970-01-01 00:00:00 +0000
+++ plugins/Utils/windowscreenshotprovider.h	2015-05-18 22:06:13 +0000
@@ -0,0 +1,31 @@
+/*
+ * 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 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 WINDOW_SCREENSHOT_PROVIDER_H_
+#define WINDOW_SCREENSHOT_PROVIDER_H_
+
+#include <QQuickImageProvider>
+
+class WindowScreenshotProvider : public QQuickImageProvider
+{
+public:
+    WindowScreenshotProvider();
+
+    // id is ignored for now
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize) override;
+};
+
+#endif // WINDOW_SCREENSHOT_PROVIDER_H_

=== modified file 'qml/CMakeLists.txt'
--- qml/CMakeLists.txt	2014-12-16 16:49:49 +0000
+++ qml/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -13,6 +13,7 @@
     Notifications
     Panel
     Stages
+    Rotation
     Tutorial
     Wizard
     )

=== added file 'qml/Components/WindowScreenshot.qml'
--- qml/Components/WindowScreenshot.qml	1970-01-01 00:00:00 +0000
+++ qml/Components/WindowScreenshot.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,35 @@
+/*
+ * 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 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.2
+
+Item {
+    id: root
+
+    function take() {
+        var timeNow = new Date().getTime();
+        image.source = "image://window/" + timeNow;
+    }
+
+    // Unload the image to free up memory
+    function discard() {
+        image.source = "";
+    }
+
+    Image {
+        id: image
+    }
+}

=== modified file 'qml/Dash/DashApplication.qml'
--- qml/Dash/DashApplication.qml	2014-09-18 21:22:37 +0000
+++ qml/Dash/DashApplication.qml	2015-05-18 22:06:13 +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 as published by
@@ -19,8 +19,8 @@
 import Ubuntu.Thumbnailer 0.1 // Register support for image://thumbnailer/ and image://albumart/
 
 MainView {
-    width: applicationArguments.hasGeometry() ? applicationArguments.width() : units.gu(40)
-    height: applicationArguments.hasGeometry() ? applicationArguments.height() : units.gu(68)
+    implicitWidth: units.gu(40)
+    implicitHeight: units.gu(68)
 
     useDeprecatedToolbar: false
 

=== added file 'qml/Dash/graphics/phone/screenshots/gmail-webapp.svg'
--- qml/Dash/graphics/phone/screenshots/gmail-webapp.svg	1970-01-01 00:00:00 +0000
+++ qml/Dash/graphics/phone/screenshots/gmail-webapp.svg	2015-05-18 22:06:13 +0000
@@ -0,0 +1,343 @@
+<?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="768"
+   height="1280"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.48.5 r10040"
+   sodipodi:docname="gmail-webapp.svg">
+  <defs
+     id="defs4" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.49497475"
+     inkscape:cx="117.33439"
+     inkscape:cy="668.80479"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1920"
+     inkscape:window-height="1056"
+     inkscape:window-x="0"
+     inkscape:window-y="24"
+     inkscape:window-maximized="1" />
+  <metadata
+     id="metadata7">
+    <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(0,227.63782)">
+    <rect
+       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.69999999000000002;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="rect2985"
+       width="769.73627"
+       height="1276.8328"
+       x="-2.0203052"
+       y="3.1671834"
+       transform="translate(0,-227.63782)" />
+    <rect
+       style="fill:#e6e6e6;fill-opacity:1;stroke:none;stroke-width:4;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="rect3797"
+       width="773.77686"
+       height="129.29953"
+       x="-6.0609155"
+       y="-0.87342685"
+       transform="translate(0,-227.63782)" />
+    <text
+       xml:space="preserve"
+       style="font-size:72px;font-style:normal;font-weight:500;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu Medium;font-stretch:normal;font-variant:normal"
+       x="20.203053"
+       y="-139.61781"
+       id="text3755"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3757"
+         x="20.203053"
+         y="-139.61781">GMail</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:72px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="14.142137"
+       y="-28.501045"
+       id="text3759"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3761"
+         x="14.142137"
+         y="-28.501045">Inbox</tspan></text>
+    <path
+       sodipodi:type="arc"
+       style="fill:#8effff;fill-opacity:1;stroke:#000000;stroke-width:0.69999999;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-28.284271,-251.88148)" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+       d="m 14.142136,237.52257 729.330134,0"
+       id="path3769"
+       inkscape:connector-curvature="0"
+       transform="translate(0,-227.63782)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="167.68533"
+       y="78.575127"
+       id="text3771"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773"
+         x="167.68533"
+         y="78.575127">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="167.68532"
+       y="131.10306"
+       id="text3775"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777"
+         x="167.68532"
+         y="131.10306"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 13.13199,165.44825 729.33013,0"
+       id="path3769-2"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:#8eff58;fill-opacity:1;stroke:#000000;stroke-width:0.69999999000000002;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765-3"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-26.263969,-93.102383)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="169.70564"
+       y="237.35422"
+       id="text3771-9"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773-7"
+         x="169.70564"
+         y="237.35422">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="169.70561"
+       y="289.88217"
+       id="text3775-1"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777-1"
+         x="169.70561"
+         y="289.88217"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 15.152292,324.22735 729.330128,0"
+       id="path3769-2-6"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:#8effff;fill-opacity:1;stroke:#000000;stroke-width:0.69999999;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765-7"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-28.284274,64.481414)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="167.68533"
+       y="394.93799"
+       id="text3771-92"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773-0"
+         x="167.68533"
+         y="394.93799">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="167.68532"
+       y="447.46594"
+       id="text3775-9"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777-8"
+         x="167.68532"
+         y="447.46594"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 13.131986,481.81114 729.330124,0"
+       id="path3769-2-3"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:#8ea2ff;fill-opacity:1;stroke:#000000;stroke-width:0.69999999000000002;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765-2"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-26.263969,226.10582)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="169.70564"
+       y="556.56238"
+       id="text3771-1"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773-1"
+         x="169.70564"
+         y="556.56238">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="169.70563"
+       y="609.09033"
+       id="text3775-8"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777-85"
+         x="169.70563"
+         y="609.09033"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 15.152292,643.43555 729.330128,0"
+       id="path3769-2-1"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:#8effff;fill-opacity:1;stroke:#000000;stroke-width:0.69999999;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765-8"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-24.243664,391.77084)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="171.72594"
+       y="722.22742"
+       id="text3771-7"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773-6"
+         x="171.72594"
+         y="722.22742">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="171.72592"
+       y="774.75537"
+       id="text3775-5"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777-2"
+         x="171.72592"
+         y="774.75537"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 17.172597,809.10057 729.330133,0"
+       id="path3769-2-13"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:#e44738;fill-opacity:1;stroke:#000000;stroke-width:0.69999999000000002;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="path3765-9"
+       sodipodi:cx="107.07617"
+       sodipodi:cy="337.52768"
+       sodipodi:rx="64.649765"
+       sodipodi:ry="61.619305"
+       d="m 171.72594,337.52768 a 64.649765,61.619305 0 1 1 -129.299533,0 64.649765,61.619305 0 1 1 129.299533,0 z"
+       transform="translate(-24.243664,557.43585)" />
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="171.72594"
+       y="887.89246"
+       id="text3771-2"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3773-8"
+         x="171.72594"
+         y="887.89246">Lorem ipsum</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Ubuntu;-inkscape-font-specification:Ubuntu"
+       x="171.72592"
+       y="940.42041"
+       id="text3775-3"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3777-7"
+         x="171.72592"
+         y="940.42041"
+         style="font-size:48px;fill:#b3b3b3">bla bla bla bla bla bla bla ...</tspan></text>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 17.172597,974.76558 729.330123,0"
+       id="path3769-2-9"
+       inkscape:connector-curvature="0" />
+    <path
+       sodipodi:type="arc"
+       style="fill:none;stroke:#000000;stroke-width:8;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="path3929"
+       sodipodi:cx="590.93921"
+       sodipodi:cy="-119.06127"
+       sodipodi:rx="33.335033"
+       sodipodi:ry="33.335033"
+       d="m 624.27424,-119.06127 a 33.335033,33.335033 0 1 1 -66.67006,0 33.335033,33.335033 0 1 1 66.67006,0 z"
+       transform="matrix(0.85096826,0,0,0.85096826,175.43863,-68.81729)" />
+    <path
+       style="fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:3.40387297;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       d="m 692.92249,-145.20602 20.63059,24.06901 12.03451,-13.75372 -20.63059,-17.19215"
+       id="path3931"
+       inkscape:connector-curvature="0" />
+  </g>
+</svg>

=== removed file 'qml/Dash/graphics/phone/screenshots/[e-mail]'
Binary files qml/Dash/graphics/phone/screenshots/[e-mail]	2013-06-20 13:42:39 +0000 and qml/Dash/graphics/phone/screenshots/[e-mail]	1970-01-01 00:00:00 +0000 differ
=== added file 'qml/Dash/graphics/phone/screenshots/ubuntu-weather-app.svg'
--- qml/Dash/graphics/phone/screenshots/ubuntu-weather-app.svg	1970-01-01 00:00:00 +0000
+++ qml/Dash/graphics/phone/screenshots/ubuntu-weather-app.svg	2015-05-18 22:06:13 +0000
@@ -0,0 +1,201 @@
+<?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:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="829"
+   height="480"
+   id="svg2740"
+   sodipodi:version="0.32"
+   inkscape:version="0.48.5 r10040"
+   version="1.0"
+   sodipodi:docname="ubuntu-weather-app.svg"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape">
+  <defs
+     id="defs2742">
+    <linearGradient
+       id="linearGradient3824">
+      <stop
+         style="stop-color:#e6e6e6;stop-opacity:1;"
+         offset="0"
+         id="stop3826" />
+      <stop
+         style="stop-color:#23abff;stop-opacity:1;"
+         offset="1"
+         id="stop3828" />
+    </linearGradient>
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient3824"
+       id="linearGradient3830"
+       x1="348.55862"
+       y1="343.23914"
+       x2="348.55862"
+       y2="-17.422215"
+       gradientUnits="userSpaceOnUse" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     gridtolerance="10000"
+     guidetolerance="10"
+     objecttolerance="10"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.82625984"
+     inkscape:cx="331.28234"
+     inkscape:cy="125.54212"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1145"
+     inkscape:window-height="847"
+     inkscape:window-x="268"
+     inkscape:window-y="63"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata2745">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-321.13452,-104.68346)">
+    <rect
+       style="fill:url(#linearGradient3830);fill-opacity:1;stroke:#000000;stroke-width:0.69999999000000002;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
+       id="rect2990"
+       width="832.66785"
+       height="480.47839"
+       x="-1.210273"
+       y="0.73188055"
+       transform="translate(321.13452,104.68346)" />
+    <path
+       d="m 310.66382,132.06057 c -1.82703,2.0443 -22.21039,-18.38308 -24.89334,-17.37811 -2.68295,1.00497 -6.73783,33.64192 -9.57527,34.01165 -2.83744,0.36973 -7.71546,-33.08881 -10.48084,-33.88783 -2.76539,-0.79903 -18.7793,19.34152 -21.17964,17.82892 -2.40034,-1.51259 5.69972,-26.09808 4.36486,-28.67057 -1.33487,-2.57249 -31.86305,-3.78032 -32.49182,-6.6501 -0.62876,-2.86978 27.66855,-10.399376 27.90248,-13.241764 0.23394,-2.842387 -18.99828,-18.90215 -17.89698,-21.393798 1.10131,-2.491647 26.85456,8.177399 28.59429,5.99159 1.73972,-2.185809 -3.39182,-29.683489 -0.75169,-30.507098 2.64013,-0.823608 18.50306,18.485327 21.32153,18.392972 2.81847,-0.09235 11.30312,-24.287685 14.18258,-23.722317 2.87947,0.565368 1.44329,25.667631 3.67226,27.34365 2.22897,1.676019 24.27161,-6.28288 25.90675,-4.004945 1.63514,2.277936 -12.63923,24.445025 -11.77955,27.07291 0.85968,2.627885 27.01183,5.1355 26.65457,7.852474 -0.35726,2.716973 -32.69913,3.875594 -34.04684,6.507203 -1.3477,2.631613 12.32368,32.410863 10.49665,34.455163 z"
+       id="path11949"
+       inkscape:flatsided="false"
+       inkscape:randomized="-0.092"
+       inkscape:rounded="0.1"
+       sodipodi:arg1="0.79570711"
+       sodipodi:arg2="1.144773"
+       sodipodi:cx="275.15002"
+       sodipodi:cy="88.090233"
+       sodipodi:r1="57.019234"
+       sodipodi:r2="32.818508"
+       sodipodi:sides="9"
+       sodipodi:type="star"
+       style="fill:#f5ff12;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.2;marker:none;visibility:visible;display:inline;overflow:visible"
+       transform="matrix(2.527571,0,0,2.527571,85.214779,60.619097)" />
+    <path
+       d="m 194.51692,77.283737 c 0,20.659371 -17.86424,37.407103 -39.90091,37.407103 -22.03666,0 -39.90091,-16.747732 -39.90091,-37.407103 0,-20.659371 17.86425,-37.4071 39.90091,-37.4071 22.03667,0 39.90091,16.747729 39.90091,37.4071 z"
+       id="path11951"
+       sodipodi:cx="154.61601"
+       sodipodi:cy="77.283737"
+       sodipodi:rx="39.900909"
+       sodipodi:ry="37.407101"
+       sodipodi:type="arc"
+       style="fill:#f5ff12;fill-opacity:1;fill-rule:nonzero;stroke:#f5ff12;stroke-width:10.27388287;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:0.5;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker:none;visibility:visible;display:inline;overflow:visible"
+       transform="matrix(2.4568175,0,0,2.1990879,404.91256,120.05076)" />
+    <path
+       transform="matrix(3.2663208,0,0,3.4016021,515.92101,-254.59331)"
+       style="fill:#6798e9;fill-opacity:1;fill-rule:nonzero;stroke:#6798e9;stroke-width:7.30059433;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0.5;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker:none;visibility:visible;display:inline;overflow:visible"
+       sodipodi:type="inkscape:offset"
+       inkscape:radius="0"
+       inkscape:original="M 110.53125 144.96875 C 100.76599 144.96875 92.384060 150.03292 88.281250 157.34375 C 86.642607 156.42892 84.835190 155.87500 82.906250 155.87500 C 77.073071 155.87500 72.219030 160.56753 70.718750 166.93750 C 68.157973 165.92533 65.180470 165.31250 62.000000 165.31250 C 52.458571 165.31250 44.718750 170.53296 44.718750 176.96875 C 44.718749 182.77816 51.066430 187.55402 59.312500 188.43750 C 58.942922 189.06456 58.656250 189.68551 58.656250 190.34375 C 58.656248 196.50568 75.538140 201.53125 96.343750 201.53125 C 117.14936 201.53125 134.03126 196.50568 134.03125 190.34375 C 134.03125 189.92916 133.77393 189.55916 133.62500 189.15625 C 134.53629 189.38287 135.43860 189.62500 136.43750 189.62500 C 142.00333 189.62501 146.53125 185.84318 146.53125 181.18750 C 146.53125 176.53182 142.00332 172.75000 136.43750 172.75000 C 135.75542 172.75000 135.17544 172.98560 134.53125 173.09375 C 135.09454 171.23218 135.46875 169.33268 135.46875 167.31250 C 135.46875 154.98864 124.31330 144.96875 110.53125 144.96875 z "
+       id="path11953"
+       d="m 110.53125,144.96875 c -9.76526,0 -18.14719,5.06417 -22.25,12.375 -1.638643,-0.91483 -3.44606,-1.46875 -5.375,-1.46875 -5.833179,0 -10.68722,4.69253 -12.1875,11.0625 -2.560777,-1.01217 -5.53828,-1.625 -8.71875,-1.625 -9.541429,0 -17.28125,5.22046 -17.28125,11.65625 -10e-7,5.80941 6.34768,10.58527 14.59375,11.46875 -0.369578,0.62706 -0.65625,1.24801 -0.65625,1.90625 -2e-6,6.16193 16.88189,11.1875 37.6875,11.1875 20.80561,0 37.68751,-5.02557 37.6875,-11.1875 0,-0.41459 -0.25732,-0.78459 -0.40625,-1.1875 0.91129,0.22662 1.8136,0.46875 2.8125,0.46875 5.56583,1e-5 10.09375,-3.78182 10.09375,-8.4375 0,-4.65568 -4.52793,-8.4375 -10.09375,-8.4375 -0.68208,0 -1.26206,0.2356 -1.90625,0.34375 0.56329,-1.86157 0.9375,-3.76107 0.9375,-5.78125 0,-12.32386 -11.15545,-22.34375 -24.9375,-22.34375 z" />
+    <path
+       inkscape:connector-curvature="0"
+       style="fill:#386195;fill-opacity:1;fill-rule:nonzero;stroke:#386195;stroke-width:24.07697487;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:0.5;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker:none;visibility:visible;display:inline;overflow:visible"
+       id="path11963"
+       d="m 975.70833,305.75079 c -17.87875,0 -33.1897,9.10731 -40.70137,22.18913 -3.00012,-1.63696 -6.34124,-2.6392 -9.87286,-2.6392 -10.67967,0 -19.5639,8.39604 -22.31073,19.7943 -4.6884,-1.81117 -10.09942,-2.93251 -15.92242,-2.93251 -17.46892,0 -31.65122,9.35352 -31.65122,20.86955 0,10.39528 11.61748,18.9466 26.71485,20.52749 -0.67665,1.12204 -1.20995,2.24338 -1.20995,3.42121 0,11.02604 30.92124,19.98985 69.01327,19.98985 38.09195,0 69.0132,-8.96381 69.0132,-19.98985 0,-0.74183 -0.5017,-1.42952 -0.7743,-2.15046 1.6684,0.40556 3.3496,0.83088 5.1784,0.83088 10.1902,0 18.439,-6.7716 18.439,-15.10234 0,-8.33078 -8.2488,-15.05348 -18.439,-15.05348 -1.2488,0 -2.3535,0.39297 -3.5329,0.58647 1.0312,-3.33102 1.7422,-6.7466 1.7422,-10.36143 0,-22.05212 -20.4533,-39.97961 -45.68617,-39.97961 z" />
+    <path
+       inkscape:connector-curvature="0"
+       style="fill:#6798e9;fill-opacity:1;fill-rule:nonzero;stroke:#6798e9;stroke-width:15.64964962;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3.20000005;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker:none;visibility:visible;display:inline;overflow:visible"
+       sodipodi:nodetypes="cccc"
+       id="path11965"
+       d="m 717.80594,482.73655 c -32.27924,28.4432 5.62151,52.69793 20.03284,13.63938 l 11.08203,-36.22961 -31.11487,22.59023 z" />
+    <path
+       inkscape:connector-curvature="0"
+       style="fill:#6798e9;fill-opacity:1;fill-rule:nonzero;stroke:#6798e9;stroke-width:15.64964962;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3.20000005;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0;marker:none;visibility:visible;display:inline;overflow:visible"
+       sodipodi:nodetypes="cccc"
+       id="path11967"
+       d="m 799.47,485.76116 c -32.27925,28.4432 5.62151,52.69792 20.03284,13.63937 l 11.08202,-36.2296 -31.11486,22.59023 z" />
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-weight:bold;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Sans;-inkscape-font-specification:Sans Bold"
+       x="68.985565"
+       y="92.712631"
+       id="text2992"
+       sodipodi:linespacing="125%"
+       transform="translate(321.13452,104.68346)"><tspan
+         sodipodi:role="line"
+         id="tspan2994"
+         x="68.985565"
+         y="92.712631" /></text>
+    <text
+       xml:space="preserve"
+       style="font-size:10px;font-style:normal;font-weight:bold;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Sans;-inkscape-font-specification:Sans Bold"
+       x="-202.1156"
+       y="155.64684"
+       id="text2996"
+       sodipodi:linespacing="125%"
+       transform="translate(321.13452,104.68346)"><tspan
+         sodipodi:role="line"
+         id="tspan2998"
+         x="-202.1156"
+         y="155.64684" /></text>
+    <text
+       xml:space="preserve"
+       style="font-size:24px;font-style:normal;font-weight:bold;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Sans;-inkscape-font-specification:Sans Bold"
+       x="342.91943"
+       y="155.03653"
+       id="text3000"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3002"
+         x="342.91943"
+         y="155.03653"
+         style="font-size:32px;font-style:normal;font-variant:normal;font-weight:500;font-stretch:normal;font-family:Ubuntu;-inkscape-font-specification:Ubuntu Medium">Wheather App</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:24px;font-style:normal;font-weight:bold;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;font-family:Sans;-inkscape-font-specification:Sans Bold"
+       x="460.31592"
+       y="358.3624"
+       id="text3004"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3006"
+         x="460.31592"
+         y="358.3624"
+         style="font-size:48px;fill:#ff0000;-inkscape-font-specification:Ubuntu;font-family:Ubuntu;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal">22C</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:24px;font-style:normal;font-weight:bold;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;font-family:Sans;-inkscape-font-specification:Sans Bold"
+       x="460.19751"
+       y="412.14325"
+       id="text3004-0"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3006-4"
+         x="460.19751"
+         y="412.14325"
+         style="font-size:48px;fill:#0000ff;-inkscape-font-specification:Ubuntu Medium;font-family:Ubuntu;font-weight:500;font-style:normal;font-stretch:normal;font-variant:normal">14C</tspan></text>
+  </g>
+</svg>

=== added file 'qml/DeviceConfiguration.qml'
--- qml/DeviceConfiguration.qml	1970-01-01 00:00:00 +0000
+++ qml/DeviceConfiguration.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,81 @@
+/*
+ * 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 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.0
+
+StateGroup {
+    id: root
+
+    readonly property int useNativeOrientation: -1
+
+    property int primaryOrientation: useNativeOrientation
+
+    property int supportedOrientations: Qt.PortraitOrientation
+                                      | Qt.InvertedPortraitOrientation
+                                      | Qt.LandscapeOrientation
+                                      | Qt.InvertedLandscapeOrientation
+
+    // Supported values so far:
+    // "phone", "tablet" or "desktop"
+    property string category: "phone"
+
+
+    property alias name: root.state
+
+    states: [
+        State {
+            name: "mako"
+            PropertyChanges {
+                target: root
+                supportedOrientations: Qt.PortraitOrientation
+                                     | Qt.LandscapeOrientation
+                                     | Qt.InvertedLandscapeOrientation
+            }
+        },
+        State {
+            name: "krillin"
+            PropertyChanges {
+                target: root
+                supportedOrientations: Qt.PortraitOrientation
+                                     | Qt.LandscapeOrientation
+                                     | Qt.InvertedLandscapeOrientation
+            }
+        },
+        State {
+            name: "manta"
+            PropertyChanges {
+                target: root
+                category: "tablet"
+            }
+        },
+        State {
+            name: "flo"
+            PropertyChanges {
+                target: root
+                primaryOrientation: Qt.InvertedLandscapeOrientation
+                category: "tablet"
+            }
+        },
+        State {
+            name: "desktop"
+            PropertyChanges {
+                target: root
+                category: "desktop"
+            }
+        }
+    ]
+
+}

=== modified file 'qml/Greeter/Greeter.qml'
--- qml/Greeter/Greeter.qml	2015-03-18 10:17:28 +0000
+++ qml/Greeter/Greeter.qml	2015-05-18 22:06:13 +0000
@@ -52,6 +52,8 @@
     property int failedLoginsDelayAttempts: 7 // number of failed logins
     property real failedLoginsDelayMinutes: 5 // minutes of forced waiting
 
+    readonly property bool animating: loader.item ? loader.item.animating : false
+
     signal tease()
     signal sessionStarted()
     signal emergencyCall()

=== modified file 'qml/Greeter/NarrowView.qml'
--- qml/Greeter/NarrowView.qml	2015-02-23 15:43:41 +0000
+++ qml/Greeter/NarrowView.qml	2015-05-18 22:06:13 +0000
@@ -33,6 +33,7 @@
     property alias infographicModel: coverPage.infographicModel
     readonly property bool fullyShown: coverPage.showProgress === 1 || lockscreen.shown
     readonly property bool required: coverPage.required || lockscreen.required
+    readonly property bool animating: coverPage.showAnimation.running || coverPage.hideAnimation.running
 
     signal selected(int index) // unused
     signal responded(string response)

=== modified file 'qml/Greeter/WideView.qml'
--- qml/Greeter/WideView.qml	2015-02-23 15:43:41 +0000
+++ qml/Greeter/WideView.qml	2015-05-18 22:06:13 +0000
@@ -32,6 +32,7 @@
     property alias infographicModel: coverPage.infographicModel
     readonly property bool fullyShown: coverPage.showProgress === 1
     readonly property bool required: coverPage.required
+    readonly property bool animating: coverPage.showAnimation.running || coverPage.hideAnimation.running
 
     // so that it can be replaced in tests with a mock object
     property var inputMethod: Qt.inputMethod

=== added file 'qml/OrientedShell.qml'
--- qml/OrientedShell.qml	1970-01-01 00:00:00 +0000
+++ qml/OrientedShell.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,185 @@
+/*
+ * 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 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.0
+import QtQuick.Window 2.0
+import Unity.Session 0.1
+import GSettings 1.0
+import "Components"
+import "Rotation"
+
+Rectangle {
+    id: root
+    color: "black"
+
+    implicitWidth: units.gu(40)
+    implicitHeight: units.gu(71)
+
+    // NB: native and primary orientations here don't map exactly to their QScreen counterparts
+    readonly property int nativeOrientation: width > height ? Qt.LandscapeOrientation : Qt.PortraitOrientation
+
+    readonly property int primaryOrientation:
+            deviceConfiguration.primaryOrientation == deviceConfiguration.useNativeOrientation
+                   ? nativeOrientation : deviceConfiguration.primaryOrientation
+
+    DeviceConfiguration {
+        id: deviceConfiguration
+        name: applicationArguments.deviceName
+    }
+
+    // to be overwritten by tests
+    property var usageModeSettings: GSettings { schema.id: "com.canonical.Unity8" }
+    property int physicalOrientation: Screen.orientation
+    property bool orientationLocked: OrientationLock.enabled
+    property var orientationLock: OrientationLock
+
+    property int orientation
+    onPhysicalOrientationChanged: {
+        if (!orientationLocked) {
+            orientation = physicalOrientation;
+        }
+    }
+    onOrientationLockedChanged: {
+        if (orientationLocked) {
+            orientationLock.savedOrientation = physicalOrientation;
+        } else {
+            orientation = physicalOrientation;
+        }
+    }
+    Component.onCompleted: {
+        if (orientationLocked) {
+            orientation = orientationLock.savedOrientation;
+        }
+    }
+
+    readonly property int supportedOrientations: shell.supportedOrientations
+                                               & deviceConfiguration.supportedOrientations
+    property int acceptedOrientationAngle: {
+        if (orientation & supportedOrientations) {
+            return Screen.angleBetween(nativeOrientation, orientation);
+        } else if (shell.orientation & supportedOrientations) {
+            // stay where we are
+            return shell.orientationAngle;
+        } else if (angleToOrientation(shell.mainAppWindowOrientationAngle) & supportedOrientations) {
+            return shell.mainAppWindowOrientationAngle;
+        } else {
+            // rotate to some supported orientation as we can't stay where we currently are
+            // TODO: Choose the closest to the current one
+            if (supportedOrientations & Qt.PortraitOrientation) {
+                return Screen.angleBetween(nativeOrientation, Qt.PortraitOrientation);
+            } else if (supportedOrientations & Qt.LandcscapeOrientation) {
+                return Screen.angleBetween(nativeOrientation, Qt.LandscapeOrientation);
+            } else if (supportedOrientations & Qt.InvertedPortraitOrientation) {
+                return Screen.angleBetween(nativeOrientation, Qt.InvertedPortraitOrientation);
+            } else if (supportedOrientations & Qt.InvertedLandscapeOrientation) {
+                return Screen.angleBetween(nativeOrientation, Qt.InvertedLandscapeOrientation);
+            } else {
+                // if all fails, fallback to primary orientation
+                return Screen.angleBetween(nativeOrientation, primaryOrientation);
+            }
+        }
+    }
+
+    function angleToOrientation(angle) {
+        switch (angle) {
+        case 0:
+            return nativeOrientation;
+            break;
+        case 90:
+            return nativeOrientation === Qt.PortraitOrientation ? Qt.InvertedLandscapeOrientation
+                                                                : Qt.PortraitOrientation;
+            break;
+        case 180:
+            return nativeOrientation === Qt.PortraitOrientation ? Qt.InvertedPortraitOrientation
+                                                                : Qt.InvertedLandscapeOrientation;
+            break;
+        case 270:
+            return nativeOrientation === Qt.PortraitOrientation ? Qt.LandscapeOrientation
+                                                                : Qt.InvertedPortraitOrientation;
+            break;
+        default:
+            console.warn("angleToOrientation: Invalid orientation angle: " + angle);
+            return primaryOrientation;
+        }
+    }
+
+    RotationStates {
+        id: rotationStates
+        objectName: "rotationStates"
+        orientedShell: root
+        shell: shell
+        shellCover: shellCover
+        windowScreenshot: windowScreenshot
+    }
+
+    Shell {
+        id: shell
+        objectName: "shell"
+        width: root.width
+        height: root.height
+        orientation: root.angleToOrientation(orientationAngle)
+        primaryOrientation: root.primaryOrientation
+        nativeOrientation: root.nativeOrientation
+        nativeWidth: root.width
+        nativeHeight: root.height
+
+        // TODO: Factor in the connected input devices (eg: physical keyboard, mouse, touchscreen),
+        //       what's the output device (eg: big TV, desktop monitor, phone display), etc.
+        usageScenario: {
+            if (root.usageModeSettings.usageMode === "Windowed") {
+                return "desktop";
+            } else if (root.usageModeSettings.usageMode === "Staged"
+                    && deviceConfiguration.category === "desktop") {
+                return "tablet";
+            } else {
+                return deviceConfiguration.category;
+            }
+        }
+
+        property real transformRotationAngle
+        property real transformOriginX
+        property real transformOriginY
+
+        transform: Rotation {
+            origin.x: shell.transformOriginX; origin.y: shell.transformOriginY; axis { x: 0; y: 0; z: 1 }
+            angle: shell.transformRotationAngle
+        }
+    }
+
+    Rectangle {
+        id: shellCover
+        color: "black"
+        anchors.fill: parent
+        visible: false
+    }
+
+    WindowScreenshot {
+        id: windowScreenshot
+        visible: false
+        width: root.width
+        height: root.height
+
+        property real transformRotationAngle
+        property real transformOriginX
+        property real transformOriginY
+
+        transform: Rotation {
+            origin.x: windowScreenshot.transformOriginX; origin.y: windowScreenshot.transformOriginY;
+            axis { x: 0; y: 0; z: 1 }
+            angle: windowScreenshot.transformRotationAngle
+        }
+    }
+}

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2015-04-02 15:08:05 +0000
+++ qml/Panel/Panel.qml	2015-05-18 22:06:13 +0000
@@ -27,6 +27,9 @@
     property alias indicators: __indicators
     property alias callHint: __callHint
     property bool fullscreenMode: false
+    property real indicatorAreaShowProgress: 1.0
+
+    opacity: fullscreenMode && indicators.fullyClosed ? 0.0 : 1.0
 
     Rectangle {
         id: darkenedArea
@@ -58,6 +61,12 @@
             NumberAnimation { duration: UbuntuAnimation.FastDuration; easing: UbuntuAnimation.StandardEasing }
         }
 
+        transform: Translate {
+            y: indicators.state === "initial"
+                ? (1.0 - indicatorAreaShowProgress) * -d.indicatorHeight
+                : 0
+        }
+
         BorderImage {
             id: dropShadow
             anchors {

=== added directory 'qml/Rotation'
=== added file 'qml/Rotation/HalfLoopRotationAnimation.qml'
--- qml/Rotation/HalfLoopRotationAnimation.qml	1970-01-01 00:00:00 +0000
+++ qml/Rotation/HalfLoopRotationAnimation.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,46 @@
+/*
+ * 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 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.3
+
+SequentialAnimation {
+    id: root
+
+    // set from outside
+    property int fromAngle
+    property int toAngle
+    property var info
+    property var shell
+
+    readonly property bool flipShellDimensions: toAngle == 90 || toAngle == 270
+
+    ScriptAction { script: {
+        info.transitioning = true;
+        shell.orientationAngle = root.toAngle;
+        shell.x = (orientedShell.width - shell.width) / 2
+        shell.y = (orientedShell.height - shell.height) / 2;
+        shell.transformOriginX = shell.width / 2;
+        shell.transformOriginY = shell.height / 2;
+        shell.updateFocusedAppOrientation();
+    } }
+    NumberAnimation {
+        target: shell
+        property: "transformRotationAngle"
+        from: root.fromAngle; to: root.toAngle
+        duration: rotationDuration; easing.type: rotationEasing
+    }
+    ScriptAction { script: { info.transitioning = false; } }
+}

=== added file 'qml/Rotation/ImmediateRotationAction.qml'
--- qml/Rotation/ImmediateRotationAction.qml	1970-01-01 00:00:00 +0000
+++ qml/Rotation/ImmediateRotationAction.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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 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.3
+
+ScriptAction {
+    property var info
+    property var shell
+
+    script: {
+        info.transitioning = true;
+        shell.orientationAngle = info.requestedOrientationAngle;
+        shell.transformRotationAngle = info.requestedOrientationAngle;
+
+        // Making bindings as orientedShell's dimensions might wiggle during startup.
+        if (info.requestedOrientationAngle === 90 || info.requestedOrientationAngle === 270) {
+            shell.width = Qt.binding(function() { return orientedShell.height; });
+            shell.height = Qt.binding(function() { return orientedShell.width; });
+        } else {
+            shell.width = Qt.binding(function() { return orientedShell.width; });
+            shell.height = Qt.binding(function() { return orientedShell.height; });
+        }
+
+        shell.x = Qt.binding(function() { return (orientedShell.width - shell.width) / 2; });
+        shell.y = Qt.binding(function() { return (orientedShell.height - shell.height) / 2; });
+        shell.transformOriginX = Qt.binding(function() { return shell.width / 2; });
+        shell.transformOriginY = Qt.binding(function() { return shell.height / 2; });
+
+        shell.updateFocusedAppOrientation();
+        info.transitioning = false;
+    }
+}

=== added file 'qml/Rotation/NinetyRotationAnimation.qml'
--- qml/Rotation/NinetyRotationAnimation.qml	1970-01-01 00:00:00 +0000
+++ qml/Rotation/NinetyRotationAnimation.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,90 @@
+/*
+ * 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 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.3
+
+SequentialAnimation {
+    id: root
+
+    property int fromAngle
+    property int toAngle
+    property var info
+    property var shell
+
+    readonly property real fromY: fromAngle === 0 || fromAngle === 90 ? 0 : orientedShell.height - orientedShell.width;
+    readonly property real toY: toAngle === 0 || toAngle === 90 ? 0 : orientedShell.height - orientedShell.width;
+    readonly property bool flipShellDimensions: toAngle == 90 || toAngle == 270
+
+    ScriptAction { script: {
+        info.transitioning = true;
+        windowScreenshot.take();
+        windowScreenshot.visible = true;
+        shell.orientationAngle = root.toAngle;
+        shell.x = 0;
+        shell.width = flipShellDimensions ? orientedShell.height : orientedShell.width;
+        shell.height = flipShellDimensions ? orientedShell.width : orientedShell.height;
+        shell.transformOriginX = orientedShell.width / 2;
+        shell.transformOriginY = orientedShell.width / 2;
+        shell.updateFocusedAppOrientation();
+        shellCover.visible = true;
+
+        windowScreenshot.transformOriginX = orientedShell.width / 2;
+        if (fromAngle == 180 || fromAngle == 270) {
+            windowScreenshot.transformOriginY = orientedShell.height - (orientedShell.width / 2);
+        } else {
+            windowScreenshot.transformOriginY = orientedShell.width / 2;
+        }
+    } }
+    ParallelAnimation {
+        NumberAnimation {
+            target: shellCover; property: "opacity"; from: 1; to: 0;
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+        RotationAnimation {
+            target: shell; property: "transformRotationAngle";
+            from: root.fromAngle; to: root.toAngle
+            direction: RotationAnimation.Shortest
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+        NumberAnimation {
+            target: shell; property: "y"
+            from: root.fromY; to: root.toY
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+
+        NumberAnimation {
+            target: windowScreenshot; property: "opacity"; from: 1; to: 0;
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+        RotationAnimation {
+            target: windowScreenshot; property: "transformRotationAngle";
+            from: 0; to: root.toAngle - root.fromAngle
+            direction: RotationAnimation.Shortest
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+        NumberAnimation {
+            target: windowScreenshot; property: "y"
+            from: 0; to: root.toY - root.fromY
+            duration: rotationDuration; easing.type: rotationEasing
+        }
+    }
+    ScriptAction { script: {
+        windowScreenshot.visible = false;
+        windowScreenshot.discard();
+        shellCover.visible = false;
+        info.transitioning = false;
+    } }
+}

=== added file 'qml/Rotation/RotationStates.qml'
--- qml/Rotation/RotationStates.qml	1970-01-01 00:00:00 +0000
+++ qml/Rotation/RotationStates.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,278 @@
+/*
+ * 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 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.0
+import Ubuntu.Components 1.1
+import Powerd 0.1
+
+// Why the state machine is done that way:
+// We cannot use regular PropertyChanges{} inside the State elements as steps in the
+// transition animations must take place in a well defined order.
+// Which means that we also cannot jump to a new state in the middle of a transition
+// as that would make hell brake loose.
+StateGroup {
+    id: root
+
+    // to be set from the outside
+    property Item orientedShell
+    property Item shell
+    property Item shellCover
+    property Item windowScreenshot
+
+    property int rotationDuration: 450
+    property int rotationEasing: Easing.InOutCubic
+    // Those values are good for debugging/development
+    //property int rotationDuration: 3000
+    //property int rotationEasing: Easing.Linear
+
+    state: "0"
+    states: [
+        State { name: "0" },
+        State { name: "90" },
+        State { name: "180" },
+        State { name: "270" }
+    ]
+
+    property QtObject d: QtObject {
+        id: d
+
+        property bool startingUp: true
+        property var finishStartUpTimer: Timer {
+            interval: 500
+            onTriggered: d.startingUp = false
+        }
+        Component.onCompleted: {
+            finishStartUpTimer.start();
+        }
+
+        property bool transitioning: false
+        onTransitioningChanged: {
+            d.tryUpdateState();
+        }
+
+        readonly property int requestedOrientationAngle: root.orientedShell.acceptedOrientationAngle
+
+        // Avoiding a direct call to tryUpdateState() as the state change might trigger an immediate
+        // change to Shell.orientationAngle which, in its turn, causes a reevaluation of
+        // requestedOrientationAngle (ie., OrientedShell.acceptedOrientationAngle). A reentrant evaluation
+        // of a binding is detected by QML as a binding loop and QML will deny the reevalutation, which
+        // will leave us in a bogus state.
+        //
+        // To avoid this mess we update the state in the next event loop iteration, ensuring a clean
+        // call stack.
+        onRequestedOrientationAngleChanged: {
+            stateUpdateTimer.start();
+        }
+        property Timer stateUpdateTimer: Timer {
+            id: stateUpdateTimer
+            interval: 1
+            onTriggered: { d.tryUpdateState(); }
+        }
+
+        function tryUpdateState() {
+            if (d.transitioning || (!d.startingUp && !root.shell.orientationChangesEnabled)) {
+                return;
+            }
+
+            var requestedState = d.requestedOrientationAngle.toString();
+            if (requestedState !== root.state) {
+                d.resolveAnimationType();
+                root.state = requestedState;
+            }
+        }
+
+        property Connections shellConnections: Connections {
+            target: root.shell
+            onOrientationChangesEnabledChanged: {
+                d.tryUpdateState();
+            }
+        }
+
+        property var shellBeingResized: Binding {
+            target: root.shell
+            property: "beingResized"
+            value: d.transitioning
+        }
+
+        readonly property int fullAnimation: 0
+        readonly property int indicatorsBarAnimation: 1
+        readonly property int noAnimation: 2
+
+        property int animationType
+
+        // animationType update *must* take place *before* the state update.
+        // If animationType and state were updated through bindings, as with normal qml code,
+        // there would be no guarantee in the order of the binding updates, which could then
+        // cause the wrong transitions to be chosen for the state changes.
+        function resolveAnimationType() {
+            if (d.startingUp) {
+                // During start up, inital property values are still settling while we're still
+                // to render the very first frame
+                d.animationType = d.noAnimation;
+            } else if (Powerd.status === Powerd.Off) {
+                // There's no point in animating if the user can't see it (display is off).
+                d.animationType = d.noAnimation;
+            } else if (root.shell.showingGreeter) {
+                // A rotating greeter looks weird.
+                d.animationType = d.noAnimation;
+            } else {
+                if (!root.shell.mainApp) {
+                    // shouldn't happen but, anyway
+                    d.animationType = d.fullAnimation;
+                    return;
+                }
+
+                if (root.shell.mainApp.rotatesWindowContents) {
+                    // The application will animate its own GUI, so we don't have to do anything ourselves.
+                    d.animationType = d.noAnimation;
+                } else if (root.shell.mainAppWindowOrientationAngle == d.requestedOrientationAngle) {
+                    // The app window is already on its final orientation angle.
+                    // So we just animate the indicators bar
+                    // TODO: what if the app is fullscreen?
+                    d.animationType = d.indicatorsBarAnimation;
+                } else {
+                    d.animationType = d.fullAnimation;
+                }
+            }
+        }
+
+        // When an application switch takes place, d.requestedOrientationAngle and
+        // root.shell.mainAppWindowOrientationAngle get updated separately, at different moments.
+        // So, when one of those properties change, we shouldn't make a decision straight away
+        // as the other might be stale and about to be changed. So let's give it a bit of time for
+        // them to get properly updated.
+        // This approach is indeed a bit hacky.
+        property bool appWindowOrientationAngleNeedsUpdateUnstable:
+            root.shell.orientationAngle === d.requestedOrientationAngle
+            && root.shell.mainApp
+            && root.shell.mainAppWindowOrientationAngle !== root.shell.orientationAngle
+            && !d.transitioning
+        onAppWindowOrientationAngleNeedsUpdateUnstableChanged: {
+            stableTimer.restart();
+        }
+        property Timer stableTimer: Timer {
+            interval: 200
+            onTriggered: {
+                if (d.appWindowOrientationAngleNeedsUpdateUnstable) {
+                    shell.updateFocusedAppOrientationAnimated();
+                }
+            }
+        }
+    }
+
+    transitions: [
+        Transition {
+            from: "90"; to: "0"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 90; toAngle: 0
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "0"; to: "90"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 0; toAngle: 90
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "0"; to: "270"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 0; toAngle: 270
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "270"; to: "0"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 270; toAngle: 0
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "90"; to: "180"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 90; toAngle: 180
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "180"; to: "90"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 180; toAngle: 90
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "180"; to: "270"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 180; toAngle: 270
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "270"; to: "180"
+            enabled: d.animationType == d.fullAnimation
+            NinetyRotationAnimation { fromAngle: 270; toAngle: 180
+                                      info: d; shell: root.shell }
+        },
+        Transition {
+            from: "0"; to: "180"
+            enabled: d.animationType == d.fullAnimation
+            HalfLoopRotationAnimation { fromAngle: 0; toAngle: 180
+                                        info: d; shell: root.shell }
+        },
+        Transition {
+            from: "180"; to: "0"
+            enabled: d.animationType == d.fullAnimation
+            HalfLoopRotationAnimation { fromAngle: 180; toAngle: 0
+                                        info: d; shell: root.shell }
+        },
+        Transition {
+            from: "90"; to: "270"
+            enabled: d.animationType == d.fullAnimation
+            HalfLoopRotationAnimation { fromAngle: 90; toAngle: 270
+                                        info: d; shell: root.shell }
+        },
+        Transition {
+            from: "270"; to: "90"
+            enabled: d.animationType == d.fullAnimation
+            HalfLoopRotationAnimation { fromAngle: 270; toAngle: 90
+                                        info: d; shell: root.shell }
+        },
+        Transition {
+            objectName: "immediateTransition"
+            enabled: d.animationType == d.noAnimation
+            ImmediateRotationAction { info: d; shell: root.shell }
+        },
+        Transition {
+            enabled: d.animationType == d.indicatorsBarAnimation
+            SequentialAnimation {
+                ScriptAction { script: {
+                    d.transitioning = true;
+                } }
+                NumberAnimation {
+                    duration: UbuntuAnimation.FastDuration; easing: UbuntuAnimation.StandardEasing
+                    target: root.shell; property: "indicatorAreaShowProgress"
+                    from: 1.0; to: 0.0
+                }
+                ImmediateRotationAction { info: d; shell: root.shell }
+                NumberAnimation {
+                    duration: UbuntuAnimation.FastDuration; easing: UbuntuAnimation.StandardEasing
+                    target: root.shell; property: "indicatorAreaShowProgress"
+                    from: 0.0; to: 1.0
+                }
+                ScriptAction { script: {
+                    d.transitioning = false;
+                }}
+            }
+        }
+    ]
+
+}

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2015-05-05 14:46:18 +0000
+++ qml/Shell.qml	2015-05-18 22:06:13 +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
@@ -45,39 +45,69 @@
 Item {
     id: shell
 
+    // to be set from outside
+    property int orientationAngle: 0
+    property int orientation
+    property int primaryOrientation
+    property int nativeOrientation
+    property real nativeWidth
+    property real nativeHeight
+    property alias indicatorAreaShowProgress: panel.indicatorAreaShowProgress
+    property bool beingResized
+    property string usageScenario: "phone" // supported values: "phone", "tablet" or "desktop"
+    function updateFocusedAppOrientation() {
+        applicationsDisplayLoader.item.updateFocusedAppOrientation();
+    }
+    function updateFocusedAppOrientationAnimated() {
+        applicationsDisplayLoader.item.updateFocusedAppOrientationAnimated();
+    }
+
+    // to be read from outside
+    readonly property int mainAppWindowOrientationAngle:
+            applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainAppWindowOrientationAngle : 0
+
+    readonly property bool orientationChangesEnabled: panel.indicators.fullyClosed
+            && (applicationsDisplayLoader.item && applicationsDisplayLoader.item.orientationChangesEnabled)
+            && !greeter.animating
+
+    readonly property bool showingGreeter: greeter.shown
+
+    property bool startingUp: true
+    Timer { id: finishStartUpTimer; interval: 500; onTriggered: startingUp = false }
+
+    property int supportedOrientations: {
+        if (startingUp) {
+            // Ensure we don't rotate during start up
+            return Qt.PrimaryOrientation;
+        } else if (greeter.shown) {
+            return Qt.PrimaryOrientation;
+        } else if (mainApp) {
+            return mainApp.supportedOrientations;
+        } else {
+            // we just don't care
+            return Qt.PortraitOrientation
+                 | Qt.LandscapeOrientation
+                 | Qt.InvertedPortraitOrientation
+                 | Qt.InvertedLandscapeOrientation;
+        }
+    }
+
+    // For autopilot consumption
+    readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
+
+    // internal props from here onwards
+    readonly property var mainApp:
+            applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null
+
     // Disable everything while greeter is waiting, so that the user can't swipe
     // the greeter or launcher until we know whether the session is locked.
     enabled: !greeter.waiting
 
-    // this is only here to select the width / height of the window if not running fullscreen
-    property bool tablet: false
-    width: tablet ? units.gu(160) : applicationArguments.hasGeometry() ? applicationArguments.width() : units.gu(40)
-    height: tablet ? units.gu(100) : applicationArguments.hasGeometry() ? applicationArguments.height() : units.gu(71)
-
     property real edgeSize: units.gu(2)
     property url defaultBackground: Qt.resolvedUrl(shell.width >= units.gu(60) ? "graphics/tablet_background.jpg" : "graphics/phone_background.jpg")
     property url background: asImageTester.status == Image.Ready ? asImageTester.source
                              : gsImageTester.status == Image.Ready ? gsImageTester.source : defaultBackground
 
-    property bool sideStageEnabled: shell.width >= units.gu(100)
-    readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
-
-    property int orientation
-    readonly property int deviceOrientationAngle: Screen.angleBetween(Screen.primaryOrientation, Screen.orientation)
-    onDeviceOrientationAngleChanged: {
-        if (!OrientationLock.enabled) {
-            orientation = Screen.orientation;
-        }
-    }
-    readonly property bool orientationLockEnabled: OrientationLock.enabled
-    onOrientationLockEnabledChanged: {
-        if (orientationLockEnabled) {
-            OrientationLock.savedOrientation = Screen.orientation;
-        } else {
-            orientation = Screen.orientation;
-        }
-    }
-
     // This is _only_ used to expose the property to autopilot tests
     readonly property string testShellMode: shellMode
 
@@ -85,7 +115,8 @@
         if (ApplicationManager.findApplication(appId)) {
             ApplicationManager.requestFocusApplication(appId);
         } else {
-            var execFlags = shell.sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;
+            var execFlags = shell.usageScenario === "phone" ? ApplicationManager.ForceMainStage
+                                                            : ApplicationManager.NoFlag;
             ApplicationManager.startApplication(appId, execFlags);
         }
     }
@@ -123,11 +154,6 @@
         sourceSize.width: 0
     }
 
-    GSettings {
-        id: usageModeSettings
-        schema.id: "com.canonical.Unity8"
-    }
-
     Binding {
         target: LauncherModel
         property: "applicationManager"
@@ -139,9 +165,7 @@
         if (ApplicationManager.count > 0) {
             ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
         }
-        if (orientationLockEnabled) {
-            orientation = OrientationLock.savedOrientation;
-        }
+        finishStartUpTimer.start();
     }
 
     VolumeControl {
@@ -234,9 +258,19 @@
             // theoretical attack where user enters lockedApp mode, then makes
             // the screen larger (maybe connects to monitor) and tries to enter
             // tablet mode.
-            property bool tabletMode: shell.sideStageEnabled && !greeter.hasLockedApp
-            source: usageModeSettings.usageMode === "Windowed" ? "Stages/DesktopStage.qml"
-                        : tabletMode ? "Stages/TabletStage.qml" : "Stages/PhoneStage.qml"
+
+            property string usageScenario: shell.usageScenario === "phone" || greeter.hasLockedApp
+                                           ? "phone"
+                                           : shell.usageScenario
+            source: {
+                if (applicationsDisplayLoader.usageScenario === "phone") {
+                    return "Stages/PhoneStage.qml";
+                } else if (applicationsDisplayLoader.usageScenario === "tablet") {
+                    return "Stages/TabletStage.qml";
+                } else {
+                    return "Stages/DesktopStage.qml";
+                }
+            }
 
             property bool interactive: tutorial.spreadEnabled
                     && !greeter.shown
@@ -279,7 +313,12 @@
             }
             Binding {
                 target: applicationsDisplayLoader.item
-                property: "orientation"
+                property: "shellOrientationAngle"
+                value: shell.orientationAngle
+            }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "shellOrientation"
                 value: shell.orientation
             }
             Binding {
@@ -287,6 +326,31 @@
                 property: "background"
                 value: shell.background
             }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "shellPrimaryOrientation"
+                value: shell.primaryOrientation
+            }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "nativeOrientation"
+                value: shell.nativeOrientation
+            }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "nativeWidth"
+                value: shell.nativeWidth
+            }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "nativeHeight"
+                value: shell.nativeHeight
+            }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "beingResized"
+                value: shell.beingResized
+            }
         }
 
         Tutorial {
@@ -356,7 +420,7 @@
         objectName: "greeter"
 
         hides: [launcher, panel.indicators]
-        tabletMode: shell.sideStageEnabled
+        tabletMode: shell.usageScenario !== "phone"
         launcherOffset: launcher.progress
         forcedUnlock: tutorial.running
         background: shell.background
@@ -483,20 +547,18 @@
                 expandedPanelHeight: units.gu(7)
 
                 indicatorsModel: Indicators.IndicatorsModel {
-                    // TODO: This should be sourced by device type (e.g. "desktop", "tablet", "phone"...)
-                    profile: indicatorProfile
-                    Component.onCompleted: load()
+                    // tablet and phone both use the same profile
+                    profile: shell.usageScenario === "desktop" ? "desktop" : "phone"
+                    Component.onCompleted: load();
                 }
             }
+
             callHint {
                 greeterShown: greeter.shown
             }
 
-            property bool topmostApplicationIsFullscreen:
-                ApplicationManager.focusedApplicationId &&
-                    ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).fullscreen
-
-            fullscreenMode: (topmostApplicationIsFullscreen && !LightDM.Greeter.active && launcher.progress == 0)
+            property bool mainAppIsFullscreen: shell.mainApp && shell.mainApp.fullscreen
+            fullscreenMode: (mainAppIsFullscreen && !LightDM.Greeter.active && launcher.progress == 0)
                             || greeter.hasLockedApp
         }
 
@@ -514,7 +576,7 @@
             available: tutorial.launcherEnabled
                     && (!greeter.locked || AccountsService.enableLauncherWhileLocked)
                     && !greeter.hasLockedApp
-            inverted: usageModeSettings.usageMode === "Staged"
+            inverted: shell.usageScenario !== "desktop"
             shadeBackground: !tutorial.running
 
             onShowDashHome: showHome()
@@ -556,7 +618,7 @@
         Rectangle {
             id: modalNotificationBackground
 
-            visible: notifications.useModal && (notifications.state == "narrow")
+            visible: notifications.useModal
             color: "#000000"
             anchors.fill: parent
             opacity: 0.9
@@ -601,6 +663,7 @@
 
     Dialogs {
         id: dialogs
+        objectName: "dialogs"
         anchors.fill: parent
         z: overlay.z + 10
         onPowerOffClicked: {

=== modified file 'qml/Stages/ApplicationWindow.qml'
--- qml/Stages/ApplicationWindow.qml	2015-02-26 22:35:53 +0000
+++ qml/Stages/ApplicationWindow.qml	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Canonical Ltd.
+ * Copyright 2014-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
@@ -24,10 +24,11 @@
     // 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
 
     // to be set from outside
     property QtObject application
-    property int orientation
+    property int surfaceOrientationAngle
 
     QtObject {
         id: d
@@ -62,6 +63,15 @@
         // Remove this when possible
         property bool surfaceInitialized: false
 
+        property bool supportsSurfaceResize:
+                application &&
+                ((application.supportedOrientations & Qt.PortraitOrientation)
+                  || (application.supportedOrientations & Qt.InvertedPortraitOrientation))
+                &&
+                ((application.supportedOrientations & Qt.LandscapeOrientation)
+                 || (application.supportedOrientations & Qt.InvertedLandscapeOrientation))
+
+        property bool surfaceOldEnoughToBeResized: false
     }
 
     Timer {
@@ -70,6 +80,12 @@
         onTriggered: { if (sessionContainer.surface) {d.surfaceInitialized = true;} }
     }
 
+    Timer {
+        id: surfaceIsOldTimer
+        interval: 1000
+        onTriggered: { if (stateGroup.state === "surface") { d.surfaceOldEnoughToBeResized = true; } }
+    }
+
     Image {
         id: screenshotImage
         objectName: "screenshotImage"
@@ -113,7 +129,8 @@
         // A fake application might not even have a session property.
         session: application && application.session ? application.session : null
         anchors.fill: parent
-        orientation: root.orientation
+
+        surfaceOrientationAngle: application && application.rotatesWindowContents ? root.surfaceOrientationAngle : 0
 
         onSurfaceChanged: {
             if (sessionContainer.surface) {
@@ -179,15 +196,21 @@
                     UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";
                                             from: 0.0; to: 1.0
                                             duration: UbuntuAnimation.BriskDuration }
-                    PropertyAction { target: splashLoader; property: "active"; value: false }
+                    ScriptAction { script: {
+                        splashLoader.active = false;
+                        surfaceIsOldTimer.start();
+                    } }
                 }
             },
             Transition {
                 from: "surface"; to: "splashScreen"
                 SequentialAnimation {
-                    PropertyAction { target: splashLoader; property: "active"; value: true }
-                    PropertyAction { target: sessionContainer.surfaceContainer
-                                     property: "visible"; value: true }
+                    ScriptAction { script: {
+                        surfaceIsOldTimer.stop();
+                        d.surfaceOldEnoughToBeResized = false;
+                        splashLoader.active = true;
+                        sessionContainer.surfaceContainer.visible = true;
+                    } }
                     UbuntuNumberAnimation { target: splashLoader; property: "opacity";
                                             from: 0.0; to: 1.0
                                             duration: UbuntuAnimation.BriskDuration }
@@ -198,14 +221,18 @@
             Transition {
                 from: "surface"; to: "screenshot"
                 SequentialAnimation {
-                    PropertyAction { target: screenshotImage
-                                     property: "visible"; value: true }
+                    ScriptAction { script: {
+                        surfaceIsOldTimer.stop();
+                        d.surfaceOldEnoughToBeResized = false;
+                        screenshotImage.visible = true;
+                    } }
                     UbuntuNumberAnimation { target: screenshotImage; property: "opacity";
                                             from: 0.0; to: 1.0
                                             duration: UbuntuAnimation.BriskDuration }
-                    PropertyAction { target: sessionContainer.surfaceContainer
-                                     property: "visible"; value: false }
-                    ScriptAction { script: { if (sessionContainer.session) { sessionContainer.session.release(); } } }
+                    ScriptAction { script: {
+                        sessionContainer.surfaceContainer.visible = false;
+                        if (sessionContainer.session) { sessionContainer.session.release(); }
+                    } }
                 }
             },
             Transition {
@@ -216,8 +243,11 @@
                     UbuntuNumberAnimation { target: screenshotImage; property: "opacity";
                                             from: 1.0; to: 0.0
                                             duration: UbuntuAnimation.BriskDuration }
-                    PropertyAction { target: screenshotImage; property: "visible"; value: false }
-                    PropertyAction { target: screenshotImage; property: "source"; value: "" }
+                    ScriptAction { script: {
+                        screenshotImage.visible = false;
+                        screenshotImage.source = "";
+                        surfaceIsOldTimer.start();
+                    } }
                 }
             },
             Transition {
@@ -233,10 +263,12 @@
             },
             Transition {
                 from: "surface"; to: "void"
-                SequentialAnimation {
-                    PropertyAction { target: sessionContainer.surfaceContainer; property: "visible"; value: false }
-                    ScriptAction { script: { if (sessionContainer.session) { sessionContainer.session.release(); } } }
-                }
+                ScriptAction { script: {
+                    surfaceIsOldTimer.stop();
+                    d.surfaceOldEnoughToBeResized = false;
+                    sessionContainer.surfaceContainer.visible = false;
+                    if (sessionContainer.session) { sessionContainer.session.release(); }
+                } }
             },
             Transition {
                 from: "void"; to: "surface"
@@ -246,6 +278,9 @@
                     UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";
                                             from: 0.0; to: 1.0
                                             duration: UbuntuAnimation.BriskDuration }
+                    ScriptAction { script: {
+                        surfaceIsOldTimer.start();
+                    } }
                 }
             }
         ]

=== modified file 'qml/Stages/DesktopStage.qml'
--- qml/Stages/DesktopStage.qml	2015-03-13 19:18:35 +0000
+++ qml/Stages/DesktopStage.qml	2015-05-18 22:06:13 +0000
@@ -27,6 +27,29 @@
 
     anchors.fill: parent
 
+    // Controls to be set from outside
+    property int dragAreaWidth // just to comply with the interface shared between stages
+    property real maximizedAppTopMargin
+    property bool interactive
+    property bool spreadEnabled // just to comply with the interface shared between stages
+    property real inverseProgress: 0 // just to comply with the interface shared between stages
+    property int shellOrientationAngle: 0
+    property int shellOrientation
+    property int shellPrimaryOrientation
+    property int nativeOrientation
+    property bool beingResized: false
+
+    // functions to be called from outside
+    function updateFocusedAppOrientation() { /* TODO */ }
+    function updateFocusedAppOrientationAnimated() { /* TODO */}
+
+    // To be read from outside
+    readonly property var mainApp: ApplicationManager.focusedApplicationId
+            ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)
+            : null
+    property int mainAppWindowOrientationAngle: 0
+    readonly property bool orientationChangesEnabled: false
+
     property alias background: wallpaper.source
 
     property var windowStateStorage: WindowStateStorage

=== added file 'qml/Stages/OrientationChangeAnimation.qml'
--- qml/Stages/OrientationChangeAnimation.qml	1970-01-01 00:00:00 +0000
+++ qml/Stages/OrientationChangeAnimation.qml	2015-05-18 22:06:13 +0000
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+
+QtObject {
+    id: root
+
+    // to be set from outside
+    property Item spreadDelegate
+    property Item background
+    property Item window
+    property Item screenshot
+
+    function start() {
+        if (window.orientationAngle === 0) {
+            if (spreadDelegate.shellOrientationAngle === 90) {
+                chosenAnimation = simple90Animation;
+            } else if (spreadDelegate.shellOrientationAngle === 180) {
+                chosenAnimation = halfLoopAnimation;
+            } else if (spreadDelegate.shellOrientationAngle === 270) {
+                chosenAnimation = moving90Animation;
+            } else {
+                chosenAnimation = null;
+            }
+        } else if (window.orientationAngle === 90) {
+            if (spreadDelegate.shellOrientationAngle === 0) {
+                chosenAnimation = simple90Animation;
+            } else if (spreadDelegate.shellOrientationAngle === 180) {
+                chosenAnimation = moving90Animation;
+            } else if (spreadDelegate.shellOrientationAngle === 270) {
+                chosenAnimation = halfLoopAnimation;
+            } else {
+                chosenAnimation = null;
+            }
+        } else if (window.orientationAngle === 180) {
+            if (spreadDelegate.shellOrientationAngle === 0) {
+                chosenAnimation = halfLoopAnimation;
+            } else if (spreadDelegate.shellOrientationAngle === 90) {
+                chosenAnimation = moving90Animation;
+            } else if (spreadDelegate.shellOrientationAngle === 270) {
+                chosenAnimation = simple90Animation;
+            } else {
+                chosenAnimation = null;
+            }
+        } else if (window.orientationAngle === 270) {
+            if (spreadDelegate.shellOrientationAngle === 0) {
+                chosenAnimation = moving90Animation;
+            } else if (spreadDelegate.shellOrientationAngle === 90) {
+                chosenAnimation = halfLoopAnimation;
+            } else if (spreadDelegate.shellOrientationAngle === 180) {
+                chosenAnimation = simple90Animation;
+            } else {
+                chosenAnimation = null;
+            }
+        }
+
+        if (chosenAnimation)
+            chosenAnimation.start();
+    }
+
+    // to be read from outside
+    property bool running: chosenAnimation ? chosenAnimation.running : false
+
+    property int duration: 450
+    property int easingType: Easing.InOutCubic
+
+    property int shortestDimension: spreadDelegate.width < spreadDelegate.height
+                                    ? spreadDelegate.width : spreadDelegate.height
+    property int longestDimension: spreadDelegate.width > spreadDelegate.height
+                                   ? spreadDelegate.width : spreadDelegate.height
+    property string longestAxis: spreadDelegate.width > spreadDelegate.height ? "x" : "y"
+
+    property QtObject chosenAnimation
+
+    function setup90Animation() {
+        background.visible = true;
+
+        screenshot.width = window.width;
+        screenshot.height = window.height;
+        screenshot.window.anchors.topMargin = window.window.anchors.topMargin;
+        screenshot.take();
+        screenshot.transformOriginX = root.shortestDimension / 2;
+        screenshot.transformOriginY = root.shortestDimension / 2;
+        screenshot.visible = true;
+
+        window.rotation = 0;
+        window.width = spreadDelegate.width;
+        window.height = spreadDelegate.height;
+        window.transformOriginX = root.shortestDimension / 2;
+        window.transformOriginY = root.shortestDimension / 2;
+    }
+
+    function tearDown90Animation() {
+        window.orientationAngle = spreadDelegate.shellOrientationAngle;
+        screenshot.discard();
+        screenshot.visible = false;
+        background.visible = false;
+    }
+
+    property QtObject simple90Animation: SequentialAnimation {
+        id: simple90Animation
+
+        ScriptAction { script: setup90Animation() }
+        ParallelAnimation {
+            RotationAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                from: window.orientationAngle - spreadDelegate.shellOrientationAngle
+                to: 0
+                property: "transformRotationAngle"
+            }
+            RotationAnimation {
+                target: root.screenshot
+                duration: root.duration
+                easing.type: root.easingType
+                from: window.orientationAngle - spreadDelegate.shellOrientationAngle
+                to: 0
+                property: "transformRotationAngle"
+            }
+            NumberAnimation {
+                target: root.screenshot
+                duration: root.duration
+                easing.type: root.easingType
+                property: "opacity"
+                from: 1.0
+                to: 0.0
+            }
+            NumberAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                property: "opacity"
+                from: 0.0
+                to: 1.0
+            }
+        }
+        ScriptAction { script: tearDown90Animation() }
+    }
+
+    property QtObject moving90Animation: SequentialAnimation {
+        id: moving90Animation
+
+        ScriptAction { script: setup90Animation() }
+        ParallelAnimation {
+            RotationAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                direction: RotationAnimation.Shortest
+                from: window.orientationAngle - spreadDelegate.shellOrientationAngle
+                to: 0
+                property: "transformRotationAngle"
+            }
+            RotationAnimation {
+                target: root.screenshot
+                duration: root.duration
+                easing.type: root.easingType
+                direction: RotationAnimation.Shortest
+                from: window.orientationAngle - spreadDelegate.shellOrientationAngle
+                to: 0
+                property: "transformRotationAngle"
+            }
+            NumberAnimation {
+                target: root.screenshot
+                duration: root.duration
+                easing.type: root.easingType
+                property: "opacity"
+                from: 1.0
+                to: 0.0
+            }
+            NumberAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                property: "opacity"
+                from: 0.0
+                to: 1.0
+            }
+            NumberAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                property: root.longestAxis
+                from: root.longestDimension - root.shortestDimension
+                to: 0
+            }
+            NumberAnimation {
+                target: root.screenshot
+                duration: root.duration
+                easing.type: root.easingType
+                property: root.longestAxis
+                from: root.longestDimension - root.shortestDimension
+                to: 0
+            }
+        }
+        ScriptAction { script: tearDown90Animation() }
+    }
+
+    property QtObject halfLoopAnimation: SequentialAnimation {
+        id: halfLoopAnimation
+
+        ScriptAction { script: {
+            background.visible = true;
+
+            window.rotation = 0;
+            window.width = spreadDelegate.width;
+            window.height = spreadDelegate.height;
+            window.transformOriginX = window.width / 2
+            window.transformOriginY = window.height / 2
+        } }
+        ParallelAnimation {
+            RotationAnimation {
+                target: root.window
+                duration: root.duration
+                easing.type: root.easingType
+                from: window.orientationAngle - spreadDelegate.shellOrientationAngle
+                to: 0
+                property: "transformRotationAngle"
+            }
+        }
+        ScriptAction { script: {
+            window.orientationAngle = spreadDelegate.shellOrientationAngle;
+            background.visible = false;
+        } }
+    }
+}

=== modified file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	2015-04-10 21:16:37 +0000
+++ qml/Stages/PhoneStage.qml	2015-05-18 22:06:13 +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 as published by
@@ -31,12 +31,64 @@
     property bool interactive
     property bool spreadEnabled: true // If false, animations and right edge will be disabled
     property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
-    property int orientation: Qt.PortraitOrientation
     property QtObject applicationManager: ApplicationManager
     property bool focusFirstApp: true // If false, focused app will appear on right edge like other apps
     property bool altTabEnabled: true
     property real startScale: 1.1
     property real endScale: 0.7
+    property int shellOrientationAngle: 0
+    property int shellOrientation
+    property int shellPrimaryOrientation
+    property int nativeOrientation
+    property real nativeWidth
+    property real nativeHeight
+    property bool beingResized: false
+    onBeingResizedChanged: {
+        if (beingResized) {
+            // Brace yourselves for impact!
+            spreadView.selectedIndex = -1;
+            spreadView.phase = 0;
+            spreadView.contentX = -spreadView.shift;
+        }
+    }
+    function updateFocusedAppOrientation() {
+        if (spreadRepeater.count > 0) {
+            spreadRepeater.itemAt(0).matchShellOrientation();
+        }
+
+        for (var i = 1; i < spreadRepeater.count; ++i) {
+
+            var spreadDelegate = spreadRepeater.itemAt(i);
+
+            var delta = spreadDelegate.appWindowOrientationAngle - root.shellOrientationAngle;
+            if (delta < 0) { delta += 360; }
+            delta = delta % 360;
+
+            var supportedOrientations = spreadDelegate.application.supportedOrientations;
+            if (supportedOrientations === Qt.PrimaryOrientation) {
+                supportedOrientations = spreadDelegate.shellPrimaryOrientation;
+            }
+
+            if (delta === 180 && (supportedOrientations & spreadDelegate.shellOrientation)) {
+                spreadDelegate.matchShellOrientation();
+            }
+        }
+    }
+    function updateFocusedAppOrientationAnimated() {
+        if (spreadRepeater.count > 0) {
+            spreadRepeater.itemAt(0).animateToShellOrientation();
+        }
+    }
+
+    // To be read from outside
+    readonly property var mainApp: applicationManager.focusedApplicationId
+            ? applicationManager.findApplication(applicationManager.focusedApplicationId)
+            : null
+    property int mainAppWindowOrientationAngle: 0
+    readonly property bool orientationChangesEnabled: priv.focusedAppOrientationChangesEnabled
+                                                   && !priv.focusedAppDelegateIsDislocated
+                                                   && !(priv.focusedAppDelegate && priv.focusedAppDelegate.xBehavior.running)
+                                                   && spreadView.phase === 0
 
     // How far left the stage has been dragged
     readonly property real dragProgress: spreadRepeater.count > 0 ? -spreadRepeater.itemAt(0).xTranslate : 0
@@ -54,12 +106,6 @@
         spreadView.snapTo(priv.indexOf(appId));
     }
 
-    onWidthChanged: {
-        spreadView.selectedIndex = -1;
-        spreadView.phase = 0;
-        spreadView.contentX = -spreadView.shift;
-    }
-
     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
@@ -73,6 +119,20 @@
         priv.oldInverseProgress = inverseProgress;
     }
 
+    // <FIXME-contentX> See rationale in the next comment with this tag
+    onWidthChanged: {
+        if (!root.beingResized) {
+            // we're being resized without a warning (ie, the corresponding property wasn't set
+            root.beingResized = true;
+            beingResizedTimer.start();
+        }
+    }
+    Timer {
+        id: beingResizedTimer
+        interval: 100
+        onTriggered: { root.beingResized = false; }
+    }
+
     Connections {
         target: applicationManager
 
@@ -115,10 +175,10 @@
     QtObject {
         id: priv
 
-        readonly property int firstSpreadIndex: root.focusFirstApp ? 1 : 0
-        property string focusedAppId: applicationManager.focusedApplicationId
-        property var focusedApplication: applicationManager.findApplication(focusedAppId)
+        property string focusedAppId: root.applicationManager.focusedApplicationId
+        property var focusedApplication: root.applicationManager.findApplication(focusedAppId)
         property var focusedAppDelegate: null
+        property bool focusedAppOrientationChangesEnabled: false
 
         property real oldInverseProgress: 0
         property bool animateX: false
@@ -131,15 +191,27 @@
             }
         }
 
+        property bool focusedAppDelegateIsDislocated: focusedAppDelegate && focusedAppDelegate.x !== 0
+
         function indexOf(appId) {
-            for (var i = 0; i < applicationManager.count; i++) {
-                if (applicationManager.get(i).appId == appId) {
+            for (var i = 0; i < root.applicationManager.count; i++) {
+                if (root.applicationManager.get(i).appId == appId) {
                     return i;
                 }
             }
             return -1;
         }
 
+        // Is more stable than "spreadView.shiftedContentX === 0" as it filters out noise caused by
+        // Flickable.contentX changing due to resizes.
+        property bool fullyShowingFocusedApp: true
+    }
+    Timer {
+        id: fullyShowingFocusedAppUpdateTimer
+        interval: 100
+        onTriggered: {
+            priv.fullyShowingFocusedApp = spreadView.shiftedContentX === 0;
+        }
     }
 
     Flickable {
@@ -187,9 +259,25 @@
         property int draggedDelegateCount: 0
         property int closingIndex: -1
 
-        property bool focusChanging: false
+        // <FIXME-contentX> Workaround Flickable's behavior of bringing contentX back between valid boundaries
+        // when resized. The proper way to fix this is refactoring PhoneStage so that it doesn't
+        // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically
+        // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger
+        // the Flickable.boundsBehavior upon release).
+        onContentXChanged: { forceItToRemainStillIfBeingResized(); }
+        onShiftChanged: { forceItToRemainStillIfBeingResized(); }
+        function forceItToRemainStillIfBeingResized() {
+            if (root.beingResized && contentX != -spreadView.shift) {
+                contentX = -spreadView.shift;
+            }
+        }
 
         onShiftedContentXChanged: {
+            if (root.beingResized) {
+                // Flickabe.contentX wiggles during resizes. Don't react to it.
+                return;
+            }
+
             switch (phase) {
             case 0:
                 if (shiftedContentX > width * positionMarker2) {
@@ -204,6 +292,7 @@
                 }
                 break;
             }
+            fullyShowingFocusedAppUpdateTimer.restart();
         }
 
         function snap() {
@@ -228,7 +317,7 @@
                 snapAnimation.start();
                 return;
             }
-            if (applicationManager.count <= index) {
+            if (root.applicationManager.count <= index) {
                 // In case we're trying to snap to some non existing app, lets snap back to the first one
                 index = 0;
             }
@@ -265,7 +354,7 @@
             ScriptAction {
                 script: {
                     if (spreadView.selectedIndex >= 0) {
-                        applicationManager.focusApplication(applicationManager.get(spreadView.selectedIndex).appId);
+                        root.applicationManager.focusApplication(root.applicationManager.get(spreadView.selectedIndex).appId);
 
                         spreadView.selectedIndex = -1;
                         spreadView.phase = 0;
@@ -280,7 +369,7 @@
             // This width controls how much the spread can be flicked left/right. It's composed of:
             //  tileDistance * app count (with a minimum of 3 apps, in order to also allow moving 1 and 2 apps a bit)
             //  + some constant value (still scales with the screen width) which looks good and somewhat fills the screen
-            width: Math.max(3, applicationManager.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5
+            width: Math.max(3, root.applicationManager.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5
             height: parent.height
             Behavior on width {
                 enabled: spreadView.closingIndex >= 0
@@ -303,7 +392,7 @@
             Repeater {
                 id: spreadRepeater
                 objectName: "spreadRepeater"
-                model: applicationManager
+                model: root.applicationManager
                 delegate: TransformedSpreadDelegate {
                     id: appDelegate
                     objectName: "appDelegate" + index
@@ -318,11 +407,10 @@
                     selected: spreadView.selectedIndex == index
                     otherSelected: spreadView.selectedIndex >= 0 && !selected
                     interactive: !spreadView.interactive && spreadView.phase === 0
-                            && spreadView.shiftedContentX === 0 && root.interactive && isFocused
+                            && priv.fullyShowingFocusedApp && root.interactive && isFocused
                     swipeToCloseEnabled: spreadView.interactive && root.interactive && !snapAnimation.running
                     maximizedAppTopMargin: root.maximizedAppTopMargin
-                    dropShadow: spreadView.active ||
-                                (priv.focusedAppDelegate && priv.focusedAppDelegate.x !== 0)
+                    dropShadow: spreadView.active || priv.focusedAppDelegateIsDislocated
                     focusFirstApp: root.focusFirstApp
 
                     readonly property bool isDash: model.appId == "unity8-dash"
@@ -345,7 +433,7 @@
                         return spreadView.width + spreadIndex * spreadView.tileDistance;
                     }
 
-                    application: applicationManager.get(index)
+                    application: root.applicationManager.get(index)
                     closeable: !isDash
 
                     property real behavioredIndex: index
@@ -361,18 +449,16 @@
                         }
                     }
 
+                    property var xBehavior: xBehavior
                     Behavior on x {
+                        id: xBehavior
                         enabled: root.spreadEnabled &&
                                  !spreadView.active &&
                                  !snapAnimation.running &&
-                                 priv.animateX
+                                 priv.animateX &&
+                                 !root.beingResized
                         UbuntuNumberAnimation {
                             duration: UbuntuAnimation.BriskDuration
-                            onRunningChanged: {
-                                if (!running && root.inverseProgress == 0) {
-                                    spreadView.focusChanging = false;
-                                }
-                            }
                         }
                     }
 
@@ -412,22 +498,21 @@
                     }
 
                     // Hiding tiles when their progress is negative or reached the maximum
-                    visible: (progress >= 0 && progress < 1.7) ||
-                             (isDash && priv.focusedAppDelegate.x !== 0)
-
-                    Binding {
-                        target: appDelegate
-                        property: "orientation"
-                        when: appDelegate.interactive
-                        value: root.orientation
-                    }
+                    visible: (progress >= 0 && progress < 1.7)
+                            || (isDash && priv.focusedAppDelegateIsDislocated)
+
+
+                    shellOrientationAngle: root.shellOrientationAngle
+                    shellOrientation: root.shellOrientation
+                    shellPrimaryOrientation: root.shellPrimaryOrientation
+                    nativeOrientation: root.nativeOrientation
 
                     onClicked: {
                         if (root.altTabEnabled && spreadView.phase == 2) {
-                            if (applicationManager.focusedApplicationId == applicationManager.get(index).appId) {
+                            if (root.applicationManager.focusedApplicationId == root.applicationManager.get(index).appId) {
                                 spreadView.snapTo(index);
                             } else {
-                                applicationManager.requestFocusApplication(applicationManager.get(index).appId);
+                                root.applicationManager.requestFocusApplication(root.applicationManager.get(index).appId);
                             }
                         }
                     }
@@ -442,7 +527,20 @@
 
                     onClosed: {
                         spreadView.closingIndex = index;
-                        applicationManager.stopApplication(applicationManager.get(index).appId);
+                        root.applicationManager.stopApplication(root.applicationManager.get(index).appId);
+                    }
+
+                    Binding {
+                        target: root
+                        when: index == 0
+                        property: "mainAppWindowOrientationAngle"
+                        value: appWindowOrientationAngle
+                    }
+                    Binding {
+                        target: priv
+                        when: index == 0
+                        property: "focusedAppOrientationChangesEnabled"
+                        value: orientationChangesEnabled
                     }
                 }
             }

=== modified file 'qml/Stages/SessionContainer.qml'
--- qml/Stages/SessionContainer.qml	2015-01-28 12:59:21 +0000
+++ qml/Stages/SessionContainer.qml	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Canonical Ltd.
+ * Copyright 2014-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
@@ -24,14 +24,13 @@
     readonly property var childSessions: session ? session.childSessions : null
     readonly property alias surface: _surfaceContainer.surface
     property alias interactive: _surfaceContainer.interactive
-    property int orientation
+    property alias surfaceOrientationAngle: _surfaceContainer.surfaceOrientationAngle
 
     readonly property alias surfaceContainer: _surfaceContainer
     SurfaceContainer {
         id: _surfaceContainer
         anchors.fill: parent
         surface: session ? session.surface : null
-        orientation: root.orientation
     }
 
     Repeater {
@@ -72,11 +71,6 @@
                 target: item; when: item
                 property: "height"; value: root.height
             }
-
-            Binding {
-                target: item; when: item
-                property: "orientation"; value: root.orientation
-            }
         }
     }
 

=== modified file 'qml/Stages/SpreadDelegate.qml'
--- qml/Stages/SpreadDelegate.qml	2015-01-28 12:59:21 +0000
+++ qml/Stages/SpreadDelegate.qml	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Canonical Ltd.
+ * Copyright 2014-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
@@ -18,6 +18,7 @@
  */
 
 import QtQuick 2.0
+import QtQuick.Window 2.0
 import Ubuntu.Components 1.1
 import "../Components"
 
@@ -28,6 +29,9 @@
     readonly property bool dragged: dragArea.moving
     signal clicked()
     signal closed()
+    readonly property alias appWindowOrientationAngle: appWindowWithShadow.orientationAngle
+    readonly property alias appWindowRotation: appWindowWithShadow.rotation
+    readonly property alias orientationChangesEnabled: appWindow.orientationChangesEnabled
 
     // to be set from outside
     property bool interactive: true
@@ -36,10 +40,54 @@
     property alias swipeToCloseEnabled: dragArea.enabled
     property bool closeable
     property alias application: appWindow.application
-    property int orientation
+    property int shellOrientationAngle
+    property int shellOrientation
+    property int shellPrimaryOrientation
+    property int nativeOrientation
+
+    function matchShellOrientation() {
+        if (!root.application)
+            return;
+        appWindowWithShadow.orientationAngle = root.shellOrientationAngle;
+    }
+
+    function animateToShellOrientation() {
+        if (!root.application)
+            return;
+
+        if (root.application.rotatesWindowContents) {
+            appWindowWithShadow.orientationAngle = root.shellOrientationAngle;
+        } else {
+            orientationChangeAnimation.start();
+        }
+    }
+
+    OrientationChangeAnimation {
+        id: orientationChangeAnimation
+        objectName: "orientationChangeAnimation"
+        spreadDelegate: root
+        background: background
+        window: appWindowWithShadow
+        screenshot: appWindowScreenshotWithShadow
+    }
+
+    QtObject {
+        id: priv
+        property bool startingUp: true
+    }
+
+    Component.onCompleted: { finishStartUpTimer.start(); }
+    Timer { id: finishStartUpTimer; interval: 400; onTriggered: priv.startingUp = false }
+
+    Rectangle {
+        id: background
+        color: "black"
+        anchors.fill: parent
+        visible: false
+    }
 
     Item {
-        objectName: "appWindowWithShadow"
+        objectName: "displacedAppWindowWithShadow"
 
         readonly property real limit: root.height / 4
 
@@ -52,27 +100,220 @@
             return k * (1 - Math.pow((k - 1) / k, distance))
         }
 
-        BorderImage {
-            anchors {
-                fill: appWindow
-                margins: -units.gu(2)
-            }
-            source: "graphics/dropshadow2gu.sci"
-            opacity: root.dropShadow ? .3 : 0
-            Behavior on opacity { UbuntuNumberAnimation {} }
-        }
-
-        ApplicationWindow {
-            id: appWindow
-            objectName: application ? "appWindow_" + application.appId : "appWindow_null"
-            focus: true
-            anchors {
-                fill: parent
-                topMargin: appWindow.fullscreen ? 0 : maximizedAppTopMargin
-            }
-
-            interactive: root.interactive
-            orientation: root.orientation
+        Item {
+            id: appWindowWithShadow
+            objectName: "appWindowWithShadow"
+
+            property int orientationAngle
+
+            property real transformRotationAngle: 0
+            property real transformOriginX
+            property real transformOriginY
+
+            property var window: appWindow
+
+            transform: Rotation {
+                origin.x: appWindowWithShadow.transformOriginX
+                origin.y: appWindowWithShadow.transformOriginY
+                axis { x: 0; y: 0; z: 1 }
+                angle: appWindowWithShadow.transformRotationAngle
+            }
+
+            state: {
+                if (priv.startingUp) {
+                    return "startingUp";
+                } else if (root.application && root.application.rotatesWindowContents) {
+                    return "counterRotate";
+                } else if (orientationChangeAnimation.running) {
+                    return "animatingRotation";
+                } else  {
+                    return "keepSceneRotation";
+                }
+            }
+
+            // Ensures the given angle is in the form (0,90,180,270)
+            function normalizeAngle(angle) {
+                while (angle < 0) {
+                    angle += 360;
+                }
+                return angle % 360;
+            }
+
+            states: [
+                // Sets the initial orientationAngle of the window, when it first slides into view
+                // (with the splash screen likely being displayed). At that point we just try to
+                // match shell's current orientation. We need a bit of time in this state as the
+                // information we need to decide orientationAngle may take a few cycles to
+                // be set.
+                State {
+                    name: "startingUp"
+                    PropertyChanges {
+                        target: appWindowWithShadow
+                        restoreEntryValues: false
+                        orientationAngle: {
+                            if (!root.application || root.application.rotatesWindowContents) {
+                                return 0;
+                            }
+                            var supportedOrientations = root.application.supportedOrientations;
+
+                            if (supportedOrientations === Qt.PrimaryOrientation) {
+                                supportedOrientations = root.shellPrimaryOrientation;
+                            }
+
+                            // If it doesn't support shell's current orientation
+                            // then simply pick some arbitraty one that it does support
+                            var chosenOrientation = 0;
+                            if (supportedOrientations & root.shellOrientation) {
+                                chosenOrientation = root.shellOrientation;
+                            } else if (supportedOrientations & Qt.PortraitOrientation) {
+                                chosenOrientation = Qt.PortraitOrientation;
+                            } else if (supportedOrientations & Qt.LandscapeOrientation) {
+                                chosenOrientation = Qt.LandscapeOrientation;
+                            } else if (supportedOrientations & Qt.InvertedPortraitOrientation) {
+                                chosenOrientation = Qt.InvertedPortraitOrientation;
+                            } else if (supportedOrientations & Qt.InvertedLandscapeOrientation) {
+                                chosenOrientation = Qt.InvertedLandscapeOrientation;
+                            } else {
+                                chosenOrientation = root.shellPrimaryOrientation;
+                            }
+
+                            return Screen.angleBetween(root.nativeOrientation, chosenOrientation);
+                        }
+
+                        rotation: normalizeAngle(appWindowWithShadow.orientationAngle - root.shellOrientationAngle)
+                        width: {
+                            if (rotation == 0 || rotation == 180) {
+                                return root.width;
+                            } else {
+                                return root.height;
+                            }
+                        }
+                        height: {
+                            if (rotation == 0 || rotation == 180)
+                                return root.height;
+                            else
+                                return root.width;
+                        }
+                    }
+                },
+                // In this state we stick to our currently set orientationAngle, which may change only due
+                // to calls made to matchShellOrientation() or animateToShellOrientation()
+                State {
+                    id: keepSceneRotationState
+                    name: "keepSceneRotation"
+
+                    StateChangeScript { script: {
+                        // break binding
+                        appWindowWithShadow.orientationAngle = appWindowWithShadow.orientationAngle;
+                    } }
+                    PropertyChanges {
+                        target: appWindowWithShadow
+                        restoreEntryValues: false
+                        rotation: normalizeAngle(appWindowWithShadow.orientationAngle - root.shellOrientationAngle)
+                        width: {
+                            if (rotation == 0 || rotation == 180) {
+                                return root.width;
+                            } else {
+                                return root.height;
+                            }
+                        }
+                        height: {
+                            if (rotation == 0 || rotation == 180)
+                                return root.height;
+                            else
+                                return root.width;
+                        }
+                    }
+                },
+                // In this state we counteract any shell rotation so that the window, in scene coordinates,
+                // remains unrotated.
+                State {
+                    name: "counterRotate"
+                    StateChangeScript { script: {
+                        // break binding
+                        appWindowWithShadow.orientationAngle = appWindowWithShadow.orientationAngle;
+                    } }
+                    PropertyChanges {
+                        target: appWindowWithShadow
+                        width: root.shellOrientationAngle == 0 || root.shellOrientationAngle == 180 ? root.width : root.height
+                        height: root.shellOrientationAngle == 0 || root.shellOrientationAngle == 180 ? root.height : root.width
+                        rotation: normalizeAngle(-root.shellOrientationAngle)
+                    }
+                    PropertyChanges {
+                        target: appWindow
+                        surfaceOrientationAngle: orientationAngle
+                    }
+                },
+                State {
+                    name: "animatingRotation"
+                }
+            ]
+
+            x: (parent.width - width) / 2
+            y: (parent.height - height) / 2
+
+            BorderImage {
+                anchors {
+                    fill: appWindow
+                    margins: -units.gu(2)
+                }
+                source: "graphics/dropshadow2gu.sci"
+                opacity: root.dropShadow ? .3 : 0
+                Behavior on opacity { UbuntuNumberAnimation {} }
+            }
+
+            ApplicationWindow {
+                id: appWindow
+                objectName: application ? "appWindow_" + application.appId : "appWindow_null"
+                focus: true
+                anchors {
+                    fill: parent
+                    topMargin: appWindow.fullscreen || application.rotatesWindowContents
+                                   ? 0 : maximizedAppTopMargin
+                }
+
+                interactive: root.interactive
+            }
+        }
+    }
+
+    Item {
+        // mimics appWindowWithShadow. Do the positioning of screenshots of non-fullscreen
+        // app windows
+        id: appWindowScreenshotWithShadow
+        visible: false
+
+        property real transformRotationAngle: 0
+        property real transformOriginX
+        property real transformOriginY
+
+        transform: Rotation {
+            origin.x: appWindowScreenshotWithShadow.transformOriginX
+            origin.y: appWindowScreenshotWithShadow.transformOriginY
+            axis { x: 0; y: 0; z: 1 }
+            angle: appWindowScreenshotWithShadow.transformRotationAngle
+        }
+
+        property var window: appWindowScreenshot
+
+        function take() {
+            // Format: "image://application/$APP_ID/$CURRENT_TIME_MS"
+            // eg: "image://application/calculator-app/123456"
+            var timeMs = new Date().getTime();
+            appWindowScreenshot.source = "image://application/" + root.application.appId + "/" + timeMs;
+        }
+        function discard() {
+            appWindowScreenshot.source = "";
+        }
+
+        Image {
+            id: appWindowScreenshot
+            source: ""
+
+            anchors.fill: parent
+
+            sourceSize.width: width
+            sourceSize.height: height
         }
     }
 

=== modified file 'qml/Stages/SurfaceContainer.qml'
--- qml/Stages/SurfaceContainer.qml	2015-03-12 18:55:52 +0000
+++ qml/Stages/SurfaceContainer.qml	2015-05-18 22:06:13 +0000
@@ -24,8 +24,8 @@
     objectName: "surfaceContainer"
     property Item surface: null
     property bool hadSurface: false
-    property int orientation
     property bool interactive
+    property int surfaceOrientationAngle: 0
 
     onSurfaceChanged: {
         if (surface) {
@@ -39,10 +39,10 @@
         }
     }
     Binding { target: surface; property: "anchors.fill"; value: root }
-    Binding { target: surface; property: "orientation"; value: root.orientation }
     Binding { target: surface; property: "z"; value: 1 }
     Binding { target: surface; property: "enabled"; value: root.interactive; when: surface }
     Binding { target: surface; property: "antialiasing"; value: !root.interactive; when: surface }
+    Binding { target: surface; property: "orientationAngle"; value: root.surfaceOrientationAngle; when: surface }
 
     InputWatcher {
         target: root.surface

=== modified file 'qml/Stages/TabletStage.qml'
--- qml/Stages/TabletStage.qml	2015-04-10 21:16:37 +0000
+++ qml/Stages/TabletStage.qml	2015-05-18 22:06:13 +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 as published by
@@ -28,13 +28,79 @@
     color: "#111111"
 
     // Controls to be set from outside
-    property bool shown: false
-    property bool moving: false
     property int dragAreaWidth
     property real maximizedAppTopMargin
     property bool interactive
+    property alias beingResized: spreadView.beingResized
+
+    property bool spreadEnabled: true // If false, animations and right edge will be disabled
+
     property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
-    property int orientation: Qt.PortraitOrientation
+    property int shellOrientationAngle: 0
+    property int shellOrientation
+    property int shellPrimaryOrientation
+    property int nativeOrientation
+    property real nativeWidth
+    property real nativeHeight
+    function updateFocusedAppOrientation() {
+        var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);
+        if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {
+            spreadRepeater.itemAt(mainStageAppIndex).matchShellOrientation();
+        }
+
+        for (var i = 0; i < spreadRepeater.count; ++i) {
+
+            if (i === mainStageAppIndex) {
+                continue;
+            }
+
+            var spreadDelegate = spreadRepeater.itemAt(i);
+
+            var delta = spreadDelegate.appWindowOrientationAngle - root.shellOrientationAngle;
+            if (delta < 0) { delta += 360; }
+            delta = delta % 360;
+
+            var supportedOrientations = spreadDelegate.application.supportedOrientations;
+            if (supportedOrientations === Qt.PrimaryOrientation) {
+                supportedOrientations = spreadDelegate.shellPrimaryOrientation;
+            }
+
+            if (delta === 180 && (supportedOrientations & spreadDelegate.shellOrientation)) {
+                spreadDelegate.matchShellOrientation();
+            }
+        }
+    }
+    function updateFocusedAppOrientationAnimated() {
+        var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);
+        if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {
+            spreadRepeater.itemAt(mainStageAppIndex).animateToShellOrientation();
+        }
+
+        if (priv.sideStageAppId) {
+            var sideStageAppIndex = priv.indexOf(priv.sideStageAppId);
+            if (sideStageAppIndex >= 0 && sideStageAppIndex < spreadRepeater.count) {
+                spreadRepeater.itemAt(sideStageAppIndex).matchShellOrientation();
+            }
+        }
+    }
+
+    // To be read from outside
+    property var mainApp: null
+    property int mainAppWindowOrientationAngle: 0
+    readonly property bool orientationChangesEnabled: priv.mainAppOrientationChangesEnabled
+
+    onWidthChanged: {
+        spreadView.selectedIndex = -1;
+        spreadView.phase = 0;
+        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
@@ -54,6 +120,13 @@
 
         property string focusedAppId: ApplicationManager.focusedApplicationId
         property string oldFocusedAppId: ""
+        property bool mainAppOrientationChangesEnabled: false
+
+        property real landscapeHeight: root.nativeOrientation == Qt.LandscapeOrientation ?
+                root.nativeHeight : root.nativeWidth
+
+        property bool shellIsLandscape: root.shellOrientation === Qt.LandscapeOrientation
+                      || root.shellOrientation === Qt.InvertedLandscapeOrientation
 
         property string mainStageAppId
         property string sideStageAppId
@@ -71,6 +144,7 @@
                     priv.sideStageAppId = focusedAppId;
                 } else {
                     priv.mainStageAppId = focusedAppId;
+                    root.mainApp = focusedApp;
                 }
             }
 
@@ -169,6 +243,7 @@
 
     Flickable {
         id: spreadView
+        objectName: "spreadView"
         anchors.fill: parent
         interactive: (spreadDragArea.dragging || phase > 1) && draggedDelegateCount === 0
         contentWidth: spreadRow.width - shift
@@ -217,7 +292,25 @@
         property int draggedDelegateCount: 0
         property int closingIndex: -1
 
+        // FIXME: Workaround Flickable's not keepping its contentX still when resized
+        onContentXChanged: { forceItToRemainStillIfBeingResized(); }
+        onShiftChanged: { forceItToRemainStillIfBeingResized(); }
+        function forceItToRemainStillIfBeingResized() {
+            if (root.beingResized && contentX != -shift) {
+                contentX = -shift;
+            }
+        }
+
         property bool animateX: true
+        property bool beingResized: false
+        onBeingResizedChanged: {
+            if (beingResized) {
+                // Brace yourselves for impact!
+                selectedIndex = -1;
+                phase = 0;
+                contentX = -shift;
+            }
+        }
 
         property bool sideStageDragging: sideStageDragHandle.dragging
         property real sideStageDragProgress: sideStageDragHandle.progress
@@ -256,7 +349,6 @@
             case "overlay":
                 return 1;
             }
-            print("Unhandled nextInStack case! This shouldn't happen any more when the Dash is an app!");
             return -1;
         }
         property int nextZInStack: indexToZIndex(nextInStack)
@@ -292,6 +384,10 @@
         }
 
         onShiftedContentXChanged: {
+            if (root.beingResized) {
+                // 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) {
@@ -401,8 +497,8 @@
         MouseArea {
             id: spreadRow
             x: spreadView.contentX
+            width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)
             height: root.height
-            width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)
 
             onClicked: {
                 spreadView.snapTo(0);
@@ -411,8 +507,9 @@
             Rectangle {
                 id: sideStageBackground
                 color: "black"
-                anchors.fill: parent
-                anchors.leftMargin: spreadView.width - (1 - sideStageDragHandle.progress) * spreadView.sideStageWidth
+                width: spreadView.sideStageWidth * (1 - sideStageDragHandle.progress)
+                height: priv.landscapeHeight
+                x: spreadView.width - width
                 z: spreadView.indexToZIndex(priv.indexOf(priv.sideStageAppId))
                 opacity: spreadView.phase == 0 ? 1 : 0
                 Behavior on opacity { UbuntuNumberAnimation {} }
@@ -420,8 +517,10 @@
 
             Item {
                 id: sideStageDragHandle
-                anchors { top: parent.top; bottom: parent.bottom; left: parent.left; leftMargin: spreadView.width - spreadView.sideStageWidth - width }
+                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
@@ -440,7 +539,6 @@
 
                 Image {
                     anchors.centerIn: parent
-                    anchors.horizontalCenterOffset: parent.progress * spreadView.sideStageWidth - (width - parent.width) / 2
                     width: sideStageDragHandleMouseArea.pressed ? parent.width * 2 : parent.width
                     height: parent.height
                     source: "graphics/[e-mail]"
@@ -453,16 +551,19 @@
                     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, (-startX + mouseX) / spreadView.sideStageWidth);
+                            sideStageDragHandle.progress = Math.max(0, totalDiff / spreadView.sideStageWidth);
                         }
                         gesturePoints.push(mouseX);
                     }
@@ -491,12 +592,26 @@
 
             Repeater {
                 id: spreadRepeater
+                objectName: "spreadRepeater"
                 model: ApplicationManager
 
                 delegate: TransformedTabletSpreadDelegate {
                     id: spreadTile
-                    height: spreadView.height
-                    width: model.stage == ApplicationInfoInterface.MainStage ? spreadView.width : spreadView.sideStageWidth
+                    objectName: "spreadDelegate_" + model.appId
+                    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)
                     selected: spreadView.selectedIndex == index
@@ -509,6 +624,8 @@
                     application: ApplicationManager.get(index)
                     closeable: !isDash
 
+                    readonly property bool wantsMainStage: model.stage == ApplicationInfoInterface.MainStage
+
                     readonly property bool isDash: model.appId == "unity8-dash"
 
                     // FIXME: A regular binding doesn't update any more after closing an app.
@@ -560,12 +677,11 @@
                         return progress;
                     }
 
-                    Binding {
-                        target: spreadTile
-                        property: "orientation"
-                        when: spreadTile.interactive
-                        value: root.orientation
-                    }
+                    shellOrientationAngle: wantsMainStage ? root.shellOrientationAngle : 0
+                    shellOrientation: wantsMainStage ? root.shellOrientation : Qt.PortraitOrientation
+                    shellPrimaryOrientation: wantsMainStage ? root.shellPrimaryOrientation : Qt.PortraitOrientation
+                    nativeOrientation: wantsMainStage ? root.nativeOrientation : Qt.PortraitOrientation
+
 
                     onClicked: {
                         if (spreadView.phase == 2) {
@@ -586,6 +702,19 @@
                         ApplicationManager.stopApplication(ApplicationManager.get(index).appId);
                     }
 
+                    Binding {
+                        target: root
+                        when: model.appId == priv.mainStageAppId
+                        property: "mainAppWindowOrientationAngle"
+                        value: appWindowOrientationAngle
+                    }
+                    Binding {
+                        target: priv
+                        when: model.appId == priv.mainStageAppId
+                        property: "mainAppOrientationChangesEnabled"
+                        value: orientationChangesEnabled
+                    }
+
                     EasingCurve {
                         id: snappingCurve
                         type: EasingCurve.Linear
@@ -599,9 +728,11 @@
 
     DirectionalDragArea {
         id: spreadDragArea
+        objectName: "spreadDragArea"
         anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
         width: root.dragAreaWidth
         direction: Direction.Leftwards
+        enabled: (spreadView.phase != 2 && root.spreadEnabled) || dragging
 
         property var gesturePoints: new Array()
 

=== modified file 'qml/Stages/TransformedSpreadDelegate.qml'
--- qml/Stages/TransformedSpreadDelegate.qml	2015-01-06 14:46:52 +0000
+++ qml/Stages/TransformedSpreadDelegate.qml	2015-05-18 22:06:13 +0000
@@ -298,7 +298,6 @@
 
             return easingCurve.value;
         }
-
     }
 
     transform: [
@@ -307,16 +306,61 @@
             axis { x: 0; y: 1; z: 0 }
             angle: priv.angle
         },
+
+        // The next two transformations are to ensure that fullscreen and rotated
+        // windows all have the same size and position as an unrotated (0 degrees)
+        // non-fullscreen window when they're stacked on top of each other on the
+        // far left of the spread.
+        Translate {
+            y: !fullscreen && appWindowRotation === 180
+                   ? priv.topMarginProgress * maximizedAppTopMargin
+                   : 0
+        },
+        Scale {
+            origin {
+                x: appWindowRotation === 270 ? spreadView.width : 0
+                y: spreadView.height
+            }
+
+            xScale: {
+                switch (appWindowRotation) {
+                case 90:
+                case 270:
+                    if (fullscreen) {
+                        return 1;
+                    } else {
+                        return 1 + priv.topMarginProgress * maximizedAppTopMargin / spreadView.width;
+                    }
+                break;
+                default:
+                    return 1;
+                }
+            }
+
+            yScale: {
+                switch (appWindowRotation) {
+                case 0:
+                    if (fullscreen) {
+                        return 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height;
+                    } else {
+                        return 1;
+                    }
+                break;
+                case 90:
+                case 270:
+                    return 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height;
+                break;
+                default:
+                    return 1;
+                }
+            }
+        },
+
         Scale {
             origin { x: 0; y: spreadView.height / 2 }
             xScale: priv.scale
             yScale: xScale
         },
-        Scale {
-            origin { x: 0; y: (spreadView.height * priv.scale) + maximizedAppTopMargin * 3 }
-            xScale: 1
-            yScale: fullscreen ? 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height : 1
-        },
         Translate {
             x: priv.xTranslate
         }

=== modified file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
--- qml/Stages/TransformedTabletSpreadDelegate.qml	2015-02-02 16:23:34 +0000
+++ qml/Stages/TransformedTabletSpreadDelegate.qml	2015-05-18 22:06:13 +0000
@@ -50,7 +50,9 @@
     property int dragOffset: 0
 
     dropShadow: spreadView.active ||
-                (active && model.stage == ApplicationInfoInterface.MainStage && priv.xTranslate != 0)
+                (active
+                 && (model.stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)
+                 && priv.xTranslate != 0)
 
     onSelectedChanged: {
         if (selected) {
@@ -139,7 +141,8 @@
                      !snapAnimation.running &&
                      model.appId !== "unity8-dash" &&
                      !spreadView.sideStageDragging &&
-                     spreadView.animateX
+                     spreadView.animateX &&
+                     !spreadView.beingResized
             UbuntuNumberAnimation {
                 duration: UbuntuAnimation.FastDuration
             }

=== modified file 'run.sh'
--- run.sh	2015-03-11 08:07:31 +0000
+++ run.sh	2015-05-18 22:06:13 +0000
@@ -44,7 +44,7 @@
   export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/builddir/plugins/LightDM/liblightdm
 fi
 
-QML_PHONE_SHELL_ARGS=""
+QML_PHONE_SHELL_ARGS="-windowgeometry=40gux68gu -devicename=mako"
 if $MOUSE_TOUCH; then
   QML_PHONE_SHELL_ARGS="$QML_PHONE_SHELL_ARGS -mousetouch"
 fi

=== added file 'src/ApplicationArguments.cpp'
--- src/ApplicationArguments.cpp	1970-01-01 00:00:00 +0000
+++ src/ApplicationArguments.cpp	2015-05-18 22:06:13 +0000
@@ -0,0 +1,22 @@
+/*
+ * 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 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 "ApplicationArguments.h"
+
+ApplicationArguments::ApplicationArguments(QObject *parent)
+    : QObject(parent)
+{
+}

=== modified file 'src/ApplicationArguments.h'
--- src/ApplicationArguments.h	2015-04-15 15:20:24 +0000
+++ src/ApplicationArguments.h	2015-05-18 22:06:13 +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
@@ -13,7 +13,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/>.
  *
- * Authored by: Nick Dedekind <[e-mail]>
  */
 
 
@@ -22,23 +21,20 @@
 
 #include <QObject>
 #include <QSize>
-#include <QStringList>
+#include <QString>
 
 class ApplicationArguments : public QObject
 {
     Q_OBJECT
+    Q_PROPERTY(QString deviceName READ deviceName CONSTANT)
 public:
-    // Not exposed to the app as setSize isn't invokable
-    void setSize(const QSize &size) {
-        m_size = size;
-    }
+    ApplicationArguments(QObject *parent = nullptr);
 
-    Q_INVOKABLE bool hasGeometry() const { return m_size.isValid(); }
-    Q_INVOKABLE int width() const { return m_size.width(); }
-    Q_INVOKABLE int height() const { return m_size.height(); }
+    void setDeviceName(QString deviceName) { m_deviceName = deviceName; }
+    QString deviceName() const { return m_deviceName; }
 
 private:
-  QSize m_size;
+    QString m_deviceName;
 };
 
 #endif // APPLICATION_ARGUMENTS_H

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-04-14 14:11:43 +0000
+++ src/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -17,7 +17,7 @@
 )
 
 add_executable(${SHELL_APP}
-    ApplicationArguments.h
+    ApplicationArguments.cpp
     main.cpp
     MouseTouchAdaptor.cpp
     CachingNetworkManagerFactory.cpp
@@ -26,13 +26,12 @@
 )
 
 qt5_use_modules(${SHELL_APP} Gui Qml Quick Test)
-pkg_check_modules(XCB REQUIRED xcb)
-
-if (NOT "${XCB_INCLUDE_DIRS}" STREQUAL "")
-    set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${XCB_INCLUDE_DIRS})
-
-    target_link_libraries(${SHELL_APP} ${XCB_LDFLAGS})
+
+pkg_check_modules(NEEDED_LIBS REQUIRED xcb libandroid-properties)
+if (NOT "${NEEDED_LIBS_INCLUDE_DIRS}" STREQUAL "")
+    set_target_properties(${SHELL_APP} PROPERTIES INCLUDE_DIRECTORIES ${NEEDED_LIBS_INCLUDE_DIRS})
 endif()
+target_link_libraries(${SHELL_APP} ${NEEDED_LIBS_LDFLAGS})
 
 target_link_libraries(${SHELL_APP} UbuntuGestures connectivity-qt1)
 

=== modified file 'src/Dash/CMakeLists.txt'
--- src/Dash/CMakeLists.txt	2014-10-27 09:40:01 +0000
+++ src/Dash/CMakeLists.txt	2015-05-18 22:06:13 +0000
@@ -1,6 +1,6 @@
 set(DASH_SRCS
     main.cpp
-    ../ApplicationArguments.h
+    ../ApplicationArguments.cpp
     ../MouseTouchAdaptor.cpp
     ../CachingNetworkManagerFactory.cpp
 )
@@ -9,6 +9,12 @@
 
 qt5_use_modules(unity8-dash Gui Qml Quick Test)
 
+pkg_check_modules(NEEDED_LIBS REQUIRED xcb libandroid-properties)
+if (NOT "${NEEDED_LIBS_INCLUDE_DIRS}" STREQUAL "")
+    set_target_properties(unity8-dash PROPERTIES INCLUDE_DIRECTORIES ${NEEDED_LIBS_INCLUDE_DIRS})
+endif()
+target_link_libraries(unity8-dash ${NEEDED_LIBS_LDFLAGS})
+
 # For it to find libUbuntuGestures.so, needed by Ubuntu.Gestures QML module.
 set_target_properties(unity8-dash PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${SHELL_PRIVATE_LIBDIR}")
 

=== modified file 'src/Dash/main.cpp'
--- src/Dash/main.cpp	2015-04-15 15:20:24 +0000
+++ src/Dash/main.cpp	2015-05-18 22:06:13 +0000
@@ -61,12 +61,6 @@
     parser.process(*application);
 
     ApplicationArguments qmlArgs;
-    if (parser.isSet(windowGeometryOption) &&
-        parser.value(windowGeometryOption).split('x').size() == 2)
-    {
-        QStringList geom = parser.value(windowGeometryOption).split('x');
-        qmlArgs.setSize(QSize(geom.at(0).toInt(), geom.at(1).toInt()));
-    }
 
     if (getenv("QT_LOAD_TESTABILITY")) {
         QLibrary testLib(QLatin1String("qttestability"));
@@ -88,6 +82,18 @@
 
     QQuickView* view = new QQuickView();
     view->setResizeMode(QQuickView::SizeRootObjectToView);
+
+    if (parser.isSet(windowGeometryOption) &&
+        parser.value(windowGeometryOption).split('x').size() == 2)
+    {
+        QStringList geom = parser.value(windowGeometryOption).split('x');
+        QSize windowSize(geom.at(0).toInt(), geom.at(1).toInt());
+        if (windowSize.isValid()) {
+            view->setWidth(windowSize.width());
+            view->setHeight(windowSize.height());
+        }
+    }
+
     view->setTitle("Scopes");
     view->rootContext()->setContextProperty("applicationArguments", &qmlArgs);
 

=== modified file 'src/UnityCommandLineParser.cpp'
--- src/UnityCommandLineParser.cpp	2015-04-14 14:11:43 +0000
+++ src/UnityCommandLineParser.cpp	2015-05-18 22:06:13 +0000
@@ -49,6 +49,10 @@
         "DISCOURAGED: Please set QT_LOAD_TESTABILITY instead.\nLoad the testability driver");
     parser.addOption(testabilityOption);
 
+    QCommandLineOption devicenameOption(QStringList() << "devicename",
+            "Specify the device name instead of letting Unity 8 find it out", "devicename", "");
+    parser.addOption(devicenameOption);
+
     QCommandLineOption modeOption("mode",
         "Whether to run greeter and/or shell [full-greeter, full-shell, greeter, shell]",
         "mode", "full-greeter");
@@ -73,6 +77,7 @@
     m_hasFrameless = parser.isSet(framelessOption);
     m_hasMouseToTouch = parser.isSet(mousetouchOption);
     m_hasFullscreen = parser.isSet(fullscreenOption);
+    m_deviceName = parser.value(devicenameOption);
     resolveMode(parser, modeOption);
 }
 

=== modified file 'src/UnityCommandLineParser.h'
--- src/UnityCommandLineParser.h	2015-04-14 14:11:43 +0000
+++ src/UnityCommandLineParser.h	2015-05-18 22:06:13 +0000
@@ -30,6 +30,7 @@
     bool hasFrameless() const { return m_hasFrameless; }
     bool hasMouseToTouch() const { return m_hasMouseToTouch; }
     bool hasFullscreen() const { return m_hasFullscreen; }
+    QString deviceName() const { return m_deviceName; }
     QString mode() const { return m_mode; }
 private:
 
@@ -44,6 +45,7 @@
     bool m_hasFrameless;
     bool m_hasMouseToTouch;
     bool m_hasFullscreen;
+    QString m_deviceName;
     QString m_mode;
 };
 

=== modified file 'src/main.cpp'
--- src/main.cpp	2015-04-15 15:20:24 +0000
+++ src/main.cpp	2015-05-18 22:06:13 +0000
@@ -25,6 +25,9 @@
 #include <csignal>
 #include <libintl.h>
 
+// libandroid-properties
+#include <hybris/properties/properties.h>
+
 // local
 #include <paths.h>
 #include "MouseTouchAdaptor.h"
@@ -50,13 +53,15 @@
 
     UnityCommandLineParser parser(*application);
 
-    QString indicatorProfile = qgetenv("UNITY_INDICATOR_PROFILE");
-    if (indicatorProfile.isEmpty()) {
-        indicatorProfile = "phone";
-    }
-
     ApplicationArguments qmlArgs;
-    qmlArgs.setSize(parser.windowGeometry());
+
+    if (!parser.deviceName().isEmpty()) {
+        qmlArgs.setDeviceName(parser.deviceName());
+    } else {
+        char buffer[200];
+        property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);
+        qmlArgs.setDeviceName(QString(buffer));
+    }
 
     // The testability driver is only loaded by QApplication but not by QGuiApplication.
     // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.
@@ -82,9 +87,14 @@
     view->setResizeMode(QQuickView::SizeRootObjectToView);
     view->setColor("black");
     view->setTitle("Unity8 Shell");
+
+    if (parser.windowGeometry().isValid()) {
+        view->setWidth(parser.windowGeometry().width());
+        view->setHeight(parser.windowGeometry().height());
+    }
+
     view->engine()->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));
     view->rootContext()->setContextProperty("applicationArguments", &qmlArgs);
-    view->rootContext()->setContextProperty("indicatorProfile", indicatorProfile);
     view->rootContext()->setContextProperty("shellMode", parser.mode());
     if (parser.hasFrameless()) {
         view->setFlags(Qt::FramelessWindowHint);
@@ -99,7 +109,7 @@
         mouseTouchAdaptor = MouseTouchAdaptor::instance();
     }
 
-    QUrl source(::qmlDirectory()+"Shell.qml");
+    QUrl source(::qmlDirectory()+"OrientedShell.qml");
     prependImportPaths(view->engine(), ::overrideImportPaths());
     if (!isMirServer) {
         prependImportPaths(view->engine(), ::nonMirImportPaths());

=== modified file 'tests/mocks/Unity/Application/ApplicationInfo.cpp'
--- tests/mocks/Unity/Application/ApplicationInfo.cpp	2014-08-28 23:16:07 +0000
+++ tests/mocks/Unity/Application/ApplicationInfo.cpp	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 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
@@ -34,6 +34,11 @@
     , m_focused(false)
     , m_fullscreen(false)
     , m_session(0)
+    , m_supportedOrientations(Qt::PortraitOrientation |
+            Qt::LandscapeOrientation |
+            Qt::InvertedPortraitOrientation |
+            Qt::InvertedLandscapeOrientation)
+    , m_rotatesWindowContents(false)
     , m_manualSurfaceCreation(false)
 {
 }
@@ -45,6 +50,11 @@
     , m_focused(false)
     , m_fullscreen(false)
     , m_session(0)
+    , m_supportedOrientations(Qt::PortraitOrientation |
+            Qt::LandscapeOrientation |
+            Qt::InvertedPortraitOrientation |
+            Qt::InvertedLandscapeOrientation)
+    , m_rotatesWindowContents(false)
     , m_manualSurfaceCreation(false)
 {
 }
@@ -99,9 +109,17 @@
 
 void ApplicationInfo::setScreenshotId(const QString &screenshotId)
 {
-    QString screenshotFileName = QString("%1/Dash/graphics/phone/screenshots/[e-mail]")
-            .arg(qmlDirectory())
-            .arg(screenshotId);
+    QString screenshotFileName;
+
+    if (screenshotId.endsWith(".svg")) {
+        screenshotFileName = QString("%1/Dash/graphics/phone/screenshots/%2")
+            .arg(qmlDirectory())
+            .arg(screenshotId);
+    } else {
+        screenshotFileName = QString("%1/Dash/graphics/phone/screenshots/[e-mail]")
+            .arg(qmlDirectory())
+            .arg(screenshotId);
+    }
 
     if (screenshotFileName != m_screenshotFileName) {
         m_screenshotFileName = screenshotFileName;
@@ -145,6 +163,9 @@
 
         if (!m_manualSurfaceCreation && m_state == ApplicationInfo::Running) {
             QTimer::singleShot(500, this, SLOT(createSession()));
+        } else if (m_state == ApplicationInfo::Stopped) {
+            delete m_session;
+            m_session = nullptr;
         }
     }
 }
@@ -172,3 +193,23 @@
         Q_EMIT manualSurfaceCreationChanged(value);
     }
 }
+
+Qt::ScreenOrientations ApplicationInfo::supportedOrientations() const
+{
+    return m_supportedOrientations;
+}
+
+void ApplicationInfo::setSupportedOrientations(Qt::ScreenOrientations orientations)
+{
+    m_supportedOrientations = orientations;
+}
+
+bool ApplicationInfo::rotatesWindowContents() const
+{
+    return m_rotatesWindowContents;
+}
+
+void ApplicationInfo::setRotatesWindowContents(bool value)
+{
+    m_rotatesWindowContents = value;
+}

=== modified file 'tests/mocks/Unity/Application/ApplicationInfo.h'
--- tests/mocks/Unity/Application/ApplicationInfo.h	2014-09-15 19:05:32 +0000
+++ tests/mocks/Unity/Application/ApplicationInfo.h	2015-05-18 22:06:13 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 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
@@ -80,6 +80,12 @@
     void setFullscreen(bool value);
     bool fullscreen() const { return m_fullscreen; }
 
+    Qt::ScreenOrientations supportedOrientations() const override;
+    void setSupportedOrientations(Qt::ScreenOrientations orientations);
+
+    bool rotatesWindowContents() const override;
+    void setRotatesWindowContents(bool value);
+
     bool manualSurfaceCreation() const { return m_manualSurfaceCreation; }
     void setManualSurfaceCreation(bool value);
 
@@ -108,6 +114,8 @@