Merge lp:~ci-train-bot/unity8/unity8-ubuntu-xenial-landing-064 into lp:unity8

[Michał Sawicz]

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-02-12 00:12:30 +0000
+++ CMakeLists.txt	2016-03-11 11:34:41 +0000
@@ -131,7 +131,7 @@
     set(STDOUT_LOGGER "-o" "-,txt")
 endif()
 
-execute_process(COMMAND arch OUTPUT_VARIABLE ARCH)
+execute_process(COMMAND dpkg-architecture -qDEB_HOST_ARCH OUTPUT_VARIABLE ARCH)
 if (NOT ARCH MATCHES "arm*")
     set(ENABLE_TOUCH_EMULATION true)
     add_definitions(-DUNITY8_ENABLE_TOUCH_EMULATION)

=== modified file 'cmake/modules/QmlTest.cmake'
--- cmake/modules/QmlTest.cmake	2015-05-21 20:24:47 +0000
+++ cmake/modules/QmlTest.cmake	2016-03-11 11:34:41 +0000
@@ -183,7 +183,7 @@
     cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
     mangle_arguments()
 
-    bake_arguments("${QMLTEST_ARG_PREFIX}" args -qmljsdebugger=port:3768)
+    bake_arguments("${QMLTEST_ARG_PREFIX}" args -qmljsdebugger=port:3768,3800)
 
     set(qmltry_command
         $<TARGET_FILE:${TARGET}>

=== modified file 'data/com.canonical.Unity8.gschema.xml'
--- data/com.canonical.Unity8.gschema.xml	2015-11-24 17:44:18 +0000
+++ data/com.canonical.Unity8.gschema.xml	2016-03-11 11:34:41 +0000
@@ -27,6 +27,17 @@
       <summary>Maximum push needed to overcome edge barrier</summary>
       <description>How much you have to push (in grid units) the mouse against an edge barrier when sensibility is 1.</description>
     </key>
+    <key type="b" name="autohide-launcher">
+      <default>true</default>
+      <summary>Autohide the launcher</summary>
+      <description>This will only be applied in windowed mode. In staged mode, the launcher will always hide.</description>
+    </key>
+    <key type="u" name="launcher-width">
+      <default>8</default>
+      <range min="6" max="12"/>
+      <summary>Width of the launcher in grid units.</summary>
+      <description>Changes the width of the launcher in all usage modes.</description>
+    </key>
   </schema>
 
   <schema path="/com/canonical/unity8/greeter/" id="com.canonical.Unity8.Greeter" gettext-domain="unity8">

=== modified file 'data/unity8-dash.conf'
--- data/unity8-dash.conf	2015-04-21 15:41:09 +0000
+++ data/unity8-dash.conf	2016-03-11 11:34:41 +0000
@@ -14,6 +14,7 @@
 oom score 50
 
 respawn
+respawn limit unlimited
 
 env APP_ID=unity8-dash
 

=== modified file 'debian/changelog'
--- debian/changelog	2016-03-08 20:59:35 +0000
+++ debian/changelog	2016-03-11 11:34:41 +0000
@@ -1,3 +1,94 @@
+unity8 (8.11+16.04.20160310.4-0ubuntu1) xenial; urgency=medium
+
+  [ Albert Astals Cid ]
+  * Add context for Re-dock as asked by translators (LP: #1534608)
+  * Add emblem to the preview header widget (LP: #1424720)
+  * Add haptics to ScopesListCategoryItem buttons
+  * Audio Cards: Make some of the image loading async (LP: #1533432)
+  * Do not create fallback code for the card tool fake card (LP:
+    #1545865)
+  * Fix resizing the dash bringing temp scopes size out of sync (LP:
+    #1543130)
+  * Minor fixes for unity-scope-tool
+  * Resolve title alignment on card creator time instead of on runtime
+  * Use fixedHeaderHeight only in the non cardtool cards
+  * Use the new undeprecated connectivityqt::Connectivity
+  * asynchronous is only false on the fake card in cardtool
+  * clazy fixes
+
+  [ Albert Astals Cid, CI Train Bot ]
+  * click scope: Add the else branch so we reset the card size in all
+    situations
+
+  [ Andrea Cimitan ]
+  * PreviewSharing widget now accepts both string and array of
+    widgetData["share-data"]["uri"] (LP: #1549056)
+  * Update AP tests for new single preview
+  * Use Text.Wrap for body notification text (LP: #1544909)
+
+  [ Andrea Cimitan, Lukáš Tinkl, Michael Zanetti, Nick Dedekind ]
+  * some fixes for the new palette (LP: #1554616)
+
+  [ CI Train Bot ]
+  * Resync trunk.
+  * Update translation template
+
+  [ CI Train Bot, Daniel d'Andrada ]
+  * Ensure the QML engine doesn't delete our mock MirSurfaces on its
+    own.
+
+  [ Daniel d'Andrada ]
+  * tst_Shell: Remove unused qml items
+
+  [ Josh Arenson ]
+  * Allow the shell to blacklist input devices and force the OSK shown.
+    (LP: #1542224)
+
+  [ Lukáš Tinkl ]
+  * Disallow resizing windows up, past the Panel (LP: #1544766)
+  * Elide the window title not to let it overflow into the indicators
+    area (LP: #1535767)
+  * Enable the PIN lockscreen to be used with a HW keyboard (LP:
+    #1550359)
+  * Fix tiny windows when switching stages
+  * Provide a range of ports to QML JS Debugger
+  * Watch for launcher item icon changes (LP: #1543290)
+
+  [ Michael Terry ]
+  * Proxy more mouse and touchpad properties to USC (LP: #1540398) (LP:
+    #1543344, #1540398)
+  * Refactor the AccountsService plugin and make it slightly faster.
+  * To let the user log in if a mouse is connected, hide the greeter
+    cover page on a mouse click (but NOT a touch click). (LP: #1540497)
+  * Watch AccountsService for changes to the user's real name.  This was
+    preventing us from noticing when the user set their name in the
+    welcome wizard.
+
+  [ Michael Zanetti ]
+  * Allow alt+tabbing in staged mode too (LP: #1540502)
+  * Allow invoking the staged mode spreads by mouse right edge pushes
+    too (LP: #1540392)
+  * Allow loading the device configuration from an external file
+  * Implement Launcher's keyboard navigation and updated pip design
+  * Make launcher scalable, allow it locking (LP: #1511015)
+  * Properly parent launcher items in all cases (LP: #1495732)
+  * Read inputMethod surface from the new property int QtMir (LP:
+    #1545286)
+  * Some visual updates and rotation lock for the virtual touchpad (LP:
+    #1549087)
+  * Visual updates for the windowed spread (LP: #1488148)
+  * stabilize swipeAwayGreeter()
+
+  [ Michał Sawicz ]
+  * Add udev rules to make sure we have access to uinput
+  * Make dash respawn indefinitely (LP: #1550056)
+  * Use dpkg-architecture, not arch, to disable touch emulation
+
+  [ Vesa Rautiainen ]
+  * Fixing the vertical position of desktop spread item icon.
+
+ -- Michał Sawicz <[e-mail]>  Thu, 10 Mar 2016 22:44:16 +0000
+
 unity8 (8.11+16.04.20160308-0ubuntu1) xenial; urgency=medium
 
   [ Albert Astals Cid ]

=== modified file 'debian/control'
--- debian/control	2016-03-04 21:03:43 +0000
+++ debian/control	2016-03-11 11:34:41 +0000
@@ -13,7 +13,7 @@
                libandroid-properties-dev,
                graphviz,
                gsettings-ubuntu-schemas (>= 0.0.2+14.10.20140815),
-               libconnectivity-qt1-dev,
+               libconnectivity-qt1-dev (>= 0.7.1),
                libevdev-dev,
                libgl1-mesa-dev[!armhf] | libgl-dev[!armhf],
                libgl1-mesa-dri,
@@ -55,7 +55,7 @@
                qtdeclarative5-qtmultimedia-plugin (>= 5.4.1-1ubuntu19~overlay2),
                qtdeclarative5-ubuntu-content1,
                qtdeclarative5-ubuntu-settings-components (>= 0.7),
-               qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1796) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1796),
+               qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1845) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1845),
                qtdeclarative5-ubuntu-web-plugin,
                ttf-ubuntu-font-family,
 Standards-Version: 3.9.4
@@ -70,7 +70,7 @@
 Package: indicators-client
 Architecture: amd64 armhf i386
 Depends: qmenumodel-qml (>= 0.2.9),
-         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1796) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1796),
+         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1845) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1845),
          unity8 (= ${binary:Version}),
          ${misc:Depends},
          ${shlibs:Depends},
@@ -101,7 +101,6 @@
          qml-module-qt-labs-folderlistmodel,
          qml-module-qtquick-xmllistmodel,
          qml-module-qtsysteminfo,
-         qtdeclarative5-gsettings1.0,
          qtdeclarative5-qtmir-plugin (>= 0.4.5),
          qtdeclarative5-ubuntu-telephony0.1,
          qtdeclarative5-ubuntu-web-plugin,
@@ -128,7 +127,7 @@
 Depends: qml-module-qtquick-layouts,
          qtdeclarative5-ubuntu-settings-components (>= 0.7),
          qtdeclarative5-ubuntu-thumbnailer0.1 | ubuntu-thumbnailer-impl,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1796) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1796),
+         qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1845) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1845),
          qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
          ubuntu-thumbnailer-impl-0,
          unity-application-impl-13,
@@ -158,7 +157,7 @@
          python3-fixtures,
          python3-gi,
          qttestability-autopilot (>= 1.4),
-         ubuntu-ui-toolkit-autopilot (>= 1.3.1796),
+         ubuntu-ui-toolkit-autopilot (>= 1.3.1845),
          unity-scope-click,
          unity8 (= ${source:Version}),
          unity8-fake-env (= ${source:Version}),
@@ -192,6 +191,8 @@
          libhardware2,
          pay-service,
          unity-schemas (>= 7.3.1+14.10.20140915),
+         qtdeclarative5-gsettings1.0,
+         qml-module-qtmultimedia,
          ${misc:Depends},
          ${shlibs:Depends},
 Provides: unity-launcher-impl,

=== added file 'debian/unity8-common.udev'
--- debian/unity8-common.udev	1970-01-01 00:00:00 +0000
+++ debian/unity8-common.udev	2016-03-11 11:34:41 +0000
@@ -0,0 +1,2 @@
+# Make local foreground session able to inject input
+KERNEL=="uinput", SUBSYSTEM=="misc", TAG+="uaccess"

=== modified file 'debian/unity8-doc.install'
--- debian/unity8-doc.install	2014-01-30 22:32:37 +0000
+++ debian/unity8-doc.install	2016-03-11 11:34:41 +0000
@@ -1,1 +1,2 @@
+doc/devices.conf usr/share/doc/unity8/
 usr/share/doc/unity8/*

=== added file 'doc/devices.conf'
--- doc/devices.conf	1970-01-01 00:00:00 +0000
+++ doc/devices.conf	2016-03-11 11:34:41 +0000
@@ -0,0 +1,30 @@
+# This file can hold multiple device configs. Devices are separated by sections.
+#
+# SupportedOrientations holds a list of all enabled orientations. A standard
+# phone will usually have Portrait,Landcape,InvertedLandscape in order to
+# disable upside down usage.
+#
+# PrimaryOrientation gives the orientation the device will start up with
+# when there is no orientations sensor input available (yet) or lock to
+# when an application specifies to be locked to PrimaryOrientation.
+#
+# The other Orientation settings can be used to re-map the orientations.
+# A device might be used with different orientations than how the screen
+# is physically mounted on the hardware.
+#
+# Category can be phone, tablet, or desktop. This option determines
+# whether the side stage is shown (tablet) or not (phone). Using
+# desktop will load the shell in windowed mode. Note that the user
+# can override/change this by connecting input hardware or change
+# user settings.
+#
+# Any options not listed will default to the values of the example below.
+
+[devicename]
+SupportedOrientations=Portrait,InvertedPortrait,Landscape,InvertedLandscape
+PrimaryOrientation=PrimaryOrienation
+PortraitOrientation=Portrait
+InvertedPortraitOrientation=InvertedPortrait
+LandscapeOrientation=Landscape
+InvertedLandscapeOrientation=InvertedLandscape
+Category=phone

=== modified file 'plugins/AccountsService/AccountsService.cpp'
--- plugins/AccountsService/AccountsService.cpp	2016-01-21 21:04:00 +0000
+++ plugins/AccountsService/AccountsService.cpp	2016-03-11 11:34:41 +0000
@@ -24,17 +24,52 @@
 #include <QStringList>
 #include <QDebug>
 
+#define IFACE_ACCOUNTS_USER          QStringLiteral("org.freedesktop.Accounts.User")
+#define IFACE_LOCATION_HERE          QStringLiteral("com.ubuntu.location.providers.here.AccountsService")
+#define IFACE_UBUNTU_INPUT           QStringLiteral("com.ubuntu.AccountsService.Input")
+#define IFACE_UBUNTU_SECURITY        QStringLiteral("com.ubuntu.AccountsService.SecurityPrivacy")
+#define IFACE_UBUNTU_SECURITY_OLD    QStringLiteral("com.ubuntu.touch.AccountsService.SecurityPrivacy")
+#define IFACE_UNITY                  QStringLiteral("com.canonical.unity.AccountsService")
+#define IFACE_UNITY_PRIVATE          QStringLiteral("com.canonical.unity.AccountsService.Private")
+
+#define PROP_BACKGROUND_FILE                   QStringLiteral("BackgroundFile")
+#define PROP_DEMO_EDGES                        QStringLiteral("demo-edges")
+#define PROP_ENABLE_INDICATORS_WHILE_LOCKED    QStringLiteral("EnableIndicatorsWhileLocked")
+#define PROP_ENABLE_LAUNCHER_WHILE_LOCKED      QStringLiteral("EnableLauncherWhileLocked")
+#define PROP_FAILED_LOGINS                     QStringLiteral("FailedLogins")
+#define PROP_LICENSE_ACCEPTED                  QStringLiteral("LicenseAccepted")
+#define PROP_LICENSE_BASE_PATH                 QStringLiteral("LicenseBasePath")
+#define PROP_MOUSE_CURSOR_SPEED                QStringLiteral("MouseCursorSpeed")
+#define PROP_MOUSE_DOUBLE_CLICK_SPEED          QStringLiteral("MouseDoubleClickSpeed")
+#define PROP_MOUSE_PRIMARY_BUTTON              QStringLiteral("MousePrimaryButton")
+#define PROP_MOUSE_SCROLL_SPEED                QStringLiteral("MouseScrollSpeed")
+#define PROP_PASSWORD_DISPLAY_HINT             QStringLiteral("PasswordDisplayHint")
+#define PROP_STATS_WELCOME_SCREEN              QStringLiteral("StatsWelcomeScreen")
+#define PROP_TOUCHPAD_CURSOR_SPEED             QStringLiteral("TouchpadCursorSpeed")
+#define PROP_TOUCHPAD_DISABLE_WHILE_TYPING     QStringLiteral("TouchpadDisableWhileTyping")
+#define PROP_TOUCHPAD_DISABLE_WITH_MOUSE       QStringLiteral("TouchpadDisableWithMouse")
+#define PROP_TOUCHPAD_DOUBLE_CLICK_SPEED       QStringLiteral("TouchpadDoubleClickSpeed")
+#define PROP_TOUCHPAD_PRIMARY_BUTTON           QStringLiteral("TouchpadPrimaryButton")
+#define PROP_TOUCHPAD_SCROLL_SPEED             QStringLiteral("TouchpadScrollSpeed")
+#define PROP_TOUCHPAD_TAP_TO_CLICK             QStringLiteral("TouchpadTapToClick")
+#define PROP_TOUCHPAD_TWO_FINGER_SCROLL        QStringLiteral("TouchpadTwoFingerScroll")
+
+
+QVariant primaryButtonConverter(const QVariant &value)
+{
+    QString stringValue = value.toString();
+    if (stringValue == "left") {
+        return QVariant::fromValue(0);
+    } else if (stringValue == "right") {
+        return QVariant::fromValue(1); // Mir is less clear on this -- any non-zero value is the same
+    } else {
+        return QVariant::fromValue(0); // default to left
+    }
+}
+
 AccountsService::AccountsService(QObject* parent, const QString &user)
-    : QObject(parent),
-    m_service(new AccountsServiceDBusAdaptor(this)),
-    m_demoEdges(false),
-    m_enableLauncherWhileLocked(false),
-    m_enableIndicatorsWhileLocked(false),
-    m_statsWelcomeScreen(false),
-    m_passwordDisplayHint(Keyboard),
-    m_failedLogins(0),
-    m_hereEnabled(false),
-    m_hereLicensePath() // null means not set yet
+    : QObject(parent)
+    , m_service(new AccountsServiceDBusAdaptor(this))
 {
     m_unityInput = new QDBusInterface(QStringLiteral("com.canonical.Unity.Input"),
                                       QStringLiteral("/com/canonical/Unity/Input"),
@@ -44,6 +79,43 @@
     connect(m_service, &AccountsServiceDBusAdaptor::propertiesChanged, this, &AccountsService::onPropertiesChanged);
     connect(m_service, &AccountsServiceDBusAdaptor::maybeChanged, this, &AccountsService::onMaybeChanged);
 
+    registerProperty(IFACE_ACCOUNTS_USER, PROP_BACKGROUND_FILE, QStringLiteral("backgroundFileChanged"));
+    registerProperty(IFACE_LOCATION_HERE, PROP_LICENSE_ACCEPTED, QStringLiteral("hereEnabledChanged"));
+    registerProperty(IFACE_LOCATION_HERE, PROP_LICENSE_BASE_PATH, QStringLiteral("hereLicensePathChanged"));
+    registerProperty(IFACE_UBUNTU_SECURITY, PROP_ENABLE_LAUNCHER_WHILE_LOCKED, QStringLiteral("enableLauncherWhileLockedChanged"));
+    registerProperty(IFACE_UBUNTU_SECURITY, PROP_ENABLE_INDICATORS_WHILE_LOCKED, QStringLiteral("enableIndicatorsWhileLockedChanged"));
+    registerProperty(IFACE_UBUNTU_SECURITY, PROP_PASSWORD_DISPLAY_HINT, QStringLiteral("passwordDisplayHintChanged"));
+    registerProperty(IFACE_UBUNTU_SECURITY_OLD, PROP_STATS_WELCOME_SCREEN, QStringLiteral("statsWelcomeScreenChanged"));
+    registerProperty(IFACE_UNITY, PROP_DEMO_EDGES, QStringLiteral("demoEdgesChanged"));
+    registerProperty(IFACE_UNITY_PRIVATE, PROP_FAILED_LOGINS, QStringLiteral("failedLoginsChanged"));
+
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_MOUSE_CURSOR_SPEED,
+                  m_unityInput, QStringLiteral("setMouseCursorSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_MOUSE_DOUBLE_CLICK_SPEED,
+                  m_unityInput, QStringLiteral("setMouseDoubleClickSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_MOUSE_PRIMARY_BUTTON,
+                  m_unityInput, QStringLiteral("setMousePrimaryButton"),
+                  primaryButtonConverter);
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_MOUSE_SCROLL_SPEED,
+                  m_unityInput, QStringLiteral("setMouseScrollSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_CURSOR_SPEED,
+                  m_unityInput, QStringLiteral("setTouchpadCursorSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_SCROLL_SPEED,
+                  m_unityInput, QStringLiteral("setTouchpadScrollSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_DISABLE_WHILE_TYPING,
+                  m_unityInput, QStringLiteral("setTouchpadDisableWhileTyping"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_DISABLE_WITH_MOUSE,
+                  m_unityInput, QStringLiteral("setTouchpadDisableWithMouse"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_DOUBLE_CLICK_SPEED,
+                  m_unityInput, QStringLiteral("setTouchpadDoubleClickSpeed"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_PRIMARY_BUTTON,
+                  m_unityInput, QStringLiteral("setTouchpadPrimaryButton"),
+                  primaryButtonConverter);
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_TAP_TO_CLICK,
+                  m_unityInput, QStringLiteral("setTouchpadTapToClick"));
+    registerProxy(IFACE_UBUNTU_INPUT, PROP_TOUCHPAD_TWO_FINGER_SCROLL,
+                  m_unityInput, QStringLiteral("setTouchpadTwoFingerScroll"));
+
     setUser(!user.isEmpty() ? user : QString::fromUtf8(qgetenv("USER")));
 }
 
@@ -57,410 +129,200 @@
     if (user.isEmpty() || m_user == user)
         return;
 
+    bool wasEmpty = m_user.isEmpty();
+
     m_user = user;
     Q_EMIT userChanged();
 
-    updateDemoEdges(false);
-    updateEnableLauncherWhileLocked(false);
-    updateEnableIndicatorsWhileLocked(false);
-    updateBackgroundFile(false);
-    updateMouseCursorSpeed();
-    updateTouchpadCursorSpeed();
-    updateStatsWelcomeScreen(false);
-    updatePasswordDisplayHint(false);
-    updateFailedLogins(false);
-    updateHereEnabled(false);
-    updateHereLicensePath(false);
+    // Do the first update synchronously, as a cheap way to block rendering
+    // until we have the right values on bootup.
+    refresh(!wasEmpty);
 }
 
 bool AccountsService::demoEdges() const
 {
-    return m_demoEdges;
+    auto value = getProperty(IFACE_UNITY, PROP_DEMO_EDGES);
+    return value.toBool();
 }
 
 void AccountsService::setDemoEdges(bool demoEdges)
 {
-    if (m_demoEdges != demoEdges) {
-        m_demoEdges = demoEdges;
-        m_service->setUserPropertyAsync(m_user, QStringLiteral("com.canonical.unity.AccountsService"), QStringLiteral("demo-edges"), demoEdges);
-
-        Q_EMIT demoEdgesChanged();
-    }
+    setProperty(IFACE_UNITY, PROP_DEMO_EDGES, demoEdges);
 }
 
 bool AccountsService::enableLauncherWhileLocked() const
 {
-    return m_enableLauncherWhileLocked;
+    auto value = getProperty(IFACE_UBUNTU_SECURITY, PROP_ENABLE_LAUNCHER_WHILE_LOCKED);
+    return value.toBool();
 }
 
 bool AccountsService::enableIndicatorsWhileLocked() const
 {
-    return m_enableIndicatorsWhileLocked;
+    auto value = getProperty(IFACE_UBUNTU_SECURITY, PROP_ENABLE_INDICATORS_WHILE_LOCKED);
+    return value.toBool();
 }
 
 QString AccountsService::backgroundFile() const
 {
-    return m_backgroundFile;
+    auto value = getProperty(IFACE_ACCOUNTS_USER, PROP_BACKGROUND_FILE);
+    return value.toString();
 }
 
 bool AccountsService::statsWelcomeScreen() const
 {
-    return m_statsWelcomeScreen;
+    auto value = getProperty(IFACE_UBUNTU_SECURITY_OLD, PROP_STATS_WELCOME_SCREEN);
+    return value.toBool();
 }
 
 AccountsService::PasswordDisplayHint AccountsService::passwordDisplayHint() const
 {
-    return m_passwordDisplayHint;
+    auto value = getProperty(IFACE_UBUNTU_SECURITY, PROP_PASSWORD_DISPLAY_HINT);
+    return (PasswordDisplayHint)value.toInt();
 }
 
 bool AccountsService::hereEnabled() const
 {
-    return m_hereEnabled;
+    auto value = getProperty(IFACE_LOCATION_HERE, PROP_LICENSE_ACCEPTED);
+    return value.toBool();
 }
 
 void AccountsService::setHereEnabled(bool enabled)
 {
-    if (m_hereEnabled != enabled) {
-        m_hereEnabled = enabled;
-        m_service->setUserPropertyAsync(m_user, QStringLiteral("com.ubuntu.location.providers.here.AccountsService"), QStringLiteral("LicenseAccepted"), enabled);
-
-        Q_EMIT hereEnabledChanged();
-    }
+    setProperty(IFACE_LOCATION_HERE, PROP_LICENSE_ACCEPTED, enabled);
 }
 
 QString AccountsService::hereLicensePath() const
 {
-    return m_hereLicensePath;
+    auto value = getProperty(IFACE_LOCATION_HERE, PROP_LICENSE_BASE_PATH);
+    QString hereLicensePath = value.toString();
+    if (hereLicensePath.isEmpty() || !QFile::exists(hereLicensePath))
+        hereLicensePath = QStringLiteral("");
+    return hereLicensePath;
 }
 
 bool AccountsService::hereLicensePathValid() const
 {
-    return !m_hereLicensePath.isNull();
-}
-
-void AccountsService::updateDemoEdges(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.canonical.unity.AccountsService"),
-                                                                    QStringLiteral("demo-edges"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QDBusVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'demo-edges' property - " << reply.error().message();
-            return;
-        }
-
-        auto demoEdges = reply.value().variant().toBool();
-        if (m_demoEdges != demoEdges) {
-            m_demoEdges = demoEdges;
-            Q_EMIT demoEdgesChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateEnableLauncherWhileLocked(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.AccountsService.SecurityPrivacy"),
-                                                                    QStringLiteral("EnableLauncherWhileLocked"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'EnableLauncherWhileLocked' property - " << reply.error().message();
-            return;
-        }
-
-        const bool enableLauncherWhileLocked = reply.value().toBool();
-        if (m_enableLauncherWhileLocked != enableLauncherWhileLocked) {
-            m_enableLauncherWhileLocked = enableLauncherWhileLocked;
-            Q_EMIT enableLauncherWhileLockedChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateEnableIndicatorsWhileLocked(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.AccountsService.SecurityPrivacy"),
-                                                                    QStringLiteral("EnableIndicatorsWhileLocked"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'EnableIndicatorsWhileLocked' property - " << reply.error().message();
-            return;
-        }
-
-        const bool enableIndicatorsWhileLocked = reply.value().toBool();
-        if (m_enableIndicatorsWhileLocked != enableIndicatorsWhileLocked) {
-            m_enableIndicatorsWhileLocked = enableIndicatorsWhileLocked;
-            Q_EMIT enableIndicatorsWhileLockedChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateBackgroundFile(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("org.freedesktop.Accounts.User"),
-                                                                    QStringLiteral("BackgroundFile"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'BackgroundFile' property - " << reply.error().message();
-            return;
-        }
-
-        const QString backgroundFile = reply.value().toString();
-        if (m_backgroundFile != backgroundFile) {
-            m_backgroundFile = backgroundFile;
-            Q_EMIT backgroundFileChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateMouseCursorSpeed()
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.AccountsService.Input"),
-                                                                    QStringLiteral("MouseCursorSpeed"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'MouseCursorSpeed' property - " << reply.error().message();
-            return;
-        }
-
-        // Merely proxy this along to USC.  We don't care about keeping a copy
-        // or exporting it internally.
-        m_unityInput->asyncCall(QStringLiteral("setMouseCursorSpeed"), reply.value());
-    });
-}
-
-void AccountsService::updateTouchpadCursorSpeed()
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.AccountsService.Input"),
-                                                                    QStringLiteral("TouchpadCursorSpeed"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'TouchpadCursorSpeed' property - " << reply.error().message();
-            return;
-        }
-
-        // Merely proxy this along to USC.  We don't care about keeping a copy
-        // or exporting it internally.
-        m_unityInput->asyncCall(QStringLiteral("setTouchpadCursorSpeed"), reply.value());
-    });
-}
-
-void AccountsService::updateStatsWelcomeScreen(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.touch.AccountsService.SecurityPrivacy"),
-                                                                    QStringLiteral("StatsWelcomeScreen"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'StatsWelcomeScreen' property - " << reply.error().message();
-            return;
-        }
-
-        const bool statsWelcomeScreen = reply.value().toBool();
-        if (m_statsWelcomeScreen != statsWelcomeScreen) {
-            m_statsWelcomeScreen = statsWelcomeScreen;
-            Q_EMIT statsWelcomeScreenChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updatePasswordDisplayHint(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.AccountsService.SecurityPrivacy"),
-                                                                    QStringLiteral("PasswordDisplayHint"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'PasswordDisplayHint' property - " << reply.error().message();
-            return;
-        }
-
-        const PasswordDisplayHint passwordDisplayHint = (PasswordDisplayHint)reply.value().toInt();
-        if (m_passwordDisplayHint != passwordDisplayHint) {
-            m_passwordDisplayHint = passwordDisplayHint;
-            Q_EMIT passwordDisplayHintChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateFailedLogins(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.canonical.unity.AccountsService.Private"),
-                                                                    QStringLiteral("FailedLogins"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'FailedLogins' property - " << reply.error().message();
-            return;
-        }
-
-        const uint failedLogins = reply.value().toUInt();
-        if (m_failedLogins != failedLogins) {
-            m_failedLogins = failedLogins;
-            Q_EMIT failedLoginsChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateHereEnabled(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.location.providers.here.AccountsService"),
-                                                                    QStringLiteral("LicenseAccepted"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'LicenseAccepted' property - " << reply.error().message();
-            return;
-        }
-
-        const bool hereEnabled = reply.value().toBool();
-        if (m_hereEnabled != hereEnabled) {
-            m_hereEnabled = hereEnabled;
-            Q_EMIT hereEnabledChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
-}
-
-void AccountsService::updateHereLicensePath(bool async)
-{
-    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
-                                                                    QStringLiteral("com.ubuntu.location.providers.here.AccountsService"),
-                                                                    QStringLiteral("LicenseBasePath"));
-    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
-
-    connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this](QDBusPendingCallWatcher* watcher) {
-
-        QDBusPendingReply<QVariant> reply = *watcher;
-        watcher->deleteLater();
-        if (reply.isError()) {
-            qWarning() << "Failed to get 'LicenseBasePath' property - " << reply.error().message();
-            return;
-        }
-
-        QString hereLicensePath = reply.value().toString();
-        if (hereLicensePath.isEmpty() || !QFile::exists(hereLicensePath))
-            hereLicensePath = QLatin1String("");
-
-        if (m_hereLicensePath.isNull() || m_hereLicensePath != hereLicensePath) {
-            m_hereLicensePath = hereLicensePath;
-            Q_EMIT hereLicensePathChanged();
-        }
-    });
-    if (!async) {
-        watcher->waitForFinished();
-        delete watcher;
-    }
+    auto value = getProperty(IFACE_LOCATION_HERE, PROP_LICENSE_BASE_PATH);
+    return !value.toString().isNull();
 }
 
 uint AccountsService::failedLogins() const
 {
-    return m_failedLogins;
+    return getProperty(IFACE_UNITY_PRIVATE, PROP_FAILED_LOGINS).toUInt();
 }
 
 void AccountsService::setFailedLogins(uint failedLogins)
 {
-    if (m_failedLogins != failedLogins) {
-        m_failedLogins = failedLogins;
-        m_service->setUserPropertyAsync(m_user, QStringLiteral("com.canonical.unity.AccountsService.Private"), QStringLiteral("FailedLogins"), failedLogins);
-
-        Q_EMIT failedLoginsChanged();
-    }
+    setProperty(IFACE_UNITY_PRIVATE, PROP_FAILED_LOGINS, failedLogins);
+}
+
+// ====================================================
+// Everything below this line is generic helper methods
+// ====================================================
+
+void AccountsService::emitChangedForProperty(const QString &interface, const QString &property)
+{
+    QString signalName = m_properties[interface][property].signal;
+    QMetaObject::invokeMethod(this, signalName.toUtf8().data());
+}
+
+QVariant AccountsService::getProperty(const QString &interface, const QString &property) const
+{
+    return m_properties[interface][property].value;
+}
+
+void AccountsService::setProperty(const QString &interface, const QString &property, const QVariant &value)
+{
+    if (m_properties[interface][property].value != value) {
+        m_properties[interface][property].value = value;
+        m_service->setUserPropertyAsync(m_user, interface, property, value);
+        emitChangedForProperty(interface, property);
+    }
+}
+
+void AccountsService::updateCache(const QString &interface, const QString &property, const QVariant &value)
+{
+    PropertyInfo &info = m_properties[interface][property];
+
+    if (info.proxyInterface) {
+        QVariant finalValue;
+        if (info.proxyConverter) {
+            finalValue = info.proxyConverter(value);
+        } else {
+            finalValue = value;
+        }
+        info.proxyInterface->asyncCall(info.proxyMethod, finalValue);
+        return; // don't bother saving a copy
+    }
+
+    if (info.value != value) {
+        info.value = value;
+        emitChangedForProperty(interface, property);
+    }
+}
+
+void AccountsService::updateProperty(const QString &interface, const QString &property)
+{
+    QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
+                                                                    interface,
+                                                                    property);
+    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
+
+    connect(watcher, &QDBusPendingCallWatcher::finished,
+            this, [this, interface, property](QDBusPendingCallWatcher* watcher) {
+
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
+        if (reply.isError()) {
+            qWarning() << "Failed to get '" << property << "' property:" << reply.error().message();
+            return;
+        }
+
+        updateCache(interface, property, reply.value());
+    });
+}
+
+void AccountsService::updateAllProperties(const QString &interface, bool async)
+{
+    QDBusPendingCall pendingReply = m_service->getAllPropertiesAsync(m_user,
+                                                                     interface);
+    QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
+
+    connect(watcher, &QDBusPendingCallWatcher::finished,
+            this, [this, interface](QDBusPendingCallWatcher* watcher) {
+
+        QDBusPendingReply< QHash<QString, QVariant> > reply = *watcher;
+        watcher->deleteLater();
+        if (reply.isError()) {
+            qWarning() << "Failed to get all properties for" << interface << ":" << reply.error().message();
+            return;
+        }
+
+        auto valueHash = reply.value();
+        auto i = valueHash.constBegin();
+        while (i != valueHash.constEnd()) {
+            updateCache(interface, i.key(), i.value());
+            ++i;
+        }
+    });
+    if (!async) {
+        watcher->waitForFinished();
+    }
+}
+
+void AccountsService::registerProxy(const QString &interface, const QString &property, QDBusInterface *iface, const QString &method, ProxyConverter converter)
+{
+    registerProperty(interface, property, nullptr);
+
+    m_properties[interface][property].proxyInterface = iface;
+    m_properties[interface][property].proxyMethod = method;
+    m_properties[interface][property].proxyConverter = converter;
+}
+
+void AccountsService::registerProperty(const QString &interface, const QString &property, const QString &signal)
+{
+    m_properties[interface][property] = PropertyInfo();
+    m_properties[interface][property].signal = signal;
 }
 
 void AccountsService::onPropertiesChanged(const QString &user, const QString &interface, const QStringList &changed)
@@ -469,42 +331,13 @@
         return;
     }
 
-    if (interface == QLatin1String("com.canonical.unity.AccountsService")) {
-        if (changed.contains(QStringLiteral("demo-edges"))) {
-            updateDemoEdges();
-        }
-    } else if (interface == QLatin1String("com.canonical.unity.AccountsService.Private")) {
-        if (changed.contains(QStringLiteral("FailedLogins"))) {
-            updateFailedLogins();
-        }
-    } else if (interface == QLatin1String("com.ubuntu.AccountsService.Input")) {
-        if (changed.contains(QStringLiteral("MouseCursorSpeed"))) {
-            updateMouseCursorSpeed();
-        }
-        if (changed.contains(QStringLiteral("TouchpadCursorSpeed"))) {
-            updateTouchpadCursorSpeed();
-        }
-    } else if (interface == QLatin1String("com.ubuntu.touch.AccountsService.SecurityPrivacy")) {
-        if (changed.contains(QStringLiteral("StatsWelcomeScreen"))) {
-            updateStatsWelcomeScreen();
-        }
-    } else if (interface == QLatin1String("com.ubuntu.AccountsService.SecurityPrivacy")) {
-        if (changed.contains(QStringLiteral("PasswordDisplayHint"))) {
-            updatePasswordDisplayHint();
-        }
-        if (changed.contains(QStringLiteral("EnableLauncherWhileLocked"))) {
-            updateEnableLauncherWhileLocked();
-        }
-        if (changed.contains(QStringLiteral("EnableIndicatorsWhileLocked"))) {
-            updateEnableIndicatorsWhileLocked();
-        }
-    } else if (interface == QLatin1String("com.ubuntu.location.providers.here.AccountsService")) {
-        if (changed.contains(QStringLiteral("LicenseAccepted"))) {
-            updateHereEnabled();
-        }
-        if (changed.contains(QStringLiteral("LicenseBasePath"))) {
-            updateHereLicensePath();
-        }
+    auto propHash = m_properties.value(interface);
+    auto i = propHash.constBegin();
+    while (i != propHash.constEnd()) {
+        if (changed.contains(i.key())) {
+            updateProperty(interface, i.key());
+        }
+        ++i;
     }
 }
 
@@ -514,6 +347,20 @@
         return;
     }
 
-    // Standard properties might have changed
-    updateBackgroundFile();
+    // Any of the standard properties might have changed!
+    auto propHash = m_properties.value(IFACE_ACCOUNTS_USER);
+    auto i = propHash.constBegin();
+    while (i != propHash.constEnd()) {
+        updateProperty(IFACE_ACCOUNTS_USER, i.key());
+        ++i;
+    }
+}
+
+void AccountsService::refresh(bool async)
+{
+    auto i = m_properties.constBegin();
+    while (i != m_properties.constEnd()) {
+        updateAllProperties(i.key(), async);
+        ++i;
+    }
 }

=== modified file 'plugins/AccountsService/AccountsService.h'
--- plugins/AccountsService/AccountsService.h	2016-01-21 21:04:00 +0000
+++ plugins/AccountsService/AccountsService.h	2016-03-11 11:34:41 +0000
@@ -19,8 +19,10 @@
 #ifndef UNITY_ACCOUNTSSERVICE_H
 #define UNITY_ACCOUNTSSERVICE_H
 
+#include <QHash>
 #include <QObject>
 #include <QString>
+#include <QVariant>
 
 class AccountsServiceDBusAdaptor;
 class QDBusInterface;
@@ -109,30 +111,33 @@
     void onMaybeChanged(const QString &user);
 
 private:
-    void updateDemoEdges(bool async = true);
-    void updateEnableLauncherWhileLocked(bool async = true);
-    void updateEnableIndicatorsWhileLocked(bool async = true);
-    void updateBackgroundFile(bool async = true);
-    void updateMouseCursorSpeed();
-    void updateTouchpadCursorSpeed();
-    void updateStatsWelcomeScreen(bool async = true);
-    void updatePasswordDisplayHint(bool async = true);
-    void updateFailedLogins(bool async = true);
-    void updateHereEnabled(bool async = true);
-    void updateHereLicensePath(bool async = true);
-
+    typedef QVariant (*ProxyConverter)(const QVariant &);
+
+    void refresh(bool async);
+    void registerProperty(const QString &interface, const QString &property, const QString &signal);
+    void registerProxy(const QString &interface, const QString &property, QDBusInterface *iface, const QString &method, ProxyConverter converter = nullptr);
+
+    void updateAllProperties(const QString &interface, bool async);
+    void updateProperty(const QString &interface, const QString &property);
+    void updateCache(const QString &interface, const QString &property, const QVariant &value);
+
+    void setProperty(const QString &interface, const QString &property, const QVariant &value);
+    QVariant getProperty(const QString &interface, const QString &property) const;
+
+    void emitChangedForProperty(const QString &interface, const QString &property);
+
+    struct PropertyInfo {
+        QVariant value{};
+        QString signal{};
+        QDBusInterface *proxyInterface{};
+        QString proxyMethod{};
+        ProxyConverter proxyConverter{};
+    };
+    typedef QHash< QString, QHash<QString, PropertyInfo> > PropertyHash;
+    PropertyHash m_properties;
     AccountsServiceDBusAdaptor *m_service;
     QDBusInterface *m_unityInput;
     QString m_user;
-    bool m_demoEdges;
-    bool m_enableLauncherWhileLocked;
-    bool m_enableIndicatorsWhileLocked;
-    QString m_backgroundFile;
-    bool m_statsWelcomeScreen;
-    PasswordDisplayHint m_passwordDisplayHint;
-    uint m_failedLogins;
-    bool m_hereEnabled;
-    QString m_hereLicensePath;
 };
 
 #endif

=== modified file 'plugins/AccountsService/AccountsServiceDBusAdaptor.cpp'
--- plugins/AccountsService/AccountsServiceDBusAdaptor.cpp	2015-10-26 14:05:14 +0000
+++ plugins/AccountsService/AccountsServiceDBusAdaptor.cpp	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -12,8 +12,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Michael Terry <[e-mail]>
  */
 
 #include "AccountsServiceDBusAdaptor.h"
@@ -37,6 +35,15 @@
                                            connection, this);
 }
 
+QDBusPendingReply<QVariantMap> AccountsServiceDBusAdaptor::getAllPropertiesAsync(const QString &user, const QString &interface)
+{
+    QDBusInterface *iface = getUserInterface(user);
+    if (iface != nullptr && iface->isValid()) {
+        return iface->asyncCall(QStringLiteral("GetAll"), interface);
+    }
+    return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(QDBusError::Other, QStringLiteral("Invalid Interface")));
+}
+
 QDBusPendingReply<QVariant> AccountsServiceDBusAdaptor::getUserPropertyAsync(const QString &user, const QString &interface, const QString &property)
 {
     QDBusInterface *iface = getUserInterface(user);
@@ -80,7 +87,7 @@
     m_ignoreNextChanged = false;
 }
 
-QString AccountsServiceDBusAdaptor::getUserForPath(const QString &path)
+QString AccountsServiceDBusAdaptor::getUserForPath(const QString &path) const
 {
     QMap<QString, QDBusInterface *>::const_iterator i;
     for (i = m_users.constBegin(); i != m_users.constEnd(); ++i) {

=== modified file 'plugins/AccountsService/AccountsServiceDBusAdaptor.h'
--- plugins/AccountsService/AccountsServiceDBusAdaptor.h	2015-10-26 14:05:14 +0000
+++ plugins/AccountsService/AccountsServiceDBusAdaptor.h	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -12,8 +12,6 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Michael Terry <[e-mail]>
  */
 
 #ifndef UNITY_ACCOUNTSSERVICEDBUSADAPTOR_H
@@ -35,8 +33,9 @@
     explicit AccountsServiceDBusAdaptor(QObject *parent = 0);
     ~AccountsServiceDBusAdaptor() = default;
 
-    Q_INVOKABLE QDBusPendingReply<QVariant> getUserPropertyAsync(const QString &user, const QString &interface, const QString &property);
-    Q_INVOKABLE QDBusPendingCall setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value);
+    QDBusPendingReply<QVariantMap> getAllPropertiesAsync(const QString &user, const QString &interface);
+    QDBusPendingReply<QVariant> getUserPropertyAsync(const QString &user, const QString &interface, const QString &property);
+    QDBusPendingCall setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value);
 
 Q_SIGNALS:
     void propertiesChanged(const QString &user, const QString &interface, const QStringList &changed);
@@ -48,7 +47,7 @@
 
 private:
     QDBusInterface *getUserInterface(const QString &user);
-    QString getUserForPath(const QString &path);
+    QString getUserForPath(const QString &path) const;
 
     QDBusInterface *m_accountsManager;
     QMap<QString, QDBusInterface *> m_users;

=== modified file 'plugins/Dash/AudioProgressBar.qml'
--- plugins/Dash/AudioProgressBar.qml	2015-12-03 14:44:08 +0000
+++ plugins/Dash/AudioProgressBar.qml	2016-03-11 11:34:41 +0000
@@ -31,6 +31,7 @@
         anchors { left: parent.left; right: parent.right }
         height: units.dp(6)
         source: "graphics/music_progress_bg.png"
+        asynchronous: true
         sourceSize.width: width
         sourceSize.height: height
     }

=== modified file 'plugins/Dash/CardCreator.js'
--- plugins/Dash/CardCreator.js	2016-02-12 00:11:52 +0000
+++ plugins/Dash/CardCreator.js	2016-03-11 11:34:41 +0000
@@ -18,12 +18,13 @@
 
 // %1 is the template["card-background"]["elements"][0]
 // %2 is the template["card-background"]["elements"][1]
-// %3 is the template["card-background"] string
+// %3 is whether the loader should be asynchronous or not
+// %4 is the template["card-background"] string
 var kBackgroundLoaderCode = 'Loader {\n\
                                 id: backgroundLoader; \n\
                                 objectName: "backgroundLoader"; \n\
                                 anchors.fill: parent; \n\
-                                asynchronous: root.asynchronous; \n\
+                                asynchronous: %3; \n\
                                 visible: status == Loader.Ready; \n\
                                 sourceComponent: UbuntuShape { \n\
                                     objectName: "background"; \n\
@@ -46,7 +47,7 @@
                                         objectName: "backgroundImage"; \n\
                                         source: { \n\
                                             if (cardData && typeof cardData["background"] === "string") return cardData["background"]; \n\
-                                            else return %3; \n\
+                                            else return %4; \n\
                                         } \n\
                                     } \n\
                                     function getColor(index) { \n\
@@ -63,8 +64,9 @@
 // %3 is used as image height
 // %4 is used for artShapeSource.hideSource and inner Loader visible
 // %5 is used as aspect ratio fallback
-// %6 is injected as code to artImage
-// %7 is used as image fallback
+// %6 is whether the loader should be asynchronous or not
+// %7 is injected as code to artImage
+// %8 is used as image fallback
 var kArtShapeHolderCode = 'Item { \n\
                             id: artShapeHolder; \n\
                             height: root.fixedArtShapeSize.height > 0 ? root.fixedArtShapeSize.height : artShapeLoader.height; \n\
@@ -73,9 +75,9 @@
                             Loader { \n\
                                 id: artShapeLoader; \n\
                                 objectName: "artShapeLoader"; \n\
-                                readonly property string cardArt: cardData && cardData["art"] || %7; \n\
+                                readonly property string cardArt: cardData && cardData["art"] || %8; \n\
                                 active: cardArt != ""; \n\
-                                asynchronous: root.asynchronous; \n\
+                                asynchronous: %6; \n\
                                 visible: status == Loader.Ready; \n\
                                 sourceComponent: Item { \n\
                                     id: artShape; \n\
@@ -132,10 +134,10 @@
                                         id: artImage; \n\
                                         objectName: "artImage"; \n\
                                         source: artShapeLoader.cardArt; \n\
-                                        asynchronous: root.asynchronous; \n\
+                                        asynchronous: %6; \n\
                                         width: %2; \n\
                                         height: %3; \n\
-                                        %6 \n\
+                                        %7 \n\
                                     } \n\
                                 } \n\
                             } \n\
@@ -144,6 +146,7 @@
 // %1 is anchors.fill
 // %2 is width
 // %3 is height
+// %4 is whether the icon should be asynchronous or not
 var kAudioButtonCode = 'AbstractButton { \n\
                             id: audioButton; \n\
                             anchors.fill: %1; \n\
@@ -169,6 +172,7 @@
                                 opacity: 0.9; \n\
                                 name: DashAudioPlayer.playing && AudioUrlComparer.compare(parent.source, DashAudioPlayer.currentSource) ? "media-playback-pause" : "media-playback-start"; \n\
                                 color: "white"; \n\
+                                asynchronous: %4; \n\
                             } \n\
                             onClicked: { \n\
                                 if (AudioUrlComparer.compare(source, DashAudioPlayer.currentSource)) { \n\
@@ -187,12 +191,14 @@
                             } \n\
                         }';
 
+// %1 is whether the loader should be asynchronous or not
+// %2 is the header height code
 var kOverlayLoaderCode = 'Loader { \n\
                             id: overlayLoader; \n\
-                            readonly property real overlayHeight: (fixedHeaderHeight > 0 ? fixedHeaderHeight : headerHeight) + units.gu(2); \n\
+                            readonly property real overlayHeight: %2 + units.gu(2); \n\
                             anchors.fill: artShapeHolder; \n\
                             active: artShapeLoader.active && artShapeLoader.item && artShapeLoader.item.image.status === Image.Ready || false; \n\
-                            asynchronous: root.asynchronous; \n\
+                            asynchronous: %1; \n\
                             visible: showHeader && status == Loader.Ready; \n\
                             sourceComponent: UbuntuShapeOverlay { \n\
                                 id: overlay; \n\
@@ -211,17 +217,19 @@
                         objectName: "outerRow"; \n\
                         property real margins: units.gu(1); \n\
                         spacing: margins; \n\
-                        height: root.fixedHeaderHeight != -1 ? root.fixedHeaderHeight : implicitHeight; \n\
+                        %2\
                         anchors { %1 } \n\
                         anchors.right: parent.right; \n\
                         anchors.margins: margins; \n\
                         anchors.rightMargin: 0; \n\
                         data: [ \n\
-                                %2 \n\
+                                %3 \n\
                                 ] \n\
                     }\n';
     var args = Array.prototype.slice.call(arguments);
-    var code = kHeaderRowCodeTemplate.arg(args.shift()).arg(args.join(',\n'));
+    var isCardTool = args.shift();
+    var heightCode = isCardTool ? "" : "height: root.fixedHeaderHeight; \n";
+    var code = kHeaderRowCodeTemplate.arg(args.shift()).arg(heightCode).arg(args.join(',\n'));
     return code;
 }
 
@@ -242,10 +250,11 @@
 }
 
 // %1 is used as anchors of mascotShapeLoader
+// %2 is whether the loader should be asynchronous or not
 var kMascotShapeLoaderCode = 'Loader { \n\
                                 id: mascotShapeLoader; \n\
                                 objectName: "mascotShapeLoader"; \n\
-                                asynchronous: root.asynchronous; \n\
+                                asynchronous: %2; \n\
                                 active: mascotImage.status === Image.Ready; \n\
                                 visible: showHeader && active && status == Loader.Ready; \n\
                                 width: units.gu(6); \n\
@@ -275,6 +284,7 @@
 // %2 is used as color of titleLabel
 // %3 is used as extra condition for visible of titleLabel
 // %4 is used as title width
+// %5 is used as horizontal alignment
 var kTitleLabelCode = 'Label { \n\
                         id: titleLabel; \n\
                         objectName: "titleLabel"; \n\
@@ -289,7 +299,7 @@
                         width: %4; \n\
                         text: root.title; \n\
                         font.weight: cardData && cardData["subtitle"] ? Font.DemiBold : Font.Normal; \n\
-                        horizontalAlignment: root.titleAlignment; \n\
+                        horizontalAlignment: %5; \n\
                     }\n';
 
 // %1 is used as extra anchors of emblemIcon
@@ -398,7 +408,7 @@
     return colorString;
 }
 
-function cardString(template, components) {
+function cardString(template, components, isCardTool) {
     var code;
 
     var templateInteractive = (template == null ? true : (template["non-interactive"] !== undefined ? !template["non-interactive"] : true)) ? "true" : "false";
@@ -410,16 +420,16 @@
                 property string backgroundShapeStyle: "inset"; \n\
                 property real fontScale: 1.0; \n\
                 property var scopeStyle: null; \n\
-                property int titleAlignment: Text.AlignLeft; \n\
-                property int fixedHeaderHeight: -1; \n\
+                %2\
                 property size fixedArtShapeSize: Qt.size(-1, -1); \n\
                 readonly property string title: cardData && cardData["title"] || ""; \n\
-                property bool asynchronous: true; \n\
                 property bool showHeader: true; \n\
                 implicitWidth: childrenRect.width; \n\
                 enabled: %1; \n\
                 \n'.arg(templateInteractive);
 
+    code = code.arg(isCardTool ? "" : "property int fixedHeaderHeight: -1; \n");
+
     var hasArt = components["art"] && components["art"]["field"] || false;
     var hasSummary = components["summary"] || false;
     var isConciergeMode = components["art"] && components["art"]["conciergeMode"] || false;
@@ -435,6 +445,7 @@
     var hasHeaderRow = hasMascot && hasTitle;
     var hasAttributes = hasTitle && components["attributes"] && components["attributes"]["field"] || false;
     var isAudio = template["quick-preview-type"] === "audio";
+    var asynchronous = isCardTool ? "false" : "true";
 
     if (isAudio) {
         // For now we only support audio cards with [optional] art, title, subtitle
@@ -468,7 +479,7 @@
                 backgroundElements1 = '"%1"'.arg(element1);
             }
         }
-        code += kBackgroundLoaderCode.arg(backgroundElements0).arg(backgroundElements1).arg(templateCardBackground);
+        code += kBackgroundLoaderCode.arg(backgroundElements0).arg(backgroundElements1).arg(asynchronous).arg(templateCardBackground);
     }
 
     if (hasArt) {
@@ -497,23 +508,31 @@
         if (isNaN(aspectRatio)) {
             aspectRatio = 1;
         }
-        var fallback = components["art"] && components["art"]["fallback"] || "";
+        var fallback = !isCardTool && components["art"] && components["art"]["fallback"] || "";
         fallback = encodeURI(fallback);
         var fallbackStatusCode = "";
         var fallbackURICode = '""';
         if (fallback !== "") {
             // fallbackStatusCode has %6 in it because we want to substitute it for fallbackURICode
-            // which in kArtShapeHolderCode is %7
-            fallbackStatusCode += 'onStatusChanged: if (status === Image.Error) source = %7;';
+            // which in kArtShapeHolderCode is %8
+            fallbackStatusCode += 'onStatusChanged: if (status === Image.Error) source = %8;';
             fallbackURICode = 'decodeURI("%1")'.arg(fallback);
         }
-        code += kArtShapeHolderCode.arg(artAnchors).arg(widthCode).arg(heightCode).arg(isConciergeMode ? "false" : "true").arg(aspectRatio).arg(fallbackStatusCode).arg(fallbackURICode);
+        code += kArtShapeHolderCode.arg(artAnchors)
+                                   .arg(widthCode)
+                                   .arg(heightCode)
+                                   .arg(isConciergeMode ? "false" : "true")
+                                   .arg(aspectRatio)
+                                   .arg(asynchronous)
+                                   .arg(fallbackStatusCode)
+                                   .arg(fallbackURICode);
     } else {
         code += 'readonly property size artShapeSize: Qt.size(-1, -1);\n'
     }
 
     if (headerAsOverlay) {
-        code += kOverlayLoaderCode;
+        var headerHeightCode = isCardTool ? "headerHeight" : "root.fixedHeaderHeight";
+        code += kOverlayLoaderCode.arg(asynchronous).arg(headerHeightCode);
     }
 
     var headerVerticalAnchors;
@@ -595,11 +614,11 @@
         }
 
         if (useMascotShape) {
-            mascotShapeCode = kMascotShapeLoaderCode.arg(mascotAnchors);
+            mascotShapeCode = kMascotShapeLoaderCode.arg(mascotAnchors).arg(asynchronous);
         }
 
         var mascotImageVisible = useMascotShape ? 'false' : 'showHeader';
-        var fallback = components["mascot"] && components["mascot"]["fallback"] || "";
+        var fallback = !isCardTool && components["mascot"] && components["mascot"]["fallback"] || "";
         fallback = encodeURI(fallback);
         var fallbackStatusCode = "";
         var fallbackURICode = '""';
@@ -715,9 +734,24 @@
             }
         }
 
+        var titleAlignment = "Text.AlignHCenter";
+        if (template["card-layout"] === "horizontal"
+            || typeof components["title"] !== "object"
+            || components["title"]["align"] === "left") titleAlignment = "Text.AlignLeft";
+        var keys = ["mascot", "emblem", "subtitle", "attributes", "summary"];
+        for (var key in keys) {
+            key = keys[key];
+            try {
+                if (typeof components[key] === "string"
+                    || typeof components[key]["field"] === "string") titleAlignment = "Text.AlignLeft";
+            } catch (e) {
+                continue;
+            }
+        }
+
         // code for different elements
         var titleLabelVisibleExtra = (headerAsOverlay ? '&& overlayLoader.active': '');
-        var titleCode = kTitleLabelCode.arg(titleAnchors).arg(titleColor).arg(titleLabelVisibleExtra).arg(titleWidth);
+        var titleCode = kTitleLabelCode.arg(titleAnchors).arg(titleColor).arg(titleLabelVisibleExtra).arg(titleWidth).arg(titleAlignment);
         var subtitleCode;
         var attributesCode;
 
@@ -759,7 +793,7 @@
         if (mascotShapeCode != '') {
            rowCode.unshift(mascotShapeCode);
         }
-        code += kHeaderRowCodeGenerator(headerVerticalAnchors + headerLeftAnchor, rowCode)
+        code += kHeaderRowCodeGenerator(isCardTool, headerVerticalAnchors + headerLeftAnchor, rowCode)
     } else {
         code += mascotShapeCode + mascotCode + titleSubtitleCode;
     }
@@ -783,9 +817,10 @@
         } else {
             audioButtonAnchorsFill = 'undefined';
             audioButtonWidth = 'height';
-            audioButtonHeight = '(root.fixedHeaderHeight > 0 ? root.fixedHeaderHeight : headerHeight) + 2 * units.gu(1)';
+            audioButtonHeight = isCardTool ? 'headerHeight + 2 * units.gu(1)'
+                                           : 'root.fixedHeaderHeight + 2 * units.gu(1)';
         }
-        code += kAudioButtonCode.arg(audioButtonAnchorsFill).arg(audioButtonWidth).arg(audioButtonHeight);
+        code += kAudioButtonCode.arg(audioButtonAnchorsFill).arg(audioButtonWidth).arg(audioButtonHeight).arg(asynchronous);
     }
 
     if (hasSummary) {
@@ -854,13 +889,13 @@
     return code;
 }
 
-function createCardComponent(parent, template, components, identifier) {
+function createCardComponent(parent, template, components, isCardTool, identifier) {
     var imports = 'import QtQuick 2.4; \n\
                    import Ubuntu.Components 1.3; \n\
                    import Ubuntu.Settings.Components 0.1; \n\
                    import Dash 0.1;\n\
                    import Utils 0.1;\n';
-    var card = cardString(template, components);
+    var card = cardString(template, components, isCardTool);
     var code = imports + 'Component {\n' + card + '}\n';
 
     try {

=== modified file 'plugins/Dash/CardCreatorCache.qml'
--- plugins/Dash/CardCreatorCache.qml	2016-01-21 17:56:08 +0000
+++ plugins/Dash/CardCreatorCache.qml	2016-03-11 11:34:41 +0000
@@ -23,16 +23,16 @@
 
     property var cache: new Object();
 
-    function getCardComponent(template, components) {
+    function getCardComponent(template, components, isCardTool) {
         if (template === undefined || components === undefined)
             return undefined;
 
         var tString = JSON.stringify(template);
         var cString = JSON.stringify(components);
-        var allString = tString + cString;
+        var allString = tString + cString + isCardTool;
         var component = cache[allString];
         if (component === undefined) {
-            component = CardCreator.createCardComponent(root, template, components, allString);
+            component = CardCreator.createCardComponent(root, template, components, isCardTool, allString);
             cache[allString] = component;
         }
         return component;

=== modified file 'plugins/Dash/plugin.cpp'
--- plugins/Dash/plugin.cpp	2015-09-18 07:44:50 +0000
+++ plugins/Dash/plugin.cpp	2016-03-11 11:34:41 +0000
@@ -28,12 +28,12 @@
 static QUrl oauthCleanedUrl(QUrl u)
 {
     QUrlQuery q(u);
-    q.removeQueryItem("oauth_nonce");
-    q.removeQueryItem("oauth_timestamp");
-    q.removeQueryItem("oauth_consumer_key");
-    q.removeQueryItem("oauth_signature_method");
-    q.removeQueryItem("oauth_version");
-    q.removeQueryItem("oauth_signature");
+    q.removeQueryItem(QStringLiteral("oauth_nonce"));
+    q.removeQueryItem(QStringLiteral("oauth_timestamp"));
+    q.removeQueryItem(QStringLiteral("oauth_consumer_key"));
+    q.removeQueryItem(QStringLiteral("oauth_signature_method"));
+    q.removeQueryItem(QStringLiteral("oauth_version"));
+    q.removeQueryItem(QStringLiteral("oauth_signature"));
     u.setQuery(q);
     return u;
 }

=== modified file 'plugins/GlobalShortcut/globalshortcutregistry.cpp'
--- plugins/GlobalShortcut/globalshortcutregistry.cpp	2015-11-20 15:01:39 +0000
+++ plugins/GlobalShortcut/globalshortcutregistry.cpp	2016-03-11 11:34:41 +0000
@@ -35,13 +35,13 @@
 
 bool GlobalShortcutRegistry::hasShortcut(const QVariant &seq) const
 {
-    return m_shortcuts.keys().contains(seq);
+    return m_shortcuts.contains(seq);
 }
 
 void GlobalShortcutRegistry::addShortcut(const QVariant &seq, GlobalShortcut *sc)
 {
     if (sc) {
-        if (!m_shortcuts.keys().contains(seq)) { // create a new entry
+        if (!m_shortcuts.contains(seq)) { // create a new entry
             m_shortcuts.insert(seq, {sc});
         } else { // append to an existing one
             auto shortcuts = m_shortcuts[seq];
@@ -75,8 +75,8 @@
 
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
-        QKeySequence seq = QKeySequence(keyEvent->key() + keyEvent->modifiers());
-        if (m_shortcuts.keys().contains(seq)) {
+        int seq = keyEvent->key() + keyEvent->modifiers();
+        if (m_shortcuts.contains(seq)) {
             const auto shortcuts = m_shortcuts.value(seq);
             Q_FOREACH(const auto &shortcut, shortcuts) {
                 if (shortcut) {

=== modified file 'plugins/IntegratedLightDM/liblightdm/CMakeLists.txt'
--- plugins/IntegratedLightDM/liblightdm/CMakeLists.txt	2016-02-01 15:15:09 +0000
+++ plugins/IntegratedLightDM/liblightdm/CMakeLists.txt	2016-03-11 11:34:41 +0000
@@ -5,13 +5,16 @@
     UsersModel.cpp
     GreeterPrivate.cpp
     UsersModelPrivate.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/AccountsService/AccountsServiceDBusAdaptor.cpp
     ${CMAKE_SOURCE_DIR}/plugins/Utils/qvariantlistmodel.cpp
     )
 
 add_library(integratedLightDM STATIC ${LibLightDM_SOURCES})
+add_library(integratedLightDMSession STATIC ${LibLightDM_SOURCES})
 add_library(MockLightDM-demo-shared SHARED ${LibLightDM_SOURCES})
 
 include_directories(
+    ${CMAKE_SOURCE_DIR}/plugins/AccountsService
     ${CMAKE_CURRENT_BINARY_DIR}
     ${GLIB_INCLUDE_DIRS}
     ${LIBUSERMETRICSOUTPUT_INCLUDE_DIRS}
@@ -22,17 +25,27 @@
     ${LIBUSERMETRICSOUTPUT_LDFLAGS}
     -lpam
 )
+target_link_libraries(integratedLightDMSession
+    ${GLIB_LIBRARIES}
+    ${LIBUSERMETRICSOUTPUT_LDFLAGS}
+    -lpam
+)
 target_link_libraries(MockLightDM-demo-shared
     ${GLIB_LIBRARIES}
     ${LIBUSERMETRICSOUTPUT_LDFLAGS}
     -lpam
 )
 
-qt5_use_modules(integratedLightDM Concurrent Gui)
-qt5_use_modules(MockLightDM-demo-shared Concurrent Gui)
+qt5_use_modules(integratedLightDM Concurrent DBus Gui)
+qt5_use_modules(integratedLightDMSession Concurrent DBus Gui)
+qt5_use_modules(MockLightDM-demo-shared Concurrent DBus Gui)
 
-set_target_properties(integratedLightDM PROPERTIES COMPILE_FLAGS -fPIC)
+set_target_properties(integratedLightDM PROPERTIES
+                      COMPILE_FLAGS "-DSM_BUSNAME=systemBus -fPIC")
+set_target_properties(integratedLightDMSession PROPERTIES
+                      COMPILE_FLAGS "-DSM_BUSNAME=sessionBus -fPIC")
 set_target_properties(MockLightDM-demo-shared PROPERTIES
+                      COMPILE_FLAGS "-DSM_BUSNAME=systemBus"
                       OUTPUT_NAME lightdm-qt5-2)
 
 install(TARGETS MockLightDM-demo-shared

=== modified file 'plugins/IntegratedLightDM/liblightdm/UsersModel.cpp'
--- plugins/IntegratedLightDM/liblightdm/UsersModel.cpp	2015-09-14 09:11:08 +0000
+++ plugins/IntegratedLightDM/liblightdm/UsersModel.cpp	2016-03-11 11:34:41 +0000
@@ -54,24 +54,10 @@
     roles[ImagePathRole] = "imagePath";
     setRoleNames(roles);
 
-    // Now modify our mock user backgrounds
-    QDir bgdir = QDir(QStringLiteral("/usr/share/demo-assets/shell/backgrounds/"));
-    QStringList backgrounds = bgdir.entryList(QDir::Files | QDir::NoDotAndDotDot);
-
-    for (int i = 0, j = 0; i < d->entries.size(); i++) {
-        Entry &entry = d->entries[i];
-        if (entry.background.isNull() && !backgrounds.isEmpty()) {
-            entry.background = bgdir.filePath(backgrounds[j++]);
-            if (j >= backgrounds.length()) {
-                j = 0;
-            }
-        }
-    }
-}
-
-UsersModel::~UsersModel()
-{
-    delete d_ptr;
+    connect(d_ptr, &UsersModelPrivate::dataChanged, this, [this](int i) {
+        QModelIndex index = createIndex(i, 0);
+        Q_EMIT dataChanged(index, index);
+    });
 }
 
 int UsersModel::rowCount(const QModelIndex &parent) const

=== modified file 'plugins/IntegratedLightDM/liblightdm/UsersModel.h'
--- plugins/IntegratedLightDM/liblightdm/UsersModel.h	2015-04-30 09:31:51 +0000
+++ plugins/IntegratedLightDM/liblightdm/UsersModel.h	2016-03-11 11:34:41 +0000
@@ -41,7 +41,7 @@
 
 public:
     explicit UsersModel(QObject *parent = 0);
-    virtual ~UsersModel();
+    virtual ~UsersModel() = default;
 
     enum UserModelRoles {NameRole = Qt::UserRole,
                          RealNameRole,

=== modified file 'plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp'
--- plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp	2016-02-04 14:10:42 +0000
+++ plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.cpp	2016-03-11 11:34:41 +0000
@@ -18,7 +18,11 @@
 
 #include "UsersModelPrivate.h"
 
+#include "AccountsServiceDBusAdaptor.h"
+#include "UsersModel.h"
+
 #include <glib.h>
+#include <QDebug>
 #include <QDir>
 #include <QSettings>
 #include <QStringList>
@@ -27,7 +31,9 @@
 {
 
 UsersModelPrivate::UsersModelPrivate(UsersModel* parent)
-  : q_ptr(parent)
+  : QObject(parent),
+    q_ptr(parent),
+    m_service(new AccountsServiceDBusAdaptor(this))
 {
     QFileInfo demoFile(QDir::homePath() + "/.unity8-greeter-demo");
     QString currentUser = g_get_user_name();
@@ -43,15 +49,43 @@
             entries.append({user, name, 0, 0, false, false, 0, 0});
         }
     } else {
-        // If we were using the actual liblightdm, we could just ask it
-        // for the user's real name.  But we aren't.  We *should* ask
-        // AccountsService for the real name, like liblightdm does internally,
-        // but this is close enough since AS and passwd are always in sync.
-        QString realName = QString::fromUtf8(g_get_real_name()); // gets name from passwd entry
-        if (realName == QStringLiteral("Unknown")) { // glib doesn't translate this string
-            realName.clear();
-        }
-        entries.append({currentUser, realName, 0, 0, false, false, 0, 0});
+        entries.append({currentUser, 0, 0, 0, false, false, 0, 0});
+
+        connect(m_service, &AccountsServiceDBusAdaptor::maybeChanged,
+                this, [this](const QString &user) {
+            if (user == entries[0].username) {
+                updateName(true);
+            }
+        });
+        updateName(false);
+    }
+}
+
+void UsersModelPrivate::updateName(bool async)
+{
+    auto pendingReply = m_service->getUserPropertyAsync(entries[0].username,
+                                                        QStringLiteral("org.freedesktop.Accounts.User"),
+                                                        QStringLiteral("RealName"));
+    auto *watcher = new QDBusPendingCallWatcher(pendingReply, this);
+
+    connect(watcher, &QDBusPendingCallWatcher::finished,
+            this, [this](QDBusPendingCallWatcher* watcher) {
+
+        QDBusPendingReply<QVariant> reply = *watcher;
+        watcher->deleteLater();
+        if (reply.isError()) {
+            qWarning() << "Failed to get 'RealName' property - " << reply.error().message();
+            return;
+        }
+
+        const QString realName = reply.value().toString();
+        if (entries[0].real_name != realName) {
+            entries[0].real_name = realName;
+            Q_EMIT dataChanged(0);
+        }
+    });
+    if (!async) {
+        watcher->waitForFinished();
     }
 }
 

=== modified file 'plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.h'
--- plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.h	2015-01-20 11:50:19 +0000
+++ plugins/IntegratedLightDM/liblightdm/UsersModelPrivate.h	2016-03-11 11:34:41 +0000
@@ -19,8 +19,11 @@
 #ifndef UNITY_MOCK_USERSMODEL_PRIVATE_H
 #define UNITY_MOCK_USERSMODEL_PRIVATE_H
 
-#include <QtCore/QList>
-#include <QtCore/QString>
+#include <QList>
+#include <QObject>
+#include <QString>
+
+class AccountsServiceDBusAdaptor;
 
 namespace QLightDM
 {
@@ -39,19 +42,28 @@
     QString infographic;
 };
 
-class UsersModelPrivate
+class UsersModelPrivate : public QObject
 {
+    Q_OBJECT
+
 public:
     explicit UsersModelPrivate(UsersModel *parent = 0);
     virtual ~UsersModelPrivate() = default;
 
     QList<Entry> entries;
 
+Q_SIGNALS:
+    void dataChanged(int);
+
 protected:
     UsersModel * const q_ptr;
 
 private:
     Q_DECLARE_PUBLIC(UsersModel)
+
+    void updateName(bool async);
+
+    AccountsServiceDBusAdaptor *m_service;
 };
 
 }

=== modified file 'plugins/Unity/Indicators/indicatorsmanager.cpp'
--- plugins/Unity/Indicators/indicatorsmanager.cpp	2015-12-02 12:02:50 +0000
+++ plugins/Unity/Indicators/indicatorsmanager.cpp	2016-03-11 11:34:41 +0000
@@ -116,7 +116,7 @@
     QSettings indicator_settings(file_info.absoluteFilePath(), QSettings::IniFormat, this);
     const QString name = indicator_settings.value(QStringLiteral("Indicator Service/Name")).toString();
 
-    if (m_platform.isPC() && name == "indicator-keyboard") {
+    if (m_platform.isPC() && name == QLatin1String("indicator-keyboard")) {
         return; // convergence: skip this indicator until it works in Mir
     }
 
@@ -293,7 +293,7 @@
     // The rest of the indicators respect their default profile (which is "phone", even on desktop PCs)
     if ((new_indicator->identifier() == QStringLiteral("indicator-session") && m_platform.isMultiSession())
             || (new_indicator->identifier() == QStringLiteral("indicator-power") && m_platform.isPC())) {
-        new_indicator->setProfile("desktop");
+        new_indicator->setProfile(QStringLiteral("desktop"));
     } else {
         new_indicator->setProfile(m_profile);
     }

=== modified file 'plugins/Unity/Indicators/rootstateparser.h'
--- plugins/Unity/Indicators/rootstateparser.h	2014-11-11 15:28:13 +0000
+++ plugins/Unity/Indicators/rootstateparser.h	2016-03-11 11:34:41 +0000
@@ -23,6 +23,7 @@
 
 class UNITYINDICATORS_EXPORT RootStateParser : public ActionStateParser
 {
+Q_OBJECT
 public:
     RootStateParser(QObject* parent = nullptr);
     virtual QVariant toQVariant(GVariant* state) const override;

=== modified file 'plugins/Unity/Launcher/desktopfilehandler.cpp'
--- plugins/Unity/Launcher/desktopfilehandler.cpp	2015-09-30 12:43:53 +0000
+++ plugins/Unity/Launcher/desktopfilehandler.cpp	2016-03-11 11:34:41 +0000
@@ -146,9 +146,9 @@
     QString iconString = settings.value(QStringLiteral("Icon")).toString();
     QString pathString = settings.value(QStringLiteral("Path")).toString();
 
-    if (QFileInfo(iconString).exists()) {
+    if (QFileInfo::exists(iconString)) {
         return QFileInfo(iconString).absoluteFilePath();
-    } else if (QFileInfo(pathString + '/' + iconString).exists()) {
+    } else if (QFileInfo::exists(pathString + '/' + iconString)) {
         return pathString + '/' + iconString;
     }
     return "image://theme/" + iconString;

=== modified file 'plugins/Unity/Launcher/launcheritem.cpp'
--- plugins/Unity/Launcher/launcheritem.cpp	2015-09-14 09:11:08 +0000
+++ plugins/Unity/Launcher/launcheritem.cpp	2016-03-11 11:34:41 +0000
@@ -37,6 +37,7 @@
     m_alerting(false),
     m_quickList(new QuickListModel(this))
 {
+    Q_ASSERT(parent != nullptr);
     QuickListEntry nameAction;
     nameAction.setActionId(QStringLiteral("launch_item"));
     nameAction.setText(m_name);

=== modified file 'plugins/Unity/Launcher/launcheritem.h'
--- plugins/Unity/Launcher/launcheritem.h	2015-07-23 14:13:57 +0000
+++ plugins/Unity/Launcher/launcheritem.h	2016-03-11 11:34:41 +0000
@@ -32,7 +32,7 @@
 {
     Q_OBJECT
 public:
-    LauncherItem(const QString &appId, const QString &name, const QString &icon, QObject *parent = 0);
+    LauncherItem(const QString &appId, const QString &name, const QString &icon, QObject *parent);
 
     QString appId() const override;
     QString name() const override;

=== modified file 'plugins/Unity/Launcher/launchermodel.cpp'
--- plugins/Unity/Launcher/launchermodel.cpp	2015-09-14 09:11:08 +0000
+++ plugins/Unity/Launcher/launchermodel.cpp	2016-03-11 11:34:41 +0000
@@ -103,7 +103,7 @@
         LauncherItem *item = m_list.at(index);
         if (!item->focused()) {
             item->setAlerting(alerting);
-            Q_EMIT dataChanged(modelIndex, modelIndex, QVector<int>() << RoleAlerting);
+            Q_EMIT dataChanged(modelIndex, modelIndex, {RoleAlerting});
         }
     }
 }
@@ -389,7 +389,8 @@
         if (countVisible && desktopFile.isValid()) {
             LauncherItem *item = new LauncherItem(appId,
                                                   desktopFile.displayName(),
-                                                  desktopFile.icon());
+                                                  desktopFile.icon(),
+                                                  this);
             item->setCountVisible(true);
             beginInsertRows(QModelIndex(), m_list.count(), m_list.count());
             m_list.append(item);
@@ -414,10 +415,19 @@
         } else {
             int idx = m_list.indexOf(item);
             item->setName(desktopFile.displayName());
-            item->setIcon(desktopFile.icon());
             item->setPinned(item->pinned()); // update pinned text if needed
             item->setRunning(item->running());
-            Q_EMIT dataChanged(index(idx), index(idx), {RoleName, RoleIcon, RoleRunning});
+            Q_EMIT dataChanged(index(idx), index(idx), {RoleName, RoleRunning});
+
+            const QString oldIcon = item->icon();
+            if (oldIcon == desktopFile.icon()) { // same icon file, perhaps different contents, simulate changing the icon name to force reload
+                item->setIcon(QString());
+                Q_EMIT dataChanged(index(idx), index(idx), {RoleIcon});
+            }
+
+            // now set the icon for real
+            item->setIcon(desktopFile.icon());
+            Q_EMIT dataChanged(index(idx), index(idx), {RoleIcon});
         }
     }
 
@@ -489,7 +499,7 @@
     if (idx >= 0) {
         LauncherItem *item = m_list.at(idx);
         setAlerting(item->appId(), true);
-        Q_EMIT dataChanged(index(idx), index(idx), QVector<int>() << RoleAlerting);
+        Q_EMIT dataChanged(index(idx), index(idx), {RoleAlerting});
     }
 }
 

=== modified file 'plugins/Unity/Launcher/launchermodel.h'
--- plugins/Unity/Launcher/launchermodel.h	2015-07-29 12:32:57 +0000
+++ plugins/Unity/Launcher/launchermodel.h	2016-03-11 11:34:41 +0000
@@ -38,7 +38,7 @@
    Q_OBJECT
 
 public:
-    LauncherModel(QObject *parent = 0);
+    LauncherModel(QObject *parent = nullptr);
     ~LauncherModel();
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2016-02-08 09:37:48 +0000
+++ plugins/Utils/CMakeLists.txt	2016-03-11 11:34:41 +0000
@@ -23,6 +23,7 @@
     windowstatestorage.cpp
     timezoneFormatter.cpp
     inputeventgenerator.cpp
+    deviceconfigparser.cpp
     plugin.cpp
     )
 

=== added file 'plugins/Utils/deviceconfigparser.cpp'
--- plugins/Utils/deviceconfigparser.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Utils/deviceconfigparser.cpp	2016-03-11 11:34:41 +0000
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "deviceconfigparser.h"
+
+#include <QSettings>
+#include <QFileInfo>
+#include <QDebug>
+#include <QStandardPaths>
+
+DeviceConfigParser::DeviceConfigParser(QObject *parent): QObject(parent)
+{
+    QString path;
+    Q_FOREACH (const QString &standardPath, QStandardPaths::standardLocations(QStandardPaths::GenericConfigLocation)) {
+        if (QFileInfo(standardPath + "/devices.conf").exists()) {
+            path = standardPath + "/devices.conf";
+            break;
+        }
+    }
+
+    if (path.isEmpty()) {
+        path = "/etc/ubuntu/devices.conf";
+    }
+    qDebug() << "Using" << path << "as device configuration file";
+    m_config = new QSettings(path, QSettings::IniFormat, this);
+}
+
+QString DeviceConfigParser::name() const
+{
+    return m_name;
+}
+
+void DeviceConfigParser::setName(const QString &name)
+{
+    if (m_name == name) {
+        return;
+    }
+    m_name = name;
+    Q_EMIT changed();
+}
+
+Qt::ScreenOrientation DeviceConfigParser::primaryOrientation() const
+{
+    return stringToOrientation(readOrientationFromConfig("PrimaryOrientation"), Qt::PrimaryOrientation);
+}
+
+Qt::ScreenOrientations DeviceConfigParser::supportedOrientations() const
+{
+    QStringList values = readOrientationsFromConfig("SupportedOrientations");
+    if (values.isEmpty()) {
+        return Qt::PortraitOrientation
+                | Qt::InvertedPortraitOrientation
+                | Qt::LandscapeOrientation
+                | Qt::InvertedLandscapeOrientation;
+    }
+
+    Qt::ScreenOrientations ret = Qt::PrimaryOrientation;
+    Q_FOREACH(const QString &orientationString, values) {
+        ret |= stringToOrientation(orientationString, Qt::PrimaryOrientation);
+    }
+    return ret;
+}
+
+Qt::ScreenOrientation DeviceConfigParser::landscapeOrientation() const
+{
+    return stringToOrientation(readOrientationFromConfig("LandscapeOrientation"), Qt::LandscapeOrientation);
+}
+
+Qt::ScreenOrientation DeviceConfigParser::invertedLandscapeOrientation() const
+{
+    return stringToOrientation(readOrientationFromConfig("InvertedLandscapeOrientation"), Qt::InvertedLandscapeOrientation);
+}
+
+Qt::ScreenOrientation DeviceConfigParser::portraitOrientation() const
+{
+    return stringToOrientation(readOrientationFromConfig("PortraitOrientation"), Qt::PortraitOrientation);
+}
+
+Qt::ScreenOrientation DeviceConfigParser::invertedPortraitOrientation() const
+{
+    return stringToOrientation(readOrientationFromConfig("InvertedPortraitOrientation"), Qt::InvertedPortraitOrientation);
+}
+
+QString DeviceConfigParser::category() const
+{
+    QStringList supportedValues = {"phone", "tablet", "desktop"};
+    m_config->beginGroup(m_name);
+    QString value = m_config->value("Category", "phone").toString();
+    if (!supportedValues.contains(value)) {
+        qWarning().nospace().noquote() << "Unknown option \"" << value << "\" in " << m_config->fileName()
+                    << ". Supported options are: " << supportedValues.join(", ") << ".";
+        return "phone";
+    }
+    m_config->endGroup();
+    return value;
+}
+
+QStringList DeviceConfigParser::readOrientationsFromConfig(const QString &key) const
+{
+    m_config->beginGroup(m_name);
+
+    QStringList ret;
+    if (m_config->contains(key)) {
+        ret = m_config->value(key).toStringList();
+    }
+
+    m_config->endGroup();
+    return ret;
+}
+
+QString DeviceConfigParser::readOrientationFromConfig(const QString &key) const
+{
+    QStringList ret = readOrientationsFromConfig(key);
+    return ret.count() > 0 ? ret.first() : QString();
+}
+
+Qt::ScreenOrientation DeviceConfigParser::stringToOrientation(const QString &orientationString, Qt::ScreenOrientation defaultValue) const
+{
+    if (orientationString == "Landscape") {
+        return Qt::LandscapeOrientation;
+    }
+    if (orientationString == "InvertedLandscape") {
+        return Qt::InvertedLandscapeOrientation;
+    }
+    if (orientationString == "Portrait") {
+        return Qt::PortraitOrientation;
+    }
+    if (orientationString == "InvertedPortrait") {
+        return Qt::InvertedPortraitOrientation;
+    }
+    if (!orientationString.isEmpty()) {
+        // Some option we don't know. Give some hint on what went wrong.
+        qWarning().nospace().noquote() << "Unknown option \"" << orientationString << "\" in " << m_config->fileName()
+                    << ". Supported options are: Landscape, InvertedLandscape, Portrait and InvertedPortrait.";
+    }
+    return defaultValue;
+}

=== added file 'plugins/Utils/deviceconfigparser.h'
--- plugins/Utils/deviceconfigparser.h	1970-01-01 00:00:00 +0000
+++ plugins/Utils/deviceconfigparser.h	2016-03-11 11:34:41 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2016 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 DEVICECONFIGPARSER_H
+#define DEVICECONFIGPARSER_H
+
+#include <QObject>
+#include <QSettings>
+
+class DeviceConfigParser: public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY changed)
+
+    Q_PROPERTY(Qt::ScreenOrientation primaryOrientation READ primaryOrientation NOTIFY changed)
+    Q_PROPERTY(Qt::ScreenOrientations supportedOrientations READ supportedOrientations NOTIFY changed)
+    Q_PROPERTY(Qt::ScreenOrientation landscapeOrientation READ landscapeOrientation NOTIFY changed)
+    Q_PROPERTY(Qt::ScreenOrientation invertedLandscapeOrientation READ invertedLandscapeOrientation NOTIFY changed)
+    Q_PROPERTY(Qt::ScreenOrientation portraitOrientation READ portraitOrientation NOTIFY changed)
+    Q_PROPERTY(Qt::ScreenOrientation invertedPortraitOrientation READ invertedPortraitOrientation NOTIFY changed)
+    Q_PROPERTY(QString category READ category NOTIFY changed)
+
+public:
+    DeviceConfigParser(QObject *parent = nullptr);
+
+    QString name() const;
+    void setName(const QString &name);
+
+    Qt::ScreenOrientation primaryOrientation() const;
+    Qt::ScreenOrientations supportedOrientations() const;
+    Qt::ScreenOrientation landscapeOrientation() const;
+    Qt::ScreenOrientation invertedLandscapeOrientation() const;
+    Qt::ScreenOrientation portraitOrientation() const;
+    Qt::ScreenOrientation invertedPortraitOrientation() const;
+    QString category() const;
+
+Q_SIGNALS:
+    void changed();
+
+private:
+    QString m_name;
+    QSettings *m_config;
+
+    QStringList readOrientationsFromConfig(const QString &key) const;
+    QString readOrientationFromConfig(const QString &key) const;
+    Qt::ScreenOrientation stringToOrientation(const QString &orientationString, Qt::ScreenOrientation defaultValue) const;
+};
+
+#endif

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2016-01-29 11:52:14 +0000
+++ plugins/Utils/plugin.cpp	2016-03-11 11:34:41 +0000
@@ -37,6 +37,7 @@
 #include "timezoneFormatter.h"
 #include "applicationsfiltermodel.h"
 #include "inputeventgenerator.h"
+#include "deviceconfigparser.h"
 
 static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
 {
@@ -70,6 +71,7 @@
     qmlRegisterType<ActiveFocusLogger>(uri, 0, 1, "ActiveFocusLogger");
     qmlRegisterType<ApplicationsFilterModel>(uri, 0, 1, "ApplicationsFilterModel");
     qmlRegisterType<InputEventGenerator>(uri, 0, 1, "InputEventGenerator");
+    qmlRegisterType<DeviceConfigParser>(uri, 0, 1, "DeviceConfigParser");
 }
 
 void UtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'po/unity8.pot'
--- po/unity8.pot	2016-03-08 21:04:17 +0000
+++ po/unity8.pot	2016-03-11 11:34:41 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: unity8\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2016-03-08 21:04+0000\n"
+"POT-Creation-Date: 2016-03-10 22:48+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -22,16 +22,16 @@
 msgid "Password: "
 msgstr ""
 
-#: plugins/Unity/Launcher/launcheritem.cpp:47
-#: plugins/Unity/Launcher/launcheritem.cpp:106
+#: plugins/Unity/Launcher/launcheritem.cpp:48
+#: plugins/Unity/Launcher/launcheritem.cpp:107
 msgid "Pin shortcut"
 msgstr ""
 
-#: plugins/Unity/Launcher/launcheritem.cpp:52
+#: plugins/Unity/Launcher/launcheritem.cpp:53
 msgid "Quit"
 msgstr ""
 
-#: plugins/Unity/Launcher/launcheritem.cpp:106
+#: plugins/Unity/Launcher/launcheritem.cpp:107
 msgid "Unpin shortcut"
 msgstr ""
 
@@ -135,15 +135,15 @@
 msgid "Restart"
 msgstr ""
 
-#: qml/Components/Lockscreen.qml:245
+#: qml/Components/Lockscreen.qml:231
 msgid "Return to Call"
 msgstr ""
 
-#: qml/Components/Lockscreen.qml:245
+#: qml/Components/Lockscreen.qml:231
 msgid "Emergency Call"
 msgstr ""
 
-#: qml/Components/Lockscreen.qml:277
+#: qml/Components/Lockscreen.qml:263
 msgid "OK"
 msgstr ""
 
@@ -152,6 +152,8 @@
 msgstr ""
 
 #: qml/Components/ModeSwitchWarningDialog.qml:57
+msgctxt ""
+"Re-dock means connect the device again to an external screen/mouse/keyboard"
 msgid "Re-dock, save your work and close these apps to continue."
 msgstr ""
 
@@ -194,15 +196,15 @@
 msgid "Add to Favorites"
 msgstr ""
 
-#: qml/Dash/GenericScopeView.qml:565 qml/Dash/GenericScopeView.qml:723
+#: qml/Dash/GenericScopeView.qml:567 qml/Dash/GenericScopeView.qml:725
 msgid "See less"
 msgstr ""
 
-#: qml/Dash/GenericScopeView.qml:565
+#: qml/Dash/GenericScopeView.qml:567
 msgid "See all"
 msgstr ""
 
-#: qml/Dash/GenericScopeView.qml:627
+#: qml/Dash/GenericScopeView.qml:629
 msgctxt "Label: Hint for dash search line edit"
 msgid "Search"
 msgstr ""
@@ -228,7 +230,7 @@
 msgid "Add a review"
 msgstr ""
 
-#: qml/Dash/Previews/PreviewSharing.qml:50
+#: qml/Dash/Previews/PreviewSharing.qml:66
 msgid "Preview Share Item"
 msgstr ""
 
@@ -256,13 +258,13 @@
 msgid "Also installed"
 msgstr ""
 
-#: qml/DisabledScreenNotice.qml:87
+#: qml/DisabledScreenNotice.qml:104
 msgid ""
 "Your device is now connected to an external display. Use this screen as a "
-"touch pad to interact with the mouse."
+"touch pad to interact with the pointer."
 msgstr ""
 
-#: qml/Greeter/CoverPage.qml:107
+#: qml/Greeter/CoverPage.qml:118
 msgid "Unlock"
 msgstr ""
 
@@ -341,62 +343,62 @@
 msgid "Conference"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:753
+#: qml/Panel/Indicators/MenuItemFactory.qml:752
 msgid "Nothing is playing"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:882
+#: qml/Panel/Indicators/MenuItemFactory.qml:881
 #, qt-format
 msgid "%1 hour"
 msgid_plural "%1 hours"
 msgstr[0] ""
 msgstr[1] ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:886
+#: qml/Panel/Indicators/MenuItemFactory.qml:885
 #, qt-format
 msgid "%1 minute"
 msgid_plural "%1 minutes"
 msgstr[0] ""
 msgstr[1] ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:891
+#: qml/Panel/Indicators/MenuItemFactory.qml:890
 #, qt-format
 msgid "%1 second"
 msgid_plural "%1 seconds"
 msgstr[0] ""
 msgstr[1] ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:894
+#: qml/Panel/Indicators/MenuItemFactory.qml:893
 msgid "0 seconds"
 msgstr ""
 
 #. Translators: String like "1 hour, 2 minutes, 3 seconds remaining"
-#: qml/Panel/Indicators/MenuItemFactory.qml:896
+#: qml/Panel/Indicators/MenuItemFactory.qml:895
 #, qt-format
 msgid "%1 remaining"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:902
+#: qml/Panel/Indicators/MenuItemFactory.qml:901
 msgid "In queue…"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:906
+#: qml/Panel/Indicators/MenuItemFactory.qml:905
 msgid "Downloading"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:908
+#: qml/Panel/Indicators/MenuItemFactory.qml:907
 msgid "Paused, tap to resume"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:910
+#: qml/Panel/Indicators/MenuItemFactory.qml:909
 msgid "Canceled"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:912
+#: qml/Panel/Indicators/MenuItemFactory.qml:911
 msgid "Finished"
 msgstr ""
 
-#: qml/Panel/Indicators/MenuItemFactory.qml:914
+#: qml/Panel/Indicators/MenuItemFactory.qml:913
 msgid "Failed, tap to retry"
 msgstr ""
 

=== modified file 'qml/Components/EdgeBarrier.qml'
--- qml/Components/EdgeBarrier.qml	2015-11-24 17:44:18 +0000
+++ qml/Components/EdgeBarrier.qml	2016-03-11 11:34:41 +0000
@@ -105,7 +105,7 @@
         },
         Transition {
             from: "resisting"; to: "passed"
-            UbuntuNumberAnimation { target: materialContainer; property: "opacity" }
+            UbuntuNumberAnimation { duration: UbuntuAnimation.BriskDuration; target: materialContainer; property: "opacity" }
         }
     ]
 }

=== modified file 'qml/Components/InputMethod.qml'
--- qml/Components/InputMethod.qml	2015-12-02 10:34:31 +0000
+++ qml/Components/InputMethod.qml	2016-03-11 11:34:41 +0000
@@ -22,15 +22,6 @@
 Item {
     id: root
 
-    Connections {
-        target: SurfaceManager
-        onSurfaceCreated: {
-            if (surface.type == Mir.InputMethodType) {
-                surfaceItem.surface = surface;
-            }
-        }
-    }
-
     property int transitionDuration: UbuntuAnimation.FastDuration
 
     MirSurfaceItem {
@@ -41,6 +32,7 @@
 
         surfaceWidth: width
         surfaceHeight: height
+        surface: SurfaceManager.inputMethodSurface
 
         onLiveChanged: {
             if (surface !== null && !live) {

=== modified file 'qml/Components/Lockscreen.qml'
--- qml/Components/Lockscreen.qml	2015-07-15 15:07:19 +0000
+++ qml/Components/Lockscreen.qml	2016-03-11 11:34:41 +0000
@@ -121,107 +121,93 @@
         opacity: root.darkenBackground
     }
 
-    MouseArea {
-        anchors.fill: root
-        onClicked: {
-            if (pinPadLoader.item)
-                pinPadLoader.item.forceActiveFocus()
-        }
-    }
-
-    FocusScope {
-        id: loaderScope
+    Loader {
+        id: pinPadLoader
+        objectName: "pinPadLoader"
         anchors.fill: parent
-
-        Loader {
-            id: pinPadLoader
-            objectName: "pinPadLoader"
-            anchors.fill: parent
-            property bool resetting: false
-            property bool waiting: false
-            property bool showWrongText: false
-
-            source: {
-                if (resetting || !root.required) {
-                    return ""
-                } else if (root.delayMinutes > 0) {
-                    return "DelayedLockscreen.qml"
-                } else if (root.alphaNumeric) {
-                    return "PassphraseLockscreen.qml"
-                } else {
-                    return "PinLockscreen.qml"
-                }
-            }
-            onSourceChanged: {
-                waiting = false
-                showWrongText = false
-                if (loaderScope.activeFocus && pinPadLoader.item)
-                    pinPadLoader.item.forceActiveFocus()
-            }
-
-            Connections {
-                target: pinPadLoader.item
-
-                onEntered: {
-                    pinPadLoader.waiting = true
-                    root.entered(passphrase);
-                }
-
-                onCancel: {
-                    root.cancel()
-                }
-            }
-
-            Binding {
-                target: pinPadLoader.item
-                property: "minPinLength"
-                value: root.minPinLength
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "maxPinLength"
-                value: root.maxPinLength
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "infoText"
-                value: root.infoText
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "retryText"
-                value: root.retryText
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "errorText"
-                value: pinPadLoader.showWrongText ? root.errorText : ""
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "entryEnabled"
-                value: !pinPadLoader.waiting
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "alphaNumeric"
-                value: root.alphaNumeric
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "delayMinutes"
-                value: root.delayMinutes
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "showCancelButton"
-                value: root.showCancelButton
-            }
-            Binding {
-                target: pinPadLoader.item
-                property: "foregroundColor"
-                value: root.foregroundColor
-            }
+        property bool resetting: false
+        property bool waiting: false
+        property bool showWrongText: false
+        focus: true
+
+        source: {
+            if (resetting || !root.required) {
+                return ""
+            } else if (root.delayMinutes > 0) {
+                return "DelayedLockscreen.qml"
+            } else if (root.alphaNumeric) {
+                return "PassphraseLockscreen.qml"
+            } else {
+                return "PinLockscreen.qml"
+            }
+        }
+        onSourceChanged: {
+            waiting = false
+            showWrongText = false
+        }
+
+        Connections {
+            target: pinPadLoader.item
+
+            onEntered: {
+                pinPadLoader.waiting = true
+                root.entered(passphrase);
+            }
+
+            onCancel: {
+                root.cancel()
+            }
+        }
+
+        Binding {
+            target: pinPadLoader.item
+            property: "minPinLength"
+            value: root.minPinLength
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "maxPinLength"
+            value: root.maxPinLength
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "infoText"
+            value: root.infoText
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "retryText"
+            value: root.retryText
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "errorText"
+            value: pinPadLoader.showWrongText ? root.errorText : ""
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "entryEnabled"
+            value: !pinPadLoader.waiting
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "alphaNumeric"
+            value: root.alphaNumeric
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "delayMinutes"
+            value: root.delayMinutes
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "showCancelButton"
+            value: root.showCancelButton
+        }
+        Binding {
+            target: pinPadLoader.item
+            property: "foregroundColor"
+            value: root.foregroundColor
         }
     }
 

=== modified file 'qml/Components/ModeSwitchWarningDialog.qml'
--- qml/Components/ModeSwitchWarningDialog.qml	2015-11-25 13:57:34 +0000
+++ qml/Components/ModeSwitchWarningDialog.qml	2016-03-11 11:34:41 +0000
@@ -54,7 +54,7 @@
     }
 
     Label {
-        text: i18n.tr("Re-dock, save your work and close these apps to continue.")
+        text: i18n.ctr("Re-dock means connect the device again to an external screen/mouse/keyboard", "Re-dock, save your work and close these apps to continue.")
         wrapMode: Text.WordWrap
         color: "#888888"
     }

=== modified file 'qml/Components/PassphraseLockscreen.qml'
--- qml/Components/PassphraseLockscreen.qml	2015-07-15 15:07:19 +0000
+++ qml/Components/PassphraseLockscreen.qml	2016-03-11 11:34:41 +0000
@@ -18,10 +18,11 @@
 import Ubuntu.Components 1.3
 import "../Components"
 
-Item {
+FocusScope {
     id: root
     y: units.gu(4)
     height: shakeContainer.height
+    focus: true
 
     property string infoText
     property string errorText
@@ -42,8 +43,6 @@
         }
     }
 
-    onActiveFocusChanged: if (activeFocus) pinentryField.forceActiveFocus()
-
     Column {
         id: shakeContainer
         anchors.horizontalCenter: parent.horizontalCenter
@@ -59,14 +58,16 @@
             text: root.infoText
         }
 
-        Item {
+        FocusScope {
             id: entryContainer
             anchors { left: parent.left; right: parent.right; margins: units.gu(2) }
             height: units.gu(4)
+            focus: true
 
             TextInput {
                 id: pinentryField
                 objectName: "pinentryField"
+                focus: true
 
                 property bool incorrectOverride: false
 

=== modified file 'qml/Components/PhysicalKeysMapper.qml'
--- qml/Components/PhysicalKeysMapper.qml	2016-01-13 18:43:34 +0000
+++ qml/Components/PhysicalKeysMapper.qml	2016-03-11 11:34:41 +0000
@@ -42,12 +42,15 @@
     signal screenshotTriggered;
 
     readonly property bool altTabPressed: d.altTabPressed
+    readonly property bool superPressed: d.superPressed
+    readonly property bool superTabPressed: d.superTabPressed
 
     property int powerKeyLongPressTime: 2000
 
     // For testing. If running windowed (e.g. tryShell), Alt+Tab is taken by the
     // running desktop, set this to true to use Ctrl+Tab instead.
     property bool controlInsteadOfAlt: false
+    property bool controlInsteadOfSuper: false
 
     QtObject {
         id: d
@@ -59,6 +62,9 @@
         property bool altPressed: false
         property bool altTabPressed: false
 
+        property bool superPressed: false
+        property bool superTabPressed: false
+
         property var powerButtonPressStart: 0
 
         // We need to eat ALT presses until we know what they're for (Alt+Tab or going to the app?)
@@ -119,11 +125,23 @@
                 event.accepted = true;
                 d.altPressInjected = false;
             }
+
+        // Adding MetaModifier here because that's what keyboards do. Pressing Super_L actually gives
+        // Super_L + MetaModifier. This helps to make sure we only invoke superPressed if no other
+        // Modifier is pressed too.
+        } else if (((event.key == Qt.Key_Super_L || event.key == Qt.Key_Super_R) && event.modifiers === Qt.MetaModifier)
+                    || (root.controlInsteadOfSuper && event.key == Qt.Key_Control)
+                    ) {
+            d.superPressed = true;
         } else if (event.key == Qt.Key_Tab) {
             if (d.altPressed && !d.altTabPressed) {
                 d.altTabPressed = true;
                 event.accepted = true;
             }
+            if (d.superPressed && !d.superTabPressed) {
+                d.superTabPressed = true;
+                event.accepted = true;
+            }
         }
     }
 
@@ -154,6 +172,12 @@
             if (d.altTabPressed) {
                 event.accepted = true;
             }
+        } else if (event.key == Qt.Key_Super_L || event.key == Qt.Key_Super_R || (root.controlInsteadOfSuper && event.key == Qt.Key_Control)) {
+            d.superPressed = false;
+            if (d.superTabPressed) {
+                d.superTabPressed = false;
+                event.accepted = true;
+            }
         }
     }
 }

=== modified file 'qml/Components/PinLockscreen.qml'
--- qml/Components/PinLockscreen.qml	2015-07-15 15:07:19 +0000
+++ qml/Components/PinLockscreen.qml	2016-03-11 11:34:41 +0000
@@ -19,8 +19,9 @@
 import Ubuntu.Components.ListItems 1.3
 import "../Components"
 
-Item {
+FocusScope {
     id: root
+    focus: true
 
     property string infoText
     property string retryText
@@ -45,6 +46,24 @@
         }
     }
 
+    Keys.onPressed: {
+        if (pinentryField.text.length == root.maxPinLength)
+            return;
+
+        if (event.key === Qt.Key_Backspace) {
+            pinentryField.backspace();
+        } else if (event.key === Qt.Key_Delete || event.key === Qt.Key_Escape) {
+            closeButton.clicked()
+        } else if (event.key === Qt.Key_Enter || event.key === Qt.Key_Return) {
+            confirmButton.clicked()
+        } else {
+            var digit = parseInt(event.text);
+            if (!isNaN(digit) && typeof digit == "number") {
+                pinentryField.appendNumber(digit);
+            }
+        }
+    }
+
     Column {
         anchors {
             left: parent.left;
@@ -204,6 +223,7 @@
                 width: numbersGrid.buttonWidth
             }
             PinPadButton {
+                id: closeButton
                 iconName: "close"
                 height: units.gu(5) // visual spec has this row a little closer in
                 width: numbersGrid.buttonWidth
@@ -216,6 +236,7 @@
                 width: numbersGrid.buttonWidth
             }
             PinPadButton {
+                id: confirmButton
                 iconName: "tick"
                 objectName: "confirmButton"
                 height: units.gu(5)

=== modified file 'qml/Components/ShellDialog.qml'
--- qml/Components/ShellDialog.qml	2015-11-06 10:06:58 +0000
+++ qml/Components/ShellDialog.qml	2016-03-11 11:34:41 +0000
@@ -37,7 +37,15 @@
 
     focus: true
 
+    // FIXME: this is a hack because Dialog subtheming seems broken atm
+    // https://bugs.launchpad.net/ubuntu/+source/ubuntu-ui-toolkit/+bug/1555548
+    ThemeSettings {
+        id: themeHack
+        name: "Ubuntu.Components.Themes.Ambiance"
+    }
+
     Component.onCompleted: {
+        __foreground.theme = themeHack
         show();
     }
 }

=== modified file 'qml/Dash/CardCarousel.qml'
--- qml/Dash/CardCarousel.qml	2016-01-28 14:11:14 +0000
+++ qml/Dash/CardCarousel.qml	2016-03-11 11:34:41 +0000
@@ -66,7 +66,6 @@
                 item.cardData = Qt.binding(function() { return model; });
                 item.fontScale = Qt.binding(function() { return carousel.fontScale; });
                 item.showHeader = Qt.binding(function() { return loader.explicitlyScaled; });
-                item.titleAlignment = Qt.binding(function() { return cardTool.titleAlignment; });
                 item.artShapeStyle = "shadow";
                 item.scopeStyle = cardCarousel.scopeStyle;
             }

=== modified file 'qml/Dash/CardGrid.qml'
--- qml/Dash/CardGrid.qml	2016-02-02 08:47:07 +0000
+++ qml/Dash/CardGrid.qml	2016-03-11 11:34:41 +0000
@@ -70,7 +70,6 @@
                     item.fixedHeaderHeight = Qt.binding(function() { return cardTool.headerHeight; });
                     item.fixedArtShapeSize = Qt.binding(function() { return cardTool.artShapeSize; });
                     item.cardData = Qt.binding(function() { return model; });
-                    item.titleAlignment = Qt.binding(function() { return cardTool.titleAlignment; });
                     item.scopeStyle = root.scopeStyle;
                     item.artShapeStyle = root.artShapeStyle;
                     item.backgroundShapeStyle = root.backgroundShapeStyle;

=== modified file 'qml/Dash/CardHorizontalList.qml'
--- qml/Dash/CardHorizontalList.qml	2016-01-28 14:11:14 +0000
+++ qml/Dash/CardHorizontalList.qml	2016-03-11 11:34:41 +0000
@@ -53,7 +53,6 @@
                 item.fixedArtShapeSize = Qt.binding(function() { return cardTool.artShapeSize; });
                 item.fixedHeaderHeight = Qt.binding(function() { return cardTool.headerHeight; });
                 item.cardData = Qt.binding(function() { return model; });
-                item.titleAlignment = Qt.binding(function() { return cardTool.titleAlignment; });
                 item.scopeStyle = root.scopeStyle;
             }
             Connections {

=== modified file 'qml/Dash/CardTool.qml'
--- qml/Dash/CardTool.qml	2016-01-28 14:11:14 +0000
+++ qml/Dash/CardTool.qml	2016-03-11 11:34:41 +0000
@@ -66,7 +66,7 @@
         return layout;
     }
 
-    property var cardComponent: CardCreatorCache.getCardComponent(cardTool.template, cardTool.components);
+    property var cardComponent: CardCreatorCache.getCardComponent(cardTool.template, cardTool.components, false);
 
     // FIXME: Saviq
     // Only way for the card below to actually be laid out completely.
@@ -139,29 +139,6 @@
     readonly property int headerHeight: cardLoader.item ? cardLoader.item.headerHeight : 0
     property size artShapeSize: cardLoader.item ? cardLoader.item.artShapeSize : 0
 
-    /*!
-     \brief Desired alignment of title
-     */
-    readonly property int titleAlignment: {
-        if (template["card-layout"] === "horizontal"
-            || typeof components["title"] !== "object"
-            || components["title"]["align"] === "left") return Text.AlignLeft;
-
-        var keys = ["mascot", "emblem", "subtitle", "attributes", "summary"];
-
-        for (var key in keys) {
-            key = keys[key];
-            try {
-                if (typeof components[key] === "string"
-                    || typeof components[key]["field"] === "string") return Text.AlignLeft;
-            } catch (e) {
-                continue;
-            }
-        }
-
-        return Text.AlignHCenter;
-    }
-
     QtObject {
         id: carouselTool
 
@@ -216,10 +193,9 @@
             "summary": "—\n—\n—\n—\n—",
             "attributes": attributesModel.model
         }
-        sourceComponent: cardTool.cardComponent
+        sourceComponent: CardCreatorCache.getCardComponent(cardTool.template, cardTool.components, true);
         onLoaded: {
             item.objectName = "cardToolCard";
-            item.asynchronous = false;
             item.width = Qt.binding(function() { return cardTool.cardWidth !== -1 ? cardTool.cardWidth : item.implicitWidth; });
             item.height = Qt.binding(function() { return cardTool.cardHeight !== -1 ? cardTool.cardHeight : item.implicitHeight; });
         }

=== modified file 'qml/Dash/CardVerticalJournal.qml'
--- qml/Dash/CardVerticalJournal.qml	2016-01-28 14:11:14 +0000
+++ qml/Dash/CardVerticalJournal.qml	2016-03-11 11:34:41 +0000
@@ -72,7 +72,6 @@
                 item.fixedArtShapeSize = Qt.binding(function() { return cardTool.artShapeSize; });
                 item.fixedHeaderHeight = Qt.binding(function() { return cardTool.headerHeight; });
                 item.cardData = Qt.binding(function() { return model; });
-                item.titleAlignment = Qt.binding(function() { return cardTool.titleAlignment; });
                 item.scopeStyle = root.scopeStyle;
             }
             Connections {

=== modified file 'qml/Dash/Dash.qml'
--- qml/Dash/Dash.qml	2015-11-19 16:55:31 +0000
+++ qml/Dash/Dash.qml	2016-03-11 11:34:41 +0000
@@ -37,6 +37,7 @@
     }
 
     property bool windowActive: window.active
+    property bool showOverlayScope: false
 
     DashCommunicatorService {
         objectName: "dashCommunicatorService"
@@ -80,7 +81,7 @@
             return
         }
 
-        closeOverlayScope();
+        dash.showOverlayScope = false;
 
         dashContent.closePreview();
 
@@ -93,12 +94,6 @@
         dashContent.setCurrentScopeAtIndex(scopeIndex, animate, reset)
     }
 
-    function closeOverlayScope() {
-        if (dashContent.x != 0) {
-            dashContent.x = 0;
-        }
-    }
-
     Scopes {
         id: scopes
     }
@@ -133,12 +128,13 @@
         height: dash.height
         scopes: scopes
         visible: x != -width
+        x: dash.showOverlayScope ? -width : 0
         onGotoScope: {
             dash.setCurrentScope(scopeId, true, false);
         }
         onOpenScope: {
             scopeItem.scope = scope;
-            x = -width;
+            dash.showOverlayScope = true;
         }
         Behavior on x {
             UbuntuNumberAnimation {
@@ -207,7 +203,7 @@
                 bottomEdgeController.enableAnimation = true;
                 bottomEdgeController.progress = 0;
                 scopeItem.scope = scope;
-                dashContent.x = -dashContent.width;
+                dash.showOverlayScope = true;
             }
             onGotoScope: {
                 bottomEdgeController.enableAnimation = true;
@@ -226,7 +222,7 @@
         id: scopeItem
         objectName: "dashTempScopeItem"
 
-        x: dashContent.x + width
+        x: dash.showOverlayScope ? 0 : width
         y: dashContent.y
         width: parent.width
         height: parent.height
@@ -234,7 +230,7 @@
         hasBackAction: true
         isCurrent: visible
         onBackClicked: {
-            closeOverlayScope();
+            dash.showOverlayScope = false;
             closePreview();
         }
 
@@ -250,6 +246,10 @@
                 scopes.closeScope(oldScope);
             }
         }
+
+        Behavior on x {
+            UbuntuNumberAnimation { }
+        }
     }
 
     Rectangle {

=== modified file 'qml/Dash/GenericScopeView.qml'
--- qml/Dash/GenericScopeView.qml	2016-02-19 11:50:12 +0000
+++ qml/Dash/GenericScopeView.qml	2016-03-11 11:34:41 +0000
@@ -370,6 +370,8 @@
                             } else {
                                 cardTool.cardWidth = units.gu(10);
                             }
+                        } else {
+                            cardTool.cardWidth = units.gu(12);
                         }
                         item.minimumHorizontalSpacing = item.defaultMinimumHorizontalSpacing;
                     }

=== modified file 'qml/Dash/Previews/PreviewHeader.qml'
--- qml/Dash/Previews/PreviewHeader.qml	2016-01-08 14:19:08 +0000
+++ qml/Dash/Previews/PreviewHeader.qml	2016-03-11 11:34:41 +0000
@@ -25,6 +25,7 @@
  *  The mascot fall back image comes in widgetData["fallback"]
  *  The subtitle comes in widgetData["subtitle"]
  *  The attributes comes in widgetData["attributes"]
+ *  The emblem comes in widgetData["emblem"]
  */
 
 PreviewWidget {
@@ -40,6 +41,7 @@
         readonly property string title: root.widgetData["title"] || ""
         readonly property string subtitle: root.widgetData["subtitle"] || ""
         readonly property var attributes: root.widgetData["attributes"] || null
+        readonly property url emblem: root.widgetData["emblem"] || ""
         readonly property color fontColor: root.scopeStyle ? root.scopeStyle.foreground : theme.palette.normal.baseText
 
         // Rewire the source since we may have unwired it on onStatusChanged
@@ -98,16 +100,42 @@
                 spacing: units.dp(2)
                 anchors.verticalCenter: parent.verticalCenter
 
-                Label {
-                    id: titleLabel
-                    objectName: "titleLabel"
+                Item {
                     anchors { left: parent.left; right: parent.right }
-                    elide: Text.ElideRight
-                    font.weight: Font.Normal
-                    fontSize: "large"
-                    wrapMode: Text.Wrap
-                    color: headerRoot.fontColor
-                    text: headerRoot.title
+                    height: titleLabel.height
+
+                    Label {
+                        id: titleLabel
+                        objectName: "titleLabel"
+                        anchors {
+                            left: parent.left;
+                            right: iconLoader.right
+                            rightMargin: iconLoader.width > 0 ? units.gu(0.5) : 0
+                        }
+                        elide: Text.ElideRight
+                        font.weight: Font.Normal
+                        fontSize: "large"
+                        wrapMode: Text.Wrap
+                        color: headerRoot.fontColor
+                        text: headerRoot.title
+                    }
+
+                    Loader {
+                        id: iconLoader
+                        active: headerRoot.emblem != ""
+                        anchors {
+                            bottom: titleLabel.baseline
+                            right: parent.right
+                        }
+                        sourceComponent: Icon {
+                            objectName: "emblemIcon"
+                            source: headerRoot.emblem
+                            color: headerRoot.fontColor
+                            height: source != "" ? titleLabel.font.pixelSize : 0
+                            // FIXME Workaround for bug https://bugs.launchpad.net/ubuntu/+source/ubuntu-ui-toolkit/+bug/1421293
+                            width: implicitWidth > 0 && implicitHeight > 0 ? (implicitWidth / implicitHeight * height) : implicitWidth
+                        }
+                    }
                 }
 
                 Loader {

=== modified file 'qml/Dash/Previews/PreviewOverlay.qml'
--- qml/Dash/Previews/PreviewOverlay.qml	2015-07-15 15:07:19 +0000
+++ qml/Dash/Previews/PreviewOverlay.qml	2016-03-11 11:34:41 +0000
@@ -158,7 +158,7 @@
                 anchors.centerIn: parent
                 width: units.gu(2.5)
                 height: width
-                color: theme.palette.normal.foregroundText
+                color: "white"
                 name: "close"
             }
         }

=== modified file 'qml/Dash/Previews/PreviewSharing.qml'
--- qml/Dash/Previews/PreviewSharing.qml	2015-12-17 15:42:39 +0000
+++ qml/Dash/Previews/PreviewSharing.qml	2016-03-11 11:34:41 +0000
@@ -44,6 +44,22 @@
         }
     }
 
+    function createExportedItems(url) {
+        var items = new Array();
+        if (typeof url === "string") {
+            var exportItem = exportItemComponent.createObject();
+            exportItem.url = url;
+            items.push(exportItem);
+        } else {
+            for (var i = 0; i < url.length; i++) {
+                var exportItem = exportItemComponent.createObject();
+                exportItem.url = url[i];
+                items.push(exportItem);
+            }
+        }
+        return items;
+    }
+
     Component {
         id: exportItemComponent
         ContentItem {
@@ -76,13 +92,7 @@
             onPeerSelected: {
                 var transfer = peer.request();
                 if (transfer.state === ContentTransfer.InProgress) {
-                    var items = new Array();
-                    for (var i = 0; i < url.length; i++) {
-                        var exportItem = exportItemComponent.createObject();
-                        exportItem.url = url[i];
-                        items.push(exportItem);
-                    }
-                    transfer.items = items;
+                    transfer.items = createExportedItems(url);
                     transfer.state = ContentTransfer.Charged;
                 }
                 peerPicker.visible = false;

=== modified file 'qml/Dash/ScopesListCategoryItem.qml'
--- qml/Dash/ScopesListCategoryItem.qml	2015-11-04 14:57:13 +0000
+++ qml/Dash/ScopesListCategoryItem.qml	2016-03-11 11:34:41 +0000
@@ -18,7 +18,7 @@
 import QtQuick.Layouts 1.1
 import Ubuntu.Components 1.3
 
-MouseArea {
+AbstractButton {
     id: root
 
     signal requestFavorite(string scopeId, bool favorite)
@@ -84,15 +84,19 @@
                 visible: text != ""
             }
         }
-        MouseArea {
+        AbstractButton {
             id: starArea
             objectName: "starArea"
             height: parent.height
             width: height
             anchors.right: parent.right
             onClicked: if (!editMode) root.requestFavorite(model.scopeId, !isFavorite);
-            onPressed: if (editMode) root.handlePressed(starArea);
-            onReleased: if (editMode) root.handleReleased(starArea);
+            onPressedChanged: {
+                if (editMode) {
+                    if (pressed) root.handlePressed(starArea.__mouseArea);
+                    else root.handleReleased(starArea.__mouseArea);
+                }
+            }
             visible: editMode || showStar
             Icon {
                 id: star

=== modified file 'qml/DeviceConfiguration.qml'
--- qml/DeviceConfiguration.qml	2015-12-01 13:56:54 +0000
+++ qml/DeviceConfiguration.qml	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
  */
 
 import QtQuick 2.4
+import Utils 0.1
 
 QtObject {
     id: root
@@ -34,57 +35,83 @@
 
     readonly property alias category: priv.category
 
+    readonly property var deviceConfigParser: DeviceConfigParser {
+        name: root.name
+    }
+
     readonly property var priv: StateGroup {
         id: priv
 
-        property int primaryOrientation: root.useNativeOrientation
-
-        property int supportedOrientations: Qt.PortraitOrientation
-                                          | Qt.InvertedPortraitOrientation
-                                          | Qt.LandscapeOrientation
-                                          | Qt.InvertedLandscapeOrientation
-
-        property int landscapeOrientation: Qt.LandscapeOrientation
-        property int invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
-        property int portraitOrientation: Qt.PortraitOrientation
-        property int invertedPortraitOrientation: Qt.InvertedPortraitOrientation
-
-        // Supported values so far:
-        // "phone", "tablet" or "desktop"
-        property string category: "phone"
+        property int primaryOrientation: deviceConfigParser.primaryOrientation == Qt.PrimaryOrientation ?
+                                             root.useNativeOrientation : deviceConfigParser.primaryOrientation
+
+        property int supportedOrientations: deviceConfigParser.supportedOrientations
+
+        property int landscapeOrientation: deviceConfigParser.landscapeOrientation
+        property int invertedLandscapeOrientation: deviceConfigParser.invertedLandscapeOrientation
+        property int portraitOrientation: deviceConfigParser.portraitOrientation
+        property int invertedPortraitOrientation: deviceConfigParser.invertedPortraitOrientation
+        property string category: deviceConfigParser.category
 
         states: [
             State {
                 name: "mako"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: root.useNativeOrientation
                     supportedOrientations: Qt.PortraitOrientation
                                          | Qt.LandscapeOrientation
                                          | Qt.InvertedLandscapeOrientation
+                    landscapeOrientation: Qt.LandscapeOrientation
+                    invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
+                    category: "phone"
                 }
             },
             State {
                 name: "krillin"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: root.useNativeOrientation
                     supportedOrientations: Qt.PortraitOrientation
                                          | Qt.LandscapeOrientation
                                          | Qt.InvertedLandscapeOrientation
+                    landscapeOrientation: Qt.LandscapeOrientation
+                    invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
+                    category: "phone"
                 }
             },
             State {
                 name: "arale"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: root.useNativeOrientation
                     supportedOrientations: Qt.PortraitOrientation
                                          | Qt.LandscapeOrientation
                                          | Qt.InvertedLandscapeOrientation
+                    landscapeOrientation: Qt.LandscapeOrientation
+                    invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
+                    category: "phone"
                 }
             },
             State {
                 name: "manta"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: root.useNativeOrientation
+                    supportedOrientations: Qt.PortraitOrientation
+                                         | Qt.InvertedPortraitOrientation
+                                         | Qt.LandscapeOrientation
+                                         | Qt.InvertedLandscapeOrientation
+                    landscapeOrientation: Qt.LandscapeOrientation
+                    invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
                     category: "tablet"
                 }
             },
@@ -92,9 +119,15 @@
                 name: "flo"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: Qt.InvertedLandscapeOrientation
+                    supportedOrientations: Qt.PortraitOrientation
+                                         | Qt.InvertedPortraitOrientation
+                                         | Qt.LandscapeOrientation
+                                         | Qt.InvertedLandscapeOrientation
                     landscapeOrientation: Qt.InvertedLandscapeOrientation
                     invertedLandscapeOrientation: Qt.LandscapeOrientation
-                    primaryOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
                     category: "tablet"
                 }
             },
@@ -102,8 +135,13 @@
                 name: "desktop"
                 PropertyChanges {
                     target: priv
+                    primaryOrientation: root.useNativeOrientation
+                    supportedOrientations: root.useNativeOrientation
+                    landscapeOrientation: Qt.LandscapeOrientation
+                    invertedLandscapeOrientation: Qt.InvertedLandscapeOrientation
+                    portraitOrientation: Qt.PortraitOrientation
+                    invertedPortraitOrientation: Qt.InvertedPortraitOrientation
                     category: "desktop"
-                    supportedOrientations: root.useNativeOrientation
                 }
             }
         ]

=== modified file 'qml/DisabledScreenNotice.qml'
--- qml/DisabledScreenNotice.qml	2016-01-26 15:29:54 +0000
+++ qml/DisabledScreenNotice.qml	2016-03-11 11:34:41 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.4
 import QtQuick.Layouts 1.1
 import Ubuntu.Components 1.3
+import Unity.Session 0.1
 import QtQuick.Window 2.2
 import "Components"
 
@@ -25,19 +26,36 @@
 
     property bool infoNoteDisplayed: true
 
-    WallpaperResolver {
-        width: root.width
-        id: wallpaperResolver
+    // For testing
+    property var screen: Screen
+    property var orientationLock: OrientationLock
+
+    DeviceConfiguration {
+        id: deviceConfiguration
+        name: applicationArguments.deviceName
     }
 
     Item {
         id: contentContainer
+        objectName: "contentContainer"
         anchors.centerIn: parent
         height: rotation == 90 || rotation == 270 ? parent.width : parent.height
         width: rotation == 90 || rotation == 270 ? parent.height : parent.width
 
+        property int savedOrientation: deviceConfiguration.primaryOrientation == deviceConfiguration.useNativeOrientation
+                                       ? (root.width > root.height ? Qt.LandscapeOrientation : Qt.PortraitOrientation)
+                                       : deviceConfiguration.primaryOrientation
+
         rotation: {
-            switch (Screen.orientation) {
+            var usedOrientation = root.screen.orientation;
+
+            if (root.orientationLock.enabled) {
+                usedOrientation = savedOrientation;
+            }
+
+            savedOrientation = usedOrientation;
+
+            switch (usedOrientation) {
             case Qt.PortraitOrientation:
                 return 0;
             case Qt.LandscapeOrientation:
@@ -47,6 +65,8 @@
             case Qt.InvertedLandscapeOrientation:
                 return 90;
             }
+
+            return 0;
         }
         transformOrigin: Item.Center
 
@@ -60,9 +80,9 @@
             }
         }
 
-        Image {
+        Rectangle {
             anchors.fill: parent
-            source: wallpaperResolver.background
+            color: "#3b3b3b"
         }
 
         Item {
@@ -74,22 +94,26 @@
                 UbuntuNumberAnimation { }
             }
 
-            Rectangle {
-                anchors.fill: parent
-                color: "black"
-                opacity: 0.4
-            }
-
-            Label {
-                id: text
+            Column {
                 anchors.centerIn: parent
                 width: parent.width - units.gu(8)
-                text: i18n.tr("Your device is now connected to an external display. Use this screen as a touch pad to interact with the mouse.")
-                color: "white"
-                horizontalAlignment: Text.AlignHCenter
-                verticalAlignment: Text.AlignVCenter
-                fontSize: "x-large"
-                wrapMode: Text.Wrap
+                spacing: units.gu(4)
+
+                Label {
+                    id: text
+                    text: i18n.tr("Your device is now connected to an external display. Use this screen as a touch pad to interact with the pointer.")
+                    color: "white"
+                    width: parent.width
+                    fontSize: "large"
+                    wrapMode: Text.Wrap
+                }
+                Icon {
+                    height: units.gu(8)
+                    width: height
+                    name: "input-touchpad-symbolic"
+                    color: "white"
+                    anchors.horizontalCenter: parent.horizontalCenter
+                }
             }
         }
 

=== modified file 'qml/Greeter/CoverPage.qml'
--- qml/Greeter/CoverPage.qml	2015-07-15 15:07:19 +0000
+++ qml/Greeter/CoverPage.qml	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013,2014,2015 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,6 +34,7 @@
     readonly property real showProgress: MathUtils.clamp((width - Math.abs(x)) / width, 0, 1)
 
     signal tease()
+    signal clicked()
 
     function hideRight() {
         d.forceRightOnNextHideAnimation = true;
@@ -55,7 +56,17 @@
     // instead, we can get a little extra horizontal push by using transforms.
     transform: Translate { id: translation; x: root.draggable ? launcherOffset : 0 }
 
-    MouseArea { anchors.fill: parent; }
+    // Eat events elsewhere on the coverpage, except mouse clicks which we pass
+    // up (they are used in the NarrowView to hide the cover page)
+    MouseArea {
+        anchors.fill: parent
+        onClicked: root.clicked()
+
+        MultiPointTouchArea {
+            anchors.fill: parent
+            mouseEnabled: false
+        }
+    }
 
     Rectangle {
         // In case background fails to load

=== modified file 'qml/Greeter/Infographics.qml'
--- qml/Greeter/Infographics.qml	2015-09-29 12:28:10 +0000
+++ qml/Greeter/Infographics.qml	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -402,6 +402,7 @@
 
     MouseArea {
         anchors.fill: dataCircle
+        enabled: notification.text != ""
 
         onDoubleClicked: {
             if (!d.animating) {

=== modified file 'qml/Greeter/NarrowView.qml'
--- qml/Greeter/NarrowView.qml	2015-11-19 16:55:31 +0000
+++ qml/Greeter/NarrowView.qml	2016-03-11 11:34:41 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Canonical, Ltd.
+ * Copyright (C) 2015-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -125,6 +125,18 @@
         onCancel: coverPage.show()
         onEmergencyCall: root.emergencyCall()
 
+        onEnabledChanged: {
+            if (enabled) {
+                lockscreen.forceActiveFocus();
+            }
+        }
+
+        onVisibleChanged: {
+            if (visible) {
+                lockscreen.forceActiveFocus();
+            }
+        }
+
         function maybeShow() {
             if (root.locked && !shown) {
                 showNow();
@@ -145,6 +157,7 @@
         width: parent.width
         background: root.background
         onTease: root.tease()
+        onClicked: hide()
 
         onShowProgressChanged: {
             if (showProgress === 1) {

=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml	2016-01-19 15:26:15 +0000
+++ qml/Launcher/Launcher.qml	2016-03-11 11:34:41 +0000
@@ -19,21 +19,26 @@
 import Ubuntu.Components 1.3
 import Ubuntu.Gestures 0.1
 import Unity.Launcher 0.1
+import GlobalShortcut 1.0
 
-Item {
+FocusScope {
     id: root
 
     property bool autohideEnabled: false
+    property bool lockedVisible: false
     property bool available: true // can be used to disable all interactions
     property alias inverted: panel.inverted
     property bool shadeBackground: true // can be used to disable background shade when launcher is visible
 
-    property int panelWidth: units.gu(8)
+    property int panelWidth: units.gu(10)
     property int dragAreaWidth: units.gu(1)
     property int minimizeDistance: units.gu(26)
     property real progress: dragArea.dragging && dragArea.touchX > panelWidth ?
                                 (width * (dragArea.touchX-panelWidth) / (width - panelWidth)) : 0
 
+    property bool superPressed: false
+    property bool superTabPressed: false
+
     readonly property bool dragging: dragArea.dragging
     readonly property real dragDistance: dragArea.dragging ? dragArea.touchX : 0
     readonly property real visibleWidth: panel.width + panel.x
@@ -57,12 +62,55 @@
         }
     }
 
+    onSuperPressedChanged: {
+        if (superPressed) {
+            superPressTimer.start();
+            superLongPressTimer.start();
+        } else {
+            superPressTimer.stop();
+            superLongPressTimer.stop();
+            launcher.switchToNextState("");
+            panel.shortcutHintsShown = false;
+        }
+    }
+
+    onSuperTabPressedChanged: {
+        if (superTabPressed) {
+            switchToNextState("visible")
+            panel.highlightIndex = -1;
+            root.focus = true;
+            superPressTimer.stop();
+            superLongPressTimer.stop();
+        } else {
+            if (panel.highlightIndex == -1) {
+                showDashHome();
+            } else if (panel.highlightIndex >= 0){
+                launcherApplicationSelected(LauncherModel.get(panel.highlightIndex).appId);
+            }
+            panel.highlightIndex = -2;
+            switchToNextState("");
+            root.focus = false;
+        }
+    }
+
+    onLockedVisibleChanged: {
+        if (lockedVisible && state == "") {
+            panel.dismissTimer.stop();
+            fadeOutAnimation.stop();
+            switchToNextState("visible")
+        } else if (!lockedVisible && state == "visible") {
+            hide();
+        }
+    }
+
     function hide() {
         switchToNextState("")
     }
 
     function fadeOut() {
-        fadeOutAnimation.start();
+        if (!root.lockedVisible) {
+            fadeOutAnimation.start();
+        }
     }
 
     function switchToNextState(state) {
@@ -90,6 +138,77 @@
         }
     }
 
+    function openForKeyboardNavigation() {
+        panel.highlightIndex = -1; // The BFB
+        root.focus = true;
+        switchToNextState("visible")
+    }
+
+    Keys.onPressed: {
+        switch (event.key) {
+        case Qt.Key_Backtab:
+            panel.highlightPrevious();
+            event.accepted = true;
+            break;
+        case Qt.Key_Up:
+            if (root.inverted) {
+                panel.highlightNext()
+            } else {
+                panel.highlightPrevious();
+            }
+            event.accepted = true;
+            break;
+        case Qt.Key_Tab:
+            panel.highlightNext();
+            event.accepted = true;
+            break;
+        case Qt.Key_Down:
+            if (root.inverted) {
+                panel.highlightPrevious();
+            } else {
+                panel.highlightNext();
+            }
+            event.accepted = true;
+            break;
+        case Qt.Key_Right:
+            panel.openQuicklist(panel.highlightIndex)
+            event.accepted = true;
+            break;
+        case Qt.Key_Escape:
+            panel.highlightIndex = -2;
+            // Falling through intentionally
+        case Qt.Key_Enter:
+        case Qt.Key_Return:
+        case Qt.Key_Space:
+            if (panel.highlightIndex == -1) {
+                showDashHome();
+            } else if (panel.highlightIndex >= 0) {
+                launcherApplicationSelected(LauncherModel.get(panel.highlightIndex).appId);
+            }
+            root.hide();
+            panel.highlightIndex = -2
+            event.accepted = true;
+            root.focus = false;
+        }
+    }
+
+    Timer {
+        id: superPressTimer
+        interval: 200
+        onTriggered: {
+            switchToNextState("visible")
+        }
+    }
+
+    Timer {
+        id: superLongPressTimer
+        interval: 1000
+        onTriggered: {
+            switchToNextState("visible")
+            panel.shortcutHintsShown = true;
+        }
+    }
+
     Timer {
         id: teaseTimer
         interval: mode == "teasing" ? 200 : 300
@@ -106,6 +225,13 @@
         interval: 1
         property string nextState: ""
         onTriggered: {
+            if (root.lockedVisible && nextState == "") {
+                // Due to binding updates when switching between modes
+                // it could happen that our request to show will be overwritten
+                // with a hide request. Rewrite it when we know hiding is not allowed.
+                nextState = "visible"
+            }
+
             // switching to an intermediate state here to make sure all the
             // values are restored, even if we were already in the target state
             root.state = "tmp"
@@ -151,7 +277,7 @@
 
     MouseArea {
         id: launcherDragArea
-        enabled: root.available && (root.state == "visible" || root.state == "visibleTemporary")
+        enabled: root.available && (root.state == "visible" || root.state == "visibleTemporary") && !root.lockedVisible
         anchors.fill: panel
         anchors.rightMargin: -units.gu(2)
         drag {
@@ -172,9 +298,10 @@
     InverseMouseArea {
         id: closeMouseArea
         anchors.fill: panel
-        enabled: root.shadeBackground && root.state == "visible"
+        enabled: root.shadeBackground && root.state == "visible" && (!root.lockedVisible || panel.highlightIndex >= -1)
         visible: enabled
         onPressed: {
+            panel.highlightIndex = -2
             root.hide();
         }
     }
@@ -183,7 +310,7 @@
         id: backgroundShade
         anchors.fill: parent
         color: "black"
-        opacity: root.shadeBackground && root.state == "visible" ? 0.6 : 0
+        opacity: root.shadeBackground && root.state == "visible" && !root.lockedVisible ? 0.6 : 0
 
         Behavior on opacity { NumberAnimation { duration: UbuntuAnimation.BriskDuration } }
     }
@@ -202,8 +329,8 @@
                     rotation: -90
                     anchors.centerIn: parent
                     gradient: Gradient {
-                        GradientStop { position: 0.0; color: panel.color}
-                        GradientStop { position: 1.0; color: Qt.rgba(panel.r,panel.g,panel.b,0)}
+                        GradientStop { position: 0.0; color: Qt.rgba(panel.color.r, panel.color.g, panel.color.b, .5)}
+                        GradientStop { position: 1.0; color: Qt.rgba(panel.color.r,panel.color.g,panel.color.b,0)}
                     }
                 }
             }
@@ -227,7 +354,7 @@
         Connections {
             target: panel.dismissTimer
             onTriggered: {
-                if (root.autohideEnabled) {
+                if (root.autohideEnabled && !root.lockedVisible) {
                     if (!panel.preventHiding) {
                         root.state = ""
                     } else {
@@ -240,11 +367,11 @@
         property bool animate: true
 
         onApplicationSelected: {
-            root.state = ""
+            root.hide();
             launcherApplicationSelected(appId)
         }
         onShowDashHome: {
-            root.state = ""
+            root.hide();
             root.showDashHome();
         }
 
@@ -254,6 +381,12 @@
             }
         }
 
+        onKbdNavigationCancelled: {
+            panel.highlightIndex = -2;
+            root.hide();
+            root.focus = false;
+        }
+
         Behavior on x {
             enabled: !dragArea.dragging && !launcherDragArea.drag.active && panel.animate;
             NumberAnimation {

=== modified file 'qml/Launcher/LauncherDelegate.qml'
--- qml/Launcher/LauncherDelegate.qml	2015-11-19 16:55:31 +0000
+++ qml/Launcher/LauncherDelegate.qml	2016-03-11 11:34:41 +0000
@@ -20,6 +20,7 @@
 Item {
     id: root
 
+    property int itemIndex: 0
     property string iconName
     property int count: 0
     property bool countVisible: false
@@ -29,10 +30,12 @@
     property real maxAngle: 0
     property bool inverted: false
     property bool alerting: false
-    readonly property alias wiggling: wiggleAnim.running
+    property bool highlighted: false
+    property bool shortcutHintShown: false
 
     readonly property int effectiveHeight: Math.cos(angle * Math.PI / 180) * itemHeight
     readonly property real foldedHeight: Math.cos(maxAngle * Math.PI / 180) * itemHeight
+    readonly property alias wiggling: wiggleAnim.running
 
     property int itemWidth
     property int itemHeight
@@ -121,20 +124,32 @@
 
     Item {
         id: iconItem
-        width: parent.itemWidth + units.gu(1)
+        width: root.width
         height: parent.itemHeight + units.gu(1)
         anchors.centerIn: parent
 
+        Image {
+            objectName: "focusRing"
+            anchors.centerIn: iconShape
+            height: width * 15 / 16
+            width: iconShape.width + units.gu(1)
+            source: "graphics/launcher-app-focus-ring.svg"
+            sourceSize.width: width
+            sourceSize.height: height
+            visible: root.highlighted
+        }
+
         ProportionalShape {
             id: iconShape
             anchors.centerIn: parent
-            width: parent.width - units.gu(2)
+            width: root.itemWidth
             aspect: UbuntuShape.DropShadow
             source: Image {
                 id: iconImage
                 sourceSize.width: iconShape.width
                 sourceSize.height: iconShape.height
                 source: root.iconName
+                cache: false // see lpbug#1543290 why no cache
             }
         }
 
@@ -144,7 +159,8 @@
             anchors {
                 right: parent.right
                 bottom: parent.bottom
-                margins: units.dp(3)
+                rightMargin: (iconItem.width - root.itemWidth) / 2 - units.dp(2)
+                margins: units.dp(5)
             }
             width: Math.min(root.itemWidth, Math.max(units.gu(2), countLabel.implicitWidth + units.gu(1)))
             height: units.gu(2)
@@ -172,16 +188,11 @@
             id: progressOverlay
             objectName: "progressOverlay"
 
-            anchors {
-                left: iconItem.left
-                right: iconItem.right
-                verticalCenter: parent.verticalCenter
-                leftMargin: units.gu(1.5)
-                rightMargin: units.gu(1.5)
-            }
+            anchors.centerIn: parent
+            width: root.itemWidth * .8
             height: units.gu(1)
             visible: root.progress > -1
-            color: UbuntuColors.darkGrey
+            backgroundColor: UbuntuColors.darkGrey
             borderSource: "none"
 
             Item {
@@ -199,32 +210,56 @@
                         top: parent.top
                         bottom: parent.bottom
                     }
-                    color: "white"
+                    backgroundColor: "white"
                     borderSource: "none"
                     width: progressOverlay.width
                 }
             }
         }
 
-        Image {
-            objectName: "runningHighlight"
+        Column {
             anchors {
                 left: parent.left
                 verticalCenter: parent.verticalCenter
             }
-            visible: root.itemRunning
-            rotation: 180
-            source: "graphics/focused_app_arrow.png"
+            spacing: units.gu(.5)
+            Repeater {
+                model: 1 // TODO: This should be "Math.min(3, app.surfaceCount)" once we have multiple surfaces
+                Rectangle {
+                    objectName: "runningHighlight" + index
+                    width: units.gu(0.25)
+                    height: units.gu(.5)
+                    color: "white"
+                    visible: root.itemRunning
+                }
+            }
         }
 
-        Image {
+        Rectangle {
             objectName: "focusedHighlight"
             anchors {
                 right: parent.right
                 verticalCenter: parent.verticalCenter
             }
+            width: units.gu(0.25)
+            height: units.gu(.5)
+            color: "white"
             visible: root.itemFocused
-            source: "graphics/focused_app_arrow.png"
+        }
+
+        Rectangle {
+            objectName: "shortcutHint"
+            anchors.centerIn: parent
+            width: units.gu(3)
+            height: width
+            color: "#E0292929"
+            visible: root.shortcutHintShown
+            Label {
+                anchors.centerIn: parent
+                text: (itemIndex + 1) % 10
+                color: "white"
+                font.weight: Font.DemiBold
+            }
         }
     }
 

=== modified file 'qml/Launcher/LauncherPanel.qml'
--- qml/Launcher/LauncherPanel.qml	2016-01-11 17:38:19 +0000
+++ qml/Launcher/LauncherPanel.qml	2016-03-11 11:34:41 +0000
@@ -19,12 +19,13 @@
 import Ubuntu.Components.ListItems 1.3 as ListItems
 import Unity.Launcher 0.1
 import Ubuntu.Components.Popups 1.3
+import GlobalShortcut 1.0
 import "../Components/ListItems"
 import "../Components/"
 
 Rectangle {
     id: root
-    color: "#B2000000"
+    color: "#E0292929"
 
     rotation: inverted ? 180 : 0
 
@@ -33,11 +34,13 @@
     property bool dragging: false
     property bool moving: launcherListView.moving || launcherListView.flicking
     property bool preventHiding: moving || dndArea.draggedIndex >= 0 || quickList.state === "open" || dndArea.pressed
-                              || mouseEventEater.containsMouse || dashItem.hovered
-    property int highlightIndex: -1
+                                 || mouseEventEater.containsMouse || dashItem.hovered
+    property int highlightIndex: -2
+    property bool shortcutHintsShown: false
 
     signal applicationSelected(string appId)
     signal showDashHome()
+    signal kbdNavigationCancelled()
 
     onXChanged: {
         if (quickList.state == "open") {
@@ -45,6 +48,26 @@
         }
     }
 
+    function highlightNext() {
+        highlightIndex++;
+        if (highlightIndex >= launcherListView.count) {
+            highlightIndex = -1;
+        }
+        launcherListView.moveToIndex(Math.max(highlightIndex, 0));
+    }
+    function highlightPrevious() {
+        highlightIndex--;
+        if (highlightIndex <= -2) {
+            highlightIndex = launcherListView.count - 1;
+        }
+        launcherListView.moveToIndex(Math.max(highlightIndex, 0));
+    }
+    function openQuicklist(index) {
+        quickList.open(index);
+        quickList.selectedIndex = 0;
+        quickList.focus = true;
+    }
+
     MouseArea {
         id: mouseEventEater
         anchors.fill: parent
@@ -57,24 +80,16 @@
             fill: parent
         }
 
-        Item {
+        Rectangle {
             objectName: "buttonShowDashHome"
             width: parent.width
-            height: units.gu(7)
-            clip: true
-
-            UbuntuShape {
-                anchors {
-                    fill: parent
-                    topMargin: -units.gu(2)
-                }
-                aspect: UbuntuShape.Flat
-                backgroundColor: UbuntuColors.orange
-            }
+            height: width * .9
+            color: UbuntuColors.orange
+            readonly property bool highlighted: root.highlightIndex == -1;
 
             Image {
                 objectName: "dashItem"
-                width: units.gu(5)
+                width: parent.width * .6
                 height: width
                 anchors.centerIn: parent
                 source: "graphics/home.png"
@@ -85,6 +100,14 @@
                 anchors.fill: parent
                 onClicked: root.showDashHome()
             }
+            Rectangle {
+                objectName: "bfbFocusHighlight"
+                anchors.fill: parent
+                border.color: "white"
+                border.width: units.dp(1)
+                color: "transparent"
+                visible: parent.highlighted
+            }
         }
 
         Item {
@@ -102,10 +125,8 @@
                     objectName: "launcherListView"
                     anchors {
                         fill: parent
-                        topMargin: -extensionSize + units.gu(0.5)
-                        bottomMargin: -extensionSize + units.gu(1)
-                        leftMargin: units.gu(0.5)
-                        rightMargin: units.gu(0.5)
+                        topMargin: -extensionSize + width * .15
+                        bottomMargin: -extensionSize + width * .15
                     }
                     topMargin: extensionSize
                     bottomMargin: extensionSize
@@ -140,11 +161,11 @@
                     }
 
                     // The height of the area where icons start getting folded
-                    property int foldingStartHeight: units.gu(6.5)
+                    property int foldingStartHeight: itemHeight
                     // The height of the area where the items reach the final folding angle
                     property int foldingStopHeight: foldingStartHeight - itemHeight - spacing
-                    property int itemWidth: units.gu(7)
-                    property int itemHeight: units.gu(6.5)
+                    property int itemWidth: width * .75
+                    property int itemHeight: itemWidth * 15 / 16 + units.gu(1)
                     property int clickFlickSpeed: units.gu(60)
                     property int draggedIndex: dndArea.draggedIndex
                     property real realContentY: contentY - originY + topMargin
@@ -172,12 +193,24 @@
 
                     UbuntuNumberAnimation {
                         id: moveAnimation
+                        objectName: "moveAnimation"
                         target: launcherListView
                         property: "contentY"
                         function moveTo(contentY) {
                             from = launcherListView.contentY;
                             to = contentY;
-                            start();
+                            restart();
+                        }
+                    }
+                    function moveToIndex(index) {
+                        var totalItemHeight = launcherListView.itemHeight + launcherListView.spacing
+                        var itemPosition = index * totalItemHeight;
+                        var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
+                        var distanceToEnd = index == 0 || index == launcherListView.count - 1 ? 0 : totalItemHeight
+                        if (itemPosition + totalItemHeight + distanceToEnd > launcherListView.contentY + launcherListView.originY + launcherListView.topMargin + height) {
+                            moveAnimation.moveTo(itemPosition + launcherListView.itemHeight - launcherListView.topMargin - height + distanceToEnd - launcherListView.originY);
+                        } else if (itemPosition - distanceToEnd < launcherListView.contentY - launcherListView.originY + launcherListView.topMargin) {
+                            moveAnimation.moveTo(itemPosition - distanceToEnd - launcherListView.topMargin + launcherListView.originY);
                         }
                     }
 
@@ -192,9 +225,10 @@
                         // the right app when running autopilot tests for
                         // multiple apps.
                         readonly property string appId: model.appId
+                        itemIndex: index
                         itemHeight: launcherListView.itemHeight
                         itemWidth: launcherListView.itemWidth
-                        width: itemWidth
+                        width: parent.width
                         height: itemHeight
                         iconName: model.icon
                         count: model.count
@@ -204,6 +238,8 @@
                         itemFocused: model.focused
                         inverted: root.inverted
                         alerting: model.alerting
+                        highlighted: root.highlightIndex == index
+                        shortcutHintShown: root.shortcutHintsShown && index <= 9
                         z: -Math.abs(offset)
                         maxAngle: 55
                         property bool dragging: false
@@ -241,14 +277,7 @@
                         onAlertingChanged: {
                             if(alerting) {
                                 if (!dragging && (launcherListView.peekingIndex === -1 || launcher.visibleWidth > 0)) {
-                                      var itemPosition = index * launcherListView.itemHeight;
-                                      var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
-                                      var distanceToEnd = index == 0 || index == launcherListView.count - 1 ? 0 : launcherListView.itemHeight
-                                      if (itemPosition + launcherListView.itemHeight + distanceToEnd > launcherListView.contentY + launcherListView.topMargin + height) {
-                                          moveAnimation.moveTo(itemPosition + launcherListView.itemHeight - launcherListView.topMargin - height + distanceToEnd);
-                                      } else if (itemPosition - distanceToEnd < launcherListView.contentY + launcherListView.topMargin) {
-                                          moveAnimation.moveTo(itemPosition - distanceToEnd - launcherListView.topMargin);
-                                      }
+                                    launcherListView.moveToIndex(index)
                                     if (!dragging && launcher.state !== "visible") {
                                         peekingAnimation.start()
                                     }
@@ -402,10 +431,7 @@
 
                             if (mouse.button & Qt.RightButton) { // context menu
                                 // Opening QuickList
-                                quickList.item = clickedItem;
-                                quickList.model = launcherListView.model.get(index).quickList;
-                                quickList.appId = launcherListView.model.get(index).appId;
-                                quickList.state = "open";
+                                quickList.open(index);
                                 return;
                             }
 
@@ -413,10 +439,8 @@
 
                             // First/last item do the scrolling at more than 12 degrees
                             if (index == 0 || index == launcherListView.count - 1) {
-                                if (clickedItem.angle > 12) {
-                                    launcherListView.flick(0, -launcherListView.clickFlickSpeed);
-                                } else if (clickedItem.angle < -12) {
-                                    launcherListView.flick(0, launcherListView.clickFlickSpeed);
+                                if (clickedItem.angle > 12 || clickedItem.angle < -12) {
+                                    launcherListView.moveToIndex(index);
                                 } else {
                                     root.applicationSelected(LauncherModel.get(index).appId);
                                 }
@@ -424,10 +448,8 @@
                             }
 
                             // the rest launches apps up to an angle of 30 degrees
-                            if (clickedItem.angle > 30) {
-                                launcherListView.flick(0, -launcherListView.clickFlickSpeed);
-                            } else if (clickedItem.angle < -30) {
-                                launcherListView.flick(0, launcherListView.clickFlickSpeed);
+                            if (clickedItem.angle > 30 || clickedItem.angle < -30) {
+                                launcherListView.moveToIndex(index);
                             } else {
                                 root.applicationSelected(LauncherModel.get(index).appId);
                             }
@@ -481,11 +503,7 @@
 
                             draggedIndex = Math.floor((mouse.y + launcherListView.realContentY) / launcherListView.realItemHeight);
 
-                            // Opening QuickList
-                            quickList.item = selectedItem;
-                            quickList.model = launcherListView.model.get(draggedIndex).quickList;
-                            quickList.appId = launcherListView.model.get(draggedIndex).appId;
-                            quickList.state = "open";
+                            quickList.open(draggedIndex)
 
                             launcherListView.interactive = false
 
@@ -644,7 +662,9 @@
         enabled: quickList.state == "open" || pressed
 
         onClicked: {
-            quickList.state = ""
+            quickList.state = "";
+            quickList.focus = false;
+            root.kbdNavigationCancelled();
         }
 
         // Forward for dragging to work when quickList is open
@@ -693,12 +713,60 @@
         property var model
         property string appId
         property var item
+        property int selectedIndex: -1
+
+        Keys.onPressed: {
+            switch (event.key) {
+            case Qt.Key_Down:
+                selectedIndex++;
+                if (selectedIndex >= popoverRepeater.count) {
+                    selectedIndex = 0;
+                }
+                event.accepted = true;
+                break;
+            case Qt.Key_Up:
+                selectedIndex--;
+                if (selectedIndex < 0) {
+                    selectedIndex = popoverRepeater.count - 1;
+                }
+                event.accepted = true;
+                break;
+            case Qt.Key_Left:
+            case Qt.Key_Escape:
+                quickList.selectedIndex = -1;
+                quickList.focus = false;
+                quickList.state = ""
+                event.accepted = true;
+                break;
+            case Qt.Key_Enter:
+            case Qt.Key_Return:
+            case Qt.Key_Space:
+                if (quickList.selectedIndex >= 0) {
+                    LauncherModel.quickListActionInvoked(quickList.appId, quickList.selectedIndex)
+                }
+                quickList.selectedIndex = -1;
+                quickList.focus = false;
+                quickList.state = ""
+                root.kbdNavigationCancelled();
+                event.accepted = true;
+                break;
+            }
+        }
 
         // internal
         property int itemCenter: item ? root.mapFromItem(quickList.item).y + (item.height / 2) + quickList.item.offset : units.gu(1)
         property int offset: itemCenter + (height/2) + units.gu(1) > parent.height ? -itemCenter - (height/2) - units.gu(1) + parent.height :
                              itemCenter - (height/2) < units.gu(1) ? (height/2) - itemCenter + units.gu(1) : 0
 
+        function open(index) {
+            var itemPosition = index * launcherListView.itemHeight;
+            var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
+            item = launcherListView.itemAt(launcherListView.width / 2, itemPosition + launcherListView.itemHeight / 2);
+            quickList.model = launcherListView.model.get(index).quickList;
+            quickList.appId = launcherListView.model.get(index).appId;
+            quickList.state = "open";
+        }
+
         Column {
             id: quickListColumn
             width: parent.width
@@ -712,6 +780,7 @@
                     objectName: "quickListEntry" + index
                     text: (model.clickable ? "" : "<b>") + model.label + (model.clickable ? "" : "</b>")
                     highlightWhenPressed: model.clickable
+                    selected: index === quickList.selectedIndex
 
                     // FIXME: This is a workaround for the theme not being context sensitive. I.e. the
                     // ListItems don't know that they are sitting in a themed Popover where the color
@@ -727,6 +796,8 @@
                         // Unsetting model to prevent showing changing entries during fading out
                         // that may happen because of triggering an action.
                         LauncherModel.quickListActionInvoked(quickList.appId, index);
+                        quickList.focus = false;
+                        root.kbdNavigationCancelled();
                         quickList.model = undefined;
                     }
                 }

=== added file 'qml/Launcher/graphics/launcher-app-focus-ring.svg'
--- qml/Launcher/graphics/launcher-app-focus-ring.svg	1970-01-01 00:00:00 +0000
+++ qml/Launcher/graphics/launcher-app-focus-ring.svg	2016-03-11 11:34:41 +0000
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="172px" height="163px" viewBox="0 0 172 163" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+    <!-- Generator: Sketch 3.4.4 (17249) - http://www.bohemiancoding.com/sketch -->
+    <title>Shape</title>
+    <desc>Created with Sketch.</desc>
+    <defs></defs>
+    <g id="•-Launcher" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
+        <g id="Artboard-9" sketch:type="MSArtboardGroup" transform="translate(-163.000000, -1436.000000)" fill="#E95420">
+            <path d="M221.983432,1440 L221.983432,1440 C195.6127,1440 184.708233,1442.4723 177.107949,1450.10734 C169.476819,1457.77336 167,1468.79245 167,1495.3481 L167,1538.9019 C167,1565.45755 169.476819,1576.47664 177.107949,1584.14266 C184.708233,1591.7777 195.6127,1594.25 221.983432,1594.25 L276.016868,1594.25 C302.387595,1594.25 313.291998,1591.77771 320.892221,1584.14264 C328.523252,1576.47663 331,1565.45769 331,1538.9019 L331,1495.3481 C331,1468.79231 328.523252,1457.77337 320.892221,1450.10736 C313.291998,1442.47229 302.387595,1440 276.016868,1440 L221.983432,1440 Z M221.983432,1436 L276.016868,1436 C302.345315,1436 314.848953,1438.36655 323.727108,1447.2854 C332.633306,1456.23243 335,1468.85167 335,1495.3481 L335,1538.9019 C335,1565.39833 332.633306,1578.01757 323.727108,1586.9646 C314.848953,1595.88345 302.345315,1598.25 276.016868,1598.25 L221.983432,1598.25 C195.654985,1598.25 183.151291,1595.88345 174.273077,1586.96463 C165.366772,1578.0176 163,1565.39822 163,1538.9019 L163,1495.3481 C163,1468.85178 165.366772,1456.2324 174.273077,1447.28537 C183.151291,1438.36655 195.654985,1436 221.983432,1436 L221.983432,1436 Z" id="Shape" sketch:type="MSShapeGroup"></path>
+        </g>
+    </g>
+</svg>
\ No newline at end of file

=== modified file 'qml/Notifications/Notification.qml'
--- qml/Notifications/Notification.qml	2016-02-29 11:31:46 +0000
+++ qml/Notifications/Notification.qml	2016-03-11 11:34:41 +0000
@@ -23,7 +23,7 @@
 import Utils 0.1
 import "../Components"
 
-Item {
+StyledItem {
     id: notification
 
     property alias iconSource: icon.fileSource
@@ -58,6 +58,10 @@
     color: (type === Notification.Confirmation && notificationList.useModal && !greeter.shown) || darkOnBright ? sdLightGrey : Qt.rgba(0.132, 0.117, 0.109, 0.97)
     opacity: 1 - (x / notification.width) // FIXME: non-zero initially because of LP: #1354406 workaround, we want this to start at 0 upon creation eventually
 
+    theme: ThemeSettings {
+        name: "Ubuntu.Components.Themes.Ambiance"
+    }
+
     state: {
         var result = "";
 
@@ -297,7 +301,7 @@
                         visible: body != "" && type !== Notification.Confirmation
                         fontSize: "small"
                         color: darkOnBright ? sdFontColor : theme.palette.normal.backgroundText
-                        wrapMode: Text.WordWrap
+                        wrapMode: Text.Wrap
                         maximumLineCount: type == Notification.SnapDecision ? 12 : 2
                         elide: Text.ElideRight
                         textFormat: Text.PlainText

=== modified file 'qml/OrientedShell.qml'
--- qml/OrientedShell.qml	2016-01-28 11:31:48 +0000
+++ qml/OrientedShell.qml	2016-03-11 11:34:41 +0000
@@ -19,6 +19,7 @@
 import Unity.InputInfo 0.1
 import Unity.Session 0.1
 import Unity.Screens 0.1
+import Utils 0.1
 import GSettings 1.0
 import "Components"
 import "Rotation"
@@ -77,6 +78,8 @@
     InputDeviceModel {
         id: keyboardsModel
         deviceFilter: InputInfo.Keyboard
+        onDeviceAdded: forceOSKEnabled = autopilotDevicePresent();
+        onDeviceRemoved: forceOSKEnabled = autopilotDevicePresent();
     }
 
     InputDeviceModel {
@@ -84,6 +87,27 @@
         deviceFilter: InputInfo.TouchScreen
     }
 
+    /* FIXME: This exposes the NameRole as a work arround for lp:1542224.
+     * When QInputInfo exposes NameRole to QML, this should be removed.
+     */
+    property bool forceOSKEnabled: false
+    property var autopilotEmulatedDeviceNames: ["py-evdev-uinput"]
+    UnitySortFilterProxyModel {
+        id: autopilotDevices
+        model: keyboardsModel
+    }
+
+    function autopilotDevicePresent() {
+        for(var i = 0; i < autopilotDevices.count; i++) {
+            var device = autopilotDevices.get(i);
+            if (autopilotEmulatedDeviceNames.indexOf(device.name) != -1) {
+                console.warn("Forcing the OSK to be enabled as there is an autopilot eumlated device present.")
+                return true;
+            }
+        }
+        return false;
+    }
+
     Screens {
         id: screens
     }
@@ -195,7 +219,8 @@
         //       have multiple keyboards around. For now we only enable one keyboard at a time
         //       thus hiding it here if there is a physical one around or if we have a second
         //       screen (the virtual touchpad & osk on the phone) attached.
-        oskEnabled: keyboardsModel.count === 0 && screens.count === 1
+        oskEnabled: (keyboardsModel.count === 0 && screens.count === 1) ||
+                    forceOSKEnabled
 
         // 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.

=== modified file 'qml/Panel/Handle.qml'
--- qml/Panel/Handle.qml	2016-03-08 20:59:14 +0000
+++ qml/Panel/Handle.qml	2016-03-11 11:34:41 +0000
@@ -19,7 +19,7 @@
 
 Rectangle {
     id: handle
-    color: UbuntuColors.slate
+    color: theme.palette.normal.foreground
     height: units.gu(2)
     property bool active: false
 
@@ -35,7 +35,7 @@
                 id: dot
                 width: units.dp(3)
                 height: width
-                color: handle.active ? UbuntuColors.orange : UbuntuColors.ash
+                color: handle.active ? theme.palette.highlighted.foreground : theme.palette.normal.raised
                 radius: units.dp(1)
             }
         }

=== modified file 'qml/Panel/Indicators/MenuItemFactory.qml'
--- qml/Panel/Indicators/MenuItemFactory.qml	2016-03-08 20:59:14 +0000
+++ qml/Panel/Indicators/MenuItemFactory.qml	2016-03-11 11:34:41 +0000
@@ -228,7 +228,6 @@
             text: menuData && menuData.label || ""
             iconSource: menuData && menuData.icon || ""
             value : menuData && menuData.actionState || 0.0
-            enabled: menuData && menuData.sensitive || false
             highlightWhenPressed: false
         }
     }

=== modified file 'qml/Panel/IndicatorsMenu.qml'
--- qml/Panel/IndicatorsMenu.qml	2016-03-08 20:59:14 +0000
+++ qml/Panel/IndicatorsMenu.qml	2016-03-11 11:34:41 +0000
@@ -38,7 +38,7 @@
     property bool enableHint: true
     property bool contentEnabled: true
     property bool showOnClick: true
-    property color panelColor: theme.palette.normal.background
+    property color panelColor: UbuntuColors.jet
 
     signal showTapped(point position)
 

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2016-03-08 20:59:14 +0000
+++ qml/Panel/Panel.qml	2016-03-11 11:34:41 +0000
@@ -89,7 +89,7 @@
 
         Rectangle {
             id: indicatorAreaBackground
-            color: callHint.visible ? UbuntuColors.green : theme.palette.normal.background
+            color: callHint.visible ? UbuntuColors.green : indicators.panelColor
             anchors {
                 top: parent.top
                 left: parent.left
@@ -169,8 +169,10 @@
             objectName: "windowDecorationTitle"
             anchors {
                 left: parent.left
+                right: __indicators.left
                 top: parent.top
                 leftMargin: units.gu(1)
+                rightMargin: units.gu(1)
                 topMargin: units.gu(0.5)
                 bottomMargin: units.gu(0.5)
             }
@@ -181,6 +183,8 @@
             fontSize: "medium"
             font.weight: Font.Normal
             text: PanelState.title
+            elide: Text.ElideRight
+            maximumLineCount: 1
         }
 
         // TODO here would the Locally integrated menus come

=== modified file 'qml/ScopeTool.qml'
--- qml/ScopeTool.qml	2015-07-15 15:07:19 +0000
+++ qml/ScopeTool.qml	2016-03-11 11:34:41 +0000
@@ -52,14 +52,6 @@
         color: "#FCFCFC"
     }
 
-    Image {
-        anchors.fill: dashContent
-        source: root.width > root.height ? "Dash/graphics/paper_landscape.png" : "Dash/graphics/paper_portrait.png"
-        fillMode: Image.PreserveAspectCrop
-        horizontalAlignment: Image.AlignRight
-        verticalAlignment: Image.AlignTop
-    }
-
     DashContent {
         id: dashContent
 

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2016-03-08 20:59:08 +0000
+++ qml/Shell.qml	2016-03-11 11:34:41 +0000
@@ -25,6 +25,7 @@
 import Unity.Connectivity 0.1
 import Unity.Launcher 0.1
 import GlobalShortcut 1.0 // has to be before Utils, because of WindowKeysFilter
+import GSettings 1.0
 import Utils 0.1
 import Powerd 0.1
 import SessionBroadcast 0.1
@@ -187,6 +188,11 @@
         }
     }
 
+    GSettings {
+        id: settings
+        schema.id: "com.canonical.Unity8"
+    }
+
     Item {
         id: stages
         objectName: "stages"
@@ -343,6 +349,11 @@
                 property: "altTabPressed"
                 value: physicalKeysMapper.altTabPressed
             }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "leftMargin"
+                value: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0
+            }
         }
 
         Tutorial {
@@ -373,7 +384,11 @@
     InputMethod {
         id: inputMethod
         objectName: "inputMethod"
-        anchors { fill: parent; topMargin: panel.panelHeight }
+        anchors {
+            fill: parent
+            topMargin: panel.panelHeight
+            leftMargin: launcher.lockedVisible ? launcher.panelWidth : 0
+        }
         z: notifications.useModal || panel.indicators.shown || wizard.active ? overlay.z + 1 : overlay.z - 1
     }
 
@@ -557,6 +572,10 @@
                     && !greeter.hasLockedApp
             inverted: shell.usageScenario !== "desktop"
             shadeBackground: !tutorial.running
+            superPressed: physicalKeysMapper.superPressed
+            superTabPressed: physicalKeysMapper.superTabPressed
+            panelWidth: units.gu(settings.launcherWidth)
+            lockedVisible: shell.usageScenario == "desktop" && !settings.autohideLauncher && !panel.fullscreenMode
 
             onShowDashHome: showHome()
             onDash: showDash()
@@ -576,6 +595,37 @@
                     panel.indicators.hide()
                 }
             }
+            onFocusChanged: {
+                if (!focus) {
+                    applicationsDisplayLoader.focus = true;
+                }
+            }
+
+            GlobalShortcut {
+                shortcut: Qt.AltModifier | Qt.Key_F1
+                onTriggered: {
+                    launcher.openForKeyboardNavigation();
+                }
+            }
+            GlobalShortcut {
+                shortcut: Qt.MetaModifier | Qt.Key_0
+                onTriggered: {
+                    if (LauncherModel.get(9)) {
+                        activateApplication(LauncherModel.get(9).appId);
+                    }
+                }
+            }
+            Repeater {
+                model: 9
+                GlobalShortcut {
+                    shortcut: Qt.MetaModifier | (Qt.Key_1 + index)
+                    onTriggered: {
+                        if (LauncherModel.get(index)) {
+                            activateApplication(LauncherModel.get(index).appId);
+                        }
+                    }
+                }
+            }
         }
 
         Wizard {

=== modified file 'qml/Stages/AbstractStage.qml'
--- qml/Stages/AbstractStage.qml	2016-01-14 13:03:20 +0000
+++ qml/Stages/AbstractStage.qml	2016-03-11 11:34:41 +0000
@@ -21,7 +21,7 @@
 Rectangle {
     id: root
 
-    color: "#111111"
+    color: "#060606"
 
     // Controls to be set from outside
     property bool altTabPressed
@@ -39,6 +39,8 @@
     property int shellOrientationAngle
     property bool spreadEnabled: true // If false, animations and right edge will be disabled
     property bool suspended
+     // A Stage should paint a wallpaper etc over its full size but not use the margins for window placement
+    property int leftMargin: 0
 
     // To be read from outside
     property var mainApp: null

=== modified file 'qml/Stages/DesktopSpread.qml'
--- qml/Stages/DesktopSpread.qml	2015-11-24 17:44:18 +0000
+++ qml/Stages/DesktopSpread.qml	2016-03-11 11:34:41 +0000
@@ -19,6 +19,7 @@
 import Ubuntu.Components 1.3
 import Ubuntu.Gestures 0.1
 import Unity.Application 0.1
+import "../Components"
 
 FocusScope {
     id: root
@@ -26,8 +27,11 @@
     property bool altTabPressed: false
     property Item workspace: null
 
+    readonly property alias ready: blurLayer.ready
     readonly property alias highlightedIndex: spreadRepeater.highlightedIndex
 
+    signal playFocusAnimation(int index)
+
     function show() {
         spreadContainer.animateIn = true;
         root.state = "altTab";
@@ -91,6 +95,9 @@
 
     function focusSelected() {
         if (spreadRepeater.highlightedIndex != -1) {
+            if (spreadContainer.visible) {
+                root.playFocusAnimation(spreadRepeater.highlightedIndex)
+            }
             var application = ApplicationManager.get(spreadRepeater.highlightedIndex);
             ApplicationManager.requestFocusApplication(application.appId);
         }
@@ -101,6 +108,31 @@
         state = ""
     }
 
+    BlurLayer {
+        id: blurLayer
+        anchors.fill: parent
+        source: root.workspace
+        visible: false
+    }
+
+    Rectangle {
+        id: spreadBackground
+        anchors.fill: parent
+        color: "#B2000000"
+        visible: false
+        opacity: visible ? 1 : 0
+        Behavior on opacity {
+            UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration }
+        }
+    }
+
+    MouseArea {
+        id: eventEater
+        anchors.fill: parent
+        visible: spreadBackground.visible
+        enabled: visible
+    }
+
     Item {
         id: spreadContainer
         objectName: "spreadContainer"
@@ -226,13 +258,20 @@
                     Transition {
                         from: ""
                         to: "altTab"
-                        PropertyAction { target: spreadDelegate; properties: "y,height,width,angle,z,itemScale,itemScaleOriginY,visible" }
-                        PropertyAction { target: clippedSpreadDelegate; properties: "anchors.topMargin" }
-                        PropertyAnimation {
-                            target: spreadDelegate; properties: "x"
-                            from: root.width
-                            duration: spreadContainer.animateIn ? UbuntuAnimation.FastDuration :0
-                            easing: UbuntuAnimation.StandardEasing
+                        SequentialAnimation {
+                            ParallelAnimation {
+                                PropertyAction { target: spreadDelegate; properties: "y,height,width,angle,z,itemScale,itemScaleOriginY,visible" }
+                                PropertyAction { target: clippedSpreadDelegate; properties: "anchors.topMargin" }
+                                PropertyAnimation {
+                                    target: spreadDelegate; properties: "x"
+                                    from: root.width
+                                    duration: spreadContainer.animateIn ? UbuntuAnimation.FastDuration :0
+                                    easing: UbuntuAnimation.StandardEasing
+                                }
+                                UbuntuNumberAnimation { target: clippedSpreadDelegate; property: "shadowOpacity"; from: 0; to: spreadMaths.shadowOpacity; duration: spreadContainer.animateIn ? UbuntuAnimation.FastDuration : 0 }
+                                UbuntuNumberAnimation { target: tileInfo; property: "opacity"; from: 0; to: spreadMaths.tileInfoOpacity; duration: spreadContainer.animateIn ? UbuntuAnimation.FastDuration : 0 }
+                            }
+                            PropertyAction { target: spreadSelectArea; property: "enabled" }
                         }
                     }
                 ]
@@ -240,7 +279,11 @@
                 MouseArea {
                     id: tileInfo
                     objectName: "tileInfo"
-                    anchors { left: parent.left; top: clippedSpreadDelegate.bottom; topMargin: units.gu(5) }
+                    anchors {
+                        left: parent.left
+                        top: clippedSpreadDelegate.bottom
+                        topMargin: ((spreadMaths.sceneHeight - spreadDelegate.y) - clippedSpreadDelegate.height) * 0.2
+                    }
                     property int nextItemX: spreadRepeater.count > index + 1 ? spreadRepeater.itemAt(index + 1).x : spreadDelegate.x + units.gu(30)
                     width: Math.min(units.gu(30), nextItemX - spreadDelegate.x)
                     height: titleInfoColumn.height
@@ -262,12 +305,20 @@
                         anchors { left: parent.left; top: parent.top; right: parent.right }
                         spacing: units.gu(1)
 
-                        UbuntuShape {
+                        UbuntuShapeForItem {
                             Layout.preferredHeight: Math.min(units.gu(6), root.height * .05)
                             Layout.preferredWidth: height * 8 / 7.6
                             image: Image {
                                 anchors.fill: parent
                                 source: model.icon
+                                Rectangle {
+                                    anchors.fill: parent
+                                    color: "black"
+                                    opacity: clippedSpreadDelegate.highlightShown ? 0 : .1
+                                    Behavior on opacity {
+                                        UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration }
+                                    }
+                                }
                             }
                         }
                         Label {
@@ -420,7 +471,7 @@
 
                             property var source: ShaderEffectSource {
                                 id: shaderEffectSource
-                                sourceItem: appContainer
+                                sourceItem: root.workspace
                             }
 
                             fragmentShader: "
@@ -494,20 +545,17 @@
             from: "*"
             to: "altTab"
             SequentialAnimation {
-                PropertyAction { target: hoverMouseArea; property: "progressiveScrollingEnabled"; value: false }
                 PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: Math.min(ApplicationManager.count - 1, 1) }
-                PauseAnimation { duration: 140 }
+                PauseAnimation { duration: spreadContainer.animateIn ? 0 : 140 }
                 PropertyAction { target: workspaceSelector; property: "visible" }
                 PropertyAction { target: spreadContainer; property: "visible" }
                 ParallelAnimation {
-                    UbuntuNumberAnimation {
-                        target: blurLayer; properties: "saturation,blurRadius";
-                        duration: spreadContainer.animateIn ? UbuntuAnimation.FastDuration : 0
-                    }
+                    UbuntuNumberAnimation { target: blurLayer; properties: "saturation,blurRadius"; duration: UbuntuAnimation.SnapDuration }
                     PropertyAction { target: spreadFlickable; property: "visible" }
                     PropertyAction { targets: [currentSelectedLabel,spreadBackground]; property: "visible" }
                     PropertyAction { target: spreadFlickable; property: "contentX"; value: 0 }
                 }
+                PropertyAction { target: hoverMouseArea; properties: "enabled,progressiveScrollingEnabled"; value: false }
             }
         },
         Transition {
@@ -518,6 +566,5 @@
             PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: -1 }
             PropertyAction { target: spreadContainer; property: "animateIn"; value: false }
         }
-
     ]
 }

=== modified file 'qml/Stages/DesktopSpreadDelegate.qml'
--- qml/Stages/DesktopSpreadDelegate.qml	2015-12-01 12:17:24 +0000
+++ qml/Stages/DesktopSpreadDelegate.qml	2016-03-11 11:34:41 +0000
@@ -56,6 +56,11 @@
         }
     ]
 
+    scale: highlightShown ? 1.025 : 1
+    Behavior on scale {
+        UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration }
+    }
+
     BorderImage {
         anchors {
             fill: root
@@ -70,7 +75,7 @@
         anchors.fill: parent
         anchors.margins: -units.gu(1)
         color: "white"
-        opacity: highlightShown ? 0.15 : 0
+        opacity: highlightShown ? 0.55 : 0
         antialiasing: true
     }
 
@@ -108,4 +113,13 @@
             ]
         }
     }
+
+    Rectangle {
+        anchors.fill: parent
+        color: "black"
+        opacity: root.highlightShown ? 0 : .1
+        Behavior on opacity {
+            UbuntuNumberAnimation { duration: UbuntuAnimation.SnapDuration }
+        }
+    }
 }

=== modified file 'qml/Stages/DesktopStage.qml'
--- qml/Stages/DesktopStage.qml	2016-02-03 14:00:47 +0000
+++ qml/Stages/DesktopStage.qml	2016-03-11 11:34:41 +0000
@@ -224,6 +224,7 @@
         PanelState.dropShadow = false;
     }
 
+
     FocusScope {
         id: appContainer
         objectName: "appContainer"
@@ -274,6 +275,7 @@
                 readonly property alias maximizedLeft: appDelegatePrivate.maximizedLeft
                 readonly property alias maximizedRight: appDelegatePrivate.maximizedRight
                 readonly property alias minimized: appDelegatePrivate.minimized
+                readonly property alias fullscreen: decoratedWindow.fullscreen
 
                 readonly property string appId: model.appId
                 property bool animationsEnabled: true
@@ -293,6 +295,7 @@
                 visible: !visuallyMinimized &&
                          !greeter.fullyShown &&
                          (priv.foregroundMaximizedAppZ === -1 || priv.foregroundMaximizedAppZ <= z) ||
+                         decoratedWindow.fullscreen ||
                          (spread.state == "altTab" && index === spread.highlightedIndex)
 
                 Binding {
@@ -348,13 +351,26 @@
                     ApplicationManager.focusApplication(appId);
                 }
 
+                function playFocusAnimation() {
+                    focusAnimation.start()
+                }
+
+                UbuntuNumberAnimation {
+                    id: focusAnimation
+                    target: appDelegate
+                    property: "scale"
+                    from: 0.98
+                    to: 1
+                    duration: UbuntuAnimation.SnapDuration
+                }
+
                 states: [
                     State {
                         name: "fullscreen"; when: decoratedWindow.fullscreen
-                        extend: "maximized"
                         PropertyChanges {
                             target: appDelegate;
-                            y: -PanelState.panelHeight
+                            x: 0; y: -PanelState.panelHeight
+                            requestedWidth: appContainer.width; requestedHeight: appContainer.height;
                         }
                     },
                     State {
@@ -371,21 +387,21 @@
                         name: "maximized"; when: appDelegate.maximized && !appDelegate.minimized
                         PropertyChanges {
                             target: appDelegate;
-                            x: 0; y: 0;
-                            requestedWidth: root.width; requestedHeight: root.height;
+                            x: root.leftMargin; y: 0;
+                            requestedWidth: appContainer.width - root.leftMargin; requestedHeight: appContainer.height;
                             visuallyMinimized: false;
                             visuallyMaximized: true
                         }
                     },
                     State {
                         name: "maximizedLeft"; when: appDelegate.maximizedLeft && !appDelegate.minimized
-                        PropertyChanges { target: appDelegate; x: 0; y: PanelState.panelHeight;
-                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
+                        PropertyChanges { target: appDelegate; x: root.leftMargin; y: PanelState.panelHeight;
+                            requestedWidth: (appContainer.width - root.leftMargin)/2; requestedHeight: appContainer.height - PanelState.panelHeight }
                     },
                     State {
                         name: "maximizedRight"; when: appDelegate.maximizedRight && !appDelegate.minimized
-                        PropertyChanges { target: appDelegate; x: root.width/2; y: PanelState.panelHeight;
-                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
+                        PropertyChanges { target: appDelegate; x: (appContainer.width + root.leftMargin)/2; y: PanelState.panelHeight;
+                            requestedWidth: (appContainer.width - root.leftMargin)/2; requestedHeight: appContainer.height - PanelState.panelHeight }
                     },
                     State {
                         name: "minimized"; when: appDelegate.minimized
@@ -438,7 +454,7 @@
                     target: appDelegate
                     property: "z"
                     value: ApplicationManager.count + 1
-                    when: index == spread.highlightedIndex && blurLayer.ready
+                    when: index == spread.highlightedIndex && spread.ready
                 }
 
                 WindowResizeArea {
@@ -448,8 +464,9 @@
                     minHeight: units.gu(10)
                     borderThickness: units.gu(2)
                     windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing
-                    screenWidth: root.width
-                    screenHeight: root.height
+                    screenWidth: appContainer.width
+                    screenHeight: appContainer.height
+                    leftMargin: root.leftMargin
 
                     onPressed: { ApplicationManager.focusApplication(model.appId) }
                 }
@@ -473,27 +490,6 @@
         }
     }
 
-    BlurLayer {
-        id: blurLayer
-        anchors.fill: parent
-        source: appContainer
-        visible: false
-    }
-
-    Rectangle {
-        id: spreadBackground
-        anchors.fill: parent
-        color: "#55000000"
-        visible: false
-    }
-
-    MouseArea {
-        id: eventEater
-        anchors.fill: parent
-        visible: spreadBackground.visible
-        enabled: visible
-    }
-
     EdgeBarrier {
         id: edgeBarrier
 
@@ -509,7 +505,7 @@
                     rotation: 90
                     anchors.centerIn: parent
                     gradient: Gradient {
-                        GradientStop { position: 0.0; color: Qt.rgba(0.16,0.16,0.16,0.7)}
+                        GradientStop { position: 0.0; color: Qt.rgba(0.16,0.16,0.16,0.5)}
                         GradientStop { position: 1.0; color: Qt.rgba(0.16,0.16,0.16,0)}
                     }
                 }
@@ -527,9 +523,13 @@
     DesktopSpread {
         id: spread
         objectName: "spread"
-        anchors.fill: parent
+        anchors.fill: appContainer
         workspace: appContainer
         focus: state == "altTab"
         altTabPressed: root.altTabPressed
+
+        onPlayFocusAnimation: {
+            appRepeater.itemAt(index).playFocusAnimation();
+        }
     }
 }

=== modified file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	2016-01-14 13:03:20 +0000
+++ qml/Stages/PhoneStage.qml	2016-03-11 11:34:41 +0000
@@ -44,6 +44,33 @@
         }
     }
 
+    onAltTabPressedChanged: {
+        if (!spreadEnabled || !altTabEnabled) {
+            return;
+        }
+        if (altTabPressed) {
+            spreadView.snapToSpread();
+            priv.highlightIndex = Math.min(spreadRepeater.count - 1, 1);
+        } else {
+            spreadView.snapTo(priv.highlightIndex)