Merge lp:~mzanetti/unity8/appmanager-rework into lp:unity8

[Michael Zanetti]

rework ApplicationManager handling

This completely reworks how the Shell talks to the ApplicationManager as a preparation for the upcoming Right Edge work.

It drops ApplicationManagerWrapper as that one was mostly a leftover from very early prototypes and was the reason for many workarounds building up around it.

Also it cuts ties between the RunningApplicationGrid and the Stages. Both only talk directly to the ApplicationManager now.

Last but not least it drops the stages code as it is now and starts fresh with a PhoneStage for the upcoming Right Edge work. In the future a TabledStage and DesktopStage should be easily addable.

[lp:~mzanetti/unity8/appmanager-rework]

575. By Michael Zanetti on 2014-01-08

initial try on the right edge animation

576. By Michael Zanetti on 2014-01-08

make it interactive

577. By Michael Zanetti on 2014-01-08

added a bit of scaling. not matching spec yet

578. By Michael Zanetti on 2014-01-08

make it actually switch apps

579. By Michael Zanetti on 2014-01-09

improve mouse interaction with CoverFlip

580. By Michael Zanetti on 2014-01-10

update screenshots before starting right edge animation

581. By Michael Zanetti on 2014-01-10

merge trunk

582. By Michael Zanetti on 2014-01-14

reworked animation

583. By Michael Zanetti on 2014-01-15

improved the whole animation a lot

584. By Michael Zanetti on 2014-01-15

fix glitch with focusing the right app when moving backwards, after having already passed progressmarker1

585. By Michael Zanetti on 2014-01-15

make it look nicer if there are only 3 running apps

586. By Michael Zanetti on 2014-01-15

make flicking AND clicking work

587. By Michael Zanetti on 2014-01-15

cleanup

588. By Michael Zanetti on 2014-01-15

fix selected animation

589. By Michael Zanetti on 2014-01-16

drop unused file

590. By Michael Zanetti on 2014-01-16

merge trunk

591. By Michael Zanetti on 2014-01-16

add a point of no return

592. By Michael Zanetti on 2014-01-20

some work on bringing the fake application plugin up to date with the new api

593. By Michael Zanetti on 2014-01-20

added missing files

594. By Michael Zanetti on 2014-01-20

more progress on the fake application manager

595. By Michael Zanetti on 2014-01-20

fix hiding the stage when the app is killed

596. By Michael Zanetti on 2014-01-21

added a dropshadow

597. By Michael Zanetti on 2014-01-22

slow down scrolling a bit and fix the flickables contentWidth to roughly reflect the app's positions

598. By Michael Zanetti on 2014-01-22

shrink app tiles a little to make 3 of them fit into one row again

[Michael Zanetti (mzanetti)]

superseeded by the right-edge-2 branch

review: Disapprove

Unmerged revisions

=== modified file 'plugins/Utils/CMakeLists.txt'
--- plugins/Utils/CMakeLists.txt	2013-12-10 14:22:43 +0000
+++ plugins/Utils/CMakeLists.txt	2014-01-22 10:43:18 +0000
@@ -18,6 +18,7 @@
     qsortfilterproxymodelqml.cpp
     timeformatter.cpp
     unitymenumodelpaths.cpp
+    easingcurve.cpp
     plugin.cpp
     )
 
@@ -33,7 +34,7 @@
 # files directly in targets.
 set_target_properties(Utils-qml PROPERTIES COMPILE_FLAGS -fvisibility=default)
 
-qt5_use_modules(Utils-qml Qml Quick DBus Network XmlPatterns)
+qt5_use_modules(Utils-qml Qml Quick DBus Network XmlPatterns Gui)
 
 # export the qmldir qmltypes and plugin files
 export_qmlfiles(Utils Utils)

=== added file 'plugins/Utils/easingcurve.cpp'
--- plugins/Utils/easingcurve.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Utils/easingcurve.cpp	2014-01-22 10:43:18 +0000
@@ -0,0 +1,49 @@
+#include "easingcurve.h"
+
+
+EasingCurve::EasingCurve(QObject *parent):
+    QObject(parent)
+{
+
+}
+
+QEasingCurve::Type EasingCurve::type() const
+{
+    return m_easingCurve.type();
+}
+
+void EasingCurve::setType(const QEasingCurve::Type &type)
+{
+    m_easingCurve.setType(type);
+    Q_EMIT typeChanged();
+}
+
+qreal EasingCurve::period() const
+{
+    return m_easingCurve.period();
+}
+
+void EasingCurve::setPeriod(qreal period)
+{
+    m_easingCurve.setPeriod(period);
+    Q_EMIT periodChanged();
+}
+
+qreal EasingCurve::progress() const
+{
+    return m_progress;
+}
+
+void EasingCurve::setProgress(qreal progress)
+{
+    if (m_progress != progress) {
+        m_progress = progress;
+        m_value = m_easingCurve.valueForProgress(m_progress);
+        Q_EMIT progressChanged();
+    }
+}
+
+qreal EasingCurve::value() const
+{
+    return m_value;
+}

=== added file 'plugins/Utils/easingcurve.h'
--- plugins/Utils/easingcurve.h	1970-01-01 00:00:00 +0000
+++ plugins/Utils/easingcurve.h	2014-01-22 10:43:18 +0000
@@ -0,0 +1,42 @@
+#ifndef EASINGCURVE_H
+#define EASINGCURVE_H
+
+#include <QObject>
+#include <QEasingCurve>
+
+class EasingCurve: public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(QEasingCurve::Type)
+    Q_PROPERTY(QEasingCurve::Type type READ type WRITE setType NOTIFY typeChanged)
+    Q_PROPERTY(qreal period READ period WRITE setPeriod NOTIFY periodChanged)
+    Q_PROPERTY(qreal progress READ progress WRITE setProgress NOTIFY progressChanged)
+    Q_PROPERTY(qreal value READ value NOTIFY progressChanged)
+
+public:
+    EasingCurve(QObject *parent = 0);
+
+    QEasingCurve::Type type() const;
+    void setType(const QEasingCurve::Type &type);
+
+    qreal period() const;
+    void setPeriod(qreal period);
+
+    qreal progress() const;
+    void setProgress(qreal progress);
+
+    qreal value() const;
+
+Q_SIGNALS:
+    void typeChanged();
+    void periodChanged();
+    void progressChanged();
+
+private:
+    QEasingCurve m_easingCurve;
+    qreal m_progress;
+    qreal m_value;
+};
+
+#endif
+

=== modified file 'plugins/Utils/plugin.cpp'
--- plugins/Utils/plugin.cpp	2013-12-10 14:22:43 +0000
+++ plugins/Utils/plugin.cpp	2014-01-22 10:43:18 +0000
@@ -32,6 +32,7 @@
 #include "qsortfilterproxymodelqml.h"
 #include "timeformatter.h"
 #include "unitymenumodelpaths.h"
+#include "easingcurve.h"
 
 static const char* BOTTOM_BAR_VISIBILITY_COMMUNICATOR_DBUS_PATH = "/BottomBarVisibilityCommunicator";
 static const char* DBUS_SERVICE = "com.canonical.Shell.BottomBarVisibilityCommunicator";
@@ -46,6 +47,7 @@
     qmlRegisterType<TimeFormatter>(uri, 0, 1, "TimeFormatter");
     qmlRegisterType<GDateTimeFormatter>(uri, 0, 1, "GDateTimeFormatter");
     qmlRegisterUncreatableType<BottomBarVisibilityCommunicatorShell>(uri, 0, 1, "BottomBarVisibilityCommunicatorShell", "Can't create BottomBarVisibilityCommunicatorShell");
+    qmlRegisterType<EasingCurve>(uri, 0, 1, "EasingCurve");
 }
 
 void UtilsPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== modified file 'qml/Components/ResponsiveFlowView.qml'
--- qml/Components/ResponsiveFlowView.qml	2013-06-05 22:03:08 +0000
+++ qml/Components/ResponsiveFlowView.qml	2014-01-22 10:43:18 +0000
@@ -27,9 +27,8 @@
     property alias verticalSpacing: flow.verticalSpacing
     property alias horizontalSpacing: flow.horizontalSpacing
     property int referenceDelegateWidth
-    property alias firstModel: repeater1.model
-    property alias secondModel: repeater2.model
-    property alias delegate: repeater1.delegate
+    property alias model: repeater.model
+    property alias delegate: repeater.delegate
     readonly property int cellWidth: referenceDelegateWidth + horizontalSpacing
     readonly property int cellHeight: referenceDelegateWidth + verticalSpacing
     property alias move: flow.move
@@ -69,13 +68,7 @@
         property int margin: allocatableVerticalSpace - columns * horizontalSpacing
 
         Repeater {
-            id: repeater1
-            model: (root.model) ? root.model[0] : null
-        }
-        Repeater {
-            id: repeater2
-            model: (root.model) ? root.model[1] : null
-            delegate: repeater1.delegate
+            id: repeater
         }
     }
 }

=== modified file 'qml/Dash/Apps/RunningApplicationTile.qml'
--- qml/Dash/Apps/RunningApplicationTile.qml	2013-10-28 14:12:24 +0000
+++ qml/Dash/Apps/RunningApplicationTile.qml	2014-01-22 10:43:18 +0000
@@ -23,7 +23,6 @@
 AbstractButton {
     id: root
     property var application
-    property bool __sideStageEnabled: shell.applicationManager.sideStageEnabled
 
     signal requestedApplicationActivation(var application)
     signal requestedApplicationTermination(var application)
@@ -51,32 +50,22 @@
         }
     }
 
-    function updateScreenshotFromCache() {
-        applicationImage.updateFromCache();
-    }
-
-    // FIXME: should use UbuntuShape from SDK
-    UbuntuShapeForItem {
+    UbuntuShape {
         id: shapedApplicationImage
-        anchors {
-            top: parent.top
-            horizontalCenter: parent.horizontalCenter
+        anchors { top: parent.top; horizontalCenter: parent.horizontalCenter }
+
+        height: units.gu(17)
+        width: applicationImage.width
+        radius: "medium"
+
+        image: Image {
+            id: applicationImage
+            source: application.screenshot
+            // height : width = ss.height : ss.width
+            height: shapedApplicationImage.height
+            width: height * sourceSize.width / sourceSize.height
         }
 
-        // FIXME: width and height should be defined according to the
-        // application window's aspect ratio.
-        width: (application.stage === ApplicationInfo.MainStage && __sideStageEnabled) ?
-            units.gu(22) : units.gu(11)
-        height: (__sideStageEnabled) ? units.gu(22) : units.gu(19)
-        radius: "medium"
-        image: applicationImage
-    }
-
-    ApplicationImage {
-        id: applicationImage
-        source: ApplicationManager.findApplication((application) ? application.appId : "")
-        width: shapedApplicationImage.width
-        height: shapedApplicationImage.height
     }
 
     UbuntuShape {

=== modified file 'qml/Dash/Apps/RunningApplicationsGrid.qml'
--- qml/Dash/Apps/RunningApplicationsGrid.qml	2013-11-29 08:57:13 +0000
+++ qml/Dash/Apps/RunningApplicationsGrid.qml	2014-01-22 10:43:18 +0000
@@ -18,6 +18,7 @@
 import "../../Components"
 
 import Ubuntu.Gestures 0.1
+import Unity.Application 0.1
 
 ResponsiveFlowView {
     id: root
@@ -25,13 +26,7 @@
 
     signal updateScreenshots
     property alias enableHeightBehavior: heightBehaviour.enabled
-    property bool enableHeightBehaviorOnNextCreation: firstModel.count + secondModel.count == 0
-
-    Connections {
-        target: shell
-        onDashShownChanged: if (shell.dashShown && shell.stageScreenshotsReady) updateScreenshots();
-        onStageScreenshotsReadyChanged: if (shell.dashShown && shell.stageScreenshotsReady) updateScreenshots();
-    }
+    property bool enableHeightBehaviorOnNextCreation: model.count === 0
 
     Behavior on height {
         id: heightBehaviour
@@ -40,13 +35,7 @@
     }
 
     Connections {
-        target: root.firstModel
-        onCountChanged: {
-            heightBehaviour.enabled = true;
-        }
-    }
-    Connections {
-        target: root.secondModel
+        target: root.model
         onCountChanged: {
             heightBehaviour.enabled = true;
         }
@@ -85,17 +74,13 @@
                     root.terminationModeEnabled = true
             }
             onRequestedApplicationTermination: {
-                shell.applicationManager.stopApplication(model.appId)
+                ApplicationManager.stopApplication(model.appId)
             }
             onRequestedApplicationActivation: {
-                shell.activateApplication(model.appId)
+                ApplicationManager.focusApplication(model.appId)
             }
 
             terminationModeEnabled: root.terminationModeEnabled
-
-            Component.onCompleted: {
-                root.updateScreenshots.connect(updateScreenshotFromCache);
-            }
         }
     }
 

=== modified file 'qml/Dash/DashApps.qml'
--- qml/Dash/DashApps.qml	2013-12-02 13:23:28 +0000
+++ qml/Dash/DashApps.qml	2014-01-22 10:43:18 +0000
@@ -17,6 +17,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1
 import Utils 0.1
+import Unity.Application 0.1
 import "../Components"
 import "../Components/ListItems"
 import "Apps"
@@ -25,10 +26,6 @@
     id: scopeView
     objectName: "DashApps"
 
-    // FIXME: a way to aggregate these models would be ideal
-    property var mainStageApplicationsModel: shell.applicationManager.mainStageApplications
-    property var sideStageApplicationModel: shell.applicationManager.sideStageApplications
-
     ListModel {
         id: dummyVisibilityModifier
 
@@ -38,19 +35,16 @@
     SortFilterProxyModel {
         id: runningApplicationsModel
 
-        property var firstModel: mainStageApplicationsModel
-        property var secondModel: sideStageApplicationModel
         property bool canEnableTerminationMode: scopeView.isCurrent
 
-        model: dummyVisibilityModifier
+        model: ApplicationManager
         filterRole: 0
-        filterRegExp: invertMatch ? ((mainStageApplicationsModel.count === 0 &&
-                                      sideStageApplicationModel.count === 0) ? RegExp("running-apps") : RegExp("")) : RegExp("disabled")
+        filterRegExp: invertMatch ? (ApplicationManager.count === 0 ? RegExp("running-apps") : RegExp("")) : RegExp("disabled")
         invertMatch: scopeView.scope.searchQuery.length == 0
     }
 
     onScopeChanged: {
         scopeView.scope.categories.overrideResults("recent", runningApplicationsModel);
-        enableHeightBehaviorOnNextCreation = (mainStageApplicationsModel.count + sideStageApplicationModel.count == 0)
+        enableHeightBehaviorOnNextCreation = ApplicationManager.count === 0
     }
 }

=== modified file 'qml/Dash/GenericScopeView.qml'
--- qml/Dash/GenericScopeView.qml	2014-01-07 17:06:01 +0000
+++ qml/Dash/GenericScopeView.qml	2014-01-22 10:43:18 +0000
@@ -159,8 +159,7 @@
                     }
                     if (source.toString().indexOf("Apps/RunningApplicationsGrid.qml") != -1) {
                         // TODO: the running apps grid doesn't support standard scope results model yet
-                        item.firstModel = Qt.binding(function() { return results.firstModel })
-                        item.secondModel = Qt.binding(function() { return results.secondModel })
+                        item.model = Qt.binding(function() { return results.model })
                         item.canEnableTerminationMode = Qt.binding(function() { return scopeView.isCurrent })
                     } else {
                         item.model = Qt.binding(function() { return results })

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2014-01-02 08:21:56 +0000
+++ qml/Shell.qml	2014-01-22 10:43:18 +0000
@@ -49,20 +49,22 @@
     readonly property real panelHeight: panel.panelHeight
 
     property bool dashShown: dash.shown
-    property bool stageScreenshotsReady: {
-        if (sideStage.shown) {
-            if (mainStage.applications.count > 0) {
-                return mainStage.usingScreenshots && sideStage.usingScreenshots;
-            } else {
-                return sideStage.usingScreenshots;
-            }
+
+    function activateApplication(appId) {
+        if (ApplicationManager.findApplication(appId)) {
+            print("Shell.qml: activating app", appId);
+            ApplicationManager.activateApplication(appId);
         } else {
-            return mainStage.usingScreenshots;
+            print("starting app", appId);
+
+            // FIXME:
+//            var execFlags = sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;
+            var execFlags = ApplicationManager.ForceMainStage;
+
+            ApplicationManager.startApplication(appId, execFlags);
         }
     }
 
-    property var applicationManager: ApplicationManagerWrapper {}
-
     Binding {
         target: LauncherModel
         property: "applicationManager"
@@ -71,49 +73,6 @@
 
     Component.onCompleted: {
         Theme.name = "Ubuntu.Components.Themes.SuruGradient"
-
-        applicationManager.sideStageEnabled = Qt.binding(function() { return sideStage.enabled })
-
-        // FIXME: if application focused before shell starts, shell draws on top of it only.
-        // We should detect already running applications on shell start and bring them to the front.
-        applicationManager.unfocusCurrentApplication();
-    }
-
-    readonly property bool applicationFocused: !!applicationManager.mainStageFocusedApplication
-                                               || !!applicationManager.sideStageFocusedApplication
-    // Used for autopilot testing.
-    readonly property string currentFocusedAppId: ApplicationManager.focusedApplicationId
-
-    readonly property bool fullscreenMode: {
-        if (greeter.shown || lockscreen.shown) {
-            return false;
-        } else if (mainStage.usingScreenshots) { // Window Manager animating so want to re-evaluate fullscreen mode
-            return mainStage.switchingFromFullscreenToFullscreen;
-        } else if (applicationManager.mainStageFocusedApplication) {
-            return applicationManager.mainStageFocusedApplication.fullscreen;
-        } else {
-            return false;
-        }
-    }
-
-    function activateApplication(appId, argument) {
-        if (applicationManager) {
-            // For newly started applications, as it takes them time to draw their first frame
-            // we add a delay before we hide the animation screenshots to compensate.
-            var addDelay = !applicationManager.getApplicationFromDesktopFile(appId);
-
-            var application;
-            application = applicationManager.activateApplication(appId, argument);
-            if (application == null) {
-                return;
-            }
-            if (application.stage == ApplicationInfo.MainStage || !sideStage.enabled) {
-                mainStage.activateApplication(appId, addDelay);
-            } else {
-                sideStage.activateApplication(appId, addDelay);
-            }
-            stages.show();
-        }
     }
 
     GSettings {
@@ -161,19 +120,19 @@
         // Whether the underlay is fully covered by opaque UI elements.
         property bool fullyCovered: panel.indicators.fullyOpened && shell.width <= panel.indicatorsMenuWidth
 
-        readonly property bool applicationRunning: ((mainStage.applications && mainStage.applications.count > 0)
-                                           || (sideStage.applications && sideStage.applications.count > 0))
+        readonly property bool applicationRunning: ApplicationManager.focusedApplicationId.length > 0
+        onApplicationRunningChanged: print("***************+ application running", applicationRunning)
 
         // Whether the user should see the topmost application surface (if there's one at all).
-        readonly property bool applicationSurfaceShouldBeSeen: applicationRunning && !stages.fullyHidden
-                                           && !mainStage.usingScreenshots // but want sideStage animating over app surface
-
-
-
-        // NB! Application surfaces are stacked behing the shell one. So they can only be seen by the user
+        readonly property bool applicationSurfaceShouldBeSeen: applicationRunning && !stages.painting
+
+        // NB! Application surfaces are stacked behind the shell one. So they can only be seen by the user
         // through the translucent parts of the shell surface.
         visible: !fullyCovered && !applicationSurfaceShouldBeSeen
 
+        onVisibleChanged: print("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh", visible, fullyCovered, applicationSurfaceShouldBeSeen,
+                                applicationRunning, stages.fullyHidden, stages.painting)
+
         CrossFadeImage {
             id: backgroundImage
             objectName: "backgroundImage"
@@ -197,12 +156,6 @@
             hides: [stages, launcher, panel.indicators]
             shown: disappearingAnimationProgress !== 1.0
             enabled: disappearingAnimationProgress === 0.0 && edgeDemo.dashEnabled
-            // FIXME: unfocus all applications when going back to the dash
-            onEnabledChanged: {
-                if (enabled) {
-                    shell.applicationManager.unfocusCurrentApplication()
-                }
-            }
 
             anchors {
                 fill: parent
@@ -233,8 +186,7 @@
         x: launcher.progress
         Behavior on x {SmoothedAnimation{velocity: 600}}
 
-        property real showProgress:
-            MathUtils.clamp(1 - (x + stages.x) / shell.width, 0, 1)
+        property real showProgress: MathUtils.clamp(1 - (x + stages.x) / shell.width, 0, 1)
 
         Showable {
             id: stages
@@ -244,6 +196,9 @@
 
             property bool fullyShown: shown && x == 0 && parent.x == 0
             property bool fullyHidden: !shown && x == width
+
+            property bool painting: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.painting : false
+
             available: !greeter.shown
             hides: [panel.indicators]
             shown: false
@@ -254,128 +209,57 @@
             width: parent.width
             height: parent.height
 
-            // close the stages when no focused application remains
-            Connections {
-                target: shell.applicationManager
-                onMainStageFocusedApplicationChanged: stages.closeIfNoApplications()
-                onSideStageFocusedApplicationChanged: stages.closeIfNoApplications()
-                ignoreUnknownSignals: true
-            }
-
-            function closeIfNoApplications() {
-                if (!shell.applicationManager.mainStageFocusedApplication
-                 && !shell.applicationManager.sideStageFocusedApplication
-                 && shell.applicationManager.mainStageApplications.count == 0
-                 && shell.applicationManager.sideStageApplications.count == 0) {
-                    stages.hide();
-                }
-            }
-
-            // show the stages when an application gets the focus
-            Connections {
-                target: shell.applicationManager
-                onMainStageFocusedApplicationChanged: {
-                    if (shell.applicationManager.mainStageFocusedApplication) {
-                        mainStage.show();
-                        stages.show();
-                    }
-                }
-                onSideStageFocusedApplicationChanged: {
-                    if (shell.applicationManager.sideStageFocusedApplication) {
-                        sideStage.show();
-                        stages.show();
-                    }
-                }
-                ignoreUnknownSignals: true
-            }
-
-            Stage {
-                id: mainStage
-
+            property string lastFocusedAppId
+            onShownChanged: {
+                print("stages shown", shown)
+                if (shown) {
+                    if (!ApplicationManager.focusedApplicationId && lastFocusedAppId) {
+                        ApplicationManager.focusApplication(lastFocusedAppId);
+                    }
+                } else {
+                    lastFocusedAppId = ApplicationManager.focusedApplicationId;
+                    ApplicationManager.unfocusCurrentApplication();
+                }
+            }
+
+            Connections {
+                target: ApplicationManager
+                onFocusedApplicationIdChanged: {
+                    if (ApplicationManager.focusedApplicationId.length > 0) {
+                        print("should show stages")
+                        stages.show();
+                    } else {
+                        stages.hide();
+                    }
+                }
+
+                onApplicationAdded: {
+                    stages.show();
+                }
+            }
+
+            Loader {
+                id: applicationsDisplayLoader
                 anchors.fill: parent
-                fullyShown: stages.fullyShown
-                fullyHidden: stages.fullyHidden
-                shouldUseScreenshots: !fullyShown
-                rightEdgeEnabled: !sideStage.enabled
-
-                applicationManager: shell.applicationManager
-                rightEdgeDraggingAreaWidth: shell.edgeSize
-                normalApplicationY: shell.panelHeight
-
-                shown: true
-                function show() {
-                    stages.show();
-                }
-                function hide() {
-                }
-
-                // FIXME: workaround the fact that focusing a main stage application
-                // raises its surface on top of all other surfaces including the ones
-                // that belong to side stage applications.
-                onFocusedApplicationChanged: {
-                    if (focusedApplication && sideStage.focusedApplication && sideStage.fullyShown) {
-                        shell.applicationManager.focusApplication(sideStage.focusedApplication);
-                    }
-                }
-            }
-
-            SideStage {
-                id: sideStage
-
-                applicationManager: shell.applicationManager
-                rightEdgeDraggingAreaWidth: shell.edgeSize
-                normalApplicationY: shell.panelHeight
-
-                onShownChanged: {
-                    if (!shown && mainStage.applications.count == 0) {
-                        stages.hide();
-                    }
-                }
-                // FIXME: when hiding the side stage, refocus the main stage
-                // application so that it goes in front of the side stage
-                // application and hides it
-                onFullyShownChanged: {
-                    if (!fullyShown && stages.fullyShown && sideStage.focusedApplication != null) {
-                        shell.applicationManager.focusApplication(mainStage.focusedApplication);
-                    }
-                }
-
-                enabled: shell.width >= units.gu(60)
-                visible: enabled
-                fullyShown: stages.fullyShown && shown
-                            && sideStage[sideStageRevealer.boundProperty] == sideStageRevealer.openedValue
-                shouldUseScreenshots: !fullyShown || mainStage.usingScreenshots || sideStageRevealer.pressed
-
-                available: !greeter.shown && !lockscreen.shown && enabled
-                hides: [launcher, panel.indicators]
-                shown: false
-                showAnimation: StandardAnimation { property: "x"; duration: 350; to: sideStageRevealer.openedValue; easing.type: Easing.OutQuint }
-                hideAnimation: StandardAnimation { property: "x"; duration: 350; to: sideStageRevealer.closedValue; easing.type: Easing.OutQuint }
-
-                width: units.gu(40)
-                height: stages.height
-                handleExpanded: sideStageRevealer.pressed
-            }
-
-            Revealer {
-                id: sideStageRevealer
-
-                enabled: mainStage.applications.count > 0 && sideStage.applications.count > 0
-                         && sideStage.available
-                direction: Qt.RightToLeft
-                openedValue: parent.width - sideStage.width
-                hintDisplacement: units.gu(3)
-                /* The size of the sidestage handle needs to be bigger than the
-                   typical size used for edge detection otherwise it is really
-                   hard to grab.
-                */
-                handleSize: sideStage.shown ? units.gu(4) : shell.edgeSize
-                closedValue: parent.width + sideStage.handleSizeCollapsed
-                target: sideStage
-                x: parent.width - width
-                width: sideStage.width + handleSize * 0.7
-                height: sideStage.height
-                orientation: Qt.Horizontal
+
+//                source: "Stages/StageWithSideStage.qml"
+                source: "Stages/PhoneStage.qml"
+
+                Binding {
+                    target: applicationsDisplayLoader.item
+                    property: "moving"
+                    value: !stages.fullyShown
+                }
+                Binding {
+                    target: applicationsDisplayLoader.item
+                    property: "shown"
+                    value: stages.shown
+                }
+                Binding {
+                    target: applicationsDisplayLoader.item
+                    property: "dragAreaWidth"
+                    value: shell.edgeSize
+                }
             }
 
             DragHandle {
@@ -388,7 +272,7 @@
                 width: shell.edgeSize
                 direction: Direction.Leftwards
                 enabled: greeter.showProgress == 0 && edgeDemo.dashEnabled
-                property bool haveApps: mainStage.applications.count > 0 || sideStage.applications.count > 0
+                property bool haveApps: ApplicationManager.count > 0
 
                 maxTotalDragDistance: haveApps ? parent.width : parent.width * 0.7
                 // Make autocompletion impossible when !haveApps
@@ -473,23 +357,6 @@
         property var previousMainApp: null
         property var previousSideApp: null
 
-        function removeApplicationFocus() {
-            greeter.previousMainApp = applicationManager.mainStageFocusedApplication;
-            greeter.previousSideApp = applicationManager.sideStageFocusedApplication;
-            applicationManager.unfocusCurrentApplication();
-        }
-
-        function restoreApplicationFocus() {
-            if (greeter.previousMainApp) {
-                applicationManager.focusApplication(greeter.previousMainApp);
-                greeter.previousMainApp = null;
-            }
-            if (greeter.previousSideApp) {
-                applicationManager.focusApplication(greeter.previousSideApp);
-                greeter.previousSideApp = null;
-            }
-        }
-
         onShownChanged: {
             if (shown) {
                 lockscreen.reset();
@@ -500,9 +367,6 @@
                     greeter.selected(0);
                 }
                 greeter.forceActiveFocus();
-                removeApplicationFocus();
-            } else {
-                restoreApplicationFocus();
             }
         }
 
@@ -519,34 +383,11 @@
                 launcher.tease();
             }
         }
-
-        Connections {
-            target: applicationManager
-            ignoreUnknownSignals: true
-            // If any app is focused when greeter is open, it's due to a user action
-            // like a snap decision (say, an incoming call).
-            // TODO: these should be protected to only unlock for certain applications / certain usecases
-            // potentially only in connection with a notification.
-            onMainStageFocusedApplicationChanged: {
-                if (greeter.shown && applicationManager.mainStageFocusedApplication) {
-                    greeter.previousMainApp = null // make way for new focused app
-                    greeter.previousSideApp = null
-                    greeter.hide()
-                }
-            }
-            onSideStageFocusedApplicationChanged: {
-                if (greeter.shown && applicationManager.sideStageFocusedApplication) {
-                    greeter.previousMainApp = null // make way for new focused app
-                    greeter.previousSideApp = null
-                    greeter.hide()
-                }
-            }
-        }
     }
 
     InputFilterArea {
         anchors.fill: parent
-        blockInput: !applicationFocused || greeter.shown || lockscreen.shown || launcher.shown
+        blockInput: ApplicationManager.focusedApplicationId.length === 0 || greeter.shown || lockscreen.shown || launcher.shown
                     || panel.indicators.shown || hud.shown
     }
 
@@ -595,7 +436,9 @@
                 available: edgeDemo.panelEnabled
                 contentEnabled: edgeDemo.panelContentEnabled
             }
-            fullscreenMode: shell.fullscreenMode
+            property string focusedAppId: ApplicationManager.focusedApplicationId
+            property var focusedApplication: ApplicationManager.findApplication(focusedAppId)
+            fullscreenMode: focusedApplication && focusedApplication.fullscreen && !greeter.shown && !lockscreen.shown
             searchVisible: !greeter.shown && !lockscreen.shown && dash.shown
 
             InputFilterArea {
@@ -621,9 +464,8 @@
             hideAnimation: StandardAnimation { property: "y"; duration: hud.showableAnimationDuration; to: hudRevealer.closedValue; easing.type: Easing.Linear }
 
             Connections {
-                target: shell.applicationManager
-                onMainStageFocusedApplicationChanged: hud.hide()
-                onSideStageFocusedApplicationChanged: hud.hide()
+                target: ApplicationManager
+                onFocusedApplicationIdChanged: hud.hide()
             }
         }
 
@@ -648,7 +490,7 @@
             theHud: hud
             anchors.fill: parent
             enabled: hud.available
-            applicationIsOnForeground: applicationFocused
+            applicationIsOnForeground: ApplicationManager.focusedApplicationId
         }
 
         InputFilterArea {
@@ -774,14 +616,14 @@
         anchors.bottom: parent.bottom
         anchors.left: parent.left
         anchors.right: parent.right
-        height: shell.applicationManager ? shell.applicationManager.keyboardHeight : 0
+        height: ApplicationManager.keyboardVisible ? ApplicationManager.keyboardHeight : 0
 
-        enabled: shell.applicationManager && shell.applicationManager.keyboardVisible
+        enabled: ApplicationManager.keyboardVisible
     }
 
     Label {
         anchors.centerIn: parent
-        visible: applicationManager.fake
+        visible: ApplicationManager.fake ? ApplicationManager.fake : false
         text: "EARLY ALPHA\nNOT READY FOR USE"
         color: "lightgrey"
         opacity: 0.2

=== added directory 'qml/Stages'
=== added file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	1970-01-01 00:00:00 +0000
+++ qml/Stages/PhoneStage.qml	2014-01-22 10:43:18 +0000
@@ -0,0 +1,574 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Gestures 0.1
+import Unity.Application 0.1
+import Utils 0.1
+import "../Components"
+
+/*
+
+*/
+
+Item {
+    id: root
+
+    // Controls to be set from outside
+    property bool shown: false
+    property bool moving: false
+    property int dragAreaWidth
+
+    // State information propagated to the outside
+    readonly property bool painting: mainScreenshotImage.visible || fadeInScreenshotImage.visible || appSplash.visible
+    onPaintingChanged: print("**********************+ painting changed", painting)
+
+    onMovingChanged: {
+        if (moving) {
+            priv.requestNewScreenshot();
+        } else {
+            mainScreenshotImage.visible = false;
+        }
+    }
+
+    Connections {
+        target: ApplicationManager
+
+        onFocusRequested: {
+            priv.switchToApp(appId);
+        }
+
+        onFocusedApplicationIdChanged: {
+            if (ApplicationManager.focusedApplicationId.length > 0) {
+                if (priv.secondApplicationStarting || priv.applicationStarting) {
+                    appSplashTimer.start();
+                } else {
+                    mainScreenshotImage.src = ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).screenshot
+                }
+            }
+        }
+
+        onApplicationAdded: {
+            if (!priv.focusedApplication) {
+                mainScreenshotImage.src = "";
+                mainScreenshotImage.visible = false;
+                priv.applicationStarting = true;
+            } else {
+                mainScreenshotImage.src = "foobar";
+                priv.newFocusedAppId = appId;
+                priv.secondApplicationStarting = true;
+                priv.requestNewScreenshot();
+            }
+        }
+    }
+
+    QtObject {
+        id: priv
+
+        property string focusedAppId: ApplicationManager.focusedApplicationId
+        property var focusedApplication: ApplicationManager.findApplication(focusedAppId)
+        property url focusedScreenshot: focusedApplication ? focusedApplication.screenshot : ""
+
+        property bool waitingForScreenshot: false
+
+        property bool applicationStarting: false
+        property bool secondApplicationStarting: false
+
+        property string newFocusedAppId
+
+        onFocusedScreenshotChanged: {
+            if (root.moving && priv.waitingForScreenshot) {
+                mainScreenshotImage.anchors.leftMargin = 0;
+                mainScreenshotImage.src = ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).screenshot;
+                mainScreenshotImage.visible = true;
+            } else if (priv.secondApplicationStarting && priv.waitingForScreenshot) {
+                applicationSwitchingAnimation.start();
+            }
+            waitingForScreenshot = false;
+        }
+
+        function requestNewScreenshot() {
+            waitingForScreenshot = true;
+            ApplicationManager.updateScreenshot(ApplicationManager.focusedApplicationId);
+        }
+
+        function switchToApp(appId) {
+            priv.newFocusedAppId = appId;
+            applicationSwitchingAnimation.start();
+            grantFocusTimer.start();
+        }
+
+    }
+
+    // FIXME: the signal connection seems to get lost with the fake application manager.
+    // Check with Qt 5.2, see if we can remove this Connections object
+    Connections {
+        target: priv.focusedApplication
+        onScreenshotChanged: priv.focusedScreenshot = priv.focusedApplication.screenshot
+    }
+
+    Timer {
+        id: grantFocusTimer
+        // Delay the actual switch to be covered by the animation for sure.
+        // 1) If we switch before starting the animation, the Mir event loop paints before the Qt event loop => flickering
+        // 2) If we do the switch after the animation, the panel wouldn't fade in early enough.
+        interval: UbuntuAnimation.SlowDuration / 4
+        repeat: false
+        onTriggered: {
+            ApplicationManager.focusApplication(priv.newFocusedAppId);
+        }
+    }
+
+    Timer {
+        id: appSplashTimer
+        // This is to show the splash screen a bit longer.
+        // Mir signals us that the newly started app has gotten focus before it paints something on the screen
+        // This would result in the old app surface becoming visible for a bit.
+        // FIXME: change appManager to only change the focusedApplicationId when the surface is ready to be shown.
+        interval: 1500
+        repeat: false
+        onTriggered: {
+            priv.applicationStarting = false;
+            priv.secondApplicationStarting = false;
+        }
+    }
+
+    SequentialAnimation {
+        id: applicationSwitchingAnimation
+        // setup
+        PropertyAction { target: mainScreenshotImage; property: "anchors.leftMargin"; value: 0 }
+        // PropertyAction seems to fail when secondApplicationStarting and we didn't have another screenshot before
+        ScriptAction { script: mainScreenshotImage.src = priv.focusedScreenshot }
+        PropertyAction { target: mainScreenshotImage; property: "visible"; value: true }
+        PropertyAction { target: fadeInScreenshotImage; property: "source"; value: ApplicationManager.findApplication(priv.newFocusedAppId).screenshot }
+        PropertyAction { target: fadeInScreenshotImage; property: "visible"; value: true }
+        PropertyAction { target: fadeInScreenshotImage; property: "opacity"; value: 0 }
+        PropertyAction { target: fadeInScreenshotImage; property: "scale"; value: .8 }
+
+
+        // The actual animation
+        ParallelAnimation {
+            UbuntuNumberAnimation { target: mainScreenshotImage; property: "anchors.leftMargin"; to: root.width; duration: UbuntuAnimation.SlowDuration }
+            UbuntuNumberAnimation { target: fadeInScreenshotImage; property: "opacity"; to: 1; duration: UbuntuAnimation.SlowDuration }
+            UbuntuNumberAnimation { target: fadeInScreenshotImage; property: "scale"; to: 1; duration: UbuntuAnimation.SlowDuration }
+        }
+
+        // restore stuff
+        PropertyAction { target: fadeInScreenshotImage; property: "visible"; value: false }
+        PropertyAction { target: mainScreenshotImage; property: "visible"; value: false }
+    }
+
+    // FIXME: Drop this and make the imageprovider show a splashscreen instead
+    Rectangle {
+        id: appSplash2
+        anchors.fill: parent
+        color: "white"
+        visible: priv.secondApplicationStarting
+    }
+    Image {
+        id: fadeInScreenshotImage
+        anchors { left: parent.left; bottom: parent.bottom }
+        width: parent.width
+        scale: .7
+        visible: false
+    }
+
+    Rectangle {
+        id: appSplash
+        anchors.fill: parent
+        color: "white"
+        visible: priv.applicationStarting
+    }
+    Image {
+        id: mainScreenshotImage
+        anchors { left: parent.left; bottom: parent.bottom }
+        width: parent.width
+
+        property string src
+        source: src
+        visible: false
+    }
+
+    EdgeDragArea {
+        id: coverFlipDragArea
+        direction: Direction.Leftwards
+
+        //enabled: root.available
+        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
+        width: root.dragAreaWidth
+
+        onTouchXChanged: {
+            if (!dragging && !priv.waitingForScreenshot) {
+                priv.requestNewScreenshot();
+            }
+            if (dragging && !priv.waitingForScreenshot) {
+                coverFlickable.contentX = -touchX
+            }
+        }
+
+        onDraggingChanged: {
+            if (!dragging) {
+                coverFlip.snap();
+            }
+        }
+    }
+
+    Rectangle {
+        id: coverFlipBackground
+        anchors.fill: parent
+        color: "black"
+        visible: coverFlip.visible
+    }
+
+    InputFilterArea {
+        anchors.fill: root
+        blockInput: coverFlip.visible
+    }
+
+    Flickable {
+        id: coverFlickable
+        anchors.fill: root
+        contentHeight: height
+        contentWidth: width * 2 + ((ApplicationManager.count - 2) * root.width * coverFlip.tileDistance * 1.5)
+        flickableDirection: Qt.Horizontal
+        enabled: coverFlip.visible
+
+        property bool passedFirstStage: false
+
+        onContentXChanged: {
+            if (coverFlickable.passedFirstStage && contentX < width * coverFlip.progressMarker1) {
+                contentX = width * coverFlip.progressMarker1;
+                return;
+            }
+            var progress = contentX / width
+            if (progress > coverFlip.progressMarker1) {
+                coverFlickable.passedFirstStage = true;
+            }
+            coverFlip.progress = progress;
+        }
+
+        Row {
+            id: coverFlip
+            height: parent.height
+            // The MouseAreas on the AppImages need to be children of the flickable in order to make focus stealing
+            // for flicking vs. clicking work correctly.
+            // However, for the animation calculations to become easier we don't want the row to move so we don't
+            // always have to take contentX into account. So lets just compensate the flickable's movement here.
+            x: coverFlickable.contentX
+            visible: progress > 0
+
+            property real progress: 0
+            property real startAngle: 45
+            property int endAngle: 10
+
+            property real maxScale: 1.4
+            property real minScale: .6
+
+            // Markers: relative screen position from left to right
+            // marks the line where first application is finished moving in from the right
+            property real progressMarker1: 0.5
+
+            property real tileDistance: 0.1
+
+            property bool animatingBack: false
+
+            property real tileWidth: root.width
+
+            property real oldProgress: 0
+            onProgressChanged: {
+                if (coverFlipDragArea.dragging) {
+                    if (oldProgress < coverFlip.progressMarker1 && progress >= coverFlip.progressMarker1) {
+                        ApplicationManager.move(0, 1)
+                    } else if (oldProgress >= coverFlip.progressMarker1 && progress < coverFlip.progressMarker1) {
+                        ApplicationManager.move(0, 1)
+                    }
+                }
+                oldProgress = progress;
+            }
+
+            function snap() {
+                if (coverFlip.progress < 0.25) {
+                    snapAnimation.targetContentX = 0
+                    snapAnimation.targetAppId = ApplicationManager.get(0).appId;
+                } else if (coverFlip.progress < coverFlip.progressMarker1) {
+                    snapAnimation.targetContentX = root.width * coverFlip.progressMarker1
+                    snapAnimation.targetAppId = ApplicationManager.get(1).appId;
+                } else if (coverFlip.progress < 0.6) {
+                    snapAnimation.targetContentX = root.width * coverFlip.progressMarker1
+                    snapAnimation.targetAppId = ApplicationManager.get(0).appId;
+                } else {
+                    if (ApplicationManager.count == 3) {
+                        snapAnimation.targetContentX = root.width * 1.1;
+                    } else {
+                        snapAnimation.targetContentX = root.width * 1.25;
+                    }
+                    snapAnimation.targetAppId = "";
+                }
+                snapAnimation.start();
+            }
+
+            function selectItem(index) {
+                tileRepeater.itemAt(index).select();
+            }
+
+            SequentialAnimation {
+                id: snapAnimation
+                property int targetContentX: 0
+                property string targetAppId
+
+                UbuntuNumberAnimation {
+                    target: coverFlickable
+                    properties: "contentX"
+                    to: snapAnimation.targetContentX
+                    duration: UbuntuAnimation.SnapDuration
+                }
+                ScriptAction {
+                    script: {
+                        if (snapAnimation.targetAppId) {
+                            coverFlickable.passedFirstStage = false;
+                            ApplicationManager.focusApplication(snapAnimation.targetAppId);
+                        }
+                        if (snapAnimation.targetContentX == root.width * coverFlip.progressMarker1) {
+                            coverFlickable.contentX = 0;
+                        }
+                    }
+                }
+            }
+
+            Repeater {
+                id: tileRepeater
+                model: ApplicationManager
+
+                Item {
+                    id: appItem
+                    height: parent.height
+                    width: coverFlip.tileWidth
+
+                    // This is the main progress, of the gesture, the same for every tile
+                    property real progress: coverFlip.progress
+                    // The progress, translated for the second stage of the animation, after the first app switch has happened
+                    // Additionally it speeds it up a bit, depending on the distance of the tile
+                    property real translatedProgress: appItem.progress - coverFlip.progressMarker1 - (coverFlip.tileDistance * (index-1))
+
+                    // Is this tile selected by a click?
+                    property bool isSelected: false
+                    // We need to remember some values when app is selected to be able to animate it to the foreground
+                    property real selectedXTranslation: 0
+                    property real selectedTranslatedProgress: 0
+                    property real selectedProgress: 0
+                    property real selectedAngle: 0
+                    property real selectedXScale: 0
+
+                    function select() {
+                        appItem.selectedXTranslation = appItem.xTranslation;
+                        appItem.selectedAngle = appItem.angle;
+                        appItem.selectedXScale = appItem.xScale;
+                        appItem.selectedTranslatedProgress = appItem.translatedProgress - coverFlip.progressMarker1;
+                        appItem.selectedProgress = appItem.progress - coverFlip.progressMarker1;
+                        appItem.isSelected = true;
+                        switchToAppAnimation.targetContentX = coverFlip.progressMarker1 * root.width
+                        switchToAppAnimation.start();
+                    }
+
+                    property int xTranslation: {
+                        var xTranslate = 0;
+                        var minXTranslate = -index * root.width + index * units.dp(3);
+                        switch (index) {
+                        case 0:
+                            if (appItem.progress < coverFlip.progressMarker1) {
+                                var progress = appItem.progress
+                                var progressDiff = coverFlip.progressMarker1
+                                var translateDiff = -root.width * 0.25
+                                // progress : progressDiff = translate : translateDiff
+                                xTranslate = progress * translateDiff / progressDiff
+                            }
+                            break;
+                        case 1:
+                            if (appItem.progress < coverFlip.progressMarker1) {
+                                var progress = appItem.progress;
+                                var progressDiff = coverFlip.progressMarker1;
+                                var translateDiff = -root.width;
+                                // progress : progressDiff = translate : translateDiff
+                                xTranslate = progress * translateDiff / progressDiff;
+                                break;
+                            }
+                            // Intentionally no break here...
+                        default:
+                            if (appItem.progress > coverFlip.progressMarker1) {
+                                xTranslate = xTranslateEasing.value * xTranslateEasing.period;
+                                if (appItem.isSelected) {
+                                    var translateDiff = root.width * index + appItem.selectedXTranslation
+                                    var progressDiff = appItem.selectedProgress
+                                    var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);
+                                    // progress : progressDiff = translate : translateDiff
+                                    var newTranslate = progress * translateDiff / progressDiff;
+
+                                    xTranslate = appItem.selectedXTranslation - newTranslate;
+                                }
+                                break;
+                            }
+                        }
+                        return xTranslate;
+                    }
+
+                    property real angle: {
+                        var newAngle = 0;
+                        switch (index) {
+                        case 0:
+                            if (appItem.progress < coverFlip.progressMarker1) {
+                                var progress = appItem.progress;
+                                var angleDiff = coverFlip.endAngle;
+                                var progressDiff = coverFlip.progressMarker1;
+                                // progress : progressDiff = angle : angleDiff
+                                newAngle = progress * angleDiff / progressDiff;
+                            } else {
+                                var progress = appItem.progress - coverFlip.progressMarker1;
+                                var angleDiff = coverFlip.endAngle;
+                                var progressDiff = 1 - coverFlip.progressMarker1;
+                                // progress : progressDiff = angle : angleDiff
+                                newAngle = progress * angleDiff / progressDiff;
+                                newAngle = Math.min(coverFlip.endAngle, newAngle);
+                            }
+                            break;
+                        case 1:
+                            if (appItem.progress < coverFlip.progressMarker1) {
+                                var progress = coverFlip.progress;
+                                var angleDiff = coverFlip.startAngle;
+                                var progressDiff = coverFlip.progressMarker1;
+                                // progress : progressDiff = angle : angleDiff
+                                var angle = progress * angleDiff / progressDiff;
+                                newAngle = coverFlip.startAngle - angle;
+                                break;
+                            }
+                            // Intentionally no break here...
+                        default:
+                            newAngle = coverFlip.startAngle - (angleEasing.value * angleEasing.period);
+                            // make sure we stop at the left screen edge
+                            newAngle = Math.max(newAngle, coverFlip.endAngle);
+
+                            if (appItem.isSelected) {
+//                                    var selectedAngleTranslate = selectedAngleEasing.value * selectedAngleEasing.period
+                                var angleDiff = appItem.selectedAngle
+                                var progressDiff = appItem.selectedProgress
+                                var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);
+                                // progress : progressDiff = angle : angleDiff
+                                var selectedAngleTranslate = progress * angleDiff / progressDiff;
+
+                                newAngle = appItem.selectedAngle - selectedAngleTranslate;
+                            }
+                        }
+                        return newAngle;
+                    }
+
+                    property real xScale: {
+                        var scale = 1;
+
+                        switch (index) {
+                        case 0:
+                            if (appItem.progress > coverFlip.progressMarker1) {
+                                var scaleDiff = coverFlip.maxScale - 1;
+                                var progressDiff = 1.5 - coverFlip.progressMarker1;
+                                // progress : progressDiff = scale : scaleDiff
+                                scale = 1 - (appItem.progress - coverFlip.progressMarker1) * scaleDiff / progressDiff;
+                            }
+                            break;
+                        case 1:
+                            if (appItem.progress < coverFlip.progressMarker1) {
+                                var scaleDiff = coverFlip.maxScale - 1
+                                var progressDiff = coverFlip.progressMarker1
+                                // progress : progressDiff = scale : scaleDiff
+                                scale = coverFlip.maxScale - (appItem.progress * scaleDiff / progressDiff);
+                                break;
+                            }
+                            // Intentionally no break
+                        default:
+                            scale = coverFlip.maxScale - scaleEasing.value * scaleEasing.period;
+                            if (appItem.isSelected) {
+                                var scaleDiff = -(1 - appItem.selectedXScale)
+                                var progressDiff = appItem.selectedProgress
+                                var progress = progressDiff - (appItem.progress - coverFlip.progressMarker1);
+                                // progress : progressDiff = angle : angleDiff
+                                var selectedScaleTranslate = progress * scaleDiff / progressDiff;
+
+                                scale = appItem.selectedXScale - selectedScaleTranslate;
+                            }
+                        }
+                        return Math.min(coverFlip.maxScale, Math.max(coverFlip.minScale, scale));
+                    }
+
+                    EasingCurve {
+                        id: xTranslateEasing
+                        type: EasingCurve.OutQuad
+                        period: index * -width
+                        progress: appItem.translatedProgress
+                    }
+                    EasingCurve {
+                        id: angleEasing
+                        type: EasingCurve.InQuad
+                        period: coverFlip.startAngle - coverFlip.endAngle
+                        progress: appItem.translatedProgress
+                    }
+                    EasingCurve {
+                        id: scaleEasing
+                        type: EasingCurve.Linear
+                        period: coverFlip.maxScale - coverFlip.minScale
+                        progress: appItem.translatedProgress
+                    }
+
+                    transform: [
+                        Rotation {
+                            origin { x: 0; y: coverFlip.height / 2 }
+                            axis { x: 0; y: 1; z: 0 }
+                            angle: appItem.angle
+                        },
+                        Translate {
+                            x: appItem.xTranslation
+                        },
+                        Scale {
+                            origin { x: appItem.xTranslation; y: root.height / 2 - (root.height - appImage.height)}
+                            xScale: appItem.xScale
+                            yScale: xScale
+                        }
+                    ]
+
+                    Image {
+                        id: dropShadow
+                        anchors.fill: appImage
+                        anchors.margins: -units.gu(2)
+                        source: "graphics/dropshadow.png"
+                    }
+                    Image {
+                        id: appImage
+                        anchors { left: parent.left; bottom: parent.bottom }
+                        width: root.width
+                        source: ApplicationManager.get(index).screenshot
+                        scale: 1
+                    }
+                    MouseArea {
+                        anchors.fill: parent
+                        onClicked: {
+                            appItem.select()
+                        }
+                    }
+
+                    SequentialAnimation {
+                        id: switchToAppAnimation
+                        property int targetContentX
+                        UbuntuNumberAnimation {
+                            target: coverFlickable;
+                            property: "contentX";
+                            to: switchToAppAnimation.targetContentX;
+                            duration: UbuntuAnimation.SnapDuration
+                        }
+                        ScriptAction {
+                            script: {
+                                ApplicationManager.focusApplication(ApplicationManager.get(index).appId);
+                                appItem.isSelected = false;
+                                coverFlip.progress = 0;
+                                coverFlickable.passedFirstStage = false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

=== added directory 'qml/Stages/graphics'
=== added file 'qml/Stages/graphics/dropshadow.png'
Binary files qml/Stages/graphics/dropshadow.png	1970-01-01 00:00:00 +0000 and qml/Stages/graphics/dropshadow.png	2014-01-22 10:43:18 +0000 differ
=== modified file 'run_on_device'
--- run_on_device	2013-11-27 11:47:14 +0000
+++ run_on_device	2014-01-22 10:43:18 +0000
@@ -103,6 +103,7 @@
         ARGS="$ARGS -k"
     fi
 
+    exec_with_ssh "killall -9 dialer-app; killall -9 gallery-app; killall -9 messaging-app; killall -9 address-book-app"
     exec_with_ssh "stop unity8"
     exec_with_ssh "start maliit-server"
     exec_with_ssh "cd $CODE_DIR/ && ./run $ARGS -- $RUN_OPTIONS"

=== modified file 'tests/mocks/Unity/Application/ApplicationInfo.h'
--- tests/mocks/Unity/Application/ApplicationInfo.h	2013-10-11 11:37:04 +0000
+++ tests/mocks/Unity/Application/ApplicationInfo.h	2014-01-22 10:43:18 +0000
@@ -19,6 +19,7 @@
 
 #include <QObject>
 #include <QQmlComponent>
+#include <QDebug>
 
 class QQuickItem;
 
@@ -56,6 +57,7 @@
     { \
         if (m_##name != value) { \
             m_##name = value; \
+    qDebug() << "emitting changed" << this << Q_FUNC_INFO; \
             Q_EMIT name##Changed(); \
         } \
     } \
@@ -74,6 +76,7 @@
     IMPLEMENT_PROPERTY(fullscreen, Fullscreen, bool)
     IMPLEMENT_PROPERTY(imageQml, ImageQml, QString)
     IMPLEMENT_PROPERTY(windowQml, WindowQml, QString)
+    IMPLEMENT_PROPERTY(screenshot, Screenshot, QUrl)
 
     #undef IMPLEMENT_PROPERTY
 

=== modified file 'tests/mocks/Unity/Application/ApplicationManager.cpp'
--- tests/mocks/Unity/Application/ApplicationManager.cpp	2013-12-17 16:04:47 +0000
+++ tests/mocks/Unity/Application/ApplicationManager.cpp	2014-01-22 10:43:18 +0000
@@ -24,6 +24,9 @@
 #include <QQuickItem>
 #include <QQuickView>
 #include <QQmlComponent>
+#include <QTimer>
+#include <QDateTime>
+#include <QDebug>
 
 ApplicationManager::ApplicationManager(QObject *parent)
     : ApplicationManagerInterface(parent)
@@ -63,6 +66,8 @@
         return app->state();
     case RoleFocused:
         return app->focused();
+    case RoleScreenshot:
+        return app->screenshot();
     default:
         return QVariant();
     }
@@ -75,7 +80,9 @@
 }
 
 ApplicationInfo *ApplicationManager::findApplication(const QString &appId) const {
+    qDebug() << "findapp called";
     for (ApplicationInfo *app : m_runningApplications) {
+        qDebug() << "searching app"<< app->appId();
         if (app->appId() == appId) {
             return app;
         }
@@ -84,8 +91,10 @@
 }
 
 void ApplicationManager::add(ApplicationInfo *application) {
-    if (!application)
+    qDebug() << "add() " << application->appId();
+    if (!application) {
         return;
+    }
 
     beginInsertRows(QModelIndex(), m_runningApplications.size(), m_runningApplications.size());
     m_runningApplications.append(application);
@@ -171,6 +180,8 @@
     }
     add(application);
 
+    QMetaObject::invokeMethod(this, "focusApplication", Qt::QueuedConnection, Q_ARG(QString, appId));
+
     return application;
 }
 
@@ -182,9 +193,33 @@
 
     remove(application);
     Q_EMIT focusedApplicationIdChanged();
+    qDebug() << Q_FUNC_INFO << "emitting focusedAppChanged" << focusedApplicationId();
     return true;
 }
 
+void ApplicationManager::updateScreenshot(const QString &appId)
+{
+    int idx = -1;
+    ApplicationInfo *application = nullptr;
+    for (int i = 0; i < m_availableApplications.count(); ++i) {
+        application = m_availableApplications.at(i);
+        if (application->appId() == appId) {
+            idx = i;
+            break;
+        }
+    }
+
+    if (idx == -1) {
+        return;
+    }
+
+    qDebug() << "setting new screenshot" << application->screenshot() << application;
+    application->setScreenshot(QString("image://application/%1/%2").arg(appId).arg(QDateTime::currentMSecsSinceEpoch()));
+    qDebug() << "set new screenshot" << application->screenshot();
+    QModelIndex appIndex = index(idx);
+    Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleScreenshot);
+}
+
 QString ApplicationManager::focusedApplicationId() const {
     for (ApplicationInfo *app : m_runningApplications) {
         if (app->focused()) {
@@ -238,10 +273,16 @@
 
     // move app to top of stack
     move(m_runningApplications.indexOf(application), 0);
+    qDebug() << Q_FUNC_INFO << "emitting focusedAppChanged" << focusedApplicationId();
     Q_EMIT focusedApplicationIdChanged();
     return true;
 }
 
+void ApplicationManager::activateApplication(const QString &appId)
+{
+    QMetaObject::invokeMethod(this, "focusRequested", Qt::QueuedConnection, Q_ARG(QString, appId));
+}
+
 void ApplicationManager::unfocusCurrentApplication()
 {
     for (ApplicationInfo *app : m_runningApplications) {
@@ -250,6 +291,7 @@
             app->setFocused(false);
         }
     }
+    qDebug() << Q_FUNC_INFO << "emitting focusedAppChanged" << focusedApplicationId();
     Q_EMIT focusedApplicationIdChanged();
 }
 
@@ -299,6 +341,7 @@
     application->setName("Phone");
     application->setIcon(QUrl("phone"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QString("image://application/%1/123456789").arg(application->appId()));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -307,6 +350,7 @@
     application->setName("Camera");
     application->setIcon(QUrl("camera"));
     application->setFullscreen(true);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -314,6 +358,7 @@
     application->setAppId("gallery-app");
     application->setName("Gallery");
     application->setIcon(QUrl("gallery"));
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -322,6 +367,7 @@
     application->setName("Facebook");
     application->setIcon(QUrl("facebook"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -329,6 +375,7 @@
     application->setAppId("webbrowser-app");
     application->setName("Browser");
     application->setIcon(QUrl("browser"));
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -337,6 +384,7 @@
     application->setName("Twitter");
     application->setIcon(QUrl("twitter"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -344,6 +392,7 @@
     application->setAppId("gmail-webapp");
     application->setName("GMail");
     application->setIcon(QUrl("gmail"));
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     m_availableApplications.append(application);
 
     application = new ApplicationInfo(this);
@@ -351,6 +400,7 @@
     application->setName("Weather");
     application->setIcon(QUrl("weather"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 
@@ -359,6 +409,7 @@
     application->setName("Notepad");
     application->setIcon(QUrl("notepad"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     m_availableApplications.append(application);
 
     application = new ApplicationInfo(this);
@@ -366,6 +417,7 @@
     application->setName("Calendar");
     application->setIcon(QUrl("calendar"));
     application->setStage(ApplicationInfo::SideStage);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     m_availableApplications.append(application);
 
     application = new ApplicationInfo(this);
@@ -373,18 +425,21 @@
     application->setName("Media Player");
     application->setIcon(QUrl("mediaplayer-app"));
     application->setFullscreen(true);
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     m_availableApplications.append(application);
 
     application = new ApplicationInfo(this);
     application->setAppId("evernote");
     application->setName("Evernote");
     application->setIcon(QUrl("evernote"));
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     m_availableApplications.append(application);
 
     application = new ApplicationInfo(this);
     application->setAppId("map");
     application->setName("Map");
     application->setIcon(QUrl("map"));
+    application->setScreenshot(QUrl("image://application/phone/123456789"));
     generateQmlStrings(application);
     m_availableApplications.append(application);
 

=== modified file 'tests/mocks/Unity/Application/ApplicationManager.h'
--- tests/mocks/Unity/Application/ApplicationManager.h	2013-10-11 11:37:04 +0000
+++ tests/mocks/Unity/Application/ApplicationManager.h	2014-01-22 10:43:18 +0000
@@ -88,10 +88,12 @@
 
     // Application control methods
     Q_INVOKABLE bool focusApplication(const QString &appId) override;
+    Q_INVOKABLE void activateApplication(const QString &appId) override;
     Q_INVOKABLE void unfocusCurrentApplication() override;
     Q_INVOKABLE ApplicationInfo *startApplication(const QString &appId, const QStringList &arguments = QStringList()) override;
     Q_INVOKABLE ApplicationInfo *startApplication(const QString &appId, ExecFlags flags, const QStringList &arguments = QStringList());
     Q_INVOKABLE bool stopApplication(const QString &appId) override;
+    Q_INVOKABLE void updateScreenshot(const QString &appId) override;
 
     QString focusedApplicationId() const override;
 

=== added file 'tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp'
--- tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp	2014-01-22 10:43:18 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2013 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * 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 "ApplicationScreenshotProvider.h"
+#include "ApplicationManager.h"
+#include "ApplicationInfo.h"
+
+#include "paths.h"
+
+#include <QDebug>
+#include <QGuiApplication>
+#include <QWindow>
+#include <QQuickWindow>
+
+ApplicationScreenshotProvider::ApplicationScreenshotProvider(ApplicationManager *appManager)
+    : QQuickImageProvider(QQuickImageProvider::Image)
+    , m_appManager(appManager)
+{
+}
+
+QImage ApplicationScreenshotProvider::requestImage(const QString &imageId, QSize * size,
+                                                     const QSize &requestedSize)
+{
+    // We ignore requestedSize here intentionally to avoid keeping scaled copies around
+    Q_UNUSED(requestedSize)
+
+    QString appId = imageId.split('/').first();
+
+    ApplicationInfo* app = static_cast<ApplicationInfo*>(m_appManager->findApplication(appId));
+    if (app == NULL) {
+        qDebug() << "ApplicationScreenshotProvider - app not found:" << appId;
+        return QImage();
+    }
+
+    QString filePath = QString("%1/Dash/graphics/phone/screenshots/[e-mail]").arg(qmlDirectory()).arg(app->icon().toString());
+
+    QImage image;
+    if (!image.load(filePath)) {
+        qDebug() << "failed loading app image" << filePath;
+    }
+
+    QGuiApplication *unity = qobject_cast<QGuiApplication*>(qApp);
+
+    Q_FOREACH (QWindow *win, unity->allWindows()) {
+        QQuickWindow *quickWin = qobject_cast<QQuickWindow*>(win);
+        if (quickWin) {
+            image = image.scaledToWidth(quickWin->width());
+        }
+    }
+
+    size->setWidth(image.width());
+    size->setHeight(image.height());
+    qDebug() << "got image of size" << size->width() << size->height() << requestedSize;
+
+    return image;
+}

=== added file 'tests/mocks/Unity/Application/ApplicationScreenshotProvider.h'
--- tests/mocks/Unity/Application/ApplicationScreenshotProvider.h	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/Application/ApplicationScreenshotProvider.h	2014-01-22 10:43:18 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2013 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * 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 APPLICATIONSCREENSHOTPROVIDER_H
+#define APPLICATIONSCREENSHOTPROVIDER_H
+
+#include <QQuickImageProvider>
+
+class ApplicationManager;
+class ApplicationScreenshotProvider : public QQuickImageProvider
+{
+public:
+    explicit ApplicationScreenshotProvider(ApplicationManager *appManager);
+
+    QImage requestImage(const QString &appId, QSize *size, const QSize &requestedSize) override;
+
+private:
+    ApplicationManager* m_appManager;
+};
+
+#endif // APPLICATIONSCREENSHOTPROVIDER_H

=== modified file 'tests/mocks/Unity/Application/CMakeLists.txt'
--- tests/mocks/Unity/Application/CMakeLists.txt	2013-12-13 01:02:53 +0000
+++ tests/mocks/Unity/Application/CMakeLists.txt	2014-01-22 10:43:18 +0000
@@ -5,6 +5,7 @@
     ApplicationInfo.cpp
     ApplicationImage.cpp
     ApplicationManager.cpp
+    ApplicationScreenshotProvider.cpp
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
 )

=== modified file 'tests/mocks/Unity/Application/plugin.cpp'
--- tests/mocks/Unity/Application/plugin.cpp	2013-09-11 15:33:02 +0000
+++ tests/mocks/Unity/Application/plugin.cpp	2014-01-22 10:43:18 +0000
@@ -18,13 +18,20 @@
 #include "ApplicationInfo.h"
 #include "ApplicationImage.h"
 #include "ApplicationManager.h"
+#include "ApplicationScreenshotProvider.h"
 
 #include <qqml.h>
+#include <QQmlEngine>
+
+ApplicationManager *s_appManager = 0;
 
 static QObject* applicationManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
-  Q_UNUSED(engine);
-  Q_UNUSED(scriptEngine);
-  return new ApplicationManager();
+    Q_UNUSED(engine);
+    Q_UNUSED(scriptEngine);
+    if (!s_appManager) {
+        s_appManager = new ApplicationManager();
+    }
+    return s_appManager;
 }
 
 void FakeUnityApplicationQmlPlugin::registerTypes(const char *uri)
@@ -37,3 +44,11 @@
 
     qmlRegisterType<ApplicationImage>(uri, 0, 1, "ApplicationImage");
 }
+
+void FakeUnityApplicationQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+{
+    QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    ApplicationManager* appManager = static_cast<ApplicationManager*>(applicationManagerSingleton(engine, NULL));
+    engine->addImageProvider(QLatin1String("application"), new ApplicationScreenshotProvider(appManager));
+}

=== modified file 'tests/mocks/Unity/Application/plugin.h'
--- tests/mocks/Unity/Application/plugin.h	2013-09-04 13:42:27 +0000
+++ tests/mocks/Unity/Application/plugin.h	2014-01-22 10:43:18 +0000
@@ -25,6 +25,7 @@
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
 public:
     void registerTypes(const char *uri);
+    void initializeEngine(QQmlEngine *engine, const char *uri);
 };
 
 #endif

=== modified file 'tests/plugins/Unity/Launcher/launchermodeltest.cpp'
--- tests/plugins/Unity/Launcher/launchermodeltest.cpp	2013-09-16 17:59:13 +0000
+++ tests/plugins/Unity/Launcher/launchermodeltest.cpp	2014-01-22 10:43:18 +0000
@@ -39,6 +39,7 @@
     ApplicationInfoInterface::Stage stage() const { return ApplicationInfoInterface::MainStage; }
     ApplicationInfoInterface::State state() const { return ApplicationInfoInterface::Running; }
     bool focused() const { return m_focused; }
+    QUrl screenshot() const { return QUrl(); }
 
     // Methods used for mocking (not in the interface)
     void setFocused(bool focused) { m_focused = focused; Q_EMIT focusedChanged(focused); }
@@ -92,6 +93,8 @@
         m_list.takeAt(index)->deleteLater();
         endRemoveRows();
     }
+    void updateScreenshot(const QString &appId) { Q_UNUSED(appId); }
+    void activateApplication(const QString &appId) { Q_UNUSED(appId); }
 
 private:
     QList<MockApp*> m_list;

=== modified file 'tests/qmltests/tst_Shell.qml'
--- tests/qmltests/tst_Shell.qml	2014-01-16 12:37:57 +0000
+++ tests/qmltests/tst_Shell.qml	2014-01-22 10:43:18 +0000
@@ -117,6 +117,7 @@
             while (apps.count > 0) {
                 ApplicationManager.stopApplication(apps.get(0).appId);
             }
+            compare(ApplicationManager.count, 0)
         }
 
         /*
@@ -182,28 +183,34 @@
         function test_suspend() {
             var greeter = findChild(shell, "greeter");
 
+            print("step1")
             // Launch an app from the launcher
             dragLauncherIntoView();
             tapOnAppIconInLauncher();
             waitUntilApplicationWindowIsFullyVisible();
 
+            print("step2")
             var mainApp = ApplicationManager.focusedApplicationId;
             verify(mainApp != "");
 
+            print("step3")
             // Try to suspend while proximity is engaged...
             Powerd.displayPowerStateChange(Powerd.Off, Powerd.UseProximity);
             tryCompare(greeter, "showProgress", 0);
 
+            print("step4")
             // Now really suspend
             Powerd.displayPowerStateChange(Powerd.Off, 0);
             tryCompare(greeter, "showProgress", 1);
             tryCompare(ApplicationManager, "focusedApplicationId", "");
 
+            print("step5")
             // And wake up
             Powerd.displayPowerStateChange(Powerd.On, 0);
             tryCompare(ApplicationManager, "focusedApplicationId", "");
             tryCompare(greeter, "showProgress", 1);
 
+            print("step6")
             // Swipe away greeter to focus app
             swipeAwayGreeter();
             tryCompare(ApplicationManager, "focusedApplicationId", mainApp);
@@ -503,6 +510,8 @@
 
         function test_DashShown(data) {
 
+            print("step1")
+            // greeter: false,
             if (data.greeter) {
                 // Swipe the greeter in
                 var greeter = findChild(shell, "greeter");
@@ -510,21 +519,31 @@
                 tryCompare(greeter, "showProgress", 1);
             }
 
+            print("step2")
+            //app: false,
             if (data.app) {
                 dragLauncherIntoView();
                 tapOnAppIconInLauncher();
             }
 
+            print("step3")
+            // launcher: true,
             if (data.launcher) {
                 dragLauncherIntoView();
             }
 
+            print("step4")
+            // indicators: false,
             if (data.indicators) {
                 showIndicators();
             }
 
+            print("step5")
+            //expectedShown: true},
             var dash = findChild(shell, "dash");
+            print("step6", dash, dash.shown, data.expectedShown)
             tryCompare(dash, "shown", data.expectedShown);
+            print("step7")
         }
 
         function test_searchIndicatorHidesOnAppFocus() {