Merge lp:~unity-team/unity8/dash-as-app into lp:unity8

[Michael Zanetti]

Split the dash from the shell into a separate app

### Notes for reviewers ###

* It depends on QtCompositor (silo 6). Alternatively this and qtcomp rc can be installed through ppa:unity-team/phone-right-edge

* Adds an upstart script to autolaunch and respawn the dash app.

* Introduces a new plugin DashCommunicator which consists of a server and a client part, to be used to communicate between shell and dash.

* Adds a mock plugin for the DashCommunicator plugin

* Drops a whole bunch of useless stuff from MockApplicationManager which isn't needed any more since QtCompositor. (The fake placing of surfaces behind the shell - as unity-mir did it.). This could/should have been gone earlier, but only became a visible issue with this branch. Those changes are isolated in commit 1099.

* Adds a fake unity8-dash app (screenshot) to MockApplicationManager which will always be there, simulating the running dash app.

* Drops some code and tests for stages in/out dragging, given the dash is a regular app now, the stages are always visible now.

* Updates/simplifies shell and dash tests for the split app scenario.

* Does some slight updates to the Stages to keep the Dash behind the current app when not in spread mode so a left edge flick still shows the dash behind the app.

### Still TODO ###

* Make autopilot work again

### Checklist ###

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

https://code.launchpad.net/~unity-team/unity-scopes-shell/drop-appid-workaround/+merge/228427
https://code.launchpad.net/~dandrader/qtmir/fix_lp1350917/+merge/229585

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

Yes, works fine for me, except launching apps from dash and AP (see TODO section)

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

Yes.

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?

I added the additional binary and upstart script to installs, to be reviewed.

 * If you changed the UI, has there been a design review?

Vesa is on holiday atm. I tried to keep UI changes as minimal as possible to fulfill the design request of adding the dash into the spread. So should be good I hope.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1127
http://jenkins.qa.ubuntu.com/job/unity8-ci/3642/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2593/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/644/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/736/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/736/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/736/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3836/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1130
http://jenkins.qa.ubuntu.com/job/unity8-ci/3645/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2629/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/647/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/739/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/739/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/739/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3872/console

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

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

"""
Q_SIGNALS:
    void setCurrentScope(const QString &scopeId, bool animate, bool reset);
"""

Naming signals like functions is never a good thing. I would make an effort to name it like a signal. "requestedScopeAsCurrent" or even "setCurrentScopeCalled" would do it.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> """
> Q_SIGNALS:
> void setCurrentScope(const QString &scopeId, bool animate, bool reset);
> """
>
> Naming signals like functions is never a good thing. I would make an effort to
> name it like a signal. "requestedScopeAsCurrent" or even
> "setCurrentScopeCalled" would do it.

That's in DashCommunicatorService and DBusDashCommunicatorService, to be clear.

[Daniel d'Andrada (dandrader)]

Jouni says nothing should happen when you do a right-edge drag and there's no app running. That is, when you have just the dash).

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

1 - long press power button
<shutdown dialog shows up>
2 - press "Restart"

Expected outcome:
The device reboots

Actual outcome:
You see the dash being restarted behind the dialog and that's it.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

1 - Launch an app or two
2 - go to the spread
3 - reveal the launcher
4 - tap on the ubuntu/dash icon

expected outcome:
Dash is focused

actual outcome:
Nothing happens

review: Needs Fixing

[Michael Zanetti (mzanetti)]

> Jouni says nothing should happen when you do a right-edge drag and there's no
> app running. That is, when you have just the dash).

This doesn't line up with an explicit request from Vesa to not have any difference on the behavior regardless of the amount of apps.

[Daniel d'Andrada (dandrader)]

> 1 - long press power button
> <shutdown dialog shows up>
> 2 - press "Restart"
>
> Expected outcome:
> The device reboots
>
> Actual outcome:
> You see the dash being restarted behind the dialog and that's it.

Hold on on that as it might be a general qtcomp issue :(

[Michael Zanetti (mzanetti)]

> """
> Q_SIGNALS:
> void setCurrentScope(const QString &scopeId, bool animate, bool reset);
> """
>
> Naming signals like functions is never a good thing. I would make an effort to
> name it like a signal. "requestedScopeAsCurrent" or even
> "setCurrentScopeCalled" would do it.

fixed

[Michael Zanetti (mzanetti)]

> """
> Q_SIGNALS:
> void setCurrentScope(const QString &scopeId, bool animate, bool reset);
> """
>
> Naming signals like functions is never a good thing. I would make an effort to
> name it like a signal. "requestedScopeAsCurrent" or even
> "setCurrentScopeCalled" would do it.

fixed

[Michael Zanetti (mzanetti)]

> 1 - Launch an app or two
> 2 - go to the spread
> 3 - reveal the launcher
> 4 - tap on the ubuntu/dash icon
>
> expected outcome:
> Dash is focused
>
> actual outcome:
> Nothing happens

Hmm, this works fine for me on the phone and in testShell. Is there any log output when this issue happens for you?

[Daniel d'Andrada (dandrader)]

> > 1 - Launch an app or two
> > 2 - go to the spread
> > 3 - reveal the launcher
> > 4 - tap on the ubuntu/dash icon
> >
> > expected outcome:
> > Dash is focused
> >
> > actual outcome:
> > Nothing happens
>
> Hmm, this works fine for me on the phone and in testShell. Is there any log
> output when this issue happens for you?

It works if an app is the currently focused app but not if unity8-dash itself is the focused guy

- have some apps open
- go to dash
- right-edge to show spread
- left-edge to show launcher
- tap dash button

[Daniel d'Andrada (dandrader)]

Did you add a 0 bytes qml/Dash/graphics/phone/screenshots/dash.png?

It would be good to save some kilobytes by making [e-mail] 480 pixels wide like all other screenshots. Afterall they're used only in a rather small windows in the qml tests.

[Daniel d'Andrada (dandrader)]

> Did you add a 0 bytes qml/Dash/graphics/phone/screenshots/dash.png?
>
> It would be good to save some kilobytes by making [e-mail] 480
> pixels wide like all other screenshots. Afterall they're used only in a rather
> small windows in the qml tests.

Btw, you would have to rewrite history to fix that, as otherwise we would end up with two images in the bzr history (leading to slower "bzr branch" commands), defeating the idea.

[Daniel d'Andrada (dandrader)]

1 - have the greeter on (like turn the display off and on)
2 - do a full left-edge drag

expected outcome:
greeter goes away for goo

actual outcome:
greeter goes back into place

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

+++ qml/Stages/PhoneStage.qml 2014-07-27 01:55:40 +0000
@@ -116,6 +117,8 @@ Item {
         contentWidth: spreadRow.width - shift
         contentX: -shift

+ readonly property bool isActive: shiftedContentX > 0 || spreadDragArea.dragging
+
         // The flickable needs to fill the screen in order to get touch events all over.
         // However, we don't want to the user to be able to scroll back all the way. For
         // that, the beginning of the gesture starts with a negative value for contentX

In QML (unlike in C++) boolean properties are named simply "foo", not "isFoo". I would choose a less overloaded/generic term than "active" if possible. What's the difference between being "active" and being "interactive". I would add a comment explaining what it means to be "active" there.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> +++ qml/Stages/PhoneStage.qml 2014-07-27 01:55:40 +0000
> @@ -116,6 +117,8 @@ Item {
> contentWidth: spreadRow.width - shift
> contentX: -shift
>
> + readonly property bool isActive: shiftedContentX > 0 ||
> spreadDragArea.dragging
> +
> // The flickable needs to fill the screen in order to get touch
> events all over.
> // However, we don't want to the user to be able to scroll back all
> the way. For
> // that, the beginning of the gesture starts with a negative value
> for contentX
>
>
> In QML (unlike in C++) boolean properties are named simply "foo", not "isFoo".
> I would choose a less overloaded/generic term than "active" if possible.
> What's the difference between being "active" and being "interactive". I would
> add a comment explaining what it means to be "active" there.

Which doesn't apply here as "Dash" is not an adjective.

+ readonly property bool isDash: model.appId == "unity8-dash"

[Daniel d'Andrada (dandrader)]

In SpreadDelegate.qml:
+ if (model.appId == "unity8-dash") {

That messes up with encapsulation. You should declare it a as SpreadDelegate property and fill it up in PhoneStage instead.

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

+ onIsActiveChanged: print("spreadView isActive changed", isActive)

Debug stuff in TabletStage.

review: Needs Fixing

[Michael Zanetti (mzanetti)]

> > Did you add a 0 bytes qml/Dash/graphics/phone/screenshots/dash.png?
> >
> > It would be good to save some kilobytes by making [e-mail] 480
> > pixels wide like all other screenshots. Afterall they're used only in a
> rather
> > small windows in the qml tests.
>
> Btw, you would have to rewrite history to fix that, as otherwise we would end
> up with two images in the bzr history (leading to slower "bzr branch"
> commands), defeating the idea.

fixed

[Michael Zanetti (mzanetti)]

> 1 - have the greeter on (like turn the display off and on)
> 2 - do a full left-edge drag
>
> expected outcome:
> greeter goes away for goo
>
> actual outcome:
> greeter goes back into place

fixed

[Michael Zanetti (mzanetti)]

> +++ qml/Stages/PhoneStage.qml 2014-07-27 01:55:40 +0000
> @@ -116,6 +117,8 @@ Item {
> contentWidth: spreadRow.width - shift
> contentX: -shift
>
> + readonly property bool isActive: shiftedContentX > 0 ||
> spreadDragArea.dragging
> +
> // The flickable needs to fill the screen in order to get touch
> events all over.
> // However, we don't want to the user to be able to scroll back all
> the way. For
> // that, the beginning of the gesture starts with a negative value
> for contentX
>
>
> In QML (unlike in C++) boolean properties are named simply "foo", not "isFoo".
> I would choose a less overloaded/generic term than "active" if possible.
> What's the difference between being "active" and being "interactive". I would
> add a comment explaining what it means to be "active" there.

I added a comment. I tend to agree that the "is*" is quite uncommon for qml, however, as you realized yourself just "active" is a bit overloaded and I think isActive describes best what's happening. I kept the name but added a comment what it does.

[Michael Zanetti (mzanetti)]

> In SpreadDelegate.qml:
> + if (model.appId == "unity8-dash") {
>
> That messes up with encapsulation. You should declare it a as SpreadDelegate
> property and fill it up in PhoneStage instead.

Well, its a "Delegate" so imo fine that it accesses model.* stuff. Also, there's quite a lot of other places where we access model.* stuff, fir instance model.surface.

Maybe this file could be split at some point to be a SpreadDelegate handling the model.stuff and then move the SurfaceContainer into a separate file that doesn't know anything about the model any more. IMO out of scope of this MP though.

[Michael Zanetti (mzanetti)]

> + onIsActiveChanged: print("spreadView isActive changed", isActive)
>
> Debug stuff in TabletStage.

fixed

[Michael Zanetti (mzanetti)]

> > > 1 - Launch an app or two
> > > 2 - go to the spread
> > > 3 - reveal the launcher
> > > 4 - tap on the ubuntu/dash icon
> > >
> > > expected outcome:
> > > Dash is focused
> > >
> > > actual outcome:
> > > Nothing happens
> >
> > Hmm, this works fine for me on the phone and in testShell. Is there any log
> > output when this issue happens for you?
>
> It works if an app is the currently focused app but not if unity8-dash itself
> is the focused guy
>
> - have some apps open
> - go to dash
> - right-edge to show spread
> - left-edge to show launcher
> - tap dash button

Fixed in here for the MockApplicationManager and fixed for qtmir in https://code.launchpad.net/~mzanetti/qtmir/always-forward-focus-requests/+merge/228659

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1131
http://jenkins.qa.ubuntu.com/job/unity8-ci/3653/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2640/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/655/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/747/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/747/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/747/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3883/console

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

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In PhoneStage:

+ // Hiding tiles when their progress is negative or reached the maximum
+ visible: (progress >= 0 && progress < 1.7) ||
+ (model.appId == "unity8-dash" && priv.focusedAppDelegate.x !== 0)

s/model.appId == "unity8-dash"/isDash

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> > In SpreadDelegate.qml:
> > + if (model.appId == "unity8-dash") {
> >
> > That messes up with encapsulation. You should declare it a as SpreadDelegate
> > property and fill it up in PhoneStage instead.
>
> Well, its a "Delegate" so imo fine that it accesses model.* stuff. Also,
> there's quite a lot of other places where we access model.* stuff, fir
> instance model.surface.

Makes it cumbersome at best to write a tst_SpreadDelegate for instance. But ok, I'm already changing that in the app lifecycle patch I'm working on top of yours so I can change that line there as well.

[Michael Zanetti (mzanetti)]

> In PhoneStage:
>
> + // Hiding tiles when their progress is negative or
> reached the maximum
> + visible: (progress >= 0 && progress < 1.7) ||
> + (model.appId == "unity8-dash" &&
> priv.focusedAppDelegate.x !== 0)
>
> s/model.appId == "unity8-dash"/isDash

fixed

[Daniel d'Andrada (dandrader)]

Looking good.
Thanks!

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1130
http://jenkins.qa.ubuntu.com/job/unity8-ci/3713/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2851
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/715
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/807
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/807
        deb: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/807/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/807
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/2925
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4094
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4094/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10795

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

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

FWIW, run_on_device will get quite broken with this. We need a think whether we can fix it quickly or do we need to leave it for later.

[Michał Sawicz (saviq)]

Failure in qmltests:

qml/Dash/Dash.qml:35:9: Cannot assign to non-existent property "onSetCurrentScopeRequested"

review: Needs Fixing

[lp:~unity-team/unity8/dash-as-app]

1109. By Daniel d'Andrada on 2014-08-05

Merge trunk

[ Gerry Boland ]
* Fix the run.sh script - pretend to be running with qtmir and emit
  SIGSTOP at the right time
[ Ying-Chun Liu ]
* Implement Attribute UI. (LP: #1282460)
[ Albert Astals ]
* Hide search history popup as soon as you start typing As discussed
  with Mike and Saviq
* Compile with for scopes-v3 unity-api
* PageHeader: Unfocus search field when search entry is selected
* Show search field if the search query changes
* Test: Add a condition for art.height being > 0 means stuff has
  already been layouted a bit without it it can happen that we get 0
  for everything at startup and tests still pass
* Remove leftover in test of an old headerless implementation
[ Michael Zanetti ]
* Drop Recent apps category from Dash (LP: #1281092)
* update launcher count emblems to match new spec (LP: #1338984)
[ Bill Filler ]
* disable predictive text for dash search field (LP: #1340409)
[ CI bot ]
* Resync trunk
[ Antti Kaijanmäki ]
* DefaultIndicatorPage: use Loader status to determine the visible
  property. (LP: #1350555)
[ Michael Terry ]
* Check user's pin/password using PAM, instead of a plaintext keyfile.
  New build dependency: libpam0g-dev for phone unlock with PAM (LP:
  #1234983)
[ Ubuntu daily release ]
* New rebuild forced

1110. By Daniel d'Andrada on 2014-08-05

Update DashCommunicator mock plugin

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1130
http://jenkins.qa.ubuntu.com/job/unity8-ci/3753/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/3017
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/755
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/847
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/847
        deb: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/847/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/847
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/3065
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4260
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4260/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10975

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

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

All tests passed locally now.

review: Approve

[Michał Sawicz (saviq)]

 * Did you perform an exploratory manual test run of the code change and any related functionality?
Yes. Extensive testing in silo 7.

 * Did CI run pass? If not, please explain why.
No, ap failures fixed in the prerequisite branch and unrelated qmltests failures otherwise.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1110
http://jenkins.qa.ubuntu.com/job/unity8-ci/3755/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/3031
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/757
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/849
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/849
        deb: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/849/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/849
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/3075
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4274
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4274/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10997

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

review: Needs Fixing (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-06-11 15:36:51 +0000
+++ CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -96,6 +96,7 @@
 declare_autopilot_test(shell unity8.shell ${CMAKE_SOURCE_DIR}/tests/autopilot/)
 
 set(SHELL_APP unity8)
+set(DASH_APP unity8-dash)
 set(SCOPE_TOOL unity-scope-tool)
 
 include_directories(
 
=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2014-06-11 15:36:51 +0000
+++ data/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -1,7 +1,10 @@
-# generate desktop file
+# generate desktop files
 configure_file(${SHELL_APP}.desktop.in ${CMAKE_CURRENT_BINARY_DIR}/${SHELL_APP}.desktop @ONLY)
+configure_file(${DASH_APP}.desktop.in ${CMAKE_CURRENT_BINARY_DIR}/${DASH_APP}.desktop @ONLY)
 
 # install desktop files
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${SHELL_APP}.desktop
+install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/${SHELL_APP}.desktop
+    ${CMAKE_CURRENT_BINARY_DIR}/${DASH_APP}.desktop
     DESTINATION ${CMAKE_INSTALL_DATADIR}/applications
     )
 
=== added file 'data/unity8-dash.conf'
--- data/unity8-dash.conf	1970-01-01 00:00:00 +0000
+++ data/unity8-dash.conf	2014-08-05 11:53:58 +0000
@@ -0,0 +1,22 @@
+description "Unity Shell v8 Dash"
+author "Michael Zanetti <[e-mail]>"
+
+emits scope-ui-starting
+
+start on started unity8
+stop on stopping unity8
+
+kill timeout 120
+
+respawn
+
+pre-start script
+    if [ -z "$UNITY_SCOPES_LIST" ]; then
+        # FIXME: remove once we have this in dconf
+        initctl set-env UNITY_SCOPES_LIST="scopes;clickscope;musicaggregator;videoaggregator"
+    fi
+
+    initctl emit scope-ui-starting
+end script
+
+exec ${BINARY:-unity8-dash} $ARGS --desktop_file_hint=/usr/share/applications/unity8-dash.desktop
 
=== added file 'data/unity8-dash.desktop.in'
--- data/unity8-dash.desktop.in	1970-01-01 00:00:00 +0000
+++ data/unity8-dash.desktop.in	2014-08-05 11:53:58 +0000
@@ -0,0 +1,9 @@
+[Desktop Entry]
+Type=Application
+Name=Unity 8 Dash
+Comment=The converged Unity shell dash
+Exec=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_BINDIR@/unity8-dash
+Terminal=false
+Icon=unity8
+NoDisplay=true
+X-Ubuntu-Touch=true
 
=== modified file 'data/unity8.conf'
--- data/unity8.conf	2014-07-18 16:40:56 +0000
+++ data/unity8.conf	2014-08-05 11:53:58 +0000
@@ -1,7 +1,7 @@
 description "Unity Shell v8"
 author "Ricardo Mendoza <[e-mail]>"
 
-emits scope-ui-starting indicator-services-start
+emits indicator-services-start
 
 start on ((xsession SESSION=ubuntu-touch) or (xsession SESSION=ubuntu-touch-surfaceflinger)) and started dbus
 stop on desktop-end
@@ -34,11 +34,6 @@
         gdbus call --session --dest org.freedesktop.DBus --object-path /org/freedesktop/DBus --method org.freedesktop.DBus.UpdateActivationEnvironment "@a{ss} {'MIR_SOCKET': '$MIR_SERVER_FILE'}"
     fi
 
-    if [ -z "$UNITY_SCOPES_LIST" ]; then
-        # FIXME: remove once we have this in dconf
-        initctl set-env UNITY_SCOPES_LIST="scopes;clickscope;musicaggregator;videoaggregator"
-    fi
-
     # Remove the socket if still there
     if [ -S "$MIR_SERVER_FILE" ]; then
         rm "$MIR_SERVER_FILE"
@@ -46,7 +41,6 @@
 
     initctl set-env --global MIR_SERVER_PROMPT_FILE=1
 
-    initctl emit scope-ui-starting
     initctl emit --no-wait indicator-services-start
 end script
 
 
=== modified file 'debian/unity8.install'
--- debian/unity8.install	2014-07-08 18:53:52 +0000
+++ debian/unity8.install	2014-08-05 11:53:58 +0000
@@ -1,6 +1,9 @@
 data/unity8.conf usr/share/upstart/sessions/
+data/unity8-dash.conf usr/share/upstart/sessions/
 usr/bin/unity8
+usr/bin/unity8-dash
 usr/share/applications/unity8.desktop
+usr/share/applications/unity8-dash.desktop
 usr/share/unity8/Greeter
 usr/share/unity8/Hud
 usr/share/unity8/Launcher
 
=== modified file 'plugins/Unity/CMakeLists.txt'
--- plugins/Unity/CMakeLists.txt	2014-07-08 19:09:35 +0000
+++ plugins/Unity/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -1,3 +1,4 @@
 add_subdirectory(Indicators)
 add_subdirectory(Launcher)
 add_subdirectory(Session)
+add_subdirectory(DashCommunicator)
 
=== added directory 'plugins/Unity/DashCommunicator'
=== added file 'plugins/Unity/DashCommunicator/CMakeLists.txt'
--- plugins/Unity/DashCommunicator/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -0,0 +1,19 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(QMLDASHCOMMUNICATORPLUGIN_SRC
+    plugin.cpp
+    dbusdashcommunicatorservice.cpp
+    dashcommunicatorservice.cpp
+    dashcommunicator.cpp
+    )
+
+add_library(DashCommunicator-qml MODULE
+    ${QMLDASHCOMMUNICATORPLUGIN_SRC}
+    )
+
+qt5_use_modules(DashCommunicator-qml DBus Qml)
+
+# export the qmldir and qmltypes files
+add_unity8_plugin(Unity.DashCommunicator 0.1 Unity/DashCommunicator TARGETS DashCommunicator-qml)
 
=== added file 'plugins/Unity/DashCommunicator/dashcommunicator.cpp'
--- plugins/Unity/DashCommunicator/dashcommunicator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dashcommunicator.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2014 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 "dashcommunicator.h"
+
+#include <QObject>
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDebug>
+
+DashCommunicator::DashCommunicator(QObject *parent):
+    QObject(parent)
+{
+}
+
+DashCommunicator::~DashCommunicator()
+{
+}
+
+
+void DashCommunicator::setCurrentScope(const QString &scopeId, bool animate, bool reset)
+{
+    QDBusConnection connection = QDBusConnection::sessionBus();
+    QDBusInterface dashIface ("com.canonical.UnityDash",
+                           "/com/canonical/UnityDash",
+                           "",
+                           connection);
+
+    dashIface.call("SetCurrentScope", scopeId, animate, reset);
+}
 
=== added file 'plugins/Unity/DashCommunicator/dashcommunicator.h'
--- plugins/Unity/DashCommunicator/dashcommunicator.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dashcommunicator.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 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 DASHCOMMUNICATOR_H
+#define DASHCOMMUNICATOR_H
+
+#include <QObject>
+
+class DashCommunicator: public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.DashCommunicator")
+
+public:
+    DashCommunicator(QObject *parent = 0);
+    ~DashCommunicator();
+
+public Q_SLOTS:
+    void setCurrentScope(const QString &scopeId, bool animate, bool reset);
+};
+
+#endif
 
=== added file 'plugins/Unity/DashCommunicator/dashcommunicatorservice.cpp'
--- plugins/Unity/DashCommunicator/dashcommunicatorservice.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dashcommunicatorservice.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2014 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 "dashcommunicatorservice.h"
+
+DashCommunicatorService::DashCommunicatorService(QObject *parent):
+    QObject(parent),
+    m_dbusService(new DBusDashCommunicatorService(this))
+{
+    connect(m_dbusService, &DBusDashCommunicatorService::setCurrentScopeRequested, this, &DashCommunicatorService::setCurrentScopeRequested);
+}
+
+
+DashCommunicatorService::~DashCommunicatorService()
+{
+
+}
 
=== added file 'plugins/Unity/DashCommunicator/dashcommunicatorservice.h'
--- plugins/Unity/DashCommunicator/dashcommunicatorservice.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dashcommunicatorservice.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2014 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 DASHCOMMUNICATORSERVICE_H
+#define DASHCOMMUNICATORSERVICE_H
+
+#include "dbusdashcommunicatorservice.h"
+
+#include <QObject>
+
+class DashCommunicatorService: public QObject
+{
+    Q_OBJECT
+public:
+    DashCommunicatorService(QObject *parent = 0);
+    ~DashCommunicatorService();
+
+Q_SIGNALS:
+    void setCurrentScopeRequested(const QString &scopeId, bool animate, bool reset);
+
+private:
+    DBusDashCommunicatorService *m_dbusService;
+};
+
+#endif // DBUSUNITYSESSIONSERVICE_H
 
=== added file 'plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.cpp'
--- plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 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 "dbusdashcommunicatorservice.h"
+
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDebug>
+
+DBusDashCommunicatorService::DBusDashCommunicatorService(QObject *parent):
+    QObject(parent)
+{
+    QDBusConnection connection = QDBusConnection::sessionBus();
+
+    connection.registerService("com.canonical.UnityDash");
+    connection.registerObject("/com/canonical/UnityDash", this, QDBusConnection::ExportScriptableSlots);
+}
+
+DBusDashCommunicatorService::~DBusDashCommunicatorService()
+{
+}
+
+void DBusDashCommunicatorService::SetCurrentScope(const QString &scopeId, bool animate, bool reset)
+{
+    Q_EMIT setCurrentScopeRequested(scopeId, animate, reset);
+}
 
=== added file 'plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h'
--- plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/dbusdashcommunicatorservice.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 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 DBUSDASHCOMMUNICATORSERVICE_H
+#define DBUSDASHCOMMUNICATORSERVICE_H
+
+#include <QObject>
+
+class DBusDashCommunicatorService: public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.DashCommunicator")
+
+public:
+    DBusDashCommunicatorService(QObject *parent = 0);
+    ~DBusDashCommunicatorService();
+
+Q_SIGNALS:
+    void setCurrentScopeRequested(const QString &scopeId, bool animate, bool reset);
+
+public Q_SLOTS:
+    Q_SCRIPTABLE void SetCurrentScope(const QString &scopeId, bool animate, bool reset);
+
+};
+
+#endif // DBUSUNITYSESSIONSERVICE_H
 
=== added file 'plugins/Unity/DashCommunicator/plugin.cpp'
--- plugins/Unity/DashCommunicator/plugin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/plugin.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ */
+
+#include "plugin.h"
+#include "dashcommunicator.h"
+#include "dashcommunicatorservice.h"
+
+#include <QDBusConnection>
+#include <QtQml/qqml.h>
+
+void DashCommunicatorPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QStringLiteral("Unity.DashCommunicator"));
+    qmlRegisterType<DashCommunicatorService>(uri, 0, 1, "DashCommunicatorService");
+    qmlRegisterType<DashCommunicator>(uri, 0, 1, "DashCommunicator");
+}
 
=== added file 'plugins/Unity/DashCommunicator/plugin.h'
--- plugins/Unity/DashCommunicator/plugin.h	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/plugin.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ */
+
+#ifndef DASHCOMMUNICATOR_PLUGIN_H
+#define DASHCOMMUNICATOR_PLUGIN_H
+
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlExtensionPlugin>
+
+class DashCommunicatorPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif
 
=== added file 'plugins/Unity/DashCommunicator/qmldir'
--- plugins/Unity/DashCommunicator/qmldir	1970-01-01 00:00:00 +0000
+++ plugins/Unity/DashCommunicator/qmldir	2014-08-05 11:53:58 +0000
@@ -0,0 +1,3 @@
+module Unity.DashCommunicator
+plugin DashCommunicator-qml
+typeinfo DashCommunicator.qmltypes
 
=== modified file 'plugins/Unity/Launcher/launchermodel.cpp'
--- plugins/Unity/Launcher/launchermodel.cpp	2014-07-25 11:29:56 +0000
+++ plugins/Unity/Launcher/launchermodel.cpp	2014-08-05 11:53:58 +0000
@@ -317,6 +317,11 @@
         return;
     }
 
+    if (app->appId() == "unity8-dash") {
+        // Not adding the dash app
+        return;
+    }
+
     bool found = false;
     Q_FOREACH(LauncherItem *item, m_list) {
         if (app->appId() == item->appId()) {
 
=== modified file 'qml/Components/EdgeDemo.qml'
--- qml/Components/EdgeDemo.qml	2014-06-11 15:36:51 +0000
+++ qml/Components/EdgeDemo.qml	2014-08-05 11:53:58 +0000
@@ -22,7 +22,6 @@
     id: demo
 
     property Item greeter
-    property Item dash
     property Item launcher
     property Item indicators
     property Item underlay
@@ -144,7 +143,7 @@
                 "edge": "top",
                 "title": i18n.tr("Top edge"),
                 "text": i18n.tr("Try swiping from the top edge to access the indicators"),
-                "anchors.fill": demo.dash,
+                "anchors.fill": demo.underlay,
             });
         }
         if (d.topEdgeDemo) {
@@ -193,12 +192,12 @@
     function startLeftEdgeDemo() {
         demo.panelEnabled = false;
         demo.launcherEnabled = true;
-        if (demo.dash && demo.underlay) {
+        if (demo.underlay) {
             d.leftEdgeDemo = d.overlay.createObject(demo.underlay, {
                 "edge": "left",
                 "title": i18n.tr("Left edge"),
                 "text": i18n.tr("Swipe from the left to reveal the launcher for quick access to apps"),
-                "anchors.fill": demo.dash,
+                "anchors.fill": demo.underlay,
             });
         }
         if (d.leftEdgeDemo) {
@@ -221,12 +220,12 @@
 
     function startFinalEdgeDemo() {
         demo.launcherEnabled = false;
-        if (demo.dash && demo.underlay) {
+        if (demo.underlay) {
             d.finalEdgeDemo = d.overlay.createObject(demo.underlay, {
                 "edge": "none",
                 "title": i18n.tr("Well done"),
                 "text": i18n.tr("You have now mastered the edge gestures and can start using the phone<br><br>Tap on the screen to start"),
-                "anchors.fill": demo.dash,
+                "anchors.fill": demo.underlay,
                 "showSkip": false,
             });
         }
 
=== modified file 'qml/Dash/Dash.qml'
--- qml/Dash/Dash.qml	2014-07-10 09:27:19 +0000
+++ qml/Dash/Dash.qml	2014-08-05 11:53:58 +0000
@@ -18,6 +18,7 @@
 import Ubuntu.Components 0.1
 import Unity 0.2
 import Utils 0.1
+import Unity.DashCommunicator 0.1
 import "../Components"
 
 Showable {
@@ -29,6 +30,13 @@
     property string showScopeOnLoaded: "clickscope"
     property real contentScale: 1.0
 
+    DashCommunicatorService {
+        objectName: "dashCommunicatorService"
+        onSetCurrentScopeRequested: {
+            dash.setCurrentScope(scopeId, animate, reset)
+        }
+    }
+
     function setCurrentScope(scopeId, animate, reset) {
         var scopeIndex = filteredScopes.findFirst(Scopes.RoleId, scopeId)
 
 
=== added file 'qml/Dash/DashApplication.qml'
--- qml/Dash/DashApplication.qml	1970-01-01 00:00:00 +0000
+++ qml/Dash/DashApplication.qml	2014-08-05 11:53:58 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.2
+import Ubuntu.Components 1.0
+
+MainView {
+    width: units.gu(40)
+    height: units.gu(71)
+
+    useDeprecatedToolbar: false
+
+    Dash {
+        anchors.fill: parent
+    }
+}
 
=== modified file 'qml/Dash/GenericScopeView.qml'
--- qml/Dash/GenericScopeView.qml	2014-07-25 11:49:28 +0000
+++ qml/Dash/GenericScopeView.qml	2014-08-05 11:53:58 +0000
@@ -46,7 +46,7 @@
     }
 
     function activateApp(appId) {
-        shell.activateApplication(appId);
+        Qt.openUrlExternally(appId);
     }
 
     function positionAtBeginning() {
 
=== modified file 'qml/Dash/ScopeListView.qml'
--- qml/Dash/ScopeListView.qml	2014-06-11 15:36:51 +0000
+++ qml/Dash/ScopeListView.qml	2014-08-05 11:53:58 +0000
@@ -20,9 +20,4 @@
 ListViewWithPageHeader {
     maximumFlickVelocity: height * 10
     flickDeceleration: height * 2
-
-    Connections {
-        target: greeter
-        onShownChanged: if (greeter.shown) showHeader()
-    }
 }
 
=== added file 'qml/Dash/graphics/phone/screenshots/[e-mail]'
 Binary files qml/Dash/graphics/phone/screenshots/[e-mail]	1970-01-01 00:00:00 +0000 and qml/Dash/graphics/phone/screenshots/[e-mail]	2014-08-05 11:53:58 +0000 differ
=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml	2014-07-16 13:01:08 +0000
+++ qml/Launcher/Launcher.qml	2014-08-05 11:53:58 +0000
@@ -29,8 +29,7 @@
     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)) :
-                                (dragArea.dragging ? 0.001 : 0)
+                                (width * (dragArea.touchX-panelWidth) / (width - panelWidth)) : 0
 
     readonly property bool shown: panel.x > -panel.width
 
@@ -245,7 +244,7 @@
             if (!dragging) {
                 if (distance > panel.width / 2) {
                     if (distance > minimizeDistance) {
-                        root.dash()
+                        root.dash();
                     } else {
                         root.switchToNextState("visible")
                     }
 
=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2014-07-29 23:36:16 +0000
+++ qml/Shell.qml	2014-08-05 11:53:58 +0000
@@ -25,7 +25,6 @@
 import LightDM 0.1 as LightDM
 import Powerd 0.1
 import SessionBroadcast 0.1
-import "Dash"
 import "Greeter"
 import "Launcher"
 import "Panel"
@@ -34,6 +33,7 @@
 import "Stages"
 import Unity.Notifications 1.0 as NotificationBackend
 import Unity.Session 0.1
+import Unity.DashCommunicator 0.1
 
 Item {
     id: shell
@@ -48,8 +48,6 @@
     property url background
     readonly property real panelHeight: panel.panelHeight
 
-    property bool dashShown: dash.shown && dash.available && underlay.visible
-
     property bool sideStageEnabled: shell.width >= units.gu(100)
     readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
 
@@ -59,7 +57,6 @@
         } else {
             var execFlags = shell.sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;
             ApplicationManager.startApplication(appId, execFlags);
-            stages.show();
         }
     }
 
@@ -86,6 +83,11 @@
         id: volumeControl
     }
 
+    DashCommunicator {
+        id: dash
+        objectName: "dashCommunicator"
+    }
+
     WindowKeysFilter {
         // Handle but do not filter out volume keys
         Keys.onVolumeUpPressed: { volumeControl.volumeUp(); event.accepted = false; }
@@ -121,64 +123,12 @@
         visible: !fullyCovered
 
         Image {
-            anchors.fill: dash
+            anchors.fill: underlay
             source: shell.width > shell.height ? "Dash/graphics/paper_landscape.png" : "Dash/graphics/paper_portrait.png"
             fillMode: Image.PreserveAspectCrop
             horizontalAlignment: Image.AlignRight
             verticalAlignment: Image.AlignTop
         }
-
-        Dash {
-            id: dash
-            objectName: "dash"
-
-            available: !LightDM.Greeter.active
-            hides: [stages, launcher, panel.indicators]
-            shown: disappearingAnimationProgress !== 1.0 && greeterWrapper.showProgress !== 1.0 &&
-                   !(panel.indicators.fullyOpened && !sideStageEnabled)
-            enabled: disappearingAnimationProgress === 0.0 && greeterWrapper.showProgress === 0.0 && edgeDemo.dashEnabled
-
-            anchors {
-                fill: parent
-                topMargin: panel.panelHeight
-            }
-
-            contentScale: 1.0 - 0.2 * disappearingAnimationProgress
-            opacity: 1.0 - disappearingAnimationProgress
-            property real disappearingAnimationProgress: stages.showProgress
-
-            // FIXME: only necessary because stages.showProgress is not animated
-            Behavior on disappearingAnimationProgress { SmoothedAnimation { velocity: 5 }}
-        }
-    }
-
-    EdgeDragArea {
-        id: stagesDragArea
-        direction: Direction.Leftwards
-
-        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
-        width: shell.edgeSize
-
-        property real progress: stages.width
-
-        onTouchXChanged: {
-            if (status == DirectionalDragArea.Recognized) {
-                if (ApplicationManager.empty) {
-                    progress = Math.max(stages.width - stagesDragArea.width + touchX, stages.width * .3);
-                } else {
-                    progress = stages.width - stagesDragArea.width + touchX;
-                }
-            }
-        }
-
-        onDraggingChanged: {
-            if (!dragging) {
-                if (!ApplicationManager.empty && progress < stages.width - units.gu(10)) {
-                    stages.show();
-                }
-                stagesDragArea.progress = Qt.binding(function () { return stages.width; });
-            }
-        }
     }
 
     Item {
@@ -186,55 +136,7 @@
         objectName: "stages"
         width: parent.width
         height: parent.height
-
-        visible: !fullyHidden && !ApplicationManager.empty
-
-        x: {
-            if (shown) {
-                if (locked || greeter.fakeActiveForApp !== "") {
-                    return 0;
-                }
-                return launcher.progress;
-            } else {
-                return stagesDragArea.progress
-            }
-        }
-        Behavior on x { SmoothedAnimation { velocity: 600; duration: UbuntuAnimation.FastDuration } }
-
-        property bool shown: false
-        onShownChanged: {
-            if (shown) {
-                if (ApplicationManager.count > 0) {
-                    ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
-                }
-            } else {
-                if (ApplicationManager.focusedApplicationId) {
-                    ApplicationManager.updateScreenshot(ApplicationManager.focusedApplicationId);
-                    ApplicationManager.unfocusCurrentApplication();
-                }
-            }
-        }
-
-        // Avoid a silent "divide by zero -> NaN" situation during init as shell.width will be
-        // zero. That breaks the property binding and the function won't be reevaluated once
-        // shell.width is set, with the NaN result staying there for good.
-        property real showProgress: shell.width ? MathUtils.clamp(1 - x / shell.width, 0, 1) : 0
-
-        property bool fullyShown: x == 0
-        property bool fullyHidden: x == width
-
-        property bool locked: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.locked : false
-
-        // It might technically not be fullyShown but visually it just looks so.
-        property bool roughlyFullyShown: x >= 0 && x <= units.gu(1)
-
-        function show() {
-            shown = true;
-        }
-
-        function hide() {
-            shown = false;
-        }
+        visible: !ApplicationManager.empty
 
         Connections {
             target: ApplicationManager
@@ -243,7 +145,6 @@
                     lockscreen.show();
                 }
                 greeter.hide();
-                stages.show();
             }
 
             onFocusedApplicationIdChanged: {
@@ -254,18 +155,9 @@
             }
 
             onApplicationAdded: {
-                if (greeter.shown) {
+                if (greeter.shown && appId != "unity8-dash") {
                     greeter.hide();
                 }
-                if (!stages.shown) {
-                    stages.show();
-                }
-            }
-
-            onEmptyChanged: {
-                if (ApplicationManager.empty) {
-                    stages.hide();
-                }
             }
         }
 
@@ -294,14 +186,18 @@
             Binding {
                 target: applicationsDisplayLoader.item
                 property: "interactive"
-                value: stages.roughlyFullyShown && !greeter.shown && !lockscreen.shown
-                       && panel.indicators.fullyClosed
+                value: !greeter.shown && !lockscreen.shown && panel.indicators.fullyClosed && launcher.progress == 0
             }
             Binding {
                 target: applicationsDisplayLoader.item
                 property: "spreadEnabled"
                 value: greeter.fakeActiveForApp === "" // to support emergency dialer hack
             }
+            Binding {
+                target: applicationsDisplayLoader.item
+                property: "inverseProgress"
+                value: launcher.progress
+            }
         }
     }
 
@@ -531,25 +427,20 @@
 
         var animate = !LightDM.Greeter.active && !stages.shown
         dash.setCurrentScope("clickscope", animate, false)
-        stages.hide()
+        ApplicationManager.requestFocusApplication("unity8-dash")
     }
 
     function showDash() {
         if (LightDM.Greeter.active && !LightDM.Greeter.promptless) {
             return;
         }
-
-        if (!stages.locked) {
-            stages.hide();
-            launcher.fadeOut();
-        } else {
-            launcher.switchToNextState("visible");
-        }
-
         if (greeter.shown) {
             greeter.hideRight();
             launcher.fadeOut();
         }
+
+        ApplicationManager.requestFocusApplication("unity8-dash")
+        launcher.fadeOut();
     }
 
     Item {
@@ -574,8 +465,8 @@
                 ApplicationManager.focusedApplicationId &&
                     ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).fullscreen
 
-            fullscreenMode: (stages.roughlyFullyShown && topmostApplicationIsFullscreen
-                    && !LightDM.Greeter.active) || greeter.fakeActiveForApp !== ""
+            fullscreenMode: (topmostApplicationIsFullscreen && !LightDM.Greeter.active && launcher.progress == 0)
+                            || greeter.fakeActiveForApp !== ""
         }
 
         Launcher {
@@ -592,7 +483,11 @@
 
             onShowDashHome: showHome()
             onDash: showDash()
-            onDashSwipeChanged: if (dashSwipe && stages.shown) dash.setCurrentScope("clickscope", false, true)
+            onDashSwipeChanged: {
+                if (dashSwipe && ApplicationManager.focusedApplicationId !== "unity8-dash") {
+                    dash.setCurrentScope("clickscope", false, true)
+                }
+            }
             onLauncherApplicationSelected: {
                 if (greeter.fakeActiveForApp !== "") {
                     lockscreen.show()
@@ -684,7 +579,6 @@
         z: alphaDisclaimerLabel.z + 10
         greeter: greeter
         launcher: launcher
-        dash: dash
         indicators: panel.indicators
         underlay: underlay
     }
 
=== modified file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	2014-07-22 15:16:32 +0000
+++ qml/Stages/PhoneStage.qml	2014-08-05 11:53:58 +0000
@@ -21,7 +21,7 @@
 import Utils 0.1
 import "../Components"
 
-Item {
+Rectangle {
     id: root
 
     // Controls to be set from outside
@@ -29,9 +29,9 @@
     property real maximizedAppTopMargin
     property bool interactive
     property bool spreadEnabled: true // If false, animations and right edge will be disabled
+    property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
 
-    // State information propagated to the outside
-    readonly property bool locked: spreadView.phase == 2
+    color: "black"
 
     function select(appId) {
         spreadView.snapTo(priv.indexOf(appId));
@@ -43,6 +43,16 @@
         spreadView.contentX = -spreadView.shift;
     }
 
+    onInverseProgressChanged: {
+        if (inverseProgress == 0 && priv.oldInverseProgress > 0) {
+            // left edge drag released. Minimum distance is given by design.
+            if (priv.oldInverseProgress > units.gu(22)) {
+                ApplicationManager.focusApplication("unity8-dash");
+            }
+        }
+        priv.oldInverseProgress = inverseProgress;
+    }
+
     Connections {
         target: ApplicationManager
 
@@ -50,7 +60,7 @@
             if (spreadView.phase > 0) {
                 spreadView.snapTo(priv.indexOf(appId));
             } else {
-                priv.switchToApp(appId);
+                ApplicationManager.focusApplication(appId);
             }
         }
 
@@ -60,7 +70,7 @@
             } else {
                 spreadView.phase = 0;
                 spreadView.contentX = -spreadView.shift;
-                priv.switchToApp(appId);
+                ApplicationManager.focusApplication(appId);
             }
         }
 
@@ -79,15 +89,11 @@
 
         property string focusedAppId: ApplicationManager.focusedApplicationId
         property var focusedApplication: ApplicationManager.findApplication(focusedAppId)
-
-        function switchToApp(appId) {
-            if (priv.focusedAppId) {
-                spreadView.focusChanging = true;
-                ApplicationManager.focusApplication(appId);
-            } else {
-                ApplicationManager.focusApplication(appId);
-            }
-        }
+        property var focusedAppDelegate: null
+
+        property real oldInverseProgress: 0
+
+        onFocusedAppIdChanged: focusedAppDelegate = spreadRepeater.itemAt(0);
 
         function indexOf(appId) {
             for (var i = 0; i < ApplicationManager.count; i++) {
@@ -100,14 +106,6 @@
 
     }
 
-    Rectangle {
-        id: coverFlipBackground
-        anchors.fill: parent
-        color: "black"
-        visible: spreadView.visible
-    }
-
-
     Flickable {
         id: spreadView
         objectName: "spreadView"
@@ -116,6 +114,10 @@
         contentWidth: spreadRow.width - shift
         contentX: -shift
 
+        // This indicates when the spreadView is active. That means, all the animations
+        // are activated and tiles need to line up for the spread.
+        readonly property bool active: shiftedContentX > 0 || spreadDragArea.dragging
+
         // The flickable needs to fill the screen in order to get touch events all over.
         // However, we don't want to the user to be able to scroll back all the way. For
         // that, the beginning of the gesture starts with a negative value for contentX
@@ -198,6 +200,12 @@
             snapAnimation.start();
         }
 
+        // In case the ApplicationManager already holds an app when starting up we're missing animations
+        // Make sure we end up in the same state
+        Component.onCompleted: {
+            spreadView.contentX = -spreadView.shift
+        }
+
         SequentialAnimation {
             id: snapAnimation
             property int targetContentX: -spreadView.shift
@@ -260,14 +268,33 @@
                             && spreadView.shiftedContentX === 0 && root.interactive && index === 0
                     swipeToCloseEnabled: spreadView.interactive
                     maximizedAppTopMargin: root.maximizedAppTopMargin
-                    dropShadow: spreadView.shiftedContentX > 0 || spreadDragArea.status == DirectionalDragArea.Undecided
-
-                    z: behavioredIndex
-                    x: index == 0 ? 0 : spreadView.width + (index - 1) * spreadView.tileDistance
+                    dropShadow: spreadView.active ||
+                                priv.focusedAppDelegate.x !== 0
+
+                    readonly property bool isDash: model.appId == "unity8-dash"
+
+                    z: isDash && !spreadView.active ? -1 : behavioredIndex
+
+                    x: {
+                        // focused app is always positioned at 0 except when following left edge drag
+                        if (index == 0) {
+                            if (!isDash && root.inverseProgress > 0) {
+                                return root.inverseProgress;
+                            }
+                           return 0;
+                        }
+                        if (isDash && !spreadView.active && !spreadDragArea.dragging) {
+                           return 0;
+                        }
+
+                        // Otherwise line up for the spread
+                        return spreadView.width + (index - 1) * spreadView.tileDistance;
+                    }
                     property real behavioredIndex: index
                     Behavior on behavioredIndex {
                         enabled: spreadView.closingIndex >= 0
                         UbuntuNumberAnimation {
+                            id: appXAnimation
                             onRunningChanged: {
                                 if (!running) {
                                     spreadView.closingIndex = -1;
@@ -277,11 +304,13 @@
                     }
 
                     Behavior on x {
-                        enabled: spreadView.focusChanging && index == 0 && root.spreadEnabled
+                        enabled: root.spreadEnabled &&
+                                 !spreadView.active &&
+                                 !snapAnimation.running
                         UbuntuNumberAnimation {
                             duration: UbuntuAnimation.FastDuration
                             onRunningChanged: {
-                                if (!running) {
+                                if (!running && root.inverseProgress == 0) {
                                     spreadView.focusChanging = false;
                                 }
                             }
@@ -322,6 +351,10 @@
                         return progress;
                     }
 
+                    // Hiding tiles when their progress is negative or reached the maximum
+                    visible: (progress >= 0 && progress < 1.7) ||
+                             (isDash && priv.focusedAppDelegate.x !== 0)
+
                     EasingCurve {
                         id: snappingCurve
                         type: EasingCurve.Linear
 
=== modified file 'qml/Stages/SpreadDelegate.qml'
--- qml/Stages/SpreadDelegate.qml	2014-07-23 12:20:45 +0000
+++ qml/Stages/SpreadDelegate.qml	2014-08-05 11:53:58 +0000
@@ -37,6 +37,7 @@
 
     SurfaceContainer {
         id: surfaceContainer
+        objectName: "surfaceContainer"
         anchors.fill: parent
         surface: model.surface
         property bool appHasCreatedASurface: false
@@ -172,6 +173,11 @@
         }
 
         onDragEnd: {
+            if (model.appId == "unity8-dash") {
+                animation.animate("center")
+                return;
+            }
+
             // velocity and distance values specified by design prototype
             if ((dragVelocity < -units.gu(40) && distance < -units.gu(8)) || distance < -root.height / 2) {
                 animation.animate("up")
 
=== modified file 'qml/Stages/TabletStage.qml'
--- qml/Stages/TabletStage.qml	2014-07-21 08:05:38 +0000
+++ qml/Stages/TabletStage.qml	2014-08-05 11:53:58 +0000
@@ -21,10 +21,11 @@
 import Utils 0.1
 import "../Components"
 
-Item {
+Rectangle {
     id: root
     objectName: "stages"
     anchors.fill: parent
+    color: "black"
 
     // Controls to be set from outside
     property bool shown: false
@@ -32,9 +33,17 @@
     property int dragAreaWidth
     property real maximizedAppTopMargin
     property bool interactive
+    property real inverseProgress: 0 // This is the progress for left edge drags, in pixels.
 
-    // State information propagated to the outside
-    readonly property bool locked: spreadView.phase == 2
+    onInverseProgressChanged: {
+        if (inverseProgress == 0 && priv.oldInverseProgress > 0) {
+            // left edge drag released. Minimum distance is given by design.
+            if (priv.oldInverseProgress > units.gu(22)) {
+                ApplicationManager.focusApplication("unity8-dash");
+            }
+        }
+        priv.oldInverseProgress = inverseProgress;
+    }
 
     QtObject {
         id: priv
@@ -49,6 +58,8 @@
         property string appId0
         property string appId1
 
+        property int oldInverseProgress: 0
+
         onFocusedAppIdChanged: {
             if (priv.focusedAppId.length > 0) {
                 var focusedApp = ApplicationManager.findApplication(focusedAppId);
@@ -107,16 +118,26 @@
             }
         }
 
+        onApplicationAdded: {
+            if (spreadView.phase == 2) {
+                spreadView.snapTo(ApplicationManager.count - 1);
+            } else {
+                spreadView.phase = 0;
+                spreadView.contentX = -spreadView.shift;
+                ApplicationManager.focusApplication(appId);
+            }
+        }
+
         onApplicationRemoved: {
             if (priv.mainStageAppId == appId) {
-                priv.mainStageAppId = "";
+                ApplicationManager.focusApplication("unity8-dash")
             }
             if (priv.sideStageAppId == appId) {
                 priv.sideStageAppId = "";
             }
             if (ApplicationManager.count == 0) {
                 spreadView.phase = 0;
-                spreadView.contentX = 0;
+                spreadView.contentX = -spreadView.shift;
             }
         }
     }
@@ -124,13 +145,26 @@
     Flickable {
         id: spreadView
         anchors.fill: parent
-        contentWidth: spreadRow.width
         interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1) && draggedIndex == -1
+        contentWidth: spreadRow.width - shift
+        contentX: -shift
 
         property int tileDistance: units.gu(20)
         property int sideStageWidth: units.gu(40)
         property bool sideStageVisible: priv.sideStageAppId
 
+        // This indicates when the spreadView is active. That means, all the animations
+        // are activated and tiles need to line up for the spread.
+        readonly property bool active: shiftedContentX > 0 || spreadDragArea.dragging
+
+        // The flickable needs to fill the screen in order to get touch events all over.
+        // However, we don't want to the user to be able to scroll back all the way. For
+        // that, the beginning of the gesture starts with a negative value for contentX
+        // so the flickable wants to pull it into the view already. "shift" tunes the
+        // distance where to "lock" the content.
+        readonly property real shift: width / 2
+        readonly property real shiftedContentX: contentX + shift
+
         // Phase of the animation:
         // 0: Starting from right edge, a new app (index 1) comes in from the right
         // 1: The app has reached the first snap position.
@@ -168,6 +202,12 @@
             }
         }
 
+        // In case the ApplicationManager already holds an app when starting up we're missing animations
+        // Make sure we end up in the same state
+        Component.onCompleted: {
+            spreadView.contentX = -spreadView.shift
+        }
+
         property int nextInStack: {
             switch (state) {
             case "main":
@@ -224,31 +264,31 @@
             return "empty";
         }
 
-        onContentXChanged: {
-            if (spreadView.phase == 0 && spreadView.contentX > spreadView.width * spreadView.positionMarker2) {
+        onShiftedContentXChanged: {
+            if (spreadView.phase == 0 && spreadView.shiftedContentX > spreadView.width * spreadView.positionMarker2) {
                 spreadView.phase = 1;
-            } else if (spreadView.phase == 1 && spreadView.contentX > spreadView.width * spreadView.positionMarker4) {
+            } else if (spreadView.phase == 1 && spreadView.shiftedContentX > spreadView.width * spreadView.positionMarker4) {
                 spreadView.phase = 2;
-            } else if (spreadView.phase == 1 && spreadView.contentX < spreadView.width * spreadView.positionMarker2) {
+            } else if (spreadView.phase == 1 && spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
                 spreadView.phase = 0;
             }
         }
 
         function snap() {
-            if (contentX < phase0Width) {
-                snapAnimation.targetContentX = 0;
+            if (shiftedContentX < phase0Width) {
+                snapAnimation.targetContentX = -shift;
                 snapAnimation.start();
-            } else if (contentX < phase1Width) {
+            } else if (shiftedContentX < phase1Width) {
                 snapTo(1);
             } else {
                 // Add 1 pixel to make sure we definitely hit positionMarker4 even with rounding errors of the animation.
-                snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4 + 1;
+                snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4 + 1 - shift;
                 snapAnimation.start();
             }
         }
         function snapTo(index) {
             spreadView.selectedIndex = index;
-            snapAnimation.targetContentX = 0;
+            snapAnimation.targetContentX = -shift;
             snapAnimation.start();
         }
 
@@ -261,12 +301,12 @@
                 return index;
             }
 
-            var isActive = app.appId == priv.mainStageAppId || app.appId == priv.sideStageAppId;
-            if (isActive && app.stage == ApplicationInfoInterface.MainStage) {
+            var active = app.appId == priv.mainStageAppId || app.appId == priv.sideStageAppId;
+            if (active && app.stage == ApplicationInfoInterface.MainStage) {
                 // if this app is active, and its the MainStage, always put it to index 0
                 return 0;
             }
-            if (isActive && app.stage == ApplicationInfoInterface.SideStage) {
+            if (active && app.stage == ApplicationInfoInterface.SideStage) {
                 if (!priv.mainStageAppId) {
                     // Only have SS apps running. Put the active one at 0
                     return 0;
@@ -309,7 +349,7 @@
 
         SequentialAnimation {
             id: snapAnimation
-            property int targetContentX: 0
+            property int targetContentX: -spreadView.shift
 
             UbuntuNumberAnimation {
                 target: spreadView
@@ -325,15 +365,14 @@
                         spreadView.selectedIndex = -1;
                         ApplicationManager.focusApplication(ApplicationManager.get(newIndex).appId);
                         spreadView.phase = 0;
-                        spreadView.contentX = 0;
+                        spreadView.contentX = -spreadView.shift;
                     }
                 }
             }
         }
 
-        Rectangle {
+        Item {
             id: spreadRow
-            color: "black"
             x: spreadView.contentX
             height: root.height
             width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)
@@ -380,7 +419,7 @@
                 MouseArea {
                     id: sideStageDragHandleMouseArea
                     anchors.fill: parent
-                    enabled: spreadView.contentX == 0
+                    enabled: spreadView.shiftedContentX == 0
                     property int startX
                     property var gesturePoints: new Array()
 
@@ -413,7 +452,7 @@
 
                     onRunningChanged: {
                         if (!running) {
-                            sideStageDragHandle.dragging = false;;
+                            sideStageDragHandle.dragging = false;
                         }
                     }
                 }
@@ -427,17 +466,26 @@
                     id: spreadTile
                     height: spreadView.height
                     width: model.stage == ApplicationInfoInterface.MainStage ? spreadView.width : spreadView.sideStageWidth
-                    x: spreadView.width
-                    z: spreadView.indexToZIndex(index)
                     active: model.appId == priv.mainStageAppId || model.appId == priv.sideStageAppId
-                    zIndex: z
+                    zIndex: spreadView.indexToZIndex(index)
                     selected: spreadView.selectedIndex == index
                     otherSelected: spreadView.selectedIndex >= 0 && !selected
                     isInSideStage: priv.sideStageAppId == model.appId
                     interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive
                     swipeToCloseEnabled: spreadView.interactive
                     maximizedAppTopMargin: root.maximizedAppTopMargin
-                    dropShadow: spreadView.contentX > 0 || spreadDragArea.status == DirectionalDragArea.Undecided
+                    dragOffset: !isDash && model.appId == priv.mainStageAppId && root.inverseProgress > 0 ? root.inverseProgress : 0
+
+                    readonly property bool isDash: model.appId == "unity8-dash"
+
+                    // FIXME: A regular binding doesn't update any more after closing an app.
+                    // Using a Binding for now.
+                    Binding {
+                        target: spreadTile
+                        property: "z"
+                        value: (!spreadView.active && isDash && !active) ? -1 : spreadTile.zIndex
+                    }
+                    x: spreadView.width
 
                     property real behavioredZIndex: zIndex
                     Behavior on behavioredZIndex {
@@ -458,7 +506,7 @@
                     }
 
                     progress: {
-                        var tileProgress = (spreadView.contentX - behavioredZIndex * spreadView.tileDistance) / spreadView.width;
+                        var tileProgress = (spreadView.shiftedContentX - behavioredZIndex * spreadView.tileDistance) / spreadView.width;
                         // Some tiles (nextInStack, active) need to move directly from the beginning, normalize progress to immediately start at 0
                         if ((index == spreadView.nextInStack && spreadView.phase < 2) || (active && spreadView.phase < 1)) {
                             tileProgress += behavioredZIndex * spreadView.tileDistance / spreadView.width;
@@ -481,11 +529,7 @@
 
                     onClicked: {
                         if (spreadView.phase == 2) {
-                            if (ApplicationManager.focusedApplicationId == ApplicationManager.get(index).appId) {
-                                spreadView.snapTo(index);
-                            } else {
-                                ApplicationManager.requestFocusApplication(ApplicationManager.get(index).appId);
-                            }
+                            spreadView.snapTo(index);
                         }
                     }
 
@@ -518,12 +562,12 @@
         onTouchXChanged: {
             if (!dragging) {
                 spreadView.phase = 0;
-                spreadView.contentX = 0;
+                spreadView.contentX = -spreadView.shift;
             }
 
-            if (attachedToView) {
-                spreadView.contentX = -touchX + spreadDragArea.width;
-                if (spreadView.contentX > spreadView.phase0Width + spreadView.phase1Width / 2) {
+            if (dragging && attachedToView) {
+                spreadView.contentX = -touchX + spreadDragArea.width - spreadView.shift;
+                if (spreadView.shiftedContentX > spreadView.phase0Width + spreadView.phase1Width / 2) {
                     attachedToView = false;
                     spreadView.snap();
                 }
@@ -548,14 +592,14 @@
             var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
             gesturePoints = [];
 
-            if (oneWayFlick && spreadView.contentX < spreadView.positionMarker1 * spreadView.width) {
+            if (oneWayFlick && spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
                 // If it was a short one-way movement, do the Alt+Tab switch
                 // no matter if we didn't cross positionMarker1 yet.
                 spreadView.snapTo(spreadView.nextInStack);
             } else if (!dragging && attachedToView) {
-                if (spreadView.contentX < spreadView.width * spreadView.positionMarker1) {
+                if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker1) {
                     spreadView.snap();
-                } else if (spreadView.contentX < spreadView.width * spreadView.positionMarker2) {
+                } else if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
                     spreadView.snapTo(spreadView.nextInStack);
                 } else {
                     // otherwise snap to the closest snap position we can find
 
=== modified file 'qml/Stages/TransformedSpreadDelegate.qml'
--- qml/Stages/TransformedSpreadDelegate.qml	2014-07-21 08:13:44 +0000
+++ qml/Stages/TransformedSpreadDelegate.qml	2014-08-05 11:53:58 +0000
@@ -46,9 +46,6 @@
     property real startDistance: units.gu(5)
     property real endDistance: units.gu(.5)
 
-    // Hiding tiles when their progress is negative or reached the maximum
-    visible: progress >= 0 && progress < 1.7
-
     onSelectedChanged: {
         if (selected) {
             priv.snapshot();
@@ -132,6 +129,10 @@
         // the selected tile, which is animated from the snapshotted position to be fullscreen.
 
         readonly property real xTranslate: {
+            if (!spreadView.active) {
+                return 0;
+            }
+
             if (otherSelected) {
                 if (spreadView.phase < 2 && index == 0) {
                     return linearAnimation(selectedProgress, 0, selectedXTranslate,
@@ -183,7 +184,7 @@
         }
 
         readonly property real angle: {
-            if (spreadView.focusChanging) {
+            if (!spreadView.active) {
                 return 0;
             }
 
@@ -216,7 +217,7 @@
         }
 
         readonly property real scale: {
-            if (spreadView.focusChanging) {
+            if (!spreadView.active) {
                 return 1;
             }
             if (priv.otherSelected) {
 
=== modified file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
--- qml/Stages/TransformedTabletSpreadDelegate.qml	2014-07-21 08:17:07 +0000
+++ qml/Stages/TransformedTabletSpreadDelegate.qml	2014-08-05 11:53:58 +0000
@@ -47,6 +47,11 @@
 
     property bool isInSideStage: false
 
+    property int dragOffset: 0
+
+    dropShadow: spreadView.active ||
+                (active && model.stage == ApplicationInfoInterface.MainStage && priv.xTranslate != 0)
+
     onSelectedChanged: {
         if (selected) {
             priv.snapshot();
@@ -129,6 +134,16 @@
             return helperEasingCurve.value * (endValue - startValue) + startValue;
         }
 
+        Behavior on xTranslate {
+            enabled: !spreadView.active &&
+                     !snapAnimation.running &&
+                     model.appId !== "unity8-dash" &&
+                     !spreadView.sideStageDragging
+            UbuntuNumberAnimation {
+                duration: UbuntuAnimation.FastDuration
+            }
+        }
+
         property real xTranslate: {
             var newTranslate = 0;
 
@@ -155,7 +170,12 @@
                 if (spreadView.phase == 0 && shouldMoveAway) {
                     newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);
                 }
-            }
+                newTranslate += root.dragOffset;
+            }
+            if (!spreadView.active && model.appId == "unity8-dash" && !root.active) {
+                newTranslate -= root.width;
+            }
+
             if (nextInStack && spreadView.phase == 0) {
                 if (model.stage == ApplicationInfoInterface.MainStage) {
                     if (spreadView.sideStageVisible && root.progress > 0) {
@@ -205,6 +225,10 @@
         }
 
         property real scale: {
+            if (!spreadView.active) {
+                return 1;
+            }
+
             if (otherSelected) {
                 return selectedScale;
             }
@@ -249,6 +273,10 @@
         }
 
         property real angle: {
+            if (!spreadView.active) {
+                return 0;
+            }
+
             if (otherSelected) {
                 return selectedAngle;
             }
 
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-07-03 20:28:32 +0000
+++ src/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -35,3 +35,4 @@
      )
 
 add_subdirectory(Panel)
+add_subdirectory(Dash)
 
=== added directory 'src/Dash'
=== added file 'src/Dash/CMakeLists.txt'
--- src/Dash/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/Dash/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -0,0 +1,12 @@
+set(DASH_SRCS
+    main.cpp
+)
+
+add_executable(unity8-dash ${DASH_SRCS})
+
+qt5_use_modules(unity8-dash Gui Qml Quick Test)
+
+# install binaries
+install(TARGETS ${DASH_APP}
+     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
 
=== added file 'src/Dash/main.cpp'
--- src/Dash/main.cpp	1970-01-01 00:00:00 +0000
+++ src/Dash/main.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Michael Zanetti <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QtQuick/QQuickView>
+#include <QtGui/QGuiApplication>
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlContext>
+#include <QDebug>
+#include <QCommandLineParser>
+#include <QLibrary>
+
+#include <paths.h>
+
+int main(int argc, const char *argv[])
+{
+    QGuiApplication *application = new QGuiApplication(argc, (char**)argv);
+
+    QCommandLineParser parser;
+    parser.setApplicationDescription("Description: Unity 8 Shell Dash");
+    parser.addHelpOption();
+
+    QCommandLineOption testabilityOption("testability",
+        "Load the testability driver (Alternatively export QT_LOAD_TESTABILITY");
+    parser.addOption(testabilityOption);
+
+    if (parser.isSet(testabilityOption) || getenv("QT_LOAD_TESTABILITY")) {
+        QLibrary testLib(QLatin1String("qttestability"));
+        if (testLib.load()) {
+            typedef void (*TasInitialize)(void);
+            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+            if (initFunction) {
+                initFunction();
+            } else {
+                qCritical("Library qttestability resolve failed!");
+            }
+        } else {
+            qCritical("Library qttestability load failed!");
+        }
+    }
+
+    QQuickView* view = new QQuickView();
+    view->setResizeMode(QQuickView::SizeRootObjectToView);
+    view->setTitle("Unity Dash");
+
+    QUrl source(::qmlDirectory()+"Dash/DashApplication.qml");
+    prependImportPaths(view->engine(), ::overrideImportPaths());
+    appendImportPaths(view->engine(), ::fallbackImportPaths());
+
+    view->setSource(source);
+    view->show();
+
+    int result = application->exec();
+
+    delete view;
+    delete application;
+
+    return result;
+}
 
=== modified file 'tests/mocks/Unity/Application/ApplicationInfo.cpp'
--- tests/mocks/Unity/Application/ApplicationInfo.cpp	2014-07-24 19:22:20 +0000
+++ tests/mocks/Unity/Application/ApplicationInfo.cpp	2014-08-05 11:53:58 +0000
@@ -31,8 +31,6 @@
     , m_state(Starting)
     , m_focused(false)
     , m_fullscreen(false)
-    , m_windowItem(0)
-    , m_windowComponent(0)
     , m_parentItem(0)
     , m_surface(0)
 {
@@ -45,8 +43,6 @@
     , m_state(Starting)
     , m_focused(false)
     , m_fullscreen(false)
-    , m_windowItem(0)
-    , m_windowComponent(0)
     , m_parentItem(0)
     , m_surface(0)
 {
@@ -61,12 +57,6 @@
     }
 }
 
-void ApplicationInfo::onWindowComponentStatusChanged(QQmlComponent::Status status)
-{
-    if (status == QQmlComponent::Ready && !m_windowItem)
-        doCreateWindowItem();
-}
-
 void ApplicationInfo::onStateChanged(State state)
 {
     if (state == ApplicationInfo::Running) {
@@ -108,55 +98,3 @@
     Q_EMIT surfaceChanged(m_surface);
     SurfaceManager::singleton()->registerSurface(m_surface);
 }
-
-void ApplicationInfo::createWindowComponent()
-{
-    // The assumptions I make here really should hold.
-    QQuickView *quickView =
-        qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);
-
-    QQmlEngine *engine = quickView->engine();
-
-    m_windowComponent = new QQmlComponent(engine, this);
-    m_windowComponent->setData(m_windowQml.toLatin1(), QUrl());
-}
-
-void ApplicationInfo::doCreateWindowItem()
-{
-    m_windowItem = qobject_cast<QQuickItem *>(m_windowComponent->create());
-    m_windowItem->setParentItem(m_parentItem);
-}
-
-void ApplicationInfo::createWindowItem()
-{
-    if (!m_windowComponent)
-        createWindowComponent();
-
-    // only create the windowItem once the component is ready
-    if (!m_windowComponent->isReady()) {
-        connect(m_windowComponent, &QQmlComponent::statusChanged,
-                this, &ApplicationInfo::onWindowComponentStatusChanged);
-    } else {
-        doCreateWindowItem();
-    }
-}
-
-void ApplicationInfo::showWindow(QQuickItem *parent)
-{
-    m_parentItem = parent;
-
-    if (!m_windowItem)
-        createWindowItem();
-
-    if (m_windowItem) {
-        m_windowItem->setVisible(true);
-    }
-}
-
-void ApplicationInfo::hideWindow()
-{
-    if (!m_windowItem)
-        return;
-
-    m_windowItem->setVisible(false);
-}
 
=== modified file 'tests/mocks/Unity/Application/ApplicationInfo.h'
--- tests/mocks/Unity/Application/ApplicationInfo.h	2014-07-21 09:17:12 +0000
+++ tests/mocks/Unity/Application/ApplicationInfo.h	2014-08-05 11:53:58 +0000
@@ -88,22 +88,12 @@
 Q_SIGNALS:
     void surfaceChanged(MirSurfaceItem*);
 
-public:
-    void showWindow(QQuickItem *parent);
-    void hideWindow();
-
 private Q_SLOTS:
-    void onWindowComponentStatusChanged(QQmlComponent::Status status);
     void onStateChanged(State state);
 
     void createSurface();
 
 private:
-    void createWindowItem();
-    void doCreateWindowItem();
-    void createWindowComponent();
-    QQuickItem *m_windowItem;
-    QQmlComponent *m_windowComponent;
     QQuickItem *m_parentItem;
     MirSurfaceItem* m_surface;
 };
 
=== modified file 'tests/mocks/Unity/Application/ApplicationManager.cpp'
--- tests/mocks/Unity/Application/ApplicationManager.cpp	2014-07-24 19:22:20 +0000
+++ tests/mocks/Unity/Application/ApplicationManager.cpp	2014-08-05 11:53:58 +0000
@@ -48,16 +48,14 @@
 ApplicationManager::ApplicationManager(QObject *parent)
     : ApplicationManagerInterface(parent)
     , m_suspended(false)
-    , m_mainStageComponent(0)
-    , m_mainStage(0)
-    , m_sideStageComponent(0)
-    , m_sideStage(0)
-    , m_rightMargin(0)
 {
     m_roleNames.insert(RoleSurface, "surface");
     m_roleNames.insert(RoleFullscreen, "fullscreen");
 
     buildListOfAvailableApplications();
+
+    startApplication("unity8-dash");
+    focusApplication("unity8-dash");
 }
 
 ApplicationManager::~ApplicationManager()
@@ -136,7 +134,6 @@
     Q_EMIT applicationAdded(application->appId());
     Q_EMIT countChanged();
     if (count() == 1) Q_EMIT emptyChanged(isEmpty()); // was empty but not anymore
-    Q_EMIT focusRequested(application->appId());
 
     connect(application, &ApplicationInfo::surfaceChanged, this, [application, this]() {
         QModelIndex appIndex = findIndex(application);
@@ -222,6 +219,10 @@
 
 bool ApplicationManager::stopApplication(const QString &appId)
 {
+    if (appId == "unity8-dash") {
+        return false;
+    }
+
     ApplicationInfo *application = findApplication(appId);
     if (application == nullptr)
         return false;
@@ -294,39 +295,25 @@
         for (ApplicationInfo *app : m_runningApplications) {
             if (app->focused() && app->stage() == ApplicationInfo::MainStage) {
                 app->setFocused(false);
-                app->hideWindow();
                 app->setState(ApplicationInfo::Suspended);
             }
         }
 
         // focus this app
         application->setFocused(true);
-        if (!m_mainStage)
-            createMainStage();
         application->setState(ApplicationInfo::Running);
-        application->showWindow(m_mainStage);
-        m_mainStage->setZ(-1000);
-        if (m_sideStage)
-            m_sideStage->setZ(-2000);
     } else if (application->stage() == ApplicationInfo::SideStage) {
         // unfocus currently focused sidestage app
         for (ApplicationInfo *app : m_runningApplications) {
             if (app->focused() && app->stage() == ApplicationInfo::SideStage) {
                 app->setFocused(false);
-                app->hideWindow();
                 app->setState(ApplicationInfo::Suspended);
             }
         }
 
         // focus this app
         application->setFocused(true);
-        if (!m_sideStage)
-            createSideStage();
         application->setState(ApplicationInfo::Running);
-        application->showWindow(m_sideStage);
-        m_sideStage->setZ(-1000);
-        if (m_mainStage)
-            m_mainStage->setZ(-2000);
     }
 
     // move app to top of stack
@@ -337,18 +324,14 @@
 
 bool ApplicationManager::requestFocusApplication(const QString &appId)
 {
-    if (appId != focusedApplicationId()) {
-        QMetaObject::invokeMethod(this, "focusRequested", Qt::QueuedConnection, Q_ARG(QString, appId));
-        return true;
-    }
-    return false;
+    QMetaObject::invokeMethod(this, "focusRequested", Qt::QueuedConnection, Q_ARG(QString, appId));
+    return true;
 }
 
 void ApplicationManager::unfocusCurrentApplication()
 {
     for (ApplicationInfo *app : m_runningApplications) {
         if (app->focused()) {
-            app->hideWindow();
             app->setFocused(false);
         }
     }
@@ -357,42 +340,6 @@
 
 void ApplicationManager::generateQmlStrings(ApplicationInfo *application)
 {
-    // TODO: Is there a better way of solving this fullscreen vs. regular
-    //       application height?
-    QString topMargin;
-    if (application->fullscreen()) {
-        topMargin.append("0");
-    } else {
-        // Taken from Panel.panelHeight
-        topMargin.append("units.gu(3) + units.dp(2)");
-    }
-
-    QString windowQml = QString(
-        "import QtQuick 2.0\n"
-        "Image {\n"
-        "   anchors.fill: parent\n"
-        "   anchors.topMargin: %1\n"
-        "   anchors.rightMargin: %2\n"
-        "   source: \"file://%3/Dash/graphics/phone/screenshots/%4.png\"\n"
-        "   smooth: true\n"
-        "   fillMode: Image.PreserveAspectCrop\n"
-        "}").arg(topMargin)
-            .arg(m_rightMargin)
-            .arg(qmlDirectory())
-            .arg(application->icon().toString());
-    application->setWindowQml(windowQml);
-
-    QString imageQml = QString(
-        "import QtQuick 2.0\n"
-        "Image {\n"
-        "   anchors.fill: parent\n"
-        "   source: \"file://%1/Dash/graphics/phone/screenshots/%2.png\"\n"
-        "   smooth: true\n"
-        "   fillMode: Image.PreserveAspectCrop\n"
-        "}").arg(qmlDirectory())
-            .arg(application->icon().toString());
-    application->setImageQml(imageQml);
-
     application->setScreenshot(QString("file://%1/Dash/graphics/phone/screenshots/[e-mail]").arg(qmlDirectory())
                                                                                              .arg(application->icon().toString()));
 }
@@ -402,6 +349,14 @@
     ApplicationInfo *application;
 
     application = new ApplicationInfo(this);
+    application->setAppId("unity8-dash");
+    application->setName("Unity 8 Mock Dash");
+    application->setIcon(QUrl("unity8-dash"));
+    application->setStage(ApplicationInfo::MainStage);
+    generateQmlStrings(application);
+    m_availableApplications.append(application);
+
+    application = new ApplicationInfo(this);
     application->setAppId("dialer-app");
     application->setName("Dialer");
     application->setIcon(QUrl("dialer"));
@@ -521,78 +476,6 @@
     m_availableApplications.append(application);
 }
 
-void ApplicationManager::createMainStageComponent()
-{
-    // The assumptions I make here really should hold.
-    QQuickView *quickView =
-        qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);
-
-    QQmlEngine *engine = quickView->engine();
-
-    m_mainStageComponent = new QQmlComponent(engine, this);
-    QString mainStageQml =
-        "import QtQuick 2.0\n"
-        "Rectangle {\n"
-        "   anchors.fill: parent\n"
-        "   color: 'black'\n"
-        "   z: -2000\n"
-        "}\n";
-    m_mainStageComponent->setData(mainStageQml.toLatin1(), QUrl());
-}
-
-void ApplicationManager::createMainStage()
-{
-    if (!m_mainStageComponent)
-        createMainStageComponent();
-
-    // The assumptions I make here really should hold.
-    QQuickView *quickView =
-        qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);
-
-    QQuickItem *shell = quickView->rootObject();
-
-    m_mainStage = qobject_cast<QQuickItem *>(m_mainStageComponent->create());
-    m_mainStage->setParentItem(shell);
-}
-
-void ApplicationManager::createSideStageComponent()
-{
-    // The assumptions I make here really should hold.
-    QQuickView *quickView =
-        qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);
-
-    QQmlEngine *engine = quickView->engine();
-
-    m_sideStageComponent = new QQmlComponent(engine, this);
-    QString sideStageQml =
-        "import QtQuick 2.0\n"
-        "import Ubuntu.Components 0.1\n"
-        "Item {\n"
-        "   width: units.gu(40)\n" // from SideStage in Shell.qml
-        "   anchors.top: parent.top\n"
-        "   anchors.bottom: parent.bottom\n"
-        "   anchors.right: parent.right\n"
-        "   z: -1000\n"
-        "}\n";
-    m_sideStageComponent->setData(sideStageQml.toLatin1(), QUrl());
-}
-
-void ApplicationManager::createSideStage()
-{
-    if (!m_sideStageComponent)
-        createSideStageComponent();
-
-    // The assumptions I make here really should hold.
-    QQuickView *quickView =
-        qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);
-
-    QQuickItem *shell = quickView->rootObject();
-
-    m_sideStage = qobject_cast<QQuickItem *>(m_sideStageComponent->create());
-    m_sideStage->setParentItem(shell);
-    m_sideStage->setFlag(QQuickItem::ItemHasContents, false);
-}
-
 QStringList ApplicationManager::availableApplications()
 {
     QStringList appIds;
@@ -602,19 +485,6 @@
     return appIds;
 }
 
-int ApplicationManager::rightMargin() const
-{
-    return m_rightMargin;
-}
-
-void ApplicationManager::setRightMargin(int rightMargin)
-{
-    m_rightMargin = rightMargin;
-    Q_FOREACH(ApplicationInfo *app, m_availableApplications) {
-        generateQmlStrings(app);
-    }
-}
-
 bool ApplicationManager::isEmpty() const
 {
     return m_runningApplications.isEmpty();
 
=== modified file 'tests/mocks/Unity/Application/ApplicationManager.h'
--- tests/mocks/Unity/Application/ApplicationManager.h	2014-07-24 19:22:20 +0000
+++ tests/mocks/Unity/Application/ApplicationManager.h	2014-08-05 11:53:58 +0000
@@ -44,10 +44,6 @@
 
     Q_PROPERTY(bool fake READ fake CONSTANT)
 
-    // Only for testing
-    // This can be used to place some controls to right, like make tryPhoneStage for example
-    Q_PROPERTY(int rightMargin READ rightMargin WRITE setRightMargin)
-
  public:
     ApplicationManager(QObject *parent = NULL);
     virtual ~ApplicationManager();
@@ -108,8 +104,6 @@
 
     // Only for testing
     Q_INVOKABLE QStringList availableApplications();
-    int rightMargin() const;
-    void setRightMargin(int rightMargin);
 
     QModelIndex findIndex(ApplicationInfo* application);
 
@@ -126,19 +120,9 @@
     void showApplicationWindow(ApplicationInfo *application);
     void buildListOfAvailableApplications();
     void generateQmlStrings(ApplicationInfo *application);
-    void createMainStageComponent();
-    void createMainStage();
-    void createSideStageComponent();
-    void createSideStage();
     bool m_suspended;
     QList<ApplicationInfo*> m_runningApplications;
     QList<ApplicationInfo*> m_availableApplications;
-    QQmlComponent *m_mainStageComponent;
-    QQuickItem *m_mainStage;
-    QQmlComponent *m_sideStageComponent;
-    QQuickItem *m_sideStage;
-
-    int m_rightMargin;
 
     static ApplicationManager *the_application_manager;
 };
 
=== modified file 'tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp'
--- tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp	2014-04-02 15:33:33 +0000
+++ tests/mocks/Unity/Application/ApplicationScreenshotProvider.cpp	2014-08-05 11:53:58 +0000
@@ -64,7 +64,7 @@
         Q_FOREACH (QWindow *win, unity->allWindows()) {
             QQuickWindow *quickWin = qobject_cast<QQuickWindow*>(win);
             if (quickWin) {
-                image = image.scaledToWidth(quickWin->width() - m_appManager->rightMargin());
+                image = image.scaledToWidth(quickWin->width());
                 break;
             }
         }
 
=== modified file 'tests/mocks/Unity/CMakeLists.txt'
--- tests/mocks/Unity/CMakeLists.txt	2014-07-25 13:25:45 +0000
+++ tests/mocks/Unity/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -2,6 +2,7 @@
 add_subdirectory(Indicators)
 add_subdirectory(Launcher)
 add_subdirectory(Notifications)
+add_subdirectory(DashCommunicator)
 
 pkg_search_module(DEE dee-1.0 REQUIRED)
 pkg_search_module(GOBJECT gobject-2.0 REQUIRED)
 
=== added directory 'tests/mocks/Unity/DashCommunicator'
=== added file 'tests/mocks/Unity/DashCommunicator/CMakeLists.txt'
--- tests/mocks/Unity/DashCommunicator/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/CMakeLists.txt	2014-08-05 11:53:58 +0000
@@ -0,0 +1,18 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(QMLDASHCOMMUNICATORPLUGIN_SRC
+    plugin.cpp
+    dashcommunicatorservice.cpp
+    dashcommunicator.cpp
+    )
+
+add_library(MockDashCommunicator-qml MODULE
+    ${QMLDASHCOMMUNICATORPLUGIN_SRC}
+    )
+
+qt5_use_modules(MockDashCommunicator-qml DBus Qml)
+
+# export the qmldir and qmltypes files
+add_unity8_mock(Unity.DashCommunicator 0.1 Unity/DashCommunicator TARGETS MockDashCommunicator-qml)
 
=== added file 'tests/mocks/Unity/DashCommunicator/dashcommunicator.cpp'
--- tests/mocks/Unity/DashCommunicator/dashcommunicator.cpp	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/dashcommunicator.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2014 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 "dashcommunicator.h"
+
+#include <QObject>
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDebug>
+
+DashCommunicator::DashCommunicator(QObject *parent):
+    QObject(parent)
+{
+}
+
+DashCommunicator::~DashCommunicator()
+{
+}
+
+
+void DashCommunicator::setCurrentScope(const QString &scopeId, bool animate, bool reset)
+{
+    Q_EMIT setCurrentScopeCalled(scopeId, animate, reset);
+}
 
=== added file 'tests/mocks/Unity/DashCommunicator/dashcommunicator.h'
--- tests/mocks/Unity/DashCommunicator/dashcommunicator.h	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/dashcommunicator.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 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 DASHCOMMUNICATOR_H
+#define DASHCOMMUNICATOR_H
+
+#include <QObject>
+
+class DashCommunicator: public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.DashCommunicator")
+
+public:
+    DashCommunicator(QObject *parent = 0);
+    ~DashCommunicator();
+
+public Q_SLOTS:
+    void setCurrentScope(const QString &scopeId, bool animate, bool reset);
+
+Q_SIGNALS:
+    // This mock just emits calls back to the QML api for the plugin to verify calls
+    void setCurrentScopeCalled(const QString &scopeId, bool animate, bool reset);
+};
+
+#endif
 
=== added file 'tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.cpp'
--- tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.cpp	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2014 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 "dashcommunicatorservice.h"
+
+DashCommunicatorService::DashCommunicatorService(QObject *parent):
+    QObject(parent)
+{
+}
+
+
+DashCommunicatorService::~DashCommunicatorService()
+{
+
+}
+
+void DashCommunicatorService::mockSetCurrentScope(const QString &scopeId, bool animate, bool reset)
+{
+    Q_EMIT setCurrentScopeRequested(scopeId, animate, reset);
+}
 
=== added file 'tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.h'
--- tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.h	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/dashcommunicatorservice.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014 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 DASHCOMMUNICATORSERVICE_H
+#define DASHCOMMUNICATORSERVICE_H
+
+#include <QObject>
+
+class DashCommunicatorService: public QObject
+{
+    Q_OBJECT
+public:
+    DashCommunicatorService(QObject *parent = 0);
+    ~DashCommunicatorService();
+
+Q_SIGNALS:
+    void setCurrentScopeRequested(const QString &scopeId, bool animate, bool reset);
+
+public Q_SLOTS:
+    void mockSetCurrentScope(const QString &scopeId, bool animate, bool reset);
+};
+
+#endif // DBUSUNITYSESSIONSERVICE_H
 
=== added file 'tests/mocks/Unity/DashCommunicator/plugin.cpp'
--- tests/mocks/Unity/DashCommunicator/plugin.cpp	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/plugin.cpp	2014-08-05 11:53:58 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ */
+
+#include "plugin.h"
+#include "dashcommunicator.h"
+#include "dashcommunicatorservice.h"
+
+#include <QDBusConnection>
+#include <QtQml/qqml.h>
+
+void DashCommunicatorPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QStringLiteral("Unity.DashCommunicator"));
+    qmlRegisterType<DashCommunicatorService>(uri, 0, 1, "DashCommunicatorService");
+    qmlRegisterType<DashCommunicator>(uri, 0, 1, "DashCommunicator");
+}
 
=== added file 'tests/mocks/Unity/DashCommunicator/plugin.h'
--- tests/mocks/Unity/DashCommunicator/plugin.h	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/plugin.h	2014-08-05 11:53:58 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ */
+
+#ifndef DASHCOMMUNICATOR_PLUGIN_H
+#define DASHCOMMUNICATOR_PLUGIN_H
+
+#include <QtQml/QQmlEngine>
+#include <QtQml/QQmlExtensionPlugin>
+
+class DashCommunicatorPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif
 
=== added file 'tests/mocks/Unity/DashCommunicator/qmldir'
--- tests/mocks/Unity/DashCommunicator/qmldir	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/DashCommunicator/qmldir	2014-08-05 11:53:58 +0000
@@ -0,0 +1,3 @@
+module Unity.DashCommunicator
+plugin MockDashCommunicator-qml
+typeinfo DashCommunicator.qmltypes
 
=== modified file 'tests/qmltests/Dash/tst_Dash.qml'
--- tests/qmltests/Dash/tst_Dash.qml	2014-07-11 11:45:45 +0000
+++ tests/qmltests/Dash/tst_Dash.qml	2014-08-05 11:53:58 +0000
@@ -59,6 +59,7 @@
             verify(dashContentList != undefined);
             tryCompare(dashContentList, "count", 0);
             scopes.load();
+            tryCompare(dashContentList, "currentIndex", 0);
         }
 
         function get_scope_data() {
@@ -91,5 +92,23 @@
             verify(dashContentList != undefined);
             tryCompare(dashContentList, "currentIndex", data.visualIndex);
         }
+
+        function test_setCurrentScope() {
+            var dashContentList = findChild(dash, "dashContentList");
+            var startX = dash.width - units.gu(1);
+            var startY = dash.height / 2;
+            var stopX = units.gu(1)
+            var stopY = startY;
+            var retry = 0;
+            while (dashContentList.currentIndex != 2 && retry <= 5) {
+                mouseFlick(dash, startX, startY, stopX, stopY)
+                waitForRendering(dashContentList)
+                retry++;
+            }
+            compare(dashContentList.currentIndex, 2);
+            var dashCommunicatorService = findInvisibleChild(dash, "dashCommunicatorService");
+            dashCommunicatorService.mockSetCurrentScope("clickscope", true, true);
+            tryCompare(dashContentList, "currentIndex", 1)
+        }
     }
 }
 
=== modified file 'tests/qmltests/Stages/tst_PhoneStage.qml'
--- tests/qmltests/Stages/tst_PhoneStage.qml	2014-07-24 21:56:42 +0000
+++ tests/qmltests/Stages/tst_PhoneStage.qml	2014-08-05 11:53:58 +0000
@@ -231,9 +231,10 @@
         }
 
         function cleanup() {
-            while (ApplicationManager.count > 0) {
+            while (ApplicationManager.count > 1) {
                 var oldCount = ApplicationManager.count;
-                ApplicationManager.stopApplication(ApplicationManager.get(0).appId)
+                var closingIndex = ApplicationManager.focusedApplicationId == "unity8-dash" ? 1 : 0
+                ApplicationManager.stopApplication(ApplicationManager.get(closingIndex).appId)
                 tryCompare(ApplicationManager, "count", oldCount - 1)
             }
         }
 
=== modified file 'tests/qmltests/tst_Shell.qml'
--- tests/qmltests/tst_Shell.qml	2014-07-28 12:48:29 +0000
+++ tests/qmltests/tst_Shell.qml	2014-08-05 11:53:58 +0000
@@ -56,49 +56,20 @@
         signalName: "sessionStarted"
     }
 
+    SignalSpy {
+        id: dashCommunicatorSpy
+        signalName: "setCurrentScopeCalled"
+    }
+
     UT.UnityTestCase {
         name: "Shell"
         when: windowShown
 
         function initTestCase() {
-            var ok = false;
-            var attempts = 0;
-            var maxAttempts = 1000;
-
-            // Qt loads a qml scene asynchronously. So early on, some findChild() calls made in
-            // tests may fail because the desired child item wasn't loaded yet.
-            // Thus here we try to ensure the scene has been fully loaded before proceeding with the tests.
-            // As I couldn't find an API in QQuickView & friends to tell me that the scene is 100% loaded
-            // (all items instantiated, etc), I resort to checking the existence of some key items until
-            // repeatedly until they're all there.
-            do {
-                var dashContentList = findChild(shell, "dashContentList");
-                waitForRendering(dashContentList);
-                var homeLoader = findChild(dashContentList, "clickscope loader");
-                ok = homeLoader !== null
-                    && homeLoader.item !== undefined;
-
-                var greeter = findChild(shell, "greeter");
-                ok &= greeter !== null;
-
-                var launcherPanel = findChild(shell, "launcherPanel");
-                ok &= launcherPanel !== null;
-
-                attempts++;
-                if (!ok) {
-                    console.log("Attempt " + attempts + " failed. Waiting a bit before trying again.");
-                    // wait a bit before retrying
-                    wait(100);
-                } else {
-                    console.log("All seem fine after " + attempts + " attempts.");
-                }
-            } while (!ok && attempts <= maxAttempts);
-
-            verify(ok);
-
             swipeAwayGreeter();
 
             sessionSpy.target = findChild(shell, "greeter")
+            dashCommunicatorSpy.target = findInvisibleChild(shell, "dashCommunicator");
         }
 
         function cleanup() {
@@ -111,56 +82,16 @@
             // kill all (fake) running apps
             killApps(ApplicationManager);
 
-            var dashContent = findChild(shell, "dashContent");
-            dashContent.closePreview();
-
-            var dashHome = findChild(shell, "clickscope loader");
-            swipeUntilScopeViewIsReached(dashHome);
-
+            waitForUIToSettle();
             hideIndicators();
         }
 
-        function killApps(apps) {
-            if (!apps) return;
-            while (apps.count > 0) {
-                ApplicationManager.stopApplication(apps.get(0).appId);
+        function killApps() {
+            while (ApplicationManager.count > 1) {
+                var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0
+                ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);
             }
-            compare(ApplicationManager.count, 0)
-        }
-
-        /*
-           Test the effect of a right-edge drag on the dash in 3 situations:
-           1 - when no application has been launched yet
-           2 - when there's a minimized application
-           3 - after the last running application has been closed/stopped
-
-           The behavior of Dash on 3 should be the same as on 1.
-         */
-        function test_rightEdgeDrag() {
-            checkRightEdgeDragWithNoRunningApps();
-
-            dragLauncherIntoView();
-
-            // Launch an app from the launcher
-            tapOnAppIconInLauncher();
-            waitUntilApplicationWindowIsFullyVisible();
-
-            // Minimize the application we just launched
-            swipeFromLeftEdge(units.gu(27));
-
-            waitForUIToSettle();
-
-            checkRightEdgeDragWithMinimizedApp();
-
-            // Minimize that application once again
-            swipeFromLeftEdge(units.gu(27));
-
-            // Right edge behavior should now be the same as before that app,
-            // was launched.  Manually cleanup beforehand to get to initial
-            // state.
-            cleanup();
-            waitForUIToSettle();
-            checkRightEdgeDragWithNoRunningApps();
+            compare(ApplicationManager.count, 1)
         }
 
         function test_leftEdgeDrag_data() {
@@ -183,7 +114,7 @@
 
             swipeFromLeftEdge(data.swipeLength);
             if (data.appHides)
-                waitUntilApplicationWindowIsFullyHidden();
+                waitUntilDashIsFocused();
             else
                 waitUntilApplicationWindowIsFullyVisible();
         }
@@ -240,99 +171,17 @@
         }
 
         /*
-            Perform a right-edge drag when the Dash is being show and there are
-            no running/minimized apps to be restored.
-
-            The expected behavior is that an animation should be played to hint the
-            user that his right-edge drag gesture has been successfully recognized
-            but there is no application to be brought to foreground.
-         */
-        function checkRightEdgeDragWithNoRunningApps() {
-            var touchX = shell.width - (shell.edgeSize / 2);
-            var touchY = shell.height / 2;
-
-            var dash = findChild(shell, "dash");
-            // check that dash has normal scale and opacity
-            tryCompare(dash, "contentScale", 1.0);
-            tryCompare(dash, "opacity", 1.0);
-
-            touchFlick(shell, touchX, touchY, shell.width * 0.1, touchY,
-                       true /* beginTouch */, false /* endTouch */, units.gu(10), 50);
-
-            // check that Dash has been scaled down and had its opacity reduced
-            tryCompareFunction(function() { return dash.contentScale <= 0.9; }, true);
-            tryCompareFunction(function() { return dash.opacity <= 0.5; }, true);
-
-            touchRelease(shell, shell.width * 0.1, touchY);
-
-            // and now everything should have gone back to normal
-            tryCompare(dash, "contentScale", 1.0);
-            tryCompare(dash, "opacity", 1.0);
-        }
-
-        /*
-            Perform a right-edge drag when the Dash is being show and there is
-            a running/minimized app to be restored.
-
-            The expected behavior is that the dash should fade away and ultimately be
-            made invisible once the gesture is finished as the restored app will now
-            be on foreground.
-         */
-        function checkRightEdgeDragWithMinimizedApp() {
-            var touchX = shell.width - (shell.edgeSize / 2);
-            var touchY = shell.height / 2;
-
-            var dash = findChild(shell, "dash");
-            // check that dash has normal scale and opacity
-            tryCompare(dash, "contentScale", 1.0);
-            tryCompare(dash, "opacity", 1.0);
-
-            touchFlick(shell, touchX, touchY, shell.width * 0.1, touchY,
-                       true /* beginTouch */, false /* endTouch */, units.gu(10), 50);
-
-            // check that Dash has been scaled down and had its opacity reduced
-            tryCompareFunction(function() { return dash.contentScale <= 0.9; }, true);
-            tryCompareFunction(function() { return dash.opacity <= 0.5; }, true);
-
-            touchRelease(shell, shell.width * 0.1, touchY);
-
-            // dash should have gone away, now that the app is on foreground
-            tryCompare(dash, "visible", false);
-        }
-
-        /*
           Regression test for bug https://bugs.launchpad.net/touch-preview-images/+bug/1193419
 
-          When the user minimizes an application (left-edge swipe) he should always end up in the "Running Apps"
-          category of the "Applications" scope view.
+          When the user minimizes an application (left-edge swipe) he should always end up in the
+          "Applications" scope view.
 
           Steps:
-          - go to apps lens
-          - scroll to the bottom
-          - reveal launcher and launch an app
+          - reveal launcher and launch an app that covers the dash
           - perform long left edge swipe to go minimize the app and go back to the dash.
-
-          Expected Results
-          - apps lens shown
+          - verify the setCurrentScope() D-Bus call to the dash has been called for the correct scope id.
          */
         function test_minimizingAppTakesToDashApps() {
-            var dashApps = findChild(shell, "clickscope");
-            swipeUntilScopeViewIsReached(dashApps);
-
-            // swipe finger up until the running/recent apps section (which we assume
-            // it's the first one) is as far from view as possible.
-            // We also assume that DashApps is tall enough that it's scrollable
-            var appsCategoryListView = findChild(dashApps, "categoryListView");
-            while (!appsCategoryListView.atYEnd) {
-                swipeUpFromCenter();
-                tryCompare(appsCategoryListView, "moving", false);
-            }
-
-            // Switch away from the Applications scope.
-            swipeRightFromCenter();
-            waitUntilItemStopsMoving(dashApps);
-            verify(!itemIsOnScreen(dashApps));
-
             dragLauncherIntoView();
 
             // Launch an app from the launcher
@@ -340,19 +189,16 @@
 
             waitUntilApplicationWindowIsFullyVisible();
 
-            // Dragging launcher into view with a little bit of gap (units.gu(1)) should switch to Apps scope
-            dragLauncherIntoView();
-            verify(itemIsOnScreen(dashApps));
+            verify(ApplicationManager.focusedApplicationId !== "unity8-dash")
 
+            dashCommunicatorSpy.clear();
             // Minimize the application we just launched
             swipeFromLeftEdge(units.gu(27));
 
-            // Wait for the whole UI to settle down
-            waitUntilApplicationWindowIsFullyHidden();
-            waitUntilItemStopsMoving(dashApps);
-            tryCompare(appsCategoryListView, "moving", false);
+            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
 
-            verify(itemIsOnScreen(dashApps));
+            compare(dashCommunicatorSpy.count, 1);
+            compare(dashCommunicatorSpy.signalArguments[0][0], "clickscope");
         }
 
         function test_showInputMethod() {
@@ -409,9 +255,14 @@
 
         // Wait for the whole UI to settle down
         function waitForUIToSettle() {
-            waitUntilApplicationWindowIsFullyHidden();
-            var dashContentList = findChild(shell, "dashContentList");
-            tryCompare(dashContentList, "moving", false);
+            var launcher = findChild(shell, "launcherPanel")
+            tryCompareFunction(function() {return launcher.x === 0 || launcher.x === -launcher.width;}, true);
+            if (launcher.x === 0) {
+                mouseClick(shell, shell.width / 2, shell.height / 2)
+            }
+            tryCompare(launcher, "x", -launcher.width)
+
+            waitForRendering(shell)
         }
 
         function dragToCloseIndicatorsPanel() {
@@ -468,24 +319,13 @@
         }
 
         function waitUntilApplicationWindowIsFullyVisible() {
-            var underlay = findChild(shell, "underlay");
-            tryCompare(underlay, "visible", false);
-        }
-
-        function waitUntilApplicationWindowIsFullyHidden() {
-            var stages = findChild(shell, "stages");
-            tryCompare(stages, "fullyHidden", true);
-        }
-
-        function swipeUntilScopeViewIsReached(scopeView) {
-            while (!itemIsOnScreen(scopeView)) {
-                if (itemIsToLeftOfScreen(scopeView)) {
-                    swipeRightFromCenter();
-                } else {
-                    swipeLeftFromCenter();
-                }
-                waitUntilItemStopsMoving(scopeView);
-            }
+            var appDelegate = findChild(shell, "appDelegate0")
+            var surfaceContainer = findChild(appDelegate, "surfaceContainer");
+            tryCompareFunction(function() { return surfaceContainer.surface !== null; }, true);
+        }
+
+        function waitUntilDashIsFocused() {
+            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
         }
 
         function swipeFromLeftEdge(swipeLength) {
@@ -494,24 +334,6 @@
             touchFlick(shell, touchStartX, touchStartY, swipeLength, touchStartY);
         }
 
-        function swipeLeftFromCenter() {
-            var touchStartX = shell.width * 3 / 4;
-            var touchStartY = shell.height / 2;
-            touchFlick(shell, touchStartX, touchStartY, 0, touchStartY);
-        }
-
-        function swipeRightFromCenter() {
-            var touchStartX = shell.width * 3 / 4;
-            var touchStartY = shell.height / 2;
-            touchFlick(shell, touchStartX, touchStartY, shell.width, touchStartY);
-        }
-
-        function swipeUpFromCenter() {
-            var touchStartX = shell.width / 2;
-            var touchStartY = shell.height / 2;
-            touchFlick(shell, touchStartX, touchStartY, touchStartX, 0);
-        }
-
         function itemIsOnScreen(item) {
             var itemRectInShell = item.mapToItem(shell, 0, 0, item.width, item.height);
 
@@ -521,64 +343,6 @@
                 && itemRectInShell.y + itemRectInShell.height <= shell.height;
         }
 
-        function itemIsToLeftOfScreen(item) {
-            var itemRectInShell = item.mapToItem(shell, 0, 0, item.width, item.height);
-            return itemRectInShell.x < 0;
-        }
-
-        function waitUntilItemStopsMoving(item) {
-            var itemRectInShell = item.mapToItem(shell, 0, 0, item.width, item.height);
-            var previousX = itemRectInShell.x;
-            var previousY = itemRectInShell.y;
-            var isStill = false;
-
-            do {
-                wait(100);
-                itemRectInShell = item.mapToItem(shell, 0, 0, item.width, item.height);
-                if (itemRectInShell.x == previousX && itemRectInShell.y == previousY) {
-                    isStill = true;
-                } else {
-                    previousX = itemRectInShell.x;
-                    previousY = itemRectInShell.y;
-                }
-            } while (!isStill);
-        }
-
-        function test_DashShown_data() {
-            return [
-                {tag: "in focus", greeter: false, app: false, launcher: false, indicators: false, expectedShown: true},
-                {tag: "under greeter", greeter: true, app: false, launcher: false, indicators: false, expectedShown: false},
-                {tag: "under app", greeter: false, app: true, launcher: false, indicators: false, expectedShown: false},
-                {tag: "under launcher", greeter: false, app: false, launcher: true, indicators: false, expectedShown: true},
-                {tag: "under indicators", greeter: false, app: false, launcher: false, indicators: true, expectedShown: false},
-            ]
-        }
-
-        function test_DashShown(data) {
-            if (data.greeter) {
-                // Swipe the greeter in
-                var greeter = findChild(shell, "greeter");
-                Powerd.displayPowerStateChange(Powerd.Off, 0);
-                tryCompare(greeter, "showProgress", 1);
-            }
-
-            if (data.app) {
-                dragLauncherIntoView();
-                tapOnAppIconInLauncher();
-            }
-
-            if (data.launcher) {
-                dragLauncherIntoView();
-            }
-
-            if (data.indicators) {
-                showIndicators();
-            }
-
-            var dash = findChild(shell, "dash");
-            tryCompare(dash, "shown", data.expectedShown);
-        }
-
         function test_focusRequestedHidesGreeter() {
             var greeter = findChild(shell, "greeter");
 
@@ -587,10 +351,9 @@
             tryCompareFunction(function() { return app.surface != null }, true);
 
             // Minimize the application we just launched
-            swipeFromLeftEdge(units.gu(27));
+            swipeFromLeftEdge(units.gu(26) + 1);
 
-            // Wait for the whole UI to settle down
-            waitUntilApplicationWindowIsFullyHidden();
+            waitUntilDashIsFocused();
 
             greeter.show();
             tryCompare(greeter, "showProgress", 1);
@@ -606,8 +369,9 @@
 
             showIndicators();
 
+            var oldCount = ApplicationManager.count;
             ApplicationManager.startApplication("camera-app");
-            tryCompare(ApplicationManager, "count", 1);
+            tryCompare(ApplicationManager, "count", oldCount + 1);
 
             tryCompare(indicators, "fullyClosed", true);
         }
@@ -616,6 +380,7 @@
         function test_showGreeterDBusCall() {
             var greeter = findChild(shell, "greeter")
             tryCompare(greeter, "showProgress", 0)
+            waitForRendering(greeter);
             LightDM.Greeter.showGreeter()
             tryCompare(greeter, "showProgress", 1)
         }
@@ -624,6 +389,7 @@
             sessionSpy.clear()
 
             var greeter = findChild(shell, "greeter")
+            waitForRendering(greeter)
             greeter.show()
             tryCompare(greeter, "showProgress", 1)
 
@@ -644,5 +410,26 @@
             ApplicationManager.requestFocusApplication("gallery-app");
             tryCompare(panel, "fullscreenMode", false);
         }
+
+        function test_leftEdgeDragFullscreen() {
+            var panel = findChild(shell, "panel");
+            tryCompare(panel, "fullscreenMode", false)
+
+            ApplicationManager.startApplication("camera-app");
+            tryCompare(panel, "fullscreenMode", true)
+
+            var touchStartX = 2;
+            var touchStartY = shell.height / 2;
+
+            touchFlick(shell, touchStartX, touchStartY, units.gu(2), touchStartY, true, false);
+
+            compare(panel.fullscreenMode, true);
+
+            touchFlick(shell, units.gu(2), touchStartY, units.gu(10), touchStartY, false, false);
+
+            tryCompare(panel, "fullscreenMode", false);
+
+            touchRelease(shell);
+        }
     }
 }
 
=== modified file 'tests/qmltests/tst_ShellWithPin.qml'
--- tests/qmltests/tst_ShellWithPin.qml	2014-07-15 18:26:25 +0000
+++ tests/qmltests/tst_ShellWithPin.qml	2014-08-05 11:53:58 +0000
@@ -58,40 +58,6 @@
         when: windowShown
 
         function initTestCase() {
-            var ok = false;
-            var attempts = 0;
-            var maxAttempts = 1000;
-
-            // Qt loads a qml scene asynchronously. So early on, some findChild() calls made in
-            // tests may fail because the desired child item wasn't loaded yet.
-            // Thus here we try to ensure the scene has been fully loaded before proceeding with the tests.
-            // As I couldn't find an API in QQuickView & friends to tell me that the scene is 100% loaded
-            // (all items instantiated, etc), I resort to checking the existence of some key items until
-            // repeatedly until they're all there.
-            do {
-                var dashContentList = findChild(shell, "dashContentList");
-                waitForRendering(dashContentList);
-                var homeLoader = findChild(dashContentList, "clickscope loader");
-                ok = homeLoader !== null
-                    && homeLoader.item !== undefined;
-
-                var greeter = findChild(shell, "greeter");
-                ok &= greeter !== null;
-
-                var launcherPanel = findChild(shell, "launcherPanel");
-                ok &= launcherPanel !== null;
-
-                attempts++;
-                if (!ok) {
-                    console.log("Attempt " + attempts + " failed. Waiting a bit before trying again.");
-                    // wait a bit before retrying
-                    wait(100);
-                } else {
-                    console.log("All seem fine after " + attempts + " attempts.");
-                }
-            } while (!ok && attempts <= maxAttempts);
-
-            verify(ok);
 
             sessionSpy.target = findChild(shell, "greeter")
         }
@@ -110,10 +76,11 @@
         }
 
         function killApps() {
-            while (ApplicationManager.count > 0) {
-                ApplicationManager.stopApplication(ApplicationManager.get(0).appId)
+            while (ApplicationManager.count > 1) {
+                var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0
+                ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);
             }
-            compare(ApplicationManager.count, 0)
+            compare(ApplicationManager.count, 1)
         }
 
         function swipeAwayGreeter() {